hurley 0.1.4

A curl-like HTTP client with performance testing capabilities
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
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206

//! Performance testing module for rurl.
//!
//! This module provides functionality for load testing and benchmarking
//! HTTP endpoints with:
//!
//! - [`Dataset`] - JSON dataset parsing for varied requests
//! - [`PerfRunner`] - Concurrent request execution with progress tracking
//! - [`PerfMetrics`] - Latency percentiles and throughput metrics
//! - [`PerfReport`] - Text and JSON output formatting

pub mod dataset;
pub mod datafile;
pub mod metrics;
pub mod runner;
pub mod report;
pub mod substitute;

pub use dataset::Dataset;
pub use datafile::{DataFile, DataRow};
pub use metrics::PerfMetrics;
pub use runner::PerfRunner;
pub use report::PerfReport;
pub use substitute::{extract_placeholders, get_row_for_request, substitute, validate_template};

// ── Integration tests ─────────────────────────────────────────────────────────
//
// These tests compose DataFile loading + template validation + substitution to
// prove end-to-end behaviour for R007 (standalone), R008 (perf cycling), R009
// (flag parsing is implicitly covered by DataFile::from_path path routing),
// R010 (end-to-end verification), and R006 (fail-fast on missing columns).
//
// Kept in `perf/mod.rs` so all re-exported symbols are directly in scope.

#[cfg(test)]
mod integration_tests {
    use std::io::Write;

    use super::{DataFile, get_row_for_request, substitute, validate_template};

    // ── Helpers ──────────────────────────────────────────────────────────────

    /// Write `content` to a temp file with the given `filename` and return the
    /// path.  Caller is responsible for removing it after use.
    fn write_temp(filename: &str, content: &str) -> std::path::PathBuf {
        let path = std::env::temp_dir().join(filename);
        let mut f = std::fs::File::create(&path).expect("create temp file");
        write!(f, "{}", content).unwrap();
        path
    }

    // ── R007 + R003 + R004: standalone mode URL / header / body substitution ─

    /// For each of the 3 data rows, substitute URL, header value, and JSON body
    /// and assert that the correct row values are present in each output.
    #[test]
    fn test_data_file_standalone_substitution() {
        let csv = "user_id,token\nu1,t1\nu2,t2\nu3,t3";
        let path = write_temp("hurley_integ_standalone.csv", csv);
        let df = DataFile::from_path(&path).expect("load CSV");
        let _ = std::fs::remove_file(&path);

        let url_tmpl = "https://api.example.com/users/{{user_id}}";
        let hdr_tmpl = "Authorization: Bearer {{token}}";
        let body_tmpl = r#"{"id": "{{user_id}}"}"#;

        for (i, (uid, tok)) in [("u1", "t1"), ("u2", "t2"), ("u3", "t3")]
            .iter()
            .enumerate()
        {
            let row = get_row_for_request(&df, i);

            let url = substitute(url_tmpl, row).unwrap();
            assert!(
                url.contains(uid),
                "row {i}: URL should contain '{uid}' but got '{url}'"
            );

            let hdr = substitute(hdr_tmpl, row).unwrap();
            assert!(
                hdr.contains(tok),
                "row {i}: header should contain '{tok}' but got '{hdr}'"
            );

            let body = substitute(body_tmpl, row).unwrap();
            assert!(
                body.contains(uid),
                "row {i}: body should contain '{uid}' but got '{body}'"
            );
        }
    }

    // ── R005 + R008: row cycling over 9 requests with 3 data rows ────────────

    /// Requests 0, 3, 6 → row 0; 1, 4, 7 → row 1; 2, 5, 8 → row 2.
    #[test]
    fn test_data_file_cycling_9_requests_3_rows() {
        let csv = "user_id\nrow0\nrow1\nrow2";
        let path = write_temp("hurley_integ_cycle.csv", csv);
        let df = DataFile::from_path(&path).expect("load CSV");
        let _ = std::fs::remove_file(&path);

        let url_tmpl = "https://api.example.com/users/{{user_id}}";

        let expected_row = |i: usize| -> &'static str {
            match i % 3 {
                0 => "row0",
                1 => "row1",
                _ => "row2",
            }
        };

        for i in 0..9usize {
            let row = get_row_for_request(&df, i);
            let url = substitute(url_tmpl, row).unwrap();
            let exp = expected_row(i);
            assert!(
                url.contains(exp),
                "request {i}: expected '{exp}' but URL was '{url}'"
            );
        }
    }

    // ── R006: validate_template returns Err for missing column ────────────────

    /// validate_template must error before any HTTP calls are made when the
    /// template references a column that is absent from the data file.
    #[test]
    fn test_validate_template_fails_before_execution() {
        let csv = "user_id,token\nu1,t1";
        let path = write_temp("hurley_integ_validate.csv", csv);
        let df = DataFile::from_path(&path).expect("load CSV");
        let _ = std::fs::remove_file(&path);

        let template = "{{user_id}}/{{missing_col}}";
        let result = validate_template(template, df.columns());
        assert!(result.is_err(), "expected Err for missing column");

        let msg = result.unwrap_err().to_string();
        assert!(
            msg.contains("missing_col"),
            "error should name the missing column; got: {msg}"
        );
    }

    // ── R002 + R007: JSON data file format ────────────────────────────────────

    /// DataFile::from_path must load a JSON array file and substitution must
    /// produce the correct output for each row.
    #[test]
    fn test_data_file_json_format() {
        let json = r#"[{"id": "1", "name": "alice"}, {"id": "2", "name": "bob"}]"#;
        let path = write_temp("hurley_integ_json.json", json);
        let df = DataFile::from_path(&path).expect("load JSON");
        let _ = std::fs::remove_file(&path);

        assert_eq!(df.len(), 2, "expected 2 rows in JSON data file");

        let tmpl = "Hello {{name}} #{{id}}";

        let row0 = get_row_for_request(&df, 0);
        let out0 = substitute(tmpl, row0).unwrap();
        assert_eq!(out0, "Hello alice #1", "row 0 substitution mismatch");

        let row1 = get_row_for_request(&df, 1);
        let out1 = substitute(tmpl, row1).unwrap();
        assert_eq!(out1, "Hello bob #2", "row 1 substitution mismatch");
    }

    // ── Backward compatibility: no data file ─────────────────────────────────

    /// When no data file is provided, the code paths that skip substitution
    /// must not panic.  Simulated here by verifying that an Option<&DataFile>
    /// of None causes no issues — the happy path is simply to skip substitution
    /// entirely and pass the template string through unchanged.
    #[test]
    fn test_backward_compat_no_data_file() {
        let data_file: Option<&DataFile> = None;

        // Static URL with no placeholders — if data_file is None we just use
        // the raw string, which must equal itself unchanged.
        let url = "https://api.example.com/static/resource";
        let effective_url = if let Some(df) = data_file {
            let row = get_row_for_request(df, 0);
            substitute(url, row).unwrap()
        } else {
            url.to_string()
        };
        assert_eq!(effective_url, url, "without data file, URL must be unchanged");

        // Template with placeholders — None path must not panic either.
        let url_with_placeholders = "https://api.example.com/users/{{user_id}}";
        let effective = if let Some(df) = data_file {
            let row = get_row_for_request(df, 0);
            substitute(url_with_placeholders, row).unwrap()
        } else {
            url_with_placeholders.to_string()
        };
        // When data_file is None substitution is skipped — the placeholder
        // string is preserved verbatim (user would see unresolved placeholders,
        // which is the documented no-data-file behaviour).
        assert_eq!(
            effective, url_with_placeholders,
            "without data file, template string must be passed through unchanged"
        );
    }
}