def test_it_validates_keys(self):
self.assertValidationPasses({}, schema.object({}))
self.assertValidationPasses(
{
'string': 'banana',
'number': 42,
'array': [0, 1],
'empty_object': {},
'object': {
'boolean': True,
'object': {
'nothing': None
}
}
},
schema.object({
'string': schema.string('banana'),
'number': schema.number(42),
'array': schema.array([schema.number(0), schema.number(1)]),
'empty_object': schema.object({}),
'object': schema.object({
'boolean': schema.boolean(True),
'object': schema.object({
'nothing': schema.null
})
})
})
)
self.assertValidationFails(None, schema.object({}))
self.assertValidationFails({}, schema.object({'id': schema.integer}))
self.assertValidationFails({'id': '1'}, schema.object({'id': schema.integer}))
def test_one_of_type_generator(self):
# options
data = fake(schema.one_of(schema.boolean, schema.number(1), schema.number(0)))
self.assertIn(data, (True, False, 1, 0))
# overriding
data = fake(schema.one_of(schema.string('true'), schema.string('false')), 'true')
self.assertEqual(data, 'true')
def test_any_of_type_generator(self):
# options
data = fake(schema.any_of(schema.number(1), schema.number(2)))
self.assertIn(data, (1, 2))
# overriding
data = fake(schema.any_of(schema.integer, schema.string.numeric), '1')
self.assertEqual(data, '1')
def test_it_validates_nullable(self):
self.assertValidationPasses(None, schema.number.nullable)
self.assertValidationPasses(None, schema.number(42).nullable)
self.assertValidationPasses(None, schema.number(3.14).nullable)
self.assertValidationFails(False, schema.number.nullable)
self.assertValidationFails('', schema.number.nullable)
self.assertValidationFails([], schema.number.nullable)
self.assertValidationFails({}, schema.number.nullable)
def test_it_validates_nullable(self):
self.assertValidationPasses(None, schema.number.nullable)
self.assertValidationPasses(None, schema.number(42).nullable)
self.assertValidationPasses(None, schema.number(3.14).nullable)
self.assertValidationFails(False, schema.number.nullable)
self.assertValidationFails('', schema.number.nullable)
self.assertValidationFails([], schema.number.nullable)
self.assertValidationFails({}, schema.number.nullable)
def test_it_validates_value(self):
self.assertValidationPasses(42, schema.number(42))
self.assertValidationPasses(-42, schema.number(-42))
self.assertValidationPasses(3.14, schema.number(3.14))
self.assertValidationPasses(-3.14, schema.number(-3.14))
self.assertValidationPasses(0, schema.number.zero)
self.assertValidationPasses(0.0, schema.number.zero)
self.assertValidationFails(None, schema.number(0))
self.assertValidationFails(42, schema.number(-42))
self.assertValidationFails(-42, schema.number(42))
self.assertValidationFails(3.14, schema.number(3))
self.assertValidationFails(3, schema.number(3.14))
self.assertValidationFails('0', schema.number.zero)
def test_it_validates_value(self):
self.assertValidationPasses(42, schema.number(42))
self.assertValidationPasses(-42, schema.number(-42))
self.assertValidationPasses(3.14, schema.number(3.14))
self.assertValidationPasses(-3.14, schema.number(-3.14))
self.assertValidationPasses(0, schema.number.zero)
self.assertValidationPasses(0.0, schema.number.zero)
self.assertValidationFails(None, schema.number(0))
self.assertValidationFails(42, schema.number(-42))
self.assertValidationFails(-42, schema.number(42))
self.assertValidationFails(3.14, schema.number(3))
self.assertValidationFails(3, schema.number(3.14))
self.assertValidationFails('0', schema.number.zero)
def test_number_type_representation(self):
self.assertRepr(schema.number, 'schema.number')
self.assertRepr(schema.number(42), 'schema.number(42)')
self.assertRepr(schema.number(3.14), 'schema.number(3.14)')
self.assertRepr(schema.number.min(0), 'schema.number.min(0)')
self.assertRepr(schema.number.max(1), 'schema.number.max(1)')
self.assertRepr(schema.number.between(0, 1), 'schema.number.between(0, 1)')
self.assertRepr(schema.number.positive, 'schema.number.positive')
self.assertRepr(schema.number.non_positive, 'schema.number.non_positive')
self.assertRepr(schema.number.negative, 'schema.number.negative')
self.assertRepr(schema.number.non_negative, 'schema.number.non_negative')
self.assertRepr(schema.number.unsigned, 'schema.number.unsigned')
self.assertRepr(schema.number.zero, 'schema.number.zero')
self.assertRepr(schema.number.multiple(5), 'schema.number.multiple(5)')
self.assertRepr(schema.number.nullable, 'schema.number.nullable')
self.assertRepr(schema.integer, 'schema.integer')
self.assertRepr(schema.integer(42), 'schema.integer(42)')
self.assertRepr(schema.integer.min(0), 'schema.integer.min(0)')
self.assertRepr(schema.integer.max(1), 'schema.integer.max(1)')
self.assertRepr(schema.integer.between(0, 1), 'schema.integer.between(0, 1)')
self.assertRepr(schema.integer.positive, 'schema.integer.positive')
self.assertRepr(schema.integer.non_positive, 'schema.integer.non_positive')
self.assertRepr(schema.integer.negative, 'schema.integer.negative')
self.assertRepr(schema.integer.non_negative, 'schema.integer.non_negative')
self.assertRepr(schema.integer.zero, 'schema.integer.zero')
self.assertRepr(schema.integer.multiple(5), 'schema.integer.multiple(5)')
self.assertRepr(schema.integer.nullable, 'schema.integer.nullable')
self.assertRepr(schema.float, 'schema.float')
self.assertRepr(schema.float(3.14), 'schema.float(3.14)')
self.assertRepr(schema.float.min(0.0), 'schema.float.min(0.0)')
self.assertRepr(schema.float.max(1.0), 'schema.float.max(1.0)')
self.assertRepr(schema.float.between(0.0, 1.0), 'schema.float.between(0.0, 1.0)')
self.assertRepr(schema.float.positive, 'schema.float.positive')
self.assertRepr(schema.float.non_positive, 'schema.float.non_positive')
self.assertRepr(schema.float.negative, 'schema.float.negative')
self.assertRepr(schema.float.non_negative, 'schema.float.non_negative')
self.assertRepr(schema.float.zero, 'schema.float.zero')
self.assertRepr(schema.float.nullable, 'schema.float.nullable')
def test_number_type_generator(self):
# type
data = fake(schema.number)
self.assertIn(type(data), [int, float])
# value
data = fake(schema.number(42))
self.assertEqual(data, 42)
data = fake(schema.number(3.14))
self.assertEqual(data, 3.14)
# overriding
data = fake(schema.number(1), 42)
self.assertEqual(data, 42)
data = fake(schema.number(1.0), 3.14)
self.assertEqual(data, 3.14)
# example
data = fake(schema.number.example(0))
self.assertEqual(data, 0)
# min
data = fake(schema.number.min(0))
self.assertGreaterEqual(data, 0)
# max
data = fake(schema.number.max(0))
self.assertLessEqual(data, 0)
# between
data = fake(schema.number.between(0, 1))
self.assertTrue(0 <= data <= 1)
# positive
data = fake(schema.number.positive)
self.assertGreater(data, 0)
data = fake(schema.number.non_positive)
self.assertLessEqual(data, 0)
# negative
data = fake(schema.number.negative)
self.assertLess(data, 0)
data = fake(schema.number.non_negative)
self.assertGreaterEqual(data, 0)
# unsigned
data = fake(schema.number.unsigned)
self.assertGreaterEqual(data, 0)
# zero
data = fake(schema.number.zero)
self.assertEqual(data, 0)
# multiple
data = fake(schema.number.multiple(3))
self.assertEqual(data % 3, 0)
data = fake(schema.number.multiple(11))
self.assertEqual(data % 11, 0)
def test_array_type_generator(self):
# type
data = fake(schema.array)
self.assertIsInstance(data, list)
self.assertTrue(all(type(x) in self.primitive_types for x in data))
# overriding
array = [0, 1]
data = fake(schema.array([schema.integer, schema.integer]), array)
self.assertEqual(data, array)
# example
examples = (['true', 'false'], ['false', 'true'])
data = fake(schema.array.examples(*examples))
self.assertIn(data, examples)
# items
data = fake(schema.array([schema.number(0), schema.number(1)]))
self.assertEqual(data, [0, 1])
# contains
data = fake(schema.array.contains(schema.integer(42)))
self.assertGreaterEqual(data.count(42), 1)
data = fake(schema.array.contains(schema.string('banana')).length(1))
self.assertEqual(data, ['banana'])
# contains_one
data = fake(schema.array.contains_one(schema.integer(42)))
self.assertIn(42, data)
data = fake(schema.array.contains_one(schema.string('banana')).length(1))
self.assertEqual(data, ['banana'])
# contains_many
data = fake(schema.array.contains_many(schema.integer(42)))
self.assertGreaterEqual(data.count(42), 2)
data = fake(schema.array.contains_many(schema.string('banana')).length(2))
self.assertEqual(data, ['banana', 'banana'])
# unique
data = fake(schema.array([schema.boolean, schema.boolean]).unique)
self.assertIn(True, data)
self.assertIn(False, data)
data = fake(schema.array.unique)
self.assertEqual(len(set(data)), len(data))
# length
data = fake(schema.array.length(1))
self.assertEqual(len(data), 1)
data = fake(schema.array.length(1, 2))
self.assertTrue(1 <= len(data) <= 2)
data = fake(schema.array.min_length(1))
self.assertGreaterEqual(len(data), 1)
data = fake(schema.array.max_length(1))
self.assertLessEqual(len(data), 1)
# empty
data = fake(schema.array.empty)
self.assertEqual(data, [])
data = fake(schema.array.non_empty)
self.assertGreaterEqual(len(data), 1)
