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

  • Committer: Vincent Ladeuil
  • Date: 2010-02-05 15:20:51 UTC
  • mto: (5013.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5014.
  • Revision ID: v.ladeuil+lp@free.fr-20100205152051-g162emr4eljaiiis
Fix test_smart.py imports. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_branch.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
22
22
also see this file.
23
23
"""
24
24
 
25
 
from cStringIO import StringIO
 
25
from StringIO import StringIO
26
26
 
27
27
from bzrlib import (
28
28
    branch as _mod_branch,
29
29
    bzrdir,
30
30
    config,
31
31
    errors,
32
 
    tests,
33
32
    trace,
34
 
    transport,
35
33
    urlutils,
36
34
    )
 
35
from bzrlib.branch import (
 
36
    Branch,
 
37
    BranchHooks,
 
38
    BranchFormat,
 
39
    BranchReferenceFormat,
 
40
    BzrBranch5,
 
41
    BzrBranchFormat5,
 
42
    BzrBranchFormat6,
 
43
    BzrBranchFormat7,
 
44
    PullResult,
 
45
    _run_with_write_locked_target,
 
46
    )
 
47
from bzrlib.bzrdir import (BzrDirMetaFormat1, BzrDirMeta1,
 
48
                           BzrDir, BzrDirFormat)
 
49
from bzrlib.transport import get_transport
37
50
 
38
51
 
39
52
class TestDefaultFormat(tests.TestCase):
40
53
 
41
54
    def test_default_format(self):
42
55
        # update this if you change the default branch format
43
 
        self.assertIsInstance(_mod_branch.BranchFormat.get_default_format(),
44
 
                _mod_branch.BzrBranchFormat7)
 
56
        self.assertIsInstance(BranchFormat.get_default_format(),
 
57
                BzrBranchFormat7)
45
58
 
46
59
    def test_default_format_is_same_as_bzrdir_default(self):
47
60
        # XXX: it might be nice if there was only one place the default was
48
61
        # set, but at the moment that's not true -- mbp 20070814 --
49
62
        # https://bugs.launchpad.net/bzr/+bug/132376
50
 
        self.assertEqual(
51
 
            _mod_branch.BranchFormat.get_default_format(),
52
 
            bzrdir.BzrDirFormat.get_default_format().get_branch_format())
 
63
        self.assertEqual(BranchFormat.get_default_format(),
 
64
                BzrDirFormat.get_default_format().get_branch_format())
53
65
 
54
66
    def test_get_set_default_format(self):
55
67
        # set the format and then set it back again
56
 
        old_format = _mod_branch.BranchFormat.get_default_format()
57
 
        _mod_branch.BranchFormat.set_default_format(SampleBranchFormat())
 
68
        old_format = BranchFormat.get_default_format()
 
69
        BranchFormat.set_default_format(SampleBranchFormat())
58
70
        try:
59
71
            # the default branch format is used by the meta dir format
60
72
            # which is not the default bzrdir format at this point
61
 
            dir = bzrdir.BzrDirMetaFormat1().initialize('memory:///')
 
73
            dir = BzrDirMetaFormat1().initialize('memory:///')
62
74
            result = dir.create_branch()
63
75
            self.assertEqual(result, 'A branch')
64
76
        finally:
65
 
            _mod_branch.BranchFormat.set_default_format(old_format)
66
 
        self.assertEqual(old_format,
67
 
                         _mod_branch.BranchFormat.get_default_format())
 
77
            BranchFormat.set_default_format(old_format)
 
78
        self.assertEqual(old_format, BranchFormat.get_default_format())
68
79
 
69
80
 
70
81
class TestBranchFormat5(tests.TestCaseWithTransport):
72
83
 
73
84
    def test_branch_format_5_uses_lockdir(self):
74
85
        url = self.get_url()
75
 
        bdir = bzrdir.BzrDirMetaFormat1().initialize(url)
76
 
        bdir.create_repository()
77
 
        branch = bdir.create_branch()
 
86
        bzrdir = BzrDirMetaFormat1().initialize(url)
 
87
        bzrdir.create_repository()
 
88
        branch = bzrdir.create_branch()
78
89
        t = self.get_transport()
79
90
        self.log("branch instance is %r" % branch)
80
 
        self.assert_(isinstance(branch, _mod_branch.BzrBranch5))
 
91
        self.assert_(isinstance(branch, BzrBranch5))
81
92
        self.assertIsDirectory('.', t)
82
93
        self.assertIsDirectory('.bzr/branch', t)
83
94
        self.assertIsDirectory('.bzr/branch/lock', t)
84
95
        branch.lock_write()
85
 
        self.addCleanup(branch.unlock)
86
 
        self.assertIsDirectory('.bzr/branch/lock/held', t)
 
96
        try:
 
97
            self.assertIsDirectory('.bzr/branch/lock/held', t)
 
98
        finally:
 
99
            branch.unlock()
87
100
 
88
101
    def test_set_push_location(self):
89
102
        from bzrlib.config import (locations_config_filename,
112
125
    # recursive section - that is, it appends the branch name.
113
126
 
114
127
 
115
 
class SampleBranchFormat(_mod_branch.BranchFormat):
 
128
class SampleBranchFormat(BranchFormat):
116
129
    """A sample format
117
130
 
118
131
    this format is initializable, unsupported to aid in testing the
123
136
        """See BzrBranchFormat.get_format_string()."""
124
137
        return "Sample branch format."
125
138
 
126
 
    def initialize(self, a_bzrdir, name=None):
 
139
    def initialize(self, a_bzrdir):
127
140
        """Format 4 branches cannot be created."""
128
 
        t = a_bzrdir.get_branch_transport(self, name=name)
 
141
        t = a_bzrdir.get_branch_transport(self)
129
142
        t.put_bytes('format', self.get_format_string())
130
143
        return 'A branch'
131
144
 
132
145
    def is_supported(self):
133
146
        return False
134
147
 
135
 
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
 
148
    def open(self, transport, _found=False, ignore_fallbacks=False):
136
149
        return "opened branch."
137
150
 
138
151
 
148
161
            dir = format._matchingbzrdir.initialize(url)
149
162
            dir.create_repository()
150
163
            format.initialize(dir)
151
 
            found_format = _mod_branch.BranchFormat.find_format(dir)
 
164
            found_format = BranchFormat.find_format(dir)
152
165
            self.failUnless(isinstance(found_format, format.__class__))
153
 
        check_format(_mod_branch.BzrBranchFormat5(), "bar")
 
166
        check_format(BzrBranchFormat5(), "bar")
154
167
 
155
168
    def test_find_format_not_branch(self):
156
169
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
157
170
        self.assertRaises(errors.NotBranchError,
158
 
                          _mod_branch.BranchFormat.find_format,
 
171
                          BranchFormat.find_format,
159
172
                          dir)
160
173
 
161
174
    def test_find_format_unknown_format(self):
162
175
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
163
176
        SampleBranchFormat().initialize(dir)
164
177
        self.assertRaises(errors.UnknownFormatError,
165
 
                          _mod_branch.BranchFormat.find_format,
 
178
                          BranchFormat.find_format,
166
179
                          dir)
167
180
 
168
181
    def test_register_unregister_format(self):
172
185
        # make a branch
173
186
        format.initialize(dir)
174
187
        # register a format for it.
175
 
        _mod_branch.BranchFormat.register_format(format)
 
188
        BranchFormat.register_format(format)
176
189
        # which branch.Open will refuse (not supported)
177
190
        self.assertRaises(errors.UnsupportedFormatError,
178
 
                          _mod_branch.Branch.open, self.get_url())
 
191
                          Branch.open, self.get_url())
