Example #1
0
 def setUp(self):
     self.v = TValidator()
Example #2
0
class ValidationTest(unittest.TestCase):
    def setUp(self):
        self.v = TValidator()

    def valid(self, msg):
        self.assertTrue(self.v.validate(msg))

    def wrong(self, msg):
        self.assertFalse(self.v.validate(msg))

    def testBinary(self):
        self.valid(myBinaryStruct(a='xyzzy'))
        self.wrong(myBinaryStruct(a=3))

    def testBool(self):
        self.valid(myBoolStruct(a=True))
        self.valid(myBoolStruct(a=False))
        self.wrong(myBoolStruct(a=1))
        self.wrong(myBoolStruct(a='a'))

    def testByte(self):
        self.valid(myByteStruct(a=0))
        self.valid(myByteStruct(a=127))
        self.valid(myByteStruct(a=-128))
        self.wrong(myByteStruct(a=1.1))
        self.wrong(myByteStruct(a=128))
        self.wrong(myByteStruct(a=-129))

    def testI16(self):
        self.valid(myI16Struct(a=4567))
        self.wrong(myI16Struct(a=0xFEDCBA987))

    def testI32(self):
        self.valid(myI32Struct(a=12131415))
        self.wrong(myI32Struct(a=0xFFFFFFFFEDCBA))

    def testDouble(self):
        self.valid(myDoubleStruct(a=-2.192))
        self.valid(myDoubleStruct(a=float('inf')))
        self.valid(myDoubleStruct(a=float('-inf')))
        self.wrong(myDoubleStruct(a=2))

    def testMixed(self):
        self.valid(
            myMixedStruct(a=[],
                          b=[mySuperSimpleStruct(a=5)],
                          c={
                              'flame': -8,
                              'fire': -191
                          },
                          d={},
                          e=set([1, 2, 3, 4])))

    def testStruct(self):
        self.valid(mySetStruct(a=set([4, 8, 15, 16])))
        self.valid(mySetStruct(a=set([])))
        self.wrong(mySetStruct(a=set([1, 0xFFFFFFFFFF, 2])))

    def testMap(self):
        self.valid(
            myMapStruct(stringMap={
                "a": "A",
                "b": "B"
            },
                        boolMap={
                            True: "True",
                            False: "False"
                        },
                        byteMap={
                            1: "one",
                            2: "two"
                        },
                        doubleMap={
                            float("0.1"): "0.one",
                            float("0.2"): "0.two"
                        },
                        enumMap={
                            1: "male",
                            2: "female"
                        }))
        self.valid(
            mySimpleStruct(a=False,
                           b=87,
                           c=7880,
                           d=-7880,
                           e=-1,
                           f=-0.1,
                           g='T-bone'))
        self.wrong(mySimpleStruct(a=1))
        self.valid(
            myComplexStruct(mySimpleStruct(a=True,
                                           b=92,
                                           c=902,
                                           d=65536,
                                           e=123456789,
                                           f=3.1415,
                                           g='Whan that Aprille'),
                            b=[314, 15, 9, 26535],
                            c={
                                "qwerty": mySimpleStruct(c=1),
                                "slippy": mySimpleStruct(a=False, b=-4, c=5)
                            },
                            e=EnumTest.EnumTwo,
                            x=ExceptionTest("test")))

    def testCustomValidator(self):
        def a_must_be_true(v):
            return v.a

        self.v.addClassValidator('mySimpleStruct', a_must_be_true)
        self.valid(myComplexStruct(mySimpleStruct(a=True), ))
        self.wrong(myComplexStruct(mySimpleStruct(a=False), ))

    def testNestedMap(self):
        self.valid(
            myNestedMapStruct(
                maps={
                    "1": {
                        "1": mySimpleStruct(c=1)
                    },
                    "2": {
                        "2": mySimpleStruct(a=False, c=2)
                    }
                }))
        self.wrong(
            myNestedMapStruct(
                maps={
                    "1": {
                        "1": mySimpleStruct(c=1)
                    },
                    "2": {
                        "2": mySimpleStruct(a=0, c=2)
                    }
                }))
