Skip to content

Commit

Permalink
Remove default types (in favor of the TypeChecker API).
Browse files Browse the repository at this point in the history 
This has been deprecated for ~2 years, so should be good to go.

Closes: #681.
  • Loading branch information
@Julian
Julian committed May 4, 2021
1 parent 83c652f commit d9f6384
Show file tree
Hide file tree
Showing 3 changed files with 2 additions and 397 deletions.
30 changes: 0 additions & 30 deletions jsonschema/tests/test_jsonschema_test_suite.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,6 @@
"""

import sys
import warnings

from jsonschema import (
Draft3Validator,
Expand All @@ -21,7 +20,6 @@
)
from jsonschema.tests._helpers import bug
from jsonschema.tests._suite import Suite
from jsonschema.validators import _DEPRECATED_DEFAULT_TYPES, create

SUITE = Suite()
DRAFT3 = SUITE.version(name="draft3")
Expand Down Expand Up @@ -498,31 +496,3 @@ def leap_second(test):
)(test)
),
)


with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)

TestDraft3LegacyTypeCheck = DRAFT3.to_unittest_testcase(
# Interestingly the any part couldn't really be done w/the old API.
(
(test for test in each if test.schema != {"type": "any"})
for each in DRAFT3.tests_of(name="type")
),
name="TestDraft3LegacyTypeCheck",
Validator=create(
meta_schema=Draft3Validator.META_SCHEMA,
validators=Draft3Validator.VALIDATORS,
default_types=_DEPRECATED_DEFAULT_TYPES,
),
)

TestDraft4LegacyTypeCheck = DRAFT4.to_unittest_testcase(
DRAFT4.tests_of(name="type"),
name="TestDraft4LegacyTypeCheck",
Validator=create(
meta_schema=Draft4Validator.META_SCHEMA,
validators=Draft4Validator.VALIDATORS,
default_types=_DEPRECATED_DEFAULT_TYPES,
),
)
220 changes: 0 additions & 220 deletions jsonschema/tests/test_validators.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -176,226 +176,6 @@ def id_of(schema):
self.assertEqual(Derived.ID_OF(Derived.META_SCHEMA), correct_id)


class TestLegacyTypeChecking(SynchronousTestCase):
def test_create_default_types(self):
Validator = validators.create(meta_schema={}, validators=())
self.assertEqual(
set(Validator.DEFAULT_TYPES), {
u"array",
u"boolean",
u"integer",
u"null",
u"number",
u"object", u"string",
},
)
self.flushWarnings()

def test_extend(self):
Validator = validators.create(meta_schema={}, validators=())
original = dict(Validator.VALIDATORS)
new = object()

Extended = validators.extend(
Validator,
validators={u"new": new},
)
self.assertEqual(
(
Extended.VALIDATORS,
Extended.META_SCHEMA,
Extended.TYPE_CHECKER,
Validator.VALIDATORS,

Extended.DEFAULT_TYPES,
Extended({}).DEFAULT_TYPES,
self.flushWarnings()[0]["message"],
), (
dict(original, new=new),
Validator.META_SCHEMA,
Validator.TYPE_CHECKER,
original,

Validator.DEFAULT_TYPES,
Validator.DEFAULT_TYPES,
self.flushWarnings()[0]["message"],
),
)

def test_types_redefines_the_validators_type_checker(self):
schema = {"type": "string"}
self.assertFalse(validators.Draft7Validator(schema).is_valid(12))

validator = validators.Draft7Validator(
schema,
types={"string": (str, int)},
)
self.assertTrue(validator.is_valid(12))
self.flushWarnings()

def test_providing_default_types_warns(self):
self.assertWarns(
category=DeprecationWarning,
message=(
"The default_types argument is deprecated. "
"Use the type_checker argument instead."
),
# https://tm.tl/9363 :'(
filename=sys.modules[self.assertWarns.__module__].__file__,

f=validators.create,
meta_schema={},
validators={},
default_types={"foo": object},
)

def test_cannot_ask_for_default_types_with_non_default_type_checker(self):
"""
We raise an error when you ask a validator with non-default
type checker for its DEFAULT_TYPES.
The type checker argument is new, so no one but this library
itself should be trying to use it, and doing so while then
asking for DEFAULT_TYPES makes no sense (not to mention is
deprecated), since type checkers are not strictly about Python
type.
"""
Validator = validators.create(
meta_schema={},
validators={},
type_checker=TypeChecker(),
)
with self.assertRaises(validators._DontDoThat) as e:
Validator.DEFAULT_TYPES

self.assertIn(
"DEFAULT_TYPES cannot be used on Validators using TypeCheckers",
str(e.exception),
)
with self.assertRaises(validators._DontDoThat):
Validator({}).DEFAULT_TYPES

self.assertFalse(self.flushWarnings())

def test_providing_explicit_type_checker_does_not_warn(self):
Validator = validators.create(
meta_schema={},
validators={},
type_checker=TypeChecker(),
)
self.assertFalse(self.flushWarnings())

Validator({})
self.assertFalse(self.flushWarnings())

def test_providing_neither_does_not_warn(self):
Validator = validators.create(meta_schema={}, validators={})
self.assertFalse(self.flushWarnings())

Validator({})
self.assertFalse(self.flushWarnings())

def test_providing_default_types_with_type_checker_errors(self):
with self.assertRaises(TypeError) as e:
validators.create(
meta_schema={},
validators={},
default_types={"foo": object},
type_checker=TypeChecker(),
)

self.assertIn(
"Do not specify default_types when providing a type checker",
str(e.exception),
)
self.assertFalse(self.flushWarnings())

def test_extending_a_legacy_validator_with_a_type_checker_errors(self):
Validator = validators.create(
meta_schema={},
validators={},
default_types={u"array": list}
)
with self.assertRaises(TypeError) as e:
validators.extend(
Validator,
validators={},
type_checker=TypeChecker(),
)

self.assertIn(
(
"Cannot extend a validator created with default_types "
"with a type_checker. Update the validator to use a "
"type_checker when created."
),
str(e.exception),
)
self.flushWarnings()

def test_extending_a_legacy_validator_does_not_rewarn(self):
Validator = validators.create(meta_schema={}, default_types={})
self.assertTrue(self.flushWarnings())

validators.extend(Validator)
self.assertFalse(self.flushWarnings())

def test_accessing_default_types_warns(self):
Validator = validators.create(meta_schema={}, validators={})
self.assertFalse(self.flushWarnings())

self.assertWarns(
DeprecationWarning,
(
"The DEFAULT_TYPES attribute is deprecated. "
"See the type checker attached to this validator instead."
),
# https://tm.tl/9363 :'(
sys.modules[self.assertWarns.__module__].__file__,

getattr,
Validator,
"DEFAULT_TYPES",
)

def test_accessing_default_types_on_the_instance_warns(self):
Validator = validators.create(meta_schema={}, validators={})
self.assertFalse(self.flushWarnings())

self.assertWarns(
DeprecationWarning,
(
"The DEFAULT_TYPES attribute is deprecated. "
"See the type checker attached to this validator instead."
),
# https://tm.tl/9363 :'(
sys.modules[self.assertWarns.__module__].__file__,

getattr,
Validator({}),
"DEFAULT_TYPES",
)

def test_providing_types_to_init_warns(self):
Validator = validators.create(meta_schema={}, validators={})
self.assertFalse(self.flushWarnings())

self.assertWarns(
category=DeprecationWarning,
message=(
"The types argument is deprecated. "
"Provide a type_checker to jsonschema.validators.extend "
"instead."
),
# https://tm.tl/9363 :'(
filename=sys.modules[self.assertWarns.__module__].__file__,

f=Validator,
schema={},
types={"bar": object},
)


class TestIterErrors(TestCase):
def setUp(self):
self.validator = validators.Draft3Validator({})
Expand Down
Loading

0 comments on commit d9f6384

Please sign in to comment.