cellular/jspg
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

more validation fixes

Browse Source
This commit is contained in:
Alex Groleau
2025-04-14 21:53:30 -04:00
parent 2fcf8613b8
commit dad1216e1f
2 changed files with 326 additions and 310 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
.env Normal file
View File

@ -0,0 +1,13 @@
ENVIRONMENT=local
DATABASE_PASSWORD=2HwURf1Za7m5ZKtECAfQJGpni3832RV3
DATABASE_ROLE=agreego_admin
DATABASE_HOST=127.1.27.10
DATABASE_PORT=5432
POSTGRES_PASSWORD=xzIq5JT0xY3F+2m1GtnrKDdK29sNSXVVYZHPKJVh8pI=
DATABASE_NAME=agreego
DEV_DATABASE_NAME=agreego_dev
GITEA_TOKEN=3d70c23673517330623a5122998fb304e3c73f0a
MOOV_ACCOUNT_ID=69a0d2f6-77a2-4e26-934f-d869134f87d3
MOOV_PUBLIC_KEY=9OMhK5qGnh7Tmk2Z
MOOV_SECRET_KEY=DrRox7B-YWfO9IheiUUX7lGP8-7VY-Ni
MOOV_DOMAIN=http://localhost

623
src/lib.rs
View File

@ -8,395 +8,398 @@ use boon::{Compiler, Schemas, ValidationError, SchemaIndex};
use lazy_static::lazy_static;
struct BoonCache {
schemas: Schemas,
id_to_index: HashMap<String, SchemaIndex>,
schemas: Schemas,
id_to_index: HashMap<String, SchemaIndex>,
}
lazy_static! {
static ref SCHEMA_CACHE: RwLock<BoonCache> = RwLock::new(BoonCache {
schemas: Schemas::new(),
id_to_index: HashMap::new()
});
static ref SCHEMA_CACHE: RwLock<BoonCache> = RwLock::new(BoonCache {
schemas: Schemas::new(),
id_to_index: HashMap::new(),
});
}
#[pg_extern(strict)]
fn cache_json_schema(schema_id: &str, schema: JsonB) -> JsonB {
let mut cache = SCHEMA_CACHE.write().unwrap();
let schema_value: Value = schema.0;
let mut cache = SCHEMA_CACHE.write().unwrap();
let schema_value: Value = schema.0;
let mut compiler = Compiler::new();
compiler.enable_format_assertions();
let mut compiler = Compiler::new();
compiler.enable_format_assertions();
let schema_url = format!("urn:jspg:{}", schema_id);
let schema_url = format!("urn:jspg:{}", schema_id);
if let Err(e) = compiler.add_resource(&schema_url, schema_value) {
return JsonB(json!({
"success": false,
"error": format!("Failed to add schema resource '{}': {}", schema_id, e)
}));
}
match compiler.compile(&schema_url, &mut cache.schemas) {
Ok(sch_index) => {
cache.id_to_index.insert(schema_id.to_string(), sch_index);
JsonB(json!({
"success": true,
"schema_id": schema_id,
"message": "Schema cached successfully."
}))
}
Err(e) => JsonB(json!({
"success": false,
"schema_id": schema_id,
"error": format!("Schema compilation failed: {}", e)
})),
if let Err(e) = compiler.add_resource(&schema_url, schema_value) {
return JsonB(json!({
"success": false,
"error": {
"kind": "SchemaResourceError",
"message": format!("Failed to add schema resource: {}", e),
"schema_id": schema_id
}
}));
}
match compiler.compile(&schema_url, &mut cache.schemas) {
Ok(sch_index) => {
cache.id_to_index.insert(schema_id.to_string(), sch_index);
JsonB(json!({ "success": true }))
}
Err(e) => JsonB(json!({
"success": false,
"error": {
"kind": "SchemaCompilationError",
"message": format!("Schema compilation failed: {}", e),
"schema_id": schema_id
}
})),
}
}
#[pg_extern(strict, parallel_safe)]
fn validate_json_schema(schema_id: &str, instance: JsonB) -> JsonB {
let cache = SCHEMA_CACHE.read().unwrap();
let cache = SCHEMA_CACHE.read().unwrap();
match cache.id_to_index.get(schema_id) {
None => JsonB(json!({
match cache.id_to_index.get(schema_id) {
None => JsonB(json!({
"success": false,
"error": {
"kind": "SchemaNotFound",
"message": format!("Schema with id '{}' not found in cache", schema_id)
}
})),
Some(sch_index) => {
let instance_value: Value = instance.0;
match cache.schemas.validate(&instance_value, *sch_index) {
Ok(_) => JsonB(json!({ "success": true })),
Err(validation_error) => {
let error = format_validation_error(&validation_error);
JsonB(json!({
"success": false,
"errors": [{
"kind": "SchemaNotFound",
"message": format!("Schema with id '{}' not found in cache", schema_id)
}]
})),
Some(sch_index) => {
let instance_value: Value = instance.0;
match cache.schemas.validate(&instance_value, *sch_index) {
Ok(_) => JsonB(json!({ "success": true })),
Err(validation_error) => {
let error_details = format_boon_errors(&validation_error);
JsonB(json!({
"success": false,
"errors": [error_details]
}))
}
}
"error": error
}))
}
}
}
}
}
fn format_boon_errors(error: &ValidationError) -> Value {
json!({
"instance_path": error.instance_location.to_string(),
"schema_path": error.schema_url.to_string(),
"kind": format!("{:?}", error.kind),
"message": format!("{}", error),
"causes": error
.causes
.iter()
.map(format_boon_errors)
.collect::<Vec<_>>()
})
fn format_validation_error(error: &ValidationError) -> Value {
json!({
"instance_path": error.instance_location.to_string(),
"schema_path": error.schema_url.to_string(),
"kind": format!("{:?}", error.kind),
"message": format!("{}", error),
"error": error
.causes
.iter()
.map(format_validation_error)
.collect::<Vec<_>>()
})
}
#[pg_extern(strict, parallel_safe)]
fn json_schema_cached(schema_id: &str) -> bool {
let cache = SCHEMA_CACHE.read().unwrap();
cache.id_to_index.contains_key(schema_id)
let cache = SCHEMA_CACHE.read().unwrap();
cache.id_to_index.contains_key(schema_id)
}
#[pg_extern(strict)]
fn clear_json_schemas() -> JsonB {
let mut cache = SCHEMA_CACHE.write().unwrap();
*cache = BoonCache {
schemas: Schemas::new(),
id_to_index: HashMap::new()
};
JsonB(json!({
"success": true,
"message": "Schema cache cleared."
}))
fn clear_json_schemas() {
let mut cache = SCHEMA_CACHE.write().unwrap();
*cache = BoonCache {
schemas: Schemas::new(),
id_to_index: HashMap::new(),
};
}
#[pg_extern(strict, parallel_safe)]
fn show_json_schemas() -> JsonB {
let cache = SCHEMA_CACHE.read().unwrap();
let ids: Vec<&String> = cache.id_to_index.keys().collect();
JsonB(json!({
"cached_schema_ids": ids
}))
fn show_json_schemas() -> Vec<String> {
let cache = SCHEMA_CACHE.read().unwrap();
let ids: Vec<String> = cache.id_to_index.keys().cloned().collect();
ids
}
#[pg_schema]
#[cfg(any(test, feature = "pg_test"))]
mod tests {
use pgrx::*;
use pgrx::pg_test;
use super::*;
use serde_json::json;
use pgrx::*;
use pgrx::pg_test;
use super::*;
use serde_json::json;
fn jsonb(val: Value) -> JsonB {
JsonB(val)
}
fn jsonb(val: Value) -> JsonB {
JsonB(val)
}
fn setup_test() {
clear_json_schemas();
}
fn setup_test() {
clear_json_schemas();
}
#[pg_test]
fn test_cache_and_validate_json_schema() {
setup_test();
let schema_id = "my_schema";
let schema = json!({
"type": "object",
"properties": {
"name": { "type": "string" },
"age": { "type": "integer", "minimum": 0 }
},
"required": ["name", "age"]
});
let valid_instance = json!({ "name": "Alice", "age": 30 });
let invalid_instance_type = json!({ "name": "Bob", "age": -5 });
let invalid_instance_missing = json!({ "name": "Charlie" });
#[pg_test]
fn test_cache_and_validate_json_schema() {
setup_test();
let schema_id = "my_schema";
let schema = json!({
"type": "object",
"properties": {
"name": { "type": "string" },
"age": { "type": "integer", "minimum": 0 }
},
"required": ["name", "age"]
});
let valid_instance = json!({ "name": "Alice", "age": 30 });
let invalid_instance_type = json!({ "name": "Bob", "age": -5 });
let invalid_instance_missing = json!({ "name": "Charlie" });
let cache_result = cache_json_schema(schema_id, jsonb(schema.clone()));
assert!(cache_result.0["success"].as_bool().unwrap());
let cache_result = cache_json_schema(schema_id, jsonb(schema.clone()));
assert!(cache_result.0["success"].as_bool().unwrap());
let valid_result = validate_json_schema(schema_id, jsonb(valid_instance));
assert!(valid_result.0["success"].as_bool().unwrap());
let valid_result = validate_json_schema(schema_id, jsonb(valid_instance));
assert!(valid_result.0["success"].as_bool().unwrap());
let invalid_result_type = validate_json_schema(schema_id, jsonb(invalid_instance_type));
assert!(!invalid_result_type.0["success"].as_bool().unwrap());
let invalid_result_type = validate_json_schema(schema_id, jsonb(invalid_instance_type));
assert!(!invalid_result_type.0["success"].as_bool().unwrap());
// --- Assertions for invalid_result_type ---
let error_obj_type = invalid_result_type.0.get("error").expect("Expected top-level 'error' object");
let causes_age = error_obj_type.get("error").and_then(Value::as_array).expect("Expected nested 'error' array (causes)");
assert!(!causes_age.is_empty(), "Expected causes for invalid age");
let first_cause_age = &causes_age[0];
assert!(first_cause_age["kind"].as_str().unwrap().contains("Minimum"), "Kind '{}' should contain Minimum", first_cause_age["kind"]);
let msg = first_cause_age["message"].as_str().unwrap_or("");
assert!(msg.contains("must be >=0"), "Error message mismatch for age minimum: {}", msg);
// Get top-level errors
let top_level_errors = invalid_result_type.0["errors"].as_array().expect("Top-level 'errors' should be an array");
assert_eq!(top_level_errors.len(), 1, "Should have exactly one top-level error for invalid type");
let invalid_result_missing = validate_json_schema(schema_id, jsonb(invalid_instance_missing));
assert!(!invalid_result_missing.0["success"].as_bool().unwrap());
// Get the first (and only) top-level error
let top_level_error = top_level_errors.get(0).expect("Should get the first top-level error");
let error_obj_missing = invalid_result_missing.0.get("error").expect("Expected top-level 'error' object");
let causes_missing = error_obj_missing.get("error").and_then(Value::as_array).expect("Expected nested 'error' array (causes) for missing");
assert!(!causes_missing.is_empty(), "Expected causes for missing age");
let first_cause_missing = &causes_missing[0];
assert!(first_cause_missing["kind"].as_str().unwrap().contains("Required"));
let msg_missing = first_cause_missing["message"].as_str().unwrap_or("");
assert!(msg_missing.contains("missing properties 'age'"), "Error message mismatch for missing 'age': {}", msg_missing);
assert!(first_cause_missing["instance_path"] == "", "Expected empty instance path for missing field");
// Check top-level error kind
assert!(top_level_error.get("kind").and_then(Value::as_str).map_or(false, |k| k.starts_with("Schema { url:")),
"Incorrect kind for top-level error. Expected 'Schema {{ url:'. Error: {:?}. All errors: {:?}", top_level_error, top_level_errors);
let non_existent_id = "non_existent_schema";
let invalid_schema_result = validate_json_schema(non_existent_id, jsonb(json!({})));
assert!(!invalid_schema_result.0["success"].as_bool().unwrap());
let schema_not_found_error = invalid_schema_result.0
.get("error") // Top level error object
.expect("Expected top-level 'error' object for schema not found");
assert_eq!(schema_not_found_error["kind"], "SchemaNotFound");
assert!(schema_not_found_error["message"].as_str().unwrap().contains(non_existent_id));
}
// Get the 'causes' array from the top-level error
let causes_age = top_level_error.get("causes").and_then(Value::as_array).expect("Top-level error 'causes' should be an array");
assert_eq!(causes_age.len(), 1, "Should have one cause for the age error");
#[pg_test]
fn test_validate_json_schema_not_cached() {
setup_test();
let instance = json!({ "foo": "bar" });
let result = validate_json_schema("non_existent_schema", jsonb(instance));
assert!(!result.0["success"].as_bool().unwrap());
let error_obj = result.0.get("error").expect("Expected top-level 'error' object");
assert_eq!(error_obj["kind"], "SchemaNotFound");
assert!(error_obj["message"].as_str().unwrap().contains("non_existent_schema"));
}
// Get the actual age error from the 'causes' array
let age_error = causes_age.get(0).expect("Should have an error object in 'causes'");
assert_eq!(age_error.get("instance_path").and_then(Value::as_str), Some("/age"),
"Incorrect instance_path for age error. Error: {:?}. All errors: {:?}", age_error, top_level_errors);
#[pg_test]
fn test_cache_invalid_json_schema() {
setup_test();
let schema_id = "invalid_schema";
let invalid_schema_json = "{\"type\": \"string\" \"maxLength\": 5}";
let invalid_schema_value: Result<Value, _> = serde_json::from_str(invalid_schema_json);
assert!(invalid_schema_value.is_err(), "Test setup assumes invalid JSON string");
assert!(age_error.get("kind").and_then(Value::as_str).map_or(false, |k| k.starts_with("Minimum { got:")),
"Incorrect kind prefix for age error. Expected 'Minimum {{ got:'. Error: {:?}. All errors: {:?}", age_error, top_level_errors);
let schema_representing_invalid = json!({
"type": 123
});
let expected_prefix = "at '/age': must be >=0";
assert!(age_error.get("message")
.and_then(Value::as_str)
.map_or(false, |m| m.starts_with(expected_prefix)),
"Incorrect message prefix for age error. Expected prefix '{}'. Error: {:?}. All errors: {:?}",
expected_prefix, age_error, top_level_errors);
let result = cache_json_schema(schema_id, jsonb(schema_representing_invalid.clone()));
assert!(!result.0["success"].as_bool().unwrap());
let error_obj = result.0.get("error").expect("Expected top-level 'error' object for compilation failure");
assert_eq!(error_obj.get("kind").and_then(Value::as_str), Some("SchemaCompilationError"));
assert!(error_obj.get("message").and_then(Value::as_str).is_some(), "Expected 'message' field in error object");
assert!(error_obj["message"].as_str().unwrap().contains("Schema compilation failed")); // Check content of message
assert_eq!(error_obj.get("schema_id").and_then(Value::as_str), Some(schema_id));
}
let invalid_result_missing = validate_json_schema(schema_id, jsonb(invalid_instance_missing));
assert!(!invalid_result_missing.0["success"].as_bool().unwrap(), "Validation should fail for missing required field");
#[pg_test]
fn test_validate_json_schema_detailed_validation_errors() {
setup_test();
let schema_id = "detailed_schema";
let schema = json!({
"type": "object",
"properties": {
"address": {
"type": "object",
"properties": {
"street": { "type": "string" },
"city": { "type": "string", "maxLength": 10 }
},
"required": ["street", "city"]
}
},
"required": ["address"]
});
let invalid_instance = json!({
"address": {
"street": 123,
"city": "Supercalifragilisticexpialidocious"
}
});
// --- Assertions for invalid_result_missing ---
assert!(cache_json_schema(schema_id, jsonb(schema.clone())).0["success"].as_bool().unwrap());
let result = validate_json_schema(schema_id, jsonb(invalid_instance));
assert!(!result.0["success"].as_bool().unwrap());
// Get top-level errors
let top_level_errors_missing = invalid_result_missing.0["errors"].as_array().expect("Errors should be an array for missing field");
assert_eq!(top_level_errors_missing.len(), 1, "Should have one top-level error for missing field");
let error_obj = result.0.get("error").expect("Expected top-level 'error' object");
let causes = error_obj.get("error").and_then(Value::as_array).expect("Expected nested 'error' array (causes)");
assert!(causes.len() >= 2, "Expected at least 2 detailed causes");
// Get the first (and only) top-level error
let top_error_missing = top_level_errors_missing.get(0).expect("Should get the first top-level missing field error");
let street_error = causes.iter().find(|e| e["instance_path"] == "/address/street").expect("Missing street error");
assert!(street_error["kind"].as_str().unwrap().contains("Type"), "Kind '{}' should contain Type", street_error["kind"]);
let street_msg = street_error["message"].as_str().unwrap_or("null");
assert!(street_msg.contains("want string, but got number"), "Street message mismatch: {}", street_msg);
// Check top-level error kind
assert!(top_error_missing.get("kind").and_then(Value::as_str).map_or(false, |k| k.starts_with("Schema { url:")),
"Incorrect kind for missing field top-level error. Error: {:?}. All errors: {:?}", top_error_missing, top_level_errors_missing);
let city_error = causes.iter().find(|e| e["instance_path"] == "/address/city").expect("Missing city error");
assert!(city_error["kind"].as_str().unwrap().contains("MaxLength"), "Kind '{}' should contain MaxLength", city_error["kind"]);
let city_msg = city_error["message"].as_str().unwrap_or("null");
assert!(city_msg.contains("length must be <=10"), "City message mismatch: {}", city_msg);
// Get the 'causes' array from the top-level error
let causes_missing = top_error_missing.get("causes").and_then(Value::as_array).expect("Causes should be an array for missing field error");
assert_eq!(causes_missing.len(), 1, "Should have one cause for missing field");
assert_eq!(causes.len(), 2, "Expected exactly 2 errors (street type, city length)");
}
// Get the actual missing field error from the 'causes' array
let missing_error = causes_missing.get(0).expect("Should have missing field error object in 'causes'");
#[pg_test]
fn test_validate_json_schema_oneof_validation_errors() {
setup_test();
let schema_id = "oneof_schema";
let schema = json!({
"oneOf": [
{
"type": "object",
"properties": {
"string_prop": { "type": "string", "maxLength": 5 }
},
"required": ["string_prop"]
},
{
"type": "object",
"properties": {
"number_prop": { "type": "number", "minimum": 10 }
},
"required": ["number_prop"]
}
]
});
// Assertions on the specific missing field error
assert_eq!(missing_error.get("instance_path").and_then(Value::as_str), Some(""),
"Incorrect instance_path for missing age error: {:?}", missing_error);
assert!(missing_error.get("kind").and_then(Value::as_str).map_or(false, |k| k.starts_with("Required { want: [\"age\"]")),
"Incorrect kind for missing age error. Expected prefix 'Required {{ want: [\"age\"] }}'. Error: {:?}", missing_error);
}
cache_json_schema(schema_id, jsonb(schema));
#[pg_test]
fn test_validate_json_schema_not_cached() {
setup_test();
let instance = json!({ "foo": "bar" });
let result = validate_json_schema("non_existent_schema", jsonb(instance));
assert!(!result.0["success"].as_bool().unwrap());
let errors = result.0["errors"].as_array().unwrap();
assert_eq!(errors.len(), 1);
assert_eq!(errors[0]["kind"], json!("SchemaNotFound"));
assert!(errors[0]["message"].as_str().unwrap().contains("non_existent_schema"));
}
let invalid_string_instance = json!({ "string_prop": "toolongstring" });
let result_invalid_string = validate_json_schema(schema_id, jsonb(invalid_string_instance));
assert!(!result_invalid_string.0["success"].as_bool().unwrap());
#[pg_test]
fn test_cache_invalid_json_schema() {
setup_test();
let schema_id = "invalid_schema";
let invalid_schema_json = "{\"type\": \"string\" \"maxLength\": 5}";
let invalid_schema_value: Result<Value, _> = serde_json::from_str(invalid_schema_json);
assert!(invalid_schema_value.is_err(), "Test setup assumes invalid JSON string");
let error_obj_string = result_invalid_string.0.get("error").expect("Expected top-level 'error' object");
assert!(error_obj_string["kind"].as_str().unwrap().contains("Schema"), "Top level kind '{}' should contain Schema for OneOf failure", error_obj_string["kind"]);
assert!(error_obj_string["message"].as_str().unwrap().contains("oneOf failed, none matched"), "OneOf message mismatch: {}", error_obj_string["message"]); // Final adjustment
let schema_representing_invalid = json!({
"type": 123
});
let causes_string = error_obj_string.get("error").and_then(Value::as_array).expect("Expected nested 'error' array (causes)");
assert_eq!(causes_string.len(), 1, "Expected one cause for oneOf failure (string)");
let result = cache_json_schema(schema_id, jsonb(schema_representing_invalid.clone()));
assert!(!result.0["success"].as_bool().unwrap());
assert!(result.0["error"].as_str().unwrap().contains("Schema compilation failed"));
}
let nested_causes_string = causes_string[0].get("error").and_then(Value::as_array).expect("Expected deeper nested causes for string oneOf");
assert_eq!(nested_causes_string.len(), 2, "Expected two nested causes for string oneOf");
let string_schema_fail = nested_causes_string.iter().find(|c| c["schema_path"].as_str().unwrap().ends_with("/oneOf/0/properties/string_prop")).expect("Missing nested cause for string schema");
assert_eq!(string_schema_fail["instance_path"].as_str().unwrap(), "/string_prop", "Instance path should be /string_prop");
assert!(string_schema_fail["kind"].as_str().unwrap().contains("MaxLength"), "Nested string cause kind should be MaxLength");
let number_schema_fail = nested_causes_string.iter().find(|c| c["schema_path"].as_str().unwrap().ends_with("/oneOf/1")).expect("Missing nested cause for number schema");
assert_eq!(number_schema_fail["instance_path"].as_str().unwrap(), "", "Instance path for branch 2 type mismatch should be empty");
assert!(number_schema_fail["kind"].as_str().unwrap().contains("Required"), "Nested number cause kind should be Required");
#[pg_test]
fn test_validate_json_schema_detailed_validation_errors() {
setup_test();
let schema_id = "detailed_schema";
let schema = json!({
"type": "object",
"properties": {
"address": {
"type": "object",
"properties": {
"street": { "type": "string" },
"city": { "type": "string", "maxLength": 10 }
},
"required": ["street", "city"]
}
},
"required": ["address"]
});
let invalid_instance = json!({
"address": {
"city": "San Francisco Bay Area"
}
});
let invalid_number_instance = json!({ "number_prop": 5 });
let result_invalid_number = validate_json_schema(schema_id, jsonb(invalid_number_instance));
assert!(!result_invalid_number.0["success"].as_bool().unwrap());
assert!(cache_json_schema(schema_id, jsonb(schema.clone())).0["success"].as_bool().unwrap());
let result = validate_json_schema(schema_id, jsonb(invalid_instance));
assert!(!result.0["success"].as_bool().unwrap());
let error_obj_number = result_invalid_number.0.get("error").expect("Expected top-level 'error' object");
assert!(error_obj_number["kind"].as_str().unwrap().contains("Schema"), "Top level kind '{}' should contain Schema for OneOf failure", error_obj_number["kind"]);
assert!(error_obj_number["message"].as_str().unwrap().contains("oneOf failed, none matched"), "OneOf message mismatch: {}", error_obj_number["message"]); // Final adjustment
let errors = result.0["errors"].as_array().expect("Errors should be an array");
let top_error = errors.get(0).expect("Expected at least one top-level error object");
let causes = top_error.get("causes").and_then(Value::as_array).expect("Expected causes array");
let causes_number = error_obj_number.get("error").and_then(Value::as_array).expect("Expected nested 'error' array (causes)");
assert_eq!(causes_number.len(), 1, "Expected one cause for oneOf failure (number)");
let nested_causes_number = causes_number[0].get("error").and_then(Value::as_array).expect("Expected deeper nested causes for number oneOf");
assert_eq!(nested_causes_number.len(), 2, "Expected two nested causes for number oneOf");
let string_schema_fail_num = nested_causes_number.iter().find(|c| c["schema_path"].as_str().unwrap().ends_with("/oneOf/0")).expect("Missing nested cause for string schema (number case)");
assert_eq!(string_schema_fail_num["instance_path"].as_str().unwrap(), "", "Instance path for branch 1 type mismatch should be empty");
assert!(string_schema_fail_num["kind"].as_str().unwrap().contains("Required"), "Nested string cause kind should be Required (number case)");
let number_schema_fail_num = nested_causes_number.iter().find(|c| c["schema_path"].as_str().unwrap().ends_with("/oneOf/1/properties/number_prop")).expect("Missing nested cause for number schema (number case)");
assert_eq!(number_schema_fail_num["instance_path"].as_str().unwrap(), "/number_prop", "Instance path should be /number_prop (number case)");
assert!(number_schema_fail_num["kind"].as_str().unwrap().contains("Minimum"), "Nested number cause kind should be Minimum (number case)");
let has_required_street_error = causes.iter().any(|e|
e.get("instance_path").and_then(Value::as_str) == Some("/address") && // Check path inside cause
e.get("kind").and_then(Value::as_str).unwrap_or("").starts_with("Required { want:") && // Check kind prefix
e.get("kind").and_then(Value::as_str).unwrap_or("").contains("street") // Ensure 'street' is mentioned
);
assert!(has_required_street_error, "Missing required 'street' error within causes. Actual errors: {:?}", errors);
let invalid_bool_instance = json!({ "other_prop": true });
let result_invalid_bool = validate_json_schema(schema_id, jsonb(invalid_bool_instance));
assert!(!result_invalid_bool.0["success"].as_bool().unwrap());
let has_maxlength_city_error = causes.iter().any(|e| // Check within causes
e.get("instance_path").and_then(Value::as_str) == Some("/address/city") &&
e.get("kind").and_then(Value::as_str).unwrap_or("").starts_with("MaxLength { got:") // Check kind prefix
);
assert!(has_maxlength_city_error, "Missing maxLength 'city' error within causes. Actual errors: {:?}", errors);
}
let error_obj_bool = result_invalid_bool.0.get("error").expect("Expected top-level 'error' object");
assert!(error_obj_bool["kind"].as_str().unwrap().contains("Schema"), "Top level kind '{}' should contain Schema for OneOf failure", error_obj_bool["kind"]);
assert!(error_obj_bool["message"].as_str().unwrap().contains("oneOf failed, none matched"), "OneOf message mismatch: {}", error_obj_bool["message"]); // Final adjustment
#[pg_test]
fn test_validate_json_schema_oneof_validation_errors() {
setup_test();
let schema_id = "oneof_schema";
let schema = json!({
"type": "object",
"properties": {
"value": {
"oneOf": [
{ "type": "string", "minLength": 5 },
{ "type": "number", "minimum": 10 }
]
}
},
"required": ["value"]
});
assert!(cache_json_schema(schema_id, jsonb(schema.clone())).0["success"].as_bool().unwrap());
let causes_bool = error_obj_bool.get("error").and_then(Value::as_array).expect("Expected nested 'error' array (causes)");
assert_eq!(causes_bool.len(), 1, "Expected one cause for oneOf failure (bool)");
let nested_causes_bool = causes_bool[0].get("error").and_then(Value::as_array).expect("Expected deeper nested causes for bool oneOf");
assert_eq!(nested_causes_bool.len(), 2, "Expected two nested causes for bool oneOf");
let bool_fail_0 = nested_causes_bool.iter().find(|c| c["schema_path"].as_str().unwrap().ends_with("/oneOf/0")).expect("Missing nested cause for branch 0 type fail");
assert_eq!(bool_fail_0["instance_path"].as_str().unwrap(), "", "Instance path for branch 0 type fail should be empty");
assert!(bool_fail_0["kind"].as_str().unwrap().contains("Required"), "Nested bool cause 0 kind should be Required");
let bool_fail_1 = nested_causes_bool.iter().find(|c| c["schema_path"].as_str().unwrap().ends_with("/oneOf/1")).expect("Missing nested cause for branch 1 type fail");
assert_eq!(bool_fail_1["instance_path"].as_str().unwrap(), "", "Instance path for branch 1 type fail should be empty");
assert!(bool_fail_1["kind"].as_str().unwrap().contains("Required"), "Nested bool cause 1 kind should be Required");
}
let invalid_instance = json!({ "value": "abc" });
let result = validate_json_schema(schema_id, jsonb(invalid_instance));
#[pg_test]
fn test_clear_json_schemas() {
setup_test();
let schema_id = "schema_to_clear";
let schema = json!({ "type": "string" });
cache_json_schema(schema_id, jsonb(schema.clone()));
assert!(!result.0["success"].as_bool().unwrap());
let show_result1 = show_json_schemas();
assert!(show_result1.contains(&schema_id.to_string()));
let errors_val = result.0["errors"].as_array().expect("Errors should be an array");
let top_schema_error = errors_val.get(0).expect("Expected at least one top-level Schema error object");
let schema_error_causes = top_schema_error.get("causes").and_then(Value::as_array).expect("Expected causes array for Schema error");
clear_json_schemas();
let oneof_error = schema_error_causes.iter().find(|e| {
e.get("kind").and_then(Value::as_str) == Some("OneOf(None)") &&
e.get("instance_path").and_then(Value::as_str) == Some("/value")
}).expect("Could not find the OneOf(None) error for /value within Schema causes");
let show_result2 = show_json_schemas();
assert!(show_result2.is_empty());
let oneof_causes = oneof_error.get("causes").and_then(Value::as_array)
.expect("Expected causes array for OneOf error");
let instance = json!("test");
let validate_result = validate_json_schema(schema_id, jsonb(instance));
assert!(!validate_result.0["success"].as_bool().unwrap());
let error_obj = validate_result.0.get("error").expect("Expected top-level 'error' object");
assert_eq!(error_obj["kind"], "SchemaNotFound");
assert!(error_obj["message"].as_str().unwrap().contains(schema_id));
}
let has_minlength_error = oneof_causes.iter().any(|e| // Check within OneOf causes
e.get("instance_path").and_then(Value::as_str) == Some("/value") &&
e.get("kind").and_then(Value::as_str).unwrap_or("").starts_with("MinLength { got:") // Check kind prefix
);
assert!(has_minlength_error, "Missing MinLength error within OneOf causes. Actual errors: {:?}", errors_val);
#[pg_test]
fn test_show_json_schemas() {
setup_test();
let schema_id1 = "schema1";
let schema_id2 = "schema2";
let schema = json!({ "type": "boolean" });
let has_type_error = oneof_causes.iter().any(|e| // Check within OneOf causes
e.get("instance_path").and_then(Value::as_str) == Some("/value") &&
e.get("kind").and_then(Value::as_str).unwrap_or("").starts_with("Type { got: String, want: Types") // More specific kind check
);
assert!(has_type_error, "Missing Type error within OneOf causes. Actual errors: {:?}", errors_val);
}
cache_json_schema(schema_id1, jsonb(schema.clone()));
cache_json_schema(schema_id2, jsonb(schema.clone()));
#[pg_test]
fn test_clear_json_schemas() {
setup_test();
let schema_id = "schema_to_clear";
let schema = json!({ "type": "string" });
cache_json_schema(schema_id, jsonb(schema.clone()));
let show_result1 = show_json_schemas();
assert!(show_result1.0["cached_schema_ids"].as_array().unwrap().iter().any(|id| id.as_str() == Some(schema_id)));
let clear_result = clear_json_schemas();
assert!(clear_result.0["success"].as_bool().unwrap());
let show_result2 = show_json_schemas();
assert!(show_result2.0["cached_schema_ids"].as_array().unwrap().is_empty());
let instance = json!("test");
let validate_result = validate_json_schema(schema_id, jsonb(instance));
assert!(!validate_result.0["success"].as_bool().unwrap());
assert_eq!(validate_result.0["errors"].as_array().unwrap()[0]["kind"], json!("SchemaNotFound"));
}
#[pg_test]
fn test_show_json_schemas() {
setup_test();
let schema_id1 = "schema1";
let schema_id2 = "schema2";
let schema = json!({ "type": "boolean" });
cache_json_schema(schema_id1, jsonb(schema.clone()));
cache_json_schema(schema_id2, jsonb(schema.clone()));
let result = show_json_schemas();
let ids = result.0["cached_schema_ids"].as_array().unwrap();
assert_eq!(ids.len(), 2);
assert!(ids.contains(&json!(schema_id1)));
assert!(ids.contains(&json!(schema_id2)));
}
let result = show_json_schemas();
assert!(result.contains(&schema_id1.to_string()));
assert!(result.contains(&schema_id2.to_string()));
}
}
#[cfg(test)]
pub mod pg_test {
pub fn setup(_options: Vec<&str>) {
// perform one-off initialization when the pg_test framework starts
}
pub fn setup(_options: Vec<&str>) {
// perform one-off initialization when the pg_test framework starts
}
pub fn postgresql_conf_options() -> Vec<&'static str> {
// return any postgresql.conf settings that are required for your tests
vec![]
}
pub fn postgresql_conf_options() -> Vec<&'static str> {
// return any postgresql.conf settings that are required for your tests
vec![]
}
}