def test_delta_as_data(self):
        delta = Delta(ops=[
            Insert('abc', None),
            Retain(1, {'color': 'red'}),
            Delete(4),
            Insert('def', {'bold': True}),
            Retain(6, None)
        ])

        expected = [{
            'insert': 'abc'
        }, {
            'retain': 1,
            'attributes': {
                'color': 'red'
            }
        }, {
            'delete': 4
        }, {
            'insert': 'def',
            'attributes': {
                'bold': True
            }
        }, {
            'retain': 6
        }]

        self.assertListEqual(delta.as_data(), expected)
 def test_retain_as_data(self):
     assert Retain(1, None).as_data() == {'retain': 1}
     assert Retain(1, {}).as_data() == {'retain': 1}
     assert Retain(1, {
         'bold': True
     }).as_data() == {
         'retain': 1,
         'attributes': {
             'bold': True
         }
     }
 def test_retain_from_dict(self):
     assert load_operation({'retain': 1}) == Retain(1, None)
     assert load_operation({
         'retain': 1,
         'attributes': {
             'bold': True
         }
     }) == Insert(1, {'bold': True})
    def test_delta_as_string(self):
        delta = Delta(ops=[
            Insert('abc', None),
            Retain(1, {'color': 'red'}),
            Delete(3),
        ])

        assert str(delta) == ('[{"insert": "abc"}, '
                              '{"retain": 1, "attributes": {"color": "red"}}, '
                              '{"delete": 3}]')
Пример #5
0
    def test_insert_in_middle_of_text(self):
        a = Delta().insert('Hello')
        b = Delta().retain(3).insert('X')

        assert a.ops == [Insert('Hello', None)]
        assert b.ops == [Retain(3, None), Insert('X', None)]

        expected = Delta().insert('HelXlo')
        compose = a.compose(b)

        assert compose.ops == expected.ops, f'{expected} not {compose}'
Пример #6
0
    def test_as_data(self):
        op = Retain(1, {'bold': True})

        assert op.as_data() == {'retain': 1, 'attributes': {'bold': True}}
 def test_retain_str_json(self):
     assert str(Retain('foo', None)) == '{"retain": "foo"}'
     assert str(Retain('foo', {})) == '{"retain": "foo"}'
     assert str(Retain(
         'foo', {'bold': True
                 })) == '{"retain": "foo", "attributes": {"bold": true}}'
Пример #8
0
    def test_parse(self):
        op = Retain.fromdict({'retain': 1})

        assert op.value == 1
        assert op.length == 1
        assert op.attributes is None
Пример #9
0
    def test_retain_attributes(self):
        op = Retain(1, {'bold': True})

        assert op.attributes == {'bold': True}
Пример #10
0
    def test_retain_constructor(self):
        op = Retain(1, None)

        assert op.value == 1
        assert op.length == 1
        assert op.attributes is None
Пример #11
0
    def test_sum_operation(self):
        op = Retain(1, None) + Retain(2, None)
        assert op == Retain(3, None)

        op = reduce(lambda o, other: o + other,
                    [Retain(1, None),
                     Retain(2, None),
                     Retain(3, None)])

        assert op == Retain(6, None)

        op = Retain(1, {'bold': True}) + Retain(2, {'bold': True})
        assert op == Retain(3, {'bold': True})

        with pytest.raises(ValueError) as err:
            Retain(1, None) + Insert('foo', None)

        assert err.match('Operations are not the same type')

        with pytest.raises(ValueError) as err:
            Retain(1, {'bold': True}) + Retain(1, {'bold': False})

        assert err.match('operations with different attributes')
Пример #12
0
    def test_as_json(self):
        op = Retain(1, {'bold': True})

        assert op.as_json() == '{"retain": 1, "attributes": {"bold": true}}'