class ValidationTest(unittest.TestCase):
    def setUp(self):
        self.v = TValidator()

    def valid(self, msg):
        self.assertTrue(self.v.validate(msg))

    def wrong(self, msg):
        self.assertFalse(self.v.validate(msg))

    def testBinary(self):
        self.valid(myBinaryStruct(a='xyzzy'))
        self.wrong(myBinaryStruct(a=3))

    def testBool(self):
        self.valid(myBoolStruct(a=True))
        self.valid(myBoolStruct(a=False))
        self.wrong(myBoolStruct(a=1))
        self.wrong(myBoolStruct(a='a'))

    def testByte(self):
        self.valid(myByteStruct(a=0))
        self.valid(myByteStruct(a=127))
        self.valid(myByteStruct(a=-128))
        self.wrong(myByteStruct(a=1.1))
        self.wrong(myByteStruct(a=128))
        self.wrong(myByteStruct(a=-129))

    def testI16(self):
        self.valid(myI16Struct(a=4567))
        self.wrong(myI16Struct(a=0xFEDCBA987))

    def testI32(self):
        self.valid(myI32Struct(a=12131415))
        self.wrong(myI32Struct(a=0xFFFFFFFFEDCBA))

    def testDouble(self):
        self.valid(myDoubleStruct(a=-2.192))
        self.valid(myDoubleStruct(a=float('inf')))
        self.valid(myDoubleStruct(a=float('-inf')))
        self.wrong(myDoubleStruct(a=2))

    def testMixed(self):
        self.valid(
            myMixedStruct(a=[],
                          b=[mySuperSimpleStruct(a=5)],
                          c={
                              'flame': -8,
                              'fire': -191
                          },
                          d={},
                          e=set([1, 2, 3, 4])))

    def testStruct(self):
        self.valid(mySetStruct(a=set([4, 8, 15, 16])))
        self.valid(mySetStruct(a=set([])))
        self.wrong(mySetStruct(a=set([1, 0xFFFFFFFFFF, 2])))

    def testMap(self):
        self.valid(
            myMapStruct(stringMap={
                "a": "A",
                "b": "B"
            },
                        boolMap={
                            True: "True",
                            False: "False"
                        },
                        byteMap={
                            1: "one",
                            2: "two"
                        },
                        doubleMap={
                            float("0.1"): "0.one",
                            float("0.2"): "0.two"
                        },
                        enumMap={
                            1: "male",
                            2: "female"
                        }))
        self.valid(
            mySimpleStruct(a=False,
                           b=87,
                           c=7880,
                           d=-7880,
                           e=-1,
                           f=-0.1,
                           g='T-bone'))
        self.wrong(mySimpleStruct(a=1))
        self.valid(
            myComplexStruct(mySimpleStruct(a=True,
                                           b=92,
                                           c=902,
                                           d=65536,
                                           e=123456789,
                                           f=3.1415,
                                           g='Whan that Aprille'),
                            b=[314, 15, 9, 26535],
                            c={
                                "qwerty": mySimpleStruct(c=1),
                                "slippy": mySimpleStruct(a=False, b=-4, c=5)
                            },
                            e=EnumTest.EnumTwo,
                            x=ExceptionTest("test")))

    def testCustomValidator(self):
        def a_must_be_true(v):
            return v.a

        self.v.addClassValidator('mySimpleStruct', a_must_be_true)
        self.valid(myComplexStruct(mySimpleStruct(a=True), ))
        self.wrong(myComplexStruct(mySimpleStruct(a=False), ))

    def testNestedMap(self):
        self.valid(
            myNestedMapStruct(
                maps={
                    "1": {
                        "1": mySimpleStruct(c=1)
                    },
                    "2": {
                        "2": mySimpleStruct(a=False, c=2)
                    }
                }))
        self.wrong(
            myNestedMapStruct(
                maps={
                    "1": {
                        "1": mySimpleStruct(c=1)
                    },
                    "2": {
                        "2": mySimpleStruct(a=0, c=2)
                    }
                }))

    def testEnumSpec(self):
        self.assertTrue(
            hasattr(myComplexStruct.thrift_spec[4][3], '_NAMES_TO_VALUES'))

    def testAnnotations(self):
        self.assertTrue(hasattr(WithAnnotations, 'thrift_field_annotations'))
        self.assertTrue(hasattr(WithAnnotations, 'thrift_struct_annotations'))
        self.assertEquals(
            WithAnnotations.thrift_field_annotations,
            {
                1: {
                    'test.annotation': 'none',
                    'test.hidden': '1',
                },
                3: {
                    'test.hidden': '3',
                },
            },
        )
        self.assertEquals(
            WithAnnotations.thrift_struct_annotations,
            {
                'test.struct_annotation':
                'ok',
                'test.partial':
                '1',
                'test.complex':
                """
   public:

    bool empty() const {
      return !(__isset.m1 ||
               __isset.m2 ||
               __isset.s1);
    }
  """,
            },
        )
 def setUp(self):
     self.v = TValidator()
