Mercurial > hgrepos > Python > libs > data-schema

comparison 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
comparison
equal deleted inserted replaced
12:8e0b60f868dd 13:940676a0de84
8 8
9 import configmix.yaml 9 import configmix.yaml
10 10
11 import data_schema 11 import data_schema
12 import data_schema.util 12 import data_schema.util
13 from data_schema import ERRORS, WARNINGS
13 14
14 15
15 TYPE_RE = type(re.compile(r"\A.+\Z")) 16 TYPE_RE = type(re.compile(r"\A.+\Z"))
16 17
17 18
1336 pass 1337 pass
1337 else: 1338 else:
1338 self.assertFalse( 1339 self.assertFalse(
1339 "no SchemaError raised when a non-dict given as schema") 1340 "no SchemaError raised when a non-dict given as schema")
1340 1341
1341 def test_problem_ctor_nonexisting_code(self):
1342 self.assertRaises(ValueError, data_schema.ValidationProblem, code=2)
1343
1344 def test_problem_ctor_no_code(self): 1342 def test_problem_ctor_no_code(self):
1345 self.assertRaises(TypeError, data_schema.ValidationProblem, code=None) 1343 self.assertRaises(TypeError, data_schema.ValidationProblem, code=None)
1346 1344
1347 def test_error_ctor(self): 1345 def test_error_ctor(self):
1348 v = data_schema.ValidationProblem(code=10000) 1346 v = data_schema.ValidationProblem(code=ERRORS.E10000)
1349 self.assertEqual(data_schema.ERROR, v.severity) 1347 self.assertEqual(data_schema.ERROR, v.severity)
1350 1348
1351 def test_warning_ctor(self): 1349 def test_warning_ctor(self):
1352 v = data_schema.ValidationProblem(code=80000) 1350 v = data_schema.ValidationProblem(code=WARNINGS.W80000)
1353 self.assertEqual(data_schema.WARNING, v.severity) 1351 self.assertEqual(data_schema.WARNING, v.severity)
1354 1352
1355 def test_d1(self): 1353 def test_d1(self):
1356 x = list(data_schema.validate({}, {"type": "dict"})) 1354 x = list(data_schema.validate({}, {"type": "dict"}))
1357 self.assertEqual(0, len(x)) 1355 self.assertEqual(0, len(x))
1358 1356
1359 def test_d1_not_nullable(self): 1357 def test_d1_not_nullable(self):
1360 x = list(data_schema.validate(None, {"type": "dict"})) 1358 x = list(data_schema.validate(None, {"type": "dict"}))
1361 self.assertEqual(1, len(x)) 1359 self.assertEqual(1, len(x))
1362 self.assertEqual(10000, x[0].code) 1360 self.assertEqual(ERRORS.E10000, x[0].code)
1363 1361
1364 def test_d1_nullable(self): 1362 def test_d1_nullable(self):
1365 x = list(data_schema.validate(None, {"type": "dict", 1363 x = list(data_schema.validate(None, {"type": "dict",
1366 "nullable": True})) 1364 "nullable": True}))
1367 self.assertEqual(0, len(x)) 1365 self.assertEqual(0, len(x))
1368 1366
1369 def test_d2(self): 1367 def test_d2(self):
1370 x = list(data_schema.validate([], {"type": "map"})) 1368 x = list(data_schema.validate([], {"type": "map"}))
1371 self.assertEqual(1, len(x)) 1369 self.assertEqual(1, len(x))
1372 self.assertEqual(data_schema.ERROR, x[0].severity) 1370 self.assertEqual(data_schema.ERROR, x[0].severity)
1373 self.assertEqual(10000, x[0].code) 1371 self.assertEqual(ERRORS.E10000, x[0].code)
1374 1372
1375 def test_d3(self): 1373 def test_d3(self):
1376 x = list(data_schema.validate( 1374 x = list(data_schema.validate(
1377 {"key": "value"}, 1375 {"key": "value"},
1378 {"type": "dict", 1376 {"type": "dict",
1379 "required": ["key2"]})) 1377 "required": ["key2"]}))
1380 self.assertEqual(2, len(x)) 1378 self.assertEqual(2, len(x))
1381 self.assertEqual(data_schema.ERROR, x[0].severity) 1379 self.assertEqual(data_schema.ERROR, x[0].severity)
1382 self.assertEqual(10004, x[0].code) 1380 self.assertEqual(ERRORS.E10004, x[0].code)
1383 self.assertEqual("key", x[0].hint) 1381 self.assertEqual("key", x[0].hint)
1384 self.assertEqual(data_schema.ERROR, x[1].severity) 1382 self.assertEqual(data_schema.ERROR, x[1].severity)
1385 self.assertEqual(10005, x[1].code) 1383 self.assertEqual(ERRORS.E10005, x[1].code)
1386 self.assertEqual(["key2"], x[1].hint) 1384 self.assertEqual(["key2"], x[1].hint)
1387 1385
1388 def test_d4(self): 1386 def test_d4(self):
1389 x = list(data_schema.validate( 1387 x = list(data_schema.validate(
1390 {"key": "value"}, 1388 {"key": "value"},
1399 x = list(data_schema.validate( 1397 x = list(data_schema.validate(
1400 {"key": "value"}, 1398 {"key": "value"},
1401 {"type": "dict", 1399 {"type": "dict",
1402 "additionalKeys": False})) 1400 "additionalKeys": False}))
1403 self.assertEqual(1, len(x)) 1401 self.assertEqual(1, len(x))
1404 self.assertEqual(10004, x[0].code) 1402 self.assertEqual(ERRORS.E10004, x[0].code)
1405 self.assertEqual("key", x[0].hint) 1403 self.assertEqual("key", x[0].hint)
1406 1404
1407 def test_d5_2(self): 1405 def test_d5_2(self):
1408 x = list(data_schema.validate( 1406 x = list(data_schema.validate(
1409 {"key": "value"}, 1407 {"key": "value"},
1427 "key2": "value"}, 1425 "key2": "value"},
1428 {"type": "dict", 1426 {"type": "dict",
1429 "additionalKeys": False}, 1427 "additionalKeys": False},
1430 skip_keys=[re.compile(r"\A__.+"), re.compile(r"\Akey\d+\Z")])) 1428 skip_keys=[re.compile(r"\A__.+"), re.compile(r"\Akey\d+\Z")]))
1431 self.assertEqual(1, len(x)) 1429 self.assertEqual(1, len(x))
1432 self.assertEqual(10004, x[0].code) 1430 self.assertEqual(ERRORS.E10004, x[0].code)
1433 self.assertEqual("key", x[0].hint) 1431 self.assertEqual("key", x[0].hint)
1434 1432
1435 def test_d6(self): 1433 def test_d6(self):
1436 x = list(data_schema.validate( 1434 x = list(data_schema.validate(
1437 {"key": "value"}, 1435 {"key": "value"},
1452 {"key": 1234}, 1450 {"key": 1234},
1453 {"type": "dict", 1451 {"type": "dict",
1454 "additionalKeys": { 1452 "additionalKeys": {
1455 "type": "string"}})) 1453 "type": "string"}}))
1456 self.assertEqual(1, len(x)) 1454 self.assertEqual(1, len(x))
1457 self.assertEqual(10002, x[0].code) 1455 self.assertEqual(ERRORS.E10002, x[0].code)
1458 self.assertEqual(1234, x[0].hint) 1456 self.assertEqual(1234, x[0].hint)
1459 1457
1460 def test_d8_2(self): 1458 def test_d8_2(self):
1461 x = list(data_schema.validate( 1459 x = list(data_schema.validate(
1462 {"key": 1234}, 1460 {"key": 1234},
1470 pr = list(data_schema.validate( 1468 pr = list(data_schema.validate(
1471 {0: "value"}, 1469 {0: "value"},
1472 {"type": "dict", 1470 {"type": "dict",
1473 "additionalKeys": True})) 1471 "additionalKeys": True}))
1474 self.assertEqual(1, len(pr)) 1472 self.assertEqual(1, len(pr))
1475 self.assertEqual(10003, pr[0].code) 1473 self.assertEqual(ERRORS.E10003, pr[0].code)
1476 1474
1477 def test_d10_int_dict_keys(self): 1475 def test_d10_int_dict_keys(self):
1478 pr = list(data_schema.validate( 1476 pr = list(data_schema.validate(
1479 {1: "value", 2: "value2"}, 1477 {1: "value", 2: "value2"},
1480 {"type": "dict", 1478 {"type": "dict",
1484 "keyNames": {"type": "int"}})) 1482 "keyNames": {"type": "int"}}))
1485 self.assertEqual(0, len(pr)) 1483 self.assertEqual(0, len(pr))
1486 1484
1487 def test_error_message(self): 1485 def test_error_message(self):
1488 self.assertEqual("dict expected", 1486 self.assertEqual("dict expected",
1489 data_schema.problem_message(10000)) 1487 data_schema.problem_message(ERRORS.E10000))
1490 pr = data_schema.ValidationProblem(code=10000) 1488 pr = data_schema.ValidationProblem(code=ERRORS.E10000)
1491 self.assertEqual("dict expected", data_schema.problem_message(pr)) 1489 self.assertEqual("dict expected", data_schema.problem_message(pr))
1492 1490
1493 self.assertEqual("duplicate dict key", 1491 self.assertEqual("duplicate dict key",
1494 data_schema.problem_message(80000)) 1492 data_schema.problem_message(WARNINGS.W80000))
1495 pr = data_schema.ValidationProblem(code=80000) 1493 pr = data_schema.ValidationProblem(code=WARNINGS.W80000)
1496 self.assertEqual("duplicate dict key", 1494 self.assertEqual("duplicate dict key",
1497 data_schema.problem_message(pr)) 1495 data_schema.problem_message(pr))
1498 1496
1499 self.assertRaises(KeyError, data_schema.problem_message, 1234) 1497 self.assertRaises(KeyError, data_schema.problem_message, 12345)
1500 1498
1501 def test_str_enum(self): 1499 def test_str_enum(self):
1502 pr = list(data_schema.validate( 1500 pr = list(data_schema.validate(
1503 "e1", 1501 "e1",
1504 {"type": "string", 1502 {"type": "string",
1515 pr = list(data_schema.validate( 1513 pr = list(data_schema.validate(
1516 "e3", 1514 "e3",
1517 {"type": "string", 1515 {"type": "string",
1518 "enum": ["e1", "e2"]})) 1516 "enum": ["e1", "e2"]}))
1519 self.assertEqual(1, len(pr)) 1517 self.assertEqual(1, len(pr))
1520 self.assertEqual(10043, pr[0].code) 1518 self.assertEqual(ERRORS.E10043, pr[0].code)
1521 1519
1522 def test_str_minlen(self): 1520 def test_str_minlen(self):
1523 pr = list(data_schema.validate( 1521 pr = list(data_schema.validate(
1524 "", 1522 "",
1525 {"type": "string", 1523 {"type": "string",
1529 pr = list(data_schema.validate( 1527 pr = list(data_schema.validate(
1530 "", 1528 "",
1531 {"type": "string", 1529 {"type": "string",
1532 "minLength": 1})) 1530 "minLength": 1}))
1533 self.assertEqual(1, len(pr)) 1531 self.assertEqual(1, len(pr))
1534 self.assertEqual(10006, pr[0].code) 1532 self.assertEqual(ERRORS.E10006, pr[0].code)
1535 1533
1536 pr = list(data_schema.validate( 1534 pr = list(data_schema.validate(
1537 "x", 1535 "x",
1538 {"type": "string", 1536 {"type": "string",
1539 "minLength": 1})) 1537 "minLength": 1}))
1549 pr = list(data_schema.validate( 1547 pr = list(data_schema.validate(
1550 "x", 1548 "x",
1551 {"type": "string", 1549 {"type": "string",
1552 "maxLength": 0})) 1550 "maxLength": 0}))
1553 self.assertEqual(1, len(pr)) 1551 self.assertEqual(1, len(pr))
1554 self.assertEqual(10007, pr[0].code) 1552 self.assertEqual(ERRORS.E10007, pr[0].code)
1555 1553
1556 pr = list(data_schema.validate( 1554 pr = list(data_schema.validate(
1557 "x", 1555 "x",
1558 {"type": "string", 1556 {"type": "string",
1559 "maxLength": 1})) 1557 "maxLength": 1}))
1562 pr = list(data_schema.validate( 1560 pr = list(data_schema.validate(
1563 b"x", 1561 b"x",
1564 {"type": "string", 1562 {"type": "string",
1565 "maxLength": 1})) 1563 "maxLength": 1}))
1566 self.assertEqual(1, len(pr)) 1564 self.assertEqual(1, len(pr))
1567 self.assertEqual(10002, pr[0].code) 1565 self.assertEqual(ERRORS.E10002, pr[0].code)
1568 1566
1569 @staticmethod 1567 @staticmethod
1570 def _pattern_check_function(obj, schema, context=None): 1568 def _pattern_check_function(obj, schema, context=None):
1571 if obj == " 5 ": 1569 if obj == " 5 ":
1572 yield data_schema.ValidationProblem(code=10009) 1570 yield data_schema.ValidationProblem(code=ERRORS.E10009)
1573 1571
1574 def test_str_re(self): 1572 def test_str_re(self):
1575 pr = list(data_schema.validate( 1573 pr = list(data_schema.validate(
1576 "abc", 1574 "abc",
1577 {"type": "string", 1575 {"type": "string",
1578 "pattern": r'\A[0-9]+\Z'})) 1576 "pattern": r'\A[0-9]+\Z'}))
1579 self.assertEqual(1, len(pr)) 1577 self.assertEqual(1, len(pr))
1580 self.assertEqual(10008, pr[0].code) 1578 self.assertEqual(ERRORS.E10008, pr[0].code)
1581 1579
1582 pr = list(data_schema.validate( 1580 pr = list(data_schema.validate(
1583 "123", 1581 "123",
1584 {"type": "string", 1582 {"type": "string",
1585 "pattern": re.compile(r'\A[a-z]+\Z')})) 1583 "pattern": re.compile(r'\A[a-z]+\Z')}))
1586 self.assertEqual(1, len(pr)) 1584 self.assertEqual(1, len(pr))
1587 self.assertEqual(10008, pr[0].code) 1585 self.assertEqual(ERRORS.E10008, pr[0].code)
1588 1586
1589 pr = list(data_schema.validate( 1587 pr = list(data_schema.validate(
1590 "123", 1588 "123",
1591 {"type": "string", 1589 {"type": "string",
1592 "pattern": self._pattern_check_function})) 1590 "pattern": self._pattern_check_function}))
1595 pr = list(data_schema.validate( 1593 pr = list(data_schema.validate(
1596 " 5 ", 1594 " 5 ",
1597 {"type": "string", 1595 {"type": "string",
1598 "pattern": self._pattern_check_function})) 1596 "pattern": self._pattern_check_function}))
1599 self.assertEqual(1, len(pr)) 1597 self.assertEqual(1, len(pr))
1600 self.assertEqual(10009, pr[0].code) 1598 self.assertEqual(ERRORS.E10009, pr[0].code)
1601 1599
1602 def test_binary_basic(self): 1600 def test_binary_basic(self):
1603 pr = list(data_schema.validate( 1601 pr = list(data_schema.validate(
1604 b"", 1602 b"",
1605 {"type": "binary"})) 1603 {"type": "binary"}))
1608 def test_str_is_not_binary(self): 1606 def test_str_is_not_binary(self):
1609 pr = list(data_schema.validate( 1607 pr = list(data_schema.validate(
1610 "", 1608 "",
1611 {"type": "binary"})) 1609 {"type": "binary"}))
1612 self.assertEqual(1, len(pr)) 1610 self.assertEqual(1, len(pr))
1613 self.assertEqual(10035, pr[0].code) 1611 self.assertEqual(ERRORS.E10035, pr[0].code)
1614 1612
1615 @staticmethod 1613 @staticmethod
1616 def _binary_pattern_check_function(obj, schema, context=None): 1614 def _binary_pattern_check_function(obj, schema, context=None):
1617 if obj != b"\x00": 1615 if obj != b"\x00":
1618 yield data_schema.ValidationProblem(code=10009) 1616 yield data_schema.ValidationProblem(code=ERRORS.E10009)
1619 1617
1620 def test_binary_pattern_check(self): 1618 def test_binary_pattern_check(self):
1621 pr = list(data_schema.validate( 1619 pr = list(data_schema.validate(
1622 b"\x00", 1620 b"\x00",
1623 {"type": "binary", 1621 {"type": "binary",
1627 pr = list(data_schema.validate( 1625 pr = list(data_schema.validate(
1628 b"\x01", 1626 b"\x01",
1629 {"type": "binary", 1627 {"type": "binary",
1630 "pattern": self._binary_pattern_check_function})) 1628 "pattern": self._binary_pattern_check_function}))
1631 self.assertEqual(1, len(pr)) 1629 self.assertEqual(1, len(pr))
1632 self.assertEqual(10009, pr[0].code) 1630 self.assertEqual(ERRORS.E10009, pr[0].code)
1633 1631
1634 def test_binary_re_str_match(self): 1632 def test_binary_re_str_match(self):
1635 pr = list(data_schema.validate( 1633 pr = list(data_schema.validate(
1636 b"\x00\x00\x00", 1634 b"\x00\x00\x00",
1637 {"type": "binary", 1635 {"type": "binary",
1649 pr = list(data_schema.validate( 1647 pr = list(data_schema.validate(
1650 b"\x00\x00\x00", 1648 b"\x00\x00\x00",
1651 {"type": "binary", 1649 {"type": "binary",
1652 "pattern": u"\\x01+"})) 1650 "pattern": u"\\x01+"}))
1653 self.assertEqual(1, len(pr)) 1651 self.assertEqual(1, len(pr))
1654 self.assertEqual(10047, pr[0].code) 1652 self.assertEqual(ERRORS.E10047, pr[0].code)
1655 1653
1656 def test_binary_re_bytes_mismatch(self): 1654 def test_binary_re_bytes_mismatch(self):
1657 pr = list(data_schema.validate( 1655 pr = list(data_schema.validate(
1658 b"\x00\x00\x00", 1656 b"\x00\x00\x00",
1659 {"type": "binary", 1657 {"type": "binary",
1660 "pattern": b"\x01+"})) 1658 "pattern": b"\x01+"}))
1661 self.assertEqual(1, len(pr)) 1659 self.assertEqual(1, len(pr))
1662 self.assertEqual(10047, pr[0].code) 1660 self.assertEqual(ERRORS.E10047, pr[0].code)
1663 1661
1664 def test_binary_length(self): 1662 def test_binary_length(self):
1665 pr = list(data_schema.validate( 1663 pr = list(data_schema.validate(
1666 b"", 1664 b"",
1667 {"type": "binary", 1665 {"type": "binary",
1668 "minLength": 1})) 1666 "minLength": 1}))
1669 self.assertEqual(1, len(pr)) 1667 self.assertEqual(1, len(pr))
1670 self.assertEqual(10036, pr[0].code) 1668 self.assertEqual(ERRORS.E10036, pr[0].code)
1671 1669
1672 pr = list(data_schema.validate( 1670 pr = list(data_schema.validate(
1673 b"1", 1671 b"1",
1674 {"type": "binary", 1672 {"type": "binary",
1675 "maxLength": 0})) 1673 "maxLength": 0}))
1676 self.assertEqual(1, len(pr)) 1674 self.assertEqual(1, len(pr))
1677 self.assertEqual(10037, pr[0].code) 1675 self.assertEqual(ERRORS.E10037, pr[0].code)
1678 1676
1679 def test_deny(self): 1677 def test_deny(self):
1680 pr = list(data_schema.validate("abc", {"type": "deny"})) 1678 pr = list(data_schema.validate("abc", {"type": "deny"}))
1681 self.assertEqual(1, len(pr)) 1679 self.assertEqual(1, len(pr))
1682 self.assertEqual(10010, pr[0].code) 1680 self.assertEqual(ERRORS.E10010, pr[0].code)
1683 1681
1684 def test_accept(self): 1682 def test_accept(self):
1685 pr = list(data_schema.validate("abc", {"type": "accept"})) 1683 pr = list(data_schema.validate("abc", {"type": "accept"}))
1686 self.assertEqual(0, len(pr)) 1684 self.assertEqual(0, len(pr))
1687 1685
1701 pr = list(data_schema.validate(None, {"type": None})) 1699 pr = list(data_schema.validate(None, {"type": None}))
1702 self.assertEqual(0, len(pr)) 1700 self.assertEqual(0, len(pr))
1703 1701
1704 pr = list(data_schema.validate({}, {"type": None})) 1702 pr = list(data_schema.validate({}, {"type": None}))
1705 self.assertEqual(1, len(pr)) 1703 self.assertEqual(1, len(pr))
1706 self.assertEqual(10011, pr[0].code) 1704 self.assertEqual(ERRORS.E10011, pr[0].code)
1707 1705
1708 def test_l1(self): 1706 def test_l1(self):
1709 pr = list(data_schema.validate([], {"type": "list"})) 1707 pr = list(data_schema.validate([], {"type": "list"}))
1710 self.assertEqual(0, len(pr)) 1708 self.assertEqual(0, len(pr))
1711 1709
1713 self.assertEqual(0, len(pr)) 1711 self.assertEqual(0, len(pr))
1714 1712
1715 def test_l1_not_nullable(self): 1713 def test_l1_not_nullable(self):
1716 pr = list(data_schema.validate(None, {"type": "list"})) 1714 pr = list(data_schema.validate(None, {"type": "list"}))
1717 self.assertEqual(1, len(pr)) 1715 self.assertEqual(1, len(pr))
1718 self.assertEqual(10001, pr[0].code) 1716 self.assertEqual(ERRORS.E10001, pr[0].code)
1719 1717
1720 def test_l1_nullable(self): 1718 def test_l1_nullable(self):
1721 pr = list(data_schema.validate( 1719 pr = list(data_schema.validate(
1722 None, {"type": "list", "nullable": True})) 1720 None, {"type": "list", "nullable": True}))
1723 self.assertEqual(0, len(pr)) 1721 self.assertEqual(0, len(pr))
1724 1722
1725 def test_l2_default_schema_for_items_is_deny(self): 1723 def test_l2_default_schema_for_items_is_deny(self):
1726 pr = list(data_schema.validate(["a", "b", "c"], {"type": "list"})) 1724 pr = list(data_schema.validate(["a", "b", "c"], {"type": "list"}))
1727 self.assertEqual(3, len(pr)) 1725 self.assertEqual(3, len(pr))
1728 for i in range(0, 3): 1726 for i in range(0, 3):
1729 self.assertEqual(10010, pr[i].code) 1727 self.assertEqual(ERRORS.E10010, pr[i].code)
1730 1728
1731 def test_l3_schema_for_items(self): 1729 def test_l3_schema_for_items(self):
1732 pr = list(data_schema.validate( 1730 pr = list(data_schema.validate(
1733 ["a", "b", "c"], 1731 ["a", "b", "c"],
1734 {"type": "array", 1732 {"type": "array",
1743 self.assertEqual(0, len(pr)) 1741 self.assertEqual(0, len(pr))
1744 1742
1745 def test_t1_not_nullable(self): 1743 def test_t1_not_nullable(self):
1746 pr = list(data_schema.validate(None, {"type": "tuple"})) 1744 pr = list(data_schema.validate(None, {"type": "tuple"}))
1747 self.assertEqual(1, len(pr)) 1745 self.assertEqual(1, len(pr))
1748 self.assertEqual(10014, pr[0].code) 1746 self.assertEqual(ERRORS.E10014, pr[0].code)
1749 1747
1750 def test_t1_nullable(self): 1748 def test_t1_nullable(self):
1751 pr = list(data_schema.validate( 1749 pr = list(data_schema.validate(
1752 None, {"type": "tuple", "nullable": True})) 1750 None, {"type": "tuple", "nullable": True}))
1753 self.assertEqual(0, len(pr)) 1751 self.assertEqual(0, len(pr))
1769 "items": [ 1767 "items": [
1770 {"type": "string"}, 1768 {"type": "string"},
1771 {"type": None}, 1769 {"type": None},
1772 {"type": "deny"}]})) 1770 {"type": "deny"}]}))
1773 self.assertEqual(1, len(pr)) 1771 self.assertEqual(1, len(pr))
1774 self.assertEqual(10010, pr[0].code) 1772 self.assertEqual(ERRORS.E10010, pr[0].code)
1775 self.assertEqual(2, pr[0].context.index) 1773 self.assertEqual(2, pr[0].context.index)
1776 1774
1777 def test_t4(self): 1775 def test_t4(self):
1778 pr = list(data_schema.validate( 1776 pr = list(data_schema.validate(
1779 ["a", None, {"key": "value"}], 1777 ["a", None, {"key": "value"}],
1780 {"type": "tuple", 1778 {"type": "tuple",
1781 "items": [ 1779 "items": [
1782 {"type": "string"}, 1780 {"type": "string"},
1783 {"type": None}]})) 1781 {"type": None}]}))
1784 self.assertEqual(1, len(pr)) 1782 self.assertEqual(1, len(pr))
1785 self.assertEqual(10017, pr[0].code) 1783 self.assertEqual(ERRORS.E10017, pr[0].code)
1786 self.assertEqual(2, pr[0].context.index) 1784 self.assertEqual(2, pr[0].context.index)
1787 1785
1788 def test_t5(self): 1786 def test_t5(self):
1789 pr = list(data_schema.validate( 1787 pr = list(data_schema.validate(
1790 ["a", None, {"key": "value"}], 1788 ["a", None, {"key": "value"}],
1820 "additionalItems": { 1818 "additionalItems": {
1821 "type": "dict", 1819 "type": "dict",
1822 "keys": {"key": {"type": "string"}} 1820 "keys": {"key": {"type": "string"}}
1823 }})) 1821 }}))
1824 self.assertEqual(1, len(pr)) 1822 self.assertEqual(1, len(pr))
1825 self.assertEqual(10016, pr[0].code) 1823 self.assertEqual(ERRORS.E10016, pr[0].code)
1826 1824
1827 def test_t8(self): 1825 def test_t8(self):
1828 # do not check anything that exceeds maxLength 1826 # do not check anything that exceeds maxLength
1829 pr = list(data_schema.validate( 1827 pr = list(data_schema.validate(
1830 ["a", None, {"key": "value"}, {"key": "value"}, {"key2": "value"}], 1828 ["a", None, {"key": "value"}, {"key": "value"}, {"key2": "value"}],
1837 "additionalItems": { 1835 "additionalItems": {
1838 "type": "dict", 1836 "type": "dict",
1839 "keys": {"key": {"type": "string"}} 1837 "keys": {"key": {"type": "string"}}
1840 }})) 1838 }}))
1841 self.assertEqual(2, len(pr)) 1839 self.assertEqual(2, len(pr))
1842 self.assertEqual(10015, pr[0].code) 1840 self.assertEqual(ERRORS.E10015, pr[0].code)
1843 self.assertEqual(10016, pr[1].code) 1841 self.assertEqual(ERRORS.E10016, pr[1].code)
1844 1842
1845 def test_set1(self): 1843 def test_set1(self):
1846 # do not check anything that exceeds maxLength 1844 # do not check anything that exceeds maxLength
1847 pr = list(data_schema.validate( 1845 pr = list(data_schema.validate(
1848 set(["a", None, "b"]), 1846 set(["a", None, "b"]),
1858 # do not check anything that exceeds maxLength 1856 # do not check anything that exceeds maxLength
1859 pr = list(data_schema.validate( 1857 pr = list(data_schema.validate(
1860 None, 1858 None,
1861 {"type": "set"})) 1859 {"type": "set"}))
1862 self.assertEqual(1, len(pr)) 1860 self.assertEqual(1, len(pr))
1863 self.assertEqual(10038, pr[0].code) 1861 self.assertEqual(ERRORS.E10038, pr[0].code)
1864 1862
1865 def test_set1_nullable(self): 1863 def test_set1_nullable(self):
1866 # do not check anything that exceeds maxLength 1864 # do not check anything that exceeds maxLength
1867 pr = list(data_schema.validate( 1865 pr = list(data_schema.validate(
1868 None, 1866 None,
1878 "items": {"any-of": [ 1876 "items": {"any-of": [
1879 {"type": "string"}, 1877 {"type": "string"},
1880 {"type": None}]}} 1878 {"type": None}]}}
1881 )) 1879 ))
1882 self.assertEqual(1, len(pr)) 1880 self.assertEqual(1, len(pr))
1883 self.assertEqual(10039, pr[0].code) 1881 self.assertEqual(ERRORS.E10039, pr[0].code)
1884 1882
1885 def test_set3(self): 1883 def test_set3(self):
1886 # do not check anything that exceeds maxLength 1884 # do not check anything that exceeds maxLength
1887 pr = list(data_schema.validate( 1885 pr = list(data_schema.validate(
1888 set(["a", None, "b"]), 1886 set(["a", None, "b"]),
1891 "items": {"any-of": [ 1889 "items": {"any-of": [
1892 {"type": "string"}, 1890 {"type": "string"},
1893 {"type": None}]}} 1891 {"type": None}]}}
1894 )) 1892 ))
1895 self.assertEqual(1, len(pr)) 1893 self.assertEqual(1, len(pr))
1896 self.assertEqual(10040, pr[0].code) 1894 self.assertEqual(ERRORS.E10040, pr[0].code)
1897 1895
1898 def test_set4_itemschema(self): 1896 def test_set4_itemschema(self):
1899 pr = list(data_schema.validate( 1897 pr = list(data_schema.validate(
1900 set(["a", None, "b"]), 1898 set(["a", None, "b"]),
1901 {"type": "set", 1899 {"type": "set",
1904 {"type": "int"}]}} 1902 {"type": "int"}]}}
1905 )) 1903 ))
1906 codes = set([p.code for p in pr]) 1904 codes = set([p.code for p in pr])
1907 1905
1908 self.assertEqual(1, len(pr)) 1906 self.assertEqual(1, len(pr))
1909 self.assertEqual(10055, pr[0].code) 1907 self.assertEqual(ERRORS.E10055, pr[0].code)
1910 self.assertEqual(2, len(pr[0].cause)) 1908 self.assertEqual(2, len(pr[0].cause))
1911 self.assertEqual(10056, pr[0].cause[0].code) 1909 self.assertEqual(ERRORS.E10056, pr[0].cause[0].code)
1912 self.assertEqual(1, len(pr[0].cause[0].cause)) 1910 self.assertEqual(1, len(pr[0].cause[0].cause))
1913 self.assertEqual(10002, pr[0].cause[0].cause[0].code) 1911 self.assertEqual(ERRORS.E10002, pr[0].cause[0].cause[0].code)
1914 self.assertEqual(10056, pr[0].cause[1].code) 1912 self.assertEqual(ERRORS.E10056, pr[0].cause[1].code)
1915 self.assertEqual(1, len(pr[0].cause[1].cause)) 1913 self.assertEqual(1, len(pr[0].cause[1].cause))
1916 self.assertEqual(10020, pr[0].cause[1].cause[0].code) 1914 self.assertEqual(ERRORS.E10020, pr[0].cause[1].cause[0].code)
1917 1915
1918 def test_empty(self): 1916 def test_empty(self):
1919 pr = list(data_schema.validate(None, {"type": "empty"})) 1917 pr = list(data_schema.validate(None, {"type": "empty"}))
1920 self.assertEqual(0, len(pr)) 1918 self.assertEqual(0, len(pr))
1921 1919
1922 pr = list(data_schema.validate([], {"type": "empty"})) 1920 pr = list(data_schema.validate([], {"type": "empty"}))
1923 self.assertEqual(0, len(pr)) 1921 self.assertEqual(0, len(pr))
1924 1922
1925 pr = list(data_schema.validate(["a"], {"type": "empty"})) 1923 pr = list(data_schema.validate(["a"], {"type": "empty"}))
1926 self.assertEqual(1, len(pr)) 1924 self.assertEqual(1, len(pr))
1927 self.assertEqual(10018, pr[0].code) 1925 self.assertEqual(ERRORS.E10018, pr[0].code)
1928 1926
1929 pr = list(data_schema.validate(tuple(), {"type": "empty"})) 1927 pr = list(data_schema.validate(tuple(), {"type": "empty"}))
1930 self.assertEqual(0, len(pr)) 1928 self.assertEqual(0, len(pr))
1931 1929
1932 pr = list(data_schema.validate(set(), {"type": "empty"})) 1930 pr = list(data_schema.validate(set(), {"type": "empty"}))
1935 pr = list(data_schema.validate(frozenset(), {"type": "empty"})) 1933 pr = list(data_schema.validate(frozenset(), {"type": "empty"}))
1936 self.assertEqual(0, len(pr)) 1934 self.assertEqual(0, len(pr))
1937 1935
1938 pr = list(data_schema.validate(tuple(["a"]), {"type": "empty"})) 1936 pr = list(data_schema.validate(tuple(["a"]), {"type": "empty"}))
1939 self.assertEqual(1, len(pr)) 1937 self.assertEqual(1, len(pr))
1940 self.assertEqual(10018, pr[0].code) 1938 self.assertEqual(ERRORS.E10018, pr[0].code)
1941 1939
1942 pr = list(data_schema.validate({}, {"type": "empty"})) 1940 pr = list(data_schema.validate({}, {"type": "empty"}))
1943 self.assertEqual(0, len(pr)) 1941 self.assertEqual(0, len(pr))
1944 1942
1945 pr = list(data_schema.validate({"key": "value"}, {"type": "empty"})) 1943 pr = list(data_schema.validate({"key": "value"}, {"type": "empty"}))
1946 self.assertEqual(1, len(pr)) 1944 self.assertEqual(1, len(pr))
1947 self.assertEqual(10018, pr[0].code) 1945 self.assertEqual(ERRORS.E10018, pr[0].code)
1948 1946
1949 pr = list(data_schema.validate("", {"type": "empty"})) 1947 pr = list(data_schema.validate("", {"type": "empty"}))
1950 self.assertEqual(1, len(pr)) 1948 self.assertEqual(1, len(pr))
1951 self.assertEqual(10018, pr[0].code) 1949 self.assertEqual(ERRORS.E10018, pr[0].code)
1952 1950
1953 def test_allOf(self): 1951 def test_allOf(self):
1954 pr = list(data_schema.validate( 1952 pr = list(data_schema.validate(
1955 None, 1953 None,
1956 {"type": { 1954 {"type": {
1969 {"type": "accept"}, 1967 {"type": "accept"},
1970 {"type": "deny"}, 1968 {"type": "deny"},
1971 ] 1969 ]
1972 }})) 1970 }}))
1973 self.assertEqual(1, len(pr)) 1971 self.assertEqual(1, len(pr))
1974 self.assertEqual(10057, pr[0].code) 1972 self.assertEqual(ERRORS.E10057, pr[0].code)
1975 self.assertEqual(1, len(pr[0].cause)) 1973 self.assertEqual(1, len(pr[0].cause))
1976 self.assertEqual(10058, pr[0].cause[0].code) 1974 self.assertEqual(ERRORS.E10058, pr[0].cause[0].code)
1977 self.assertEqual(1, len(pr[0].cause[0].cause)) 1975 self.assertEqual(1, len(pr[0].cause[0].cause))
1978 self.assertEqual(10010, pr[0].cause[0].cause[0].code) 1976 self.assertEqual(ERRORS.E10010, pr[0].cause[0].cause[0].code)
1979 1977
1980 def test_anyOf(self): 1978 def test_anyOf(self):
1981 pr = list(data_schema.validate( 1979 pr = list(data_schema.validate(
1982 None, 1980 None,
1983 {"type": { 1981 {"type": {
1995 {"type": "string"}, 1993 {"type": "string"},
1996 {"type": "deny"}, 1994 {"type": "deny"},
1997 ] 1995 ]
1998 }})) 1996 }}))
1999 self.assertEqual(1, len(pr)) 1997 self.assertEqual(1, len(pr))
2000 self.assertEqual(10055, pr[0].code) 1998 self.assertEqual(ERRORS.E10055, pr[0].code)
2001 self.assertEqual(2, len(pr[0].cause)) 1999 self.assertEqual(2, len(pr[0].cause))
2002 self.assertEqual(10056, pr[0].cause[0].code) 2000 self.assertEqual(ERRORS.E10056, pr[0].cause[0].code)
2003 self.assertEqual(1, len(pr[0].cause[0].cause)) 2001 self.assertEqual(1, len(pr[0].cause[0].cause))
2004 self.assertEqual(10002, pr[0].cause[0].cause[0].code) 2002 self.assertEqual(ERRORS.E10002, pr[0].cause[0].cause[0].code)
2005 self.assertEqual(10056, pr[0].cause[1].code) 2003 self.assertEqual(ERRORS.E10056, pr[0].cause[1].code)
2006 self.assertEqual(1, len(pr[0].cause[1].cause)) 2004 self.assertEqual(1, len(pr[0].cause[1].cause))
2007 self.assertEqual(10010, pr[0].cause[1].cause[0].code) 2005 self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code)
2008 2006
2009 def test_anyOf_with_list(self): 2007 def test_anyOf_with_list(self):
2010 pr = list(data_schema.validate( 2008 pr = list(data_schema.validate(
2011 None, 2009 None,
2012 {"type": [ 2010 {"type": [
2020 {"type": [ 2018 {"type": [
2021 {"type": "string"}, 2019 {"type": "string"},
2022 {"type": "deny"}, 2020 {"type": "deny"},
2023 ]})) 2021 ]}))
2024 self.assertEqual(1, len(pr)) 2022 self.assertEqual(1, len(pr))
2025 self.assertEqual(10055, pr[0].code) 2023 self.assertEqual(ERRORS.E10055, pr[0].code)
2026 self.assertEqual(2, len(pr[0].cause)) 2024 self.assertEqual(2, len(pr[0].cause))
2027 self.assertEqual(10056, pr[0].cause[0].code) 2025 self.assertEqual(ERRORS.E10056, pr[0].cause[0].code)
2028 self.assertEqual(1, len(pr[0].cause[0].cause)) 2026 self.assertEqual(1, len(pr[0].cause[0].cause))
2029 self.assertEqual(10002, pr[0].cause[0].cause[0].code) 2027 self.assertEqual(ERRORS.E10002, pr[0].cause[0].cause[0].code)
2030 self.assertEqual(10056, pr[0].cause[1].code) 2028 self.assertEqual(ERRORS.E10056, pr[0].cause[1].code)
2031 self.assertEqual(1, len(pr[0].cause[1].cause)) 2029 self.assertEqual(1, len(pr[0].cause[1].cause))
2032 self.assertEqual(10010, pr[0].cause[1].cause[0].code) 2030 self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code)
2033 2031
2034 def test_oneOf(self): 2032 def test_oneOf(self):
2035 pr = list(data_schema.validate( 2033 pr = list(data_schema.validate(
2036 None, 2034 None,
2037 {"type": { 2035 {"type": {
2050 {"type": "deny"}, 2048 {"type": "deny"},
2051 ] 2049 ]
2052 }})) 2050 }}))
2053 2051
2054 self.assertEqual(1, len(pr)) 2052 self.assertEqual(1, len(pr))
2055 self.assertEqual(10053, pr[0].code) 2053 self.assertEqual(ERRORS.E10053, pr[0].code)
2056 self.assertEqual(2, len(pr[0].cause)) 2054 self.assertEqual(2, len(pr[0].cause))
2057 self.assertEqual(10054, pr[0].cause[0].code) 2055 self.assertEqual(ERRORS.E10054, pr[0].cause[0].code)
2058 self.assertEqual(1, len(pr[0].cause[0].cause)) 2056 self.assertEqual(1, len(pr[0].cause[0].cause))
2059 self.assertEqual(10002, pr[0].cause[0].cause[0].code) 2057 self.assertEqual(ERRORS.E10002, pr[0].cause[0].cause[0].code)
2060 self.assertEqual(10054, pr[0].cause[1].code) 2058 self.assertEqual(ERRORS.E10054, pr[0].cause[1].code)
2061 self.assertEqual(1, len(pr[0].cause[1].cause)) 2059 self.assertEqual(1, len(pr[0].cause[1].cause))
2062 self.assertEqual(10010, pr[0].cause[1].cause[0].code) 2060 self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code)
2063 2061
2064 pr = list(data_schema.validate( 2062 pr = list(data_schema.validate(
2065 None, 2063 None,
2066 {"type": { 2064 {"type": {
2067 "one-of": [ 2065 "one-of": [
2070 {"type": "empty"}, 2068 {"type": "empty"},
2071 {"type": None}, 2069 {"type": None},
2072 ] 2070 ]
2073 }})) 2071 }}))
2074 self.assertEqual(1, len(pr)) 2072 self.assertEqual(1, len(pr))
2075 self.assertEqual(10019, pr[0].code) 2073 self.assertEqual(ERRORS.E10019, pr[0].code)
2076 self.assertEqual("2,3", pr[0].hint) 2074 self.assertEqual("2,3", pr[0].hint)
2077 2075
2078 def test_not(self): 2076 def test_not(self):
2079 pr = list(data_schema.validate( 2077 pr = list(data_schema.validate(
2080 None, 2078 None,
2081 {"type": { 2079 {"type": {
2082 "not": { 2080 "not": {
2083 "type": "empty"}}})) 2081 "type": "empty"}}}))
2084 self.assertEqual(1, len(pr)) 2082 self.assertEqual(1, len(pr))
2085 self.assertEqual(10029, pr[0].code) 2083 self.assertEqual(ERRORS.E10029, pr[0].code)
2086 2084
2087 pr = list(data_schema.validate( 2085 pr = list(data_schema.validate(
2088 None, 2086 None,
2089 {"type": { 2087 {"type": {
2090 "not": { 2088 "not": {
2097 2, 2095 2,
2098 {"type": { 2096 {"type": {
2099 "not": { 2097 "not": {
2100 "type": "int"}}})) 2098 "type": "int"}}}))
2101 self.assertEqual(1, len(pr)) 2099 self.assertEqual(1, len(pr))
2102 self.assertEqual(10029, pr[0].code) 2100 self.assertEqual(ERRORS.E10029, pr[0].code)
2103 2101
2104 pr = list(data_schema.validate( 2102 pr = list(data_schema.validate(
2105 1, 2103 1,
2106 {"type": { 2104 {"type": {
2107 "not": { 2105 "not": {
2121 pr = list(data_schema.validate( 2119 pr = list(data_schema.validate(
2122 None, 2120 None,
2123 {"not": { 2121 {"not": {
2124 "type": "empty"}})) 2122 "type": "empty"}}))
2125 self.assertEqual(1, len(pr)) 2123 self.assertEqual(1, len(pr))
2126 self.assertEqual(10029, pr[0].code) 2124 self.assertEqual(ERRORS.E10029, pr[0].code)
2127 2125
2128 pr = list(data_schema.validate( 2126 pr = list(data_schema.validate(
2129 None, 2127 None,
2130 {"not": { 2128 {"not": {
2131 "not": { 2129 "not": {
2135 pr = list(data_schema.validate( 2133 pr = list(data_schema.validate(
2136 2, 2134 2,
2137 {"not": { 2135 {"not": {
2138 "type": "int"}})) 2136 "type": "int"}}))
2139 self.assertEqual(1, len(pr)) 2137 self.assertEqual(1, len(pr))
2140 self.assertEqual(10029, pr[0].code) 2138 self.assertEqual(ERRORS.E10029, pr[0].code)
2141 2139
2142 pr = list(data_schema.validate( 2140 pr = list(data_schema.validate(
2143 1, 2141 1,
2144 {"not": { 2142 {"not": {
2145 "not": { 2143 "not": {
2156 pr = list(data_schema.validate(1, {"type": "integer"})) 2154 pr = list(data_schema.validate(1, {"type": "integer"}))
2157 self.assertEqual(0, len(pr)) 2155 self.assertEqual(0, len(pr))
2158 2156
2159 pr = list(data_schema.validate(1, {"type": "float"})) 2157 pr = list(data_schema.validate(1, {"type": "float"}))
2160 self.assertEqual(1, len(pr)) 2158 self.assertEqual(1, len(pr))
2161 self.assertEqual(10023, pr[0].code) 2159 self.assertEqual(ERRORS.E10023, pr[0].code)
2162 2160
2163 pr = list(data_schema.validate( 2161 pr = list(data_schema.validate(
2164 2, 2162 2,
2165 {"type": "int", 2163 {"type": "int",
2166 "minValue": 3, 2164 "minValue": 3,
2167 "maxValue": 1})) 2165 "maxValue": 1}))
2168 2166
2169 self.assertEqual(2, len(pr)) 2167 self.assertEqual(2, len(pr))
2170 self.assertEqual(10021, pr[0].code) 2168 self.assertEqual(ERRORS.E10021, pr[0].code)
2171 self.assertEqual(10022, pr[1].code) 2169 self.assertEqual(ERRORS.E10022, pr[1].code)
2172 2170
2173 def test_float(self): 2171 def test_float(self):
2174 pr = list(data_schema.validate(1.8, {"type": "float"})) 2172 pr = list(data_schema.validate(1.8, {"type": "float"}))
2175 self.assertEqual(0, len(pr)) 2173 self.assertEqual(0, len(pr))
2176 2174
2177 pr = list(data_schema.validate(1, {"type": "float"})) 2175 pr = list(data_schema.validate(1, {"type": "float"}))
2178 self.assertEqual(1, len(pr)) 2176 self.assertEqual(1, len(pr))
2179 self.assertEqual(10023, pr[0].code) 2177 self.assertEqual(ERRORS.E10023, pr[0].code)
2180 2178
2181 pr = list(data_schema.validate( 2179 pr = list(data_schema.validate(
2182 2.0, 2180 2.0,
2183 {"type": "real", 2181 {"type": "real",
2184 "minValue": 2.1, 2182 "minValue": 2.1,
2185 "maxValue": 1.9})) 2183 "maxValue": 1.9}))
2186 2184
2187 self.assertEqual(2, len(pr)) 2185 self.assertEqual(2, len(pr))
2188 self.assertEqual(10024, pr[0].code) 2186 self.assertEqual(ERRORS.E10024, pr[0].code)
2189 self.assertEqual(10025, pr[1].code) 2187 self.assertEqual(ERRORS.E10025, pr[1].code)
2190 2188
2191 def test_number(self): 2189 def test_number(self):
2192 pr = list(data_schema.validate(1.8, {"type": "number"})) 2190 pr = list(data_schema.validate(1.8, {"type": "number"}))
2193 self.assertEqual(0, len(pr)) 2191 self.assertEqual(0, len(pr))
2194 pr = list(data_schema.validate(1, {"type": "num"})) 2192 pr = list(data_schema.validate(1, {"type": "num"}))
2199 {"type": "number", 2197 {"type": "number",
2200 "minValue": 3, 2198 "minValue": 3,
2201 "maxValue": 1.3})) 2199 "maxValue": 1.3}))
2202 2200
2203 self.assertEqual(2, len(pr)) 2201 self.assertEqual(2, len(pr))
2204 self.assertEqual(10031, pr[0].code) 2202 self.assertEqual(ERRORS.E10031, pr[0].code)
2205 self.assertEqual(10032, pr[1].code) 2203 self.assertEqual(ERRORS.E10032, pr[1].code)
2206 2204
2207 pr = list(data_schema.validate({}, {"type": "number"})) 2205 pr = list(data_schema.validate({}, {"type": "number"}))
2208 self.assertEqual(1, len(pr)) 2206 self.assertEqual(1, len(pr))
2209 self.assertEqual(10030, pr[0].code) 2207 self.assertEqual(ERRORS.E10030, pr[0].code)
2210 2208
2211 def test_bool(self): 2209 def test_bool(self):
2212 pr = list(data_schema.validate(True, {"type": "bool"})) 2210 pr = list(data_schema.validate(True, {"type": "bool"}))
2213 self.assertEqual(0, len(pr)) 2211 self.assertEqual(0, len(pr))
2214 2212
2217 self.assertEqual(0, len(pr)) 2215 self.assertEqual(0, len(pr))
2218 2216
2219 pr = list(data_schema.validate(True, {"type": "boolean", 2217 pr = list(data_schema.validate(True, {"type": "boolean",
2220 "value": False})) 2218 "value": False}))
2221 self.assertEqual(1, len(pr)) 2219 self.assertEqual(1, len(pr))
2222 self.assertEqual(10028, pr[0].code) 2220 self.assertEqual(ERRORS.E10028, pr[0].code)
2223 2221
2224 pr = list(data_schema.validate(False, {"type": "boolean"})) 2222 pr = list(data_schema.validate(False, {"type": "boolean"}))
2225 self.assertEqual(0, len(pr)) 2223 self.assertEqual(0, len(pr))
2226 2224
2227 pr = list(data_schema.validate(False, {"type": "boolean", 2225 pr = list(data_schema.validate(False, {"type": "boolean",
2229 self.assertEqual(0, len(pr)) 2227 self.assertEqual(0, len(pr))
2230 2228
2231 pr = list(data_schema.validate(False, {"type": "boolean", 2229 pr = list(data_schema.validate(False, {"type": "boolean",
2232 "value": True})) 2230 "value": True}))
2233 self.assertEqual(1, len(pr)) 2231 self.assertEqual(1, len(pr))
2234 self.assertEqual(10027, pr[0].code) 2232 self.assertEqual(ERRORS.E10027, pr[0].code)
2235 2233
2236 def test_bool_real(self): 2234 def test_bool_real(self):
2237 pr = list(data_schema.validate([1, 2], {"type": "bool"})) 2235 pr = list(data_schema.validate([1, 2], {"type": "bool"}))
2238 self.assertEqual(1, len(pr)) 2236 self.assertEqual(1, len(pr))
2239 self.assertEqual(10026, pr[0].code) 2237 self.assertEqual(ERRORS.E10026, pr[0].code)
2240 2238
2241 pr = list(data_schema.validate([], {"type": "bool"})) 2239 pr = list(data_schema.validate([], {"type": "bool"}))
2242 self.assertEqual(1, len(pr)) 2240 self.assertEqual(1, len(pr))
2243 self.assertEqual(10026, pr[0].code) 2241 self.assertEqual(ERRORS.E10026, pr[0].code)
2244 2242
2245 pr = list(data_schema.validate(None, {"type": "bool"})) 2243 pr = list(data_schema.validate(None, {"type": "bool"}))
2246 self.assertEqual(1, len(pr)) 2244 self.assertEqual(1, len(pr))
2247 self.assertEqual(10026, pr[0].code) 2245 self.assertEqual(ERRORS.E10026, pr[0].code)
2248 2246
2249 @staticmethod 2247 @staticmethod
2250 def _check_value_ts(obj, schema, context): 2248 def _check_value_ts(obj, schema, context):
2251 if obj == datetime.datetime.fromtimestamp(0): 2249 if obj == datetime.datetime.fromtimestamp(0):
2252 yield data_schema.ValidationProblem( 2250 yield data_schema.ValidationProblem(
2253 code=10042, hint=obj, context=context) 2251 code=ERRORS.E10042, hint=obj, context=context)
2254 2252
2255 def test_timestamp(self): 2253 def test_timestamp(self):
2256 pr = list(data_schema.validate( 2254 pr = list(data_schema.validate(
2257 datetime.datetime.utcnow(), 2255 datetime.datetime.utcnow(),
2258 {"type": "timestamp"})) 2256 {"type": "timestamp"}))
2266 pr = list(data_schema.validate( 2264 pr = list(data_schema.validate(
2267 datetime.datetime.fromtimestamp(0), 2265 datetime.datetime.fromtimestamp(0),
2268 {"type": "datetime", 2266 {"type": "datetime",
2269 "value": self._check_value_ts})) 2267 "value": self._check_value_ts}))
2270 self.assertEqual(1, len(pr)) 2268 self.assertEqual(1, len(pr))
2271 self.assertEqual(10042, pr[0].code) 2269 self.assertEqual(ERRORS.E10042, pr[0].code)
2272 2270
2273 def test_scalar(self): 2271 def test_scalar(self):
2274 pr = list(data_schema.validate(1, {"type": "scalar"})) 2272 pr = list(data_schema.validate(1, {"type": "scalar"}))
2275 self.assertEqual(0, len(pr)) 2273 self.assertEqual(0, len(pr))
2276 2274
2284 {"type": "scalar"})) 2282 {"type": "scalar"}))
2285 self.assertEqual(0, len(pr)) 2283 self.assertEqual(0, len(pr))
2286 2284
2287 pr = list(data_schema.validate(None, {"type": "scalar"})) 2285 pr = list(data_schema.validate(None, {"type": "scalar"}))
2288 self.assertEqual(1, len(pr)) 2286 self.assertEqual(1, len(pr))
2289 self.assertEqual(10033, pr[0].code) 2287 self.assertEqual(ERRORS.E10033, pr[0].code)
2290 2288
2291 pr = list(data_schema.validate({}, {"type": "scalar"})) 2289 pr = list(data_schema.validate({}, {"type": "scalar"}))
2292 self.assertEqual(1, len(pr)) 2290 self.assertEqual(1, len(pr))
2293 self.assertEqual(10033, pr[0].code) 2291 self.assertEqual(ERRORS.E10033, pr[0].code)
2294 2292
2295 pr = list(data_schema.validate([], {"type": "scalar"})) 2293 pr = list(data_schema.validate([], {"type": "scalar"}))
2296 self.assertEqual(1, len(pr)) 2294 self.assertEqual(1, len(pr))
2297 self.assertEqual(10033, pr[0].code) 2295 self.assertEqual(ERRORS.E10033, pr[0].code)
2298 2296
2299 pr = list(data_schema.validate(tuple(), {"type": "scalar"})) 2297 pr = list(data_schema.validate(tuple(), {"type": "scalar"}))
2300 self.assertEqual(1, len(pr)) 2298 self.assertEqual(1, len(pr))
2301 self.assertEqual(10033, pr[0].code) 2299 self.assertEqual(ERRORS.E10033, pr[0].code)
2302 2300
2303 pr = list(data_schema.validate(set(), {"type": "scalar"})) 2301 pr = list(data_schema.validate(set(), {"type": "scalar"}))
2304 self.assertEqual(1, len(pr)) 2302 self.assertEqual(1, len(pr))
2305 self.assertEqual(10033, pr[0].code) 2303 self.assertEqual(ERRORS.E10033, pr[0].code)
2306 2304
2307 pr = list(data_schema.validate(frozenset(), {"type": "scalar"})) 2305 pr = list(data_schema.validate(frozenset(), {"type": "scalar"}))
2308 self.assertEqual(1, len(pr)) 2306 self.assertEqual(1, len(pr))
2309 self.assertEqual(10033, pr[0].code) 2307 self.assertEqual(ERRORS.E10033, pr[0].code)
2310 2308
2311 pr = list(data_schema.validate( 2309 pr = list(data_schema.validate(
2312 None, 2310 None,
2313 {"type": { 2311 {"type": {
2314 "one-of": [ 2312 "one-of": [