#[cfg(not(target_arch = "wasm32"))]
mod tests {
use jsonschema::Draft;
use std::fs;
use testsuite::{suite, Test};
#[suite(
path = "crates/jsonschema/tests/suite",
drafts = [
"draft4",
"draft6",
"draft7",
"draft2019-09",
"draft2020-12",
],
xfail = [
"draft4::optional::bignum::integer::a_bignum_is_an_integer",
"draft4::optional::bignum::integer::a_negative_bignum_is_an_integer",
]
)]
fn test_suite(test: Test) {
let mut options = jsonschema::options();
match test.draft {
"draft4" => {
options.with_draft(Draft::Draft4);
}
"draft6" => {
options.with_draft(Draft::Draft6);
}
"draft7" => {
options.with_draft(Draft::Draft7);
}
"draft2019-09" | "draft2020-12" => {}
_ => panic!("Unsupported draft"),
};
if test.is_optional {
options.should_validate_formats(true);
}
let validator = options
.build(&test.schema)
.expect("Failed to build a schema");
if test.valid {
if let Some(first) = validator.iter_errors(&test.data).next() {
panic!(
"Test case should not have validation errors:\nGroup: {}\nTest case: {}\nSchema: {}\nInstance: {}\nError: {first:?}",
test.case,
test.description,
pretty_json(&test.schema),
pretty_json(&test.data),
);
}
assert!(
validator.is_valid(&test.data),
"Test case should be valid:\nCase: {}\nTest: {}\nSchema: {}\nInstance: {}",
test.case,
test.description,
pretty_json(&test.schema),
pretty_json(&test.data),
);
assert!(
validator.validate(&test.data).is_ok(),
"Test case should be valid:\nCase: {}\nTest: {}\nSchema: {}\nInstance: {}",
test.case,
test.description,
pretty_json(&test.schema),
pretty_json(&test.data),
);
let output = validator.apply(&test.data).basic();
assert!(
output.is_valid(),
"Test case should be valid via basic output:\nCase: {}\nTest: {}\nSchema: {}\nInstance: {}\nError: {:?}",
test.case,
test.description,
pretty_json(&test.schema),
pretty_json(&test.data),
output
);
} else {
let errors = validator.iter_errors(&test.data).collect::<Vec<_>>();
assert!(
!errors.is_empty(),
"Test case should have validation errors:\nCase: {}\nTest: {}\nSchema: {}\nInstance: {}",
test.case,
test.description,
pretty_json(&test.schema),
pretty_json(&test.data),
);
for error in errors {
let pointer = error.instance_path.as_str();
assert_eq!(
test.data.pointer(pointer), Some(&*error.instance),
"Expected error instance did not match actual error instance:\nCase: {}\nTest: {}\nSchema: {}\nInstance: {}\nExpected pointer: {:#?}\nActual pointer: {:#?}",
test.case,
test.description,
pretty_json(&test.schema),
pretty_json(&test.data),
&*error.instance,
&pointer,
);
}
assert!(
!validator.is_valid(&test.data),
"Test case should be invalid:\nCase: {}\nTest: {}\nSchema: {}\nInstance: {}",
test.case,
test.description,
pretty_json(&test.schema),
pretty_json(&test.data),
);
let Some(error) = validator.validate(&test.data).err() else {
panic!(
"Test case should be invalid:\nCase: {}\nTest: {}\nSchema: {}\nInstance: {}",
test.case,
test.description,
pretty_json(&test.schema),
pretty_json(&test.data),
);
};
let pointer = error.instance_path.as_str();
assert_eq!(
test.data.pointer(pointer), Some(&*error.instance),
"Expected error instance did not match actual error instance:\nCase: {}\nTest: {}\nSchema: {}\nInstance: {}\nExpected pointer: {:#?}\nActual pointer: {:#?}",
test.case,
test.description,
pretty_json(&test.schema),
pretty_json(&test.data),
&*error.instance,
&pointer,
);
let output = validator.apply(&test.data).basic();
assert!(
!output.is_valid(),
"Test case should be invalid via basic output:\nCase: {}\nTest: {}\nSchema: {}\nInstance: {}",
test.case,
test.description,
pretty_json(&test.schema),
pretty_json(&test.data),
);
}
}
fn pretty_json(v: &serde_json::Value) -> String {
serde_json::to_string_pretty(v).expect("Failed to format JSON")
}
#[test]
fn test_instance_path() {
let expectations: serde_json::Value =
serde_json::from_str(include_str!("draft7_instance_paths.json")).expect("Valid JSON");
for (filename, expected) in expectations.as_object().expect("Is object") {
let test_file = fs::read_to_string(format!("tests/suite/tests/draft7/{}", filename))
.unwrap_or_else(|_| panic!("Valid file: {}", filename));
let data: serde_json::Value = serde_json::from_str(&test_file).expect("Valid JSON");
for item in expected.as_array().expect("Is array") {
let suite_id = item["suite_id"].as_u64().expect("Is integer") as usize;
let schema = &data[suite_id]["schema"];
let validator = jsonschema::options()
.with_draft(Draft::Draft7)
.build(schema)
.unwrap_or_else(|_| {
panic!(
"Valid schema. File: {}; Suite ID: {}; Schema: {}",
filename, suite_id, schema
)
});
for test_data in item["tests"].as_array().expect("Valid array") {
let test_id = test_data["id"].as_u64().expect("Is integer") as usize;
let mut instance_path = String::new();
for segment in test_data["instance_path"]
.as_array()
.expect("Valid array")
.iter()
{
instance_path.push('/');
instance_path.push_str(segment.as_str().expect("A string"));
}
let instance = &data[suite_id]["tests"][test_id]["data"];
let error = validator.validate(instance).expect_err(&format!(
"\nFile: {}\nSuite: {}\nTest: {}",
filename,
&data[suite_id]["description"],
&data[suite_id]["tests"][test_id]["description"],
));
assert_eq!(
error.instance_path.as_str(),
instance_path,
"\nFile: {}\nSuite: {}\nTest: {}\nError: {}",
filename,
&data[suite_id]["description"],
&data[suite_id]["tests"][test_id]["description"],
&error
)
}
}
}
}
}