class ValidationTest(unittest.TestCase):
    def setUp(self):
        self.v = TValidator()

    def valid(self, msg):
        self.assertTrue(self.v.validate(msg))

    def wrong(self, msg):
        self.assertFalse(self.v.validate(msg))

    def testBinary(self):
        self.valid(myBinaryStruct(a="xyzzy"))
        self.wrong(myBinaryStruct(a=3))

    def testBool(self):
        self.valid(myBoolStruct(a=True))
        self.valid(myBoolStruct(a=False))
        self.wrong(myBoolStruct(a=1))
        self.wrong(myBoolStruct(a="a"))

    def testByte(self):
        self.valid(myByteStruct(a=0))
        self.valid(myByteStruct(a=127))
        self.valid(myByteStruct(a=-128))
        self.wrong(myByteStruct(a=1.1))
        self.wrong(myByteStruct(a=128))
        self.wrong(myByteStruct(a=-129))

    def testI16(self):
        self.valid(myI16Struct(a=4567))
        self.wrong(myI16Struct(a=0xFEDCBA987))

    def testI32(self):
        self.valid(myI32Struct(a=12131415))
        self.wrong(myI32Struct(a=0xFFFFFFFFEDCBA))

    def testDouble(self):
        self.valid(myDoubleStruct(a=-2.192))
        self.valid(myDoubleStruct(a=float("inf")))
        self.valid(myDoubleStruct(a=float("-inf")))
        self.wrong(myDoubleStruct(a=2))

    def testMixed(self):
        self.valid(
            myMixedStruct(a=[], b=[mySuperSimpleStruct(a=5)], c={"flame": -8, "fire": -191}, d={}, e=set([1, 2, 3, 4]))
        )

    def testStruct(self):
        self.valid(mySetStruct(a=set([4, 8, 15, 16])))
        self.valid(mySetStruct(a=set([])))
        self.wrong(mySetStruct(a=set([1, 0xFFFFFFFFFF, 2])))

    def testMap(self):
        self.valid(
            myMapStruct(
                stringMap={"a": "A", "b": "B"},
                boolMap={True: "True", False: "False"},
                byteMap={1: "one", 2: "two"},
                doubleMap={float("0.1"): "0.one", float("0.2"): "0.two"},
                enumMap={1: "male", 2: "female"},
            )
        )
        self.valid(mySimpleStruct(a=False, b=87, c=7880, d=-7880, e=-1, f=-0.1, g="T-bone"))
        self.wrong(mySimpleStruct(a=1))
        self.valid(
            myComplexStruct(
                mySimpleStruct(a=True, b=92, c=902, d=65536, e=123456789, f=3.1415, g="Whan that Aprille"),
                b=[314, 15, 9, 26535],
                c={"qwerty": mySimpleStruct(c=1), "slippy": mySimpleStruct(a=False, b=-4, c=5)},
                e=EnumTest.EnumTwo,
                x=ExceptionTest("test"),
            )
        )

    def testCustomValidator(self):
        def a_must_be_true(v):
            return v.a

        self.v.addClassValidator("mySimpleStruct", a_must_be_true)
        self.valid(myComplexStruct(mySimpleStruct(a=True)))
        self.wrong(myComplexStruct(mySimpleStruct(a=False)))

    def testNestedMap(self):
        self.valid(myNestedMapStruct(maps={"1": {"1": mySimpleStruct(c=1)}, "2": {"2": mySimpleStruct(a=False, c=2)}}))
        self.wrong(myNestedMapStruct(maps={"1": {"1": mySimpleStruct(c=1)}, "2": {"2": mySimpleStruct(a=0, c=2)}}))

    def testEnumSpec(self):
        self.assertTrue(hasattr(myComplexStruct.thrift_spec[4][3], "_NAMES_TO_VALUES"))

    def testAnnotations(self):
        self.assertTrue(hasattr(WithAnnotations, "thrift_field_annotations"))
        self.assertTrue(hasattr(WithAnnotations, "thrift_struct_annotations"))
        self.assertEquals(
            WithAnnotations.thrift_field_annotations,
            {1: {"test.annotation": "none", "test.hidden": "1"}, 3: {"test.hidden": "3"}},
        )
        self.assertEquals(
            WithAnnotations.thrift_struct_annotations,
            {
                "test.struct_annotation": "ok",
                "test.partial": "1",
                "test.complex": """
   public:

    bool empty() const {
      return !(__isset.m1 ||
               __isset.m2 ||
               __isset.s1);
    }
  """,
            },
        )
