/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 breezy/tests/test_vf_search.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_vf_search.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from ... import (
 
17
from .. import (
18
18
    graph as _mod_graph,
19
19
    tests,
20
20
    )
21
 
from .. import (
 
21
from ..bzr import (
22
22
    vf_search,
23
23
    )
24
 
from ...revision import NULL_REVISION
25
 
from ...tests.test_graph import TestGraphBase
 
24
from ..revision import NULL_REVISION
 
25
from .test_graph import TestGraphBase
26
26
 
27
27
# Ancestry 1:
28
28
#
35
35
#   rev3  /
36
36
#     |  /
37
37
#   rev4
38
 
ancestry_1 = {b'rev1': [NULL_REVISION],
39
 
              b'rev2a': [b'rev1'],
40
 
              b'rev2b': [b'rev1'],
41
 
              b'rev3': [b'rev2a'],
42
 
              b'rev4': [b'rev3', b'rev2b']}
 
38
ancestry_1 = {'rev1': [NULL_REVISION], 'rev2a': ['rev1'], 'rev2b': ['rev1'],
 
39
              'rev3': ['rev2a'], 'rev4': ['rev3', 'rev2b']}
43
40
 
44
41
# Ancestry 2:
45
42
#
52
49
# rev3a
53
50
#   |
54
51
# rev4a
55
 
ancestry_2 = {b'rev1a': [NULL_REVISION],
56
 
              b'rev2a': [b'rev1a'],
57
 
              b'rev1b': [NULL_REVISION],
58
 
              b'rev3a': [b'rev2a'],
59
 
              b'rev4a': [b'rev3a']}
 
52
ancestry_2 = {'rev1a': [NULL_REVISION], 'rev2a': ['rev1a'],
 
53
              'rev1b': [NULL_REVISION], 'rev3a': ['rev2a'], 'rev4a': ['rev3a']}
60
54
 
61
55
 
62
56
# Extended history shortcut
71
65
#       d |
72
66
#       |\|
73
67
#       e f
74
 
extended_history_shortcut = {b'a': [NULL_REVISION],
75
 
                             b'b': [b'a'],
76
 
                             b'c': [b'b'],
77
 
                             b'd': [b'c'],
78
 
                             b'e': [b'd'],
79
 
                             b'f': [b'a', b'd'],
80
 
                             }
 
68
extended_history_shortcut = {'a': [NULL_REVISION],
 
69
                             'b': ['a'],
 
70
                             'c': ['b'],
 
71
                             'd': ['c'],
 
72
                             'e': ['d'],
 
73
                             'f': ['a', 'd'],
 
74
                            }
81
75
 
82
76
 
83
77
class TestSearchResultRefine(tests.TestCase):
88
82
    def test_refine(self):
89
83
        # Used when pulling from a stacked repository, so test some revisions
90
84
        # being satisfied from the stacking branch.
91
 
        self.make_graph(
92
 
            {b"tip": [b"mid"], b"mid": [b"base"], b"tag": [b"base"],
93
 
             b"base": [NULL_REVISION], NULL_REVISION: []})
94
 
        result = vf_search.SearchResult(
95
 
            {b'tip', b'tag'},
96
 
            {NULL_REVISION}, 4, {b'tip', b'mid', b'tag', b'base'})
97
 
        result = result.refine({b'tip'}, {b'mid'})
 
85
        g = self.make_graph(
 
86
            {"tip":["mid"], "mid":["base"], "tag":["base"],
 
87
             "base":[NULL_REVISION], NULL_REVISION:[]})
 
88
        result = vf_search.SearchResult({'tip', 'tag'},
 
89
            {NULL_REVISION}, 4, {'tip', 'mid', 'tag', 'base'})
 
90
        result = result.refine({'tip'}, {'mid'})
98
91
        recipe = result.get_recipe()
99
92
        # We should be starting from tag (original head) and mid (seen ref)
100
 
        self.assertEqual({b'mid', b'tag'}, recipe[1])
 
93
        self.assertEqual({'mid', 'tag'}, recipe[1])
101
94
        # We should be stopping at NULL (original stop) and tip (seen head)
102
 
        self.assertEqual({NULL_REVISION, b'tip'}, recipe[2])
 
95
        self.assertEqual({NULL_REVISION, 'tip'}, recipe[2])
103
96
        self.assertEqual(3, recipe[3])
104
 
        result = result.refine({b'mid', b'tag', b'base'},
105
 
                               {NULL_REVISION})
 
97
        result = result.refine({'mid', 'tag', 'base'},
 
98
            {NULL_REVISION})
106
99
        recipe = result.get_recipe()
107
100
        # We should be starting from nothing (NULL was known as a cut point)
108
101
        self.assertEqual(set([]), recipe[1])
110
103
        # tag (seen head) and mid(seen mid-point head). We could come back and
111
104
        # define this as not including mid, for minimal results, but it is
112
105
        # still 'correct' to include mid, and simpler/easier.
113
 
        self.assertEqual({NULL_REVISION, b'tip', b'tag', b'mid'}, recipe[2])
 
106
        self.assertEqual({NULL_REVISION, 'tip', 'tag', 'mid'}, recipe[2])
114
107
        self.assertEqual(0, recipe[3])
115
108
        self.assertTrue(result.is_empty())
116
109
 
129
122
        self.assertSearchResult([], [], 0, None)
130
123
 
131
124
    def test_ancestry_1(self):
132
 
        self.assertSearchResult([b'rev4'], [NULL_REVISION], len(ancestry_1),
 
125
        self.assertSearchResult(['rev4'], [NULL_REVISION], len(ancestry_1),
133
126
                                ancestry_1)
134
127
 
135
128
    def test_ancestry_2(self):
136
 
        self.assertSearchResult([b'rev1b', b'rev4a'], [NULL_REVISION],
 
129
        self.assertSearchResult(['rev1b', 'rev4a'], [NULL_REVISION],
137
130
                                len(ancestry_2), ancestry_2)
138
 
        self.assertSearchResult([b'rev1b', b'rev4a'], [],
139
 
                                len(ancestry_2) + 1, ancestry_2,
 
131
        self.assertSearchResult(['rev1b', 'rev4a'], [],
 
132
                                len(ancestry_2)+1, ancestry_2,
140
133
                                missing_keys=[NULL_REVISION])
141
134
 
142
135
    def test_partial_search(self):
143
 
        parent_map = dict((k, extended_history_shortcut[k])
144
 
                          for k in [b'e', b'f'])
145
 
        self.assertSearchResult([b'e', b'f'], [b'd', b'a'], 2,
146
 
                                parent_map)
147
 
        parent_map.update((k, extended_history_shortcut[k])
148
 
                          for k in [b'd', b'a'])
149
 
        self.assertSearchResult([b'e', b'f'], [b'c', NULL_REVISION], 4,
150
 
                                parent_map)
151
 
        parent_map[b'c'] = extended_history_shortcut[b'c']
152
 
        self.assertSearchResult([b'e', b'f'], [b'b'], 6,
 
136
        parent_map = dict((k,extended_history_shortcut[k])
 
137
                          for k in ['e', 'f'])
 
138
        self.assertSearchResult(['e', 'f'], ['d', 'a'], 2,
 
139
                                parent_map)
 
140
        parent_map.update((k,extended_history_shortcut[k])
 
141
                          for k in ['d', 'a'])
 
142
        self.assertSearchResult(['e', 'f'], ['c', NULL_REVISION], 4,
 
143
                                parent_map)
 
144
        parent_map['c'] = extended_history_shortcut['c']
 
145
        self.assertSearchResult(['e', 'f'], ['b'], 6,
153
146
                                parent_map, missing_keys=[NULL_REVISION])
154
 
        parent_map[b'b'] = extended_history_shortcut[b'b']
155
 
        self.assertSearchResult([b'e', b'f'], [], 7,
 
147
        parent_map['b'] = extended_history_shortcut['b']
 
148
        self.assertSearchResult(['e', 'f'], [], 7,
156
149
                                parent_map, missing_keys=[NULL_REVISION])
157
150
 
158
151
 
166
159
                         (sorted(start), sorted(stop), count))
167
160
 
168
161
    def test_empty_ancestry(self):
169
 
        self.assertSearchResult([], [], 0, {}, (), [b'tip-rev-id'], 10)
 
162
        self.assertSearchResult([], [], 0, {}, (), ['tip-rev-id'], 10)
170
163
 
171
164
    def test_ancestry_1(self):
172
 
        self.assertSearchResult([b'rev4'], [b'rev1'], 4,
173
 
                                ancestry_1, (), [b'rev1'], 10)
174
 
        self.assertSearchResult([b'rev2a', b'rev2b'], [b'rev1'], 2,
175
 
                                ancestry_1, (), [b'rev1'], 1)
 
165
        self.assertSearchResult(['rev4'], ['rev1'], 4,
 
166
                                ancestry_1, (), ['rev1'], 10)
 
167
        self.assertSearchResult(['rev2a', 'rev2b'], ['rev1'], 2,
 
168
                                ancestry_1, (), ['rev1'], 1)
 
169
 
176
170
 
177
171
    def test_multiple_heads(self):
178
 
        self.assertSearchResult([b'e', b'f'], [b'a'], 5,
179
 
                                extended_history_shortcut, (), [b'a'], 10)
 
172
        self.assertSearchResult(['e', 'f'], ['a'], 5,
 
173
                                extended_history_shortcut, (), ['a'], 10)
180
174
        # Note that even though we only take 1 step back, we find 'f', which
181
175
        # means the described search will still find d and c.
182
 
        self.assertSearchResult([b'f'], [b'a'], 4,
183
 
                                extended_history_shortcut, (), [b'a'], 1)
184
 
        self.assertSearchResult([b'f'], [b'a'], 4,
185
 
                                extended_history_shortcut, (), [b'a'], 2)
 
176
        self.assertSearchResult(['f'], ['a'], 4,
 
177
                                extended_history_shortcut, (), ['a'], 1)
 
178
        self.assertSearchResult(['f'], ['a'], 4,
 
179
                                extended_history_shortcut, (), ['a'], 2)
186
180
 
187
181
 
188
182
class TestPendingAncestryResultRefine(tests.TestCase):
194
188
        # Used when pulling from a stacked repository, so test some revisions
195
189
        # being satisfied from the stacking branch.
196
190
        g = self.make_graph(
197
 
            {b"tip": [b"mid"], b"mid": [b"base"], b"tag": [b"base"],
198
 
             b"base": [NULL_REVISION], NULL_REVISION: []})
199
 
        result = vf_search.PendingAncestryResult([b'tip', b'tag'], None)
200
 
        result = result.refine({b'tip'}, {b'mid'})
201
 
        self.assertEqual({b'mid', b'tag'}, result.heads)
202
 
        result = result.refine({b'mid', b'tag', b'base'},
203
 
                               {NULL_REVISION})
 
191
            {"tip":["mid"], "mid":["base"], "tag":["base"],
 
192
             "base":[NULL_REVISION], NULL_REVISION:[]})
 
193
        result = vf_search.PendingAncestryResult(['tip', 'tag'], None)
 
194
        result = result.refine({'tip'}, {'mid'})
 
195
        self.assertEqual({'mid', 'tag'}, result.heads)
 
196
        result = result.refine({'mid', 'tag', 'base'},
 
197
            {NULL_REVISION})
204
198
        self.assertEqual({NULL_REVISION}, result.heads)
205
199
        self.assertTrue(result.is_empty())
206
200
 
211
205
    def test_get_keys(self):
212
206
        builder = self.make_branch_builder('b')
213
207
        builder.start_series()
214
 
        builder.build_snapshot(None, [
215
 
            ('add', ('', b'root-id', 'directory', ''))],
216
 
            revision_id=b'rev-1')
217
 
        builder.build_snapshot([b'rev-1'], [], revision_id=b'rev-2')
 
208
        builder.build_snapshot('rev-1', None, [
 
209
            ('add', ('', 'root-id', 'directory', ''))])
 
210
        builder.build_snapshot('rev-2', ['rev-1'], [])
218
211
        builder.finish_series()
219
212
        repo = builder.get_branch().repository
220
213
        repo.lock_read()
221
214
        self.addCleanup(repo.unlock)
222
 
        result = vf_search.PendingAncestryResult([b'rev-2'], repo)
223
 
        self.assertEqual({b'rev-1', b'rev-2'}, set(result.get_keys()))
 
215
        result = vf_search.PendingAncestryResult(['rev-2'], repo)
 
216
        self.assertEqual({'rev-1', 'rev-2'}, set(result.get_keys()))
224
217
 
225
218
    def test_get_keys_excludes_ghosts(self):
226
219
        builder = self.make_branch_builder('b')
227
220
        builder.start_series()
228
 
        builder.build_snapshot(None, [
229
 
            ('add', ('', b'root-id', 'directory', ''))],
230
 
            revision_id=b'rev-1')
231
 
        builder.build_snapshot([b'rev-1', b'ghost'], [], revision_id=b'rev-2')
 
221
        builder.build_snapshot('rev-1', None, [
 
222
            ('add', ('', 'root-id', 'directory', ''))])
 
223
        builder.build_snapshot('rev-2', ['rev-1', 'ghost'], [])
232
224
        builder.finish_series()
233
225
        repo = builder.get_branch().repository
234
226
        repo.lock_read()
235
227
        self.addCleanup(repo.unlock)
236
 
        result = vf_search.PendingAncestryResult([b'rev-2'], repo)
237
 
        self.assertEqual(sorted([b'rev-1', b'rev-2']),
238
 
                         sorted(result.get_keys()))
 
228
        result = vf_search.PendingAncestryResult(['rev-2'], repo)
 
229
        self.assertEqual(sorted(['rev-1', 'rev-2']), sorted(result.get_keys()))
239
230
 
240
231
    def test_get_keys_excludes_null(self):
241
232
        # Make a 'graph' with an iter_ancestry that returns NULL_REVISION
243
234
        # ancestries.
244
235
        class StubGraph(object):
245
236
            def iter_ancestry(self, keys):
246
 
                return [(NULL_REVISION, ()), (b'foo', (NULL_REVISION,))]
247
 
        result = vf_search.PendingAncestryResult([b'rev-3'], None)
 
237
                return [(NULL_REVISION, ()), ('foo', (NULL_REVISION,))]
 
238
        result = vf_search.PendingAncestryResult(['rev-3'], None)
248
239
        result_keys = result._get_keys(StubGraph())
249
240
        # Only the non-null keys from the ancestry appear.
250
 
        self.assertEqual({b'foo'}, set(result_keys))
 
241
        self.assertEqual({'foo'}, set(result_keys))