Mercurial > hgrepos > Python > libs > data-schema

diff tests/test_schema.py @ 13:940676a0de84

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ERRORS and WARNINGS are now enums
author Franz Glasner <fzglas.hg@dom66.de>
date Fri, 07 Jul 2023 02:10:32 +0200
parents 84dfd1a94926
children 696b83f29363
line wrap: on
line diff
--- a/tests/test_schema.py	Fri Jul 07 01:32:49 2023 +0200
+++ b/tests/test_schema.py	Fri Jul 07 02:10:32 2023 +0200
@@ -10,6 +10,7 @@
 
 import data_schema
 import data_schema.util
+from data_schema import ERRORS, WARNINGS
 
 
 TYPE_RE = type(re.compile(r"\A.+\Z"))
@@ -1338,18 +1339,15 @@
             self.assertFalse(
                 "no SchemaError raised when a non-dict given as schema")
 
-    def test_problem_ctor_nonexisting_code(self):
-        self.assertRaises(ValueError, data_schema.ValidationProblem, code=2)
-
     def test_problem_ctor_no_code(self):
         self.assertRaises(TypeError, data_schema.ValidationProblem, code=None)
 
     def test_error_ctor(self):
-        v = data_schema.ValidationProblem(code=10000)
+        v = data_schema.ValidationProblem(code=ERRORS.E10000)
         self.assertEqual(data_schema.ERROR, v.severity)
 
     def test_warning_ctor(self):
-        v = data_schema.ValidationProblem(code=80000)
+        v = data_schema.ValidationProblem(code=WARNINGS.W80000)
         self.assertEqual(data_schema.WARNING, v.severity)
 
     def test_d1(self):
@@ -1359,7 +1357,7 @@
     def test_d1_not_nullable(self):
         x = list(data_schema.validate(None, {"type": "dict"}))
         self.assertEqual(1, len(x))
-        self.assertEqual(10000, x[0].code)
+        self.assertEqual(ERRORS.E10000, x[0].code)
 
     def test_d1_nullable(self):
         x = list(data_schema.validate(None, {"type": "dict",
@@ -1370,7 +1368,7 @@
         x = list(data_schema.validate([], {"type": "map"}))
         self.assertEqual(1, len(x))
         self.assertEqual(data_schema.ERROR, x[0].severity)
-        self.assertEqual(10000, x[0].code)
+        self.assertEqual(ERRORS.E10000, x[0].code)
 
     def test_d3(self):
         x = list(data_schema.validate(
@@ -1379,10 +1377,10 @@
              "required": ["key2"]}))
         self.assertEqual(2, len(x))
         self.assertEqual(data_schema.ERROR, x[0].severity)
-        self.assertEqual(10004, x[0].code)
+        self.assertEqual(ERRORS.E10004, x[0].code)
         self.assertEqual("key", x[0].hint)
         self.assertEqual(data_schema.ERROR, x[1].severity)
-        self.assertEqual(10005, x[1].code)
+        self.assertEqual(ERRORS.E10005, x[1].code)
         self.assertEqual(["key2"], x[1].hint)
 
     def test_d4(self):
@@ -1401,7 +1399,7 @@
             {"type": "dict",
              "additionalKeys": False}))
         self.assertEqual(1, len(x))
-        self.assertEqual(10004, x[0].code)
+        self.assertEqual(ERRORS.E10004, x[0].code)
         self.assertEqual("key", x[0].hint)
 
     def test_d5_2(self):
@@ -1429,7 +1427,7 @@
              "additionalKeys": False},
             skip_keys=[re.compile(r"\A__.+"), re.compile(r"\Akey\d+\Z")]))
         self.assertEqual(1, len(x))
-        self.assertEqual(10004, x[0].code)
+        self.assertEqual(ERRORS.E10004, x[0].code)
         self.assertEqual("key", x[0].hint)
 
     def test_d6(self):
@@ -1454,7 +1452,7 @@
              "additionalKeys": {
                  "type": "string"}}))
         self.assertEqual(1, len(x))
-        self.assertEqual(10002, x[0].code)
+        self.assertEqual(ERRORS.E10002, x[0].code)
         self.assertEqual(1234, x[0].hint)
 
     def test_d8_2(self):
