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

  • Committer: Jelmer Vernooij
  • Date: 2018-05-22 02:05:12 UTC
  • mto: (6973.12.2 python3-k)
  • mto: This revision was merged to the branch mainline in revision 6992.
  • Revision ID: jelmer@jelmer.uk-20180522020512-btpj2jchdlehi3en
Add more bees.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_branchbuilder.py
119
119
        rev_id1 = builder.build_snapshot(None,
120
120
            [('add', ('', 'a-root-id', 'directory', None)),
121
121
             ('add', ('a', 'a-id', 'file', 'contents'))],
122
 
            revision_id='A-id')
 
122
            revision_id=b'A-id')
123
123
        self.assertEqual('A-id', rev_id1)
124
124
        return builder
125
125
 
127
127
        builder = self.build_a_rev()
128
128
        branch = builder.get_branch()
129
129
        self.assertEqual((1, 'A-id'), branch.last_revision_info())
130
 
        rev_tree = branch.repository.revision_tree('A-id')
 
130
        rev_tree = branch.repository.revision_tree(b'A-id')
131
131
        rev_tree.lock_read()
132
132
        self.addCleanup(rev_tree.unlock)
133
133
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
138
138
        builder = self.build_a_rev()
139
139
        rev_id2 = builder.build_snapshot(None,
140
140
            [('add', ('b', 'b-id', 'file', 'content_b'))],
141
 
            revision_id='B-id')
 
141
            revision_id=b'B-id')
142
142
        self.assertEqual('B-id', rev_id2)
143
143
        branch = builder.get_branch()
144
144
        self.assertEqual((2, rev_id2), branch.last_revision_info())
154
154
        builder = self.build_a_rev()
155
155
        rev_id2 = builder.build_snapshot(None,
156
156
            [('add', ('b', 'b-id', 'directory', None))],
157
 
            revision_id='B-id')
158
 
        rev_tree = builder.get_branch().repository.revision_tree('B-id')
 
157
            revision_id=b'B-id')
 
158
        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
159
159
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
160
160
                              (u'a', 'a-id', 'file'),
161
161
                              (u'b', 'b-id', 'directory'),
201
201
        builder = self.build_a_rev()
202
202
        rev_id2 = builder.build_snapshot(None,
203
203
            [('modify', ('a', 'new\ncontent\n'))],
204
 
            revision_id='B-id')
 
204
            revision_id=b'B-id')
205
205
        self.assertEqual('B-id', rev_id2)
206
206
        branch = builder.get_branch()
207
207
        rev_tree = branch.repository.revision_tree(rev_id2)
213
213
    def test_delete_file(self):
214
214
        builder = self.build_a_rev()
215
215
        rev_id2 = builder.build_snapshot(None,
216
 
            [('unversion', 'a')], revision_id='B-id')
 
216
            [('unversion', 'a')], revision_id=b'B-id')
217
217
        self.assertEqual('B-id', rev_id2)
218
218
        branch = builder.get_branch()
219
219
        rev_tree = branch.repository.revision_tree(rev_id2)
228
228
             ('add', ('b/c', 'c-id', 'file', 'foo\n')),
229
229
             ('add', ('b/d', 'd-id', 'directory', None)),
230
230
             ('add', ('b/d/e', 'e-id', 'file', 'eff\n')),
231
 
            ], revision_id='B-id')
232
 
        rev_tree = builder.get_branch().repository.revision_tree('B-id')
 
231
            ], revision_id=b'B-id')
 
232
        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
233
233
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
234
234
                              (u'a', 'a-id', 'file'),
235
235
                              (u'b', 'b-id', 'directory'),
239
239
        # Removing a directory removes all child dirs
240
240
        builder.build_snapshot(
241
241
                None, [('unversion', 'b')],
242
 
                revision_id='C-id')
243
 
        rev_tree = builder.get_branch().repository.revision_tree('C-id')
 
242
                revision_id=b'C-id')
 
243
        rev_tree = builder.get_branch().repository.revision_tree(b'C-id')
244
244
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
245
245
                              (u'a', 'a-id', 'file'),
246
246
                             ], rev_tree)
249
249
        builder = self.build_a_rev()
250
250
        e = self.assertRaises(ValueError,
251
251
            builder.build_snapshot, None, [('weirdo', ('foo',))],
252
 
            revision_id='B-id')
 
252
            revision_id=b'B-id')
253
253
        self.assertEqual('Unknown build action: "weirdo"', str(e))
254
254
 
255
255
    def test_rename(self):
256
256
        builder = self.build_a_rev()
257
257
        builder.build_snapshot(None,
258
 
            [('rename', ('a', 'b'))], revision_id='B-id')
259
 
        rev_tree = builder.get_branch().repository.revision_tree('B-id')
 
