Added support for allOf, anyOf, const, any

.gitignore

@@ -3,4 +3,8 @@
 venv
 *.pyc
 build
-dist
+dist
+.pytest_cache
+.benchmarks
+.hypothesis
+__pycache__

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "python.testing.pytestArgs": [
+        "-vs",
+        "--color=yes",
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.nosetestsEnabled": false,
+    "python.testing.pytestEnabled": true
+}

README.md

@@ -0,0 +1,104 @@
+
+## Hyposchema
+
+```python
+
+from jsonschema import validate
+import json
+from hypothesis import given, settings
+from hyposchema.hypo_schema import generate_from_schema
+
+
+EXAMPLE_JSON_SCHEMA= {
+    "title": "Example Schema",
+    "type": "object",
+    "properties": {
+        "firstName": {
+            "type": "string"
+        },
+                "lastName": {
+                    "type": "string"
+                },
+                "age": {
+                    "description": "Age in years",
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "listOfElements": {
+                    "type": "array",
+                    "items": {
+                        "type": "number"
+                    }
+                },
+                "listOfRandom": {
+                    "min": 4,
+                    "max": 10,
+                    "type": "array"
+                },
+                "type": {
+                    "type": "string",
+                    "enum": ["string", "int", "bool"]
+                },
+                "nestedMap": {
+                    "type": "object",
+                    "properties": {
+                        "firstProp": {
+                            "type": "string"
+                        }
+                    },
+                    "required": ["firstProp"]
+                }
+            },
+            "required": ["firstName", "lastName", "nestedMap", "listOfElements"]
+}
+
+
+
+
+@given(generate_from_schema(EXAMPLE_JSON_SCHEMA))
+@settings(max_examples=10)
+def test_basic_map(example_data):
+    print(json.dumps(example_data, indent=4))
+    validate(example_data, EXAMPLE_JSON_SCHEMA)
+
+test_basic_map()
+
+```
+
+Better using a simpler schema than json-schema, like `skema`:
+
+```python
+
+import skema
+from jsonschema import validate
+import json
+from hypothesis import given, settings
+from hyposchema.hypo_schema import generate_from_schema
+
+EXAMPLE_JSON_SCHEMA=skema.to_jsonschema("""
+Root: EventA & EventB
+EventA:
+    type: Str
+    fields:
+        args: [
+            name: Str
+            type: Str | Any
+        ]
+    ...
+
+EventB:
+    timestamp: Any
+    sentBy: Str
+    madeBy: "me" | "you"
+    ...
+
+""", resolve=True)
+
+@given(generate_from_schema(EXAMPLE_JSON_SCHEMA))
+@settings(max_examples=10)
+def test_basic_map( example_data):
+    print(json.dumps(example_data, indent=4))
+    validate(example_data, EXAMPLE_JSON_SCHEMA)
+
+test_basic_map()
+```

hyposchema/hypo_schema.py

@@ -83,6 +83,10 @@ def gen_enum(prop):
     enum = prop["enum"]
     return hs.sampled_from(enum)
 
+def gen_const(prop):
+    const = prop["const"]
+    return hs.sampled_from([const])
+
 def gen_bool(prop):
     return hs.booleans()
 
@@ -93,6 +97,30 @@ def gen_one_of(prop):
 
     return hs.one_of(possible_values)
 
+def gen_any_of(prop):
+    possible_values = []
+    for value in prop["anyOf"]:
+        possible_values.append(get_generator(value))
+
+    return hs.one_of(possible_values)
+
+def gen_all_of(prop):
+    dicts = prop["allOf"]
+    if not all([d['type'] == 'object' for d in dicts]):
+        raise Exception('allOf is supported as array of object types')
+    result = {
+        'additionalProperties': True,
+        'required': [],
+        'properties': {},
+    }
+    for obj in dicts:
+        result['additionalProperties'] = result['additionalProperties'] and bool(obj.get('additionalProperties', True))
+        result['properties'] = {**result['properties'], **(obj.get('properties', {}) or {})}
+        result['required'] = result['required'] + (obj.get('required', [])  or [])
+    result['required'] = list(set(result['required']))
+    return gen_object(result)
+
+
 
 
 def get_generator(prop):
@@ -103,15 +131,29 @@ def get_generator(prop):
             "object": gen_object,
             "array": gen_array,
     }
+    if not prop:
+        return gen_anything()
 
     enum = prop.get("enum", None)
     if enum is not None:
         return gen_enum(prop)
 
