spikard 0.6.2 → 0.7.2

data/vendor/crates/spikard-core/tests/parameters_schema_and_formats.rs

@@ -0,0 +1,301 @@
+use serde_json::json;
+use spikard_core::parameters::ParameterValidator;
+use std::collections::HashMap;
+
+#[test]
+fn parameter_validator_rejects_missing_source() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "q": {"type": "string"}
+        }
+    });
+
+    let err = ParameterValidator::new(schema).expect_err("missing source should fail");
+    assert!(err.contains("missing required 'source' field"), "err: {err}");
+}
+
+#[test]
+fn parameter_validator_rejects_invalid_source() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "q": {"type": "string", "source": "bogus"}
+        }
+    });
+
+    let err = ParameterValidator::new(schema).expect_err("invalid source should fail");
+    assert!(err.contains("Invalid source"), "err: {err}");
+}
+
+#[test]
+fn optional_field_overrides_required_list() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "q": {"type": "string", "source": "query", "optional": true}
+        },
+        "required": ["q"]
+    });
+
+    let validator = ParameterValidator::new(schema).expect("validator");
+    let extracted = validator
+        .validate_and_extract(
+            &json!({}),
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+        )
+        .expect("optional required field should not fail");
+
+    assert_eq!(extracted, json!({}));
+}
+
+#[test]
+fn invalid_uuid_format_yields_uuid_parsing_error() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "id": {"type": "string", "format": "uuid", "source": "path"}
+        },
+        "required": ["id"]
+    });
+
+    let validator = ParameterValidator::new(schema).expect("validator");
+
+    let mut path_params = HashMap::new();
+    path_params.insert("id".to_string(), "g".to_string());
+
+    let err = validator
+        .validate_and_extract(
+            &json!({}),
+            &HashMap::new(),
+            &path_params,
+            &HashMap::new(),
+            &HashMap::new(),
+        )
+        .expect_err("invalid uuid should fail");
+
+    assert_eq!(err.errors.len(), 1);
+    assert_eq!(err.errors[0].error_type, "uuid_parsing");
+}
+
+#[test]
+fn invalid_duration_format_yields_duration_parsing_error() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "d": {"type": "string", "format": "duration", "source": "query"}
+        },
+        "required": ["d"]
+    });
+
+    let validator = ParameterValidator::new(schema).expect("validator");
+
+    let mut raw_query = HashMap::new();
+    raw_query.insert("d".to_string(), vec!["not-a-duration".to_string()]);
+
+    let err = validator
+        .validate_and_extract(
+            &json!({}),
+            &raw_query,
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+        )
+        .expect_err("invalid duration should fail");
+
+    assert_eq!(err.errors.len(), 1);
+    assert_eq!(err.errors[0].error_type, "duration_parsing");
+}
+
+#[test]
+fn invalid_time_without_timezone_is_rejected() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "t": {"type": "string", "format": "time", "source": "query"}
+        },
+        "required": ["t"]
+    });
+
+    let validator = ParameterValidator::new(schema).expect("validator");
+
+    let mut raw_query = HashMap::new();
+    raw_query.insert("t".to_string(), vec!["10:30:00".to_string()]);
+
+    let err = validator
+        .validate_and_extract(
+            &json!({}),
+            &raw_query,
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+        )
+        .expect_err("time without timezone should fail");
+
+    assert_eq!(err.errors.len(), 1);
+    assert_eq!(err.errors[0].error_type, "time_parsing");
+}
+
+#[test]
+fn required_header_uses_hyphenated_name_in_error_location() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "x_api_key": {"type": "string", "source": "header"}
+        },
+        "required": ["x_api_key"]
+    });
+
+    let validator = ParameterValidator::new(schema).expect("validator");
+    let err = validator
+        .validate_and_extract(
+            &json!({}),
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+        )
+        .expect_err("missing header should fail");
+
+    assert_eq!(err.errors.len(), 1);
+    assert_eq!(err.errors[0].error_type, "missing");
+    assert_eq!(err.errors[0].loc, vec!["headers".to_string(), "x-api-key".to_string()]);
+}
+
+#[test]
+fn required_cookie_is_reported_under_cookie_location() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "session_id": {"type": "string", "source": "cookie"}
+        },
+        "required": ["session_id"]
+    });
+
+    let validator = ParameterValidator::new(schema).expect("validator");
+    let err = validator
+        .validate_and_extract(
+            &json!({}),
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+        )
+        .expect_err("missing cookie should fail");
+
+    assert_eq!(err.errors.len(), 1);
+    assert_eq!(err.errors[0].error_type, "missing");
+    assert_eq!(err.errors[0].loc, vec!["cookie".to_string(), "session_id".to_string()]);
+}
+
+#[test]
+fn boolean_empty_string_is_coerced_to_false() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "flag": {"type": "boolean", "source": "query"}
+        },
+        "required": ["flag"]
+    });
+
+    let validator = ParameterValidator::new(schema).expect("validator");
+    let mut raw_query = HashMap::new();
+    raw_query.insert("flag".to_string(), vec!["".to_string()]);
+
+    let extracted = validator
+        .validate_and_extract(
+            &json!({}),
+            &raw_query,
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+        )
+        .expect("empty boolean string should coerce to false");
+
+    assert_eq!(extracted, json!({"flag": false}));
+}
+
+#[test]
+fn array_query_coercion_reports_item_errors() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "ids": {"type": "array", "items": {"type": "integer"}, "source": "query"}
+        },
+        "required": ["ids"]
+    });
+
+    let validator = ParameterValidator::new(schema).expect("validator");
+    let mut raw_query = HashMap::new();
+    raw_query.insert("ids".to_string(), vec!["1".to_string(), "x".to_string()]);
+
+    let err = validator
+        .validate_and_extract(
+            &json!({"ids": ["1", "x"]}),
+            &raw_query,
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+        )
+        .expect_err("invalid array item should fail");
+
+    assert_eq!(err.errors.len(), 1);
+    assert_eq!(err.errors[0].error_type, "int_parsing");
+    assert_eq!(err.errors[0].loc, vec!["query".to_string(), "ids".to_string()]);
+}
+
+#[test]
+fn array_query_coercion_preserves_non_string_items() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "ids": {"type": "array", "items": {"type": "integer"}, "source": "query"}
+        }
+    });
+
+    let validator = ParameterValidator::new(schema).expect("validator");
+
+    let extracted = validator
+        .validate_and_extract(
+            &json!({"ids": [1, "2"]}),
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+        )
+        .expect("mixed array should coerce string items and preserve non-strings");
+
+    assert_eq!(extracted["ids"], json!([1, 2]));
+}
+
+#[test]
+fn invalid_time_with_out_of_range_offset_is_rejected() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "t": {"type": "string", "format": "time", "source": "query"}
+        },
+        "required": ["t"]
+    });
+
+    let validator = ParameterValidator::new(schema).expect("validator");
+
+    let mut raw_query = HashMap::new();
+    raw_query.insert("t".to_string(), vec!["10:30:00+24:00".to_string()]);
+
+    let err = validator
+        .validate_and_extract(
+            &json!({}),
+            &raw_query,
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+        )
+        .expect_err("time offset out of range should fail");
+
+    assert_eq!(err.errors.len(), 1);
+    assert_eq!(err.errors[0].error_type, "time_parsing");
+}

