jsoncompat 0.3.1

JSON Schema Compatibility Checker
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use criterion::{Criterion, criterion_group, criterion_main};
use json_schema_ast::SchemaDocument;
use json_schema_fuzz::{GenerationConfig, ValueGenerator};
use jsoncompat::{Role, check_compat};
use rand::SeedableRng;
use rand::rngs::StdRng;
use serde_json::{Value, json};
use std::hint::black_box;

fn bench_generate_value_with_raw_validation(c: &mut Criterion) {
    let schema = SchemaDocument::from_json(&json!({
        "allOf": [
            {
                "type": "object",
                "properties": {
                    "kind": { "enum": ["a", "b", "c"] },
                    "payload": {
                        "anyOf": [
                            {
                                "type": "object",
                                "properties": {
                                    "count": { "type": "integer", "minimum": 0, "maximum": 100 },
                                    "enabled": { "type": "boolean" }
                                },
                                "required": ["count"]
                            },
                            {
                                "type": "object",
                                "properties": {
                                    "label": { "type": "string", "pattern": "^[a-z]{3}$" }
                                },
                                "required": ["label"]
                            }
                        ]
                    }
                },
                "required": ["kind", "payload"]
            },
            {
                "type": "object",
                "propertyNames": { "pattern": "^[a-z]+$" },
                "minProperties": 2
            }
        ]
    }))
    .unwrap();

    let _ = schema.root().unwrap();
    let _ = schema.is_valid(&json!({})).unwrap();

    c.bench_function("generate_value/raw_validated", |b| {
        let config = GenerationConfig::new(6);
        let mut rng = StdRng::seed_from_u64(42);
        b.iter(|| {
            black_box(ValueGenerator::generate(
                black_box(&schema),
                black_box(config),
                black_box(&mut rng),
            ))
            .unwrap()
        });
    });
}

fn bench_is_subschema_of_with_cached_sup_validator(c: &mut Criterion) {
    let enum_branches = (0..64)
        .map(|value| json!({ "enum": [{ "kind": "entry", "value": value }] }))
        .collect::<Vec<Value>>();

    let sub = SchemaDocument::from_json(&json!({ "anyOf": enum_branches })).unwrap();
    let sup = SchemaDocument::from_json(&json!({
        "type": "object",
        "properties": {
            "kind": { "const": "entry" },
            "value": { "type": "integer", "minimum": 0, "maximum": 100 }
        },
        "required": ["kind", "value"],
        "additionalProperties": false
    }))
    .unwrap();

    c.bench_function("is_subschema_of/cached_sup_validator", |b| {
        b.iter(|| {
            black_box(check_compat(
                black_box(&sup),
                black_box(&sub),
                black_box(Role::Serializer),
            ))
            .unwrap()
        });
    });
}

criterion_group!(
    benches,
    bench_generate_value_with_raw_validation,
    bench_is_subschema_of_with_cached_sup_validator
);
criterion_main!(benches);