+    const = prop.get("const", None)
+    if const is not None:
+        return gen_const(prop)
+
     one_of = prop.get("oneOf", None)
     if one_of is not None:
         return gen_one_of(prop)
 
+    any_of = prop.get("anyOf", None)
+    if any_of is not None:
+        return gen_any_of(prop)
+
+    all_of = prop.get("allOf", None)
+    if all_of is not None:
+        return gen_all_of(prop)
+
     json_type = prop.get("type", None)
     if json_type is None:
         raise JsonTypeError("Couldnt find type in prop {0}".format(prop))

hyposchema/regex.py

@@ -27,7 +27,7 @@
 from itertools import chain
 
 import hypothesis.strategies as strats
-from hypothesis.strategies import defines_strategy
+from hypothesis._strategies import defines_strategy
 from hypothesis.searchstrategy import SearchStrategy
 from hypothesis.internal.compat import hunichr, hrange
 

requirements.txt

@@ -1,2 +1,3 @@
 twine
 wheel
+skema

tests/skema/test_complex.py

@@ -0,0 +1,36 @@
+
+import skema
+from jsonschema import validate
+import json
+from hypothesis import given, settings
+from hyposchema.hypo_schema import generate_from_schema
+
+
+EXAMPLE_JSON_SCHEMA=skema.to_jsonschema("""
+Root: EventA & EventB
+EventA:
+    type: Str
+    fields:
+        args: [
+            name: Str
+            type: Str | Any
+        ]
+    ...
+
+EventB:
+    timestamp: Any
+    sentBy: Str
+    madeBy: "me" | "you"
+    ...
+
+""", resolve=True)
+
+
+
+
+@given(generate_from_schema(EXAMPLE_JSON_SCHEMA))
+@settings(max_examples=10)
+def test_basic_map( example_data):
+    print(json.dumps(example_data, indent=4))
+    validate(example_data, EXAMPLE_JSON_SCHEMA)
+

tests/skema/test_simple.py

@@ -0,0 +1,26 @@
+
+import skema
+from jsonschema import validate
+import json
+from hypothesis import given, settings
+from hyposchema.hypo_schema import generate_from_schema
+
+
+EXAMPLE_JSON_SCHEMA=skema.to_jsonschema("""
+Root:
+    a: Int
+    b: Str
+    c:
+        x: Any
+        y: Str | Int
+""", resolve=True)
+
+
+
+
+@given(generate_from_schema(EXAMPLE_JSON_SCHEMA))
+@settings(max_examples=10)
+def test_basic_map( example_data):
+    print(json.dumps(example_data, indent=4))
+    validate(example_data, EXAMPLE_JSON_SCHEMA)
+

tests/test_allOf.py

@@ -0,0 +1,63 @@
+import unittest
+
+from jsonschema import validate
+import json
+from hypothesis import given, settings
+from hyposchema.hypo_schema import generate_from_schema
+
+
+EXAMPLE_JSON_SCHEMA= {
+    "title": "Example Schema",
+    "type": "object",
+    "properties": {
+                "firstName": {
+                    "type": "string"
+                },
+                "all": {
+                    'allOf': [
+                        {"type": "object", 'properties': {'a': {}, 'b': {}}, 'required': ['a', 'b'] },
+                        {"type": "object", 'properties': {'c': {}, 'd': {}}, 'required': ['c',] },
+                    ]
+                },
+                "age": {
+                    "description": "Age in years",
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "listOfElements": {
+                    "type": "array",
+                    "items": {
+                        "type": "number"
+                    }
+                },
+                "listOfRandom": {
+                    "min": 4,
+                    "max": 10,
+                    "type": "array"
+                },
+                "type": {
+                    "type": "string",
+                    "enum": ["string", "int", "bool"]
+                },
+                "nestedMap": {
+                    "type": "object",
+                    "properties": {
+                        "firstProp": {
+                            "type": "string"
+                        }
+                    },
+                    "required": ["firstProp"]
+                }
+            },
+            "required": ["all", "nestedMap", "listOfElements"]
+}
+
+
+
+
+@given(generate_from_schema(EXAMPLE_JSON_SCHEMA))
+@settings(max_examples=10)
+def test_basic_map( example_data):
+    print(json.dumps(example_data, indent=4))
+    validate(example_data, EXAMPLE_JSON_SCHEMA)
+