icookforms 0.1.0

The World's Reference Cookie Audit Software - Complete Security & Compliance Analysis
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

//! Cookie security and compliance analyzer

pub mod compliance;
pub mod security;
pub mod tracking;

use crate::types::config::AnalysisConfig;
use crate::types::{AnalysisResult, Cookie};

/// Main cookie analyzer
pub struct Analyzer {
    config: AnalysisConfig,
}

impl Analyzer {
    /// Create a new analyzer with default configuration
    #[must_use]
    pub fn new() -> Self {
        Self {
            config: AnalysisConfig::default(),
        }
    }

    /// Create an analyzer with custom configuration
    #[must_use]
    pub fn with_config(config: AnalysisConfig) -> Self {
        Self { config }
    }

    /// Analyze a single cookie
    #[must_use]
    pub fn analyze(&self, cookie: &Cookie) -> AnalysisResult {
        let scan_id = uuid::Uuid::new_v4().to_string();
        let mut result = AnalysisResult::new(scan_id);

        // Security analysis - CORRECTED: Pass slice instead of single cookie
        if self.config.security_enabled {
            let security_issues = security::analyze_security(std::slice::from_ref(cookie));
            result.security_issues.extend(security_issues);
        }

        // Compliance analysis
        if self.config.compliance_enabled {
            for regulation in &self.config.regulations {
                let compliance_issues = compliance::check_compliance(cookie, *regulation);
                result.compliance_issues.extend(compliance_issues);
            }
        }

        // Tracking analysis
        if self.config.tracking_enabled {
            if let Some(tracking) = tracking::detect_tracking(cookie) {
                result.tracking_info.push(tracking);
            }
        }

        // Calculate scores
        result.calculate_scores();

        result
    }

    /// Analyze multiple cookies
    #[must_use]
    pub fn analyze_batch(&self, cookies: &[Cookie]) -> AnalysisResult {
        let scan_id = uuid::Uuid::new_v4().to_string();
        let mut result = AnalysisResult::new(scan_id);

        // Security analysis for all cookies
        if self.config.security_enabled {
            let security_issues = security::analyze_security(cookies);
            result.security_issues.extend(security_issues);
        }

        // Compliance and tracking analysis per cookie
        for cookie in cookies {
            // Compliance analysis
            if self.config.compliance_enabled {
                for regulation in &self.config.regulations {
                    let compliance_issues = compliance::check_compliance(cookie, *regulation);
                    result.compliance_issues.extend(compliance_issues);
                }
            }

            // Tracking analysis
            if self.config.tracking_enabled {
                if let Some(tracking) = tracking::detect_tracking(cookie) {
                    result.tracking_info.push(tracking);
                }
            }
        }

        result.calculate_scores();
        result
    }
}

impl Default for Analyzer {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_analyzer_creation() {
        let analyzer = Analyzer::new();
        assert!(analyzer.config.security_enabled);
    }

    #[test]
    fn test_analyze_cookie() {
        let analyzer = Analyzer::new();
        let cookie = Cookie::new("test".to_string(), "value".to_string());
        let result = analyzer.analyze(&cookie);

        assert!(!result.id.is_empty());
    }

    #[test]
    fn test_analyze_batch() {
        let analyzer = Analyzer::new();
        let cookies = vec![
            Cookie::new("test1".to_string(), "value1".to_string()),
            Cookie::new("test2".to_string(), "value2".to_string()),
        ];
        let result = analyzer.analyze_batch(&cookies);

        assert!(!result.id.is_empty());
    }
}