linthis 0.19.1

A fast, cross-platform multi-language linter and formatter
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
136
137

//! Integration tests for linthis CLI.
//!
//! These tests verify the CLI interface by running the linthis binary
//! and checking its output and exit codes.

// Shared test utilities
mod common;

// Test modules
mod cache_tests;
mod check_tests;
mod config_tests;
mod error_tests;
mod format_tests;
mod language_tests;
mod plugin_tests;

use std::process::Command;

/// Helper to get the path to the linthis binary
fn linthis_bin() -> Command {
    Command::new(env!("CARGO_BIN_EXE_linthis"))
}

/// Test that --help works
#[test]
fn test_help_flag() {
    let output = linthis_bin()
        .arg("--help")
        .output()
        .expect("Failed to execute linthis");

    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("linthis"));
    assert!(stdout.contains("Usage"));
}

/// Test that --version works
#[test]
fn test_version_flag() {
    let output = linthis_bin()
        .arg("--version")
        .output()
        .expect("Failed to execute linthis");

    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("linthis"));
}

/// Test init subcommand help
#[test]
fn test_init_help() {
    let output = linthis_bin()
        .args(["init", "--help"])
        .output()
        .expect("Failed to execute linthis");

    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("init"));
}

/// Test plugin subcommand help
#[test]
fn test_plugin_help() {
    let output = linthis_bin()
        .args(["plugin", "--help"])
        .output()
        .expect("Failed to execute linthis");

    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("plugin"));
}

/// Test hook subcommand help
#[test]
fn test_hook_help() {
    let output = linthis_bin()
        .args(["hook", "--help"])
        .output()
        .expect("Failed to execute linthis");

    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("hook"));
}

/// Test config subcommand help
#[test]
fn test_config_help() {
    let output = linthis_bin()
        .args(["config", "--help"])
        .output()
        .expect("Failed to execute linthis");

    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("config"));
}

/// Test that running with non-existent path fails gracefully
#[test]
fn test_nonexistent_path() {
    let output = linthis_bin()
        .args(["-c", "/nonexistent/path/that/does/not/exist"])
        .output()
        .expect("Failed to execute linthis");

    // Should not crash, may exit with error
    // Just verify it completes
    let _ = output.status;
}

/// Test quiet mode flag
#[test]
fn test_quiet_mode() {
    let output = linthis_bin()
        .args(["--quiet", "--help"])
        .output()
        .expect("Failed to execute linthis");

    assert!(output.status.success());
}

/// Test verbose mode flag
#[test]
fn test_verbose_mode() {
    let output = linthis_bin()
        .args(["--verbose", "--help"])
        .output()
        .expect("Failed to execute linthis");

    assert!(output.status.success());
}