spikard 0.13.0 → 0.15.2

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

@@ -1,260 +0,0 @@
-//! 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
-    #[must_use]
-    pub const fn with_timeout(mut self, timeout_ms: u64) -> Self {
-        self.timeout_ms = timeout_ms;
-        self
-    }
-
-    /// Set whether to follow redirects
-    #[must_use]
-    pub const 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
-    #[must_use]
-    pub const 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)
-    #[must_use]
-    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)
-    #[must_use]
-    pub const fn is_success(&self) -> bool {
-        self.status_code >= 200 && self.status_code < 300
-    }
-
-    /// Check if response was a client error (4xx status code)
-    #[must_use]
-    pub const fn is_client_error(&self) -> bool {
-        self.status_code >= 400 && self.status_code < 500
-    }
-
-    /// Check if response was a server error (5xx status code)
-    #[must_use]
-    pub const 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, 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, 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, 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"));
-    }
-}

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

@@ -1,369 +0,0 @@
-//! Shared validation utilities
-
-use serde_json::Value;
-
-/// Helper for validating request headers
-pub struct HeaderValidator;
-
-impl HeaderValidator {
-    /// Validate that required headers are present
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if required headers are missing.
-    pub fn validate_required(headers: &[(String, String)], required: &[&str]) -> Result<(), String> {
-        let header_names: std::collections::HashSet<_> = headers.iter().map(|(k, _)| k.to_lowercase()).collect();
-
-        for req in required {
-            if !header_names.contains(&req.to_lowercase()) {
-                return Err(format!("Missing required header: {req}"));
-            }
-        }
-        Ok(())
-    }
-
-    /// Validate header format
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the header format is invalid.
-    pub fn validate_format(key: &str, value: &str, format: HeaderFormat) -> Result<(), String> {
-        match format {
-            HeaderFormat::Bearer => {
-                if !value.starts_with("Bearer ") {
-                    return Err(format!("{key}: must start with 'Bearer '"));
-                }
-                Ok(())
-            }
-            HeaderFormat::Json => {
-                if !value.starts_with("application/json") {
-                    return Err(format!("{key}: must be 'application/json'"));
-                }
-                Ok(())
-            }
-        }
-    }
-}
-
-/// Header validation formats
-#[derive(Copy, Clone)]
-pub enum HeaderFormat {
-    /// Bearer token format
-    Bearer,
-    /// JSON content type
-    Json,
-}
-
-/// Helper for validating request bodies
-pub struct BodyValidator;
-
-impl BodyValidator {
-    /// Validate that required fields are present in a JSON object
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if required fields are missing.
-    pub fn validate_required_fields(body: &Value, required: &[&str]) -> Result<(), String> {
-        let obj = body
-            .as_object()
-            .ok_or_else(|| "Body must be a JSON object".to_string())?;
-
-        for field in required {
-            if !obj.contains_key(*field) {
-                return Err(format!("Missing required field: {field}"));
-            }
-        }
-        Ok(())
-    }
-
-    /// Validate field type
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the field type doesn't match.
-    pub fn validate_field_type(body: &Value, field: &str, expected_type: FieldType) -> Result<(), String> {
-        let obj = body
-            .as_object()
-            .ok_or_else(|| "Body must be a JSON object".to_string())?;
-
-        let value = obj.get(field).ok_or_else(|| format!("Field not found: {field}"))?;
-
-        match expected_type {
-            FieldType::String => {
-                if !value.is_string() {
-                    return Err(format!("{field}: expected string"));
-                }
-            }
-            FieldType::Number => {
-                if !value.is_number() {
-                    return Err(format!("{field}: expected number"));
-                }
-            }
-            FieldType::Boolean => {
-                if !value.is_boolean() {
-                    return Err(format!("{field}: expected boolean"));
-                }
-            }
-            FieldType::Object => {
-                if !value.is_object() {
-                    return Err(format!("{field}: expected object"));
-                }
-            }
-            FieldType::Array => {
-                if !value.is_array() {
-                    return Err(format!("{field}: expected array"));
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
-/// Field types for validation
-#[derive(Copy, Clone)]
-pub enum FieldType {
-    String,
-    Number,
-    Boolean,
-    Object,
-    Array,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_header_validation() {
-        let headers = vec![
-            ("Content-Type".to_string(), "application/json".to_string()),
-            ("Authorization".to_string(), "Bearer token123".to_string()),
-        ];
-
-        assert!(HeaderValidator::validate_required(&headers, &["Content-Type"]).is_ok());
-        assert!(HeaderValidator::validate_required(&headers, &["Missing"]).is_err());
-    }
-
-    #[test]
-    fn test_body_validation() {
-        let body = serde_json::json!({
-            "name": "test",
-            "age": 25
-        });
-
-        assert!(BodyValidator::validate_required_fields(&body, &["name"]).is_ok());
-        assert!(BodyValidator::validate_required_fields(&body, &["missing"]).is_err());
-    }
-
-    #[test]
-    fn test_field_type_validation() {
-        let body = serde_json::json!({
-            "name": "test",
-            "age": 25
-        });
-
-        assert!(BodyValidator::validate_field_type(&body, "name", FieldType::String).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "age", FieldType::Number).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "name", FieldType::Number).is_err());
-    }
-
-    #[test]
-    fn test_header_validator_case_insensitive() {
-        let headers = vec![
-            ("content-type".to_string(), "application/json".to_string()),
-            ("authorization".to_string(), "Bearer token123".to_string()),
-        ];
-
-        assert!(HeaderValidator::validate_required(&headers, &["Content-Type"]).is_ok());
-        assert!(HeaderValidator::validate_required(&headers, &["AUTHORIZATION"]).is_ok());
-        assert!(HeaderValidator::validate_required(&headers, &["X-Custom"]).is_err());
-    }
-
-    #[test]
-    fn test_header_validator_multiple_required() {
-        let headers = vec![
-            ("Content-Type".to_string(), "application/json".to_string()),
-            ("Authorization".to_string(), "Bearer token".to_string()),
-            ("X-Request-Id".to_string(), "123".to_string()),
-        ];
-
-        assert!(
-            HeaderValidator::validate_required(&headers, &["Content-Type", "Authorization", "X-Request-Id"]).is_ok()
-        );
-        assert!(HeaderValidator::validate_required(&headers, &["Content-Type", "Authorization", "Missing"]).is_err());
-    }
-
-    #[test]
-    fn test_header_validator_empty_headers() {
-        let headers: Vec<(String, String)> = vec![];
-
-        assert!(HeaderValidator::validate_required(&headers, &[]).is_ok());
-        assert!(HeaderValidator::validate_required(&headers, &["Any"]).is_err());
-    }
-
-    #[test]
-    fn test_header_format_bearer() {
-        assert!(HeaderValidator::validate_format("Authorization", "Bearer token123", HeaderFormat::Bearer).is_ok());
-        assert!(HeaderValidator::validate_format("Authorization", "token123", HeaderFormat::Bearer).is_err());
-        assert!(HeaderValidator::validate_format("Authorization", "Basic dXNlcjpwYXNz", HeaderFormat::Bearer).is_err());
-    }
-
-    #[test]
-    fn test_header_format_json() {
-        assert!(HeaderValidator::validate_format("Content-Type", "application/json", HeaderFormat::Json).is_ok());
-        assert!(
-            HeaderValidator::validate_format("Content-Type", "application/json; charset=utf-8", HeaderFormat::Json)
-                .is_ok()
-        );
-        assert!(HeaderValidator::validate_format("Content-Type", "text/plain", HeaderFormat::Json).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_required_fields_empty_body() {
-        let body = serde_json::json!({});
-
-        assert!(BodyValidator::validate_required_fields(&body, &[]).is_ok());
-        assert!(BodyValidator::validate_required_fields(&body, &["name"]).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_required_fields_multiple() {
-        let body = serde_json::json!({
-            "name": "John",
-            "email": "john@example.com",
-            "age": 30
-        });
-
-        assert!(BodyValidator::validate_required_fields(&body, &["name", "email", "age"]).is_ok());
-        assert!(BodyValidator::validate_required_fields(&body, &["name", "missing"]).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_not_json_object() {
-        let body = serde_json::json!([1, 2, 3]);
-
-        assert!(BodyValidator::validate_required_fields(&body, &["field"]).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_field_type_string() {
-        let body = serde_json::json!({
-            "name": "test",
-            "id": 123
-        });
-
-        assert!(BodyValidator::validate_field_type(&body, "name", FieldType::String).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "id", FieldType::String).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_field_type_number() {
-        let body = serde_json::json!({
-            "age": 25,
-            "name": "test"
-        });
-
-        assert!(BodyValidator::validate_field_type(&body, "age", FieldType::Number).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "name", FieldType::Number).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_field_type_boolean() {
-        let body = serde_json::json!({
-            "active": true,
-            "name": "test"
-        });
-
-        assert!(BodyValidator::validate_field_type(&body, "active", FieldType::Boolean).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "name", FieldType::Boolean).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_field_type_object() {
-        let body = serde_json::json!({
-            "metadata": { "key": "value" },
-            "name": "test"
-        });
-
-        assert!(BodyValidator::validate_field_type(&body, "metadata", FieldType::Object).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "name", FieldType::Object).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_field_type_array() {
-        let body = serde_json::json!({
-            "items": [1, 2, 3],
-            "name": "test"
-        });
-
-        assert!(BodyValidator::validate_field_type(&body, "items", FieldType::Array).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "name", FieldType::Array).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_field_not_found() {
-        let body = serde_json::json!({
-            "name": "test"
-        });
-
-        assert!(BodyValidator::validate_field_type(&body, "missing", FieldType::String).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_body_not_object() {
-        let body = serde_json::json!("string");
-
-        assert!(BodyValidator::validate_field_type(&body, "field", FieldType::String).is_err());
-    }
-
-    #[test]
-    fn test_body_validator_null_field() {
-        let body = serde_json::json!({
-            "value": null
-        });
-
-        assert!(BodyValidator::validate_field_type(&body, "value", FieldType::String).is_err());
-    }
-
-    #[test]
-    fn test_complex_validation_flow() {
-        let headers = vec![
-            ("Content-Type".to_string(), "application/json".to_string()),
-            ("Authorization".to_string(), "Bearer token".to_string()),
-        ];
-
-        let body = serde_json::json!({
-            "username": "john_doe",
-            "password": "secret123",
-            "roles": ["admin", "user"],
-            "preferences": {
-                "theme": "dark"
-            }
-        });
-
-        assert!(HeaderValidator::validate_required(&headers, &["Content-Type", "Authorization"]).is_ok());
-
-        assert!(BodyValidator::validate_required_fields(&body, &["username", "password"]).is_ok());
-
-        assert!(BodyValidator::validate_field_type(&body, "username", FieldType::String).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "roles", FieldType::Array).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "preferences", FieldType::Object).is_ok());
-    }
-
-    #[test]
-    fn test_field_type_all_variants() {
-        let body = serde_json::json!({
-            "string_field": "text",
-            "number_field": 42,
-            "boolean_field": true,
-            "object_field": { "nested": "value" },
-            "array_field": [1, 2, 3]
-        });
-
-        assert!(BodyValidator::validate_field_type(&body, "string_field", FieldType::String).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "number_field", FieldType::Number).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "boolean_field", FieldType::Boolean).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "object_field", FieldType::Object).is_ok());
-        assert!(BodyValidator::validate_field_type(&body, "array_field", FieldType::Array).is_ok());
-    }
-}