lumin 0.1.16

A library for searching and displaying local files
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

use anyhow::Result;
use lumin::tree::{Entry, TreeOptions, generate_tree};
use serial_test::serial;
use std::path::Path;

mod test_helpers;
use test_helpers::{TEST_DIR, TestEnvironment};

/// Tests for the tree functionality
#[cfg(test)]
mod tree_tests {
    use super::*;

    /// Test tree generation with default options
    #[test]
    #[serial]
    fn test_tree_default_options() -> Result<()> {
        let _env = TestEnvironment::setup()?;

        let options = TreeOptions::default();
        let result = generate_tree(Path::new(TEST_DIR), &options)?;

        // Should find multiple directories
        assert!(!result.is_empty());

        // Check the structure format
        for dir_tree in &result {
            // Dir should be a valid path string
            assert!(!dir_tree.dir.is_empty());

            // Each directory should have entries
            assert!(!dir_tree.entries.is_empty());

            // Entries should be either files or directories
            for entry in &dir_tree.entries {
                match entry {
                    Entry::File { name } => {
                        assert!(!name.is_empty());
                    }
                    Entry::Directory { name } => {
                        assert!(!name.is_empty());
                    }
                }
            }
        }

        // Should not find directories in .hidden directory (respects gitignore)
        assert!(!result.iter().any(|r| r.dir.contains(".hidden")));

        Ok(())
    }

    /// Test tree generation without respecting gitignore
    #[test]
    #[serial]
    fn test_tree_ignore_gitignore() -> Result<()> {
        let _env = TestEnvironment::setup()?;

        // Configure to ignore gitignore
        let mut options = TreeOptions::default();
        options.respect_gitignore = false;

        let result = generate_tree(Path::new(TEST_DIR), &options)?;

        // Should find .hidden directories
        assert!(
            result.iter().any(|r| r.dir.contains(".hidden")),
            "Did not find .hidden directories when ignoring gitignore"
        );

        Ok(())
    }

    /// Test tree with default options
    #[test]
    #[serial]
    fn test_tree_text_files_only() -> Result<()> {
        let _env = TestEnvironment::setup()?;

        let options = TreeOptions::default();
        let result = generate_tree(Path::new(TEST_DIR), &options)?;

        // Verify that the test finds some structure
        assert!(!result.is_empty());

        Ok(())
    }

    /// Test tree finding binary files
    #[test]
    #[serial]
    fn test_tree_include_binary() -> Result<()> {
        let _env = TestEnvironment::setup()?;

        let options = TreeOptions::default();

        let result = generate_tree(Path::new(TEST_DIR), &options)?;

        // Should find binary files in entries
        let has_binary_files = result.iter().any(|dir_tree| {
            dir_tree.entries.iter().any(|entry| match entry {
                Entry::File { name } => {
                    name.ends_with(".jpg") || name.ends_with(".png") || name == "binary_executable"
                }
                _ => false,
            })
        });

        assert!(has_binary_files, "Did not find binary files");

        Ok(())
    }
}