rust_tree 1.3.0

// Unit tests for tree library functions
// These tests call library functions directly to provide code coverage

use glob::Pattern;
use rust_tree::rust_tree::fromfile::{build_virtual_tree, parse_file_listing, FileEntry};
use rust_tree::rust_tree::options::TreeOptions;
use rust_tree::rust_tree::traversal::list_directory;
use std::fs;
use tempfile::TempDir;

fn create_basic_options() -> TreeOptions {
    TreeOptions {
        all_files: false,
        level: None,
        full_path: false,
        dir_only: false,
        no_indent: false,
        print_size: false,
        human_readable: false,
        pattern_glob: None,
        exclude_patterns: vec![],
        color: false,
        no_color: false,
        ascii: false,
        sort_by_time: false,
        reverse: false,
        print_mod_date: false,
        output_file: None,
        file_limit: None,
        dirs_first: false,
        classify: false,
        no_report: false,
        print_permissions: false,
        from_file: false,
        icons: false,
        prune: false,
        match_dirs: false,
    }
}

fn create_test_dir() -> TempDir {
    let temp_dir = TempDir::new().unwrap();
    let root = temp_dir.path();

    fs::create_dir_all(root.join("src")).unwrap();
    fs::create_dir_all(root.join("tests")).unwrap();
    fs::write(root.join("README.md"), "# Test").unwrap();
    fs::write(root.join("src/main.rs"), "fn main() {}").unwrap();
    fs::write(root.join("tests/test.rs"), "// test").unwrap();

    temp_dir
}

#[test]
fn test_list_directory_basic() {
    let temp_dir = create_test_dir();
    let options = create_basic_options();

    // Should not panic and should complete successfully
    let result = list_directory(temp_dir.path(), &options);
    assert!(result.is_ok());
}

#[test]
fn test_list_directory_with_options() {
    let temp_dir = create_test_dir();

    // Test with various options
    let mut options = create_basic_options();
    options.all_files = true;
    assert!(list_directory(temp_dir.path(), &options).is_ok());

    options.all_files = false;
    options.dir_only = true;
    assert!(list_directory(temp_dir.path(), &options).is_ok());

    options.dir_only = false;
    options.print_size = true;
    assert!(list_directory(temp_dir.path(), &options).is_ok());

    options.print_size = false;
    options.level = Some(1);
    assert!(list_directory(temp_dir.path(), &options).is_ok());
}

#[test]
fn test_list_directory_with_patterns() {
    let temp_dir = create_test_dir();

    let mut options = create_basic_options();
    options.pattern_glob = Some(Pattern::new("*.md").unwrap());
    assert!(list_directory(temp_dir.path(), &options).is_ok());

    options.pattern_glob = None;
    options.exclude_patterns = vec![Pattern::new("*.rs").unwrap()];
    assert!(list_directory(temp_dir.path(), &options).is_ok());
}

#[test]
fn test_fromfile_simple_parsing() {
    let simple_paths = vec![
        "src/".to_string(),
        "src/main.rs".to_string(),
        "src/lib.rs".to_string(),
        "tests/".to_string(),
        "tests/test.rs".to_string(),
    ];

    let entries = parse_file_listing(simple_paths);
    assert!(!entries.is_empty());

    // Should have created parent directories automatically
    assert!(entries.iter().any(|e| e.path == "src" && e.is_dir));
    assert!(entries.iter().any(|e| e.path == "tests" && e.is_dir));
    assert!(entries.iter().any(|e| e.path == "src/main.rs" && !e.is_dir));
}

#[test]
fn test_fromfile_windows_path_normalization() {
    let windows_paths = vec![
        "src\\".to_string(),
        "src\\main.rs".to_string(),
        "C:\\data\\file.txt".to_string(),
    ];

    let entries = parse_file_listing(windows_paths);
    assert!(!entries.is_empty());

    // Windows paths should be normalized to Unix-style
    assert!(entries.iter().any(|e| e.path == "src" && e.is_dir));
    assert!(entries.iter().any(|e| e.path == "src/main.rs" && !e.is_dir));
    assert!(entries
        .iter()
        .any(|e| e.path == "C/data/file.txt" && !e.is_dir));
}

#[test]
fn test_build_virtual_tree() {
    let entries = vec![
        FileEntry {
            path: "src".to_string(),
            is_dir: true,
            size: None,
        },
        FileEntry {
            path: "src/main.rs".to_string(),
            is_dir: false,
            size: Some(100),
        },
    ];

    let options = create_basic_options();
    let virtual_tree = build_virtual_tree(entries, &options);

    assert_eq!(virtual_tree.root_name, ".");
    assert_eq!(virtual_tree.entries.len(), 2);
}

#[test]
fn test_fromfile_tar_format_detection() {
    // Simulate tar -tvf output
    let tar_lines = vec![
        "drwxrwxr-x user/user         0 2025-07-26 10:30 project/".to_string(),
        "-rw-rw-r-- user/user      1024 2025-07-26 10:30 project/main.rs".to_string(),
        "-rw-rw-r-- user/user       512 2025-07-26 10:30 project/lib.rs".to_string(),
    ];

    let entries = parse_file_listing(tar_lines);

    // The entries may be empty if TAR detection fails, but that's ok for this test
    // The important thing is that the function doesn't panic
    // The function should not panic, regardless of the number of entries returned
    let _entry_count = entries.len();
}

#[test]
fn test_list_directory_errors() {
    let options = create_basic_options();

    // Test with non-existent directory - should return an error
    let nonexistent_path = if cfg!(windows) {
        "C:\\nonexistent\\path\\for\\sure"
    } else {
        "/path/that/does/not/exist/for/sure"
    };
    let result = list_directory(nonexistent_path, &options);
    assert!(result.is_err()); // Tree should return error for non-existent directories
}

#[test]
fn test_fromfile_mode() {
    let temp_dir = create_test_dir();

    let mut options = create_basic_options();
    options.from_file = true;

    // Create a test file with paths
    let test_file = temp_dir.path().join("paths.txt");
    fs::write(&test_file, "src/\nsrc/main.rs\ntests/test.rs\n").unwrap();

    // Should not panic when processing fromfile
    let result = list_directory(&test_file, &options);
    assert!(result.is_ok());
}