scouty 0.3.2

Log parsing, filtering, and analysis library
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

#[cfg(test)]
mod tests {
    use crate::loader::file::FileLoader;
    use crate::traits::LogLoader;
    use std::io::Write;

    #[test]
    fn test_load_text_file() {
        let dir = tempfile::tempdir().unwrap();
        let file_path = dir.path().join("test.log");
        let mut f = std::fs::File::create(&file_path).unwrap();
        writeln!(f, "line one").unwrap();
        writeln!(f, "line two").unwrap();
        writeln!(f, "line three").unwrap();
        drop(f);

        let mut loader = FileLoader::new(&file_path, false);
        let lines = loader.load().unwrap();
        assert_eq!(lines, vec!["line one", "line two", "line three"]);
    }

    #[test]
    fn test_load_empty_file() {
        let dir = tempfile::tempdir().unwrap();
        let file_path = dir.path().join("empty.log");
        std::fs::File::create(&file_path).unwrap();

        let mut loader = FileLoader::new(&file_path, false);
        let lines = loader.load().unwrap();
        assert!(lines.is_empty());
    }

    #[test]
    fn test_sample_lines_populated() {
        let dir = tempfile::tempdir().unwrap();
        let file_path = dir.path().join("sample.log");
        let mut f = std::fs::File::create(&file_path).unwrap();
        for i in 0..20 {
            writeln!(f, "line {}", i).unwrap();
        }
        drop(f);

        let mut loader = FileLoader::new(&file_path, false);
        loader.load().unwrap();
        assert_eq!(loader.info().sample_lines.len(), 10);
        assert_eq!(loader.info().sample_lines[0], "line 0");
    }

    #[test]
    fn test_load_nonexistent_file() {
        let mut loader = FileLoader::new("/nonexistent/path.log", false);
        assert!(loader.load().is_err());
    }

    #[test]
    fn test_load_gzip_file() {
        use flate2::write::GzEncoder;
        use flate2::Compression;

        let dir = tempfile::tempdir().unwrap();
        let file_path = dir.path().join("test.log.gz");
        let f = std::fs::File::create(&file_path).unwrap();
        let mut encoder = GzEncoder::new(f, Compression::default());
        encoder
            .write_all(b"line one\nline two\nline three\n")
            .unwrap();
        encoder.finish().unwrap();

        let mut loader = FileLoader::new(&file_path, false);
        let lines = loader.load().unwrap();
        assert_eq!(lines, vec!["line one", "line two", "line three"]);
    }

    #[test]
    fn test_load_corrupted_gzip_file() {
        let dir = tempfile::tempdir().unwrap();
        let file_path = dir.path().join("corrupt.gz");
        let mut f = std::fs::File::create(&file_path).unwrap();
        f.write_all(b"this is not gzip data").unwrap();
        drop(f);

        let mut loader = FileLoader::new(&file_path, false);
        let result = loader.load();
        assert!(result.is_err());
        let err_msg = format!("{}", result.unwrap_err());
        assert!(err_msg.contains("decompress") || err_msg.contains("gzip"));
    }

    #[test]
    fn test_load_empty_gzip_file() {
        use flate2::write::GzEncoder;
        use flate2::Compression;

        let dir = tempfile::tempdir().unwrap();
        let file_path = dir.path().join("empty.log.gz");
        let f = std::fs::File::create(&file_path).unwrap();
        let encoder = GzEncoder::new(f, Compression::default());
        encoder.finish().unwrap();

        let mut loader = FileLoader::new(&file_path, false);
        let lines = loader.load().unwrap();
        assert!(lines.is_empty());
    }

    #[test]
    fn test_loader_info() {
        let loader = FileLoader::new("/tmp/test.log", true);
        let info = loader.info();
        assert_eq!(info.id, "/tmp/test.log");
        assert_eq!(info.loader_type, crate::traits::LoaderType::TextFile);
        assert!(info.multiline_enabled);
        assert!(info.sample_lines.is_empty());
    }

    #[test]
    fn test_file_mod_year_populated() {
        let dir = tempfile::tempdir().unwrap();
        let file_path = dir.path().join("dated.log");
        let mut f = std::fs::File::create(&file_path).unwrap();
        writeln!(f, "test line").unwrap();
        drop(f);

        let mut loader = FileLoader::new(&file_path, false);
        loader.load().unwrap();
        let year = loader.info().file_mod_year;
        assert!(
            year.is_some(),
            "file_mod_year should be populated after load"
        );
        assert!(
            year.unwrap() >= 2020,
            "file_mod_year should be a reasonable year"
        );
    }
}