spikard 0.12.0 → 0.15.2

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

@@ -1,301 +0,0 @@
-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![String::new()]);
-
-    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

@@ -1,67 +0,0 @@
-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

@@ -1,250 +0,0 @@
-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,
-        "files": [&file_object],
-        "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

@@ -1,45 +0,0 @@
-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"))
-    );
-}