Mercurial > hgrepos > Python > libs > data-schema

comparison tests/test_schema.py @ 31:271ec3abdfa3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Use "$type" as the schema's type specifier instead of "type". THIS IS BACKWARDS INCOMPATIBLE.
author Franz Glasner <f.glasner@feldmann-mg.com>
date Tue, 18 Jul 2023 14:28:52 +0200
parents 2e7c08c356ee
children 5a2fba996773
comparison
equal deleted inserted replaced
30:2e7c08c356ee 31:271ec3abdfa3
587 def setUp(self): 587 def setUp(self):
588 self._ctx = data_schema.Context( 588 self._ctx = data_schema.Context(
589 None, root_object={"foo": "bar", "foo2": None}, settings=None) 589 None, root_object={"foo": "bar", "foo2": None}, settings=None)
590 590
591 def test_no_cond(self): 591 def test_no_cond(self):
592 schema = data_schema._Schema(None, True, {"type": None}) 592 schema = data_schema._Schema(None, True, {"$type": None})
593 self.assertIs(data_schema.process_schema_conditionals( 593 self.assertIs(data_schema.process_schema_conditionals(
594 schema, self._ctx), 594 schema, self._ctx),
595 schema) 595 schema)
596 596
597 def test_cond_is_none(self): 597 def test_cond_is_none(self):
598 schema = data_schema._Schema(None, True, {"type": None, 598 schema = data_schema._Schema(None, True, {"$type": None,
599 "cond": None}) 599 "cond": None})
600 self.assertIs(data_schema.process_schema_conditionals( 600 self.assertIs(data_schema.process_schema_conditionals(
601 schema, self._ctx), 601 schema, self._ctx),
602 schema) 602 schema)
603 603
604 def test_ambiguous(self): 604 def test_ambiguous(self):
605 schema = data_schema._Schema(None, True, {"type": None, 605 schema = data_schema._Schema(None, True, {"$type": None,
606 "cond": None, 606 "cond": None,
607 "match": None}) 607 "match": None})
608 self.assertRaises( 608 self.assertRaises(
609 data_schema.SchemaError, 609 data_schema.SchemaError,
610 data_schema.process_schema_conditionals, 610 data_schema.process_schema_conditionals,
611 schema, 611 schema,
612 self._ctx) 612 self._ctx)
613 613
614 def test_cond_not_a_sequence(self): 614 def test_cond_not_a_sequence(self):
615 schema = data_schema._Schema(None, True, {"type": None, 615 schema = data_schema._Schema(None, True, {"$type": None,
616 "cond": {"type": None}}) 616 "cond": {"$type": None}})
617 self.assertRaises( 617 self.assertRaises(
618 data_schema.SchemaError, 618 data_schema.SchemaError,
619 data_schema.process_schema_conditionals, 619 data_schema.process_schema_conditionals,
620 schema, 620 schema,
621 self._ctx) 621 self._ctx)
622 622
623 def test_match_not_a_sequence(self): 623 def test_match_not_a_sequence(self):
624 schema = data_schema._Schema( 624 schema = data_schema._Schema(
625 None, True, {"type": None, 625 None, True, {"$type": None,
626 "match": {"type": None}}) 626 "match": {"$type": None}})
627 self.assertRaises( 627 self.assertRaises(
628 data_schema.SchemaError, 628 data_schema.SchemaError,
629 data_schema.process_schema_conditionals, 629 data_schema.process_schema_conditionals,
630 schema, 630 schema,
631 self._ctx) 631 self._ctx)
632 632
633 def test_condline_not_a_dict(self): 633 def test_condline_not_a_dict(self):
634 schema = data_schema._Schema(None, True, {"type": None, 634 schema = data_schema._Schema(None, True, {"$type": None,
635 "cond": [None]}) 635 "cond": [None]})
636 self.assertRaises( 636 self.assertRaises(
637 data_schema.SchemaError, 637 data_schema.SchemaError,
638 data_schema.process_schema_conditionals, 638 data_schema.process_schema_conditionals,
639 schema, 639 schema,
640 self._ctx) 640 self._ctx)
641 641
642 def test_matchline_not_a_dict(self): 642 def test_matchline_not_a_dict(self):
643 schema = {"type": None, 643 schema = {"$type": None,
644 "match": [None]} 644 "match": [None]}
645 self.assertRaises( 645 self.assertRaises(
646 data_schema.SchemaError, 646 data_schema.SchemaError,
647 data_schema.process_schema_conditionals, 647 data_schema.process_schema_conditionals,
648 schema, 648 schema,
649 self._ctx) 649 self._ctx)
650 650
651 def test_cond_unknown_predicate(self): 651 def test_cond_unknown_predicate(self):
652 schema = data_schema._Schema( 652 schema = data_schema._Schema(
653 None, True, {"type": None, 653 None, True, {"$type": None,
654 "cond": [ 654 "cond": [
655 {"unexisting-when-xxxx": None, 655 {"unexisting-when-xxxx": None,
656 "then": {}} 656 "then": {}}
657 ]}) 657 ]})
658 self.assertRaises( 658 self.assertRaises(
661 schema, 661 schema,
662 self._ctx) 662 self._ctx)
663 663
664 def test_match_unknown_predicate(self): 664 def test_match_unknown_predicate(self):
665 schema = data_schema._Schema( 665 schema = data_schema._Schema(
666 None, True, {"type": None, 666 None, True, {"$type": None,
667 "match": [ 667 "match": [
668 {"unexisting-when-xxxx": None, 668 {"unexisting-when-xxxx": None,
669 "then": {}} 669 "then": {}}
670 ]}) 670 ]})
671 self.assertRaises( 671 self.assertRaises(
674 schema, 674 schema,
675 self._ctx) 675 self._ctx)
676 676
677 def test_simple_replace_when_true(self): 677 def test_simple_replace_when_true(self):
678 schema = data_schema._Schema( 678 schema = data_schema._Schema(
679 None, True, {"type": None, 679 None, True, {"$type": None,
680 "require": ["huhu", "haha"], 680 "require": ["huhu", "haha"],
681 "cond": [ 681 "cond": [
682 {"when": True, 682 {"when": True,
683 "then": { 683 "then": {
684 "require": ["r1", "r2", "r3"], 684 "require": ["r1", "r2", "r3"],
692 self.assertIsNone(r["new-key"]) 692 self.assertIsNone(r["new-key"])
693 self.assertFalse("cond" in r) 693 self.assertFalse("cond" in r)
694 694
695 def test_simple_replace_when_not_false(self): 695 def test_simple_replace_when_not_false(self):
696 schema = data_schema._Schema( 696 schema = data_schema._Schema(
697 None, True, {"type": None, 697 None, True, {"$type": None,
698 "require": ["huhu", "haha"], 698 "require": ["huhu", "haha"],
699 "cond": [ 699 "cond": [
700 {"when": {"not": False}, 700 {"when": {"not": False},
701 "then": { 701 "then": {
702 "require": ["r1", "r2", "r3"], 702 "require": ["r1", "r2", "r3"],
710 self.assertIsNone(r["new-key"]) 710 self.assertIsNone(r["new-key"])
711 self.assertFalse("cond" in r) 711 self.assertFalse("cond" in r)
712 712
713 def test_simple_merge_when_true(self): 713 def test_simple_merge_when_true(self):
714 schema = data_schema._Schema( 714 schema = data_schema._Schema(
715 None, True, {"type": None, 715 None, True, {"$type": None,
716 "require": ["huhu", "haha"], 716 "require": ["huhu", "haha"],
717 "old-key": "here I am", 717 "old-key": "here I am",
718 "cond": [ 718 "cond": [
719 {"when": True, 719 {"when": True,
720 "then-merge": { 720 "then-merge": {
731 self.assertFalse("old-key" in r) 731 self.assertFalse("old-key" in r)
732 self.assertFalse("cond" in r) 732 self.assertFalse("cond" in r)
733 733
734 def test_simple_replace_first_wins_1(self): 734 def test_simple_replace_first_wins_1(self):
735 schema = data_schema._Schema( 735 schema = data_schema._Schema(
736 None, True, {"type": None, 736 None, True, {"$type": None,
737 "require": ["huhu", "haha", "hehe"], 737 "require": ["huhu", "haha", "hehe"],
738 "cond": [ 738 "cond": [
739 {"when": True, 739 {"when": True,
740 "then": { 740 "then": {
741 "new-key2": "v2"}}, 741 "new-key2": "v2"}},
751 self.assertEqual("v2", r["new-key2"]) 751 self.assertEqual("v2", r["new-key2"])
752 self.assertFalse("cond" in r) 752 self.assertFalse("cond" in r)
753 753
754 def test_simple_replace_first_wins_2(self): 754 def test_simple_replace_first_wins_2(self):
755 schema = data_schema._Schema( 755 schema = data_schema._Schema(
756 None, True, {"type": None, 756 None, True, {"$type": None,
757 "require": ["huhu", "haha", "hehe"], 757 "require": ["huhu", "haha", "hehe"],
758 "cond": [ 758 "cond": [
759 {"when": False, 759 {"when": False,
760 "then": { 760 "then": {
761 "new-key2": "v2"}}, 761 "new-key2": "v2"}},
772 self.assertFalse("new-key2" in r) 772 self.assertFalse("new-key2" in r)
773 self.assertFalse("cond" in r) 773 self.assertFalse("cond" in r)
774 774
775 def test_simple_replace_when_false(self): 775 def test_simple_replace_when_false(self):
776 schema = data_schema._Schema( 776 schema = data_schema._Schema(
777 None, True, {"type": None, 777 None, True, {"$type": None,
778 "require": ["huhu", "haha"], 778 "require": ["huhu", "haha"],
779 "cond": [ 779 "cond": [
780 {"when": False, 780 {"when": False,
781 "then": { 781 "then": {
782 "require": ["r1", "r2", "r3"], 782 "require": ["r1", "r2", "r3"],
789 self.assertFalse("new-key" in r) 789 self.assertFalse("new-key" in r)
790 self.assertFalse("cond" in r) 790 self.assertFalse("cond" in r)
791 791
792 def test_simple_replace_when_ref_true(self): 792 def test_simple_replace_when_ref_true(self):
793 schema = data_schema._Schema( 793 schema = data_schema._Schema(
794 None, True, {"type": None, 794 None, True, {"$type": None,
795 "require": ["huhu", "haha"], 795 "require": ["huhu", "haha"],
796 "cond": [ 796 "cond": [
797 {"when-ref-true": '#foo', 797 {"when-ref-true": '#foo',
798 "then": { 798 "then": {
799 "require": ["r1", "r2", "r3"], 799 "require": ["r1", "r2", "r3"],
807 self.assertIsNone(r["new-key"]) 807 self.assertIsNone(r["new-key"])
808 self.assertFalse("cond" in r) 808 self.assertFalse("cond" in r)
809 809
810 def test_simple_replace_when_ref_true_2(self): 810 def test_simple_replace_when_ref_true_2(self):
811 schema = data_schema._Schema( 811 schema = data_schema._Schema(
812 None, True, {"type": None, 812 None, True, {"$type": None,
813 "require": ["huhu", "haha"], 813 "require": ["huhu", "haha"],
814 "cond": [ 814 "cond": [
815 {"when": {"ref-true": '#foo'}, 815 {"when": {"ref-true": '#foo'},
816 "then": { 816 "then": {
817 "require": ["r1", "r2", "r3"], 817 "require": ["r1", "r2", "r3"],
825 self.assertIsNone(r["new-key"]) 825 self.assertIsNone(r["new-key"])
826 self.assertFalse("cond" in r) 826 self.assertFalse("cond" in r)
827 827
828 def test_simple_replace_when_ref_is_not_true(self): 828 def test_simple_replace_when_ref_is_not_true(self):
829 schema = data_schema._Schema( 829 schema = data_schema._Schema(
830 None, True, {"type": None, 830 None, True, {"$type": None,
831 "require": ["huhu", "haha"], 831 "require": ["huhu", "haha"],
832 "cond": [ 832 "cond": [
833 {"when-ref-true": '#not-a-foo', 833 {"when-ref-true": '#not-a-foo',
834 "then": { 834 "then": {
835 "require": ["r1", "r2", "r3"], 835 "require": ["r1", "r2", "r3"],
842 self.assertTrue("new-key" not in r) 842 self.assertTrue("new-key" not in r)
843 self.assertFalse("cond" in r) 843 self.assertFalse("cond" in r)
844 844
845 def test_simple_replace_when_ref_is_not_true_2(self): 845 def test_simple_replace_when_ref_is_not_true_2(self):
846 schema = data_schema._Schema( 846 schema = data_schema._Schema(
847 None, True, {"type": None, 847 None, True, {"$type": None,
848 "require": ["huhu", "haha"], 848 "require": ["huhu", "haha"],
849 "cond": [ 849 "cond": [
850 {"when": {"ref-true": '#not-a-foo'}, 850 {"when": {"ref-true": '#not-a-foo'},
851 "then": { 851 "then": {
852 "require": ["r1", "r2", "r3"], 852 "require": ["r1", "r2", "r3"],
859 self.assertTrue("new-key" not in r) 859 self.assertTrue("new-key" not in r)
860 self.assertFalse("cond" in r) 860 self.assertFalse("cond" in r)
861 861
862 def test_simple_replace_when_ref_exists(self): 862 def test_simple_replace_when_ref_exists(self):
863 schema = data_schema._Schema( 863 schema = data_schema._Schema(
864 None, True, {"type": None, 864 None, True, {"$type": None,
865 "require": ["huhu", "haha"], 865 "require": ["huhu", "haha"],
866 "cond": [ 866 "cond": [
867 {"when-ref-exists": '#foo2', 867 {"when-ref-exists": '#foo2',
868 "then": { 868 "then": {
869 "require": ["r1", "r2", "r3"], 869 "require": ["r1", "r2", "r3"],
881 self.assertFalse("new-key3" in r) 881 self.assertFalse("new-key3" in r)
882 self.assertFalse("cond" in r) 882 self.assertFalse("cond" in r)
883 883
884 def test_simple_replace_when_ref_exists_2(self): 884 def test_simple_replace_when_ref_exists_2(self):
885 schema = data_schema._Schema( 885 schema = data_schema._Schema(
886 None, True, {"type": None, 886 None, True, {"$type": None,
887 "require": ["huhu", "haha"], 887 "require": ["huhu", "haha"],
888 "cond": [ 888 "cond": [
889 {"when": {"ref-exists": '#foo2'}, 889 {"when": {"ref-exists": '#foo2'},
890 "then": { 890 "then": {
891 "require": ["r1", "r2", "r3"], 891 "require": ["r1", "r2", "r3"],
903 self.assertFalse("new-key3" in r) 903 self.assertFalse("new-key3" in r)
904 self.assertFalse("cond" in r) 904 self.assertFalse("cond" in r)
905 905
906 def test_simple_replace_when_ref_exists_is_false(self): 906 def test_simple_replace_when_ref_exists_is_false(self):
907 schema = data_schema._Schema( 907 schema = data_schema._Schema(
908 None, True, {"type": None, 908 None, True, {"$type": None,
909 "cond": [ 909 "cond": [
910 {"when-ref-exists": '#foo-not-existing', 910 {"when-ref-exists": '#foo-not-existing',
911 "then": { 911 "then": {
912 "require": ["r1", "r2", "r3"], 912 "require": ["r1", "r2", "r3"],
913 "new-key": None, 913 "new-key": None,
923 self.assertEqual("val", r["new-key3"]) 923 self.assertEqual("val", r["new-key3"])
924 self.assertFalse("cond" in r) 924 self.assertFalse("cond" in r)
925 925
926 def test_simple_replace_when_ref_exists_is_false_2(self): 926 def test_simple_replace_when_ref_exists_is_false_2(self):
927 schema = data_schema._Schema( 927 schema = data_schema._Schema(
928 None, True, {"type": None, 928 None, True, {"$type": None,
929 "cond": [ 929 "cond": [
930 {"when": {"ref-exists": '#foo-not-existing'}, 930 {"when": {"ref-exists": '#foo-not-existing'},
931 "then": { 931 "then": {
932 "require": ["r1", "r2", "r3"], 932 "require": ["r1", "r2", "r3"],
933 "new-key": None, 933 "new-key": None,
948 None, True, {"cond": [ 948 None, True, {"cond": [
949 {"when": {"all-of": [ 949 {"when": {"all-of": [
950 True, 950 True,
951 {"ref-exists": '#foo2'}, 951 {"ref-exists": '#foo2'},
952 {"ref-true": '#foo'}]}, 952 {"ref-true": '#foo'}]},
953 "then": {"type": "string"}}, 953 "then": {"$type": "string"}},
954 {"when": True, 954 {"when": True,
955 "then": {"type": None}} 955 "then": {"$type": None}}
956 ]}) 956 ]})
957 r = data_schema.process_schema_conditionals(schema, self._ctx) 957 r = data_schema.process_schema_conditionals(schema, self._ctx)
958 self.assertIsNot(r, schema) 958 self.assertIsNot(r, schema)
959 self.assertEqual("string", r["type"]) 959 self.assertEqual("string", r["$type"])
960 960
961 def test_allOf_false(self): 961 def test_allOf_false(self):
962 schema = data_schema._Schema( 962 schema = data_schema._Schema(
963 None, True, {"cond": [ 963 None, True, {"cond": [
964 {"when": {"all-of": [ 964 {"when": {"all-of": [
965 True, 965 True,
966 {"ref-exists": '#foo-non-existing'}, 966 {"ref-exists": '#foo-non-existing'},
967 {"ref-true": '#foo'}]}, 967 {"ref-true": '#foo'}]},
968 "then": {"type": "string"}}, 968 "then": {"$type": "string"}},
969 {"when": True, 969 {"when": True,
970 "then": {"type": None}} 970 "then": {"$type": None}}
971 ]}) 971 ]})
972 r = data_schema.process_schema_conditionals(schema, self._ctx) 972 r = data_schema.process_schema_conditionals(schema, self._ctx)
973 self.assertIsNot(r, schema) 973 self.assertIsNot(r, schema)
974 self.assertIsNone(r["type"]) 974 self.assertIsNone(r["$type"])
975 975
976 def test_short_allOf_true(self): 976 def test_short_allOf_true(self):
977 schema = data_schema._Schema( 977 schema = data_schema._Schema(
978 None, True, {"cond": [ 978 None, True, {"cond": [
979 {"when": [ 979 {"when": [
980 True, 980 True,
981 {"ref-exists": '#foo2'}, 981 {"ref-exists": '#foo2'},
982 {"ref-true": '#foo'}], 982 {"ref-true": '#foo'}],
983 "then": {"type": "string"}}, 983 "then": {"$type": "string"}},
984 {"when": True, 984 {"when": True,
985 "then": {"type": None}} 985 "then": {"$type": None}}
986 ]}) 986 ]})
987 r = data_schema.process_schema_conditionals(schema, self._ctx) 987 r = data_schema.process_schema_conditionals(schema, self._ctx)
988 self.assertIsNot(r, schema) 988 self.assertIsNot(r, schema)
989 self.assertEqual("string", r["type"]) 989 self.assertEqual("string", r["$type"])
990 990
991 def test_short_allOf_false(self): 991 def test_short_allOf_false(self):
992 schema = data_schema._Schema( 992 schema = data_schema._Schema(
993 None, True, {"cond": [ 993 None, True, {"cond": [
994 {"when": [ 994 {"when": [
995 True, 995 True,
996 {"ref-exists": '#foo-non-existing'}, 996 {"ref-exists": '#foo-non-existing'},
997 {"ref-true": '#foo'}], 997 {"ref-true": '#foo'}],
998 "then": {"type": "string"}}, 998 "then": {"$type": "string"}},
999 {"when": True, 999 {"when": True,
1000 "then": {"type": None}} 1000 "then": {"$type": None}}
1001 ]}) 1001 ]})
1002 r = data_schema.process_schema_conditionals(schema, self._ctx) 1002 r = data_schema.process_schema_conditionals(schema, self._ctx)
1003 self.assertIsNot(r, schema) 1003 self.assertIsNot(r, schema)
1004 self.assertIsNone(r["type"]) 1004 self.assertIsNone(r["$type"])
1005 1005
1006 def test_anyOf_true(self): 1006 def test_anyOf_true(self):
1007 schema = data_schema._Schema( 1007 schema = data_schema._Schema(
1008 None, True, {"cond": [ 1008 None, True, {"cond": [
1009 {"when": {"any-of": [ 1009 {"when": {"any-of": [
1010 False, 1010 False,
1011 {"ref-exists": '#foo2'}, 1011 {"ref-exists": '#foo2'},
1012 {"ref-true": '#foo'}]}, 1012 {"ref-true": '#foo'}]},
1013 "then": {"type": "string"}}, 1013 "then": {"$type": "string"}},
1014 {"when": True, 1014 {"when": True,
1015 "then": {"type": None}} 1015 "then": {"$type": None}}
1016 ]}) 1016 ]})
1017 r = data_schema.process_schema_conditionals(schema, self._ctx) 1017 r = data_schema.process_schema_conditionals(schema, self._ctx)
1018 self.assertIsNot(r, schema) 1018 self.assertIsNot(r, schema)
1019 self.assertEqual("string", r["type"]) 1019 self.assertEqual("string", r["$type"])
1020 1020
1021 def test_anyOf_false(self): 1021 def test_anyOf_false(self):
1022 schema = data_schema._Schema( 1022 schema = data_schema._Schema(
1023 None, True, {"cond": [ 1023 None, True, {"cond": [
1024 {"when": {"any-of": [ 1024 {"when": {"any-of": [
1025 False, 1025 False,
1026 {"ref-exists": '#foo2-non'}, 1026 {"ref-exists": '#foo2-non'},
1027 {"ref-true": '#foo2'}]}, 1027 {"ref-true": '#foo2'}]},
1028 "then": {"type": "string"}}, 1028 "then": {"$type": "string"}},
1029 {"when": True, 1029 {"when": True,
1030 "then": {"type": None}} 1030 "then": {"$type": None}}
1031 ]}) 1031 ]})
1032 r = data_schema.process_schema_conditionals(schema, self._ctx) 1032 r = data_schema.process_schema_conditionals(schema, self._ctx)
1033 self.assertIsNot(r, schema) 1033 self.assertIsNot(r, schema)
1034 self.assertIsNone(r["type"]) 1034 self.assertIsNone(r["$type"])
1035 1035
1036 def test_oneOf_true(self): 1036 def test_oneOf_true(self):
1037 schema = data_schema._Schema( 1037 schema = data_schema._Schema(
1038 None, True, {"cond": [ 1038 None, True, {"cond": [
1039 {"when": {"one-of": [ 1039 {"when": {"one-of": [
1040 False, 1040 False,
1041 {"ref-exists": '#foo2'}, 1041 {"ref-exists": '#foo2'},
1042 {"not": {"ref-true": '#foo'}}]}, 1042 {"not": {"ref-true": '#foo'}}]},
1043 "then": {"type": "string"}}, 1043 "then": {"$type": "string"}},
1044 {"when": True, 1044 {"when": True,
1045 "then": {"type": None}} 1045 "then": {"$type": None}}
1046 ]}) 1046 ]})
1047 r = data_schema.process_schema_conditionals(schema, self._ctx) 1047 r = data_schema.process_schema_conditionals(schema, self._ctx)
1048 self.assertIsNot(r, schema) 1048 self.assertIsNot(r, schema)
1049 self.assertEqual("string", r["type"]) 1049 self.assertEqual("string", r["$type"])
1050 1050
1051 def test_oneOf_false(self): 1051 def test_oneOf_false(self):
1052 schema = data_schema._Schema( 1052 schema = data_schema._Schema(
1053 None, True, {"cond": [ 1053 None, True, {"cond": [
1054 {"when": {"one-of": [ 1054 {"when": {"one-of": [
1055 False, 1055 False,
1056 {"ref-exists": '#foo2'}, 1056 {"ref-exists": '#foo2'},
1057 {"ref-true": '#foo'}]}, 1057 {"ref-true": '#foo'}]},
1058 "then": {"type": "string"}}, 1058 "then": {"$type": "string"}},
1059 {"when": True, 1059 {"when": True,
1060 "then": {"type": None}} 1060 "then": {"$type": None}}
1061 ]}) 1061 ]})
1062 r = data_schema.process_schema_conditionals(schema, self._ctx) 1062 r = data_schema.process_schema_conditionals(schema, self._ctx)
1063 self.assertIsNot(r, schema) 1063 self.assertIsNot(r, schema)
1064 self.assertIsNone(r["type"]) 1064 self.assertIsNone(r["$type"])
1065 1065
1066 def test_oneOf_false_2(self): 1066 def test_oneOf_false_2(self):
1067 schema = data_schema._Schema( 1067 schema = data_schema._Schema(
1068 None, True, {"cond": [ 1068 None, True, {"cond": [
1069 {"when": {"one-of": [ 1069 {"when": {"one-of": [
1070 False, 1070 False,
1071 {"not": {"ref-exists": '#foo2'}}, 1071 {"not": {"ref-exists": '#foo2'}},
1072 {"not": {"ref-true": '#foo'}}]}, 1072 {"not": {"ref-true": '#foo'}}]},
1073 "then": {"type": "string"}}, 1073 "then": {"$type": "string"}},
1074 {"when": True, 1074 {"when": True,
1075 "then": {"type": None}} 1075 "then": {"$type": None}}
1076 ]}) 1076 ]})
1077 r = data_schema.process_schema_conditionals(schema, self._ctx) 1077 r = data_schema.process_schema_conditionals(schema, self._ctx)
1078 self.assertIsNot(r, schema) 1078 self.assertIsNot(r, schema)
1079 self.assertIsNone(r["type"]) 1079 self.assertIsNone(r["$type"])
1080 1080
1081 def test_match_nothing(self): 1081 def test_match_nothing(self):
1082 schema = data_schema._Schema( 1082 schema = data_schema._Schema(
1083 None, 1083 None,
1084 True, 1084 True,
1215 def test_equal_no_list(self): 1215 def test_equal_no_list(self):
1216 schema = data_schema._Schema( 1216 schema = data_schema._Schema(
1217 None, True, {"foos": "bar", 1217 None, True, {"foos": "bar",
1218 "match": [{ 1218 "match": [{
1219 "when": { 1219 "when": {
1220 "equals": {"type": None}, 1220 "equals": {"$type": None},
1221 "then-replace": { 1221 "then-replace": {
1222 "foos": "new-bar"}}}] 1222 "foos": "new-bar"}}}]
1223 }) 1223 })
1224 self.assertRaises( 1224 self.assertRaises(
1225 data_schema.SchemaError, 1225 data_schema.SchemaError,
1343 data_schema.process_schema_references(schema, ctx) 1343 data_schema.process_schema_references(schema, ctx)
1344 1344
1345 def test_raise_if_scheme_ref_is_not_the_single_key(self): 1345 def test_raise_if_scheme_ref_is_not_the_single_key(self):
1346 schema = data_schema._Schema( 1346 schema = data_schema._Schema(
1347 None, True, {"$ref": "schema:#/", 1347 None, True, {"$ref": "schema:#/",
1348 "type": None 1348 "$type": None
1349 }) 1349 })
1350 ctx = data_schema.Context( 1350 ctx = data_schema.Context(
1351 None, root_schema=schema, settings=None) 1351 None, root_schema=schema, settings=None)
1352 self.assertRaises( 1352 self.assertRaises(
1353 data_schema.SchemaError, 1353 data_schema.SchemaError,
1357 1357
1358 def test_raise_if_scheme_ref_is_not_the_single_key_root(self): 1358 def test_raise_if_scheme_ref_is_not_the_single_key_root(self):
1359 schema = data_schema._Schema( 1359 schema = data_schema._Schema(
1360 None, True, {"$ref": "schema:#/subschema", 1360 None, True, {"$ref": "schema:#/subschema",
1361 "subschema": { 1361 "subschema": {
1362 "type": None 1362 "$type": None
1363 } 1363 }
1364 }) 1364 })
1365 ctx = data_schema.Context( 1365 ctx = data_schema.Context(
1366 None, root_schema=schema, settings=None) 1366 None, root_schema=schema, settings=None)
1367 r = data_schema.process_schema_references( 1367 r = data_schema.process_schema_references(
1368 schema, 1368 schema,
1369 ctx, 1369 ctx,
1370 check_single_ref_key=False) 1370 check_single_ref_key=False)
1371 self.assertEqual({"type": None}, r) 1371 self.assertEqual({"$type": None}, r)
1372 1372
1373 def test_recursive_schema_scheme(self): 1373 def test_recursive_schema_scheme(self):
1374 barschema = { 1374 barschema = {
1375 "type": "null" 1375 "$type": "null"
1376 } 1376 }
1377 fooschema = { 1377 fooschema = {
1378 "$ref": "schema:#/bar" 1378 "$ref": "schema:#/bar"
1379 } 1379 }
1380 schema = data_schema._Schema( 1380 schema = data_schema._Schema(
1386 None, root_schema=schema, settings=None) 1386 None, root_schema=schema, settings=None)
1387 r = data_schema.process_schema_references( 1387 r = data_schema.process_schema_references(
1388 schema, 1388 schema,
1389 ctx, 1389 ctx,
1390 check_single_ref_key=False) 1390 check_single_ref_key=False)
1391 self.assertEqual({"type": "null"}, r) 1391 self.assertEqual({"$type": "null"}, r)
1392 1392
1393 def test_recursive_schema_scheme_raises_if_non_root_is_not_single_key(self): 1393 def test_recursive_schema_scheme_raises_if_non_root_is_not_single_key(self):
1394 barschema = { 1394 barschema = {
1395 "type": "null" 1395 "$type": "null"
1396 } 1396 }
1397 fooschema = { 1397 fooschema = {
1398 "$ref": "schema:#/bar", 1398 "$ref": "schema:#/bar",
1399 "type": "dict", 1399 "$type": "dict",
1400 } 1400 }
1401 schema = data_schema._Schema( 1401 schema = data_schema._Schema(
1402 None, True, { 1402 None, True, {
1403 "foo": fooschema, 1403 "foo": fooschema,
1404 "bar": barschema, 1404 "bar": barschema,
1413 ctx, 1413 ctx,
1414 check_single_ref_key=False) 1414 check_single_ref_key=False)
1415 1415
1416 def test_recursive_schema_scheme_ref_to_non_existing_schema_raises(self): 1416 def test_recursive_schema_scheme_ref_to_non_existing_schema_raises(self):
1417 barschema = { 1417 barschema = {
1418 "type": "null" 1418 "$type": "null"
1419 } 1419 }
1420 fooschema = { 1420 fooschema = {
1421 "$ref": "schema:#/non-bar", 1421 "$ref": "schema:#/non-bar",
1422 } 1422 }
1423 schema = data_schema._Schema( 1423 schema = data_schema._Schema(
1474 def test_warning_ctor(self): 1474 def test_warning_ctor(self):
1475 v = data_schema.ValidationProblem(code=WARNINGS.W80000) 1475 v = data_schema.ValidationProblem(code=WARNINGS.W80000)
1476 self.assertEqual(SEVERITY.WARNING, v.severity) 1476 self.assertEqual(SEVERITY.WARNING, v.severity)
1477 1477
1478 def test_d1(self): 1478 def test_d1(self):
1479 x = list(data_schema.validate({}, {"type": "dict"})) 1479 x = list(data_schema.validate({}, {"$type": "dict"}))
1480 self.assertEqual(0, len(x)) 1480 self.assertEqual(0, len(x))
1481 1481
1482 def test_d1_not_nullable(self): 1482 def test_d1_not_nullable(self):
1483 x = list(data_schema.validate(None, {"type": "dict"})) 1483 x = list(data_schema.validate(None, {"$type": "dict"}))
1484 self.assertEqual(1, len(x)) 1484 self.assertEqual(1, len(x))
1485 self.assertEqual(ERRORS.E10000, x[0].code) 1485 self.assertEqual(ERRORS.E10000, x[0].code)
1486 1486
1487 def test_d1_nullable(self): 1487 def test_d1_nullable(self):
1488 x = list(data_schema.validate(None, {"type": "dict", 1488 x = list(data_schema.validate(None, {"$type": "dict",
1489 "nullable": True})) 1489 "nullable": True}))
1490 self.assertEqual(0, len(x)) 1490 self.assertEqual(0, len(x))
1491 1491
1492 def test_d2(self): 1492 def test_d2(self):
1493 x = list(data_schema.validate([], {"type": "map"})) 1493 x = list(data_schema.validate([], {"$type": "map"}))
1494 self.assertEqual(1, len(x)) 1494 self.assertEqual(1, len(x))
1495 self.assertEqual(SEVERITY.ERROR, x[0].severity) 1495 self.assertEqual(SEVERITY.ERROR, x[0].severity)
1496 self.assertEqual(ERRORS.E10000, x[0].code) 1496 self.assertEqual(ERRORS.E10000, x[0].code)
1497 1497
1498 def test_d3(self): 1498 def test_d3(self):
1499 x = list(data_schema.validate( 1499 x = list(data_schema.validate(
1500 {"key": "value"}, 1500 {"key": "value"},
1501 {"type": "dict", 1501 {"$type": "dict",
1502 "required": ["key2"]})) 1502 "required": ["key2"]}))
1503 self.assertEqual(2, len(x)) 1503 self.assertEqual(2, len(x))
1504 self.assertEqual(SEVERITY.ERROR, x[0].severity) 1504 self.assertEqual(SEVERITY.ERROR, x[0].severity)
1505 self.assertEqual(ERRORS.E10004, x[0].code) 1505 self.assertEqual(ERRORS.E10004, x[0].code)
1506 self.assertEqual("key", x[0].hint) 1506 self.assertEqual("key", x[0].hint)
1509 self.assertEqual(["key2"], x[1].hint) 1509 self.assertEqual(["key2"], x[1].hint)
1510 1510
1511 def test_d4(self): 1511 def test_d4(self):
1512 x = list(data_schema.validate( 1512 x = list(data_schema.validate(
1513 {"key": "value"}, 1513 {"key": "value"},
1514 {"type": "dict", 1514 {"$type": "dict",
1515 "keys": { 1515 "keys": {
1516 "key": {"type": "string"}, 1516 "key": {"$type": "string"},
1517 }, 1517 },
1518 "required": ["key"]})) 1518 "required": ["key"]}))
1519 self.assertEqual(0, len(x)) 1519 self.assertEqual(0, len(x))
1520 1520
1521 def test_d5(self): 1521 def test_d5(self):
1522 x = list(data_schema.validate( 1522 x = list(data_schema.validate(
1523 {"key": "value"}, 1523 {"key": "value"},
1524 {"type": "dict", 1524 {"$type": "dict",
1525 "additional-keys": False})) 1525 "additional-keys": False}))
1526 self.assertEqual(1, len(x)) 1526 self.assertEqual(1, len(x))
1527 self.assertEqual(ERRORS.E10004, x[0].code) 1527 self.assertEqual(ERRORS.E10004, x[0].code)
1528 self.assertEqual("key", x[0].hint) 1528 self.assertEqual("key", x[0].hint)
1529 1529
1530 def test_d5_2(self): 1530 def test_d5_2(self):
1531 x = list(data_schema.validate( 1531 x = list(data_schema.validate(
1532 {"key": "value"}, 1532 {"key": "value"},
1533 {"type": "dict", 1533 {"$type": "dict",
1534 "additional-keys": False}, 1534 "additional-keys": False},
1535 skip_keys=["key"])) 1535 skip_keys=["key"]))
1536 self.assertEqual(0, len(x)) 1536 self.assertEqual(0, len(x))
1537 1537
1538 def test_d5_3(self): 1538 def test_d5_3(self):
1539 x = list(data_schema.validate( 1539 x = list(data_schema.validate(
1540 {"key": "value", 1540 {"key": "value",
1541 "key2": "value"}, 1541 "key2": "value"},
1542 {"type": "dict", 1542 {"$type": "dict",
1543 "additional-keys": False}, 1543 "additional-keys": False},
1544 skip_keys=[re.compile(r"\Akey\d*\Z")])) 1544 skip_keys=[re.compile(r"\Akey\d*\Z")]))
1545 self.assertEqual(0, len(x)) 1545 self.assertEqual(0, len(x))
1546 1546
1547 def test_d5_4(self): 1547 def test_d5_4(self):
1548 x = list(data_schema.validate( 1548 x = list(data_schema.validate(
1549 {"key": "value", 1549 {"key": "value",
1550 "key2": "value"}, 1550 "key2": "value"},
1551 {"type": "dict", 1551 {"$type": "dict",
1552 "additional-keys": False}, 1552 "additional-keys": False},
1553 skip_keys=[re.compile(r"\A__.+"), re.compile(r"\Akey\d+\Z")])) 1553 skip_keys=[re.compile(r"\A__.+"), re.compile(r"\Akey\d+\Z")]))
1554 self.assertEqual(1, len(x)) 1554 self.assertEqual(1, len(x))
1555 self.assertEqual(ERRORS.E10004, x[0].code) 1555 self.assertEqual(ERRORS.E10004, x[0].code)
1556 self.assertEqual("key", x[0].hint) 1556 self.assertEqual("key", x[0].hint)
1557 1557
1558 def test_d6(self): 1558 def test_d6(self):
1559 x = list(data_schema.validate( 1559 x = list(data_schema.validate(
1560 {"key": "value"}, 1560 {"key": "value"},
1561 {"type": "dict", 1561 {"$type": "dict",
1562 "additional-keys": True})) 1562 "additional-keys": True}))
1563 self.assertEqual(0, len(x)) 1563 self.assertEqual(0, len(x))
1564 1564
1565 def test_d7(self): 1565 def test_d7(self):
1566 x = list(data_schema.validate( 1566 x = list(data_schema.validate(
1567 {"key": "value"}, 1567 {"key": "value"},
1568 {"type": "dict", 1568 {"$type": "dict",
1569 "additional-keys": { 1569 "additional-keys": {
1570 "type": "string"}})) 1570 "$type": "string"}}))
1571 self.assertEqual(0, len(x)) 1571 self.assertEqual(0, len(x))
1572 1572
1573 def test_d8(self): 1573 def test_d8(self):
1574 x = list(data_schema.validate( 1574 x = list(data_schema.validate(
1575 {"key": 1234}, 1575 {"key": 1234},
1576 {"type": "dict", 1576 {"$type": "dict",
1577 "additional-keys": { 1577 "additional-keys": {
1578 "type": "string"}})) 1578 "$type": "string"}}))
1579 self.assertEqual(1, len(x)) 1579 self.assertEqual(1, len(x))
1580 self.assertEqual(ERRORS.E10002, x[0].code) 1580 self.assertEqual(ERRORS.E10002, x[0].code)
1581 self.assertEqual(1234, x[0].hint) 1581 self.assertEqual(1234, x[0].hint)
1582 1582
1583 def test_d8_2(self): 1583 def test_d8_2(self):
1584 x = list(data_schema.validate( 1584 x = list(data_schema.validate(
1585 {"key": 1234}, 1585 {"key": 1234},
1586 {"type": "dict", 1586 {"$type": "dict",
1587 "additional-keys": { 1587 "additional-keys": {
1588 "type": "string"}}, 1588 "$type": "string"}},
1589 skip_keys=["key"])) 1589 skip_keys=["key"]))
1590 self.assertEqual(0, len(x)) 1590 self.assertEqual(0, len(x))
1591 1591
1592 def test_d9_non_string_keys(self): 1592 def test_d9_non_string_keys(self):
1593 pr = list(data_schema.validate( 1593 pr = list(data_schema.validate(
1594 {0: "value"}, 1594 {0: "value"},
1595 {"type": "dict", 1595 {"$type": "dict",
1596 "additional-keys": True})) 1596 "additional-keys": True}))
1597 self.assertEqual(1, len(pr)) 1597 self.assertEqual(1, len(pr))
1598 self.assertEqual(ERRORS.E10003, pr[0].code) 1598 self.assertEqual(ERRORS.E10003, pr[0].code)
1599 1599
1600 def test_d10_int_dict_keys(self): 1600 def test_d10_int_dict_keys(self):
1601 pr = list(data_schema.validate( 1601 pr = list(data_schema.validate(
1602 {1: "value", 2: "value2"}, 1602 {1: "value", 2: "value2"},
1603 {"type": "dict", 1603 {"$type": "dict",
1604 "keys": { 1604 "keys": {
1605 1: {"type": "string"}}, 1605 1: {"$type": "string"}},
1606 "additional-keys": True, 1606 "additional-keys": True,
1607 "key-names": {"type": "int"}})) 1607 "key-names": {"$type": "int"}}))
1608 self.assertEqual(0, len(pr)) 1608 self.assertEqual(0, len(pr))
1609 1609
1610 def test_error_message(self): 1610 def test_error_message(self):
1611 self.assertEqual("dict expected", 1611 self.assertEqual("dict expected",
1612 data_schema.problem_message(ERRORS.E10000)) 1612 data_schema.problem_message(ERRORS.E10000))
1622 self.assertRaises(KeyError, data_schema.problem_message, 12345) 1622 self.assertRaises(KeyError, data_schema.problem_message, 12345)
1623 1623
1624 def test_str_enum(self): 1624 def test_str_enum(self):
1625 pr = list(data_schema.validate( 1625 pr = list(data_schema.validate(
1626 "e1", 1626 "e1",
1627 {"type": "string", 1627 {"$type": "string",
1628 "enum": ["e1", "e2"]})) 1628 "enum": ["e1", "e2"]}))
1629 self.assertEqual(0, len(pr)) 1629 self.assertEqual(0, len(pr))
1630 1630
1631 pr = list(data_schema.validate( 1631 pr = list(data_schema.validate(
1632 "e2", 1632 "e2",
1633 {"type": "string", 1633 {"$type": "string",
1634 "enum": ["e1", "e2"]})) 1634 "enum": ["e1", "e2"]}))
1635 self.assertEqual(0, len(pr)) 1635 self.assertEqual(0, len(pr))
1636 1636
1637 def test_str_not_in_enum(self): 1637 def test_str_not_in_enum(self):
1638 pr = list(data_schema.validate( 1638 pr = list(data_schema.validate(
1639 "e3", 1639 "e3",
1640 {"type": "string", 1640 {"$type": "string",
1641 "enum": ["e1", "e2"]})) 1641 "enum": ["e1", "e2"]}))
1642 self.assertEqual(1, len(pr)) 1642 self.assertEqual(1, len(pr))
1643 self.assertEqual(ERRORS.E10043, pr[0].code) 1643 self.assertEqual(ERRORS.E10043, pr[0].code)
1644 1644
1645 def test_str_minlen(self): 1645 def test_str_minlen(self):
1646 pr = list(data_schema.validate( 1646 pr = list(data_schema.validate(
1647 "", 1647 "",
1648 {"type": "string", 1648 {"$type": "string",
1649 "min-length": 0})) 1649 "min-length": 0}))
1650 self.assertEqual(0, len(pr)) 1650 self.assertEqual(0, len(pr))
1651 1651
1652 pr = list(data_schema.validate( 1652 pr = list(data_schema.validate(
1653 "", 1653 "",
1654 {"type": "string", 1654 {"$type": "string",
1655 "min-length": 1})) 1655 "min-length": 1}))
1656 self.assertEqual(1, len(pr)) 1656 self.assertEqual(1, len(pr))
1657 self.assertEqual(ERRORS.E10006, pr[0].code) 1657 self.assertEqual(ERRORS.E10006, pr[0].code)
1658 1658
1659 pr = list(data_schema.validate( 1659 pr = list(data_schema.validate(
1660 "x", 1660 "x",
1661 {"type": "string", 1661 {"$type": "string",
1662 "min-length": 1})) 1662 "min-length": 1}))
1663 self.assertEqual(0, len(pr)) 1663 self.assertEqual(0, len(pr))
1664 1664
1665 def test_str_maxlen(self): 1665 def test_str_maxlen(self):
1666 pr = list(data_schema.validate( 1666 pr = list(data_schema.validate(
1667 "", 1667 "",
1668 {"type": "string", 1668 {"$type": "string",
1669 "max-length": 0})) 1669 "max-length": 0}))
1670 self.assertEqual(0, len(pr)) 1670 self.assertEqual(0, len(pr))
1671 1671
1672 pr = list(data_schema.validate( 1672 pr = list(data_schema.validate(
1673 "x", 1673 "x",
1674 {"type": "string", 1674 {"$type": "string",
1675 "max-length": 0})) 1675 "max-length": 0}))
1676 self.assertEqual(1, len(pr)) 1676 self.assertEqual(1, len(pr))
1677 self.assertEqual(ERRORS.E10007, pr[0].code) 1677 self.assertEqual(ERRORS.E10007, pr[0].code)
1678 1678
1679 pr = list(data_schema.validate( 1679 pr = list(data_schema.validate(
1680 "x", 1680 "x",
1681 {"type": "string", 1681 {"$type": "string",
1682 "max-length": 1})) 1682 "max-length": 1}))
1683 self.assertEqual(0, len(pr)) 1683 self.assertEqual(0, len(pr))
1684 1684
1685 pr = list(data_schema.validate( 1685 pr = list(data_schema.validate(
1686 b"x", 1686 b"x",
1687 {"type": "string", 1687 {"$type": "string",
1688 "max-length": 1})) 1688 "max-length": 1}))
1689 self.assertEqual(1, len(pr)) 1689 self.assertEqual(1, len(pr))
1690 self.assertEqual(ERRORS.E10002, pr[0].code) 1690 self.assertEqual(ERRORS.E10002, pr[0].code)
1691 1691
1692 @staticmethod 1692 @staticmethod
1695 yield data_schema.ValidationProblem(code=ERRORS.E10009) 1695 yield data_schema.ValidationProblem(code=ERRORS.E10009)
1696 1696
1697 def test_str_re(self): 1697 def test_str_re(self):
1698 pr = list(data_schema.validate( 1698 pr = list(data_schema.validate(
1699 "abc", 1699 "abc",
1700 {"type": "string", 1700 {"$type": "string",
1701 "pattern": r'\A[0-9]+\Z'})) 1701 "pattern": r'\A[0-9]+\Z'}))
1702 self.assertEqual(1, len(pr)) 1702 self.assertEqual(1, len(pr))
1703 self.assertEqual(ERRORS.E10008, pr[0].code) 1703 self.assertEqual(ERRORS.E10008, pr[0].code)
1704 1704
1705 pr = list(data_schema.validate( 1705 pr = list(data_schema.validate(
1706 "123", 1706 "123",
1707 {"type": "string", 1707 {"$type": "string",
1708 "pattern": re.compile(r'\A[a-z]+\Z')})) 1708 "pattern": re.compile(r'\A[a-z]+\Z')}))
1709 self.assertEqual(1, len(pr)) 1709 self.assertEqual(1, len(pr))
1710 self.assertEqual(ERRORS.E10008, pr[0].code) 1710 self.assertEqual(ERRORS.E10008, pr[0].code)
1711 1711
1712 pr = list(data_schema.validate( 1712 pr = list(data_schema.validate(
1713 "123", 1713 "123",
1714 {"type": "string", 1714 {"$type": "string",
1715 "pattern": self._pattern_check_function})) 1715 "pattern": self._pattern_check_function}))
1716 self.assertEqual(0, len(pr)) 1716 self.assertEqual(0, len(pr))
1717 1717
1718 pr = list(data_schema.validate( 1718 pr = list(data_schema.validate(
1719 " 5 ", 1719 " 5 ",
1720 {"type": "string", 1720 {"$type": "string",
1721 "pattern": self._pattern_check_function})) 1721 "pattern": self._pattern_check_function}))
1722 self.assertEqual(1, len(pr)) 1722 self.assertEqual(1, len(pr))
1723 self.assertEqual(ERRORS.E10009, pr[0].code) 1723 self.assertEqual(ERRORS.E10009, pr[0].code)
1724 1724
1725 def test_binary_basic(self): 1725 def test_binary_basic(self):
1726 pr = list(data_schema.validate( 1726 pr = list(data_schema.validate(
1727 b"", 1727 b"",
1728 {"type": "binary"})) 1728 {"$type": "binary"}))
1729 self.assertEqual(0, len(pr)) 1729 self.assertEqual(0, len(pr))
1730 1730
1731 def test_str_is_not_binary(self): 1731 def test_str_is_not_binary(self):
1732 pr = list(data_schema.validate( 1732 pr = list(data_schema.validate(
1733 "", 1733 "",
1734 {"type": "binary"})) 1734 {"$type": "binary"}))
1735 self.assertEqual(1, len(pr)) 1735 self.assertEqual(1, len(pr))
1736 self.assertEqual(ERRORS.E10035, pr[0].code) 1736 self.assertEqual(ERRORS.E10035, pr[0].code)
1737 1737
1738 @staticmethod 1738 @staticmethod
1739 def _binary_pattern_check_function(obj, schema, context=None): 1739 def _binary_pattern_check_function(obj, schema, context=None):
1741 yield data_schema.ValidationProblem(code=ERRORS.E10009) 1741 yield data_schema.ValidationProblem(code=ERRORS.E10009)
1742 1742
1743 def test_binary_pattern_check(self): 1743 def test_binary_pattern_check(self):
1744 pr = list(data_schema.validate( 1744 pr = list(data_schema.validate(
1745 b"\x00", 1745 b"\x00",
1746 {"type": "binary", 1746 {"$type": "binary",
1747 "pattern": self._binary_pattern_check_function})) 1747 "pattern": self._binary_pattern_check_function}))
1748 self.assertEqual(0, len(pr)) 1748 self.assertEqual(0, len(pr))
1749 1749
1750 pr = list(data_schema.validate( 1750 pr = list(data_schema.validate(
1751 b"\x01", 1751 b"\x01",
1752 {"type": "binary", 1752 {"$type": "binary",
1753 "pattern": self._binary_pattern_check_function})) 1753 "pattern": self._binary_pattern_check_function}))
1754 self.assertEqual(1, len(pr)) 1754 self.assertEqual(1, len(pr))
1755 self.assertEqual(ERRORS.E10009, pr[0].code) 1755 self.assertEqual(ERRORS.E10009, pr[0].code)
1756 1756
1757 def test_binary_re_str_match(self): 1757 def test_binary_re_str_match(self):
1758 pr = list(data_schema.validate( 1758 pr = list(data_schema.validate(
1759 b"\x00\x00\x00", 1759 b"\x00\x00\x00",
1760 {"type": "binary", 1760 {"$type": "binary",
1761 "pattern": u"\\x00+"})) 1761 "pattern": u"\\x00+"}))
1762 self.assertEqual(0, len(pr)) 1762 self.assertEqual(0, len(pr))
1763 1763
1764 def test_binary_re_bytes_match(self): 1764 def test_binary_re_bytes_match(self):
1765 pr = list(data_schema.validate( 1765 pr = list(data_schema.validate(
1766 b"\x00\x00\x00", 1766 b"\x00\x00\x00",
1767 {"type": "binary", 1767 {"$type": "binary",
1768 "pattern": b"\x00+"})) 1768 "pattern": b"\x00+"}))
1769 self.assertEqual(0, len(pr)) 1769 self.assertEqual(0, len(pr))
1770 1770
1771 def test_binary_re_str_mismatch(self): 1771 def test_binary_re_str_mismatch(self):
1772 pr = list(data_schema.validate( 1772 pr = list(data_schema.validate(
1773 b"\x00\x00\x00", 1773 b"\x00\x00\x00",
1774 {"type": "binary", 1774 {"$type": "binary",
1775 "pattern": u"\\x01+"})) 1775 "pattern": u"\\x01+"}))
1776 self.assertEqual(1, len(pr)) 1776 self.assertEqual(1, len(pr))
1777 self.assertEqual(ERRORS.E10047, pr[0].code) 1777 self.assertEqual(ERRORS.E10047, pr[0].code)
1778 1778
1779 def test_binary_re_bytes_mismatch(self): 1779 def test_binary_re_bytes_mismatch(self):
1780 pr = list(data_schema.validate( 1780 pr = list(data_schema.validate(
1781 b"\x00\x00\x00", 1781 b"\x00\x00\x00",
1782 {"type": "binary", 1782 {"$type": "binary",
1783 "pattern": b"\x01+"})) 1783 "pattern": b"\x01+"}))
1784 self.assertEqual(1, len(pr)) 1784 self.assertEqual(1, len(pr))
1785 self.assertEqual(ERRORS.E10047, pr[0].code) 1785 self.assertEqual(ERRORS.E10047, pr[0].code)
1786 1786
1787 def test_binary_length(self): 1787 def test_binary_length(self):
1788 pr = list(data_schema.validate( 1788 pr = list(data_schema.validate(
1789 b"", 1789 b"",
1790 {"type": "binary", 1790 {"$type": "binary",
1791 "min-length": 1})) 1791 "min-length": 1}))
1792 self.assertEqual(1, len(pr)) 1792 self.assertEqual(1, len(pr))
1793 self.assertEqual(ERRORS.E10036, pr[0].code) 1793 self.assertEqual(ERRORS.E10036, pr[0].code)
1794 1794
1795 pr = list(data_schema.validate( 1795 pr = list(data_schema.validate(
1796 b"1", 1796 b"1",
1797 {"type": "binary", 1797 {"$type": "binary",
1798 "max-length": 0})) 1798 "max-length": 0}))
1799 self.assertEqual(1, len(pr)) 1799 self.assertEqual(1, len(pr))
1800 self.assertEqual(ERRORS.E10037, pr[0].code) 1800 self.assertEqual(ERRORS.E10037, pr[0].code)
1801 1801
1802 def test_deny(self): 1802 def test_deny(self):
1803 pr = list(data_schema.validate("abc", {"type": "deny"})) 1803 pr = list(data_schema.validate("abc", {"$type": "deny"}))
1804 self.assertEqual(1, len(pr)) 1804 self.assertEqual(1, len(pr))
1805 self.assertEqual(ERRORS.E10010, pr[0].code) 1805 self.assertEqual(ERRORS.E10010, pr[0].code)
1806 1806
1807 def test_accept(self): 1807 def test_accept(self):
1808 pr = list(data_schema.validate("abc", {"type": "accept"})) 1808 pr = list(data_schema.validate("abc", {"$type": "accept"}))
1809 self.assertEqual(0, len(pr)) 1809 self.assertEqual(0, len(pr))
1810 1810
1811 pr = list(data_schema.validate(None, {"type": "accept"})) 1811 pr = list(data_schema.validate(None, {"$type": "accept"}))
1812 self.assertEqual(0, len(pr)) 1812 self.assertEqual(0, len(pr))
1813 1813
1814 def test_null(self): 1814 def test_null(self):
1815 pr = list(data_schema.validate(None, {"type": "none"})) 1815 pr = list(data_schema.validate(None, {"$type": "none"}))
1816 self.assertEqual(0, len(pr)) 1816 self.assertEqual(0, len(pr))
1817 1817
1818 pr = list(data_schema.validate(None, {"type": "null"})) 1818 pr = list(data_schema.validate(None, {"$type": "null"}))
1819 self.assertEqual(0, len(pr)) 1819 self.assertEqual(0, len(pr))
1820 1820
1821 pr = list(data_schema.validate(None, {"type": "nil"})) 1821 pr = list(data_schema.validate(None, {"$type": "nil"}))
1822 self.assertEqual(0, len(pr)) 1822 self.assertEqual(0, len(pr))
1823 1823
1824 pr = list(data_schema.validate(None, {"type": None})) 1824 pr = list(data_schema.validate(None, {"$type": None}))
1825 self.assertEqual(0, len(pr)) 1825 self.assertEqual(0, len(pr))
1826 1826
1827 pr = list(data_schema.validate({}, {"type": None})) 1827 pr = list(data_schema.validate({}, {"$type": None}))
1828 self.assertEqual(1, len(pr)) 1828 self.assertEqual(1, len(pr))
1829 self.assertEqual(ERRORS.E10011, pr[0].code) 1829 self.assertEqual(ERRORS.E10011, pr[0].code)
1830 1830
1831 def test_l1(self): 1831 def test_l1(self):
1832 pr = list(data_schema.validate([], {"type": "list"})) 1832 pr = list(data_schema.validate([], {"$type": "list"}))
1833 self.assertEqual(0, len(pr)) 1833 self.assertEqual(0, len(pr))
1834 1834
1835 pr = list(data_schema.validate(tuple(), {"type": "list"})) 1835 pr = list(data_schema.validate(tuple(), {"$type": "list"}))
1836 self.assertEqual(0, len(pr)) 1836 self.assertEqual(0, len(pr))
1837 1837
1838 def test_l1_not_nullable(self): 1838 def test_l1_not_nullable(self):
1839 pr = list(data_schema.validate(None, {"type": "list"})) 1839 pr = list(data_schema.validate(None, {"$type": "list"}))
1840 self.assertEqual(1, len(pr)) 1840 self.assertEqual(1, len(pr))
1841 self.assertEqual(ERRORS.E10001, pr[0].code) 1841 self.assertEqual(ERRORS.E10001, pr[0].code)
1842 1842
1843 def test_l1_nullable(self): 1843 def test_l1_nullable(self):
1844 pr = list(data_schema.validate( 1844 pr = list(data_schema.validate(
1845 None, {"type": "list", "nullable": True})) 1845 None, {"$type": "list", "nullable": True}))
1846 self.assertEqual(0, len(pr)) 1846 self.assertEqual(0, len(pr))
1847 1847
1848 def test_l2_default_schema_for_items_is_deny(self): 1848 def test_l2_default_schema_for_items_is_deny(self):
1849 pr = list(data_schema.validate(["a", "b", "c"], {"type": "list"})) 1849 pr = list(data_schema.validate(["a", "b", "c"], {"$type": "list"}))
1850 self.assertEqual(3, len(pr)) 1850 self.assertEqual(3, len(pr))
1851 for i in range(0, 3): 1851 for i in range(0, 3):
1852 self.assertEqual(ERRORS.E10010, pr[i].code) 1852 self.assertEqual(ERRORS.E10010, pr[i].code)
1853 1853
1854 def test_l3_schema_for_items(self): 1854 def test_l3_schema_for_items(self):
1855 pr = list(data_schema.validate( 1855 pr = list(data_schema.validate(
1856 ["a", "b", "c"], 1856 ["a", "b", "c"],
1857 {"type": "array", 1857 {"$type": "array",
1858 "items": {"type": "string"}})) 1858 "items": {"$type": "string"}}))
1859 self.assertEqual(0, len(pr)) 1859 self.assertEqual(0, len(pr))
1860 1860
1861 def test_t1(self): 1861 def test_t1(self):
1862 pr = list(data_schema.validate([], {"type": "tuple"})) 1862 pr = list(data_schema.validate([], {"$type": "tuple"}))
1863 self.assertEqual(0, len(pr)) 1863 self.assertEqual(0, len(pr))
1864 1864
1865 pr = list(data_schema.validate(tuple(), {"type": "tuple"})) 1865 pr = list(data_schema.validate(tuple(), {"$type": "tuple"}))
1866 self.assertEqual(0, len(pr)) 1866 self.assertEqual(0, len(pr))
1867 1867
1868 def test_t1_not_nullable(self): 1868 def test_t1_not_nullable(self):
1869 pr = list(data_schema.validate(None, {"type": "tuple"})) 1869 pr = list(data_schema.validate(None, {"$type": "tuple"}))
1870 self.assertEqual(1, len(pr)) 1870 self.assertEqual(1, len(pr))
1871 self.assertEqual(ERRORS.E10014, pr[0].code) 1871 self.assertEqual(ERRORS.E10014, pr[0].code)
1872 1872
1873 def test_t1_nullable(self): 1873 def test_t1_nullable(self):
1874 pr = list(data_schema.validate( 1874 pr = list(data_schema.validate(
1875 None, {"type": "tuple", "nullable": True})) 1875 None, {"$type": "tuple", "nullable": True}))
1876 self.assertEqual(0, len(pr)) 1876 self.assertEqual(0, len(pr))
1877 1877
1878 def test_t2(self): 1878 def test_t2(self):
1879 pr = list(data_schema.validate( 1879 pr = list(data_schema.validate(
1880 ["a", None, {"key": "value"}], 1880 ["a", None, {"key": "value"}],
1881 {"type": "tuple", 1881 {"$type": "tuple",
1882 "items": [ 1882 "items": [
1883 {"type": "string"}, 1883 {"$type": "string"},
1884 {"type": None}, 1884 {"$type": None},
1885 {"type": "accept"}]})) 1885 {"$type": "accept"}]}))
1886 self.assertEqual(0, len(pr)) 1886 self.assertEqual(0, len(pr))
1887 1887
1888 def test_t3(self): 1888 def test_t3(self):
1889 pr = list(data_schema.validate( 1889 pr = list(data_schema.validate(
1890 ["a", None, {"key": "value"}], 1890 ["a", None, {"key": "value"}],
1891 {"type": "tuple", 1891 {"$type": "tuple",
1892 "items": [ 1892 "items": [
1893 {"type": "string"}, 1893 {"$type": "string"},
1894 {"type": None}, 1894 {"$type": None},
1895 {"type": "deny"}]})) 1895 {"$type": "deny"}]}))
1896 self.assertEqual(1, len(pr)) 1896 self.assertEqual(1, len(pr))
1897 self.assertEqual(ERRORS.E10010, pr[0].code) 1897 self.assertEqual(ERRORS.E10010, pr[0].code)
1898 self.assertEqual(2, pr[0].context.index) 1898 self.assertEqual(2, pr[0].context.index)
1899 1899
1900 def test_t4(self): 1900 def test_t4(self):
1901 pr = list(data_schema.validate( 1901 pr = list(data_schema.validate(
1902 ["a", None, {"key": "value"}], 1902 ["a", None, {"key": "value"}],
1903 {"type": "tuple", 1903 {"$type": "tuple",
1904 "items": [ 1904 "items": [
1905 {"type": "string"}, 1905 {"$type": "string"},
1906 {"type": None}]})) 1906 {"$type": None}]}))
1907 self.assertEqual(1, len(pr)) 1907 self.assertEqual(1, len(pr))
1908 self.assertEqual(ERRORS.E10017, pr[0].code) 1908 self.assertEqual(ERRORS.E10017, pr[0].code)
1909 self.assertEqual(2, pr[0].context.index) 1909 self.assertEqual(2, pr[0].context.index)
1910 1910
1911 def test_t5(self): 1911 def test_t5(self):
1912 pr = list(data_schema.validate( 1912 pr = list(data_schema.validate(
1913 ["a", None, {"key": "value"}], 1913 ["a", None, {"key": "value"}],
1914 {"type": "tuple", 1914 {"$type": "tuple",
1915 "items": [ 1915 "items": [
1916 {"type": "string"}, 1916 {"$type": "string"},
1917 {"type": None}], 1917 {"$type": None}],
1918 "additional-items": True})) 1918 "additional-items": True}))
1919 self.assertEqual(0, len(pr)) 1919 self.assertEqual(0, len(pr))
1920 1920
1921 def test_t6(self): 1921 def test_t6(self):
1922 pr = list(data_schema.validate( 1922 pr = list(data_schema.validate(
1923 ["a", None, {"key": "value"}, {"key": "value"}], 1923 ["a", None, {"key": "value"}, {"key": "value"}],
1924 {"type": "tuple", 1924 {"$type": "tuple",
1925 "items": [ 1925 "items": [
1926 {"type": "string"}, 1926 {"$type": "string"},
1927 {"type": None}], 1927 {"$type": None}],
1928 "additional-items": { 1928 "additional-items": {
1929 "type": "dict", 1929 "$type": "dict",
1930 "keys": {"key": {"type": "string"}} 1930 "keys": {"key": {"$type": "string"}}
1931 }})) 1931 }}))
1932 self.assertEqual(0, len(pr)) 1932 self.assertEqual(0, len(pr))
1933 1933
1934 def test_t7(self): 1934 def test_t7(self):
1935 # do not check anything that exceeds max-length 1935 # do not check anything that exceeds max-length
1936 pr = list(data_schema.validate( 1936 pr = list(data_schema.validate(
1937 ["a", None, {"key": "value"}, {"key": "value"}, {"key2": "value"}], 1937 ["a", None, {"key": "value"}, {"key": "value"}, {"key2": "value"}],
1938 {"type": "tuple", 1938 {"$type": "tuple",
1939 "max-length": 4, 1939 "max-length": 4,
1940 "items": [ 1940 "items": [
1941 {"type": "string"}, 1941 {"$type": "string"},
1942 {"type": None}], 1942 {"$type": None}],
1943 "additional-items": { 1943 "additional-items": {
1944 "type": "dict", 1944 "$type": "dict",
1945 "keys": {"key": {"type": "string"}} 1945 "keys": {"key": {"$type": "string"}}
1946 }})) 1946 }}))
1947 self.assertEqual(1, len(pr)) 1947 self.assertEqual(1, len(pr))
1948 self.assertEqual(ERRORS.E10016, pr[0].code) 1948 self.assertEqual(ERRORS.E10016, pr[0].code)
1949 1949
1950 def test_t8(self): 1950 def test_t8(self):
1951 # do not check anything that exceeds max-length 1951 # do not check anything that exceeds max-length
1952 pr = list(data_schema.validate( 1952 pr = list(data_schema.validate(
1953 ["a", None, {"key": "value"}, {"key": "value"}, {"key2": "value"}], 1953 ["a", None, {"key": "value"}, {"key": "value"}, {"key2": "value"}],
1954 {"type": "tuple", 1954 {"$type": "tuple",
1955 "min-length": 6, 1955 "min-length": 6,
1956 "max-length": 4, 1956 "max-length": 4,
1957 "items": [ 1957 "items": [
1958 {"type": "string"}, 1958 {"$type": "string"},
1959 {"type": None}], 1959 {"$type": None}],
1960 "additional-items": { 1960 "additional-items": {
1961 "type": "dict", 1961 "$type": "dict",
1962 "keys": {"key": {"type": "string"}} 1962 "keys": {"key": {"$type": "string"}}
1963 }})) 1963 }}))
1964 self.assertEqual(2, len(pr)) 1964 self.assertEqual(2, len(pr))
1965 self.assertEqual(ERRORS.E10015, pr[0].code) 1965 self.assertEqual(ERRORS.E10015, pr[0].code)
1966 self.assertEqual(ERRORS.E10016, pr[1].code) 1966 self.assertEqual(ERRORS.E10016, pr[1].code)
1967 1967
1968 def test_set1(self): 1968 def test_set1(self):
1969 # do not check anything that exceeds max-length 1969 # do not check anything that exceeds max-length
1970 pr = list(data_schema.validate( 1970 pr = list(data_schema.validate(
1971 set(["a", None, "b"]), 1971 set(["a", None, "b"]),
1972 {"type": "set", 1972 {"$type": "set",
1973 "min-length": 3, 1973 "min-length": 3,
1974 "items": {"any-of": [ 1974 "items": {"any-of": [
1975 {"type": "string"}, 1975 {"$type": "string"},
1976 {"type": None}]}} 1976 {"$type": None}]}}
1977 )) 1977 ))
1978 self.assertEqual(0, len(pr)) 1978 self.assertEqual(0, len(pr))
1979 1979
1980 def test_set1_not_nullable(self): 1980 def test_set1_not_nullable(self):
1981 # do not check anything that exceeds max-length 1981 # do not check anything that exceeds max-length
1982 pr = list(data_schema.validate( 1982 pr = list(data_schema.validate(
1983 None, 1983 None,
1984 {"type": "set"})) 1984 {"$type": "set"}))
1985 self.assertEqual(1, len(pr)) 1985 self.assertEqual(1, len(pr))
1986 self.assertEqual(ERRORS.E10038, pr[0].code) 1986 self.assertEqual(ERRORS.E10038, pr[0].code)
1987 1987
1988 def test_set1_nullable(self): 1988 def test_set1_nullable(self):
1989 # do not check anything that exceeds max-length 1989 # do not check anything that exceeds max-length
1990 pr = list(data_schema.validate( 1990 pr = list(data_schema.validate(
1991 None, 1991 None,
1992 {"type": "set", "nullable": True})) 1992 {"$type": "set", "nullable": True}))
1993 self.assertEqual(0, len(pr)) 1993 self.assertEqual(0, len(pr))
1994 1994
1995 def test_set2(self): 1995 def test_set2(self):
1996 # do not check anything that exceeds max-length 1996 # do not check anything that exceeds max-length
1997 pr = list(data_schema.validate( 1997 pr = list(data_schema.validate(
1998 set(["a", None, "b"]), 1998 set(["a", None, "b"]),
1999 {"type": "set", 1999 {"$type": "set",
2000 "min-length": 4, 2000 "min-length": 4,
2001 "items": {"any-of": [ 2001 "items": {"any-of": [
2002 {"type": "string"}, 2002 {"$type": "string"},
2003 {"type": None}]}} 2003 {"$type": None}]}}
2004 )) 2004 ))
2005 self.assertEqual(1, len(pr)) 2005 self.assertEqual(1, len(pr))
2006 self.assertEqual(ERRORS.E10039, pr[0].code) 2006 self.assertEqual(ERRORS.E10039, pr[0].code)
2007 2007
2008 def test_set3(self): 2008 def test_set3(self):
2009 # do not check anything that exceeds max-length 2009 # do not check anything that exceeds max-length
2010 pr = list(data_schema.validate( 2010 pr = list(data_schema.validate(
2011 set(["a", None, "b"]), 2011 set(["a", None, "b"]),
2012 {"type": "set", 2012 {"$type": "set",
2013 "max-length": 2, 2013 "max-length": 2,
2014 "items": {"any-of": [ 2014 "items": {"any-of": [
2015 {"type": "string"}, 2015 {"$type": "string"},
2016 {"type": None}]}} 2016 {"$type": None}]}}
2017 )) 2017 ))
2018 self.assertEqual(1, len(pr)) 2018 self.assertEqual(1, len(pr))
2019 self.assertEqual(ERRORS.E10040, pr[0].code) 2019 self.assertEqual(ERRORS.E10040, pr[0].code)
2020 2020
2021 def test_set4_itemschema(self): 2021 def test_set4_itemschema(self):
2022 pr = list(data_schema.validate( 2022 pr = list(data_schema.validate(
2023 set(["a", None, "b"]), 2023 set(["a", None, "b"]),
2024 {"type": "set", 2024 {"$type": "set",
2025 "items": {"any-of": [ 2025 "items": {"any-of": [
2026 {"type": "string"}, 2026 {"$type": "string"},
2027 {"type": "int"}]}} 2027 {"$type": "int"}]}}
2028 )) 2028 ))
2029 codes = set([p.code for p in pr]) 2029 codes = set([p.code for p in pr])
2030 2030
2031 self.assertEqual(1, len(pr)) 2031 self.assertEqual(1, len(pr))
2032 self.assertEqual(ERRORS.E10055, pr[0].code) 2032 self.assertEqual(ERRORS.E10055, pr[0].code)
2037 self.assertEqual(ERRORS.E10056, pr[0].cause[1].code) 2037 self.assertEqual(ERRORS.E10056, pr[0].cause[1].code)
2038 self.assertEqual(1, len(pr[0].cause[1].cause)) 2038 self.assertEqual(1, len(pr[0].cause[1].cause))
2039 self.assertEqual(ERRORS.E10020, pr[0].cause[1].cause[0].code) 2039 self.assertEqual(ERRORS.E10020, pr[0].cause[1].cause[0].code)
2040 2040
2041 def test_empty(self): 2041 def test_empty(self):
2042 pr = list(data_schema.validate(None, {"type": "empty"})) 2042 pr = list(data_schema.validate(None, {"$type": "empty"}))
2043 self.assertEqual(0, len(pr)) 2043 self.assertEqual(0, len(pr))
2044 2044
2045 pr = list(data_schema.validate([], {"type": "empty"})) 2045 pr = list(data_schema.validate([], {"$type": "empty"}))
2046 self.assertEqual(0, len(pr)) 2046 self.assertEqual(0, len(pr))
2047 2047
2048 pr = list(data_schema.validate(["a"], {"type": "empty"})) 2048 pr = list(data_schema.validate(["a"], {"$type": "empty"}))
2049 self.assertEqual(1, len(pr)) 2049 self.assertEqual(1, len(pr))
2050 self.assertEqual(ERRORS.E10018, pr[0].code) 2050 self.assertEqual(ERRORS.E10018, pr[0].code)
2051 2051
2052 pr = list(data_schema.validate(tuple(), {"type": "empty"})) 2052 pr = list(data_schema.validate(tuple(), {"$type": "empty"}))
2053 self.assertEqual(0, len(pr)) 2053 self.assertEqual(0, len(pr))
2054 2054
2055 pr = list(data_schema.validate(set(), {"type": "empty"})) 2055 pr = list(data_schema.validate(set(), {"$type": "empty"}))
2056 self.assertEqual(0, len(pr)) 2056 self.assertEqual(0, len(pr))
2057 2057
2058 pr = list(data_schema.validate(frozenset(), {"type": "empty"})) 2058 pr = list(data_schema.validate(frozenset(), {"$type": "empty"}))
2059 self.assertEqual(0, len(pr)) 2059 self.assertEqual(0, len(pr))
2060 2060
2061 pr = list(data_schema.validate(tuple(["a"]), {"type": "empty"})) 2061 pr = list(data_schema.validate(tuple(["a"]), {"$type": "empty"}))
2062 self.assertEqual(1, len(pr)) 2062 self.assertEqual(1, len(pr))
2063 self.assertEqual(ERRORS.E10018, pr[0].code) 2063 self.assertEqual(ERRORS.E10018, pr[0].code)
2064 2064
2065 pr = list(data_schema.validate({}, {"type": "empty"})) 2065 pr = list(data_schema.validate({}, {"$type": "empty"}))
2066 self.assertEqual(0, len(pr)) 2066 self.assertEqual(0, len(pr))
2067 2067
2068 pr = list(data_schema.validate({"key": "value"}, {"type": "empty"})) 2068 pr = list(data_schema.validate({"key": "value"}, {"$type": "empty"}))
2069 self.assertEqual(1, len(pr)) 2069 self.assertEqual(1, len(pr))
2070 self.assertEqual(ERRORS.E10018, pr[0].code) 2070 self.assertEqual(ERRORS.E10018, pr[0].code)
2071 2071
2072 pr = list(data_schema.validate("", {"type": "empty"})) 2072 pr = list(data_schema.validate("", {"$type": "empty"}))
2073 self.assertEqual(1, len(pr)) 2073 self.assertEqual(1, len(pr))
2074 self.assertEqual(ERRORS.E10018, pr[0].code) 2074 self.assertEqual(ERRORS.E10018, pr[0].code)
2075 2075
2076 def test_allOf(self): 2076 def test_allOf(self):
2077 pr = list(data_schema.validate( 2077 pr = list(data_schema.validate(
2078 None, 2078 None,
2079 {"type": { 2079 {"$type": {
2080 "all-of": [ 2080 "all-of": [
2081 {"type": None}, 2081 {"$type": None},
2082 {"type": "accept"}, 2082 {"$type": "accept"},
2083 ] 2083 ]
2084 }})) 2084 }}))
2085 self.assertEqual(0, len(pr)) 2085 self.assertEqual(0, len(pr))
2086 2086
2087 pr = list(data_schema.validate( 2087 pr = list(data_schema.validate(
2088 None, 2088 None,
2089 {"type": { 2089 {"$type": {
2090 "all-of": [ 2090 "all-of": [
2091 {"type": None}, 2091 {"$type": None},
2092 {"type": "accept"}, 2092 {"$type": "accept"},
2093 {"type": "deny"}, 2093 {"$type": "deny"},
2094 ] 2094 ]
2095 }})) 2095 }}))
2096 self.assertEqual(1, len(pr)) 2096 self.assertEqual(1, len(pr))
2097 self.assertEqual(ERRORS.E10057, pr[0].code) 2097 self.assertEqual(ERRORS.E10057, pr[0].code)
2098 self.assertEqual(1, len(pr[0].cause)) 2098 self.assertEqual(1, len(pr[0].cause))
2101 self.assertEqual(ERRORS.E10010, pr[0].cause[0].cause[0].code) 2101 self.assertEqual(ERRORS.E10010, pr[0].cause[0].cause[0].code)
2102 2102
2103 def test_anyOf(self): 2103 def test_anyOf(self):
2104 pr = list(data_schema.validate( 2104 pr = list(data_schema.validate(
2105 None, 2105 None,
2106 {"type": { 2106 {"$type": {
2107 "any-of": [ 2107 "any-of": [
2108 {"type": "deny"}, 2108 {"$type": "deny"},
2109 {"type": None}, 2109 {"$type": None},
2110 ] 2110 ]
2111 }})) 2111 }}))
2112 self.assertEqual(0, len(pr)) 2112 self.assertEqual(0, len(pr))
2113 2113
2114 pr = list(data_schema.validate( 2114 pr = list(data_schema.validate(
2115 None, 2115 None,
2116 {"type": { 2116 {"$type": {
2117 "any-of": [ 2117 "any-of": [
2118 {"type": "string"}, 2118 {"$type": "string"},
2119 {"type": "deny"}, 2119 {"$type": "deny"},
2120 ] 2120 ]
2121 }})) 2121 }}))
2122 self.assertEqual(1, len(pr)) 2122 self.assertEqual(1, len(pr))
2123 self.assertEqual(ERRORS.E10055, pr[0].code) 2123 self.assertEqual(ERRORS.E10055, pr[0].code)
2124 self.assertEqual(2, len(pr[0].cause)) 2124 self.assertEqual(2, len(pr[0].cause))
2130 self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code) 2130 self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code)
2131 2131
2132 def test_anyOf_with_list(self): 2132 def test_anyOf_with_list(self):
2133 pr = list(data_schema.validate( 2133 pr = list(data_schema.validate(
2134 None, 2134 None,
2135 {"type": [ 2135 {"$type": [
2136 {"type": "deny"}, 2136 {"$type": "deny"},
2137 {"type": None}, 2137 {"$type": None},
2138 ]})) 2138 ]}))
2139 self.assertEqual(0, len(pr)) 2139 self.assertEqual(0, len(pr))
2140 2140
2141 pr = list(data_schema.validate( 2141 pr = list(data_schema.validate(
2142 None, 2142 None,
2143 {"type": [ 2143 {"$type": [
2144 {"type": "string"}, 2144 {"$type": "string"},
2145 {"type": "deny"}, 2145 {"$type": "deny"},
2146 ]})) 2146 ]}))
2147 self.assertEqual(1, len(pr)) 2147 self.assertEqual(1, len(pr))
2148 self.assertEqual(ERRORS.E10055, pr[0].code) 2148 self.assertEqual(ERRORS.E10055, pr[0].code)
2149 self.assertEqual(2, len(pr[0].cause)) 2149 self.assertEqual(2, len(pr[0].cause))
2150 self.assertEqual(ERRORS.E10056, pr[0].cause[0].code) 2150 self.assertEqual(ERRORS.E10056, pr[0].cause[0].code)
2155 self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code) 2155 self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code)
2156 2156
2157 def test_oneOf(self): 2157 def test_oneOf(self):
2158 pr = list(data_schema.validate( 2158 pr = list(data_schema.validate(
2159 None, 2159 None,
2160 {"type": { 2160 {"$type": {
2161 "one-of": [ 2161 "one-of": [
2162 {"type": "deny"}, 2162 {"$type": "deny"},
2163 {"type": None}, 2163 {"$type": None},
2164 ] 2164 ]
2165 }})) 2165 }}))
2166 self.assertEqual(0, len(pr)) 2166 self.assertEqual(0, len(pr))
2167 2167
2168 pr = list(data_schema.validate( 2168 pr = list(data_schema.validate(
2169 None, 2169 None,
2170 {"type": { 2170 {"$type": {
2171 "one-of": [ 2171 "one-of": [
2172 {"type": "string"}, 2172 {"$type": "string"},
2173 {"type": "deny"}, 2173 {"$type": "deny"},
2174 ] 2174 ]
2175 }})) 2175 }}))
2176 2176
2177 self.assertEqual(1, len(pr)) 2177 self.assertEqual(1, len(pr))
2178 self.assertEqual(ERRORS.E10053, pr[0].code) 2178 self.assertEqual(ERRORS.E10053, pr[0].code)
2184 self.assertEqual(1, len(pr[0].cause[1].cause)) 2184 self.assertEqual(1, len(pr[0].cause[1].cause))
2185 self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code) 2185 self.assertEqual(ERRORS.E10010, pr[0].cause[1].cause[0].code)
2186 2186
2187 pr = list(data_schema.validate( 2187 pr = list(data_schema.validate(
2188 None, 2188 None,
2189 {"type": { 2189 {"$type": {
2190 "one-of": [ 2190 "one-of": [
2191 {"type": "string"}, 2191 {"$type": "string"},
2192 {"type": "deny"}, 2192 {"$type": "deny"},
2193 {"type": "empty"}, 2193 {"$type": "empty"},
2194 {"type": None}, 2194 {"$type": None},
2195 ] 2195 ]
2196 }})) 2196 }}))
2197 self.assertEqual(1, len(pr)) 2197 self.assertEqual(1, len(pr))
2198 self.assertEqual(ERRORS.E10019, pr[0].code) 2198 self.assertEqual(ERRORS.E10019, pr[0].code)
2199 self.assertEqual("2,3", pr[0].hint) 2199 self.assertEqual("2,3", pr[0].hint)
2200 2200
2201 def test_not(self): 2201 def test_not(self):
2202 pr = list(data_schema.validate( 2202 pr = list(data_schema.validate(
2203 None, 2203 None,
2204 {"type": { 2204 {"$type": {
2205 "not": { 2205 "not": {
2206 "type": "empty"}}})) 2206 "$type": "empty"}}}))
2207 self.assertEqual(1, len(pr)) 2207 self.assertEqual(1, len(pr))
2208 self.assertEqual(ERRORS.E10029, pr[0].code) 2208 self.assertEqual(ERRORS.E10029, pr[0].code)
2209 2209
2210 pr = list(data_schema.validate( 2210 pr = list(data_schema.validate(
2211 None, 2211 None,
2212 {"type": { 2212 {"$type": {
2213 "not": { 2213 "not": {
2214 "type": { 2214 "$type": {
2215 "not": { 2215 "not": {
2216 "type": "empty"}}}}})) 2216 "$type": "empty"}}}}}))
2217 self.assertEqual(0, len(pr)) 2217 self.assertEqual(0, len(pr))
2218 2218
2219 pr = list(data_schema.validate( 2219 pr = list(data_schema.validate(
2220 2, 2220 2,
2221 {"type": { 2221 {"$type": {
2222 "not": { 2222 "not": {
2223 "type": "int"}}})) 2223 "$type": "int"}}}))
2224 self.assertEqual(1, len(pr)) 2224 self.assertEqual(1, len(pr))
2225 self.assertEqual(ERRORS.E10029, pr[0].code) 2225 self.assertEqual(ERRORS.E10029, pr[0].code)
2226 2226
2227 pr = list(data_schema.validate( 2227 pr = list(data_schema.validate(
2228 1, 2228 1,
2229 {"type": { 2229 {"$type": {
2230 "not": { 2230 "not": {
2231 "type": { 2231 "$type": {
2232 "not": { 2232 "not": {
2233 "type": "int"}}}}})) 2233 "$type": "int"}}}}}))
2234 self.assertEqual(0, len(pr)) 2234 self.assertEqual(0, len(pr))
2235 2235
2236 pr = list(data_schema.validate( 2236 pr = list(data_schema.validate(
2237 2.0, 2237 2.0,
2238 {"type": { 2238 {"$type": {
2239 "not": { 2239 "not": {
2240 "type": "int"}}})) 2240 "$type": "int"}}}))
2241 self.assertEqual(0, len(pr)) 2241 self.assertEqual(0, len(pr))
2242 2242
2243 def test_not_shortcut(self): 2243 def test_not_shortcut(self):
2244 pr = list(data_schema.validate( 2244 pr = list(data_schema.validate(
2245 None, 2245 None,
2246 {"not": { 2246 {"not": {
2247 "type": "empty"}})) 2247 "$type": "empty"}}))
2248 self.assertEqual(1, len(pr)) 2248 self.assertEqual(1, len(pr))
2249 self.assertEqual(ERRORS.E10029, pr[0].code) 2249 self.assertEqual(ERRORS.E10029, pr[0].code)
2250 2250
2251 pr = list(data_schema.validate( 2251 pr = list(data_schema.validate(
2252 None, 2252 None,
2253 {"not": { 2253 {"not": {
2254 "not": { 2254 "not": {
2255 "type": "empty"}}})) 2255 "$type": "empty"}}}))
2256 self.assertEqual(0, len(pr)) 2256 self.assertEqual(0, len(pr))
2257 2257
2258 pr = list(data_schema.validate( 2258 pr = list(data_schema.validate(
2259 2, 2259 2,
2260 {"not": { 2260 {"not": {
2261 "type": "int"}})) 2261 "$type": "int"}}))
2262 self.assertEqual(1, len(pr)) 2262 self.assertEqual(1, len(pr))
2263 self.assertEqual(ERRORS.E10029, pr[0].code) 2263 self.assertEqual(ERRORS.E10029, pr[0].code)
2264 2264
2265 pr = list(data_schema.validate( 2265 pr = list(data_schema.validate(
2266 1, 2266 1,
2267 {"not": { 2267 {"not": {
2268 "not": { 2268 "not": {
2269 "type": "int"}}})) 2269 "$type": "int"}}}))
2270 self.assertEqual(0, len(pr)) 2270 self.assertEqual(0, len(pr))
2271 2271
2272 pr = list(data_schema.validate( 2272 pr = list(data_schema.validate(
2273 2.0, 2273 2.0,
2274 {"not": { 2274 {"not": {
2275 "type": "int"}})) 2275 "$type": "int"}}))
2276 self.assertEqual(0, len(pr)) 2276 self.assertEqual(0, len(pr))
2277 2277
2278 def test_integer(self): 2278 def test_integer(self):
2279 pr = list(data_schema.validate(1, {"type": "integer"})) 2279 pr = list(data_schema.validate(1, {"$type": "integer"}))
2280 self.assertEqual(0, len(pr)) 2280 self.assertEqual(0, len(pr))
2281 2281
2282 pr = list(data_schema.validate(1, {"type": "float"})) 2282 pr = list(data_schema.validate(1, {"$type": "float"}))
2283 self.assertEqual(1, len(pr)) 2283 self.assertEqual(1, len(pr))
2284 self.assertEqual(ERRORS.E10023, pr[0].code) 2284 self.assertEqual(ERRORS.E10023, pr[0].code)
2285 2285
2286 pr = list(data_schema.validate( 2286 pr = list(data_schema.validate(
2287 2, 2287 2,
2288 {"type": "int", 2288 {"$type": "int",
2289 "min-value": 3, 2289 "min-value": 3,
2290 "max-value": 1})) 2290 "max-value": 1}))
2291 2291
2292 self.assertEqual(2, len(pr)) 2292 self.assertEqual(2, len(pr))
2293 self.assertEqual(ERRORS.E10021, pr[0].code) 2293 self.assertEqual(ERRORS.E10021, pr[0].code)
2294 self.assertEqual(ERRORS.E10022, pr[1].code) 2294 self.assertEqual(ERRORS.E10022, pr[1].code)
2295 2295
2296 def test_float(self): 2296 def test_float(self):
2297 pr = list(data_schema.validate(1.8, {"type": "float"})) 2297 pr = list(data_schema.validate(1.8, {"$type": "float"}))
2298 self.assertEqual(0, len(pr)) 2298 self.assertEqual(0, len(pr))
2299 2299
2300 pr = list(data_schema.validate(1, {"type": "float"})) 2300 pr = list(data_schema.validate(1, {"$type": "float"}))
2301 self.assertEqual(1, len(pr)) 2301 self.assertEqual(1, len(pr))
2302 self.assertEqual(ERRORS.E10023, pr[0].code) 2302 self.assertEqual(ERRORS.E10023, pr[0].code)
2303 2303
2304 pr = list(data_schema.validate( 2304 pr = list(data_schema.validate(
2305 2.0, 2305 2.0,
2306 {"type": "real", 2306 {"$type": "real",
2307 "min-value": 2.1, 2307 "min-value": 2.1,
2308 "max-value": 1.9})) 2308 "max-value": 1.9}))
2309 2309
2310 self.assertEqual(2, len(pr)) 2310 self.assertEqual(2, len(pr))
2311 self.assertEqual(ERRORS.E10024, pr[0].code) 2311 self.assertEqual(ERRORS.E10024, pr[0].code)
2312 self.assertEqual(ERRORS.E10025, pr[1].code) 2312 self.assertEqual(ERRORS.E10025, pr[1].code)
2313 2313
2314 def test_number(self): 2314 def test_number(self):
2315 pr = list(data_schema.validate(1.8, {"type": "number"})) 2315 pr = list(data_schema.validate(1.8, {"$type": "number"}))
2316 self.assertEqual(0, len(pr)) 2316 self.assertEqual(0, len(pr))
2317 pr = list(data_schema.validate(1, {"type": "num"})) 2317 pr = list(data_schema.validate(1, {"$type": "num"}))
2318 self.assertEqual(0, len(pr)) 2318 self.assertEqual(0, len(pr))
2319 2319
2320 pr = list(data_schema.validate( 2320 pr = list(data_schema.validate(
2321 2.0, 2321 2.0,
2322 {"type": "number", 2322 {"$type": "number",
2323 "min-value": 3, 2323 "min-value": 3,
2324 "max-value": 1.3})) 2324 "max-value": 1.3}))
2325 2325
2326 self.assertEqual(2, len(pr)) 2326 self.assertEqual(2, len(pr))
2327 self.assertEqual(ERRORS.E10031, pr[0].code) 2327 self.assertEqual(ERRORS.E10031, pr[0].code)
2328 self.assertEqual(ERRORS.E10032, pr[1].code) 2328 self.assertEqual(ERRORS.E10032, pr[1].code)
2329 2329
2330 pr = list(data_schema.validate({}, {"type": "number"})) 2330 pr = list(data_schema.validate({}, {"$type": "number"}))
2331 self.assertEqual(1, len(pr)) 2331 self.assertEqual(1, len(pr))
2332 self.assertEqual(ERRORS.E10030, pr[0].code) 2332 self.assertEqual(ERRORS.E10030, pr[0].code)
2333 2333
2334 def test_bool(self): 2334 def test_bool(self):
2335 pr = list(data_schema.validate(True, {"type": "bool"})) 2335 pr = list(data_schema.validate(True, {"$type": "bool"}))
2336 self.assertEqual(0, len(pr)) 2336 self.assertEqual(0, len(pr))
2337 2337
2338 pr = list(data_schema.validate(True, {"type": "boolean", 2338 pr = list(data_schema.validate(True, {"$type": "boolean",
2339 "value": True})) 2339 "value": True}))
2340 self.assertEqual(0, len(pr)) 2340 self.assertEqual(0, len(pr))
2341 2341
2342 pr = list(data_schema.validate(True, {"type": "boolean", 2342 pr = list(data_schema.validate(True, {"$type": "boolean",
2343 "value": False})) 2343 "value": False}))
2344 self.assertEqual(1, len(pr)) 2344 self.assertEqual(1, len(pr))
2345 self.assertEqual(ERRORS.E10028, pr[0].code) 2345 self.assertEqual(ERRORS.E10028, pr[0].code)
2346 2346
2347 pr = list(data_schema.validate(False, {"type": "boolean"})) 2347 pr = list(data_schema.validate(False, {"$type": "boolean"}))
2348 self.assertEqual(0, len(pr)) 2348 self.assertEqual(0, len(pr))
2349 2349
2350 pr = list(data_schema.validate(False, {"type": "boolean", 2350 pr = list(data_schema.validate(False, {"$type": "boolean",
2351 "value": False})) 2351 "value": False}))
2352 self.assertEqual(0, len(pr)) 2352 self.assertEqual(0, len(pr))
2353 2353
2354 pr = list(data_schema.validate(False, {"type": "boolean", 2354 pr = list(data_schema.validate(False, {"$type": "boolean",
2355 "value": True})) 2355 "value": True}))
2356 self.assertEqual(1, len(pr)) 2356 self.assertEqual(1, len(pr))
2357 self.assertEqual(ERRORS.E10027, pr[0].code) 2357 self.assertEqual(ERRORS.E10027, pr[0].code)
2358 2358
2359 def test_bool_real(self): 2359 def test_bool_real(self):
2360 pr = list(data_schema.validate([1, 2], {"type": "bool"})) 2360 pr = list(data_schema.validate([1, 2], {"$type": "bool"}))
2361 self.assertEqual(1, len(pr)) 2361 self.assertEqual(1, len(pr))
2362 self.assertEqual(ERRORS.E10026, pr[0].code) 2362 self.assertEqual(ERRORS.E10026, pr[0].code)
2363 2363
2364 pr = list(data_schema.validate([], {"type": "bool"})) 2364 pr = list(data_schema.validate([], {"$type": "bool"}))
2365 self.assertEqual(1, len(pr)) 2365 self.assertEqual(1, len(pr))
2366 self.assertEqual(ERRORS.E10026, pr[0].code) 2366 self.assertEqual(ERRORS.E10026, pr[0].code)
2367 2367
2368 pr = list(data_schema.validate(None, {"type": "bool"})) 2368 pr = list(data_schema.validate(None, {"$type": "bool"}))
2369 self.assertEqual(1, len(pr)) 2369 self.assertEqual(1, len(pr))
2370 self.assertEqual(ERRORS.E10026, pr[0].code) 2370 self.assertEqual(ERRORS.E10026, pr[0].code)
2371 2371
2372 @staticmethod 2372 @staticmethod
2373 def _check_value_ts(obj, schema, context): 2373 def _check_value_ts(obj, schema, context):
2376 code=ERRORS.E10042, hint=obj, context=context) 2376 code=ERRORS.E10042, hint=obj, context=context)
2377 2377
2378 def test_timestamp(self): 2378 def test_timestamp(self):
2379 pr = list(data_schema.validate( 2379 pr = list(data_schema.validate(
2380 datetime.datetime.utcnow(), 2380 datetime.datetime.utcnow(),
2381 {"type": "timestamp"})) 2381 {"$type": "timestamp"}))
2382 2382
2383 pr = list(data_schema.validate( 2383 pr = list(data_schema.validate(
2384 datetime.datetime.fromtimestamp(180000), 2384 datetime.datetime.fromtimestamp(180000),
2385 {"type": "datetime", 2385 {"$type": "datetime",
2386 "value": self._check_value_ts})) 2386 "value": self._check_value_ts}))
2387 self.assertEqual(0, len(pr)) 2387 self.assertEqual(0, len(pr))
2388 2388
2389 pr = list(data_schema.validate( 2389 pr = list(data_schema.validate(
2390 datetime.datetime.fromtimestamp(0), 2390 datetime.datetime.fromtimestamp(0),
2391 {"type": "datetime", 2391 {"$type": "datetime",
2392 "value": self._check_value_ts})) 2392 "value": self._check_value_ts}))
2393 self.assertEqual(1, len(pr)) 2393 self.assertEqual(1, len(pr))
2394 self.assertEqual(ERRORS.E10042, pr[0].code) 2394 self.assertEqual(ERRORS.E10042, pr[0].code)
2395 2395
2396 def test_scalar(self): 2396 def test_scalar(self):
2397 pr = list(data_schema.validate(1, {"type": "scalar"})) 2397 pr = list(data_schema.validate(1, {"$type": "scalar"}))
2398 self.assertEqual(0, len(pr)) 2398 self.assertEqual(0, len(pr))
2399 2399
2400 pr = list(data_schema.validate("", {"type": "scalar"})) 2400 pr = list(data_schema.validate("", {"$type": "scalar"}))
2401 self.assertEqual(0, len(pr)) 2401 self.assertEqual(0, len(pr))
2402 2402
2403 pr = list(data_schema.validate(False, {"type": "scalar"})) 2403 pr = list(data_schema.validate(False, {"$type": "scalar"}))
2404 self.assertEqual(0, len(pr)) 2404 self.assertEqual(0, len(pr))
2405 2405
2406 pr = list(data_schema.validate(datetime.datetime.utcnow(), 2406 pr = list(data_schema.validate(datetime.datetime.utcnow(),
2407 {"type": "scalar"})) 2407 {"$type": "scalar"}))
2408 self.assertEqual(0, len(pr)) 2408 self.assertEqual(0, len(pr))
2409 2409
2410 pr = list(data_schema.validate(None, {"type": "scalar"})) 2410 pr = list(data_schema.validate(None, {"$type": "scalar"}))
2411 self.assertEqual(1, len(pr)) 2411 self.assertEqual(1, len(pr))
2412 self.assertEqual(ERRORS.E10033, pr[0].code) 2412 self.assertEqual(ERRORS.E10033, pr[0].code)
2413 2413
2414 pr = list(data_schema.validate({}, {"type": "scalar"})) 2414 pr = list(data_schema.validate({}, {"$type": "scalar"}))
2415 self.assertEqual(1, len(pr)) 2415 self.assertEqual(1, len(pr))
2416 self.assertEqual(ERRORS.E10033, pr[0].code) 2416 self.assertEqual(ERRORS.E10033, pr[0].code)
2417 2417
2418 pr = list(data_schema.validate([], {"type": "scalar"})) 2418 pr = list(data_schema.validate([], {"$type": "scalar"}))
2419 self.assertEqual(1, len(pr)) 2419 self.assertEqual(1, len(pr))
2420 self.assertEqual(ERRORS.E10033, pr[0].code) 2420 self.assertEqual(ERRORS.E10033, pr[0].code)
2421 2421
2422 pr = list(data_schema.validate(tuple(), {"type": "scalar"})) 2422 pr = list(data_schema.validate(tuple(), {"$type": "scalar"}))
2423 self.assertEqual(1, len(pr)) 2423 self.assertEqual(1, len(pr))
2424 self.assertEqual(ERRORS.E10033, pr[0].code) 2424 self.assertEqual(ERRORS.E10033, pr[0].code)
2425 2425
2426 pr = list(data_schema.validate(set(), {"type": "scalar"})) 2426 pr = list(data_schema.validate(set(), {"$type": "scalar"}))
2427 self.assertEqual(1, len(pr)) 2427 self.assertEqual(1, len(pr))
2428 self.assertEqual(ERRORS.E10033, pr[0].code) 2428 self.assertEqual(ERRORS.E10033, pr[0].code)
2429 2429
2430 pr = list(data_schema.validate(frozenset(), {"type": "scalar"})) 2430 pr = list(data_schema.validate(frozenset(), {"$type": "scalar"}))
2431 self.assertEqual(1, len(pr)) 2431 self.assertEqual(1, len(pr))
2432 self.assertEqual(ERRORS.E10033, pr[0].code) 2432 self.assertEqual(ERRORS.E10033, pr[0].code)
2433 2433
2434 pr = list(data_schema.validate( 2434 pr = list(data_schema.validate(
2435 None, 2435 None,
2436 {"type": { 2436 {"$type": {
2437 "one-of": [ 2437 "one-of": [
2438 {"type": "scalar"}, 2438 {"$type": "scalar"},
2439 {"type": None}, 2439 {"$type": None},
2440 ]}})) 2440 ]}}))
2441 self.assertEqual(0, len(pr)) 2441 self.assertEqual(0, len(pr))
2442 2442
2443 2443
2444 if __name__ == "__main__": 2444 if __name__ == "__main__":