179
192
        self.make_branch_and_tree('foo')
180
193
        # but open_downlevel will work
181
194
        self.assertEqual(
182
195
            format.open(dir),
183
196
            bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
184
197
        # unregister the format
185
 
        _mod_branch.BranchFormat.unregister_format(format)
 
198
        BranchFormat.unregister_format(format)
186
199
        self.make_branch_and_tree('bar')
187
200
 
188
201
 
199
212
        raise NotImplementedError(self.get_class)
200
213
 
201
214
    def test_creation(self):
202
 
        format = bzrdir.BzrDirMetaFormat1()
 
215
        format = BzrDirMetaFormat1()
203
216
        format.set_branch_format(_mod_branch.BzrBranchFormat6())
204
217
        branch = self.make_branch('a', format=format)
205
218
        self.assertIsInstance(branch, self.get_class())
420
433
        branch.lock_write()
421
434
        branch.set_reference_info('file-id', 'path2', 'location2')
422
435
        branch.unlock()
423
 
        doppelganger = _mod_branch.Branch.open('branch')
 
436
        doppelganger = Branch.open('branch')
424
437
        doppelganger.set_reference_info('file-id', 'path3', 'location3')
425
438
        self.assertEqual(('path3', 'location3'),
426
439
                         branch.get_reference_info('file-id'))
430
443
 
431
444
    def test_create_open_reference(self):
432
445
        bzrdirformat = bzrdir.BzrDirMetaFormat1()
433
 
        t = transport.get_transport(self.get_url('.'))
 
446
        t = get_transport(self.get_url('.'))
434
447
        t.mkdir('repo')
435
448
        dir = bzrdirformat.initialize(self.get_url('repo'))
436
449
        dir.create_repository()
437
450
        target_branch = dir.create_branch()
438
451
        t.mkdir('branch')
439
452
        branch_dir = bzrdirformat.initialize(self.get_url('branch'))
440
 
        made_branch = _mod_branch.BranchReferenceFormat().initialize(
441
 
            branch_dir, target_branch=target_branch)
 
453
        made_branch = BranchReferenceFormat().initialize(branch_dir, target_branch)
442
454
        self.assertEqual(made_branch.base, target_branch.base)
443
455
        opened_branch = branch_dir.open_branch()
444
456
        self.assertEqual(opened_branch.base, target_branch.base)
455
467
            _mod_branch.BranchReferenceFormat().get_reference(checkout.bzrdir))
