Exemplo n.º 1
0
 def test_encode_Comparison(self):
     from instrumental.storage import ObjectEncoder as OE
     node = ast.Compare(left=ast.Name(id='a'),
                        ops=[ast.Eq()],
                        comparators=[ast.Num(n=4)],
                        lineno=4)
     construct = Comparison('somemodule', '4.2', node, [])
     construct.conditions = {False: set(), True: set(['X'])}
     result = OE().encode(construct)
     
     expected = {'__python_class__': 'Comparison',
                 'modulename': 'somemodule',
                 'label': '4.2',
                 'node': {'__python_class__': 'Compare',
                          'left': {'__python_class__': 'Name',
                                   'id': 'a'},
                          'ops': [{'__python_class__': 'Eq'}],
                          'comparators': [{'__python_class__': 'Num',
                                           'n': 4}],
                          'lineno': 4,
                          },
                 'conditions': {0: [], 1: ['X']},
                 }
     
     assert result == expected
Exemplo n.º 2
0
 def _makeOne(self, selector='3.1', pragmas={}):
     node = ast.Compare(left=ast.Name(id='a'),
                        ops=[ast.Eq()],
                        comparators=[ast.Name(id='b')],
                        col_offset=12,
                        lineno=3)
     construct = Comparison('somemodule', selector, node, pragmas)
     return construct
Exemplo n.º 3
0
 def _makeOneWithLiteral(self,
                         op=ast.Eq(),
                         left=ast.Num(n=4),
                         right=ast.Num(n=4)):
     node = ast.Compare(left=left,
                        ops=[op],
                        comparators=[right],
                        col_offset=12,
                        lineno=3)
     construct = Comparison('somemodule', '3.1', node, {})
     return construct
Exemplo n.º 4
0
    def test_serialize_Comparison(self):
        from instrumental.constructs import Comparison

        node = ast.Compare(left=ast.Name(id="a"),
                           ops=[ast.NotEq()],
                           comparators=[ast.Str(s="foobar")],
                           lineno=4)
        construct = Comparison('somemodule', '4.2', node, [])

        serializer = self._makeOne()
        actual = serializer.dump(construct)
        expected = "Comparison|somemodule|4.2|Compare'4'Name{a};NotEq;Str{Zm9vYmFy}||False:;True:"
        assert actual == expected, (actual, expected)
Exemplo n.º 5
0
 def test_encode_Node_with_list_attribute(self):
     from instrumental.storage import ObjectEncoder as OE
     node = ast.Compare(left=ast.Name(id='a'),
                        ops=[ast.Eq()],
                        comparators=[ast.Num(n=4)])
     result = OE().encode_Node(node)
     
     expected = {'__python_class__': 'Compare',
                 'left': {'__python_class__': 'Name',
                          'id': 'a'},
                 'ops': [{'__python_class__': 'Eq'}],
                 'comparators': [{'__python_class__': 'Num',
                                  'n': 4}],
                 }
     
     assert result == expected, (result, expected)