prosesmasher-app-core 0.1.7

Internal core checks crate for the prosesmasher workspace. Published to support the workspace dependency graph.
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
145
146
147
148
149
150
151
152

use crate::check::Check;
use low_expectations::ExpectationSuite;
use prosesmasher_domain_types::{
    Block, CheckConfig, Document, DocumentMetadata, Locale, Paragraph, Section, Sentence,
    Word,
};

/// Build a doc with a specific word count and sentence count.
fn make_sentence_doc(total_words: usize, total_sentences: usize) -> Document {
    let words: Vec<Word> = (0..total_words)
        .map(|i| Word {
            text: format!("w{i}"),
            syllable_count: 1,
        })
        .collect();
    let text = words
        .iter()
        .map(|w| w.text.as_str())
        .collect::<Vec<_>>()
        .join(" ");

    Document {
        locale: Locale::En,
        sections: vec![Section {
            heading: None,
            blocks: vec![Block::Paragraph(Paragraph {
                sentences: vec![Sentence { text, words }],
                has_bold: false,
                has_italic: false,
                links: vec![],
            })],
        }],
        metadata: DocumentMetadata {
            total_words,
            total_sentences,
            ..Default::default()
        },
    }
}

fn config_with_avg_max(max: usize) -> CheckConfig {
    let mut config = CheckConfig {
        locale: Locale::En,
        ..CheckConfig::default()
    };
    config.quality.readability.avg_sentence_length_max = Some(max);
    config
}

#[test]
fn average_within_limit_passes() {
    // 100 words / 5 sentences = 20 avg, max 25 → pass
    let doc = make_sentence_doc(100, 5);
    let config = config_with_avg_max(25);
    let mut suite = ExpectationSuite::new("test");
    super::AvgSentenceLengthCheck.run(&doc, &config, &mut suite);
    let result = suite.into_suite_result();
    assert_eq!(result.statistics.successful_expectations, 1, "avg 20 <= max 25");
    assert_eq!(result.statistics.unsuccessful_expectations, 0);
}

#[test]
fn average_over_limit_fails() {
    // 100 words / 3 sentences = 33 avg, max 25 → fail
    let doc = make_sentence_doc(100, 3);
    let config = config_with_avg_max(25);
    let mut suite = ExpectationSuite::new("test");
    super::AvgSentenceLengthCheck.run(&doc, &config, &mut suite);
    let result = suite.into_suite_result();
    assert_eq!(
        result.statistics.unsuccessful_expectations, 1,
        "avg 33 > max 25 should fail"
    );
    let vr = result.results.get("avg-sentence-length");
    assert!(vr.is_some(), "avg-sentence-length result should exist");
    if let Some(vr) = vr {
        let evidence = vr.result.partial_unexpected_list.as_ref();
        assert!(evidence.is_some(), "evidence should be present");
        assert_eq!(evidence.and_then(|e| e.first())
            .and_then(|item| item.get("average_words_per_sentence"))
            .and_then(serde_json::Value::as_i64), Some(33), "average words per sentence");
    }
}

#[test]
fn zero_sentences_skips() {
    let doc = make_sentence_doc(50, 0);
    let config = config_with_avg_max(25);
    let mut suite = ExpectationSuite::new("test");
    super::AvgSentenceLengthCheck.run(&doc, &config, &mut suite);
    let result = suite.into_suite_result();
    assert_eq!(result.statistics.evaluated_expectations, 0);
}

#[test]
fn no_threshold_skips() {
    let doc = make_sentence_doc(100, 5);
    let config = CheckConfig::default();
    let mut suite = ExpectationSuite::new("test");
    super::AvgSentenceLengthCheck.run(&doc, &config, &mut suite);
    let result = suite.into_suite_result();
    assert_eq!(result.statistics.successful_expectations, 1);
}

#[test]
fn exact_boundary_passes() {
    // 75 words / 3 sentences = 25 avg, max 25 → pass (at_most is inclusive)
    let doc = make_sentence_doc(75, 3);
    let config = config_with_avg_max(25);
    let mut suite = ExpectationSuite::new("test");
    super::AvgSentenceLengthCheck.run(&doc, &config, &mut suite);
    let result = suite.into_suite_result();
    assert_eq!(result.statistics.successful_expectations, 1, "exact boundary should pass");
}

#[test]
fn check_id_and_label() {
    let check = super::AvgSentenceLengthCheck;
    assert_eq!(check.id(), "avg-sentence-length");
    assert_eq!(check.label(), "Average Sentence Length");
    assert!(check.supported_locales().is_none());
}

#[test]
fn truncation_at_boundary_passes() {
    // 101 words / 4 sentences = 25 (integer division truncates 25.25 → 25)
    // With max=25, should pass because truncated value equals max.
    let doc = make_sentence_doc(101, 4);
    let config = config_with_avg_max(25);
    let mut suite = ExpectationSuite::new("test");
    super::AvgSentenceLengthCheck.run(&doc, &config, &mut suite);
    let result = suite.into_suite_result();
    assert_eq!(
        result.statistics.successful_expectations, 1,
        "101/4 = 25 (truncated from 25.25) should pass with max=25"
    );
    assert_eq!(result.statistics.unsuccessful_expectations, 0);
}

#[test]
fn truncation_above_boundary_fails() {
    // 104 words / 4 sentences = 26 (exact), max=25 → fail
    let doc = make_sentence_doc(104, 4);
    let config = config_with_avg_max(25);
    let mut suite = ExpectationSuite::new("test");
    super::AvgSentenceLengthCheck.run(&doc, &config, &mut suite);
    let result = suite.into_suite_result();
    assert_eq!(
        result.statistics.unsuccessful_expectations, 1,
        "104/4 = 26 should fail with max=25"
    );
}