rtest 0.2.2

integration test building framework
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

use super::ExecutionStrategy;
use crate::{
    context::ResourceId,
    runner::{result_map::ExecutionResultMap, test_repo::TestRepo, Runner},
};

#[derive(Default)]
pub struct SimpleStrategy {}

impl ExecutionStrategy for SimpleStrategy {
    fn run(&self, repo: &mut TestRepo, _: &[ResourceId]) -> ExecutionResultMap {
        let mut result_map = ExecutionResultMap::default();
        for _ in 0..50 {
            let (mut ok, mut missing) = (true, Vec::new());
            while ok {
                (ok, missing) = Self::run_all_possible(repo, &mut result_map)
            }
            missing.dedup();
            for m in missing {
                if Self::recreate_resource(repo, &mut result_map, m) {
                    break;
                }
            }
        }
        result_map
    }
}

impl SimpleStrategy {
    /// will run all testcases that work without any modifications
    /// returns if some progress was done
    fn run_all_possible(repo: &mut TestRepo, results: &mut ExecutionResultMap) -> (bool, Vec<ResourceId>) {
        let mut at_least_once = false;
        let mut at_least_one_finished = false;
        let mut missing = Vec::new();
        let params = repo.runner_params();
        for tc in repo.cases_mut().values_mut() {
            if results.did_execute(tc.test_id()) {
                at_least_one_finished = true;
                continue;
            }
            match Runner::exec_testcase(tc, &params) {
                Ok(res) => {
                    results.record(tc.test_id(), res);
                    at_least_once = true;
                },
                Err(m) => missing.push(m),
            }
        }
        (at_least_once && at_least_one_finished, missing)
    }

    /// try to recreate a resource
    fn recreate_resource(repo: &mut TestRepo, results: &mut ExecutionResultMap, wanted: ResourceId) -> bool {
        let params = repo.runner_params();
        for tc in repo.cases_mut().values_mut() {
            if results.did_execute(tc.test_id()) && tc.info.output_resources.contains(&wanted) {
                if let Ok(res) = Runner::exec_testcase(tc, &params) {
                    results.record(tc.test_id(), res);
                    return true;
                }
            }
        }
        false
    }
}