← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_branch.py

  • Committer: John Arbash Meinel
  • Date: 2010-02-10 17:52:08 UTC
  • mfrom: (5021 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5023.
  • Revision ID: john@arbash-meinel.com-20100210175208-bubuwav4uqigu291
Merge bzr.dev 5021 to resolve NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_branch.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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 StringIO import StringIO
 
25
from cStringIO 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,
32
33
    trace,
 
34
    transport,
33
35
    urlutils,
34
36
    )
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.errors import (NotBranchError,
50
 
                           UnknownFormatError,
51
 
                           UnknownHook,
52
 
                           UnsupportedFormatError,
53
 
                           )
54
 
 
55
 
from bzrlib.tests import TestCase, TestCaseWithTransport
56
 
from bzrlib.transport import get_transport
57
 
 
58
 
 
59
 
class TestDefaultFormat(TestCase):
 
37
 
 
38
 
 
39
class TestDefaultFormat(tests.TestCase):
60
40
 
61
41
    def test_default_format(self):
62
42
        # update this if you change the default branch format
63
 
        self.assertIsInstance(BranchFormat.get_default_format(),
64
 
                BzrBranchFormat7)
 
43
        self.assertIsInstance(_mod_branch.BranchFormat.get_default_format(),
 
44
                _mod_branch.BzrBranchFormat7)
65
45
 
66
46
    def test_default_format_is_same_as_bzrdir_default(self):
67
47
        # XXX: it might be nice if there was only one place the default was
68
48
        # set, but at the moment that's not true -- mbp 20070814 --
69
49
        # https://bugs.launchpad.net/bzr/+bug/132376
70
 
        self.assertEqual(BranchFormat.get_default_format(),
71
 
                BzrDirFormat.get_default_format().get_branch_format())
 
50
        self.assertEqual(
 
51
            _mod_branch.BranchFormat.get_default_format(),
 
52
            bzrdir.BzrDirFormat.get_default_format().get_branch_format())
72
53
 
73
54
    def test_get_set_default_format(self):
74
55
        # set the format and then set it back again
75
 
        old_format = BranchFormat.get_default_format()
76
 
        BranchFormat.set_default_format(SampleBranchFormat())
 
56
        old_format = _mod_branch.BranchFormat.get_default_format()
 
57
        _mod_branch.BranchFormat.set_default_format(SampleBranchFormat())
77
58
        try:
78
59
            # the default branch format is used by the meta dir format
79
60
            # which is not the default bzrdir format at this point
80
 
            dir = BzrDirMetaFormat1().initialize('memory:///')
 
61
            dir = bzrdir.BzrDirMetaFormat1().initialize('memory:///')
81
62
            result = dir.create_branch()
82
63
            self.assertEqual(result, 'A branch')
83
64
        finally:
84
 
            BranchFormat.set_default_format(old_format)
85
 
        self.assertEqual(old_format, BranchFormat.get_default_format())
86
 
 
87
 
 
88
 
class TestBranchFormat5(TestCaseWithTransport):
 
65
            _mod_branch.BranchFormat.set_default_format(old_format)
 
66
        self.assertEqual(old_format,
 
67
                         _mod_branch.BranchFormat.get_default_format())
 
68
 
 
69
 
 
70
class TestBranchFormat5(tests.TestCaseWithTransport):
89
71
    """Tests specific to branch format 5"""
90
72
 
91
73
    def test_branch_format_5_uses_lockdir(self):
92
74
        url = self.get_url()
93
 
        bzrdir = BzrDirMetaFormat1().initialize(url)
94
 
        bzrdir.create_repository()
95
 
        branch = bzrdir.create_branch()
 
75
        bdir = bzrdir.BzrDirMetaFormat1().initialize(url)
 
76
        bdir.create_repository()
 
77
        branch = bdir.create_branch()
96
78
        t = self.get_transport()
97
79
        self.log("branch instance is %r" % branch)
98
 
        self.assert_(isinstance(branch, BzrBranch5))
 
80
        self.assert_(isinstance(branch, _mod_branch.BzrBranch5))