258
            [('rename', ('a', 'b'))], revision_id=b'B-id')
 
259
        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
260
260
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
261
261
                              (u'b', 'a-id', 'file')], rev_tree)
262
262
 
264
264
        builder = self.build_a_rev()
265
265
        builder.build_snapshot(None,
266
266
            [('add', ('dir', 'dir-id', 'directory', None)),
267
 
             ('rename', ('a', 'dir/a'))], revision_id='B-id')
268
 
        rev_tree = builder.get_branch().repository.revision_tree('B-id')
 
267
             ('rename', ('a', 'dir/a'))], revision_id=b'B-id')
 
268
        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
269
269
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
270
270
                              (u'dir', 'dir-id', 'directory'),
271
271
                              (u'dir/a', 'a-id', 'file')], rev_tree)
275
275
        builder.build_snapshot(None,
276
276
            [('add', ('dir', 'dir-id', 'directory', None)),
277
277
             ('rename', ('a', 'dir/a'))],
278
 
            revision_id='B-id')
 
278
            revision_id=b'B-id')
279
279
        builder.build_snapshot(None,
280
280
            [('rename', ('dir/a', 'a')),
281
 
             ('unversion', 'dir')], revision_id='C-id')
282
 
        rev_tree = builder.get_branch().repository.revision_tree('C-id')
 
281
             ('unversion', 'dir')], revision_id=b'C-id')
 
282
        rev_tree = builder.get_branch().repository.revision_tree(b'C-id')
283
283
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
284
284
                              (u'a', 'a-id', 'file')], rev_tree)
285
285
 
289
289
        self.addCleanup(builder.finish_series)
290
290
        builder.build_snapshot(['A-id'],
291
291
            [('modify', ('a', 'new\ncontent\n'))],
292
 
            revision_id='B-id')
 
292
            revision_id=b'B-id')
293
293
        builder.build_snapshot(['A-id'],
294
294
            [('add', ('c', 'c-id', 'file', 'alt\ncontent\n'))],
295
 
            revision_id='C-id')
 
295
            revision_id=b'C-id')
296
296
        # We should now have a graph:
297
297
        #   A
298
298
        #   |\
301
301
        repo = builder.get_branch().repository
302
302
        self.assertEqual({'B-id': ('A-id',), 'C-id': ('A-id',)},
303
303
                         repo.get_parent_map(['B-id', 'C-id']))
304
 
        b_tree = repo.revision_tree('B-id')
 
304
        b_tree = repo.revision_tree(b'B-id')
305
305
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
306
306
                              (u'a', 'a-id', 'file'),
307
307
                             ], b_tree)
308
308
        self.assertEqual('new\ncontent\n', b_tree.get_file_text('a'))
309
309
 
310
310
        # We should still be using the content from A in C, not from B
311
 
        c_tree = repo.revision_tree('C-id')
 
311
        c_tree = repo.revision_tree(b'C-id')
312
312
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
313
313
                              (u'a', 'a-id', 'file'),
314
314
                              (u'c', 'c-id', 'file'),
322
322
        self.addCleanup(builder.finish_series)
323
323
        builder.build_snapshot(['A-id'],
324
324
            [('add', ('b', 'b-id', 'file', 'b\ncontent\n'))],
325
 
            revision_id='B-id')
 
325
            revision_id=b'B-id')
326
326
        builder.build_snapshot(['A-id'],
327
327
            [('add', ('c', 'c-id', 'file', 'alt\ncontent\n'))],
328
 
            revision_id='C-id')
329
 
        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
 
328
            revision_id=b'C-id')
 
329
        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
330
330
        repo = builder.get_branch().repository
331
331
        self.assertEqual({'B-id': ('A-id',), 'C-id': ('A-id',),
332
332
                          'D-id': ('B-id', 'C-id')},
333
333
                         repo.get_parent_map(['B-id', 'C-id', 'D-id']))
334
 
        d_tree = repo.revision_tree('D-id')
 
334
        d_tree = repo.revision_tree(b'D-id')
335
335
        # Note: by default a merge node does *not* pull in the changes from the
336
336
        #       merged tree, you have to supply it yourself.
337
337
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
345
345
        self.addCleanup(builder.finish_series)
346
346
        builder.build_snapshot(['A-id'],
347
347
            [('add', ('b', 'b-id', 'file', 'b\ncontent\n'))],
348
 
            revision_id='B-id')
 
348
            revision_id=b'B-id')
349
349
        builder.build_snapshot(['A-id'],
350
350
            [('add', ('c', 'c-id', 'file', 'alt\ncontent\n'))],
351
 
            revision_id='C-id')
 
351
            revision_id=b'C-id')
352
352
        builder.build_snapshot(['B-id', 'C-id'],
353
353
            [('add', ('c', 'c-id', 'file', 'alt\ncontent\n'))],
354
 
            revision_id='D-id')
 
