neocurl 2.0.5

A command line tool to test servers
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
148

use std::collections::HashMap;

use super::PyMethod;
use pyo3::{prelude::*, types::PyDict};

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct PyRequest {
    pub url: String,
    pub method: PyMethod,
    pub headers: HashMap<String, String>,
    pub params: HashMap<String, String>,
    pub body: Option<Vec<u8>>,
    pub timeout: u64,
}

impl PyRequest {
    /// Creates a new PyRequest instance from a URL and optional keyword arguments.
    pub fn from_args(
        url: String,
        method: PyMethod,
        kwargs: Option<&Bound<'_, PyDict>>,
    ) -> PyResult<Self> {
        let body_py = kwargs.and_then(|d| d.get_item("body").ok()?);
        let body = if let Some(body_py) = body_py {
            match body_py.extract::<String>() {
                Ok(body) => Some(body.as_bytes().to_vec()),
                Err(_) => {
                    // Try to parse as bytes
                    match body_py.extract::<Vec<u8>>() {
                        Ok(bytes) => Some(bytes),
                        Err(_) => {
                            return Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
                                "Body must be a string or bytes",
                            ));
                        }
                    }
                }
            }
        } else {
            None
        };

        let headers_py = kwargs.and_then(|d| d.get_item("headers").ok()?);
        let headers = if let Some(headers_py) = headers_py {
            match headers_py.extract::<HashMap<String, String>>() {
                Ok(headers) => headers,
                Err(_) => {
                    return Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
                        "Headers must be a dictionary with string keys and values",
                    ));
                }
            }
        } else {
            HashMap::new() // Default to empty headers if not provided
        };

        let params_py = kwargs.and_then(|d| d.get_item("params").ok()?);
        let params = if let Some(params_py) = params_py {
            match params_py.extract::<HashMap<String, String>>() {
                Ok(params) => params,
                Err(_) => {
                    return Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
                        "Params must be a dictionary with string keys and values",
                    ));
                }
            }
        } else {
            HashMap::new() // Default to empty params if not provided
        };

        let timeout = kwargs
            .and_then(|d| d.get_item("timeout").ok()?)
            .and_then(|v| v.extract::<u64>().ok())
            .unwrap_or(100_000); // Default timeout of 100 seconds

        Ok(PyRequest {
            url,
            method,
            headers,
            params,
            body,
            timeout,
        })
    }

    #[allow(dead_code)]
    pub fn to_reqwest(&self) -> reqwest::RequestBuilder {
        let client = reqwest::Client::builder()
            .pool_max_idle_per_host(1_000_000)
            .build()
            .expect("Failed to build reqwest client");

        let mut request_builder = match self.method {
            PyMethod::Get => client.get(&self.url),
            PyMethod::Head => client.head(&self.url),
            PyMethod::Post => client.post(&self.url),
            PyMethod::Put => client.put(&self.url),
            PyMethod::Delete => client.delete(&self.url),
            PyMethod::Patch => client.patch(&self.url),
        };

        for (key, value) in &self.headers {
            request_builder = request_builder.header(key, value);
        }

        for (key, value) in &self.params {
            request_builder = request_builder.query(&[(key.as_str(), value.as_str())]);
        }

        if let Some(body) = &self.body {
            request_builder = request_builder.body(body.clone());
        }

        request_builder.timeout(std::time::Duration::from_millis(self.timeout))
    }

    pub fn to_reqwest_blocking(&self) -> reqwest::blocking::RequestBuilder {
        let client = reqwest::blocking::Client::builder()
            .pool_max_idle_per_host(1_000_000)
            .build()
            .expect("Failed to build reqwest client");

        let mut request_builder = match self.method {
            PyMethod::Get => client.get(&self.url),
            PyMethod::Head => client.head(&self.url),
            PyMethod::Post => client.post(&self.url),
            PyMethod::Put => client.put(&self.url),
            PyMethod::Delete => client.delete(&self.url),
            PyMethod::Patch => client.patch(&self.url),
        };

        for (key, value) in &self.headers {
            request_builder = request_builder.header(key, value);
        }

        for (key, value) in &self.params {
            request_builder = request_builder.query(&[(key.as_str(), value.as_str())]);
        }

        if let Some(body) = &self.body {
            request_builder = request_builder.body(body.clone());
        }

        // request_builder.timeout(std::time::Duration::from_millis(self.timeout))

        request_builder
    }
}