@@ -1472,7 +1470,7 @@
             {"type": "dict",
              "additionalKeys": True}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10003, pr[0].code)
+        self.assertEqual(ERRORS.E10003, pr[0].code)
 
     def test_d10_int_dict_keys(self):
         pr = list(data_schema.validate(
@@ -1486,17 +1484,17 @@
 
     def test_error_message(self):
         self.assertEqual("dict expected",
-                         data_schema.problem_message(10000))
-        pr = data_schema.ValidationProblem(code=10000)
+                         data_schema.problem_message(ERRORS.E10000))
+        pr = data_schema.ValidationProblem(code=ERRORS.E10000)
         self.assertEqual("dict expected", data_schema.problem_message(pr))
 
         self.assertEqual("duplicate dict key",
-                         data_schema.problem_message(80000))
-        pr = data_schema.ValidationProblem(code=80000)
+                         data_schema.problem_message(WARNINGS.W80000))
+        pr = data_schema.ValidationProblem(code=WARNINGS.W80000)
         self.assertEqual("duplicate dict key",
                          data_schema.problem_message(pr))
 
-        self.assertRaises(KeyError, data_schema.problem_message, 1234)
+        self.assertRaises(KeyError, data_schema.problem_message, 12345)
 
     def test_str_enum(self):
         pr = list(data_schema.validate(
@@ -1517,7 +1515,7 @@
             {"type": "string",
              "enum": ["e1", "e2"]}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10043, pr[0].code)
+        self.assertEqual(ERRORS.E10043, pr[0].code)
 
     def test_str_minlen(self):
         pr = list(data_schema.validate(
@@ -1531,7 +1529,7 @@
             {"type": "string",
              "minLength": 1}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10006, pr[0].code)
+        self.assertEqual(ERRORS.E10006, pr[0].code)
 
         pr = list(data_schema.validate(
             "x",
@@ -1551,7 +1549,7 @@
             {"type": "string",
              "maxLength": 0}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10007, pr[0].code)
+        self.assertEqual(ERRORS.E10007, pr[0].code)
 
         pr = list(data_schema.validate(
             "x",
@@ -1564,12 +1562,12 @@
             {"type": "string",
              "maxLength": 1}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10002, pr[0].code)
+        self.assertEqual(ERRORS.E10002, pr[0].code)
 
     @staticmethod
     def _pattern_check_function(obj, schema, context=None):
         if obj == " 5   ":
-            yield data_schema.ValidationProblem(code=10009)
+            yield data_schema.ValidationProblem(code=ERRORS.E10009)
 
     def test_str_re(self):
         pr = list(data_schema.validate(
@@ -1577,14 +1575,14 @@
             {"type": "string",
              "pattern": r'\A[0-9]+\Z'}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10008, pr[0].code)
+        self.assertEqual(ERRORS.E10008, pr[0].code)
 
         pr = list(data_schema.validate(
             "123",
             {"type": "string",
              "pattern": re.compile(r'\A[a-z]+\Z')}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10008, pr[0].code)
+        self.assertEqual(ERRORS.E10008, pr[0].code)
 
         pr = list(data_schema.validate(
             "123",
@@ -1597,7 +1595,7 @@
             {"type": "string",
              "pattern": self._pattern_check_function}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10009, pr[0].code)
+        self.assertEqual(ERRORS.E10009, pr[0].code)
 
     def test_binary_basic(self):
         pr = list(data_schema.validate(
@@ -1610,12 +1608,12 @@
             "",
             {"type": "binary"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10035, pr[0].code)
+        self.assertEqual(ERRORS.E10035, pr[0].code)
 
     @staticmethod
     def _binary_pattern_check_function(obj, schema, context=None):
         if obj != b"\x00":
-            yield data_schema.ValidationProblem(code=10009)
+            yield data_schema.ValidationProblem(code=ERRORS.E10009)
 
     def test_binary_pattern_check(self):
         pr = list(data_schema.validate(
@@ -1629,7 +1627,7 @@
             {"type": "binary",
              "pattern": self._binary_pattern_check_function}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10009, pr[0].code)
+        self.assertEqual(ERRORS.E10009, pr[0].code)
 
     def test_binary_re_str_match(self):
         pr = list(data_schema.validate(
@@ -1651,7 +1649,7 @@
             {"type": "binary",
              "pattern": u"\\x01+"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10047, pr[0].code)
+        self.assertEqual(ERRORS.E10047, pr[0].code)
 
     def test_binary_re_bytes_mismatch(self):
         pr = list(data_schema.validate(
@@ -1659,7 +1657,7 @@
             {"type": "binary",
              "pattern": b"\x01+"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10047, pr[0].code)
+        self.assertEqual(ERRORS.E10047, pr[0].code)
 
     def test_binary_length(self):
         pr = list(data_schema.validate(
@@ -1667,19 +1665,19 @@
             {"type": "binary",
              "minLength": 1}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10036, pr[0].code)
+        self.assertEqual(ERRORS.E10036, pr[0].code)
 
         pr = list(data_schema.validate(
             b"1",
             {"type": "binary",
              "maxLength": 0}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10037, pr[0].code)
+        self.assertEqual(ERRORS.E10037, pr[0].code)
 
     def test_deny(self):
         pr = list(data_schema.validate("abc", {"type": "deny"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10010, pr[0].code)
+        self.assertEqual(ERRORS.E10010, pr[0].code)
 
     def test_accept(self):
         pr = list(data_schema.validate("abc", {"type": "accept"}))
@@ -1703,7 +1701,7 @@
 
         pr = list(data_schema.validate({}, {"type": None}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10011, pr[0].code)
+        self.assertEqual(ERRORS.E10011, pr[0].code)
 
     def test_l1(self):
         pr = list(data_schema.validate([], {"type": "list"}))
@@ -1715,7 +1713,7 @@
     def test_l1_not_nullable(self):
         pr = list(data_schema.validate(None, {"type": "list"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10001, pr[0].code)
+        self.assertEqual(ERRORS.E10001, pr[0].code)
 
     def test_l1_nullable(self):
         pr = list(data_schema.validate(
@@ -1726,7 +1724,7 @@
         pr = list(data_schema.validate(["a", "b", "c"], {"type": "list"}))
         self.assertEqual(3, len(pr))
         for i in range(0, 3):
-            self.assertEqual(10010, pr[i].code)
+            self.assertEqual(ERRORS.E10010, pr[i].code)
 
     def test_l3_schema_for_items(self):
         pr = list(data_schema.validate(
@@ -1745,7 +1743,7 @@
     def test_t1_not_nullable(self):
         pr = list(data_schema.validate(None, {"type": "tuple"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10014, pr[0].code)
+        self.assertEqual(ERRORS.E10014, pr[0].code)
 
     def test_t1_nullable(self):
         pr = list(data_schema.validate(
@@ -1771,7 +1769,7 @@
                  {"type": None},
                  {"type": "deny"}]}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10010, pr[0].code)
+        self.assertEqual(ERRORS.E10010, pr[0].code)
         self.assertEqual(2, pr[0].context.index)
 
     def test_t4(self):
@@ -1782,7 +1780,7 @@
                  {"type": "string"},
                  {"type": None}]}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10017, pr[0].code)
+        self.assertEqual(ERRORS.E10017, pr[0].code)
         self.assertEqual(2, pr[0].context.index)
 
     def test_t5(self):
@@ -1822,7 +1820,7 @@
                  "keys": {"key": {"type": "string"}}
              }}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10016, pr[0].code)
+        self.assertEqual(ERRORS.E10016, pr[0].code)
 
     def test_t8(self):
         # do not check anything that exceeds maxLength
@@ -1839,8 +1837,8 @@
                  "keys": {"key": {"type": "string"}}
              }}))
         self.assertEqual(2, len(pr))
-        self.assertEqual(10015, pr[0].code)
-        self.assertEqual(10016, pr[1].code)
+        self.assertEqual(ERRORS.E10015, pr[0].code)
+        self.assertEqual(ERRORS.E10016, pr[1].code)
 
     def test_set1(self):
         # do not check anything that exceeds maxLength
@@ -1860,7 +1858,7 @@
             None,
             {"type": "set"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10038, pr[0].code)
+        self.assertEqual(ERRORS.E10038, pr[0].code)
 
     def test_set1_nullable(self):
         # do not check anything that exceeds maxLength
@@ -1880,7 +1878,7 @@
                  {"type": None}]}}
              ))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10039, pr[0].code)
+        self.assertEqual(ERRORS.E10039, pr[0].code)
 
     def test_set3(self):
         # do not check anything that exceeds maxLength
@@ -1893,7 +1891,7 @@
                  {"type": None}]}}
              ))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10040, pr[0].code)
+        self.assertEqual(ERRORS.E10040, pr[0].code)
 
     def test_set4_itemschema(self):
         pr = list(data_schema.validate(
@@ -1906,14 +1904,14 @@
         codes = set([p.code for p in pr])
 
         self.assertEqual(1, len(pr))
-        self.assertEqual(10055, pr[0].code)
+        self.assertEqual(ERRORS.E10055, pr[0].code)
         self.assertEqual(2, len(pr[0].cause))
-        self.assertEqual(10056, pr[0].cause[0].code)
+        self.assertEqual(ERRORS.E10056, pr[0].cause[0].code)
         self.assertEqual(1, len(pr[0].cause[0].cause))
-        self.assertEqual(10002, pr[0].cause[0].cause[0].code)
-        self.assertEqual(10056, pr[0].cause[1].code)
+        self.assertEqual(ERRORS.E10002, pr[0].cause[0].cause[0].code)
+        self.assertEqual(ERRORS.E10056, pr[0].cause[1].code)
         self.assertEqual(1, len(pr[0].cause[1].cause))
-        self.assertEqual(10020, pr[0].cause[1].cause[0].code)
+        self.assertEqual(ERRORS.E10020, pr[0].cause[1].cause[0].code)
 
     def test_empty(self):
         pr = list(data_schema.validate(None, {"type": "empty"}))
@@ -1924,7 +1922,7 @@
 
         pr = list(data_schema.validate(["a"], {"type": "empty"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10018, pr[0].code)
+        self.assertEqual(ERRORS.E10018, pr[0].code)
 
         pr = list(data_schema.validate(tuple(), {"type": "empty"}))
         self.assertEqual(0, len(pr))
@@ -1937,18 +1935,18 @@
 
         pr = list(data_schema.validate(tuple(["a"]), {"type": "empty"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10018, pr[0].code)
+        self.assertEqual(ERRORS.E10018, pr[0].code)
 
         pr = list(data_schema.validate({}, {"type": "empty"}))
         self.assertEqual(0, len(pr))
 
         pr = list(data_schema.validate({"key": "value"}, {"type": "empty"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10018, pr[0].code)
+        self.assertEqual(ERRORS.E10018, pr[0].code)
 
         pr = list(data_schema.validate("", {"type": "empty"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10018, pr[0].code)
+        self.assertEqual(ERRORS.E10018, pr[0].code)
 
     def test_allOf(self):
         pr = list(data_schema.validate(
@@ -1971,11 +1969,11 @@
                 ]
             }}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10057, pr[0].code)
+        self.assertEqual(ERRORS.E10057, pr[0].code)
         self.assertEqual(1, len(pr[0].cause))
-        self.assertEqual(10058, pr[0].cause[0].code)
+        self.assertEqual(ERRORS.E10058, pr[0].cause[0].code)
         self.assertEqual(1, len(pr[0].cause[0].cause))
-        self.assertEqual(10010, pr[0].cause[0].cause[0].code)
+        self.assertEqual(ERRORS.E10010, pr[0].cause[0].cause[0].code)
 
     def test_anyOf(self):
         pr = list(data_schema.validate(
@@ -1997,14 +1995,14 @@
                 ]
             }}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10055, pr[0].code)
+        self.assertEqual(ERRORS.E10055, pr[0].code)
         self.assertEqual(2, len(pr[0].cause))
-        self.assertEqual(10056, pr[0].cause[0].code)
+        self.assertEqual(ERRORS.E10056, pr[0].cause[0].code)
         self.assertEqual(1, len(pr[0].cause[0].cause))
-        self.assertEqual(10002, pr[0].cause[0].cause[0].code)
-        self.assertEqual(10056, pr[0].cause[1].code)
+        self.assertEqual(ERRORS.E10002, pr[0].cause[0].cause[0].code)
+        self.assertEqual(ERRORS.E10056, pr[0].cause[1].code)
         self.assertEqual(1, len(pr[0].cause[1].cause))
-        self.assertEqual(10010, pr[0].cause[1].cause[0].code)
+        self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code)
 
     def test_anyOf_with_list(self):
         pr = list(data_schema.validate(
@@ -2022,14 +2020,14 @@
                 {"type": "deny"},
             ]}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10055, pr[0].code)
+        self.assertEqual(ERRORS.E10055, pr[0].code)
         self.assertEqual(2, len(pr[0].cause))
-        self.assertEqual(10056, pr[0].cause[0].code)
+        self.assertEqual(ERRORS.E10056, pr[0].cause[0].code)
         self.assertEqual(1, len(pr[0].cause[0].cause))
-        self.assertEqual(10002, pr[0].cause[0].cause[0].code)
-        self.assertEqual(10056, pr[0].cause[1].code)
+        self.assertEqual(ERRORS.E10002, pr[0].cause[0].cause[0].code)
+        self.assertEqual(ERRORS.E10056, pr[0].cause[1].code)
         self.assertEqual(1, len(pr[0].cause[1].cause))
-        self.assertEqual(10010, pr[0].cause[1].cause[0].code)
+        self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code)
 
     def test_oneOf(self):
         pr = list(data_schema.validate(
@@ -2052,14 +2050,14 @@
             }}))
 
         self.assertEqual(1, len(pr))
-        self.assertEqual(10053, pr[0].code)
+        self.assertEqual(ERRORS.E10053, pr[0].code)
         self.assertEqual(2, len(pr[0].cause))
-        self.assertEqual(10054, pr[0].cause[0].code)
+        self.assertEqual(ERRORS.E10054, pr[0].cause[0].code)
         self.assertEqual(1, len(pr[0].cause[0].cause))
-        self.assertEqual(10002, pr[0].cause[0].cause[0].code)
-        self.assertEqual(10054, pr[0].cause[1].code)
+        self.assertEqual(ERRORS.E10002, pr[0].cause[0].cause[0].code)
+        self.assertEqual(ERRORS.E10054, pr[0].cause[1].code)
         self.assertEqual(1, len(pr[0].cause[1].cause))
-        self.assertEqual(10010, pr[0].cause[1].cause[0].code)
+        self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code)
 
         pr = list(data_schema.validate(
             None,
@@ -2072,7 +2070,7 @@
                 ]
             }}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10019, pr[0].code)
+        self.assertEqual(ERRORS.E10019, pr[0].code)
         self.assertEqual("2,3", pr[0].hint)
 
     def test_not(self):
@@ -2082,7 +2080,7 @@
                 "not": {
                     "type": "empty"}}}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10029, pr[0].code)
