spikard 0.4.0-x86_64-linux

data/vendor/crates/spikard-bindings-shared/src/response_builder.rs

@@ -0,0 +1,309 @@
+//! Response building utilities
+
+use axum::http::{HeaderMap, StatusCode, header};
+use serde_json::json;
+
+/// Builder for constructing HTTP responses across bindings
+pub struct ResponseBuilder {
+    status: StatusCode,
+    body: serde_json::Value,
+    headers: HeaderMap,
+}
+
+impl ResponseBuilder {
+    /// Create a new response builder with default status 200 OK
+    pub fn new() -> Self {
+        Self {
+            status: StatusCode::OK,
+            body: json!({}),
+            headers: HeaderMap::new(),
+        }
+    }
+
+    /// Set the HTTP status code
+    pub fn status(mut self, status: StatusCode) -> Self {
+        self.status = status;
+        self
+    }
+
+    /// Set the response body
+    pub fn body(mut self, body: serde_json::Value) -> Self {
+        self.body = body;
+        self
+    }
+
+    /// Add a response header
+    pub fn header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        if let Ok(name) = key.into().parse::<header::HeaderName>()
+            && let Ok(val) = value.into().parse::<header::HeaderValue>()
+        {
+            self.headers.insert(name, val);
+        }
+        self
+    }
+
+    /// Build the response as (status, headers, body)
+    pub fn build(self) -> (StatusCode, HeaderMap, String) {
+        let body = serde_json::to_string(&self.body).unwrap_or_else(|_| "{}".to_string());
+        (self.status, self.headers, body)
+    }
+}
+
+impl Default for ResponseBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_response_builder_default() {
+        let (status, headers, body) = ResponseBuilder::new().build();
+
+        assert_eq!(status, StatusCode::OK);
+        assert_eq!(body, "{}");
+        assert!(headers.is_empty());
+    }
+
+    #[test]
+    fn test_response_builder_default_trait() {
+        let (status, _, body) = ResponseBuilder::default().build();
+
+        assert_eq!(status, StatusCode::OK);
+        assert_eq!(body, "{}");
+    }
+
+    #[test]
+    fn test_response_builder_status() {
+        let (status, _, _) = ResponseBuilder::new().status(StatusCode::CREATED).build();
+
+        assert_eq!(status, StatusCode::CREATED);
+    }
+
+    #[test]
+    fn test_response_builder_status_chain() {
+        let (status, _, _) = ResponseBuilder::new()
+            .status(StatusCode::ACCEPTED)
+            .status(StatusCode::CREATED)
+            .build();
+
+        // Last status should win
+        assert_eq!(status, StatusCode::CREATED);
+    }
+
+    #[test]
+    fn test_response_builder_body() {
+        let body_data = json!({ "id": 123, "name": "test" });
+        let (_, _, body) = ResponseBuilder::new().body(body_data.clone()).build();
+
+        let parsed: serde_json::Value = serde_json::from_str(&body).unwrap();
+        assert_eq!(parsed["id"], 123);
+        assert_eq!(parsed["name"], "test");
+    }
+
+    #[test]
+    fn test_response_builder_body_chain() {
+        let first_body = json!({ "first": "value" });
+        let second_body = json!({ "second": "value" });
+
+        let (_, _, body) = ResponseBuilder::new().body(first_body).body(second_body).build();
+
+        let parsed: serde_json::Value = serde_json::from_str(&body).unwrap();
+        assert!(!parsed.get("first").is_some());
+        assert_eq!(parsed["second"], "value");
+    }
+
+    #[test]
+    fn test_response_builder_header() {
+        let (_, headers, _) = ResponseBuilder::new()
+            .header("Content-Type", "application/json")
+            .build();
+
+        assert_eq!(
+            headers.get("content-type").unwrap().to_str().unwrap(),
+            "application/json"
+        );
+    }
+
+    #[test]
+    fn test_response_builder_multiple_headers() {
+        let (_, headers, _) = ResponseBuilder::new()
+            .header("Content-Type", "application/json")
+            .header("X-Custom-Header", "custom-value")
+            .header("Authorization", "Bearer token123")
+            .build();
+
+        assert_eq!(headers.len(), 3);
+        assert_eq!(
+            headers.get("content-type").unwrap().to_str().unwrap(),
+            "application/json"
+        );
+        assert_eq!(
+            headers.get("x-custom-header").unwrap().to_str().unwrap(),
+            "custom-value"
+        );
+        assert_eq!(
+            headers.get("authorization").unwrap().to_str().unwrap(),
+            "Bearer token123"
+        );
+    }
+
+    #[test]
+    fn test_response_builder_header_overwrite() {
+        let (_, headers, _) = ResponseBuilder::new()
+            .header("Content-Type", "text/plain")
+            .header("Content-Type", "application/json")
+            .build();
+
+        assert_eq!(
+            headers.get("content-type").unwrap().to_str().unwrap(),
+            "application/json"
+        );
+    }
+
+    #[test]
+    fn test_response_builder_full_chain() {
+        let (status, headers, body) = ResponseBuilder::new()
+            .status(StatusCode::CREATED)
+            .body(json!({
+                "id": 456,
+                "status": "active",
+                "items": [1, 2, 3]
+            }))
+            .header("Content-Type", "application/json")
+            .header("X-Request-Id", "req-123")
+            .build();
+
+        assert_eq!(status, StatusCode::CREATED);
+        assert_eq!(headers.len(), 2);
+
+        let parsed: serde_json::Value = serde_json::from_str(&body).unwrap();
+        assert_eq!(parsed["id"], 456);
+        assert_eq!(parsed["status"], "active");
+        assert_eq!(parsed["items"][0], 1);
+    }
+
+    #[test]
+    fn test_response_builder() {
+        let (status, _, body) = ResponseBuilder::new()
+            .status(StatusCode::CREATED)
+            .body(json!({ "id": 123 }))
+            .build();
+
+        assert_eq!(status, StatusCode::CREATED);
+        assert!(body.contains("123"));
+    }
+
+    #[test]
+    fn test_response_builder_complex_json() {
+        let complex_body = json!({
+            "user": {
+                "id": 1,
+                "name": "John Doe",
+                "email": "john@example.com",
+                "roles": ["admin", "user"],
+                "settings": {
+                    "notifications": true,
+                    "theme": "dark"
+                }
+            },
+            "success": true,
+            "timestamp": "2024-01-01T00:00:00Z"
+        });
+
+        let (status, _, body) = ResponseBuilder::new().status(StatusCode::OK).body(complex_body).build();
+
+        assert_eq!(status, StatusCode::OK);
+        let parsed: serde_json::Value = serde_json::from_str(&body).unwrap();
+        assert_eq!(parsed["user"]["id"], 1);
+        assert_eq!(parsed["user"]["roles"][0], "admin");
+        assert_eq!(parsed["user"]["settings"]["theme"], "dark");
+    }
+
+    #[test]
+    fn test_response_builder_null_body() {
+        let (_, _, body) = ResponseBuilder::new().body(serde_json::Value::Null).build();
+
+        assert_eq!(body, "null");
+    }
+
+    #[test]
+    fn test_response_builder_array_body() {
+        let array_body = json!([1, 2, 3, 4, 5]);
+        let (_, _, body) = ResponseBuilder::new().body(array_body).build();
+
+        let parsed: serde_json::Value = serde_json::from_str(&body).unwrap();
+        assert!(parsed.is_array());
+        assert_eq!(parsed[0], 1);
+        assert_eq!(parsed[4], 5);
+    }
+
+    #[test]
+    fn test_response_builder_empty_object() {
+        let (_, _, body) = ResponseBuilder::new().body(json!({})).build();
+
+        let parsed: serde_json::Value = serde_json::from_str(&body).unwrap();
+        assert!(parsed.is_object());
+        assert_eq!(parsed.as_object().unwrap().len(), 0);
+    }
+
+    #[test]
+    fn test_response_builder_all_status_codes() {
+        let status_codes = vec![
+            StatusCode::OK,
+            StatusCode::CREATED,
+            StatusCode::ACCEPTED,
+            StatusCode::BAD_REQUEST,
+            StatusCode::UNAUTHORIZED,
+            StatusCode::FORBIDDEN,
+            StatusCode::NOT_FOUND,
+            StatusCode::INTERNAL_SERVER_ERROR,
+            StatusCode::SERVICE_UNAVAILABLE,
+        ];
+
+        for code in status_codes {
+            let (status, _, _) = ResponseBuilder::new().status(code).build();
+
+            assert_eq!(status, code);
+        }
+    }
+
+    #[test]
+    fn test_response_builder_invalid_header_name() {
+        // Invalid header names should be silently ignored
+        let (_, headers, _) = ResponseBuilder::new()
+            .header("Invalid\nHeader", "value")
+            .header("Valid-Header", "value")
+            .build();
+
+        // Only valid header should be present
+        assert_eq!(headers.len(), 1);
+    }
+
+    #[test]
+    fn test_response_builder_invalid_header_value() {
+        // Invalid header values should be silently ignored
+        let (_, headers, _) = ResponseBuilder::new().header("Valid-Header", "valid-value").build();
+
+        assert_eq!(headers.len(), 1);
+    }
+
+    #[test]
+    fn test_response_builder_special_characters_in_json() {
+        let body_with_special_chars = json!({
+            "message": "Hello \"World\"",
+            "path": "C:\\Users\\test",
+            "unicode": "café ☕",
+            "newlines": "line1\nline2"
+        });
+
+        let (_, _, body) = ResponseBuilder::new().body(body_with_special_chars).build();
+
+        let parsed: serde_json::Value = serde_json::from_str(&body).unwrap();
+        assert_eq!(parsed["message"], "Hello \"World\"");
+        assert_eq!(parsed["unicode"], "café ☕");
+    }
+}