data/vendor/crates/spikard-core/tests/request_data_roundtrip.rs

@@ -0,0 +1,67 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use serde_json::json;
+use spikard_core::request_data::RequestData;
+
+fn make_request_data() -> RequestData {
+    RequestData {
+        path_params: Arc::new(HashMap::from([("id".to_string(), "42".to_string())])),
+        query_params: json!({"page": 3, "filter": "active"}),
+        validated_params: None,
+        raw_query_params: Arc::new(HashMap::from([
+            ("page".to_string(), vec!["3".to_string()]),
+            ("filter".to_string(), vec!["active".to_string()]),
+        ])),
+        body: json!({"name": "spikard", "active": true}),
+        #[cfg(feature = "di")]
+        raw_body: Some(bytes::Bytes::from_static(b"{\"name\":\"spikard\",\"active\":true}")),
+        #[cfg(not(feature = "di"))]
+        raw_body: Some(b"{\"name\":\"spikard\",\"active\":true}".to_vec()),
+        headers: Arc::new(HashMap::from([
+            ("content-type".to_string(), "application/json".to_string()),
+            ("x-request-id".to_string(), "req-123".to_string()),
+        ])),
+        cookies: Arc::new(HashMap::from([("session".to_string(), "abc123".to_string())])),
+        method: "POST".to_string(),
+        path: "/widgets/42".to_string(),
+        #[cfg(feature = "di")]
+        dependencies: None,
+    }
+}
+
+#[test]
+fn request_data_serialization_roundtrip() {
+    let original = make_request_data();
+
+    let json = serde_json::to_string(&original).expect("serialize");
+    let decoded: RequestData = serde_json::from_str(&json).expect("deserialize");
+
+    assert_eq!(original.path_params.as_ref(), decoded.path_params.as_ref());
+    assert_eq!(original.query_params, decoded.query_params);
+    assert_eq!(original.raw_query_params.as_ref(), decoded.raw_query_params.as_ref());
+    assert_eq!(original.body, decoded.body);
+    assert_eq!(original.raw_body, decoded.raw_body);
+    assert_eq!(original.headers.as_ref(), decoded.headers.as_ref());
+    assert_eq!(original.cookies.as_ref(), decoded.cookies.as_ref());
+    assert_eq!(original.method, decoded.method);
+    assert_eq!(original.path, decoded.path);
+}
+
+#[test]
+fn request_data_clone_shares_arc_backing() {
+    let request = make_request_data();
+
+    let initial_path_refs = Arc::strong_count(&request.path_params);
+    let initial_headers_refs = Arc::strong_count(&request.headers);
+    let initial_cookies_refs = Arc::strong_count(&request.cookies);
+    let initial_query_refs = Arc::strong_count(&request.raw_query_params);
+
+    let clone = request.clone();
+
+    assert_eq!(Arc::strong_count(&request.path_params), initial_path_refs + 1);
+    assert_eq!(Arc::strong_count(&clone.path_params), initial_path_refs + 1);
+    assert_eq!(Arc::strong_count(&request.headers), initial_headers_refs + 1);
+    assert_eq!(Arc::strong_count(&request.cookies), initial_cookies_refs + 1);
+    assert_eq!(Arc::strong_count(&request.raw_query_params), initial_query_refs + 1);
+}

