aperture-cli 0.1.9

Dynamic CLI generator for OpenAPI specifications
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

//! Integration tests for request/response logging functionality

use aperture_cli::logging::{get_max_body_len, redact_sensitive_value, should_redact_header};
use std::env;

/// Combined test for all logging environment variables.
/// These are combined into a single test to avoid race conditions when tests
/// run in parallel, since environment variables are global state.
#[test]
fn test_logging_environment_variables() {
    // Save original values
    let original_log = env::var("APERTURE_LOG").ok();
    let original_format = env::var("APERTURE_LOG_FORMAT").ok();
    let original_max_body = env::var("APERTURE_LOG_MAX_BODY").ok();

    // Test APERTURE_LOG
    env::set_var("APERTURE_LOG", "debug");
    assert_eq!(
        env::var("APERTURE_LOG").ok(),
        Some("debug".to_string()),
        "APERTURE_LOG should be settable"
    );

    // Test APERTURE_LOG_FORMAT
    env::set_var("APERTURE_LOG_FORMAT", "json");
    assert_eq!(
        env::var("APERTURE_LOG_FORMAT").ok(),
        Some("json".to_string()),
        "APERTURE_LOG_FORMAT should be settable"
    );

    // Test APERTURE_LOG_MAX_BODY default
    env::remove_var("APERTURE_LOG_MAX_BODY");
    assert_eq!(get_max_body_len(), 1000, "Default max body should be 1000");

    // Test APERTURE_LOG_MAX_BODY custom value
    env::set_var("APERTURE_LOG_MAX_BODY", "2000");
    assert_eq!(
        get_max_body_len(),
        2000,
        "Custom max body value should be respected"
    );

    // Restore original values
    if let Some(val) = original_log {
        env::set_var("APERTURE_LOG", val);
    } else {
        env::remove_var("APERTURE_LOG");
    }

    if let Some(val) = original_format {
        env::set_var("APERTURE_LOG_FORMAT", val);
    } else {
        env::remove_var("APERTURE_LOG_FORMAT");
    }

    if let Some(val) = original_max_body {
        env::set_var("APERTURE_LOG_MAX_BODY", val);
    } else {
        env::remove_var("APERTURE_LOG_MAX_BODY");
    }
}

#[test]
fn test_logging_module_redaction() {
    // Test that the logging module properly redacts sensitive headers

    // Should redact these headers
    assert!(should_redact_header("Authorization"));
    assert!(should_redact_header("authorization"));
    assert!(should_redact_header("X-API-Key"));
    assert!(should_redact_header("X-Auth-Token"));
    assert!(should_redact_header("api-key"));

    // Should not redact these headers
    assert!(!should_redact_header("Content-Type"));
    assert!(!should_redact_header("Content-Length"));
    assert!(!should_redact_header("User-Agent"));
}

#[test]
fn test_logging_module_redaction_value() {
    // Test that sensitive values are properly redacted

    assert_eq!(redact_sensitive_value("secret123"), "[REDACTED]");
    assert_eq!(redact_sensitive_value(""), "");
}

#[test]
fn test_cli_verbose_flag_parsing() {
    // This test verifies that the CLI can be parsed with verbose flags
    // In a real scenario, this would test the actual CLI parsing
    // For now, we verify the concept works
    let verbosity_default = 0u8;
    let verbosity_v = 1u8;
    let verbosity_vv = 2u8;

    // Verify the mapping logic
    assert_eq!(verbosity_default, 0);
    assert_eq!(verbosity_v, 1);
    assert_eq!(verbosity_vv, 2);
}