Compare commits
3 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 6ca00f27e9 | |||
| 520be66035 | |||
| c3146ca433 |
4
.env
4
.env
@ -1,7 +1,7 @@
|
||||
ENVIRONMENT=local
|
||||
DATABASE_PASSWORD=2HwURf1Za7m5ZKtECAfQJGpni3832RV3
|
||||
DATABASE_PASSWORD=QgSvstSjoc6fKphMzNgT3SliNY10eSRS
|
||||
DATABASE_ROLE=agreego_admin
|
||||
DATABASE_HOST=127.1.27.10
|
||||
DATABASE_HOST=127.1.27.9
|
||||
DATABASE_PORT=5432
|
||||
POSTGRES_PASSWORD=xzIq5JT0xY3F+2m1GtnrKDdK29sNSXVVYZHPKJVh8pI=
|
||||
DATABASE_NAME=agreego
|
||||
|
||||
2
flows
2
flows
Submodule flows updated: db55335254...9d758d581e
379
src/lib.rs
379
src/lib.rs
@ -23,56 +23,51 @@ lazy_static! {
|
||||
fn cache_json_schema(schema_id: &str, schema: JsonB) -> JsonB {
|
||||
let mut cache = SCHEMA_CACHE.write().unwrap();
|
||||
let schema_value: Value = schema.0;
|
||||
let schema_path = format!("urn:{}", schema_id);
|
||||
|
||||
let mut compiler = Compiler::new();
|
||||
compiler.enable_format_assertions();
|
||||
|
||||
if let Err(e) = compiler.add_resource(schema_id, schema_value) {
|
||||
// Use schema_path when adding the resource
|
||||
if let Err(e) = compiler.add_resource(&schema_path, schema_value.clone()) {
|
||||
return JsonB(json!({
|
||||
"success": false,
|
||||
"error": {
|
||||
"kind": "SchemaResourceError",
|
||||
"message": format!("Failed to add schema resource: {}", e),
|
||||
"schema_id": schema_id
|
||||
"message": format!("Failed to add schema resource '{}': {}", schema_id, e),
|
||||
"schema_path": schema_path
|
||||
}
|
||||
}));
|
||||
}
|
||||
|
||||
match compiler.compile(schema_id, &mut cache.schemas) {
|
||||
// Use schema_path when compiling
|
||||
match compiler.compile(&schema_path, &mut cache.schemas) {
|
||||
Ok(sch_index) => {
|
||||
// Store the index using the original schema_id as the key
|
||||
cache.id_to_index.insert(schema_id.to_string(), sch_index);
|
||||
JsonB(json!({ "success": true }))
|
||||
}
|
||||
Err(e) => {
|
||||
// Enhance error reporting by matching on the CompileError variant
|
||||
let error_details = match &e {
|
||||
CompileError::ValidationError { url, src } => {
|
||||
// Metaschema validation failed - provide more detail
|
||||
json!({
|
||||
"kind": "SchemaCompilationError",
|
||||
"sub_kind": "ValidationError", // Explicitly state it's a metaschema validation error
|
||||
"message": format!("Schema failed validation against its metaschema: {}", src),
|
||||
"schema_id": schema_id,
|
||||
"failed_at_url": url,
|
||||
"validation_details": format!("{:?}", src), // Include full debug info of the validation error
|
||||
})
|
||||
}
|
||||
// Handle other potential compilation errors
|
||||
_ => {
|
||||
let error_type = format!("{:?}", e).split('(').next().unwrap_or("Unknown").to_string();
|
||||
json!({
|
||||
"kind": "SchemaCompilationError",
|
||||
"sub_kind": error_type, // e.g., "InvalidJsonPointer", "UnsupportedUrlScheme"
|
||||
"message": format!("Schema compilation failed: {}", e),
|
||||
"schema_id": schema_id,
|
||||
"details": format!("{:?}", e), // Generic debug info
|
||||
})
|
||||
}
|
||||
};
|
||||
JsonB(json!({
|
||||
"success": false,
|
||||
"error": error_details
|
||||
}))
|
||||
let error = match &e {
|
||||
CompileError::ValidationError { url: _url, src } => { // Prefix url with _
|
||||
json!({
|
||||
"message": format!("Schema '{}' failed validation against its metaschema: {}", schema_id, src),
|
||||
"schema_path": schema_path,
|
||||
"error": format!("{:?}", src),
|
||||
})
|
||||
}
|
||||
_ => {
|
||||
let _error_type = format!("{:?}", e).split('(').next().unwrap_or("Unknown").to_string(); // Prefix error_type with _
|
||||
json!({
|
||||
"message": format!("Schema '{}' compilation failed: {}", schema_id, e),
|
||||
"schema_path": schema_path,
|
||||
"error": format!("{:?}", e),
|
||||
})
|
||||
}
|
||||
};
|
||||
JsonB(json!({
|
||||
"success": false,
|
||||
"error": error
|
||||
}))
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -81,11 +76,11 @@ fn cache_json_schema(schema_id: &str, schema: JsonB) -> JsonB {
|
||||
fn validate_json_schema(schema_id: &str, instance: JsonB) -> JsonB {
|
||||
let cache = SCHEMA_CACHE.read().unwrap();
|
||||
|
||||
// Lookup uses the original schema_id
|
||||
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)
|
||||
}
|
||||
})),
|
||||
@ -106,16 +101,26 @@ fn validate_json_schema(schema_id: &str, instance: JsonB) -> JsonB {
|
||||
}
|
||||
|
||||
fn format_validation_error(error: &ValidationError) -> Value {
|
||||
let nested_errors: Vec<Value> = error.causes.iter().map(format_validation_error).collect();
|
||||
|
||||
// Use specific message for leaf errors, generic for containers
|
||||
let message = if error.causes.is_empty() {
|
||||
let default_message = format!("{}", error); // Use boon's default message for specific errors
|
||||
// Try to strip the "at '<path>': " prefix
|
||||
if let Some(start_index) = default_message.find("': ") {
|
||||
default_message[start_index + 3..].to_string()
|
||||
} else {
|
||||
default_message // Fallback if pattern not found
|
||||
}
|
||||
} else {
|
||||
"Validation failed due to nested errors".to_string() // Generic message for container errors
|
||||
};
|
||||
|
||||
json!({
|
||||
"message": message,
|
||||
"schema_path": error.schema_url.to_string(), // Use schema_url directly
|
||||
"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<_>>()
|
||||
"error": nested_errors // Recursively format nested errors
|
||||
})
|
||||
}
|
||||
|
||||
@ -141,290 +146,24 @@ fn show_json_schemas() -> Vec<String> {
|
||||
ids
|
||||
}
|
||||
|
||||
#[pg_schema]
|
||||
#[cfg(any(test, feature = "pg_test"))]
|
||||
mod tests {
|
||||
use pgrx::*;
|
||||
use pgrx::pg_test;
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
fn jsonb(val: Value) -> JsonB {
|
||||
JsonB(val)
|
||||
}
|
||||
|
||||
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" });
|
||||
|
||||
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 invalid_result_type = validate_json_schema(schema_id, jsonb(invalid_instance_type));
|
||||
assert!(!invalid_result_type.0["success"].as_bool().unwrap());
|
||||
|
||||
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);
|
||||
|
||||
let invalid_result_missing = validate_json_schema(schema_id, jsonb(invalid_instance_missing));
|
||||
assert!(!invalid_result_missing.0["success"].as_bool().unwrap());
|
||||
|
||||
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");
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
#[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"));
|
||||
}
|
||||
|
||||
#[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 schema_representing_invalid = json!({
|
||||
"type": 123
|
||||
});
|
||||
|
||||
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_eq!(error_obj.get("sub_kind").and_then(Value::as_str), Some("ValidationError"), "Expected sub_kind 'ValidationError' for metaschema failure");
|
||||
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 failed validation against its metaschema"), "Error message mismatch");
|
||||
assert_eq!(error_obj.get("schema_id").and_then(Value::as_str), Some(schema_id));
|
||||
let failed_at_url = error_obj.get("failed_at_url").and_then(Value::as_str).expect("Expected 'failed_at_url' string");
|
||||
assert!(failed_at_url.ends_with(&format!("{}#", schema_id)), "failed_at_url ('{}') should end with schema_id + '#' ('{}#')", failed_at_url, schema_id);
|
||||
assert!(error_obj.get("validation_details").and_then(Value::as_str).is_some(), "Expected 'validation_details' 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"
|
||||
}
|
||||
});
|
||||
|
||||
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 = 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");
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
assert_eq!(causes.len(), 2, "Expected exactly 2 errors (street type, city length)");
|
||||
}
|
||||
|
||||
#[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"]
|
||||
}
|
||||
]
|
||||
});
|
||||
|
||||
cache_json_schema(schema_id, jsonb(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());
|
||||
|
||||
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 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 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");
|
||||
|
||||
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());
|
||||
|
||||
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 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 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 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
|
||||
|
||||
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");
|
||||
}
|
||||
|
||||
#[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.contains(&schema_id.to_string()));
|
||||
|
||||
clear_json_schemas();
|
||||
|
||||
let show_result2 = show_json_schemas();
|
||||
assert!(show_result2.is_empty());
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
#[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();
|
||||
assert!(result.contains(&schema_id1.to_string()));
|
||||
assert!(result.contains(&schema_id2.to_string()));
|
||||
}
|
||||
}
|
||||
|
||||
/// This module is required by `cargo pgrx test` invocations.
|
||||
/// It must be visible at the root of your extension crate.
|
||||
#[cfg(test)]
|
||||
pub mod pg_test {
|
||||
pub fn setup(_options: Vec<&str>) {
|
||||
// perform one-off initialization when the pg_test framework starts
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn postgresql_conf_options() -> Vec<&'static str> {
|
||||
// return any postgresql.conf settings that are required for your tests
|
||||
vec![]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[cfg(any(test, feature = "pg_test"))]
|
||||
#[pg_schema]
|
||||
mod tests {
|
||||
include!("tests.rs");
|
||||
}
|
||||
|
||||
264
src/tests.rs
Normal file
264
src/tests.rs
Normal file
@ -0,0 +1,264 @@
|
||||
use crate::*;
|
||||
use serde_json::{json, Value};
|
||||
|
||||
// Helper macro for asserting success with pretty JSON output on failure
|
||||
macro_rules! assert_success_with_json {
|
||||
($result_jsonb:expr, $fmt:literal $(, $($args:tt)*)?) => {
|
||||
let condition_result: Option<bool> = $result_jsonb.0.get("success").and_then(Value::as_bool);
|
||||
if condition_result != Some(true) {
|
||||
let base_msg = format!($fmt $(, $($args)*)?);
|
||||
let pretty_json = serde_json::to_string_pretty(&$result_jsonb.0)
|
||||
.unwrap_or_else(|_| format!("(Failed to pretty-print JSON: {:?})", $result_jsonb.0));
|
||||
// Construct the full message string first
|
||||
let panic_msg = format!("Assertion Failed (expected success): {}\nResult JSON:\n{}", base_msg, pretty_json);
|
||||
panic!("{}", panic_msg); // Use the constructed string
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Helper macro for asserting failure with pretty JSON output on failure
|
||||
macro_rules! assert_failure_with_json {
|
||||
($result_jsonb:expr, $fmt:literal $(, $($args:tt)*)?) => {
|
||||
let condition_result: Option<bool> = $result_jsonb.0.get("success").and_then(Value::as_bool);
|
||||
if condition_result != Some(false) {
|
||||
let base_msg = format!($fmt $(, $($args)*)?);
|
||||
let pretty_json = serde_json::to_string_pretty(&$result_jsonb.0)
|
||||
.unwrap_or_else(|_| format!("(Failed to pretty-print JSON: {:?})", $result_jsonb.0));
|
||||
// Construct the full message string first
|
||||
let panic_msg = format!("Assertion Failed (expected failure): {}\nResult JSON:\n{}", base_msg, pretty_json);
|
||||
panic!("{}", panic_msg); // Use the constructed string
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
fn jsonb(val: Value) -> JsonB {
|
||||
JsonB(val)
|
||||
}
|
||||
|
||||
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" });
|
||||
|
||||
let cache_result = cache_json_schema(schema_id, jsonb(schema.clone()));
|
||||
assert_success_with_json!(cache_result, "Cache operation should succeed.");
|
||||
|
||||
let valid_result = validate_json_schema(schema_id, jsonb(valid_instance));
|
||||
assert_success_with_json!(valid_result, "Validation of valid instance should succeed.");
|
||||
|
||||
let invalid_result_type = validate_json_schema(schema_id, jsonb(invalid_instance_type));
|
||||
assert_failure_with_json!(invalid_result_type, "Validation with invalid type should fail.");
|
||||
|
||||
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 age_error = causes_age.iter().find(|e| e["instance_path"].as_str() == Some("/age")).expect("Missing cause for /age instance path");
|
||||
let age_error_message = age_error["message"].as_str().expect("Expected string message for age error");
|
||||
assert_eq!(age_error_message, "must be >=0, but got -5", "Age error message mismatch: '{}'", age_error_message);
|
||||
|
||||
let invalid_result_missing = validate_json_schema(schema_id, jsonb(invalid_instance_missing));
|
||||
assert_failure_with_json!(invalid_result_missing, "Validation with missing field should fail.");
|
||||
let error_obj_missing = invalid_result_missing.0.get("error").expect("Expected 'error' object for missing field");
|
||||
let causes_missing = error_obj_missing.get("error").and_then(Value::as_array).expect("Expected nested 'error' array (causes)");
|
||||
assert!(!causes_missing.is_empty(), "Expected causes for missing field");
|
||||
let missing_prop_error = causes_missing.iter().find(|e| e["instance_path"].as_str() == Some("")).expect("Missing cause for root instance path");
|
||||
let expected_missing_message = "missing properties 'age'";
|
||||
assert_eq!(missing_prop_error["message"].as_str().expect("Expected string message for missing prop error"), expected_missing_message, "Missing property error message mismatch: '{}'", missing_prop_error["message"].as_str().unwrap_or("null"));
|
||||
|
||||
let non_existent_id = "non_existent_schema";
|
||||
let invalid_schema_result = validate_json_schema(non_existent_id, jsonb(json!({})));
|
||||
assert_failure_with_json!(invalid_schema_result, "Validation with non-existent schema should fail.");
|
||||
let error_obj = invalid_schema_result.0.get("error").expect("Expected top-level 'error' object");
|
||||
assert_eq!(error_obj["message"].as_str().expect("Expected message for cleared schema"), "Schema with id 'non_existent_schema' not found in cache");
|
||||
}
|
||||
|
||||
#[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_failure_with_json!(result, "Validation with non-existent schema should fail.");
|
||||
assert_eq!(result.0.get("success"), Some(&Value::Bool(false)), "Expected 'success': false for non-existent schema");
|
||||
let error_obj = result.0.get("error").expect("Expected nested 'error' object for non-existent schema failure");
|
||||
let error_message = error_obj["message"].as_str().expect("Expected message string for non-existent schema");
|
||||
assert!(error_message.contains("non_existent_schema") && error_message.contains("not found"), "Error message mismatch for non-existent schema: '{}'", error_message);
|
||||
}
|
||||
|
||||
#[pg_test]
|
||||
fn test_cache_invalid_json_schema() {
|
||||
setup_test();
|
||||
let schema_id = "invalid_schema";
|
||||
let invalid_schema = json!({ "type": "invalid" });
|
||||
let cache_result = cache_json_schema(schema_id, jsonb(invalid_schema));
|
||||
assert_failure_with_json!(cache_result, "Caching invalid schema should fail.");
|
||||
|
||||
let error_obj = cache_result.0.get("error").expect("Expected 'error' object for failed cache");
|
||||
let message = error_obj.get("message").and_then(Value::as_str).expect("Message field missing");
|
||||
let expected_message_start = &format!("Schema '{}' failed validation against its metaschema: ", schema_id);
|
||||
assert!(message.starts_with(expected_message_start), "Compile error message start mismatch: {}", message);
|
||||
}
|
||||
|
||||
#[pg_test]
|
||||
fn test_validate_json_schema_detailed_validation_errors() {
|
||||
setup_test();
|
||||
let schema_id = "detailed_errors";
|
||||
let schema = json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"address": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"street": { "type": "string" },
|
||||
"city": { "type": "string", "maxLength": 10 }
|
||||
},
|
||||
"required": ["street", "city"]
|
||||
}
|
||||
},
|
||||
"required": ["address"]
|
||||
});
|
||||
let _ = cache_json_schema(schema_id, jsonb(schema));
|
||||
|
||||
let invalid_instance = json!({
|
||||
"address": {
|
||||
"street": 123,
|
||||
"city": "Supercalifragilisticexpialidocious"
|
||||
}
|
||||
});
|
||||
|
||||
let result = validate_json_schema(schema_id, jsonb(invalid_instance));
|
||||
assert_failure_with_json!(result, "Validation should fail for detailed errors test.");
|
||||
|
||||
let error_obj = result.0.get("error").expect("Expected top-level 'error' object");
|
||||
assert_eq!(error_obj["message"].as_str(), Some("Validation failed due to nested errors"));
|
||||
|
||||
let causes_array = error_obj.get("error").and_then(Value::as_array).expect("Expected nested error array");
|
||||
assert_eq!(causes_array.len(), 2, "Expected exactly 2 top-level errors (street type, city length)");
|
||||
|
||||
let street_error = causes_array.iter().find(|e| e["instance_path"].as_str() == Some("/address/street")).expect("Missing street error");
|
||||
assert_eq!(street_error["message"].as_str().expect("Expected string message for street error"), "want string, but got number", "Street error message mismatch");
|
||||
|
||||
let city_error = causes_array.iter().find(|e| e["instance_path"].as_str() == Some("/address/city")).expect("Missing city error");
|
||||
let expected_city_error_message = "length must be <=10, but got 34";
|
||||
assert_eq!(city_error["message"].as_str().expect("Expected string message for city error"), expected_city_error_message, "City error message mismatch");
|
||||
}
|
||||
|
||||
#[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"]
|
||||
}
|
||||
]
|
||||
});
|
||||
|
||||
let _ = cache_json_schema(schema_id, jsonb(schema));
|
||||
|
||||
let expected_urn = format!("urn:{}#", schema_id);
|
||||
|
||||
// --- Test case 1: String length failure ---
|
||||
let invalid_string_instance = json!({ "string_prop": "toolongstring" });
|
||||
let result_invalid_string = validate_json_schema(schema_id, jsonb(invalid_string_instance));
|
||||
assert_failure_with_json!(result_invalid_string, "Validation with invalid string length should fail");
|
||||
let error_obj_string = result_invalid_string.0.get("error").expect("Expected error object (string case)");
|
||||
|
||||
// Check the top-level error object directly: Input matches Branch 0 type, fails maxLength validation within it.
|
||||
assert_eq!(error_obj_string["schema_path"].as_str(), Some(expected_urn.as_str()), "Schema path mismatch (string case)");
|
||||
assert_eq!(error_obj_string["instance_path"].as_str(), Some(""), "Incorrect instance_path for string fail (string case)");
|
||||
let actual_string_schema_fail_message = error_obj_string["message"].as_str().expect("Expected string message for string schema fail");
|
||||
let expected_string_schema_fail_message = "Validation failed due to nested errors";
|
||||
assert_eq!(actual_string_schema_fail_message, expected_string_schema_fail_message, "String schema fail message mismatch: '{}'", actual_string_schema_fail_message);
|
||||
|
||||
// --- Test case 2: Number type failure ---
|
||||
let invalid_number_instance = json!({ "number_prop": 5 });
|
||||
let result_invalid_number = validate_json_schema(schema_id, jsonb(invalid_number_instance));
|
||||
assert_failure_with_json!(result_invalid_number, "Validation with invalid number should fail");
|
||||
let error_obj_number = result_invalid_number.0.get("error").expect("Expected error object (number case)");
|
||||
|
||||
// Check the top-level error object directly: Input matches Branch 1 type, fails minimum validation within it.
|
||||
assert_eq!(error_obj_number["schema_path"].as_str(), Some(expected_urn.as_str()), "Schema path mismatch (number case)");
|
||||
assert_eq!(error_obj_number["instance_path"].as_str(), Some(""), "Incorrect instance_path for number fail (number case)");
|
||||
let actual_number_schema_fail_message_num = error_obj_number["message"].as_str().expect("Expected string message for number schema fail (number case)");
|
||||
let expected_number_schema_fail_message_num = "Validation failed due to nested errors";
|
||||
assert_eq!(actual_number_schema_fail_message_num, expected_number_schema_fail_message_num, "Number schema fail message mismatch (number case): '{}'", actual_number_schema_fail_message_num);
|
||||
|
||||
// --- Test case 3: Bool type failure ---
|
||||
let invalid_bool_instance = json!({ "bool_prop": 123 });
|
||||
let result_invalid_bool = validate_json_schema(schema_id, jsonb(invalid_bool_instance));
|
||||
assert_failure_with_json!(result_invalid_bool, "Validation with invalid bool should fail");
|
||||
let error_obj_bool = result_invalid_bool.0.get("error").expect("Expected error object (bool case)");
|
||||
|
||||
// Boon reports the failure for the first branch checked (Branch 0).
|
||||
assert_eq!(error_obj_bool["schema_path"].as_str(), Some(expected_urn.as_str()), "Schema path mismatch (bool case)");
|
||||
// Instance path is empty because the failure is at the root of the object being checked against Branch 0
|
||||
assert_eq!(error_obj_bool["instance_path"].as_str(), Some(""), "Incorrect instance_path for bool fail");
|
||||
let actual_bool_fail_message_0 = error_obj_bool["message"].as_str().expect("Expected string message for branch 0 type fail");
|
||||
let expected_bool_fail_message_0 = "Validation failed due to nested errors";
|
||||
assert_eq!(actual_bool_fail_message_0, expected_bool_fail_message_0, "Branch 0 type fail message mismatch: '{}'", actual_bool_fail_message_0);
|
||||
}
|
||||
|
||||
#[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.contains(&schema_id.to_string()));
|
||||
|
||||
clear_json_schemas();
|
||||
|
||||
let show_result2 = show_json_schemas();
|
||||
assert!(show_result2.is_empty());
|
||||
|
||||
let instance = json!("test");
|
||||
let validate_result = validate_json_schema(schema_id, jsonb(instance));
|
||||
assert_failure_with_json!(validate_result, "Validation should fail after clearing schemas.");
|
||||
|
||||
let error_obj = validate_result.0.get("error").expect("Expected top-level 'error' object");
|
||||
assert_eq!(error_obj["message"].as_str().expect("Expected message for cleared schema"), "Schema with id 'schema_to_clear' not found in cache");
|
||||
}
|
||||
|
||||
#[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();
|
||||
assert!(result.contains(&schema_id1.to_string()));
|
||||
assert!(result.contains(&schema_id2.to_string()));
|
||||
}
|
||||
Reference in New Issue
Block a user