data/vendor/crates/spikard-core/tests/validation_coverage.rs

@@ -0,0 +1,250 @@
+use serde_json::json;
+use spikard_core::validation::SchemaValidator;
+use spikard_core::validation::error_mapper::{ErrorCondition, ErrorMapper};
+
+#[test]
+fn validator_preprocesses_binary_file_objects_recursively() {
+    let schema = json!({
+        "type": "object",
+        "required": ["file", "files", "nested"],
+        "properties": {
+            "file": { "type": "string", "format": "binary" },
+            "files": {
+                "type": "array",
+                "items": { "type": "string", "format": "binary" }
+            },
+            "nested": {
+                "type": "object",
+                "properties": {
+                    "inner": { "type": "string", "format": "binary" }
+                }
+            }
+        }
+    });
+
+    let validator = SchemaValidator::new(schema).expect("validator");
+
+    let file_object = json!({
+        "filename": "a.txt",
+        "size": 5,
+        "content": "hello",
+        "content_type": "text/plain"
+    });
+
+    let data = json!({
+        "file": file_object.clone(),
+        "files": [file_object.clone()],
+        "nested": {
+            "inner": file_object,
+            "other": 1
+        }
+    });
+
+    validator
+        .validate(&data)
+        .expect("binary preprocessing should satisfy schema");
+}
+
+#[test]
+fn error_mapper_covers_fallbacks_and_common_conditions() {
+    let empty_schema = json!({});
+    let prop = "/properties/value";
+
+    let cases = vec![
+        (
+            ErrorCondition::StringTooShort { min_length: None },
+            "string_too_short",
+            "String is too short",
+        ),
+        (
+            ErrorCondition::StringTooLong { max_length: None },
+            "string_too_long",
+            "String is too long",
+        ),
+        (
+            ErrorCondition::GreaterThan { value: None },
+            "greater_than",
+            "Input should be greater than the minimum",
+        ),
+        (
+            ErrorCondition::GreaterThanEqual { value: None },
+            "greater_than_equal",
+            "Input should be greater than or equal to the minimum",
+        ),
+        (
+            ErrorCondition::LessThan { value: None },
+            "less_than",
+            "Input should be less than the maximum",
+        ),
+        (
+            ErrorCondition::LessThanEqual { value: None },
+            "less_than_equal",
+            "Input should be less than or equal to the maximum",
+        ),
+        (
+            ErrorCondition::Enum { values: None },
+            "enum",
+            "Input should be one of the allowed values",
+        ),
+        (
+            ErrorCondition::StringPatternMismatch { pattern: None },
+            "string_pattern_mismatch",
+            "String does not match expected pattern",
+        ),
+    ];
+
+    for (condition, expected_type, expected_msg) in cases {
+        let (error_type, msg, ctx) = ErrorMapper::map_error(&condition, &empty_schema, prop, "generic");
+        assert_eq!(error_type, expected_type);
+        assert_eq!(msg, expected_msg);
+        assert!(ctx.is_none());
+    }
+
+    let (error_type, msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::TypeMismatch {
+            expected_type: "integer".to_string(),
+        },
+        &empty_schema,
+        prop,
+        "generic",
+    );
+    assert_eq!(error_type, "int_parsing");
+    assert!(msg.contains("valid integer"));
+    assert!(ctx.is_none());
+
+    let (error_type, msg, ctx) = ErrorMapper::map_error(&ErrorCondition::Missing, &empty_schema, prop, "generic");
+    assert_eq!(error_type, "missing");
+    assert_eq!(msg, "Field required");
+    assert!(ctx.is_none());
+
+    let (error_type, msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::AdditionalProperties {
+            field: "extra".to_string(),
+        },
+        &empty_schema,
+        prop,
+        "generic",
+    );
+    assert_eq!(error_type, "validation_error");
+    assert_eq!(msg, "Additional properties are not allowed");
+    assert_eq!(ctx.as_ref().unwrap()["unexpected_field"], "extra");
+
+    let (error_type, msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::TooFewItems { min_items: Some(2) },
+        &empty_schema,
+        prop,
+        "generic",
+    );
+    assert_eq!(error_type, "too_short");
+    assert!(msg.contains("at least 2"));
+    assert_eq!(ctx.as_ref().unwrap()["min_length"], 2);
+
+    let (error_type, msg, ctx) = ErrorMapper::map_error(&ErrorCondition::TooManyItems, &empty_schema, prop, "generic");
+    assert_eq!(error_type, "too_long");
+    assert!(msg.contains("at most"));
+    assert!(ctx.as_ref().unwrap().get("max_length").is_some());
+}
+
+#[test]
+fn error_mapper_uses_schema_constraints_when_present() {
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "value": {
+                "type": "string",
+                "minLength": 2,
+                "maxLength": 4,
+                "pattern": "^a+$",
+                "enum": ["a", "aa"]
+            },
+            "num": {
+                "type": "integer",
+                "exclusiveMinimum": 0,
+                "minimum": 1,
+                "exclusiveMaximum": 10,
+                "maximum": 9
+            }
+        }
+    });
+
+    let (ty, _msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::StringTooShort { min_length: None },
+        &schema,
+        "/properties/value",
+        "generic",
+    );
+    assert_eq!(ty, "string_too_short");
+    assert_eq!(ctx.as_ref().unwrap()["min_length"], 2);
+
+    let (ty, _msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::StringTooLong { max_length: None },
+        &schema,
+        "/properties/value",
+        "generic",
+    );
+    assert_eq!(ty, "string_too_long");
+    assert_eq!(ctx.as_ref().unwrap()["max_length"], 4);
+
+    let (ty, msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::Enum { values: None },
+        &schema,
+        "/properties/value",
+        "generic",
+    );
+    assert_eq!(ty, "enum");
+    assert!(msg.contains("or"));
+    assert!(ctx.as_ref().unwrap()["expected"].as_str().unwrap().contains("or"));
+
+    let (ty, _msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::StringPatternMismatch { pattern: None },
+        &schema,
+        "/properties/value",
+        "generic",
+    );
+    assert_eq!(ty, "string_pattern_mismatch");
+    assert_eq!(ctx.as_ref().unwrap()["pattern"], "^a+$");
+
+    let (ty, _msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::GreaterThan { value: None },
+        &schema,
+        "/properties/num",
+        "generic",
+    );
+    assert_eq!(ty, "greater_than");
+    assert_eq!(ctx.as_ref().unwrap()["gt"], 0);
+
+    let (ty, _msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::GreaterThanEqual { value: None },
+        &schema,
+        "/properties/num",
+        "generic",
+    );
+    assert_eq!(ty, "greater_than_equal");
+    assert_eq!(ctx.as_ref().unwrap()["ge"], 1);
+
+    let (ty, _msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::LessThan { value: None },
+        &schema,
+        "/properties/num",
+        "generic",
+    );
+    assert_eq!(ty, "less_than");
+    assert_eq!(ctx.as_ref().unwrap()["lt"], 10);
+
+    let (ty, _msg, ctx) = ErrorMapper::map_error(
+        &ErrorCondition::LessThanEqual { value: None },
+        &schema,
+        "/properties/num",
+        "generic",
+    );
+    assert_eq!(ty, "less_than_equal");
+    assert_eq!(ctx.as_ref().unwrap()["le"], 9);
+
+    let (ty, _msg, ctx) = ErrorMapper::map_error(&ErrorCondition::EmailFormat, &schema, "/properties/value", "generic");
+    assert_eq!(ty, "string_pattern_mismatch");
+    assert!(ctx.as_ref().unwrap()["pattern"].as_str().unwrap().contains("@"));
+
+    let (ty, _msg, ctx) = ErrorMapper::map_error(&ErrorCondition::UuidFormat, &schema, "/properties/value", "generic");
+    assert_eq!(ty, "uuid_parsing");
+    assert!(ctx.is_none());
+}

