fn test_with_data()

in guard/src/commands/test.rs [118:186]

• 67 lines of code
• 7 McCabe index (conditional complexity)

fn test_with_data(test_data_files: &[PathBuf], rules: &RulesFile<'_>, verbose: bool) -> Result<i32> {
    let mut exit_code = 0;
    let mut test_counter = 1;
    for specs in iterate_over(test_data_files, |data, path| {
        match serde_yaml::from_str::<Vec<TestSpec>>(&data) {
            Ok(spec) => {
                Ok(spec)
            },
            Err(_) => match serde_json::from_str::<Vec<TestSpec>>(&data) {
                Ok(specs) => Ok(specs),
                Err(e) => Err(Error::new (ErrorKind::ParseError(
                    format!("Unable to process data in file {}, Error {},", path.display(), e))))
            }
        }
    }) {
        match specs {
            Err(e) => println!("Error processing {}", e),
            Ok(specs) => {
                for each in specs {
                    let root = PathAwareValue::try_from(each.input)?;
                    let context = RootScope::new(rules, &root);
                    let stacker = StackTracker::new(&context);
                    rules.evaluate(&root, &stacker)?;
                    let expectations = each.expectations.rules;
                    let stack = stacker.stack();

                    println!("Test Case #{}", test_counter);
                    if !each.name.is_none() {
                        println!("Name: {}", each.name.unwrap());
                    }

                    let mut by_result = HashMap::new();
                    for each in &stack[0].children {
                        match expectations.get(&each.context) {
                            Some(value) => {
                                match Status::try_from(value.as_str()) {
                                    Err(e) => println!("Incorrect STATUS provided {}", e),
                                    Ok(status) => {
                                        let got = each.status.unwrap();
                                        if status != got {
                                            by_result.entry(String::from("FAILED")).or_insert(indexmap::IndexSet::new())
                                                .insert(String::from(format!("{}: Expected = {}, Evaluated = {}",
                                                                             each.context, status, got)));
                                            exit_code = 7;
                                        }
                                        else {
                                            by_result.entry(String::from("PASS")).or_insert(indexmap::IndexSet::new())
                                                .insert(String::from(format!("{}: Expected = {}, Evaluated = {}",
                                                                             each.context, status, got)));
                                        }
                                        if verbose {
                                            super::validate::print_context(each, 1);
                                        }
                                    }
                                }
                            },
                            None => {
                                println!("  No Test expectation was set for Rule {}", each.context)
                            }
                        }
                    }
                    print_test_case_report(&by_result);
                    test_counter += 1;
                }
            }
        }
    }
    Ok(exit_code)
}