specimen 0.1.0

A data-driven testing library as well as a yaml data format.
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use regex::Regex;
use specimen::Writable;
use std::collections::HashMap;

fn indent(text: &str, spaces: usize) -> String {
    let indent = " ".repeat(spaces);
    return text
        .lines()
        .map(|line| format!("{}{}", indent, line))
        .collect::<Vec<String>>()
        .join("\n");
}

fn to_hashmap(data: &yaml_rust::Yaml) -> specimen::Dict {
    return match data {
        yaml_rust::Yaml::Hash(key_value_vec) => {
            let mut hashmap = HashMap::new();
            for (yaml_key, yaml_value) in key_value_vec {
                let key = match yaml_key {
                    yaml_rust::Yaml::String(key) => key,
                    _ => panic!("Expected the key to be a YAML string"),
                };
                let value = match yaml_value {
                    yaml_rust::Yaml::String(value) => value,
                    _ => panic!("Expected the value to be a YAML string"),
                };
                hashmap.insert(key.clone().into(), value.clone().into());
            }
            hashmap
        }
        _ => panic!("Expected a YAML mapping"),
    };
}

fn call_logger(tile: &specimen::Dict) -> Result<(), Box<str>> {
    let call_string = &tile["calls"];
    let call_yaml = &yaml_rust::YamlLoader::load_from_str(call_string).unwrap()[0];
    let call_vec = match call_yaml {
        yaml_rust::Yaml::Array(vec) => vec,
        _ => panic!("Expected a YAML array"),
    };
    let mut index = 0;
    let mut error = "".to_string();
    let result = specimen::ioless_run(
        &mut |spec_tile: &specimen::Dict| -> Result<(), Box<str>> {
            let mut expected_tile = to_hashmap(&call_vec[index]);
            expected_tile.insert("filepath".into(), spec_tile["filepath"].clone());

            if error.len() == 0 && expected_tile != *spec_tile {
                error = format!(
                    "[Call {}]\nExpected: {:?}\nActual__: {:?}",
                    index, expected_tile, spec_tile,
                );
            }
            index += 1;
            Ok(())
        },
        &[specimen::file::File {
            path: tile["filepath"].clone(),
            content: tile["spec"].clone(),
        }],
        &mut Writable::Vec(Vec::new()),
    );

    if let Err(err) = result {
        return Err(err.to_string().into());
    }

    if index != call_vec.len() {
        return Err(format!("Expected {} calls, but got {}", call_vec.len(), index).into());
    }

    return if error != "" {
        return Err(error.into());
    } else {
        Ok(())
    };
}

fn report(tile: &specimen::Dict) -> Result<(), Box<str>> {
    let behavior_yaml = &yaml_rust::YamlLoader::load_from_str(&tile["behavior"]).unwrap()[0];
    let behavior = to_hashmap(behavior_yaml);
    let mut writable_buffer = Writable::Vec(Vec::new());

    let result = specimen::ioless_run(
        &mut |spec_tile: &specimen::Dict| -> Result<(), Box<str>> {
            let outcome = &behavior[&spec_tile["letter"]];
            return match &**outcome {
                "pass" => Ok(()),
                "fail" => Err("failure".into()),
                "abort" => Err("ABORTaborted".into()),
                other => Err(format!("ABORT: unknown outcome: {}", other).into()),
            };
        },
        &[specimen::file::File {
            path: tile["filepath"].clone(),
            content: tile["spec"].clone(),
        }],
        &mut writable_buffer,
    );

    if let Err(error) = result {
        return Err(error.to_string().into());
    }

    let buffer = match writable_buffer {
        Writable::Vec(vec) => vec,
        _ => panic!("Expected a Vec"),
    };
    let output = String::from_utf8(buffer).unwrap();
    let report_regex = Regex::new(&tile["report"]).unwrap();
    if !report_regex.is_match(&output) {
        Err(format!(
            "Expected:\n{}\nActual:\n{}",
            indent(&*tile["report"], 4),
            indent(&*output, 4)
        )
        .into())
    } else {
        Ok(())
    }
}

#[test]
fn test_spec() {
    let test_passed = specimen::run(
        &mut |tile: &specimen::Dict| -> Result<(), Box<str>> {
            return match tile.get("box") {
                Some(box_name) if **box_name == *"call-logger" => call_logger(tile),
                Some(box_name) if **box_name == *"report" => report(tile),
                Some(box_name) => Err(format!("Unknown box: {}", box_name).into()),
                None => Err("No box specified".into()),
            };
        },
        &[
            specimen::file::File::read_local_file("../spec/about.yaml"),
            specimen::file::File::read_local_file("../spec/flag.yaml"),
            specimen::file::File::read_local_file("../spec/matrix.yaml"),
            specimen::file::File::read_local_file("../spec/report.yaml"),
        ],
    );

    assert!(test_passed);
}