bugfix: Support oneOf in array types. (#56)

* bugfix: Support oneOf in array types.

Also make top-level array types expose the same interface as
ProtocolBase (from_json, serialize).

Fixes #49

* bugfix: call validate() when instantiating TypeProxy objects

There are validations that occur based on the presence of properties
(i.e. you cannot assign an object with invalid properties), and there
are different validations that are applied on demand or when serializing
by calling validate() (these are things like 'required' and range
checks). When deciding which type to use from a TypeProxy, we need to
make sure we call validate() because we want to make sure that we
correctly determine which type is valid.

Author: cwacek

python_jsonschema_objects/classbuilder.py

@@ -255,8 +255,8 @@ def validate(self):
 
         propname = lambda x: self.__prop_names__[x]
         missing = [x for x in self.__required__
-                   if propname(x) not in self._properties
-                   or self._properties[propname(x)] is None]
+                   if propname(x) not in self._properties or
+                   self._properties[propname(x)] is None]
 
         if len(missing) > 0:
             raise validators.ValidationError(
@@ -305,6 +305,7 @@ def __call__(self, *a, **kw):
                 self.__class__, klass))
             try:
                 obj = klass(*a, **kw)
+                obj.validate()
             except TypeError as e:
                 validation_errors.append((klass, e))
             except validators.ValidationError as e:

python_jsonschema_objects/validators.py

@@ -166,6 +166,20 @@ def __init__(self, ary):
             raise TypeError("Invalid value given to array validator: {0}"
                             .format(ary))
 
+    @classmethod
+    def from_json(cls, jsonmsg):
+        import json
+        msg = json.loads(jsonmsg)
+        obj = cls(msg)
+        obj.validate()
+        return obj
+
+    @classmethod
+    def serialize(self):
+        self.validate()
+        enc = util.ProtocolJSONEncoder()
+        return enc.encode(self)
+
     def validate(self):
         converted = self.validate_items()
         self.validate_length()
@@ -238,10 +252,12 @@ def validate_items(self):
                     val = elem
                 val.validate()
                 typed_elems.append(val)
+
             elif util.safe_issubclass(typ, ArrayValidator):
                 val = typ(elem)
                 val.validate()
                 typed_elems.append(val)
+
             elif isinstance(typ, classbuilder.TypeProxy):
                 try:
                     if isinstance(elem, (six.string_types, six.integer_types, float)):
@@ -251,8 +267,9 @@ def validate_items(self):
                 except TypeError as e:
                     raise ValidationError("'{0}' is not a valid value for '{1}': {2}"
                                           .format(elem, typ, e))
-                val.validate()
-                typed_elems.append(val)
+                else:
+                    val.validate()
+                    typed_elems.append(val)
 
         return typed_elems
 
@@ -314,11 +331,32 @@ def create(name, item_constraint=None, **addl_constraints):
 
                     item_constraint = klassbuilder.resolved[uri]
 
-                elif isdict and item_constraint['type'] == 'array':
+                elif isdict and item_constraint.get('type') == 'array':
+                    # We need to create a sub-array validator.
                     item_constraint = ArrayValidator.create(name + "#sub",
                                                             item_constraint=item_constraint[
                                                                 'items'],
                                                             addl_constraints=item_constraint)
+                elif isdict and 'oneOf' in item_constraint:
+                    # We need to create a TypeProxy validator
+                    uri = "{0}_{1}".format(name, "<anonymous_list_type>")
+                    type_array = []
+                    for i, item_detail in enumerate(item_constraint['oneOf']):
+                        if '$ref' in item_detail:
+                            subtype = klassbuilder.construct(
+                                util.resolve_ref_uri(
+                                    klassbuilder.resolver.resolution_scope,
+                                    item_detail['$ref']),
+                                item_detail)
+                        else:
+                            subtype = klassbuilder.construct(
+                                uri + "_%s" % i, item_detail)
+
+                        type_array.append(subtype)
+
+                    item_constraint = classbuilder.TypeProxy(type_array)
+
+
 
         props['__itemtype__'] = item_constraint
 

test/test_regression_49.py

@@ -0,0 +1,51 @@
+import pytest
+
+from jsonschema import validate
+import python_jsonschema_objects as pjo
+import json
+
+
+@pytest.fixture
+def bad_schema_49():
+    return {
+        'title': 'example',
+        'type': 'array',
+        'items': {
+            'oneOf': [
+                {
+                    'type': 'object',
+                    'properties': {
+                        'a': {
+                            'type': 'string',
+                        }
+                    },
+                    'required': ['a'],
+                },
+                {
+                    'type': 'object',
+                    'properties': {
+                        'b': {
+                            'type': 'string',
+                        }
+                    },
+                    'required': ['b'],
+                },
+            ]
+        },
+    }
+
+
+@pytest.fixture
+def instance():
+    return [{"a": ''}, {"b": ""}]
+
+
+def test_is_valid_jsonschema(bad_schema_49, instance):
+    validate(instance, bad_schema_49)
+
+
+def test_regression_49(bad_schema_49, instance):
+    builder = pjo.ObjectBuilder(bad_schema_49)
+    ns = builder.build_classes()
+
+    ns.Example.from_json(json.dumps(instance))