/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_tree.py

  • Committer: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_tree.py
91
91
             include_root, want_unversioned)
92
92
            )
93
93
 
 
94
    def find_source_path(self, target_path, recurse='none'):
 
95
        self.calls.append(
 
96
            ('find_source_path', self.source, self.target, target_path, recurse))
 
97
 
94
98
    @classmethod
95
99
    def is_compatible(klass, source, target):
96
100
        return True
106
110
            RecordingOptimiser.calls = []
107
111
            InterTree.register_optimiser(RecordingOptimiser)
108
112
            tree = self.make_branch_and_tree('1')
 
113
            null_tree = tree.basis_tree()
109
114
            tree2 = self.make_branch_and_tree('2')
110
115
            # do a series of calls:
111
116
            # trivial usage
126
131
            InterTree._optimisers = old_optimisers
127
132
        self.assertEqual(
128
133
            [
 
134
                ('find_source_path', null_tree, tree, '', 'none'),
 
135
                ('find_source_path', null_tree, tree2, '', 'none'),
129
136
                ('compare', tree2, tree, False, None, None, False, False,
130
137
                    False),
131
138
                ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
141
148
        self.assertEqual(len(delta.added), 0)
142
149
        delta = wt.changes_from(wt.basis_tree(), include_root=True)
143
150
        self.assertEqual(len(delta.added), 1)
144
 
        self.assertEqual(delta.added[0][0], '')
 
151
        self.assertEqual(delta.added[0].path[1], '')
145
152
 
146
153
    def test_changes_from_with_require_versioned(self):
147
154
        """Ensure the require_versioned option does what's expected."""
163
170
        self.assertEqual(len(delta.added), 1)
164
171
 
165
172
 
166
 
class TestMultiWalker(TestCaseWithTransport):
167
 
 
168
 
    def assertStepOne(self, has_more, path, file_id, iterator):
169
 
        retval = _mod_tree.MultiWalker._step_one(iterator)
170
 
        if not has_more:
171
 
            self.assertIs(None, path)
172
 
            self.assertIs(None, file_id)
173
 
            self.assertEqual((False, None, None), retval)
174
 
        else:
175
 
            self.assertEqual((has_more, path, file_id),
176
 
                             (retval[0], retval[1], retval[2].file_id))
177
 
 
178
 
    def test__step_one_empty(self):
179
 
        tree = self.make_branch_and_tree('empty')
180
 
        repo = tree.branch.repository
181
 
        empty_tree = repo.revision_tree(revision.NULL_REVISION)
182
 
 
183
 
        iterator = empty_tree.iter_entries_by_dir()
184
 
        self.assertStepOne(False, None, None, iterator)
185
 
        self.assertStepOne(False, None, None, iterator)
186
 
 
187
 
    def test__step_one(self):
188
 
        tree = self.make_branch_and_tree('tree')
189
 
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
190
 
        tree.add(['a', 'b', 'b/c'], [b'a-id', b'b-id', b'c-id'])
191
 
 
192
 
        iterator = tree.iter_entries_by_dir()
193
 
        tree.lock_read()
194
 
        self.addCleanup(tree.unlock)
195
 
 
196
 
        root_id = tree.path2id('')
197
 
        self.assertStepOne(True, '', root_id, iterator)
198
 
        self.assertStepOne(True, 'a', b'a-id', iterator)
199
 
        self.assertStepOne(True, 'b', b'b-id', iterator)
200
 
        self.assertStepOne(True, 'b/c', b'c-id', iterator)
201
 
        self.assertStepOne(False, None, None, iterator)
202
 
        self.assertStepOne(False, None, None, iterator)
203
 
 
204
 
    def assertWalkerNext(self, exp_path, exp_file_id, master_has_node,
205
 
                         exp_other_paths, iterator):
206
 
        """Check what happens when we step the iterator.
207
 
 
208
 
        :param path: The path for this entry
209
 
        :param file_id: The file_id for this entry
210
 
        :param master_has_node: Does the master tree have this entry?
211
 
        :param exp_other_paths: A list of other_path values.
212
 
        :param iterator: The iterator to step
213
 
        """
214
 
        path, file_id, master_ie, other_values = next(iterator)
215
 
        self.assertEqual((exp_path, exp_file_id), (path, file_id),
216
 
                         'Master entry did not match')
217
 
        if master_has_node:
218
 
            self.assertIsNot(None, master_ie, 'master should have an entry')
219
 
        else:
220
 
            self.assertIs(None, master_ie, 'master should not have an entry')
221
 
        self.assertEqual(len(exp_other_paths), len(other_values),
222
 
                         'Wrong number of other entries')
223
 
        other_paths = []
224
 
        other_file_ids = []
225
 
        for path, ie in other_values:
226
 
            other_paths.append(path)
227
 
            if ie is None:
228
 
                other_file_ids.append(None)
229
 
            else:
230
 
                other_file_ids.append(ie.file_id)
231
 
 
232
 
        exp_file_ids = []
233
 
        for path in exp_other_paths:
234
 
            if path is None:
235
 
                exp_file_ids.append(None)
236
 
            else:
237
 
                exp_file_ids.append(file_id)
238
 
        self.assertEqual(exp_other_paths, other_paths, "Other paths incorrect")
239
 
        self.assertEqual(exp_file_ids, other_file_ids,
240
 
                         "Other file_ids incorrect")
241
 
 
242
 
    def lock_and_get_basis_and_root_id(self, tree):
243
 
        tree.lock_read()
244
 
        self.addCleanup(tree.unlock)
245
 
        basis_tree = tree.basis_tree()
246
 
        basis_tree.lock_read()
247
 
        self.addCleanup(basis_tree.unlock)
248
 
        root_id = tree.path2id('')
249
 
        return basis_tree, root_id
250
 
 
251
 
    def test_simple_stepping(self):
252
 
        tree = self.make_branch_and_tree('tree')
253
 
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
254
 
        tree.add(['a', 'b', 'b/c'], [b'a-id', b'b-id', b'c-id'])
255
 
 
256
 
        tree.commit('first', rev_id=b'first-rev-id')
257
 
 
258
 
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
259
 
 
260
 
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
261
 
        iterator = walker.iter_all()
262
 
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
263
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
264
 
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
265
 
        self.assertWalkerNext(u'b/c', b'c-id', True, [u'b/c'], iterator)
266
 
        self.assertRaises(StopIteration, next, iterator)
267
 
 
268
 
    def test_master_has_extra(self):
269
 
        tree = self.make_branch_and_tree('tree')
270
 
        self.build_tree(['tree/a', 'tree/b/', 'tree/c', 'tree/d'])
271
 
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
272
 
 
273
 
        tree.commit('first', rev_id=b'first-rev-id')
274
 
 
275
 
        tree.add(['c'], [b'c-id'])
276
 
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
277
 
 
278
 
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
279
 
        iterator = walker.iter_all()
280
 
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
281
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
282
 
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
283
 
        self.assertWalkerNext(u'c', b'c-id', True, [None], iterator)
284
 
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
285
 
        self.assertRaises(StopIteration, next, iterator)
286
 
 
287
 
    def test_master_renamed_to_earlier(self):
288
 
        """The record is still present, it just shows up early."""
289
 
        tree = self.make_branch_and_tree('tree')
290
 
        self.build_tree(['tree/a', 'tree/c', 'tree/d'])
291
 
        tree.add(['a', 'c', 'd'], [b'a-id', b'c-id', b'd-id'])
292
 
        tree.commit('first', rev_id=b'first-rev-id')
293
 
        tree.rename_one('d', 'b')
294
 
 
295
 
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
296
 
 
297
 
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
298
 
        iterator = walker.iter_all()
299
 
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
300
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
301
 
        self.assertWalkerNext(u'b', b'd-id', True, [u'd'], iterator)
302
 
        self.assertWalkerNext(u'c', b'c-id', True, [u'c'], iterator)
303
 
        self.assertRaises(StopIteration, next, iterator)
304
 
 
305
 
    def test_master_renamed_to_later(self):
306
 
        tree = self.make_branch_and_tree('tree')
307
 
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
308
 
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
309
 
        tree.commit('first', rev_id=b'first-rev-id')
310
 
        tree.rename_one('b', 'e')
311
 
 
312
 
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
313
 
 
314
 
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
315
 
        iterator = walker.iter_all()
316
 
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
317
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
318
 
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
319
 
        self.assertWalkerNext(u'e', b'b-id', True, [u'b'], iterator)
320
 
        self.assertRaises(StopIteration, next, iterator)
321
 
 
322
 
    def test_other_extra_in_middle(self):
323
 
        tree = self.make_branch_and_tree('tree')
324
 
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
325
 
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
326
 
        tree.commit('first', rev_id=b'first-rev-id')
327
 
        tree.remove(['b'])
328
 
 
329
 
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
330
 
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
331
 
        iterator = walker.iter_all()
332
 
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
333
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
334
 
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
335
 
        self.assertWalkerNext(u'b', b'b-id', False, [u'b'], iterator)
336
 
        self.assertRaises(StopIteration, next, iterator)
337
 
 
338
 
    def test_other_extra_at_end(self):
339
 
        tree = self.make_branch_and_tree('tree')
340
 
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
341
 
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
342
 
        tree.commit('first', rev_id=b'first-rev-id')
343
 
        tree.remove(['d'])
344
 
 
345
 
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
346
 
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
347
 
        iterator = walker.iter_all()
348
 
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
349
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
350
 
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
351
 
        self.assertWalkerNext(u'd', b'd-id', False, [u'd'], iterator)
352
 
        self.assertRaises(StopIteration, next, iterator)
353
 
 
354
 
    def test_others_extra_at_end(self):
355
 
        tree = self.make_branch_and_tree('tree')
356
 
        self.build_tree(['tree/a', 'tree/b', 'tree/c', 'tree/d', 'tree/e'])
357
 
        tree.add(['a', 'b', 'c', 'd', 'e'],
358
 
                 [b'a-id', b'b-id', b'c-id', b'd-id', b'e-id'])
359
 
        tree.commit('first', rev_id=b'first-rev-id')
360
 
        tree.remove(['e'])
361
 
        tree.commit('second', rev_id=b'second-rev-id')
362
 
        tree.remove(['d'])
363
 
        tree.commit('third', rev_id=b'third-rev-id')
364
 
        tree.remove(['c'])
365
 
 
366
 
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
367
 
        first_tree = tree.branch.repository.revision_tree(b'first-rev-id')
368
 
        second_tree = tree.branch.repository.revision_tree(b'second-rev-id')
369
 
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree,
370
 
                                              second_tree])