354
            revision_id=b'D-id')
355
355
        repo = builder.get_branch().repository
356
356
        self.assertEqual({'B-id': ('A-id',), 'C-id': ('A-id',),
357
357
                          'D-id': ('B-id', 'C-id')},
358
358
                         repo.get_parent_map(['B-id', 'C-id', 'D-id']))
359
 
        d_tree = repo.revision_tree('D-id')
 
359
        d_tree = repo.revision_tree(b'D-id')
360
360
        self.assertTreeShape([(u'', 'a-root-id', 'directory'),
361
361
                              (u'a', 'a-id', 'file'),
362
362
                              (u'b', 'b-id', 'file'),
372
372
        self.addCleanup(builder.finish_series)
373
373
        builder.build_snapshot([],
374
374
            [('add', ('', None, 'directory', None))],
375
 
            revision_id='B-id')
 
375
            revision_id=b'B-id')
376
376
        # We should now have a graph:
377
377
        #   A B
378
378
        # And not A => B
400
400
        try:
401
401
            builder.build_snapshot(['ghost'],
402
402
                [('add', ('', 'ROOT_ID', 'directory', ''))],
403
 
                allow_leftmost_as_ghost=True, revision_id='tip')
 
403
                allow_leftmost_as_ghost=True, revision_id=b'tip')
404
404
        finally:
405
405
            builder.finish_series()
406
406
        b = builder.get_branch()
414
414
        builder.start_series()
415
415
        builder.build_snapshot(None,
416
416
            [('add', ('', 'TREE_ROOT', 'directory', ''))],
417
 
            revision_id='rev-1')
 
417
            revision_id=b'rev-1')
418
418
        builder.build_snapshot(None,
419
419
            [('unversion', ''),
420
420
             ('add', ('', 'my-root', 'directory', ''))],
421
 
            revision_id='rev-2')
 
421
            revision_id=b'rev-2')
422
422
        builder.finish_series()
423
 
        rev_tree = builder.get_branch().repository.revision_tree('rev-2')
 
423
        rev_tree = builder.get_branch().repository.revision_tree(b'rev-2')
424
424
        self.assertTreeShape([(u'', 'my-root', 'directory')], rev_tree)
425
425
 
426
426
    def test_empty_flush(self):
429
429
        builder.start_series()
430
430
        builder.build_snapshot(None,
431
431
            [('add', ('', 'TREE_ROOT', 'directory', ''))],
432
 
            revision_id='rev-1')
433
 
        builder.build_snapshot(None, [('flush', None)], revision_id='rev-2')
 
432
            revision_id=b'rev-1')
 
433
        builder.build_snapshot(None, [('flush', None)], revision_id=b'rev-2')
434
434
        builder.finish_series()
435
 
        rev_tree = builder.get_branch().repository.revision_tree('rev-2')
 
435
        rev_tree = builder.get_branch().repository.revision_tree(b'rev-2')
436
436
        self.assertTreeShape([(u'', 'TREE_ROOT', 'directory')], rev_tree)
437
437
 
438
438
    def test_kind_change(self):
444
444
        builder.build_snapshot(None,
445
445
            [('add', (u'', 'a-root-id', 'directory', None)),
446
446
             ('add', (u'a', 'a-id', 'file', 'content\n'))],
447
 
            revision_id='A-id')
 
447
            revision_id=b'A-id')
448
448
        builder.build_snapshot(None,
449
449
            [('unversion', 'a'),
450
450
             ('flush', None),
451
451
             ('add', (u'a', 'a-id', 'directory', None))],
452
 
            revision_id='B-id')
 
452
            revision_id=b'B-id')
453
453
        builder.finish_series()
454
 
        rev_tree = builder.get_branch().repository.revision_tree('B-id')
 
454
        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
455
455
        self.assertTreeShape(
456
456
            [(u'', 'a-root-id', 'directory'), (u'a', 'a-id', 'directory')],
457
457
            rev_tree)
465
465
        builder.build_snapshot(None,
466
466
            [('add', (u'', 'orig-root', 'directory', None)),
467
467
             ('add', (u'dir', 'dir-id', 'directory', None))],
468
 
            revision_id='A-id')
 
468
            revision_id=b'A-id')
469
469
        builder.build_snapshot(None,
470
470
            [('unversion', ''),  # implicitly unversions all children
471
471
             ('flush', None),
472
472
             ('add', (u'', 'dir-id', 'directory', None))],
473
 
            revision_id='B-id')
 
473
            revision_id=b'B-id')
474
474
        builder.finish_series()
475
 
        rev_tree = builder.get_branch().repository.revision_tree('B-id')
 
475
        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
476
476
        self.assertTreeShape([(u'', 'dir-id', 'directory')], rev_tree)
477
477