Example #6
0
class ValidationTest(unittest.TestCase):
    def setUp(self):
        self.v = TValidator()

    def valid(self, msg):
        self.assertTrue(self.v.validate(msg))

    def wrong(self, msg):
        self.assertFalse(self.v.validate(msg))

    def testBinary(self):
        self.valid(myBinaryStruct(a="xyzzy"))
        self.wrong(myBinaryStruct(a=3))

    def testBool(self):
        self.valid(myBoolStruct(a=True))
        self.valid(myBoolStruct(a=False))
        self.wrong(myBoolStruct(a=1))
        self.wrong(myBoolStruct(a="a"))

    def testByte(self):
        self.valid(myByteStruct(a=0))
        self.valid(myByteStruct(a=127))
        self.valid(myByteStruct(a=-128))
        self.wrong(myByteStruct(a=1.1))
        self.wrong(myByteStruct(a=128))
        self.wrong(myByteStruct(a=-129))

    def testI16(self):
        self.valid(myI16Struct(a=4567))
        self.wrong(myI16Struct(a=0xFEDCBA987))

    def testI32(self):
        self.valid(myI32Struct(a=12131415))
        self.wrong(myI32Struct(a=0xFFFFFFFFEDCBA))

    def testDouble(self):
        self.valid(myDoubleStruct(a=-2.192))
        self.valid(myDoubleStruct(a=float("inf")))
        self.valid(myDoubleStruct(a=float("-inf")))
        self.wrong(myDoubleStruct(a=2))

    def testMixed(self):
        self.valid(
            myMixedStruct(a=[], b=[mySuperSimpleStruct(a=5)], c={"flame": -8, "fire": -191}, d={}, e=set([1, 2, 3, 4]))
        )

    def testStruct(self):
        self.valid(mySetStruct(a=set([4, 8, 15, 16])))
        self.valid(mySetStruct(a=set([])))
        self.wrong(mySetStruct(a=set([1, 0xFFFFFFFFFF, 2])))

    def testMap(self):
        self.valid(
            myMapStruct(
                stringMap={"a": "A", "b": "B"},
                boolMap={True: "True", False: "False"},
                byteMap={1: "one", 2: "two"},
                doubleMap={float("0.1"): "0.one", float("0.2"): "0.two"},
                enumMap={1: "male", 2: "female"},
            )
        )
        self.valid(mySimpleStruct(a=False, b=87, c=7880, d=-7880, e=-1, f=-0.1, g="T-bone"))
        self.wrong(mySimpleStruct(a=1))
        self.valid(
            myComplexStruct(
                mySimpleStruct(a=True, b=92, c=902, d=65536, e=123456789, f=3.1415, g="Whan that Aprille"),
                b=[314, 15, 9, 26535],
                c={"qwerty": mySimpleStruct(c=1), "slippy": mySimpleStruct(a=False, b=-4, c=5)},
                e=EnumTest.EnumTwo,
                x=ExceptionTest("test"),
            )
        )

    def testCustomValidator(self):
        def a_must_be_true(v):
            return v.a

        self.v.addClassValidator("mySimpleStruct", a_must_be_true)
        self.valid(myComplexStruct(mySimpleStruct(a=True)))
        self.wrong(myComplexStruct(mySimpleStruct(a=False)))

    def testNestedMap(self):
        self.valid(myNestedMapStruct(maps={"1": {"1": mySimpleStruct(c=1)}, "2": {"2": mySimpleStruct(a=False, c=2)}}))
        self.wrong(myNestedMapStruct(maps={"1": {"1": mySimpleStruct(c=1)}, "2": {"2": mySimpleStruct(a=0, c=2)}}))