456
468
 
457
469
 
458
 
class TestHooks(tests.TestCaseWithTransport):
 
470
class TestHooks(tests.TestCase):
459
471
 
460
472
    def test_constructor(self):
461
473
        """Check that creating a BranchHooks instance has the right defaults."""
462
 
        hooks = _mod_branch.BranchHooks()
 
474
        hooks = BranchHooks()
463
475
        self.assertTrue("set_rh" in hooks, "set_rh not in %s" % hooks)
464
476
        self.assertTrue("post_push" in hooks, "post_push not in %s" % hooks)
465
477
        self.assertTrue("post_commit" in hooks, "post_commit not in %s" % hooks)
466
478
        self.assertTrue("pre_commit" in hooks, "pre_commit not in %s" % hooks)
467
479
        self.assertTrue("post_pull" in hooks, "post_pull not in %s" % hooks)
468
 
        self.assertTrue("post_uncommit" in hooks,
469
 
                        "post_uncommit not in %s" % hooks)
 
480
        self.assertTrue("post_uncommit" in hooks, "post_uncommit not in %s" % hooks)
470
481
        self.assertTrue("post_change_branch_tip" in hooks,
471
482
                        "post_change_branch_tip not in %s" % hooks)
472
 
        self.assertTrue("post_branch_init" in hooks,
473
 
                        "post_branch_init not in %s" % hooks)
474
 
        self.assertTrue("post_switch" in hooks,
475
 
                        "post_switch not in %s" % hooks)
476
483
 
477
484
    def test_installed_hooks_are_BranchHooks(self):
478
485
        """The installed hooks object should be a BranchHooks."""
479
486
        # the installed hooks are saved in self._preserved_hooks.
480
487
        self.assertIsInstance(self._preserved_hooks[_mod_branch.Branch][1],
481
 
                              _mod_branch.BranchHooks)
482
 
 
483
 
    def test_post_branch_init_hook(self):
484
 
        calls = []
485
 
        _mod_branch.Branch.hooks.install_named_hook('post_branch_init',
486
 
            calls.append, None)
487
 
        self.assertLength(0, calls)
488
 
        branch = self.make_branch('a')
489
 
        self.assertLength(1, calls)
490
 
        params = calls[0]
491
 
        self.assertIsInstance(params, _mod_branch.BranchInitHookParams)
492
 
        self.assertTrue(hasattr(params, 'bzrdir'))
493
 
        self.assertTrue(hasattr(params, 'branch'))
494
 
 
495
 
    def test_post_switch_hook(self):
496
 
        from bzrlib import switch
497
 
        calls = []
498
 
        _mod_branch.Branch.hooks.install_named_hook('post_switch',
499
 
            calls.append, None)
500
 
        tree = self.make_branch_and_tree('branch-1')
501
 
        self.build_tree(['branch-1/file-1'])
502
 
        tree.add('file-1')
503
 
        tree.commit('rev1')
504
 
        to_branch = tree.bzrdir.sprout('branch-2').open_branch()
505
 
        self.build_tree(['branch-1/file-2'])
506
 
        tree.add('file-2')
507
 
        tree.remove('file-1')
508
 
        tree.commit('rev2')
509
 
        checkout = tree.branch.create_checkout('checkout')
510
 
        self.assertLength(0, calls)
511
 
        switch.switch(checkout.bzrdir, to_branch)
512
 
        self.assertLength(1, calls)
513
 
        params = calls[0]
514
 
        self.assertIsInstance(params, _mod_branch.SwitchHookParams)
515
 
        self.assertTrue(hasattr(params, 'to_branch'))