371
 
        iterator = walker.iter_all()
372
 
        self.assertWalkerNext(u'', root_id, True, [u'', u'', u''], iterator)
373
 
        self.assertWalkerNext(u'a', b'a-id', True,
374
 
                              [u'a', u'a', u'a'], iterator)
375
 
        self.assertWalkerNext(u'b', b'b-id', True,
376
 
                              [u'b', u'b', u'b'], iterator)
377
 
        self.assertWalkerNext(u'c', b'c-id', False,
378
 
                              [u'c', u'c', u'c'], iterator)
379
 
        self.assertWalkerNext(u'd', b'd-id', False,
380
 
                              [None, u'd', u'd'], iterator)
381
 
        self.assertWalkerNext(u'e', b'e-id', False,
382
 
                              [None, u'e', None], iterator)
383
 
        self.assertRaises(StopIteration, next, iterator)
384
 
 
385
 
    def test_different_file_id_in_others(self):
386
 
        tree = self.make_branch_and_tree('tree')
387
 
        self.build_tree(['tree/a', 'tree/b', 'tree/c/'])
388
 
        tree.add(['a', 'b', 'c'], [b'a-id', b'b-id', b'c-id'])
389
 
        tree.commit('first', rev_id=b'first-rev-id')
390
 
 
391
 
        tree.rename_one('b', 'c/d')
