def test_cache_remote_on(self): ref = "foo://bar" foo_handler = mock.Mock() resolver = RefResolver( "", {}, cache_remote=True, handlers={"foo": foo_handler}, ) with resolver.resolving(ref): pass with resolver.resolving(ref): pass foo_handler.assert_called_once_with(ref)
def test_it_delegates_to_a_ref_resolver(self): resolver = RefResolver("", {}) schema = {"$ref": mock.Mock()} @contextlib.contextmanager def resolving(): yield {"type": "integer"} with mock.patch.object(resolver, "resolving") as resolve: resolve.return_value = resolving() with self.assertRaises(ValidationError): self.validator_class(schema, resolver=resolver).validate(None) resolve.assert_called_once_with(schema["$ref"])
def test_invalid_format_default_message(self): checker = FormatChecker(formats=()) check_fn = mock.Mock(return_value=False) checker.checks(u"thing")(check_fn) schema = {u"format": u"thing"} message = self.message_for( instance="bla", schema=schema, format_checker=checker, ) self.assertIn(repr("bla"), message) self.assertIn(repr("thing"), message) self.assertIn("is not a", message)
def test_iter_errors(self): instance = "hello" self.smelly.return_value = [] self.assertEqual(list(self.validator.iter_errors(instance)), []) error = mock.Mock() self.smelly.return_value = [error] self.assertEqual(list(self.validator.iter_errors(instance)), [error]) self.smelly.assert_called_with( self.validator, self.validator_value, instance, self.schema, )
def test_extend(self): original_validators = dict(self.Validator.VALIDATORS) new = mock.Mock() Extended = validators.extend( self.Validator, validators={u"a new one": new}, ) original_validators.update([(u"a new one", new)]) self.assertEqual(Extended.VALIDATORS, original_validators) self.assertNotIn(u"a new one", self.Validator.VALIDATORS) self.assertEqual(Extended.META_SCHEMA, self.Validator.META_SCHEMA) self.assertEqual(Extended.DEFAULT_TYPES, self.Validator.DEFAULT_TYPES) self.assertEqual(Extended.TYPE_CHECKER, self.Validator.TYPE_CHECKER)
def test_it_validates_formats_of_any_type(self): checker = mock.Mock(spec=FormatChecker) validator = self.validator_class( {"format": "foo"}, format_checker=checker, ) validator.validate([1, 2, 3]) checker.check.assert_called_once_with([1, 2, 3], "foo") cause = ValueError() checker.check.side_effect = FormatError('aoeu', cause=cause) with self.assertRaises(ValidationError) as cm: validator.validate([1, 2, 3]) # Make sure original cause is attached self.assertIs(cm.exception.cause, cause)
def test_it_validates_formats_if_a_checker_is_provided(self): checker = mock.Mock(spec=FormatChecker) validator = self.validator_class( {"format": "foo"}, format_checker=checker, ) validator.validate("bar") checker.check.assert_called_once_with("bar", "foo") cause = ValueError() checker.check.side_effect = FormatError("aoeu", cause=cause) with self.assertRaises(ValidationError) as cm: validator.validate("bar") # Make sure original cause is attached self.assertIs(cm.exception.cause, cause)
def resolve(self, reference): _, _, reference = reference.partition("http://localhost:1234/") return mock.Mock(**{"json.return_value": REMOTES.get(reference)})
def test_any_type_is_valid_for_type_any(self): validator = self.validator_class({"type": "any"}) validator.validate(mock.Mock())
def test_is_type_is_true_for_any_type(self): self.assertTrue(self.validator.is_valid(mock.Mock(), {"type": "any"}))
def test_non_existent_properties_are_ignored(self): instance, my_property, my_value = mock.Mock(), mock.Mock(), mock.Mock() validate(instance=instance, schema={my_property: my_value})
def setUp(self): self.instance = mock.Mock() self.schema = {} self.resolver = mock.Mock() self.validator = self.validator_class(self.schema)
def setUp(self): self.fn = mock.Mock()
class Validator(ValidatorMixin): validate_ref = mock.Mock(return_value=[]) validate_type = mock.Mock(return_value=[])