/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 bzrlib/tests/per_branch/test_branch.py

  • Committer: Jelmer Vernooij
  • Date: 2012-01-30 14:12:36 UTC
  • mfrom: (6437.3.28 2.5)
  • mto: This revision was merged to the branch mainline in revision 6522.
  • Revision ID: jelmer@samba.org-20120130141236-66k8qj1he6q2nq3r
Merge 2.5 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/per_branch/test_branch.py
24
24
    errors,
25
25
    gpg,
26
26
    merge,
 
27
    osutils,
27
28
    urlutils,
28
29
    transport,
29
30
    remote,
76
77
        br = self.get_branch()
77
78
        br.fetch(wt.branch)
78
79
        br.generate_revision_history('rev3')
79
 
        rh = br.revision_history()
80
 
        self.assertEqual(['rev1', 'rev2', 'rev3'], rh)
81
 
        for revision_id in rh:
 
80
        for revision_id in ['rev3', 'rev2', 'rev1']:
82
81
            self.assertIsInstance(revision_id, str)
83
82
        last = br.last_revision()
84
83
        self.assertEqual('rev3', last)
114
113
        tree_a.add('vla', 'file2')
115
114
        tree_a.commit('rev2', rev_id='rev2')
116
115
 
117
 
        delta = tree_a.branch.get_revision_delta(1)
 
116
        delta = self.applyDeprecated(symbol_versioning.deprecated_in(
 
117
            (2, 5, 0)), tree_a.branch.get_revision_delta, 1)
118
118
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
119
119
        self.assertEqual([('foo', 'file1', 'file')], delta.added)
120
 
        delta = tree_a.branch.get_revision_delta(2)
 
120
        delta = self.applyDeprecated(symbol_versioning.deprecated_in(
 
121
            (2, 5, 0)), tree_a.branch.get_revision_delta, 2)
121
122
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
122
123
        self.assertEqual([('vla', 'file2', 'file')], delta.added)
123
124
 
215
216
    def test_record_initial_ghost(self):
216
217
        """Branches should support having ghosts."""
217
218
        wt = self.make_branch_and_tree('.')
 
219
        if not wt.branch.repository._format.supports_ghosts:
 
220
            raise tests.TestNotApplicable("repository format does not "
 
221
                "support ghosts")
218
222
        wt.set_parent_ids(['non:existent@rev--ision--0--2'],
219
223
            allow_leftmost_as_ghost=True)
