← 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: Patrick Regan
  • Date: 2009-12-02 20:34:07 UTC
  • mto: (4852.3.3 2.1.0b4-doc-updates)
  • mto: This revision was merged to the branch mainline in revision 4856.
  • Revision ID: patrick.rubbs.regan@gmail.com-20091202203407-fjd0mshgn3j3foel
Removed trailing whitespace from files in doc directory

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