cargo-hold 1.3.4

cargo-hold: A CI tool to ensure Cargo's incremental compilation is reliable by managing your caches intelligently
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

use std::path::{Path, PathBuf};

use clap::Parser;

use crate::cli::{Cli, Commands, normalize_path};

#[test]
fn test_cli_parsing() {
    let cli = Cli::parse_from(["cargo-hold", "anchor"]);
    assert!(matches!(cli.command(), Commands::Anchor));
    assert_eq!(cli.global_opts().target_dir(), Path::new("target"));
    assert!(cli.global_opts().metadata_path().is_none());
    // get_metadata_path now returns absolute paths
    assert!(
        cli.global_opts()
            .get_metadata_path()
            .ends_with("target/cargo-hold.metadata")
    );
    assert_eq!(cli.global_opts().verbose(), 0);
    assert!(!cli.global_opts().quiet());
}

#[test]
fn test_verbose_flag() {
    let cli = Cli::parse_from(["cargo-hold", "-vv", "stow"]);
    assert_eq!(cli.global_opts().verbose(), 2);
    assert!(matches!(cli.command(), Commands::Stow));
}

#[test]
fn test_custom_metadata_path() {
    let cli = Cli::parse_from([
        "cargo-hold",
        "--metadata-path",
        "custom.metadata",
        "salvage",
    ]);
    assert_eq!(
        cli.global_opts().metadata_path(),
        Some(Path::new("custom.metadata"))
    );
    // get_metadata_path now returns absolute paths
    assert!(
        cli.global_opts()
            .get_metadata_path()
            .ends_with("custom.metadata")
    );
    assert!(matches!(cli.command(), Commands::Salvage));
}

#[test]
fn test_custom_target_dir() {
    let cli = Cli::parse_from(["cargo-hold", "--target-dir", "build", "stow"]);
    assert_eq!(cli.global_opts().target_dir(), Path::new("build"));
    // get_metadata_path now returns absolute paths
    assert!(
        cli.global_opts()
            .get_metadata_path()
            .ends_with("build/cargo-hold.metadata")
    );
    assert!(matches!(cli.command(), Commands::Stow));
}

#[test]
fn test_global_flag_positioning() {
    // Global flags can be placed anywhere
    let cli = Cli::parse_from(["cargo-hold", "bilge", "--verbose"]);
    assert_eq!(cli.global_opts().verbose(), 1);
    assert!(matches!(cli.command(), Commands::Bilge));
}

#[test]
fn test_cli_builder() {
    // Test the builder pattern for programmatic construction
    let cli = Cli::builder()
        .target_dir("custom/target")
        .verbose(2)
        .quiet(false)
        .command(Commands::Anchor)
        .build()
        .expect("Failed to build CLI");

    assert_eq!(cli.global_opts().target_dir(), Path::new("custom/target"));
    assert_eq!(cli.global_opts().verbose(), 2);
    assert!(!cli.global_opts().quiet());
    assert!(matches!(cli.command(), Commands::Anchor));

    // Test builder with metadata path
    let cli = Cli::builder()
        .metadata_path("custom.metadata")
        .command(Commands::Stow)
        .build()
        .expect("Failed to build CLI");

    assert_eq!(
        cli.global_opts().metadata_path(),
        Some(Path::new("custom.metadata"))
    );
    assert!(matches!(cli.command(), Commands::Stow));
}

#[test]
fn test_normalize_path() {
    // Test with current directory components
    let normalized = normalize_path("./target/./debug");
    assert!(normalized.is_absolute());
    // The path might start with ./ if current_dir fails, so check for /./
    assert!(!normalized.to_string_lossy().contains("/./"));

    // Test with parent directory components
    let normalized = normalize_path("target/../other/target");
    assert!(normalized.is_absolute());
    assert!(normalized.ends_with("other/target"));
    assert!(!normalized.to_string_lossy().contains(".."));

    // Test absolute path is preserved
    let abs_path = if cfg!(windows) {
        PathBuf::from("C:\\Users\\test")
    } else {
        PathBuf::from("/home/test")
    };
    let normalized = normalize_path(&abs_path);
    assert_eq!(normalized, abs_path);

    // Test complex path with multiple .. and .
    let normalized = normalize_path("./a/b/../c/./d/../e");
    assert!(normalized.is_absolute());
    assert!(normalized.ends_with("a/c/e"));
}