220
224
        self.assertEqual(['non:existent@rev--ision--0--2'],
228
232
    def test_record_two_ghosts(self):
229
233
        """Recording with all ghosts works."""
230
234
        wt = self.make_branch_and_tree('.')
 
235
        if not wt.branch.repository._format.supports_ghosts:
 
236
            raise tests.TestNotApplicable("repository format does not "
 
237
                "support ghosts")
231
238
        wt.set_parent_ids([
232
239
                'foo@azkhazan-123123-abcabc',
233
240
                'wibble@fofof--20050401--1928390812',
245
252
                          self.get_branch().repository.get_revision,
246
253
                          None)
247
254
 
248
 
# TODO 20051003 RBC:
249
 
# compare the gpg-to-sign info for a commit with a ghost and
250
 
#     an identical tree without a ghost
251
 
# fetch missing should rewrite the TOC of weaves to list newly available parents.
252
 
 
253
 
    def test_sign_existing_revision(self):
254
 
        wt = self.make_branch_and_tree('.')
255
 
        branch = wt.branch
256
 
        wt.commit("base", allow_pointless=True, rev_id='A')
257
 
        from bzrlib.testament import Testament
258
 
        strategy = gpg.LoopbackGPGStrategy(None)
259
 
        branch.repository.lock_write()
260
 
        branch.repository.start_write_group()
261
 
        branch.repository.sign_revision('A', strategy)
262
 
        branch.repository.commit_write_group()
263
 
        branch.repository.unlock()
264
 
        self.assertEqual('-----BEGIN PSEUDO-SIGNED CONTENT-----\n' +
265
 
                         Testament.from_revision(branch.repository,
266
 
                         'A').as_short_text() +
267
 
                         '-----END PSEUDO-SIGNED CONTENT-----\n',
268
 
                         branch.repository.get_signature_text('A'))
269
 
 
270
 
    def test_store_signature(self):
271
 
        wt = self.make_branch_and_tree('.')
272
 
        branch = wt.branch
273
 
        branch.lock_write()
274
 
        try:
275
 
            branch.repository.start_write_group()
276
 
            try:
277
 
                branch.repository.store_revision_signature(
278
 
                    gpg.LoopbackGPGStrategy(None), 'FOO', 'A')
279
 
            except:
280
 
                branch.repository.abort_write_group()
281
 
                raise
282
 
            else:
283
 
                branch.repository.commit_write_group()
284
 
        finally:
285
 
            branch.unlock()
286
 
        # A signature without a revision should not be accessible.
287
 
        self.assertRaises(errors.NoSuchRevision,
288
 
                          branch.repository.has_signature_for_revision_id,
289
 
                          'A')
290
 
        wt.commit("base", allow_pointless=True, rev_id='A')
291
 
        self.assertEqual('-----BEGIN PSEUDO-SIGNED CONTENT-----\n'
292
 
                         'FOO-----END PSEUDO-SIGNED CONTENT-----\n',
293
 
                         branch.repository.get_signature_text('A'))
294
 
 
295
 
    def test_branch_keeps_signatures(self):
296
 
        wt = self.make_branch_and_tree('source')
297
 
        wt.commit('A', allow_pointless=True, rev_id='A')
298
 
        repo = wt.branch.repository
299
 
        repo.lock_write()
300
 
        repo.start_write_group()
301
 
        repo.sign_revision('A', gpg.LoopbackGPGStrategy(None))
302
 
        repo.commit_write_group()
303
 
        repo.unlock()
304
 
        #FIXME: clone should work to urls,
305
 
        # wt.clone should work to disks.
306
 
        self.build_tree(['target/'])
307
 
        d2 = repo.bzrdir.clone(urlutils.local_path_to_url('target'))
308
 
        self.assertEqual(repo.get_signature_text('A'),
309
 
                         d2.open_repository().get_signature_text('A'))
310
 
 
311
 
    def test_nicks(self):
312
 
        """Test explicit and implicit branch nicknames.
 
255
    def test_nicks_bzr(self):
 
256
        """Test the behaviour of branch nicks specific to bzr branches.
313
257
 
314
258
        Nicknames are implicitly the name of the branch's directory, unless an
315
259
        explicit nickname is set.  That is, an explicit nickname always
316
260
        overrides the implicit one.
 
261
 
317
262
        """
318
263
        t = self.get_transport()
319
264
        branch = self.make_branch('bzr.dev')
 
265
        if not isinstance(branch, _mod_branch.BzrBranch):
 
266
            raise tests.TestNotApplicable("not a bzr branch format")
320
267
        # The nick will be 'bzr.dev', because there is no explicit nick set.
321
268
        self.assertEqual(branch.nick, 'bzr.dev')
322
269
        # Move the branch to a different directory, 'bzr.ab'.  Now that branch
338
285
        branch.nick = u"\u1234"
339
286
        self.assertEqual(branch.nick, u"\u1234")
340
287
 
 
288
    def test_nicks(self):
 
289
        """Test explicit and implicit branch nicknames.
 
290
 
 
291
        A nickname is always available, whether set explicitly or not.
 
292
        """
 
293
        t = self.get_transport()
 
294
        branch = self.make_branch('bzr.dev')
 
295
        # An implicit nick name is set; what it is exactly depends on the
 
296
        # format.
 
297
        self.assertIsInstance(branch.nick, basestring)
 
298
        # Set the branch nick explicitly.
 
299
        branch.nick = "Aaron's branch"
 
300
        # Because the nick has been set explicitly, the nick is now always
 
301
        # "Aaron's branch".
 
302
        self.assertEqual(branch.nick, "Aaron's branch")
 
303
        branch.nick = u"\u1234"
 
304
        self.assertEqual(branch.nick, u"\u1234")
 
305
 
341
306
    def test_commit_nicks(self):
342
307
        """Nicknames are committed to the revision"""
343
308
        wt = self.make_branch_and_tree('bzr.dev')
353
318
            repo = self.make_repository('.', shared=True)
354
319
        except errors.IncompatibleFormat:
355
320
            return
 
321
        if repo.bzrdir._format.colocated_branches:
 
322
            raise tests.TestNotApplicable(
 
323
                "control dir does not support colocated branches")
356
324
        self.assertEquals(0, len(repo.bzrdir.list_branches()))
 
325
        if not self.bzrdir_format.colocated_branches:
 
326
            raise tests.TestNotApplicable("control dir format does not support "
 
327
                "colocated branches")
357
328
        try:
358
329
            child_branch1 = self.branch_format.initialize(repo.bzrdir, 
359
330
                name='branch1')
360
 
        except (errors.UninitializableFormat, errors.NoColocatedBranchSupport):
 
331
        except errors.UninitializableFormat:
361
332
            # branch references are not default init'able and
362
333
            # not all bzrdirs support colocated branches.
363
334
            return
397
368
        try:
398
369
            repo = self.make_repository('.', shared=True)
399
370
        except errors.IncompatibleFormat:
400
 
            return
 
371
            raise tests.TestNotApplicable("requires shared repository support")
401
372
        child_transport = repo.bzrdir.root_transport.clone('child')
402
373
        child_transport.mkdir('.')
403
 
        child_dir = self.bzrdir_format.initialize_on_transport(child_transport)
 
374
        try:
 
375
            child_dir = self.bzrdir_format.initialize_on_transport(child_transport)
 
376
        except errors.UninitializableFormat:
 
377
            raise tests.TestNotApplicable("control dir format not initializable")
404
378
        try:
405
379
            child_branch = self.branch_format.initialize(child_dir)
406
380
        except errors.UninitializableFormat:
429
403
        """Create a fake revision history easily."""
430
404
        tree = self.make_branch_and_tree('.')
431
405
        rev1 = tree.commit('foo')
432
 
        orig_history = tree.branch.revision_history()
 
406
        tree.lock_write()
 
407
        self.addCleanup(tree.unlock)
 
408
        graph = tree.branch.repository.get_graph()
 
409
        orig_history = list(
 
410
            graph.iter_lefthand_ancestry(
 
411
                tree.branch.last_revision(), [revision.NULL_REVISION]))
433
412
        rev2 = tree.commit('bar', allow_pointless=True)
434
413
        tree.branch.generate_revision_history(rev1)
435
 
        self.assertEqual(orig_history, tree.branch.revision_history())
 
414
        self.assertEqual(orig_history, list(
 
415
            graph.iter_lefthand_ancestry(
 
416
                tree.branch.last_revision(), [revision.NULL_REVISION])))
436
417
 
437
418
    def test_generate_revision_history_NULL_REVISION(self):
438
419
        tree = self.make_branch_and_tree('.')
439
420
        rev1 = tree.commit('foo')
 
421
        tree.lock_write()
 
422
        self.addCleanup(tree.unlock)
440
423
        tree.branch.generate_revision_history(revision.NULL_REVISION)
441
 
        self.assertEqual([], tree.branch.revision_history())
 
424
        self.assertEqual(revision.NULL_REVISION, tree.branch.last_revision())
442
425
 
443
426
    def test_create_checkout(self):
444
427
        tree_a = self.make_branch_and_tree('a')
465
448
        tree_a = self.make_branch_and_tree('a')
466
449
        rev_id = tree_a.commit('put some content in the branch')
467
450
        # open the branch via a readonly transport
468
 
        source_branch = _mod_branch.Branch.open(self.get_readonly_url('a'))
 
451
        url = self.get_readonly_url(urlutils.basename(tree_a.branch.base))
 
452
        t = transport.get_transport_from_url(url)
 
453
        if not tree_a.branch.bzrdir._format.supports_transport(t):
 
454
            raise tests.TestNotApplicable("format does not support transport")
 
455
        source_branch = _mod_branch.Branch.open(url)
469
456
        # sanity check that the test will be valid
470
457
        self.assertRaises((errors.LockError, errors.TransportNotPossible),
471
458
            source_branch.lock_write)
477
464
        tree_a = self.make_branch_and_tree('a')
478
465
        rev_id = tree_a.commit('put some content in the branch')
479
466
        # open the branch via a readonly transport
480
 
        source_branch = _mod_branch.Branch.open(self.get_readonly_url('a'))
 
467
        url = self.get_readonly_url(
 
468
            osutils.basename(tree_a.branch.base.rstrip('/')))
 
469
        t = transport.get_transport_from_url(url)
 
470
        if not tree_a.branch.bzrdir._format.supports_transport(t):
 
471
            raise tests.TestNotApplicable("format does not support transport")
 
472
        source_branch = _mod_branch.Branch.open(url)
481
473
        # sanity check that the test will be valid
482
474
        self.assertRaises((errors.LockError, errors.TransportNotPossible),
483
475
            source_branch.lock_write)
490
482
        br = tree.branch
491
483
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
492
484
            br.set_revision_history, ["rev1"])
493
 
        self.assertEquals(br.revision_history(), ["rev1"])
 
485
        self.assertEquals(br.last_revision(), "rev1")
494
486
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
495
487
            br.set_revision_history, [])
496
 
        self.assertEquals(br.revision_history(), [])
 
488
        self.assertEquals(br.last_revision(), 'null:')
497
489
 
498
490
    def test_heads_to_fetch(self):
499
491
        # heads_to_fetch is a method that returns a collection of revids that
565
557
                          _mod_branch.Branch.open_containing,
566
558
                          self.get_readonly_url('g/p/q'))
567
559
        branch = self.make_branch('.')
 
560
        if not branch.bzrdir._format.supports_transport(
 
561
            transport.get_transport_from_url(self.get_readonly_url('.'))):
 
562
            raise tests.TestNotApplicable("format does not support transport")
568
563
        branch, relpath = _mod_branch.Branch.open_containing(
569
564
            self.get_readonly_url(''))
570
565
        self.assertEqual('', relpath)
662
657
 
663
658
    def test_get_child_submit_format(self):
664
659
        branch = self.get_branch()
665
 
        branch.get_config().set_user_option('child_submit_format', '10')
 
660
        branch.get_config_stack().set('child_submit_format', '10')
666
661
        branch = self.get_branch()
667
662
        self.assertEqual('10', branch.get_child_submit_format())
668
663
 
871
866
    def test_fallbacks_not_opened(self):
872
867
        stacked = self.make_branch_with_fallback()
873
868
        self.get_transport('').rename('fallback', 'moved')
874
 
        reopened = stacked.bzrdir.open_branch(ignore_fallbacks=True)
 
869
        reopened_dir = bzrdir.BzrDir.open(stacked.base)
 
870
        reopened = reopened_dir.open_branch(ignore_fallbacks=True)
875
871
        self.assertEqual([], reopened.repository._fallback_repositories)
876
872
 
877
873
    def test_fallbacks_are_opened(self):
878
874
        stacked = self.make_branch_with_fallback()
879
 
        reopened = stacked.bzrdir.open_branch(ignore_fallbacks=False)
 
875
        reopened_dir = bzrdir.BzrDir.open(stacked.base)
 
876
        reopened = reopened_dir.open_branch(ignore_fallbacks=False)
880
877
        self.assertLength(1, reopened.repository._fallback_repositories)
881
878
 
882
879
 
890
887
            tree.add_reference(subtree)
891
888
        except errors.UnsupportedOperation:
892
889
            raise tests.TestNotApplicable('Tree cannot hold references.')
893
 
        reference_parent = tree.branch.reference_parent('subtree-id',
894
 
                                                        'subtree')
 
890
        reference_parent = tree.branch.reference_parent(
 
891
            'subtree-id',
 
892
            urlutils.relative_url(tree.branch.user_url, subtree.branch.user_url))
895
893
        self.assertEqual(subtree.branch.base, reference_parent.base)
896
894
 
897
895
    def test_reference_parent_accepts_possible_transports(self):
903
901
        except errors.UnsupportedOperation:
904
902
            raise tests.TestNotApplicable('Tree cannot hold references.')
905
903
        reference_parent = tree.branch.reference_parent('subtree-id',
906
 
            'subtree', possible_transports=[subtree.bzrdir.root_transport])
 
904
            urlutils.relative_url(
 
905
                tree.branch.user_url, subtree.branch.user_url),
 
906
            possible_transports=[subtree.bzrdir.root_transport])
907
907
 
908
908
    def test_get_reference_info(self):
909
909
        branch = self.make_branch('branch')