392
 
        self.build_tree(['tree/b'])
393
 
        tree.add(['b'], [b'b2-id'])
394
 
        tree.commit('second', rev_id=b'second-rev-id')
395
 
 
396
 
        tree.rename_one('a', 'c/e')
397
 
        self.build_tree(['tree/a'])
398
 
        tree.add(['a'], [b'a2-id'])
399
 
 
400
 
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
401
 
        first_tree = tree.branch.repository.revision_tree(b'first-rev-id')
402
 
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree])
403
 
 
404
 
        iterator = walker.iter_all()
405
 
        self.assertWalkerNext(u'', root_id, True, [u'', u''], iterator)
406
 
        self.assertWalkerNext(u'a', b'a2-id', True, [None, None], iterator)
407
 
        self.assertWalkerNext(u'b', b'b2-id', True, [u'b', None], iterator)
408
 
        self.assertWalkerNext(u'c', b'c-id', True, [u'c', u'c'], iterator)
409
 
        self.assertWalkerNext(u'c/d', b'b-id', True, [u'c/d', u'b'], iterator)
410
 
        self.assertWalkerNext(u'c/e', b'a-id', True, [u'a', u'a'], iterator)
411
 
        self.assertRaises(StopIteration, next, iterator)
412
 
 
413
 
    def assertLtByDirblock(self, lt_val, path1, path2):
