grpctestify 1.4.8

gRPC testing utility 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
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
138
139
140
141
142
143
144
145

// Tests for report generators - public API only

use grpctestify::cli::args::ProgressMode;
use grpctestify::report::Reporter;

#[test]
fn test_progress_mode_from_str_dots() {
    // Arrange & Act
    let mode: ProgressMode = "dots".parse().unwrap_or(ProgressMode::Dots);

    // Assert
    assert!(matches!(mode, ProgressMode::Dots));
}

#[test]
fn test_progress_mode_from_str_bar() {
    // Arrange & Act
    let mode: ProgressMode = "bar".parse().unwrap_or(ProgressMode::Dots);

    // Assert
    assert!(matches!(mode, ProgressMode::Bar));
}

#[test]
fn test_progress_mode_from_str_none() {
    // Arrange & Act
    let mode: ProgressMode = "none".parse().unwrap_or(ProgressMode::Dots);

    // Assert
    assert!(matches!(mode, ProgressMode::None));
}

#[test]
fn test_progress_mode_from_str_invalid() {
    // Arrange & Act
    let mode: ProgressMode = "invalid".parse().unwrap_or(ProgressMode::Dots);

    // Assert
    assert!(matches!(mode, ProgressMode::Dots));
}

#[test]
fn test_progress_mode_debug() {
    // Arrange
    let mode = ProgressMode::Dots;

    // Act
    let debug_str = format!("{:?}", mode);

    // Assert
    assert!(debug_str.contains("Dots"));
}

#[test]
fn test_progress_mode_clone() {
    // Arrange
    let mode = ProgressMode::Bar;

    // Act
    let mode_clone = mode;

    // Assert
    assert!(matches!(mode_clone, ProgressMode::Bar));
}

#[test]
fn test_junit_reporter_on_suite_end() {
    // Arrange
    let temp_dir = tempfile::TempDir::new().expect("Failed to create temp dir");
    let path = temp_dir.path().join("junit.xml");
    let reporter = grpctestify::report::junit::JunitReporter::new(path.clone());
    let results = grpctestify::state::TestResults::new();

    // Act
    let result = reporter.on_suite_end(&results);

    // Assert
    assert!(result.is_ok());
    assert!(path.exists());

    // Verify XML content
    let content = std::fs::read_to_string(&path).expect("Failed to read JUnit file");
    assert!(content.contains("<?xml version=\"1.0\""));
    assert!(content.contains("<testsuites"));
    assert!(content.contains("</testsuites>"));
}

#[test]
fn test_junit_reporter_xml_escaping() {
    // Arrange
    let temp_dir = tempfile::TempDir::new().expect("Failed to create temp dir");
    let path = temp_dir.path().join("junit.xml");
    let reporter = grpctestify::report::junit::JunitReporter::new(path.clone());

    // Create results with special characters in error message
    let mut results = grpctestify::state::TestResults::new();
    let fail_result = grpctestify::state::TestResult::fail(
        "test_special.gctf",
        "Error with <special> & \"chars\"".to_string(),
        100,
        None,
    );
    results.add(fail_result);

    // Act
    let result = reporter.on_suite_end(&results);

    // Assert
    assert!(result.is_ok());
    let content = std::fs::read_to_string(&path).expect("Failed to read JUnit file");

    // Verify XML escaping
    assert!(content.contains("&lt;"));
    assert!(content.contains("&gt;"));
    assert!(content.contains("&amp;"));
    assert!(content.contains("&quot;"));
}

#[test]
fn test_junit_reporter_skipped_test() {
    // Arrange
    let temp_dir = tempfile::TempDir::new().expect("Failed to create temp dir");
    let path = temp_dir.path().join("junit.xml");
    let reporter = grpctestify::report::junit::JunitReporter::new(path.clone());

    // Create results with skipped test
    let mut results = grpctestify::state::TestResults::new();
    let skip_result = grpctestify::state::TestResult {
        name: "test_skip.gctf".to_string(),
        status: grpctestify::state::TestStatus::Skip,
        duration_ms: 0,
        grpc_duration_ms: None,
        error_message: Some("Skipped due to condition".to_string()),
        execution_time: chrono::Utc::now().timestamp(),
    };
    results.add(skip_result);

    // Act
    let result = reporter.on_suite_end(&results);

    // Assert
    assert!(result.is_ok());
    let content = std::fs::read_to_string(&path).expect("Failed to read JUnit file");
    assert!(content.contains("<skipped"));
}