testing-conventions 0.0.101

Enforce testing conventions in libraries (Python, TypeScript, and Rust).
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

mod common;

use common::{expect_tested, ts_adapter, Staged};
use testing_conventions::mutation::measure_typescript;

#[test]
fn killed_reports_no_survivors() {
    let package = Staged::new("killed");
    let (_, survivors) = expect_tested(
        measure_typescript(
            &package.path().join("src"),
            &[],
            &std::collections::BTreeMap::new(),
            None,
            &ts_adapter(),
        )
        .expect("stryker runs"),
    );
    assert!(
        survivors.is_empty(),
        "every mutant should be caught; got {survivors:?}"
    );
}

#[test]
fn survivors_are_reported() {
    let package = Staged::new("survivors");
    let (_, survivors) = expect_tested(
        measure_typescript(
            &package.path().join("src"),
            &[],
            &std::collections::BTreeMap::new(),
            None,
            &ts_adapter(),
        )
        .expect("stryker runs"),
    );
    assert!(
        !survivors.is_empty(),
        "the assertion-light suite should leave survivors under the scan path"
    );
    assert!(
        survivors.iter().all(|m| m.file == "index.ts"),
        "survivors are reported relative to the scan path; got {survivors:?}"
    );
}

#[test]
fn a_loose_tree_with_no_manifest_reports_root_relative_survivors() {
    let project = Staged::loose("loose_survivors");
    let (_, survivors) = expect_tested(
        measure_typescript(
            project.path(),
            &[],
            &std::collections::BTreeMap::new(),
            None,
            &ts_adapter(),
        )
        .expect("stryker runs"),
    );
    assert!(
        !survivors.is_empty(),
        "the assertion-light suite should leave survivors"
    );
    assert!(
        survivors.iter().all(|m| m.file == "index.ts"),
        "every survivor is in index.ts; got {survivors:?}"
    );
}

#[test]
fn a_loose_tree_with_no_manifest_passes_when_all_mutants_are_killed() {
    let project = Staged::loose("loose_killed");
    let (_, survivors) = expect_tested(
        measure_typescript(
            project.path(),
            &[],
            &std::collections::BTreeMap::new(),
            None,
            &ts_adapter(),
        )
        .expect("stryker runs"),
    );
    assert!(
        survivors.is_empty(),
        "every mutant should be caught; got {survivors:?}"
    );
}

#[test]
fn a_mutation_exemption_drops_the_survivors() {
    let package = Staged::new("survivors");
    let exempt = vec!["index.ts".to_string()];
    let (_, survivors) = expect_tested(
        measure_typescript(
            &package.path().join("src"),
            &exempt,
            &std::collections::BTreeMap::new(),
            None,
            &ts_adapter(),
        )
        .expect("stryker runs"),
    );
    assert!(
        survivors.is_empty(),
        "the exemption should drop every survivor; got {survivors:?}"
    );
}