apirquest_core 0.6.3

ApiRquest is a library for testing Api Rest. Written in Rust, it allows you to use the Rhai scripting language to increase test flexibility. It uses Gherkin syntax for test scenarios.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! # Runner
//! ApiRquest lets you execute http requests from Gherkin files
//!
//!
//! # Examples
//! ```
//! use apirquest_core::Runner;
//!
//! let mut runner = Runner::new("../features/test_api_restful_api.feature".to_string());
//! let result = runner.run();
//! ```
//!

mod script;
mod scenario;

use log::debug;
use crate::scenario::scenario::{Scenario, ScenarioError};
use crate::script::Script;

#[allow(missing_docs)]
pub struct Runner<'a> {
    pub filename: String,
    script: Option<Script<'a>>,
    pub tags: Vec<String>,
}

impl<'a> Runner<'_> {

    /// Create the runner
    ///
    /// ```
    /// use apirquest_core::Runner;
    /// let mut runner = Runner::new("../features/api_restful_api.feature".to_string());
    /// ```
    pub fn new(filename: String) -> Runner<'static> {
        Runner {
            filename: filename.clone(),
            script: Some(Script::new(filename.to_string())),
            tags: Vec::new() ,
        }
    }

    /// Filter the scenarios to be run.
    ///
    /// # Exemples
    /// ```
    /// // ELaunching the scenario "ScenarioExample"
    /// //
    /// use apirquest_core::Runner;
    /// let mut runner = Runner::new("../features/api_restful_api.feature".to_string());
    /// runner.tags(vec!["@ScenarioExample"]);
    /// ```
    pub fn tags(&mut self, p0: Vec<&str>)  {
        p0.iter().for_each(|x| self.tags.push(x.to_string()));
    }

    /// Execute the script
    ///
    pub fn run(&mut self) ->  Result<(), ScenarioError>  {
        debug!("Loading script: {}", self.filename);
        self.script.as_mut().unwrap().load_script();

        let background= match &self.script.as_mut().unwrap().background {
            Some(background) => {background.clone()},
            None => Scenario::new(),
        };
        for sc in self.script.as_mut().unwrap().scenarios.iter_mut() {
            if self.tags.is_empty() || self.tags.contains(&sc.tag) {
                debug!("Tag: {}", sc.tag);
                match sc.execute(&background) {
                    Ok(_) => {
                        debug!("End of scenario: {}", sc.name)
                    }
                    Err(scenario_error) => {
                        return Err(scenario_error);
                    }
                }
            } else {
                 debug!("Skipping tag: {}", sc.tag);
            }
        }
        return Ok(());
    }
}

#[cfg(test)]
mod tests {
    use log::error;
    use super::*;

    #[test]
    fn runner_run() {
        debug!("runner: apiRquest");
        debug!("Load script file: ../features/test_api_restful_api.feature");
        let mut runner = Runner::new("../features/test_api_restful_api.feature".to_string());
        runner.tags(vec!["@ScenarioExample"]);
        let r = runner.run();

        r.unwrap_or_else(|e| error!("Error: {}", e))
    }
}