+        self.assertEqual(ERRORS.E10029, pr[0].code)
 
         pr = list(data_schema.validate(
             None,
@@ -2099,7 +2097,7 @@
                 "not": {
                     "type": "int"}}}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10029, pr[0].code)
+        self.assertEqual(ERRORS.E10029, pr[0].code)
 
         pr = list(data_schema.validate(
             1,
@@ -2123,7 +2121,7 @@
             {"not": {
                 "type": "empty"}}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10029, pr[0].code)
+        self.assertEqual(ERRORS.E10029, pr[0].code)
 
         pr = list(data_schema.validate(
             None,
@@ -2137,7 +2135,7 @@
             {"not": {
                 "type": "int"}}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10029, pr[0].code)
+        self.assertEqual(ERRORS.E10029, pr[0].code)
 
         pr = list(data_schema.validate(
             1,
@@ -2158,7 +2156,7 @@
 
         pr = list(data_schema.validate(1, {"type": "float"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10023, pr[0].code)
+        self.assertEqual(ERRORS.E10023, pr[0].code)
 
         pr = list(data_schema.validate(
             2,
@@ -2167,8 +2165,8 @@
              "maxValue": 1}))
 
         self.assertEqual(2, len(pr))
-        self.assertEqual(10021, pr[0].code)
-        self.assertEqual(10022, pr[1].code)
+        self.assertEqual(ERRORS.E10021, pr[0].code)
+        self.assertEqual(ERRORS.E10022, pr[1].code)
 
     def test_float(self):
         pr = list(data_schema.validate(1.8, {"type": "float"}))
@@ -2176,7 +2174,7 @@
 
         pr = list(data_schema.validate(1, {"type": "float"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10023, pr[0].code)
+        self.assertEqual(ERRORS.E10023, pr[0].code)
 
         pr = list(data_schema.validate(
             2.0,
@@ -2185,8 +2183,8 @@
              "maxValue": 1.9}))
 
         self.assertEqual(2, len(pr))
-        self.assertEqual(10024, pr[0].code)
-        self.assertEqual(10025, pr[1].code)
+        self.assertEqual(ERRORS.E10024, pr[0].code)
+        self.assertEqual(ERRORS.E10025, pr[1].code)
 
     def test_number(self):
         pr = list(data_schema.validate(1.8, {"type": "number"}))
@@ -2201,12 +2199,12 @@
              "maxValue": 1.3}))
 
         self.assertEqual(2, len(pr))
-        self.assertEqual(10031, pr[0].code)
-        self.assertEqual(10032, pr[1].code)
+        self.assertEqual(ERRORS.E10031, pr[0].code)
+        self.assertEqual(ERRORS.E10032, pr[1].code)
 
         pr = list(data_schema.validate({}, {"type": "number"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10030, pr[0].code)
+        self.assertEqual(ERRORS.E10030, pr[0].code)
 
     def test_bool(self):
         pr = list(data_schema.validate(True, {"type": "bool"}))
@@ -2219,7 +2217,7 @@
         pr = list(data_schema.validate(True, {"type": "boolean",
                                               "value": False}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10028, pr[0].code)
+        self.assertEqual(ERRORS.E10028, pr[0].code)
 
         pr = list(data_schema.validate(False, {"type": "boolean"}))
         self.assertEqual(0, len(pr))
@@ -2231,26 +2229,26 @@
         pr = list(data_schema.validate(False, {"type": "boolean",
                                                "value": True}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10027, pr[0].code)
+        self.assertEqual(ERRORS.E10027, pr[0].code)
 
     def test_bool_real(self):
         pr = list(data_schema.validate([1, 2], {"type": "bool"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10026, pr[0].code)
+        self.assertEqual(ERRORS.E10026, pr[0].code)
 
         pr = list(data_schema.validate([], {"type": "bool"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10026, pr[0].code)
+        self.assertEqual(ERRORS.E10026, pr[0].code)
 
         pr = list(data_schema.validate(None, {"type": "bool"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10026, pr[0].code)
+        self.assertEqual(ERRORS.E10026, pr[0].code)
 
     @staticmethod
     def _check_value_ts(obj, schema, context):
         if obj == datetime.datetime.fromtimestamp(0):
             yield data_schema.ValidationProblem(
-                code=10042, hint=obj, context=context)
+                code=ERRORS.E10042, hint=obj, context=context)
 
     def test_timestamp(self):
         pr = list(data_schema.validate(
@@ -2268,7 +2266,7 @@
             {"type": "datetime",
              "value": self._check_value_ts}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10042, pr[0].code)
+        self.assertEqual(ERRORS.E10042, pr[0].code)
 
     def test_scalar(self):
         pr = list(data_schema.validate(1, {"type": "scalar"}))
@@ -2286,27 +2284,27 @@
 
         pr = list(data_schema.validate(None, {"type": "scalar"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10033, pr[0].code)
+        self.assertEqual(ERRORS.E10033, pr[0].code)
 
         pr = list(data_schema.validate({}, {"type": "scalar"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10033, pr[0].code)
+        self.assertEqual(ERRORS.E10033, pr[0].code)
 
         pr = list(data_schema.validate([], {"type": "scalar"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10033, pr[0].code)
+        self.assertEqual(ERRORS.E10033, pr[0].code)
 
         pr = list(data_schema.validate(tuple(), {"type": "scalar"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10033, pr[0].code)
+        self.assertEqual(ERRORS.E10033, pr[0].code)
 
         pr = list(data_schema.validate(set(), {"type": "scalar"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10033, pr[0].code)
+        self.assertEqual(ERRORS.E10033, pr[0].code)
 
         pr = list(data_schema.validate(frozenset(), {"type": "scalar"}))
         self.assertEqual(1, len(pr))
-        self.assertEqual(10033, pr[0].code)
+        self.assertEqual(ERRORS.E10033, pr[0].code)
 
         pr = list(data_schema.validate(
             None,