dugout 0.1.7

Git-native secrets manager for development teams, written in Rust
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

//! Tests for error handling and CLI flags.

use crate::support::*;

#[test]
fn test_no_command_shows_help() {
    let t = Test::new();

    let output = t.cmd().arg("--help").output().unwrap();
    assert_success(&output);
    let out = stdout(&output);
    assert!(out.contains("dugout") || out.contains("Usage"));
}

#[test]
fn test_unknown_command_fails() {
    let t = Test::new();

    let output = t.cmd().arg("unknown-command").output().unwrap();
    assert_failure(&output);
}

#[test]
fn test_verbose_flag_accepted() {
    let t = Test::new();

    // Verbose flag should be accepted
    let output = t
        .cmd()
        .args(["--verbose", "init", "--no-banner", "--name", "test"])
        .output()
        .unwrap();
    assert_success(&output);
}

#[test]
fn test_version_flag() {
    let t = Test::new();

    let output = t.cmd().arg("--version").output().unwrap();
    assert_success(&output);
    let out = stdout(&output);
    assert!(out.contains("dugout") || !out.is_empty());
}

#[test]
fn test_completions_bash_outputs_script() {
    let t = Test::new();

    let output = t.cmd().args(["completions", "bash"]).output().unwrap();
    assert_success(&output);
    let out = stdout(&output);
    assert!(out.contains("_dugout") || out.contains("complete"));
}

#[test]
fn test_completions_zsh() {
    let t = Test::new();

    let output = t.cmd().args(["completions", "zsh"]).output().unwrap();
    assert_success(&output);
    let out = stdout(&output);
    // Verify output contains zsh-specific syntax
    assert!(
        out.contains("#compdef") || out.contains("_dugout"),
        "zsh completion should contain zsh-specific syntax"
    );
}

#[test]
fn test_completions_fish() {
    let t = Test::new();

    let output = t.cmd().args(["completions", "fish"]).output().unwrap();
    assert_success(&output);
    let out = stdout(&output);
    // Verify output contains fish-specific syntax
    assert!(
        out.contains("complete") && out.contains("dugout"),
        "fish completion should contain fish-specific syntax"
    );
}

#[test]
fn test_completions_powershell() {
    let t = Test::new();

    let output = t
        .cmd()
        .args(["completions", "power-shell"])
        .output()
        .unwrap();
    assert_success(&output);
    let out = stdout(&output);
    // Verify output contains PowerShell-specific syntax
    assert!(
        out.contains("Register-ArgumentCompleter") || out.contains("param"),
        "powershell completion should contain PowerShell-specific syntax"
    );
}