Merge pull request #16 from monoscope-tech/feature/dump-curl

feat: add curl dump

Author: nopunYntendeed

src/base_request.rs

@@ -122,6 +122,7 @@ pub struct RequestConfig {
     pub request_body: Option<HashMap<String, String>>,
     pub pre_request_hook: Option<String>,
     pub post_response_hook: Option<String>,
+    pub curl: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -423,6 +424,73 @@ pub async fn base_request(
                     headers.insert("X-Testkit-Collection-ID".into(), col.clone());
                     request_config.headers = Some(headers);
                 }
+
+                let method_str = test_item.request.http_method.get_method().to_string();
+                let params_vec = if let Some(v) = test_item.request.params.clone() {
+                    Some(
+                        v.iter()
+                            .map(|(k, v)| {
+                                (replace_vars(k, &exports_map), replace_vars(v, &exports_map))
+                            })
+                            .collect(),
+                    )
+                } else {
+                    None
+                };
+
+                let mut processed_headers = HashMap::new();
+                if let Some(headers) = &test_item.request.headers {
+                    for (name, mut value) in headers.clone() {
+                        for env_var in get_env_variable_paths(&value) {
+                            if let Ok(val) = get_env_variable(&env_var) {
+                                value = value.replace(&env_var, &val);
+                            }
+                        }
+                        for export_var in get_vars(&value) {
+                            let key_str = export_var.replace("{{", "").replace("}}", "");
+                            if let Some(val) = exports_map.lock().unwrap().get(&key_str) {
+                                value = value.replace(&export_var, &val.to_string());
+                            }
+                        }
+                        processed_headers.insert(name, value);
+                    }
+                }
+
+                let json_body_str = if let Some(json) = &test_item.request.json {
+                    let js_string = match json {
+                        Value::String(s) => s.clone(),
+                        _ => json.to_string(),
+                    };
+                    let j_string =
+                        prepare_json_body(js_string.clone(), &exports_map, &mut step_result, false);
+                    processed_headers
+                        .insert("Content-Type".to_string(), "application/json".to_string());
+                    Some(j_string)
+                } else {
+                    None
+                };
+
+                let request_body_str = if let Some(b) = &test_item.request.request_body {
+                    let mut body = b.clone();
+                    for (key, val) in body.clone().iter() {
+                        body.insert(key.clone(), replace_vars(val, &exports_map));
+                    }
+                    serde_json::to_string(&body).ok()
+                } else {
+                    None
+                };
+
+                let curl_cmd = generate_curl_command(
+                    &method_str,
+                    &url,
+                    &Some(processed_headers),
+                    &json_body_str,
+                    &request_body_str,
+                    &params_vec,
+                );
+
+                request_config.curl = Some(curl_cmd);
+
                 let response = request_builder.send().await;
                 match response {
                     Err(e) => {
@@ -960,6 +1028,53 @@ async fn check_assertions(
     assert_results
 }
 
+fn generate_curl_command(
+    method: &str,
+    url: &str,
+    headers: &Option<HashMap<String, String>>,
+    json_body: &Option<String>,
+    request_body: &Option<String>,
+    params: &Option<Vec<(String, String)>>,
+) -> String {
+    let mut curl_cmd = String::from("curl");
+
+    // Build URL with query params first
+    let mut final_url = url.to_string();
+    if let Some(params_vec) = params {
+        if !params_vec.is_empty() {
+            let query_string: Vec<String> =
+                params_vec.iter().map(|(k, v)| format!("{}={}", k, v)).collect();
+            final_url.push_str(&format!("?{}", query_string.join("&")));
+        }
+    }
+
+    // Add method if not GET
+    if method != "GET" {
+        curl_cmd.push_str(&format!(" -X {} '{}'", method, final_url));
+    } else {
+        curl_cmd.push_str(&format!(" '{}'", final_url));
+    }
+
+    if let Some(headers_map) = headers {
+        for (key, value) in headers_map {
+            let escaped_value = value.replace("'", "'\\''");
+            curl_cmd.push_str(&format!(" -H '{}: {}'", key, escaped_value));
+        }
+    }
+
+    if let Some(json) = json_body {
+        let escaped_json = json.replace("'", "'\\''");
+        curl_cmd.push_str(&format!(" -d '{}'", escaped_json));
+    }
+
+    if let Some(body) = request_body {
+        let escaped_body = body.replace("'", "'\\''");
+        curl_cmd.push_str(&format!(" -d '{}'", escaped_body));
+    }
+
+    curl_cmd
+}
+
 #[cfg(test)]
 mod tests {
     // Unit tests for this module can be added here.