torc 0.23.0

Workflow management system
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

use rstest::rstest;
use serial_test::serial;
use std::sync::{Arc, Mutex};
use torc::client::apis::configuration::Configuration;
use torc::client::utils::send_with_retries;

/// Mock error type for testing
#[derive(Debug)]
struct MockError {
    message: String,
}

impl std::fmt::Display for MockError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.message)
    }
}

impl std::error::Error for MockError {}

#[rstest]
#[serial]
#[ignore] // TODO: currently way too slow
fn test_with_retries_success_on_first_try() {
    let config = Configuration::default();

    let result = send_with_retries(
        &config,
        || Ok::<String, MockError>("success".to_string()),
        1, // 1 minute timeout
    );

    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "success");
}

#[rstest]
#[serial]
#[ignore] // TODO: currently way too slow
fn test_with_retries_non_network_error_fails_immediately() {
    let config = Configuration::default();

    let result = send_with_retries(
        &config,
        || {
            Err::<String, MockError>(MockError {
                message: "database error".to_string(),
            })
        },
        1, // 1 minute timeout
    );

    assert!(result.is_err());
    assert_eq!(result.unwrap_err().message, "database error");
}

#[rstest]
#[serial]
#[ignore] // TODO: currently way too slow
fn test_with_retries_network_error_detection() {
    let config = Configuration::default();
    let call_count = Arc::new(Mutex::new(0));
    let call_count_clone = Arc::clone(&call_count);

    // This should be detected as a network error and trigger retry logic
    let result = send_with_retries(
        &config,
        move || {
            let mut count = call_count_clone.lock().unwrap();
            *count += 1;

            if *count == 1 {
                Err(MockError {
                    message: "connection timeout error".to_string(),
                })
            } else {
                Ok("recovered".to_string())
            }
        },
        1, // 1 minute timeout - should be enough for at least one retry
    );

    // The function should have been called at least once
    let final_count = *call_count.lock().unwrap();
    assert!(
        final_count >= 1,
        "Expected at least 1 call, got {}",
        final_count
    );

    // For network errors, the function will enter retry loop, but since we can't
    // easily mock the ping endpoint, it will likely fail with the original error
    // The important thing is that it was recognized as a network error
    if result.is_err() {
        assert!(result.unwrap_err().message.contains("connection"));
    }
}

#[rstest]
#[serial]
#[ignore] // TODO: currently way too slow
fn test_with_retries_different_network_error_types() {
    let config = Configuration::default();

    let network_error_types = vec![
        "connection refused",
        "network timeout",
        "dns resolution failed",
        "host unreachable",
        "network is down",
    ];

    for error_msg in network_error_types {
        let result = send_with_retries(
            &config,
            || {
                Err::<String, MockError>(MockError {
                    message: error_msg.to_string(),
                })
            },
            1, // 1 minute timeout
        );

        // Should be recognized as network error (though will eventually timeout)
        assert!(result.is_err());
    }
}

#[rstest]
#[serial]
#[ignore] // TODO: currently way too slow
fn test_with_retries_can_be_called_from_external_module() {
    // This test verifies that the function is properly exported and accessible
    let config = Configuration::default();

    // Import the function using the full path to ensure it's accessible
    let result =
        torc::client::send_with_retries(&config, || Ok::<&str, MockError>("accessible"), 1);

    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "accessible");
}

#[rstest]
#[case(0)] // Zero timeout
#[case(1)] // One minute timeout
#[case(5)] // Five minute timeout
#[serial]
#[ignore] // TODO: currently way too slow
fn test_with_retries_different_timeouts(#[case] timeout_minutes: u64) {
    let config = Configuration::default();

    let result = send_with_retries(
        &config,
        || Ok::<String, MockError>("timeout_test".to_string()),
        timeout_minutes,
    );

    // Success case should work regardless of timeout
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "timeout_test");
}

#[rstest]
#[serial]
#[ignore] // TODO: currently way too slow
fn test_with_retries_closure_capture() {
    let config = Configuration::default();
    let captured_value = "captured_data";

    let result = send_with_retries(
        &config,
        || Ok::<String, MockError>(format!("processed: {}", captured_value)),
        1,
    );

    assert!(result.is_ok());
    assert_eq!(result.unwrap(), "processed: captured_data");
}