spikard 0.3.6 → 0.6.1

data/vendor/crates/spikard-bindings-shared/tests/error_response_edge_cases.rs

@@ -0,0 +1,383 @@
+//! Edge case tests for error_response module
+//!
+//! These tests cover serialization edge cases and ensure fallback
+//! behavior works correctly when serialization fails.
+
+use axum::http::StatusCode;
+use pretty_assertions::assert_eq;
+use serde_json::{Value, json};
+use spikard_bindings_shared::ErrorResponseBuilder;
+use spikard_core::errors::StructuredError;
+use spikard_core::problem::ProblemDetails;
+use spikard_core::validation::{ValidationError, ValidationErrorDetail};
+
+#[test]
+fn test_structured_error_with_empty_message() {
+    let (status, body) = ErrorResponseBuilder::structured_error(StatusCode::BAD_REQUEST, "empty_msg", "");
+    assert_eq!(status, StatusCode::BAD_REQUEST);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(parsed["error"], "");
+    assert_eq!(parsed["code"], "empty_msg");
+}
+
+#[test]
+fn test_structured_error_with_unicode() {
+    let (status, body) = ErrorResponseBuilder::structured_error(
+        StatusCode::BAD_REQUEST,
+        "unicode_test",
+        "Error with emoji: 😀 and special chars: 中文",
+    );
+    assert_eq!(status, StatusCode::BAD_REQUEST);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert!(parsed["error"].as_str().unwrap().contains("😀"));
+    assert!(parsed["error"].as_str().unwrap().contains("中文"));
+}
+
+#[test]
+fn test_with_details_empty_details() {
+    let (status, body) =
+        ErrorResponseBuilder::with_details(StatusCode::NOT_FOUND, "not_found", "Resource not found", json!({}));
+    assert_eq!(status, StatusCode::NOT_FOUND);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(parsed["code"], "not_found");
+    assert!(parsed["details"].is_object());
+    assert_eq!(parsed["details"].as_object().unwrap().len(), 0);
+}
+
+#[test]
+fn test_with_details_nested_objects() {
+    let details = json!({
+        "level1": {
+            "level2": {
+                "level3": {
+                    "message": "deeply nested"
+                }
+            }
+        }
+    });
+
+    let (status, body) = ErrorResponseBuilder::with_details(
+        StatusCode::INTERNAL_SERVER_ERROR,
+        "nested_error",
+        "Error with nested details",
+        details.clone(),
+    );
+
+    assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(
+        parsed["details"]["level1"]["level2"]["level3"]["message"],
+        "deeply nested"
+    );
+}
+
+#[test]
+fn test_with_details_array_values() {
+    let details = json!({
+        "errors": ["error1", "error2", "error3"],
+        "codes": [400, 401, 403]
+    });
+
+    let (status, body) = ErrorResponseBuilder::with_details(
+        StatusCode::BAD_REQUEST,
+        "multiple_errors",
+        "Multiple validation errors",
+        details,
+    );
+
+    assert_eq!(status, StatusCode::BAD_REQUEST);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(parsed["details"]["errors"][0], "error1");
+    assert_eq!(parsed["details"]["codes"][2], 403);
+}
+
+#[test]
+fn test_from_structured_error_with_details() {
+    let error = StructuredError::new(
+        "custom_error".to_string(),
+        "Custom error occurred".to_string(),
+        json!({"field": "username", "reason": "already_exists"}),
+    );
+
+    let (status, body) = ErrorResponseBuilder::from_structured_error(error);
+    assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(parsed["code"], "custom_error");
+    assert_eq!(parsed["error"], "Custom error occurred");
+    assert_eq!(parsed["details"]["field"], "username");
+}
+
+#[test]
+fn test_validation_error_multiple_errors() {
+    let validation_error = ValidationError {
+        errors: vec![
+            ValidationErrorDetail {
+                error_type: "missing".to_string(),
+                loc: vec!["body".to_string(), "username".to_string()],
+                msg: "Field required".to_string(),
+                input: Value::Null,
+                ctx: None,
+            },
+            ValidationErrorDetail {
+                error_type: "type_error".to_string(),
+                loc: vec!["body".to_string(), "age".to_string()],
+                msg: "Value must be a number".to_string(),
+                input: Value::String("abc".to_string()),
+                ctx: None,
+            },
+            ValidationErrorDetail {
+                error_type: "value_error".to_string(),
+                loc: vec!["body".to_string(), "email".to_string()],
+                msg: "Invalid email format".to_string(),
+                input: Value::String("not-an-email".to_string()),
+                ctx: None,
+            },
+        ],
+    };
+
+    let (status, body) = ErrorResponseBuilder::validation_error(&validation_error);
+    assert_eq!(status, StatusCode::UNPROCESSABLE_ENTITY);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(parsed["status"], 422);
+    assert_eq!(parsed["errors"].as_array().unwrap().len(), 3);
+}
+
+#[test]
+fn test_validation_error_with_context() {
+    let validation_error = ValidationError {
+        errors: vec![ValidationErrorDetail {
+            error_type: "value_error".to_string(),
+            loc: vec!["query".to_string(), "page".to_string()],
+            msg: "Value must be greater than 0".to_string(),
+            input: json!(0),
+            ctx: Some(json!({"min": 1, "max": 100})),
+        }],
+    };
+
+    let (status, body) = ErrorResponseBuilder::validation_error(&validation_error);
+    assert_eq!(status, StatusCode::UNPROCESSABLE_ENTITY);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert!(parsed["errors"].is_array());
+    assert_eq!(parsed["errors"][0]["type"], "value_error");
+}
+
+#[test]
+fn test_problem_details_with_instance() {
+    let mut problem = ProblemDetails::not_found("User not found");
+    problem.instance = Some("/users/12345".to_string());
+
+    let (status, body) = ErrorResponseBuilder::problem_details_response(&problem);
+    assert_eq!(status, StatusCode::NOT_FOUND);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(parsed["instance"], "/users/12345");
+}
+
+#[test]
+fn test_problem_details_with_extensions() {
+    let mut problem = ProblemDetails::internal_server_error("Database connection failed");
+    problem.extensions.insert("retry_after".to_string(), json!(30));
+    problem.extensions.insert("error_id".to_string(), json!("ERR-2024-001"));
+
+    let (status, body) = ErrorResponseBuilder::problem_details_response(&problem);
+    assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(parsed["retry_after"], 30);
+    assert_eq!(parsed["error_id"], "ERR-2024-001");
+}
+
+#[test]
+fn test_all_convenience_methods_return_valid_json() {
+    let test_cases = vec![
+        ErrorResponseBuilder::bad_request("Bad request"),
+        ErrorResponseBuilder::internal_error("Internal error"),
+        ErrorResponseBuilder::unauthorized("Unauthorized"),
+        ErrorResponseBuilder::forbidden("Forbidden"),
+        ErrorResponseBuilder::not_found("Not found"),
+        ErrorResponseBuilder::method_not_allowed("Method not allowed"),
+        ErrorResponseBuilder::unprocessable_entity("Unprocessable entity"),
+        ErrorResponseBuilder::conflict("Conflict"),
+        ErrorResponseBuilder::service_unavailable("Service unavailable"),
+        ErrorResponseBuilder::request_timeout("Request timeout"),
+    ];
+
+    for (status, body) in test_cases {
+        let parsed: Value = serde_json::from_str(&body)
+            .unwrap_or_else(|_| panic!("Failed to parse JSON for status {}: {}", status, body));
+
+        assert!(
+            parsed.get("error").is_some(),
+            "Missing 'error' field for status {}",
+            status
+        );
+        assert!(
+            parsed.get("code").is_some(),
+            "Missing 'code' field for status {}",
+            status
+        );
+        assert!(
+            parsed.get("details").is_some(),
+            "Missing 'details' field for status {}",
+            status
+        );
+    }
+}
+
+#[test]
+fn test_error_response_status_code_mapping() {
+    assert_eq!(ErrorResponseBuilder::bad_request("msg").0, StatusCode::BAD_REQUEST);
+    assert_eq!(
+        ErrorResponseBuilder::internal_error("msg").0,
+        StatusCode::INTERNAL_SERVER_ERROR
+    );
+    assert_eq!(ErrorResponseBuilder::unauthorized("msg").0, StatusCode::UNAUTHORIZED);
+    assert_eq!(ErrorResponseBuilder::forbidden("msg").0, StatusCode::FORBIDDEN);
+    assert_eq!(ErrorResponseBuilder::not_found("msg").0, StatusCode::NOT_FOUND);
+    assert_eq!(
+        ErrorResponseBuilder::method_not_allowed("msg").0,
+        StatusCode::METHOD_NOT_ALLOWED
+    );
+    assert_eq!(
+        ErrorResponseBuilder::unprocessable_entity("msg").0,
+        StatusCode::UNPROCESSABLE_ENTITY
+    );
+    assert_eq!(ErrorResponseBuilder::conflict("msg").0, StatusCode::CONFLICT);
+    assert_eq!(
+        ErrorResponseBuilder::service_unavailable("msg").0,
+        StatusCode::SERVICE_UNAVAILABLE
+    );
+    assert_eq!(
+        ErrorResponseBuilder::request_timeout("msg").0,
+        StatusCode::REQUEST_TIMEOUT
+    );
+}
+
+#[test]
+fn test_structured_error_with_special_characters() {
+    let message = r#"Error with quotes: "test" and backslashes: \\ and newlines:
+line1
+line2"#;
+
+    let (status, body) = ErrorResponseBuilder::structured_error(StatusCode::BAD_REQUEST, "special_chars", message);
+    assert_eq!(status, StatusCode::BAD_REQUEST);
+
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert!(parsed["error"].as_str().unwrap().contains("quotes"));
+    assert!(parsed["error"].as_str().unwrap().contains("backslashes"));
+    assert!(parsed["error"].as_str().unwrap().contains("newlines"));
+}
+
+#[test]
+fn test_with_details_null_values() {
+    let details = json!({
+        "field1": null,
+        "field2": "value",
+        "field3": null
+    });
+
+    let (status, body) =
+        ErrorResponseBuilder::with_details(StatusCode::BAD_REQUEST, "null_test", "Testing null values", details);
+
+    assert_eq!(status, StatusCode::BAD_REQUEST);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert!(parsed["details"]["field1"].is_null());
+    assert_eq!(parsed["details"]["field2"], "value");
+    assert!(parsed["details"]["field3"].is_null());
+}
+
+#[test]
+fn test_validation_error_empty_location() {
+    let validation_error = ValidationError {
+        errors: vec![ValidationErrorDetail {
+            error_type: "missing".to_string(),
+            loc: vec![],
+            msg: "Field required".to_string(),
+            input: Value::Null,
+            ctx: None,
+        }],
+    };
+
+    let (status, body) = ErrorResponseBuilder::validation_error(&validation_error);
+    assert_eq!(status, StatusCode::UNPROCESSABLE_ENTITY);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert!(parsed["errors"][0]["loc"].is_array());
+}
+
+#[test]
+fn test_problem_details_all_standard_types() {
+    let test_cases = vec![
+        (ProblemDetails::bad_request("Bad request"), StatusCode::BAD_REQUEST),
+        (ProblemDetails::not_found("Not found"), StatusCode::NOT_FOUND),
+        (
+            ProblemDetails::method_not_allowed("Method not allowed"),
+            StatusCode::METHOD_NOT_ALLOWED,
+        ),
+        (
+            ProblemDetails::internal_server_error("Internal error"),
+            StatusCode::INTERNAL_SERVER_ERROR,
+        ),
+    ];
+
+    for (problem, expected_status) in test_cases {
+        let (status, body) = ErrorResponseBuilder::problem_details_response(&problem);
+        assert_eq!(status, expected_status);
+
+        let parsed: Value = serde_json::from_str(&body).unwrap();
+        assert_eq!(parsed["status"], expected_status.as_u16());
+        assert!(parsed.get("type").is_some());
+        assert!(parsed.get("title").is_some());
+    }
+}
+
+#[test]
+fn test_error_message_types() {
+    let (_, body) = ErrorResponseBuilder::bad_request("test".to_string());
+    assert!(body.contains("test"));
+
+    let (_, body) = ErrorResponseBuilder::bad_request("test");
+    assert!(body.contains("test"));
+
+    let (_, body) = ErrorResponseBuilder::bad_request(format!("Error: {}", 123));
+    assert!(body.contains("Error: 123"));
+}
+
+#[test]
+fn test_with_details_boolean_values() {
+    let details = json!({
+        "is_active": true,
+        "is_admin": false,
+        "has_permission": true
+    });
+
+    let (status, body) =
+        ErrorResponseBuilder::with_details(StatusCode::FORBIDDEN, "permission_error", "Permission denied", details);
+
+    assert_eq!(status, StatusCode::FORBIDDEN);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(parsed["details"]["is_active"], true);
+    assert_eq!(parsed["details"]["is_admin"], false);
+    assert_eq!(parsed["details"]["has_permission"], true);
+}
+
+#[test]
+fn test_with_details_numeric_values() {
+    let details = json!({
+        "integer": 42,
+        "float": 3.2,
+        "negative": -100,
+        "zero": 0
+    });
+
+    let (status, body) = ErrorResponseBuilder::with_details(
+        StatusCode::BAD_REQUEST,
+        "numeric_test",
+        "Numeric validation failed",
+        details,
+    );
+
+    assert_eq!(status, StatusCode::BAD_REQUEST);
+    let parsed: Value = serde_json::from_str(&body).unwrap();
+    assert_eq!(parsed["details"]["integer"], 42);
+    assert_eq!(parsed["details"]["float"], 3.2);
+    assert_eq!(parsed["details"]["negative"], -100);
+    assert_eq!(parsed["details"]["zero"], 0);
+}