99
81
        self.assertIsDirectory('.', t)
100
82
        self.assertIsDirectory('.bzr/branch', t)
101
83
        self.assertIsDirectory('.bzr/branch/lock', t)
102
84
        branch.lock_write()
103
 
        try:
104
 
            self.assertIsDirectory('.bzr/branch/lock/held', t)
105
 
        finally:
106
 
            branch.unlock()
 
85
        self.addCleanup(branch.unlock)
 
86
        self.assertIsDirectory('.bzr/branch/lock/held', t)
107
87
 
108
88
    def test_set_push_location(self):
109
89
        from bzrlib.config import (locations_config_filename,
132
112
    # recursive section - that is, it appends the branch name.
133
113
 
134
114
 
135
 
class SampleBranchFormat(BranchFormat):
 
115
class SampleBranchFormat(_mod_branch.BranchFormat):
136
116
    """A sample format
137
117
 
138
118
    this format is initializable, unsupported to aid in testing the
156
136
        return "opened branch."
157
137
 
158
138
 
159
 
class TestBzrBranchFormat(TestCaseWithTransport):
 
139
class TestBzrBranchFormat(tests.TestCaseWithTransport):
160
140
    """Tests for the BzrBranchFormat facility."""
161
141
 
162
142
    def test_find_format(self):
168
148
            dir = format._matchingbzrdir.initialize(url)
169
149
            dir.create_repository()
170
150
            format.initialize(dir)
171
 
            found_format = BranchFormat.find_format(dir)
 
151
            found_format = _mod_branch.BranchFormat.find_format(dir)
172
152
            self.failUnless(isinstance(found_format, format.__class__))
173
 
        check_format(BzrBranchFormat5(), "bar")
 
153
        check_format(_mod_branch.BzrBranchFormat5(), "bar")
174
154
 
175
155
    def test_find_format_not_branch(self):
176
156
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
177
 
        self.assertRaises(NotBranchError,
178
 
                          BranchFormat.find_format,
 
157
        self.assertRaises(errors.NotBranchError,
 
158
                          _mod_branch.BranchFormat.find_format,
179
159
                          dir)
180
160
 
181
161
    def test_find_format_unknown_format(self):
182
162
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
183
163
        SampleBranchFormat().initialize(dir)
184
 
        self.assertRaises(UnknownFormatError,
185
 
                          BranchFormat.find_format,
 
164
        self.assertRaises(errors.UnknownFormatError,
 
165
                          _mod_branch.BranchFormat.find_format,
186
166
                          dir)
187
167
 
188
168
    def test_register_unregister_format(self):
192
172
        # make a branch
193
173
        format.initialize(dir)
194
174
        # register a format for it.
195
 
        BranchFormat.register_format(format)
 
175
        _mod_branch.BranchFormat.register_format(format)
196
176
        # which branch.Open will refuse (not supported)
197
 
        self.assertRaises(UnsupportedFormatError, Branch.open, self.get_url())
 
177
        self.assertRaises(errors.UnsupportedFormatError,
 
178
                          _mod_branch.Branch.open, self.get_url())
198
179
        self.make_branch_and_tree('foo')
199
180
        # but open_downlevel will work
200
 
        self.assertEqual(format.open(dir), bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
 
181
        self.assertEqual(
 
182
            format.open(dir),
 
183
            bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
201
184
        # unregister the format
202
 
        BranchFormat.unregister_format(format)
 
185
        _mod_branch.BranchFormat.unregister_format(format)
203
186
        self.make_branch_and_tree('bar')
204
187
 
205
188
 
216
199
        raise NotImplementedError(self.get_class)
217
200
 
218
201
    def test_creation(self):
219
 
        format = BzrDirMetaFormat1()
 
202
        format = bzrdir.BzrDirMetaFormat1()
220
203
        format.set_branch_format(_mod_branch.BzrBranchFormat6())
221
204
        branch = self.make_branch('a', format=format)
222
205
        self.assertIsInstance(branch, self.get_class())
309
292
                         'locations.conf')
310
293
 
311
294
 
312
 
class TestBranch6(TestBranch67, TestCaseWithTransport):
 
295
class TestBranch6(TestBranch67, tests.TestCaseWithTransport):
313
296
 
314
297
    def get_class(self):
315
298
        return _mod_branch.BzrBranch6
330
313
        self.assertRaises(errors.UnstackableBranchFormat, branch.get_stacked_on_url)
331
314
 
332
315
 
333
 
class TestBranch7(TestBranch67, TestCaseWithTransport):
 
316
class TestBranch7(TestBranch67, tests.TestCaseWithTransport):
334
317
 
335
318
    def get_class(self):
336
319
        return _mod_branch.BzrBranch7
380
363
        self.assertTrue(branch.repository.has_revision(revid))
381
364
 
382
365
 
383
 
class BzrBranch8(TestCaseWithTransport):
 
366
class BzrBranch8(tests.TestCaseWithTransport):
384
367
 
385
368
    def make_branch(self, location, format=None):
386
369
        if format is None:
387
370
            format = bzrdir.format_registry.make_bzrdir('1.9')
388
371
            format.set_branch_format(_mod_branch.BzrBranchFormat8())
389
 
        return TestCaseWithTransport.make_branch(self, location, format=format)
 
372
        return tests.TestCaseWithTransport.make_branch(
 
373
            self, location, format=format)
390
374
 
391
375
    def create_branch_with_reference(self):
392
376
        branch = self.make_branch('branch')
436
420
        branch.lock_write()
437
421
        branch.set_reference_info('file-id', 'path2', 'location2')
438
422
        branch.unlock()
439
 
        doppelganger = Branch.open('branch')
 
423
        doppelganger = _mod_branch.Branch.open('branch')
440
424
        doppelganger.set_reference_info('file-id', 'path3', 'location3')
441
425
        self.assertEqual(('path3', 'location3'),
442
426
                         branch.get_reference_info('file-id'))
443
427
 
444
 
class TestBranchReference(TestCaseWithTransport):
 
428
class TestBranchReference(tests.TestCaseWithTransport):
445
429
    """Tests for the branch reference facility."""
446
430
 
447
431
    def test_create_open_reference(self):
448
432
        bzrdirformat = bzrdir.BzrDirMetaFormat1()
449
 
        t = get_transport(self.get_url('.'))
 
433
        t = transport.get_transport(self.get_url('.'))
450
434
        t.mkdir('repo')
451
435
        dir = bzrdirformat.initialize(self.get_url('repo'))
452
436
        dir.create_repository()
453
437
        target_branch = dir.create_branch()
454
438
        t.mkdir('branch')
455
439
        branch_dir = bzrdirformat.initialize(self.get_url('branch'))
456
 
        made_branch = BranchReferenceFormat().initialize(branch_dir, target_branch)
 
440
        made_branch = _mod_branch.BranchReferenceFormat().initialize(
 
441
            branch_dir, target_branch)
457
442
        self.assertEqual(made_branch.base, target_branch.base)
458
443
        opened_branch = branch_dir.open_branch()
459
444
        self.assertEqual(opened_branch.base, target_branch.base)
470
455
            _mod_branch.BranchReferenceFormat().get_reference(checkout.bzrdir))
471
456
 
472
457
 
473
 
class TestHooks(TestCase):
 
458
class TestHooks(tests.TestCase):
474
459
 
475
460
    def test_constructor(self):
476
461
        """Check that creating a BranchHooks instance has the right defaults."""
477
 
        hooks = BranchHooks()
 
462
        hooks = _mod_branch.BranchHooks()
478
463
        self.assertTrue("set_rh" in hooks, "set_rh not in %s" % hooks)
479
464
        self.assertTrue("post_push" in hooks, "post_push not in %s" % hooks)
480
465
        self.assertTrue("post_commit" in hooks, "post_commit not in %s" % hooks)
481
466
        self.assertTrue("pre_commit" in hooks, "pre_commit not in %s" % hooks)
482
467
        self.assertTrue("post_pull" in hooks, "post_pull not in %s" % hooks)
483
 
        self.assertTrue("post_uncommit" in hooks, "post_uncommit not in %s" % hooks)
 
468
        self.assertTrue("post_uncommit" in hooks,
 
469
                        "post_uncommit not in %s" % hooks)
484
470
        self.assertTrue("post_change_branch_tip" in hooks,
485
471
                        "post_change_branch_tip not in %s" % hooks)
486
472
 
488
474
        """The installed hooks object should be a BranchHooks."""
489
475
        # the installed hooks are saved in self._preserved_hooks.
490
476
        self.assertIsInstance(self._preserved_hooks[_mod_branch.Branch][1],
491
 
            BranchHooks)
492
 
 
493
 
 
494
 
class TestPullResult(TestCase):
 
477
                              _mod_branch.BranchHooks)
 
478
 
 
479
 
 
480
class TestPullResult(tests.TestCase):
495
481
 
496
482
    def test_pull_result_to_int(self):
497
483
        # to support old code, the pull result can be used as an int
498
 
        r = PullResult()
 
484
        r = _mod_branch.PullResult()
499
485
        r.old_revno = 10
500
486
        r.new_revno = 20
501
487
        # this usage of results is not recommended for new code (because it
505
491
        self.assertEqual(a, "10 revisions pulled")
506
492
 
507
493
    def test_report_changed(self):
508
 
        r = PullResult()
 
494
        r = _mod_branch.PullResult()
509
495
        r.old_revid = "old-revid"
510
496
        r.old_revno = 10
511
497
        r.new_revid = "new-revid"
515
501
        self.assertEqual("Now on revision 20.\n", f.getvalue())
516
502
 
517
503
    def test_report_unchanged(self):
518
 
        r = PullResult()
 
504
        r = _mod_branch.PullResult()
519
505
        r.old_revid = "same-revid"
520
506
        r.new_revid = "same-revid"
521
507
        f = StringIO()
547
533
    """Helper for TestRunWithWriteLockedTarget."""
548
534
 
549
535
 
550
 
class TestRunWithWriteLockedTarget(TestCase):
 
536
class TestRunWithWriteLockedTarget(tests.TestCase):
551
537
    """Tests for _run_with_write_locked_target."""
552
538
 
553
539
    def setUp(self):
554
 
        TestCase.setUp(self)
 
540
        tests.TestCase.setUp(self)
555
541
        self._calls = []
556
542
 
557
543
    def func_that_returns_ok(self):
564
550
 
565
551
    def test_success_unlocks(self):
566
552
        lockable = _StubLockable(self._calls)
567
 
        result = _run_with_write_locked_target(
 
553
        result = _mod_branch._run_with_write_locked_target(
568
554
            lockable, self.func_that_returns_ok)
569
555
        self.assertEqual('ok', result)
570
556
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
572
558
    def test_exception_unlocks_and_propagates(self):
573
559
        lockable = _StubLockable(self._calls)
574
560
        self.assertRaises(_ErrorFromCallable,
575
 
            _run_with_write_locked_target, lockable, self.func_that_raises)
 
561
                          _mod_branch._run_with_write_locked_target,
 
562
                          lockable, self.func_that_raises)
576
563
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
577
564
 
578
565
    def test_callable_succeeds_but_error_during_unlock(self):
579
566
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
580
567
        self.assertRaises(_ErrorFromUnlock,
581
 
            _run_with_write_locked_target, lockable, self.func_that_returns_ok)
 
568
                          _mod_branch._run_with_write_locked_target,
 
569
                          lockable, self.func_that_returns_ok)
582
570
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
583
571
 
584
572
    def test_error_during_unlock_does_not_mask_original_error(self):
585
573
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
586
574
        self.assertRaises(_ErrorFromCallable,
587
 
            _run_with_write_locked_target, lockable, self.func_that_raises)
 
575
                          _mod_branch._run_with_write_locked_target,
 
576
                          lockable, self.func_that_raises)
588
577
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
589
578
 
590
579