catalyst 0.2.9

A lightweight API testing tool
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

use std::collections::HashMap;
use serde_json::json;
use catalyst::core::runner::{TestRunner, TestResult};

#[tokio::test]
async fn test_failure_summary_display() {
    let mut runner = TestRunner::new(false); // colored output enabled
    runner.no_fail_summary = false; // failure summary enabled
    
    // Add some test results with failures
    runner.results.push(TestResult {
        name: "Test 1 - Success".to_string(),
        success: true,
        expected_status: 200,
        actual_status: 200,
        response_body: Some(json!({"message": "success"})),
        headers: HashMap::new(),
        messages: vec![],
        method: "GET".to_string(),
        endpoint: "/api/users".to_string(),
    });
    
    runner.results.push(TestResult {
        name: "Test 2 - Failure".to_string(),
        success: false,
        expected_status: 200,
        actual_status: 404,
        response_body: Some(json!({"error": "Not found", "code": 404})),
        headers: HashMap::new(),
        messages: vec!["Status mismatch".to_string(), "Body validation failed".to_string()],
        method: "POST".to_string(),
        endpoint: "/api/users/123".to_string(),
    });
    
    runner.results.push(TestResult {
        name: "Test 3 - Success".to_string(),
        success: true,
        expected_status: 201,
        actual_status: 201,
        response_body: Some(json!({"id": 123, "created": true})),
        headers: HashMap::new(),
        messages: vec![],
        method: "POST".to_string(),
        endpoint: "/api/users".to_string(),
    });
    
    // Verify that we have the expected mix of results
    let success_count = runner.results.iter().filter(|r| r.success).count();
    let fail_count = runner.results.iter().filter(|r| !r.success).count();
    
    assert_eq!(success_count, 2);
    assert_eq!(fail_count, 1);
    
    // Test the format_response_body method
    let json_body = json!({"error": "Not found", "code": 404});
    let formatted = runner.format_response_body(&json_body);
    assert!(formatted.contains("\"error\": \"Not found\""));
    assert!(formatted.contains("\"code\": 404"));
    
    // Test truncation with large body
    let large_json = json!({
        "data": "x".repeat(10000),
        "message": "This is a large response"
    });
    let truncated = runner.format_response_body(&large_json);
    assert!(truncated.contains("... (truncated)"));
    assert!(truncated.len() <= TestRunner::MAX_SUMMARY_BODY_BYTES + 20); // Allow for truncation message
}

#[tokio::test]
async fn test_no_fail_summary_flag() {
    let mut runner = TestRunner::new(false);
    runner.no_fail_summary = true; // failure summary disabled
    
    // Add a failing test result
    runner.results.push(TestResult {
        name: "Failing Test".to_string(),
        success: false,
        expected_status: 200,
        actual_status: 500,
        response_body: Some(json!({"error": "Internal server error"})),
        headers: HashMap::new(),
        messages: vec!["Server error occurred".to_string()],
        method: "GET".to_string(),
        endpoint: "/api/status".to_string(),
    });
    
    // When no_fail_summary is true, failure details should not be displayed
    // This is tested indirectly by checking the flag value
    assert!(runner.no_fail_summary);
}

#[tokio::test]
async fn test_body_truncation_logic() {
    let runner = TestRunner::new(false);
    
    // Test normal sized body
    let normal_body = json!({"message": "Hello world"});
    let formatted_normal = runner.format_response_body(&normal_body);
    assert!(!formatted_normal.contains("... (truncated)"));
    
    // Test large body that exceeds MAX_SUMMARY_BODY_BYTES
    let large_data = "x".repeat(TestRunner::MAX_SUMMARY_BODY_BYTES + 1000);
    let large_body = json!({"data": large_data});
    let formatted_large = runner.format_response_body(&large_body);
    assert!(formatted_large.contains("... (truncated)"));
    assert!(formatted_large.len() <= TestRunner::MAX_SUMMARY_BODY_BYTES + 50);
    
    // Test non-JSON body (string)
    let string_body = json!("This is just a string response");
    let formatted_string = runner.format_response_body(&string_body);
    assert_eq!(formatted_string, "\"This is just a string response\"");
}

#[tokio::test]
async fn test_test_result_structure() {
    // Test that TestResult properly captures method and endpoint
    let result = TestResult {
        name: "Test API call".to_string(),
        success: true,
        expected_status: 200,
        actual_status: 200,
        response_body: Some(json!({"status": "ok"})),
        headers: HashMap::new(),
        messages: vec![],
        method: "GET".to_string(),
        endpoint: "/api/status".to_string(),
    };
    
    assert_eq!(result.name, "Test API call");
    assert!(result.success);
    assert_eq!(result.expected_status, 200);
    assert_eq!(result.actual_status, 200);
    assert_eq!(result.method, "GET");
    assert_eq!(result.endpoint, "/api/status");
    assert!(result.response_body.is_some());
}