data/vendor/crates/spikard-bindings-shared/tests/handler_base_integration.rs

@@ -0,0 +1,280 @@
+//! Integration tests for handler_base module
+//!
+//! These tests cover the validation paths and error handling that aren't
+//! covered by unit tests in the module itself.
+
+use axum::body::Body;
+use axum::http::Request;
+use serde_json::json;
+use spikard_bindings_shared::handler_base::{HandlerError, HandlerExecutor, LanguageHandler};
+use spikard_core::validation::{SchemaValidator, ValidationError, ValidationErrorDetail};
+use spikard_http::handler_trait::{Handler, RequestData};
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+
+struct MockHandler {
+    should_fail_prepare: bool,
+    should_fail_invoke: bool,
+    should_fail_interpret: bool,
+}
+
+impl LanguageHandler for MockHandler {
+    type Input = String;
+    type Output = String;
+
+    fn prepare_request(&self, _data: &RequestData) -> Result<Self::Input, HandlerError> {
+        if self.should_fail_prepare {
+            Err(HandlerError::Internal("Prepare failed".to_string()))
+        } else {
+            Ok("prepared".to_string())
+        }
+    }
+
+    fn invoke_handler(
+        &self,
+        input: Self::Input,
+    ) -> Pin<Box<dyn Future<Output = Result<Self::Output, HandlerError>> + Send + '_>> {
+        let should_fail = self.should_fail_invoke;
+        Box::pin(async move {
+            if should_fail {
+                Err(HandlerError::Execution("Handler failed".to_string()))
+            } else {
+                Ok(format!("output:{}", input))
+            }
+        })
+    }
+
+    fn interpret_response(&self, output: Self::Output) -> Result<axum::http::Response<Body>, HandlerError> {
+        if self.should_fail_interpret {
+            Err(HandlerError::ResponseConversion("Interpret failed".to_string()))
+        } else {
+            Ok(axum::http::Response::builder()
+                .status(200)
+                .body(Body::from(output))
+                .unwrap())
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_handler_executor_with_validation_error() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "username": {"type": "string"},
+            "age": {"type": "number"}
+        },
+        "required": ["username", "age"]
+    });
+    let validator = Arc::new(SchemaValidator::new(schema).unwrap());
+
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+
+    let executor = HandlerExecutor::new(handler, Some(validator));
+
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        validated_params: None,
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({"username": "john"}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "POST".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn test_handler_executor_prepare_failure() {
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: true,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+
+    let executor = HandlerExecutor::with_handler(handler);
+
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        validated_params: None,
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn test_handler_executor_invoke_failure() {
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: true,
+        should_fail_interpret: false,
+    });
+
+    let executor = HandlerExecutor::with_handler(handler);
+
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        validated_params: None,
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn test_handler_executor_interpret_failure() {
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: true,
+    });
+
+    let executor = HandlerExecutor::with_handler(handler);
+
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        validated_params: None,
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn test_handler_executor_with_request_validator() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"}
+        },
+        "required": ["name"]
+    });
+    let request_validator = Arc::new(SchemaValidator::new(schema).unwrap());
+
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+
+    let executor = HandlerExecutor::new(handler, Some(request_validator));
+
+    let request = Request::builder().body(Body::empty()).unwrap();
+
+    let mut headers = HashMap::new();
+    headers.insert("x-api-key".to_string(), "test-key".to_string());
+
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        validated_params: None,
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({"name": "test"}),
+        raw_body: None,
+        headers: Arc::new(headers),
+        cookies: Arc::new(HashMap::new()),
+        method: "POST".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_handler_error_from_validation_error() {
+    let validation_error = ValidationError {
+        errors: vec![ValidationErrorDetail {
+            error_type: "missing".to_string(),
+            loc: vec!["body".to_string(), "field".to_string()],
+            msg: "Field required".to_string(),
+            input: json!(null),
+            ctx: None,
+        }],
+    };
+
+    let handler_error: HandlerError = validation_error.into();
+    assert!(matches!(handler_error, HandlerError::Validation(_)));
+}
+
+#[tokio::test]
+async fn test_handler_executor_builder_pattern() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "email": {"type": "string", "format": "email"}
+        }
+    });
+    let request_validator = Arc::new(SchemaValidator::new(schema).unwrap());
+
+    let handler = Arc::new(MockHandler {
+        should_fail_prepare: false,
+        should_fail_invoke: false,
+        should_fail_interpret: false,
+    });
+
+    let executor = HandlerExecutor::with_handler(handler).with_request_validator(request_validator);
+
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: json!({}),
+        validated_params: None,
+        raw_query_params: Arc::new(HashMap::new()),
+        body: json!({"email": "test@example.com"}),
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "POST".to_string(),
+        path: "/test".to_string(),
+        dependencies: None,
+    };
+
+    let result = executor.call(request, request_data).await;
+    assert!(result.is_ok());
+}