data/vendor/crates/spikard-bindings-shared/src/test_client_base.rs

@@ -0,0 +1,248 @@
+//! Shared test client infrastructure
+
+use std::collections::HashMap;
+
+/// Base configuration for test clients across bindings
+pub struct TestClientConfig {
+    /// The base URL for the test server
+    pub base_url: String,
+    /// Request timeout in milliseconds
+    pub timeout_ms: u64,
+    /// Whether to follow redirects
+    pub follow_redirects: bool,
+}
+
+impl TestClientConfig {
+    /// Create a new test client configuration with custom base URL
+    pub fn new(base_url: impl Into<String>) -> Self {
+        Self {
+            base_url: base_url.into(),
+            timeout_ms: 30000,
+            follow_redirects: true,
+        }
+    }
+
+    /// Set the timeout in milliseconds
+    pub fn with_timeout(mut self, timeout_ms: u64) -> Self {
+        self.timeout_ms = timeout_ms;
+        self
+    }
+
+    /// Set whether to follow redirects
+    pub fn with_follow_redirects(mut self, follow_redirects: bool) -> Self {
+        self.follow_redirects = follow_redirects;
+        self
+    }
+}
+
+impl Default for TestClientConfig {
+    fn default() -> Self {
+        Self {
+            base_url: "http://localhost:3000".to_string(),
+            timeout_ms: 30000,
+            follow_redirects: true,
+        }
+    }
+}
+
+/// Common test response metadata
+#[derive(Debug, Clone)]
+pub struct TestResponseMetadata {
+    /// HTTP status code
+    pub status_code: u16,
+    /// Response headers
+    pub headers: HashMap<String, String>,
+    /// Response body size in bytes
+    pub body_size: usize,
+    /// Response time in milliseconds
+    pub response_time_ms: u64,
+}
+
+impl TestResponseMetadata {
+    /// Create a new test response metadata
+    pub fn new(status_code: u16, headers: HashMap<String, String>, body_size: usize, response_time_ms: u64) -> Self {
+        Self {
+            status_code,
+            headers,
+            body_size,
+            response_time_ms,
+        }
+    }
+
+    /// Get a header value by name (case-insensitive)
+    pub fn get_header(&self, name: &str) -> Option<&String> {
+        let lower_name = name.to_lowercase();
+        self.headers
+            .iter()
+            .find(|(k, _)| k.to_lowercase() == lower_name)
+            .map(|(_, v)| v)
+    }
+
+    /// Check if response was successful (2xx status code)
+    pub fn is_success(&self) -> bool {
+        self.status_code >= 200 && self.status_code < 300
+    }
+
+    /// Check if response was a client error (4xx status code)
+    pub fn is_client_error(&self) -> bool {
+        self.status_code >= 400 && self.status_code < 500
+    }
+
+    /// Check if response was a server error (5xx status code)
+    pub fn is_server_error(&self) -> bool {
+        self.status_code >= 500 && self.status_code < 600
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_test_client_config_default() {
+        let config = TestClientConfig::default();
+        assert_eq!(config.base_url, "http://localhost:3000");
+        assert_eq!(config.timeout_ms, 30000);
+        assert!(config.follow_redirects);
+    }
+
+    #[test]
+    fn test_test_client_config_new() {
+        let config = TestClientConfig::new("http://example.com:8080");
+        assert_eq!(config.base_url, "http://example.com:8080");
+        assert_eq!(config.timeout_ms, 30000);
+        assert!(config.follow_redirects);
+    }
+
+    #[test]
+    fn test_test_client_config_with_timeout() {
+        let config = TestClientConfig::default().with_timeout(5000);
+        assert_eq!(config.timeout_ms, 5000);
+    }
+
+    #[test]
+    fn test_test_client_config_with_follow_redirects_false() {
+        let config = TestClientConfig::default().with_follow_redirects(false);
+        assert!(!config.follow_redirects);
+    }
+
+    #[test]
+    fn test_test_client_config_chaining() {
+        let config = TestClientConfig::new("http://api.example.com")
+            .with_timeout(10000)
+            .with_follow_redirects(false);
+
+        assert_eq!(config.base_url, "http://api.example.com");
+        assert_eq!(config.timeout_ms, 10000);
+        assert!(!config.follow_redirects);
+    }
+
+    #[test]
+    fn test_response_metadata_new() {
+        let mut headers = HashMap::new();
+        headers.insert("Content-Type".to_string(), "application/json".to_string());
+
+        let metadata = TestResponseMetadata::new(200, headers.clone(), 256, 100);
+
+        assert_eq!(metadata.status_code, 200);
+        assert_eq!(metadata.headers, headers);
+        assert_eq!(metadata.body_size, 256);
+        assert_eq!(metadata.response_time_ms, 100);
+    }
+
+    #[test]
+    fn test_response_metadata_clone() {
+        let mut headers = HashMap::new();
+        headers.insert("Content-Type".to_string(), "application/json".to_string());
+
+        let metadata1 = TestResponseMetadata::new(201, headers, 512, 200);
+        let metadata2 = metadata1.clone();
+
+        assert_eq!(metadata1.status_code, metadata2.status_code);
+        assert_eq!(metadata1.body_size, metadata2.body_size);
+        assert_eq!(metadata1.response_time_ms, metadata2.response_time_ms);
+    }
+
+    #[test]
+    fn test_get_header_case_insensitive() {
+        let mut headers = HashMap::new();
+        headers.insert("Content-Type".to_string(), "application/json".to_string());
+        headers.insert("Authorization".to_string(), "Bearer token123".to_string());
+
+        let metadata = TestResponseMetadata::new(200, headers, 100, 50);
+
+        assert_eq!(
+            metadata.get_header("Content-Type"),
+            Some(&"application/json".to_string())
+        );
+        assert_eq!(
+            metadata.get_header("content-type"),
+            Some(&"application/json".to_string())
+        );
+        assert_eq!(
+            metadata.get_header("CONTENT-TYPE"),
+            Some(&"application/json".to_string())
+        );
+        assert_eq!(metadata.get_header("Missing"), None);
+    }
+
+    #[test]
+    fn test_is_success() {
+        let headers = HashMap::new();
+        let metadata_200 = TestResponseMetadata::new(200, headers.clone(), 100, 50);
+        let metadata_201 = TestResponseMetadata::new(201, headers.clone(), 100, 50);
+        let metadata_204 = TestResponseMetadata::new(204, headers.clone(), 0, 50);
+        let metadata_299 = TestResponseMetadata::new(299, headers.clone(), 100, 50);
+        let metadata_300 = TestResponseMetadata::new(300, headers.clone(), 100, 50);
+        let metadata_400 = TestResponseMetadata::new(400, headers.clone(), 100, 50);
+
+        assert!(metadata_200.is_success());
+        assert!(metadata_201.is_success());
+        assert!(metadata_204.is_success());
+        assert!(metadata_299.is_success());
+        assert!(!metadata_300.is_success());
+        assert!(!metadata_400.is_success());
+    }
+
+    #[test]
+    fn test_is_client_error() {
+        let headers = HashMap::new();
+        let metadata_399 = TestResponseMetadata::new(399, headers.clone(), 100, 50);
+        let metadata_400 = TestResponseMetadata::new(400, headers.clone(), 100, 50);
+        let metadata_404 = TestResponseMetadata::new(404, headers.clone(), 100, 50);
+        let metadata_499 = TestResponseMetadata::new(499, headers.clone(), 100, 50);
+        let metadata_500 = TestResponseMetadata::new(500, headers.clone(), 100, 50);
+
+        assert!(!metadata_399.is_client_error());
+        assert!(metadata_400.is_client_error());
+        assert!(metadata_404.is_client_error());
+        assert!(metadata_499.is_client_error());
+        assert!(!metadata_500.is_client_error());
+    }
+
+    #[test]
+    fn test_is_server_error() {
+        let headers = HashMap::new();
+        let metadata_499 = TestResponseMetadata::new(499, headers.clone(), 100, 50);
+        let metadata_500 = TestResponseMetadata::new(500, headers.clone(), 100, 50);
+        let metadata_502 = TestResponseMetadata::new(502, headers.clone(), 100, 50);
+        let metadata_599 = TestResponseMetadata::new(599, headers.clone(), 100, 50);
+        let metadata_600 = TestResponseMetadata::new(600, headers.clone(), 100, 50);
+
+        assert!(!metadata_499.is_server_error());
+        assert!(metadata_500.is_server_error());
+        assert!(metadata_502.is_server_error());
+        assert!(metadata_599.is_server_error());
+        assert!(!metadata_600.is_server_error());
+    }
+
+    #[test]
+    fn test_response_metadata_debug() {
+        let headers = HashMap::new();
+        let metadata = TestResponseMetadata::new(200, headers, 100, 50);
+        let debug_str = format!("{:?}", metadata);
+        assert!(debug_str.contains("200"));
+        assert!(debug_str.contains("100"));
+        assert!(debug_str.contains("50"));
+    }
+}