Ejemplo n.º 1
0
 def test_optional_validation(self):
     """Fields are required by default but can be made optional"""
     fields = [
         IntegerField(required=False),
         UnicodeField(required=False),
         ObjectField(required=False),
         ArrayField(required=False),
         IsoDateString(required=False),
         # subschema tested elsewhere...
     ]
     for field in fields:
         assert field.validate(None)
Ejemplo n.º 2
0
    def test_object_serialization(self):
        field = ObjectField()

        self.assertEqual({}, field.serialize(None))

        self.assertEqual([], field.serialize([]))

        self.assertEqual("wow", field.serialize("wow"))

        source = {"wow": "cool"}
        self.assertEqual(source, field.serialize(source))

        class SomeSchema(Schema):
            great = ArrayField(int)

        source = SomeSchema(great=[1, 2, 3])
        self.assertEqual({"great": [1, 2, 3]}, field.serialize(source))

        source = {"implicit": None}
        self.assertEqual({}, field.serialize(source))
        self.assertEqual(source, field.serialize(source, implicit_nulls=False))
Ejemplo n.º 3
0
    def test_object_validation(self):
        field = ObjectField()

        assert field.validate({})

        assert field.validate({"foo": "bar"})

        with self.assertRaises(Invalid):
            field.validate(1)

        with self.assertRaises(Invalid):
            field.validate([])

        with self.assertRaises(Invalid):
            field.validate(None)

        class SomeSchema(Schema):
            inner = IntegerField()

        assert field.validate(SomeSchema(inner=1))

        with self.assertRaises(Invalid):
            field.validate(SomeSchema(inner="wow"))

        field = ObjectField(required=False)

        assert field.validate({"foo": "bar"})

        assert field.validate(None)