data/vendor/crates/spikard-core/tests/validation_error_paths.rs

@@ -0,0 +1,45 @@
+use serde_json::json;
+use spikard_core::validation::SchemaValidator;
+
+#[test]
+fn validate_json_reports_parse_errors_as_validation_error_detail() {
+    let schema = json!({"type": "object"});
+    let validator = SchemaValidator::new(schema).expect("validator");
+
+    let err = validator.validate_json(b"{").expect_err("invalid json");
+    assert_eq!(err.errors.len(), 1);
+    assert_eq!(err.errors[0].error_type, "json_parse_error");
+    assert_eq!(err.errors[0].loc, vec!["body"]);
+}
+
+#[test]
+fn validation_error_locations_include_nested_required_and_additional_properties() {
+    let schema = json!({
+        "type": "object",
+        "required": ["nested"],
+        "properties": {
+            "nested": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": ["inner"],
+                "properties": {
+                    "inner": {"type": "string", "minLength": 2}
+                }
+            }
+        }
+    });
+
+    let validator = SchemaValidator::new(schema).expect("validator");
+
+    let missing_inner = json!({ "nested": {} });
+    let err = validator.validate(&missing_inner).expect_err("missing inner");
+    assert_eq!(err.errors[0].loc, vec!["body", "nested", "inner"]);
+
+    let extra_prop = json!({ "nested": { "inner": "ok", "extra": true } });
+    let err = validator.validate(&extra_prop).expect_err("additional properties");
+    assert!(
+        err.errors
+            .iter()
+            .any(|detail| detail.msg.contains("Additional properties"))
+    );
+}

data/vendor/crates/spikard-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-http"
-version = "0.6.2"
+version = "0.7.2"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"