← 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: Jelmer Vernooij
  • Date: 2011-02-11 17:58:56 UTC
  • mto: This revision was merged to the branch mainline in revision 5662.
  • Revision ID: jelmer@samba.org-20110211175856-alncdirjmi75qr67
Add 'WorkingTreeFormat.missing_parent_conflicts' flag to use in tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_branch.py
16
16
 
17
17
"""Tests for the Branch facility that are not interface  tests.
18
18
 
19
 
For interface tests see `tests/per_branch/*.py`.
 
19
For interface tests see tests/per_branch/*.py.
20
20
 
21
21
For concrete class tests see this file, and for meta-branch tests
22
22
also see this file.
32
32
    symbol_versioning,
33
33
    tests,
34
34
    trace,
 
35
    transport,
35
36
    urlutils,
36
37
    )
37
38
 
40
41
 
41
42
    def test_default_format(self):
42
43
        # update this if you change the default branch format
43
 
        self.assertIsInstance(_mod_branch.format_registry.get_default(),
 
44
        self.assertIsInstance(_mod_branch.BranchFormat.get_default_format(),
44
45
                _mod_branch.BzrBranchFormat7)
45
46
 
46
47
    def test_default_format_is_same_as_bzrdir_default(self):
48
49
        # set, but at the moment that's not true -- mbp 20070814 --
49
50
        # https://bugs.launchpad.net/bzr/+bug/132376
50
51
        self.assertEqual(
51
 
            _mod_branch.format_registry.get_default(),
 
52
            _mod_branch.BranchFormat.get_default_format(),
52
53
            bzrdir.BzrDirFormat.get_default_format().get_branch_format())
53
54
 
54
55
    def test_get_set_default_format(self):
55
56
        # set the format and then set it back again
56
 
        old_format = _mod_branch.format_registry.get_default()
57
 
        _mod_branch.format_registry.set_default(SampleBranchFormat())
 
57
        old_format = _mod_branch.BranchFormat.get_default_format()
 
58
        _mod_branch.BranchFormat.set_default_format(SampleBranchFormat())
58
59
        try:
59
60
            # the default branch format is used by the meta dir format
60
61
            # which is not the default bzrdir format at this point
62
63
            result = dir.create_branch()
63
64
            self.assertEqual(result, 'A branch')
64
65
        finally:
65
 
            _mod_branch.format_registry.set_default(old_format)
 
66
            _mod_branch.BranchFormat.set_default_format(old_format)
66
67
        self.assertEqual(old_format,
67
 
                         _mod_branch.format_registry.get_default())
 
68
                         _mod_branch.BranchFormat.get_default_format())
68
69
 
69
70
 
70
71
class TestBranchFormat5(tests.TestCaseWithTransport):
74
75
        url = self.get_url()
75
76
        bdir = bzrdir.BzrDirMetaFormat1().initialize(url)
76
77
        bdir.create_repository()
77
 
        branch = _mod_branch.BzrBranchFormat5().initialize(bdir)
 
78
        branch = bdir.create_branch()
78
79
        t = self.get_transport()
79
80
        self.log("branch instance is %r" % branch)
80
81
        self.assert_(isinstance(branch, _mod_branch.BzrBranch5))
112
113
        """See BzrBranchFormat.get_format_string()."""
113
114
        return "Sample branch format."
114
115
 
115
 
    def initialize(self, a_bzrdir, name=None, repository=None,
116
 
                   append_revisions_only=None):
 
116
    def initialize(self, a_bzrdir, name=None, repository=None):
117
117
        """Format 4 branches cannot be created."""
118
118
        t = a_bzrdir.get_branch_transport(self, name=name)
119
119
        t.put_bytes('format', self.get_format_string())
138
138
        """See BzrBranchFormat.get_format_string()."""
139
139
        return SampleSupportedBranchFormatString
140
140
 
141
 
    def initialize(self, a_bzrdir, name=None, append_revisions_only=None):
 
141
    def initialize(self, a_bzrdir, name=None):
142
142
        t = a_bzrdir.get_branch_transport(self, name=name)
143
143
        t.put_bytes('format', self.get_format_string())
144
144
        return 'A branch'
178
178
            dir.create_repository()
179
179
            format.initialize(dir)
180
180
            found_format = _mod_branch.BranchFormat.find_format(dir)
181
 
            self.assertIsInstance(found_format, format.__class__)
 
181
            self.failUnless(isinstance(found_format, format.__class__))
182
182
        check_format(_mod_branch.BzrBranchFormat5(), "bar")
183
183
 
 
184
    def test_extra_format(self):
 
185
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
186
        SampleSupportedBranchFormat().initialize(dir)
 
187
        format = SampleExtraBranchFormat()
 
188
        _mod_branch.BranchFormat.register_extra_format(format)
 
189
        self.addCleanup(_mod_branch.BranchFormat.unregister_extra_format,
 
190
            format)
 
191
        self.assertTrue(format in _mod_branch.BranchFormat.get_formats())
 
192
        self.assertEquals(format,
 
193
            _mod_branch.network_format_registry.get("extra"))
 
194
 
184
195
    def test_find_format_factory(self):
185
196
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
186
197
        SampleSupportedBranchFormat().initialize(dir)
187
198
        factory = _mod_branch.MetaDirBranchFormatFactory(
188
199
            SampleSupportedBranchFormatString,
189
200
            "bzrlib.tests.test_branch", "SampleSupportedBranchFormat")
190
 
        _mod_branch.format_registry.register(factory)
191
 
        self.addCleanup(_mod_branch.format_registry.remove, factory)
 
201
        _mod_branch.BranchFormat.register_format(factory)
 
202
        self.addCleanup(_mod_branch.BranchFormat.unregister_format, factory)
192
203
        b = _mod_branch.Branch.open(self.get_url())
193
204
        self.assertEqual(b, "opened supported branch.")
194
205
 
206
217
                          dir)
207
218
 
208
219
    def test_register_unregister_format(self):
209
 
        # Test the deprecated format registration functions
210
220
        format = SampleBranchFormat()
211
221
        # make a control dir
212
222
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
213
223
        # make a branch
214
224
        format.initialize(dir)
215
225
        # register a format for it.
216
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
217
 
            _mod_branch.BranchFormat.register_format, format)
 
226
        _mod_branch.BranchFormat.register_format(format)
218
227
        # which branch.Open will refuse (not supported)
219
228
        self.assertRaises(errors.UnsupportedFormatError,
220
229
                          _mod_branch.Branch.open, self.get_url())
224
233
            format.open(dir),
225
234
            bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
226
235
        # unregister the format
227
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
228
 
            _mod_branch.BranchFormat.unregister_format, format)
 
236
        _mod_branch.BranchFormat.unregister_format(format)
229
237
        self.make_branch_and_tree('bar')
230
238
 
231
239
 
232
 
class TestBranchFormatRegistry(tests.TestCase):
233
 
 
234
 
    def setUp(self):
235
 
        super(TestBranchFormatRegistry, self).setUp()
236
 
        self.registry = _mod_branch.BranchFormatRegistry()
237
 
 
238
 
    def test_default(self):
239
 
        self.assertIs(None, self.registry.get_default())
240
 
        format = SampleBranchFormat()
241
 
        self.registry.set_default(format)
242
 
        self.assertEquals(format, self.registry.get_default())
243
 
 
244
 
    def test_register_unregister_format(self):
245
 
        format = SampleBranchFormat()
246
 
        self.registry.register(format)
247
 
        self.assertEquals(format,
248
 
            self.registry.get("Sample branch format."))
249
 
        self.registry.remove(format)
250
 
        self.assertRaises(KeyError, self.registry.get,
251
 
            "Sample branch format.")
252
 
 
253
 
    def test_get_all(self):
254
 
        format = SampleBranchFormat()
255
 
        self.assertEquals([], self.registry._get_all())
256
 
        self.registry.register(format)
257
 
        self.assertEquals([format], self.registry._get_all())
258
 
 
259
 
    def test_register_extra(self):
260
 
        format = SampleExtraBranchFormat()
261
 
        self.assertEquals([], self.registry._get_all())
262
 
        self.registry.register_extra(format)
263
 
        self.assertEquals([format], self.registry._get_all())
264
 
 
265
 
    def test_register_extra_lazy(self):
266
 
        self.assertEquals([], self.registry._get_all())
267
 
        self.registry.register_extra_lazy("bzrlib.tests.test_branch",
268
 
            "SampleExtraBranchFormat")
269
 
        formats = self.registry._get_all()
270
 
        self.assertEquals(1, len(formats))
271
 
        self.assertIsInstance(formats[0], SampleExtraBranchFormat)
272
 
 
273
 
 
274
240
#Used by TestMetaDirBranchFormatFactory 
275
241
FakeLazyFormat = None
276
242
 
323
289
 
324
290
    def test_layout(self):
325
291
        branch = self.make_branch('a', format=self.get_format_name())
326
 
        self.assertPathExists('a/.bzr/branch/last-revision')
327
 
        self.assertPathDoesNotExist('a/.bzr/branch/revision-history')
328
 
        self.assertPathDoesNotExist('a/.bzr/branch/references')
 
292
        self.failUnlessExists('a/.bzr/branch/last-revision')
 
293
        self.failIfExists('a/.bzr/branch/revision-history')
 
294
        self.failIfExists('a/.bzr/branch/references')
329
295
 
330
296
    def test_config(self):
331
297
        """Ensure that all configuration data is stored in the branch"""
332
298
        branch = self.make_branch('a', format=self.get_format_name())
333
299
        branch.set_parent('http://example.com')
334
 
        self.assertPathDoesNotExist('a/.bzr/branch/parent')
 
300
        self.failIfExists('a/.bzr/branch/parent')
335
301
        self.assertEqual('http://example.com', branch.get_parent())
336
302
        branch.set_push_location('sftp://example.com')
337
303
        config = branch.get_config()._get_branch_data_config()
338
304
        self.assertEqual('sftp://example.com',
339
305
                         config.get_user_option('push_location'))
340
306
        branch.set_bound_location('ftp://example.com')
341
 
        self.assertPathDoesNotExist('a/.bzr/branch/bound')
 
307
        self.failIfExists('a/.bzr/branch/bound')
342
308
        self.assertEqual('ftp://example.com', branch.get_bound_location())
343
309
 
344
310
    def test_set_revision_history(self):
350
316
        branch = builder.get_branch()
351
317
        branch.lock_write()
352
318
        self.addCleanup(branch.unlock)
353
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
354
 
            branch.set_revision_history, ['foo', 'bar'])
355
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
356
 
                branch.set_revision_history, ['foo'])
 
319
        branch.set_revision_history(['foo', 'bar'])
 
320
        branch.set_revision_history(['foo'])
357
321
        self.assertRaises(errors.NotLefthandHistory,
358
 
            self.applyDeprecated, symbol_versioning.deprecated_in((2, 4, 0)),
359
 
            branch.set_revision_history, ['bar'])
 
322
                          branch.set_revision_history, ['bar'])
360
323
 
361
324
    def do_checkout_test(self, lightweight=False):
362
325
        tree = self.make_branch_and_tree('source',
375
338
        subtree.commit('a subtree file')
376
339
        subsubtree.commit('a subsubtree file')
377
340
        tree.branch.create_checkout('target', lightweight=lightweight)
378
 
        self.assertPathExists('target')
379
 
        self.assertPathExists('target/subtree')
380
 
        self.assertPathExists('target/subtree/file')
381
 
        self.assertPathExists('target/subtree/subsubtree/file')
 
341
        self.failUnlessExists('target')
 
342
        self.failUnlessExists('target/subtree')
 
343
        self.failUnlessExists('target/subtree/file')
 
344
        self.failUnlessExists('target/subtree/subsubtree/file')
382
345
        subbranch = _mod_branch.Branch.open('target/subtree/subsubtree')
383
346
        if lightweight:
384
347
            self.assertEndsWith(subbranch.base, 'source/subtree/subsubtree/')
653
616
        if value is not None:
654
617
            self.config.set_user_option('append_revisions_only', value)
655
618
        self.assertEqual(expected_value,
656
 
                         self.branch.get_append_revisions_only())
 
619
                         self.branch._get_append_revisions_only())
657
620
 
658
621
    def test_valid_append_revisions_only(self):
659
622
        self.assertEquals(None,
710
673
        r.new_revid = "same-revid"
711
674
        f = StringIO()
712
675
        r.report(f)
713
 
        self.assertEqual("No revisions or tags to pull.\n", f.getvalue())
 
676
        self.assertEqual("No revisions to pull.\n", f.getvalue())
 
677
 
 
678
 
 
679
class _StubLockable(object):
 
680
    """Helper for TestRunWithWriteLockedTarget."""
 
681
 
 
682
    def __init__(self, calls, unlock_exc=None):
 
683
        self.calls = calls
 
684
        self.unlock_exc = unlock_exc
 
685
 
 
686
    def lock_write(self):
 
687
        self.calls.append('lock_write')
 
688
 
 
689
    def unlock(self):
 
690
        self.calls.append('unlock')
 
691
        if self.unlock_exc is not None:
 
692
            raise self.unlock_exc
 
693
 
 
694
 
 
695
class _ErrorFromCallable(Exception):
 
696
    """Helper for TestRunWithWriteLockedTarget."""
 
697
 
 
698
 
 
699
class _ErrorFromUnlock(Exception):
 
700
    """Helper for TestRunWithWriteLockedTarget."""
 
701
 
 
702
 
 
703
class TestRunWithWriteLockedTarget(tests.TestCase):
 
704
    """Tests for _run_with_write_locked_target."""
 
705
 
 
706
    def setUp(self):
 
707
        tests.TestCase.setUp(self)
 
708
        self._calls = []
 
709
 
 
710
    def func_that_returns_ok(self):
 
711
        self._calls.append('func called')
 
712
        return 'ok'
 
713
 
 
714
    def func_that_raises(self):
 
715
        self._calls.append('func called')
 
716
        raise _ErrorFromCallable()
 
717
 
 
718
    def test_success_unlocks(self):
 
719
        lockable = _StubLockable(self._calls)
 
720
        result = _mod_branch._run_with_write_locked_target(
 
721
            lockable, self.func_that_returns_ok)
 
722
        self.assertEqual('ok', result)
 
723
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
 
724
 
 
725
    def test_exception_unlocks_and_propagates(self):
 
726
        lockable = _StubLockable(self._calls)
 
727
        self.assertRaises(_ErrorFromCallable,
 
728
                          _mod_branch._run_with_write_locked_target,
 
729
                          lockable, self.func_that_raises)
 
730
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
 
731
 
 
732
    def test_callable_succeeds_but_error_during_unlock(self):
 
733
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
 
734
        self.assertRaises(_ErrorFromUnlock,
 
735
                          _mod_branch._run_with_write_locked_target,
 
736
                          lockable, self.func_that_returns_ok)
 
737
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
 
738
 
 
739
    def test_error_during_unlock_does_not_mask_original_error(self):
 
740
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
 
741
        self.assertRaises(_ErrorFromCallable,
 
742
                          _mod_branch._run_with_write_locked_target,
 
743
                          lockable, self.func_that_raises)
 
744
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
 
745
 
714
746