netrunner_cli 0.7.3

A feature-rich Rust-based CLI to test and analyze your internet connection
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
146
147

use netrunner_cli::modules::{
    speed_test::SpeedTest,
    types::{ConnectionQuality, DetailLevel, TestConfig},
};
use std::time::Duration;

fn ensure_crypto_provider() {
    let _ = rustls::crypto::ring::default_provider().install_default();
}

#[tokio::test]
async fn test_speed_test_creation() {
    ensure_crypto_provider();
    let config = TestConfig::default();
    let speed_test = SpeedTest::new(config);
    assert!(speed_test.is_ok());
}

#[tokio::test]
async fn test_speed_test_with_custom_config() {
    ensure_crypto_provider();
    let config = TestConfig {
        server_url: "https://httpbin.org".to_string(),
        test_size_mb: 5,
        timeout_seconds: 10,
        json_output: true,
        animation_enabled: false,
        detail_level: DetailLevel::Basic,
        max_servers: 1,
    };

    let speed_test = SpeedTest::new(config);
    assert!(speed_test.is_ok());
}

#[tokio::test]
async fn test_connection_quality_rating() {
    ensure_crypto_provider();
    // Test excellent connection
    let quality = ConnectionQuality::from_speed_and_ping(150.0, 30.0, 10.0);
    assert_eq!(quality, ConnectionQuality::Excellent);

    // Test good connection
    let quality = ConnectionQuality::from_speed_and_ping(75.0, 15.0, 30.0);
    assert_eq!(quality, ConnectionQuality::Good);

    // Test average connection
    let quality = ConnectionQuality::from_speed_and_ping(30.0, 8.0, 80.0);
    assert_eq!(quality, ConnectionQuality::Average);

    // Test poor connection
    let quality = ConnectionQuality::from_speed_and_ping(15.0, 3.0, 120.0);
    assert_eq!(quality, ConnectionQuality::Poor);

    // Test very poor connection
    let quality = ConnectionQuality::from_speed_and_ping(5.0, 1.0, 200.0);
    assert_eq!(quality, ConnectionQuality::VeryPoor);

    // Test failed connection
    let quality = ConnectionQuality::from_speed_and_ping(0.0, 0.0, 0.0);
    assert_eq!(quality, ConnectionQuality::Failed);
}

#[tokio::test]
async fn test_speed_test_timeout() {
    ensure_crypto_provider();
    let config = TestConfig {
        server_url: "https://httpbin.org/delay/20".to_string(), // This will timeout
        test_size_mb: 1,
        timeout_seconds: 1, // Very short timeout
        json_output: true,
        animation_enabled: false,
        detail_level: DetailLevel::Basic,
        max_servers: 1,
    };

    let speed_test = SpeedTest::new(config).unwrap();
    let result = speed_test.run_full_test().await;

    // Should still return a result even if some tests fail
    assert!(result.is_ok());
    let test_result = result.unwrap();
    assert!(test_result.download_mbps >= 0.0);
    assert!(test_result.upload_mbps >= 0.0);
    assert!(test_result.ping_ms >= 0.0);
}

#[tokio::test]
async fn test_speed_test_result_structure() {
    ensure_crypto_provider();
    let config = TestConfig {
        server_url: "https://httpbin.org".to_string(),
        test_size_mb: 1,
        timeout_seconds: 30,
        json_output: true,
        animation_enabled: false,
        detail_level: DetailLevel::Standard,
        max_servers: 1,
    };

    let speed_test = SpeedTest::new(config).unwrap();
    let result = speed_test.run_full_test().await;

    assert!(result.is_ok());
    let test_result = result.unwrap();

    // Verify result structure
    assert!(test_result.download_mbps >= 0.0);
    assert!(test_result.upload_mbps >= 0.0);
    assert!(test_result.ping_ms >= 0.0);
    assert!(test_result.test_duration_seconds > 0.0);
    assert!(!test_result.server_location.is_empty());

    // Verify timestamp is recent (within last minute)
    let now = chrono::Utc::now();
    let diff = now.signed_duration_since(test_result.timestamp);
    assert!(diff.num_seconds() < 60);
}

#[tokio::test]
async fn test_multiple_speed_tests() {
    ensure_crypto_provider();
    let config = TestConfig {
        server_url: "https://httpbin.org".to_string(),
        test_size_mb: 1,
        timeout_seconds: 15,
        json_output: true,
        animation_enabled: false,
        detail_level: DetailLevel::Basic,
        max_servers: 1,
    };

    // Run multiple tests to ensure consistency
    for _ in 0..3 {
        let speed_test = SpeedTest::new(config.clone()).unwrap();
        let result = speed_test.run_full_test().await;
        assert!(result.is_ok());

        let test_result = result.unwrap();
        assert!(test_result.download_mbps >= 0.0);
        assert!(test_result.upload_mbps >= 0.0);
        assert!(test_result.ping_ms >= 0.0);

        // Add small delay between tests
        tokio::time::sleep(Duration::from_millis(100)).await;
    }
}