414
 
        self.assertEqual(
415
 
            lt_val, _mod_tree.MultiWalker._lt_path_by_dirblock(path1, path2))
416
 
 
417
 
    def test__lt_path_by_dirblock(self):
418
 
        # We only support Unicode strings at this point
419
 
        self.assertRaises(
420
 
            TypeError, _mod_tree.MultiWalker._lt_path_by_dirblock, b'', b'b')
421
 
        self.assertLtByDirblock(False, u'', u'')
422
 
        self.assertLtByDirblock(False, u'a', u'a')
423
 
        self.assertLtByDirblock(False, u'a/b', u'a/b')
424
 
        self.assertLtByDirblock(False, u'a/b/c', u'a/b/c')
425
 
        self.assertLtByDirblock(False, u'a-a', u'a')
426
 
        self.assertLtByDirblock(True, u'a-a', u'a/a')
427
 
        self.assertLtByDirblock(True, u'a=a', u'a/a')
428
 
        self.assertLtByDirblock(False, u'a-a/a', u'a/a')
429
 
        self.assertLtByDirblock(False, u'a=a/a', u'a/a')
430
 
        self.assertLtByDirblock(False, u'a-a/a', u'a/a/a')
431
 
        self.assertLtByDirblock(False, u'a=a/a', u'a/a/a')
432
 
        self.assertLtByDirblock(False, u'a-a/a/a', u'a/a/a')
433
 
        self.assertLtByDirblock(False, u'a=a/a/a', u'a/a/a')
434
 
 
435
 
    def assertPathToKey(self, expected, path):
436
 
        self.assertEqual(expected, _mod_tree.MultiWalker._path_to_key(path))
437
 
 
438
 
    def test__path_to_key(self):
439
 
        self.assertPathToKey(([u''], u''), u'')
440
 
        self.assertPathToKey(([u''], u'a'), u'a')
441
 
        self.assertPathToKey(([u'a'], u'b'), u'a/b')
442
 
        self.assertPathToKey(([u'a', u'b'], u'c'), u'a/b/c')
443
 
 
444
 
 
445
173
class FindPreviousPathsTests(TestCaseWithTransport):
446
174
 
447
175
    def test_new(self):