def test_FailDeserializeWithInvalidTypes(self):
        with self.assertRaises(TypeError):
            deserialize(Rule(Object), {
                'name': 'Karel',
                'full_name': 0.0,
            })

        with self.assertRaises(TypeError):
            deserialize(
                Rule(Object), {
                    'name': 'Rolf',
                    'full_name': 'Rolf van Kleef',
                    'calling_name': False,
                })
Exemplo n.º 2
0
 def test_SetCorrectValueShouldSucceed(self):
     self.assertEqual(
         Object(name='Rolf'),
         deserialize(Rule(Object), {
            'name': 'Rolf'
         }, try_all=False)
     )
 def test_DictDeserialize(self):
     self.assertEqual(
         DictTest(
             test={
                 1: [
                     User(name='Peter',
                          full_name='Peter Driebergen',
                          calling_name='Unknown')
                 ]
             }),
         deserialize(
             Rule(DictTest), {
                 "test": {
                     1: [{
                         'name': 'Peter',
                         'full_name': 'Peter Driebergen',
                     }],
                 }
             }))
 def test_CorrectDeserializationForNestedWithTypeUnionsAndLists(self):
     # noinspection PyArgumentList
     self.assertEqual(
         Group(
             name='IAPC',
             members=[
                 User(name='Rolf',
                      full_name='Rolf van Kleef',
                      calling_name='Unknown'),
                 Group(name='Syscom',
                       members=[
                           User(name='Kevin',
                                full_name='Kevin Alberts',
                                calling_name='Kevin'),
                       ]),
             ],
         ),
         deserialize(
             Rule(Object), {
                 'name':
                 'IAPC',
                 'members': [
                     {
                         'name': 'Rolf',
                         'full_name': 'Rolf van Kleef'
                     },
                     {
                         'name':
                         'Syscom',
                         'members': [
                             {
                                 'name': 'Kevin',
                                 'full_name': 'Kevin Alberts',
                                 'calling_name': 'Kevin'
                             },
                         ]
                     },
                 ],
             }))
    def test_DeserializeTupleFail(self):
        with self.assertRaises(TypeError):
            deserialize(Rule(NestedTypingStuff), {"test": [[1, 2]]})

        with self.assertRaises(TypeError):
            deserialize(Rule(NestedTypingStuff), {"test": [[1, 2, "boo"]]})
 def test_DeserializeTupleCorrect(self):
     # noinspection PyArgumentList
     self.assertEqual(
         NestedTypingStuff(test=[(1, 2, 3)]),
         deserialize(Rule(NestedTypingStuff), {"test": [[1, 2, 3]]}))
 def test_DeserializeIntoAbstract(self):
     with self.assertRaises(TypeError):
         deserialize(Rule(Object), {'name': 'Test'})
Exemplo n.º 8
0
 def test_SetWrongValueShouldFail(self):
     with self.assertRaises(TypeError):
         deserialize(Rule(Object), {
             'name': 'abcdefghijklmnopqrstuvwxyz'
         })
Exemplo n.º 9
0
 def test_SetWrongTypeShouldFail(self):
     with self.assertRaises(TypeError):
         deserialize(Rule(Object), {
             'name': 8
         })
Exemplo n.º 10
0
if __name__ == '__main__':
    import sys
    import traceback

    from dict_deserializer.deserializer import deserialize

    def print_result(function, *args, **kwargs):
        try:
            print(function(*args, **kwargs))
        except:
            sleep(0.05)
            print(traceback.format_exc(), file=sys.stderr)

    fns = [[
        Rule(ReceiptLine), {
            'type': 'transaction',
            'name': 'asdf',
            'article_id': 5,
            'amount': 5
        }
    ], [Rule(ReceiptLine), {
        'type': 'refund',
        'name': 'asdf',
        'pk': 5
    }], [Rule(ReceiptLine), {
        'type': 'other',
        'name': 'asdf'
    }], [Rule(ReceiptLine), {
        'type': 'transaction'
    }], [