parlov-analysis 0.6.0

Analysis engine trait and signal detection for parlov.
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
153
154
155
156
157
158
159

//! Unit tests for signal family definitions and family-adjusted scoring.

use super::*;

#[test]
fn first_signal_gets_full_points() {
    let contributions = vec![SignalContribution {
        family: SignalFamily::Range,
        confidence: 12.0,
        impact: 8,
        description: "test".into(),
    }];
    let result = apply_family_adjustment(&contributions);
    assert!((result.confidence_total - 12.0).abs() < 0.01);
    assert_eq!(result.impact_total, 8);
}

#[test]
fn second_signal_in_family_gets_half() {
    let contributions = vec![
        SignalContribution {
            family: SignalFamily::Range,
            confidence: 12.0,
            impact: 8,
            description: "first".into(),
        },
        SignalContribution {
            family: SignalFamily::Range,
            confidence: 10.0,
            impact: 5,
            description: "second".into(),
        },
    ];
    let result = apply_family_adjustment(&contributions);
    assert!((result.confidence_total - 17.0).abs() < 0.01);
    assert_eq!(result.impact_total, 13);
}

#[test]
fn third_signal_in_family_gets_zero_confidence() {
    let contributions = vec![
        SignalContribution {
            family: SignalFamily::Range,
            confidence: 12.0,
            impact: 8,
            description: "first".into(),
        },
        SignalContribution {
            family: SignalFamily::Range,
            confidence: 10.0,
            impact: 5,
            description: "second".into(),
        },
        SignalContribution {
            family: SignalFamily::Range,
            confidence: 8.0,
            impact: 15,
            description: "third".into(),
        },
    ];
    let result = apply_family_adjustment(&contributions);
    assert!((result.confidence_total - 17.0).abs() < 0.01);
    // Impact still counts: 8 + 5 + 15 = 28
    assert_eq!(result.impact_total, 28);
}

#[test]
fn different_families_count_independently() {
    let contributions = vec![
        SignalContribution {
            family: SignalFamily::Range,
            confidence: 12.0,
            impact: 8,
            description: "range".into(),
        },
        SignalContribution {
            family: SignalFamily::Auth,
            confidence: 8.0,
            impact: 8,
            description: "auth".into(),
        },
    ];
    let result = apply_family_adjustment(&contributions);
    assert!((result.confidence_total - 20.0).abs() < 0.01);
    assert_eq!(result.family_count, 2);
}

#[test]
fn corroboration_bonus_values() {
    assert_eq!(corroboration_bonus(0), 0);
    assert_eq!(corroboration_bonus(1), 0);
    assert_eq!(corroboration_bonus(2), 3);
    assert_eq!(corroboration_bonus(3), 6);
    assert_eq!(corroboration_bonus(5), 8);
}

#[test]
fn header_family_mappings() {
    assert_eq!(header_family("content-range"), SignalFamily::Range);
    assert_eq!(header_family("etag"), SignalFamily::CacheValidator);
    assert_eq!(header_family("www-authenticate"), SignalFamily::Auth);
    assert_eq!(header_family("x-custom"), SignalFamily::General);
}

#[test]
fn redirect_family_is_distinct() {
    assert_ne!(SignalFamily::Redirect, SignalFamily::Range);
    assert_ne!(SignalFamily::Redirect, SignalFamily::CacheValidator);
    assert_ne!(SignalFamily::Redirect, SignalFamily::Auth);
    assert_ne!(SignalFamily::Redirect, SignalFamily::Precondition);
    assert_ne!(SignalFamily::Redirect, SignalFamily::Negotiation);
    assert_ne!(SignalFamily::Redirect, SignalFamily::ErrorBody);
    assert_ne!(SignalFamily::Redirect, SignalFamily::General);
}

#[test]
fn status_code_family_redirect_301() {
    assert_eq!(status_code_family(301), SignalFamily::Redirect);
}

#[test]
fn status_code_family_redirect_302() {
    assert_eq!(status_code_family(302), SignalFamily::Redirect);
}

#[test]
fn status_code_family_redirect_303() {
    assert_eq!(status_code_family(303), SignalFamily::Redirect);
}

#[test]
fn status_code_family_redirect_307() {
    assert_eq!(status_code_family(307), SignalFamily::Redirect);
}

#[test]
fn status_code_family_redirect_308() {
    assert_eq!(status_code_family(308), SignalFamily::Redirect);
}

#[test]
fn status_code_family_redirect_300() {
    assert_eq!(status_code_family(300), SignalFamily::Redirect);
}

#[test]
fn header_family_location() {
    assert_eq!(header_family("location"), SignalFamily::Redirect);
}

#[test]
fn error_body_family_is_distinct() {
    assert_ne!(SignalFamily::ErrorBody, SignalFamily::Range);
    assert_ne!(SignalFamily::ErrorBody, SignalFamily::CacheValidator);
    assert_ne!(SignalFamily::ErrorBody, SignalFamily::Auth);
    assert_ne!(SignalFamily::ErrorBody, SignalFamily::Precondition);
    assert_ne!(SignalFamily::ErrorBody, SignalFamily::Negotiation);
    assert_ne!(SignalFamily::ErrorBody, SignalFamily::General);
}