516
 
        self.assertTrue(hasattr(params, 'revision_id'))
517
 
 
518
 
 
519
 
class TestBranchOptions(tests.TestCaseWithTransport):
520
 
 
521
 
    def setUp(self):
522
 
        super(TestBranchOptions, self).setUp()
523
 
        self.branch = self.make_branch('.')
524
 
        self.config = self.branch.get_config()
525
 
 
526
 
    def check_append_revisions_only(self, expected_value, value=None):
527
 
        """Set append_revisions_only in config and check its interpretation."""
528
 
        if value is not None:
529
 
            self.config.set_user_option('append_revisions_only', value)
530
 
        self.assertEqual(expected_value,
531
 
                         self.branch._get_append_revisions_only())
532
 
 
533
 
    def test_valid_append_revisions_only(self):
534
 
        self.assertEquals(None,
535
 
                          self.config.get_user_option('append_revisions_only'))
536
 
        self.check_append_revisions_only(None)
537
 
        self.check_append_revisions_only(False, 'False')
538
 
        self.check_append_revisions_only(True, 'True')
539
 
        # The following values will cause compatibility problems on projects
540
 
        # using older bzr versions (<2.2) but are accepted
541
 
        self.check_append_revisions_only(False, 'false')
542
 
        self.check_append_revisions_only(True, 'true')
543
 
 
544
 
    def test_invalid_append_revisions_only(self):
545
 
        """Ensure warning is noted on invalid settings"""
546
 
        self.warnings = []
547
 
        def warning(*args):
548
 
            self.warnings.append(args[0] % args[1:])
549
 
        self.overrideAttr(trace, 'warning', warning)
550
 
        self.check_append_revisions_only(None, 'not-a-bool')
551
 
        self.assertLength(1, self.warnings)
552
 
        self.assertEqual(
553
 
            'Value "not-a-bool" is not a boolean for "append_revisions_only"',
554
 
            self.warnings[0])
 
488
            BranchHooks)
555
489
 
556
490
 
557
491
class TestPullResult(tests.TestCase):
558
492
 
559
493
    def test_pull_result_to_int(self):
560
494
        # to support old code, the pull result can be used as an int
561
 
        r = _mod_branch.PullResult()
 
495
        r = PullResult()
562
496
        r.old_revno = 10
563
497
        r.new_revno = 20
564
498
        # this usage of results is not recommended for new code (because it
568
502
        self.assertEqual(a, "10 revisions pulled")
569
503
 
570
504
    def test_report_changed(self):
571
 
        r = _mod_branch.PullResult()
 
505
        r = PullResult()
572
506
        r.old_revid = "old-revid"
573
507
        r.old_revno = 10
574
508
        r.new_revid = "new-revid"
578
512
        self.assertEqual("Now on revision 20.\n", f.getvalue())
579
513
 
580
514
    def test_report_unchanged(self):
581
 
        r = _mod_branch.PullResult()
 
515
        r = PullResult()
582
516
        r.old_revid = "same-revid"
583
517
        r.new_revid = "same-revid"
584
518
        f = StringIO()
627
561
 
628
562
    def test_success_unlocks(self):
629
563
        lockable = _StubLockable(self._calls)
630
 
        result = _mod_branch._run_with_write_locked_target(
 
564
        result = _run_with_write_locked_target(
631
565
            lockable, self.func_that_returns_ok)
632
566
        self.assertEqual('ok', result)
633
567
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
635
569
    def test_exception_unlocks_and_propagates(self):
636
570
        lockable = _StubLockable(self._calls)
637
571
        self.assertRaises(_ErrorFromCallable,
638
 
                          _mod_branch._run_with_write_locked_target,
639
 
                          lockable, self.func_that_raises)
 
572
            _run_with_write_locked_target, lockable, self.func_that_raises)
640
573
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
641
574
 
642
575
    def test_callable_succeeds_but_error_during_unlock(self):
643
576
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
644
577
        self.assertRaises(_ErrorFromUnlock,
645
 
                          _mod_branch._run_with_write_locked_target,
646
 
                          lockable, self.func_that_returns_ok)
 
578
            _run_with_write_locked_target, lockable, self.func_that_returns_ok)
647
579
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
648
580
 
649
581
    def test_error_during_unlock_does_not_mask_original_error(self):
650
582
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
651
583
        self.assertRaises(_ErrorFromCallable,
652
 
                          _mod_branch._run_with_write_locked_target,
653
 
                          lockable, self.func_that_raises)
 
584
            _run_with_write_locked_target, lockable, self.func_that_raises)
654
585
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
655
586
 
656
587