anyOf

.github/workflows/linting.yml

@@ -26,4 +26,5 @@ jobs:
           VALIDATE_PYTHON_PYLINT: true
           LINTER_RULES_PATH: '.'
           PYTHON_FLAKE8_CONFIG_FILE: .flake8
+          PYTHON_ISORT_CONFIG_FILE: .isort.cfg
           PYTHON_PYLINT_CONFIG_FILE: .pylintrc

.isort.cfg

@@ -0,0 +1,2 @@
+[settings]
+skip=tests,venv

json_schema_fuzz/__init__.py

@@ -4,6 +4,8 @@
 
 import exrex
 
+from .merging import merge, merge_list
+
 
 def random_integer(schema):
     """Generate random integer."""
@@ -12,8 +14,10 @@ def random_integer(schema):
 
 def random_object(schema):
     """Generate random JSON object."""
+
     properties = schema.get("properties", dict())
     required = schema.get("required", [])
+
     object = dict()
     for key, value in properties.items():
         if key in required or random.choice([True, False]):
@@ -54,7 +58,29 @@ def random_array(schema):
 
 def generate_json(schema):
     """Generate random JSON conforming to schema."""
+
+    # Merge allOf subschemas into the base schema
+    all_of = schema.get("allOf", [])
+    for subschema in all_of:
+        schema = merge(schema, subschema)
+
+    any_of = schema.get("anyOf", None)
+    if any_of:
+        found = False
+        while not found:
+            # Pick a random sample of the any_of sublist
+            # and determine whether it is valid
+            chosen_anyof = random.sample(
+                any_of, random.randint(1, len(any_of)))
+            try:
+                combined_anyof_schema = merge_list(chosen_anyof)
+                found = True
+            except NotImplementedError:
+                pass
+        schema = merge(schema, combined_anyof_schema)
+
     type = schema.get("type", None)
+
     if type == "integer":
         return random_integer(schema)
     elif type == "object":

json_schema_fuzz/merging.py

@@ -0,0 +1,50 @@
+"""Merging."""
+import copy
+from typing import Any, Dict, List
+
+
+def merge(
+    schema_a: Dict[Any, Any],
+    schema_b: Dict[Any, Any],
+    path: List[Any] = None,
+    in_place: bool = False,
+):
+    """Merge two JSON schemas recursively."""
+    if path is None:
+        path = []
+
+    if not in_place:
+        # Make a copy of a so that it doesn't get modified in place
+        schema_a = copy.deepcopy(schema_a)
+
+    for key in schema_b:
+        if key not in schema_a:
+            schema_a[key] = schema_b[key]
+            continue
+        if isinstance(schema_a[key], dict) and isinstance(schema_b[key], dict):
+            merge(schema_a[key], schema_b[key],
+                  path=path + [str(key)],
+                  in_place=True)
+        elif schema_a[key] == schema_b[key]:
+            pass  # same leaf value
+        elif (
+                isinstance(schema_a[key], list)
+                and isinstance(schema_b[key], list)
+        ):
+            # Append lists together
+            schema_a[key].extend(schema_b[key])
+        else:
+            raise NotImplementedError(
+                f"Conflicting key {key} encountered in path {path}")
+    if in_place:
+        return None
+    else:
+        return schema_a
+
+
+def merge_list(schemas: List[Dict]) -> Dict:
+    """ Merge a list of JSON schemas together """
+    combined_schema = {}
+    for schema in schemas:
+        merge(combined_schema, schema, in_place=True)
+    return combined_schema

tests/merge_cases/empties.json

@@ -0,0 +1,7 @@
+{
+    "schemas": [
+        {},
+        {}
+    ],
+    "merged": {}
+}

tests/test_generator.py

@@ -28,6 +28,21 @@ def test_object():
     assert isinstance(output.get("a", 0), int)
 
 
+def test_allof():
+    """Test a schema with an allOf property"""
+    schema = {
+        "type": "object",
+        "allOf": [
+            {"properties": {"a": {"type": "integer"}}, "required": ["a"]},
+            {"properties": {"b": {"type": "integer"}}, "required": ["b"]},
+        ],
+    }
+    output = generate_json(schema)
+    assert isinstance(output, dict)
+    assert isinstance(output["a"], int)
+    assert isinstance(output["b"], int)
+
+
 def test_boolean():
     """Test generating booleans."""
     schema = {
@@ -73,3 +88,19 @@ def test_no_pattern_string():
     }
     output = generate_json(schema)
     assert isinstance(output, str)
+
+
+def test_anyof():
+    """Test generating an object from an anyOf schema."""
+    schema = {
+        "anyOf": [
+            {
+                "type": "string",
+            },
+            {
+                "type": "integer",
+            },
+        ],
+    }
+    output = generate_json(schema)
+    assert isinstance(output, (str, int))

tests/test_merging.py

@@ -0,0 +1,53 @@
+"""Test JSON schema merging."""
+import glob
+import json
+from pathlib import Path
+
+import pytest
+
+from json_schema_fuzz.merging import merge
+
+THIS_DIR = Path(__file__).parent
+CASE_DIR = THIS_DIR / "merge_cases"
+case_files = glob.glob(str(CASE_DIR / "*.json"))
+cases = []
+for filename in case_files:
+    with open(filename, "r") as stream:
+        case = json.load(stream)
+        cases.append((case["schemas"], case["merged"]))
+
+
+@pytest.mark.parametrize("schemas,merged", cases)
+def test_merging(schemas, merged):
+    """Test that merging the `schemas` results in the `merged` schema."""
+    assert merge(*schemas) == merged
+
+
+def test_merge_doesnt_modify():
+    """ Test that merging doesn't modify input values """
+    required_a = ["required_property"]
+    schema_a = {"required": required_a}
+    schema_b = {"required": ["another_required_property"]}
+    merged = merge(schema_a, schema_b)
+
+    assert len(merged['required']) == 2
+    assert len(required_a) == 1
+
+
+def test_merge_conflicting():
+    """Test that merging conflicting values throws a NotImplementedError."""
+    schema_a = {"multipleOf": 3}
+    schema_b = {"multipleOf": 5}
+
+    with pytest.raises(NotImplementedError):
+        merge(schema_a, schema_b)
+
+
+def test_merge_nested():
+    """ Test that merging nested dictionaries works """
+    schema_a = {"properties": {"a": "value"}}
+    schema_b = {"properties": {"b": "value"}}
+    merged = merge(schema_a, schema_b)
+
+    assert 'a' in merged['properties']
+    assert 'b' in merged['properties']