/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to brzlib/tests/test_versionedfile.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/tests/test_versionedfile.py
16
16
 
17
17
"""Tests for VersionedFile classes"""
18
18
 
19
 
from .. import (
 
19
from brzlib import (
20
20
    errors,
 
21
    groupcompress,
21
22
    multiparent,
22
23
    tests,
23
 
    )
24
 
from ..bzr import (
25
 
    groupcompress,
26
24
    versionedfile,
27
25
    )
28
26
 
37
35
 
38
36
    def make_three_vf(self):
39
37
        vf = self.make_vf()
40
 
        vf.add_lines((b'one',), (), [b'first\n'])
41
 
        vf.add_lines((b'two',), [(b'one',)], [b'first\n', b'second\n'])
42
 
        vf.add_lines((b'three',), [(b'one',), (b'two',)],
43
 
                     [b'first\n', b'second\n', b'third\n'])
 
38
        vf.add_lines(('one',), (), ['first\n'])
 
39
        vf.add_lines(('two',), [('one',)], ['first\n', 'second\n'])
 
40
        vf.add_lines(('three',), [('one',), ('two',)],
 
41
                    ['first\n', 'second\n', 'third\n'])
44
42
        return vf
45
43
 
46
44
    def test_finds_parents(self):
47
45
        vf = self.make_three_vf()
48
 
        gen = versionedfile._MPDiffGenerator(vf, [(b'three',)])
 
46
        gen = versionedfile._MPDiffGenerator(vf, [('three',)])
49
47
        needed_keys, refcount = gen._find_needed_keys()
50
 
        self.assertEqual(sorted([(b'one',), (b'two',), (b'three',)]),
 
48
        self.assertEqual(sorted([('one',), ('two',), ('three',)]),
51
49
                         sorted(needed_keys))
52
 
        self.assertEqual({(b'one',): 1, (b'two',): 1}, refcount)
 
50
        self.assertEqual({('one',): 1, ('two',): 1}, refcount)
53
51
 
54
52
    def test_ignores_ghost_parents(self):
55
53
        # If a parent is a ghost, it is just ignored
56
54
        vf = self.make_vf()
57
 
        vf.add_lines((b'two',), [(b'one',)], [b'first\n', b'second\n'])
58
 
        gen = versionedfile._MPDiffGenerator(vf, [(b'two',)])
 
55
        vf.add_lines(('two',), [('one',)], ['first\n', 'second\n'])
 
56
        gen = versionedfile._MPDiffGenerator(vf, [('two',)])
59
57
        needed_keys, refcount = gen._find_needed_keys()
60
 
        self.assertEqual(sorted([(b'two',)]), sorted(needed_keys))
 
58
        self.assertEqual(sorted([('two',)]), sorted(needed_keys))
61
59
        # It is returned, but we don't really care as we won't extract it
62
 
        self.assertEqual({(b'one',): 1}, refcount)
63
 
        self.assertEqual([(b'one',)], sorted(gen.ghost_parents))
 
60
        self.assertEqual({('one',): 1}, refcount)
 
61
        self.assertEqual([('one',)], sorted(gen.ghost_parents))
64
62
        self.assertEqual([], sorted(gen.present_parents))
65
63
 
66
64
    def test_raises_on_ghost_keys(self):
67
65
        # If the requested key is a ghost, then we have a problem
68
66
        vf = self.make_vf()
69
 
        gen = versionedfile._MPDiffGenerator(vf, [(b'one',)])
 
67
        gen = versionedfile._MPDiffGenerator(vf, [('one',)])
70
68
        self.assertRaises(errors.RevisionNotPresent,
71
69
                          gen._find_needed_keys)
72
70
 
73
71
    def test_refcount_multiple_children(self):
74
72
        vf = self.make_three_vf()
75
 
        gen = versionedfile._MPDiffGenerator(vf, [(b'two',), (b'three',)])
 
73
        gen = versionedfile._MPDiffGenerator(vf, [('two',), ('three',)])
76
74
        needed_keys, refcount = gen._find_needed_keys()
77
 
        self.assertEqual(sorted([(b'one',), (b'two',), (b'three',)]),
 
75
        self.assertEqual(sorted([('one',), ('two',), ('three',)]),
78
76
                         sorted(needed_keys))
79
 
        self.assertEqual({(b'one',): 2, (b'two',): 1}, refcount)
80
 
        self.assertEqual([(b'one',)], sorted(gen.present_parents))
 
77
        self.assertEqual({('one',): 2, ('two',): 1}, refcount)
 
78
        self.assertEqual([('one',)], sorted(gen.present_parents))
81
79
 
82
80
    def test_process_contents(self):
83
81
        vf = self.make_three_vf()
84
 
        gen = versionedfile._MPDiffGenerator(vf, [(b'two',), (b'three',)])
 
82
        gen = versionedfile._MPDiffGenerator(vf, [('two',), ('three',)])
85
83
        gen._find_needed_keys()
86
 
        self.assertEqual({(b'two',): ((b'one',),),
87
 
                          (b'three',): ((b'one',), (b'two',))},
 
84
        self.assertEqual({('two',): (('one',),),
 
85
                          ('three',): (('one',), ('two',))},
88
86
                         gen.parent_map)
89
 
        self.assertEqual({(b'one',): 2, (b'two',): 1}, gen.refcounts)
90
 
        self.assertEqual(sorted([(b'one',), (b'two',), (b'three',)]),
 
87
        self.assertEqual({('one',): 2, ('two',): 1}, gen.refcounts)
 
88
        self.assertEqual(sorted([('one',), ('two',), ('three',)]),
91
89
                         sorted(gen.needed_keys))
92
90
        stream = vf.get_record_stream(gen.needed_keys, 'topological', True)
93
 
        record = next(stream)
94
 
        self.assertEqual((b'one',), record.key)
 
91
        record = stream.next()
 
92
        self.assertEqual(('one',), record.key)
95
93
        # one is not needed in the output, but it is needed by children. As
96
94
        # such, it should end up in the various caches
97
95
        gen._process_one_record(record.key, record.get_bytes_as('chunked'))
98
96
        # The chunks should be cached, the refcount untouched
99
 
        self.assertEqual({(b'one',)}, set(gen.chunks))
100
 
        self.assertEqual({(b'one',): 2, (b'two',): 1}, gen.refcounts)
101
 
        self.assertEqual(set(), set(gen.diffs))
 
97
        self.assertEqual([('one',)], gen.chunks.keys())
 
98
        self.assertEqual({('one',): 2, ('two',): 1}, gen.refcounts)
 
99
        self.assertEqual([], gen.diffs.keys())
102
100
        # Next we get 'two', which is something we output, but also needed for
103
101
        # three
104
 
        record = next(stream)
105
 
        self.assertEqual((b'two',), record.key)
 
102
        record = stream.next()
 
103
        self.assertEqual(('two',), record.key)
106
104
        gen._process_one_record(record.key, record.get_bytes_as('chunked'))
107
105
        # Both are now cached, and the diff for two has been extracted, and
108
106
        # one's refcount has been updated. two has been removed from the
109
107
        # parent_map
110
 
        self.assertEqual({(b'one',), (b'two',)}, set(gen.chunks))
111
 
        self.assertEqual({(b'one',): 1, (b'two',): 1}, gen.refcounts)
112
 
        self.assertEqual({(b'two',)}, set(gen.diffs))
113
 
        self.assertEqual({(b'three',): ((b'one',), (b'two',))},
 
108
        self.assertEqual(sorted([('one',), ('two',)]),
 
109
                         sorted(gen.chunks.keys()))
 
110
        self.assertEqual({('one',): 1, ('two',): 1}, gen.refcounts)
 
111
        self.assertEqual([('two',)], gen.diffs.keys())
 
112
        self.assertEqual({('three',): (('one',), ('two',))},
114
113
                         gen.parent_map)
115
114
        # Finally 'three', which allows us to remove all parents from the
116
115
        # caches
117
 
        record = next(stream)
118
 
        self.assertEqual((b'three',), record.key)
 
116
        record = stream.next()
 
117
        self.assertEqual(('three',), record.key)
119
118
        gen._process_one_record(record.key, record.get_bytes_as('chunked'))
120
119
        # Both are now cached, and the diff for two has been extracted, and
121
120
        # one's refcount has been updated
122
 
        self.assertEqual(set(), set(gen.chunks))
 
121
        self.assertEqual([], gen.chunks.keys())
123
122
        self.assertEqual({}, gen.refcounts)
124
 
        self.assertEqual({(b'two',), (b'three',)}, set(gen.diffs))
 
123
        self.assertEqual(sorted([('two',), ('three',)]),
 
124
                         sorted(gen.diffs.keys()))
125
125
 
126
126
    def test_compute_diffs(self):
127
127
        vf = self.make_three_vf()
128
128
        # The content is in the order requested, even if it isn't topological
129
 
        gen = versionedfile._MPDiffGenerator(vf, [(b'two',), (b'three',),
130
 
                                                  (b'one',)])
 
129
        gen = versionedfile._MPDiffGenerator(vf, [('two',), ('three',),
 
130
                                                  ('one',)])
131
131
        diffs = gen.compute_diffs()
132
132
        expected_diffs = [
133
133
            multiparent.MultiParent([multiparent.ParentText(0, 0, 0, 1),
134
 
                                     multiparent.NewText([b'second\n'])]),
 
134
                                     multiparent.NewText(['second\n'])]),
135
135
            multiparent.MultiParent([multiparent.ParentText(1, 0, 0, 2),
136
 
                                     multiparent.NewText([b'third\n'])]),
137
 
            multiparent.MultiParent([multiparent.NewText([b'first\n'])]),
 
136
                                     multiparent.NewText(['third\n'])]),
 
137
            multiparent.MultiParent([multiparent.NewText(['first\n'])]),
138
138
            ]
139
139
        self.assertEqual(expected_diffs, diffs)