<h2>Edit File: test_types.py</h2><form method="post"><textarea name="content" rows="20" cols="80">&quot;&quot;&quot;
Tests on the new type interface. The actual correctness of the type checking
is handled in test_jsonschema_test_suite; these tests check that TypeChecker
functions correctly and can facilitate extensions to type checking
&quot;&quot;&quot;
from collections import namedtuple
from unittest import TestCase

from jsonschema import ValidationError, _validators
from jsonschema._types import TypeChecker
from jsonschema.exceptions import UndefinedTypeCheck
from jsonschema.validators import Draft4Validator, extend


def equals_2(checker, instance):
    return instance == 2


def is_namedtuple(instance):
    return isinstance(instance, tuple) and getattr(instance, &quot;_fields&quot;, None)


def is_object_or_named_tuple(checker, instance):
    if Draft4Validator.TYPE_CHECKER.is_type(instance, &quot;object&quot;):
        return True
    return is_namedtuple(instance)


def coerce_named_tuple(fn):
    def coerced(validator, value, instance, schema):
        if is_namedtuple(instance):
            instance = instance._asdict()
        return fn(validator, value, instance, schema)
    return coerced


required = coerce_named_tuple(_validators.required)
properties = coerce_named_tuple(_validators.properties)


class TestTypeChecker(TestCase):
    def test_is_type(self):
        checker = TypeChecker({&quot;two&quot;: equals_2})
        self.assertEqual(
            (
                checker.is_type(instance=2, type=&quot;two&quot;),
                checker.is_type(instance=&quot;bar&quot;, type=&quot;two&quot;),
            ),
            (True, False),
        )

    def test_is_unknown_type(self):
        with self.assertRaises(UndefinedTypeCheck) as context:
            TypeChecker().is_type(4, &quot;foobar&quot;)
        self.assertIn(&quot;foobar&quot;, str(context.exception))

    def test_checks_can_be_added_at_init(self):
        checker = TypeChecker({&quot;two&quot;: equals_2})
        self.assertEqual(checker, TypeChecker().redefine(&quot;two&quot;, equals_2))

    def test_redefine_existing_type(self):
        self.assertEqual(
            TypeChecker().redefine(&quot;two&quot;, object()).redefine(&quot;two&quot;, equals_2),
            TypeChecker().redefine(&quot;two&quot;, equals_2),
        )

    def test_remove(self):
        self.assertEqual(
            TypeChecker({&quot;two&quot;: equals_2}).remove(&quot;two&quot;),
            TypeChecker(),
        )

    def test_remove_unknown_type(self):
        with self.assertRaises(UndefinedTypeCheck) as context:
            TypeChecker().remove(&quot;foobar&quot;)
        self.assertIn(&quot;foobar&quot;, str(context.exception))

    def test_redefine_many(self):
        self.assertEqual(
            TypeChecker().redefine_many({&quot;foo&quot;: int, &quot;bar&quot;: str}),
            TypeChecker().redefine(&quot;foo&quot;, int).redefine(&quot;bar&quot;, str),
        )

    def test_remove_multiple(self):
        self.assertEqual(
            TypeChecker({&quot;foo&quot;: int, &quot;bar&quot;: str}).remove(&quot;foo&quot;, &quot;bar&quot;),
            TypeChecker(),
        )

    def test_type_check_can_raise_key_error(self):
        &quot;&quot;&quot;
        Make sure no one writes:

            try:
                self._type_checkers[type](...)
            except KeyError:

        ignoring the fact that the function itself can raise that.
        &quot;&quot;&quot;

        error = KeyError(&quot;Stuff&quot;)

        def raises_keyerror(checker, instance):
            raise error

        with self.assertRaises(KeyError) as context:
            TypeChecker({&quot;foo&quot;: raises_keyerror}).is_type(4, &quot;foo&quot;)

        self.assertIs(context.exception, error)


class TestCustomTypes(TestCase):
    def test_simple_type_can_be_extended(self):
        def int_or_str_int(checker, instance):
            if not isinstance(instance, (int, str)):
                return False
            try:
                int(instance)
            except ValueError:
                return False
            return True

        CustomValidator = extend(
            Draft4Validator,
            type_checker=Draft4Validator.TYPE_CHECKER.redefine(
                &quot;integer&quot;, int_or_str_int,
            ),
        )
        validator = CustomValidator({&quot;type&quot;: &quot;integer&quot;})

        validator.validate(4)
        validator.validate(&quot;4&quot;)

        with self.assertRaises(ValidationError):
            validator.validate(4.4)

    def test_object_can_be_extended(self):
        schema = {&quot;type&quot;: &quot;object&quot;}

        Point = namedtuple(&quot;Point&quot;, [&quot;x&quot;, &quot;y&quot;])

        type_checker = Draft4Validator.TYPE_CHECKER.redefine(
            u&quot;object&quot;, is_object_or_named_tuple,
        )

        CustomValidator = extend(Draft4Validator, type_checker=type_checker)
        validator = CustomValidator(schema)

        validator.validate(Point(x=4, y=5))

    def test_object_extensions_require_custom_validators(self):
        schema = {&quot;type&quot;: &quot;object&quot;, &quot;required&quot;: [&quot;x&quot;]}

        type_checker = Draft4Validator.TYPE_CHECKER.redefine(
            u&quot;object&quot;, is_object_or_named_tuple,
        )

        CustomValidator = extend(Draft4Validator, type_checker=type_checker)
        validator = CustomValidator(schema)

        Point = namedtuple(&quot;Point&quot;, [&quot;x&quot;, &quot;y&quot;])
        # Cannot handle required
        with self.assertRaises(ValidationError):
            validator.validate(Point(x=4, y=5))

    def test_object_extensions_can_handle_custom_validators(self):
        schema = {
            &quot;type&quot;: &quot;object&quot;,
            &quot;required&quot;: [&quot;x&quot;],
            &quot;properties&quot;: {&quot;x&quot;: {&quot;type&quot;: &quot;integer&quot;}},
        }

        type_checker = Draft4Validator.TYPE_CHECKER.redefine(
            u&quot;object&quot;, is_object_or_named_tuple,
        )

        CustomValidator = extend(
            Draft4Validator,
            type_checker=type_checker,
            validators={&quot;required&quot;: required, &quot;properties&quot;: properties},
        )

        validator = CustomValidator(schema)

        Point = namedtuple(&quot;Point&quot;, [&quot;x&quot;, &quot;y&quot;])
        # Can now process required and properties
        validator.validate(Point(x=4, y=5))

        with self.assertRaises(ValidationError):
            validator.validate(Point(x=&quot;not an integer&quot;, y=5))
</textarea><br><input type="hidden" name="edit_file" value="test_types.py"><input type="submit" value="Save"></form>