← 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: Patch Queue Manager
  • Date: 2016-02-01 19:13:13 UTC
  • mfrom: (6614.2.2 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20160201191313-wdfvmfff1djde6oq
(vila) Release 2.7.0 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_branch.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 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
28
28
    branch as _mod_branch,
29
29
    bzrdir,
30
30
    config,
 
31
    controldir,
31
32
    errors,
32
 
    symbol_versioning,
33
33
    tests,
34
34
    trace,
35
35
    urlutils,
36
36
    )
 
37
from bzrlib.branchfmt.fullhistory import (
 
38
    BzrBranch5,
 
39
    BzrBranchFormat5,
 
40
    )
37
41
 
38
42
 
39
43
class TestDefaultFormat(tests.TestCase):
74
78
        url = self.get_url()
75
79
        bdir = bzrdir.BzrDirMetaFormat1().initialize(url)
76
80
        bdir.create_repository()
77
 
        branch = _mod_branch.BzrBranchFormat5().initialize(bdir)
 
81
        branch = BzrBranchFormat5().initialize(bdir)
78
82
        t = self.get_transport()
79
83
        self.log("branch instance is %r" % branch)
80
 
        self.assert_(isinstance(branch, _mod_branch.BzrBranch5))
 
84
        self.assertTrue(isinstance(branch, BzrBranch5))
81
85
        self.assertIsDirectory('.', t)
82
86
        self.assertIsDirectory('.bzr/branch', t)
83
87
        self.assertIsDirectory('.bzr/branch/lock', t)
101
105
    # recursive section - that is, it appends the branch name.
102
106
 
103
107
 
104
 
class SampleBranchFormat(_mod_branch.BranchFormat):
 
108
class SampleBranchFormat(_mod_branch.BranchFormatMetadir):
105
109
    """A sample format
106
110
 
107
111
    this format is initializable, unsupported to aid in testing the
108
112
    open and open_downlevel routines.
109
113
    """
110
114
 
111
 
    def get_format_string(self):
 
115
    @classmethod
 
116
    def get_format_string(cls):
112
117
        """See BzrBranchFormat.get_format_string()."""
113
118
        return "Sample branch format."
114
119
 
115
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
120
    def initialize(self, a_bzrdir, name=None, repository=None,
 
121
                   append_revisions_only=None):
116
122
        """Format 4 branches cannot be created."""
117
123
        t = a_bzrdir.get_branch_transport(self, name=name)
118
124
        t.put_bytes('format', self.get_format_string())
121
127
    def is_supported(self):
122
128
        return False
123
129
 
124
 
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
 
130
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False,
 
131
             possible_transports=None):
125
132
        return "opened branch."
126
133
 
127
134
 
130
137
SampleSupportedBranchFormatString = "Sample supported branch format."
131
138
 
132
139
# And the format class can then reference the constant to avoid skew.
133
 
class SampleSupportedBranchFormat(_mod_branch.BranchFormat):
 
140
class SampleSupportedBranchFormat(_mod_branch.BranchFormatMetadir):
134
141
    """A sample supported format."""
135
142
 
136
 
    def get_format_string(self):
 
143
    @classmethod
 
144
    def get_format_string(cls):
137
145
        """See BzrBranchFormat.get_format_string()."""
138
146
        return SampleSupportedBranchFormatString
139
147
 
140
 
    def initialize(self, a_bzrdir, name=None):
 
148
    def initialize(self, a_bzrdir, name=None, append_revisions_only=None):
141
149
        t = a_bzrdir.get_branch_transport(self, name=name)
142
150
        t.put_bytes('format', self.get_format_string())
143
151
        return 'A branch'
144
152
 
145
 
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
 
153
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False,
 
154
             possible_transports=None):
146
155
        return "opened supported branch."
147
156
 
148
157
 
160
169
    def initialize(self, a_bzrdir, name=None):
161
170
        raise NotImplementedError(self.initialize)
162
171
 
163
 
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
 
172
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False,
 
173
             possible_transports=None):
164
174
        raise NotImplementedError(self.open)
165
175
 
166
176
 
176
186
            dir = format._matchingbzrdir.initialize(url)
177
187
            dir.create_repository()
178
188
            format.initialize(dir)
179
 
            found_format = _mod_branch.BranchFormat.find_format(dir)
 
189
            found_format = _mod_branch.BranchFormatMetadir.find_format(dir)
180
190
            self.assertIsInstance(found_format, format.__class__)
181
 
        check_format(_mod_branch.BzrBranchFormat5(), "bar")
 
191
        check_format(BzrBranchFormat5(), "bar")
182
192
 
183
193
    def test_find_format_factory(self):
184
194
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
191
201
        b = _mod_branch.Branch.open(self.get_url())
192
202
        self.assertEqual(b, "opened supported branch.")
193
203
 
 
204
    def test_from_string(self):
 
205
        self.assertIsInstance(
 
206
            SampleBranchFormat.from_string("Sample branch format."),
 
207
            SampleBranchFormat)
 
208
        self.assertRaises(AssertionError,
 
209
            SampleBranchFormat.from_string, "Different branch format.")
 
210
 
194
211
    def test_find_format_not_branch(self):
195
212
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
196
213
        self.assertRaises(errors.NotBranchError,
197
 
                          _mod_branch.BranchFormat.find_format,
 
214
                          _mod_branch.BranchFormatMetadir.find_format,
198
215
                          dir)
199
216
 
200
217
    def test_find_format_unknown_format(self):
201
218
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
202
219
        SampleBranchFormat().initialize(dir)
203
220
        self.assertRaises(errors.UnknownFormatError,
204
 
                          _mod_branch.BranchFormat.find_format,
 
221
                          _mod_branch.BranchFormatMetadir.find_format,
205
222
                          dir)
206
223
 
207
 
    def test_register_unregister_format(self):
208
 
        # Test the deprecated format registration functions
209
 
        format = SampleBranchFormat()
210
 
        # make a control dir
211
 
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
212
 
        # make a branch
213
 
        format.initialize(dir)
214
 
        # register a format for it.
215
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
216
 
            _mod_branch.BranchFormat.register_format, format)
217
 
        # which branch.Open will refuse (not supported)
218
 
        self.assertRaises(errors.UnsupportedFormatError,
219
 
                          _mod_branch.Branch.open, self.get_url())
220
 
        self.make_branch_and_tree('foo')
221
 
        # but open_downlevel will work
222
 
        self.assertEqual(
223
 
            format.open(dir),
224
 
            bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
225
 
        # unregister the format
226
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
227
 
            _mod_branch.BranchFormat.unregister_format, format)
228
 
        self.make_branch_and_tree('bar')
 
224
    def test_find_format_with_features(self):
 
225
        tree = self.make_branch_and_tree('.', format='2a')
 
226
        tree.branch.update_feature_flags({"name": "optional"})
 
227
        found_format = _mod_branch.BranchFormatMetadir.find_format(tree.bzrdir)
 
228
        self.assertIsInstance(found_format, _mod_branch.BranchFormatMetadir)
 
229
        self.assertEqual(found_format.features.get("name"), "optional")
 
230
        tree.branch.update_feature_flags({"name": None})
 
231
        branch = _mod_branch.Branch.open('.')
 
232
        self.assertEqual(branch._format.features, {})
229
233
 
230
234
 
231
235
class TestBranchFormatRegistry(tests.TestCase):
238
242
        self.assertIs(None, self.registry.get_default())
239
243
        format = SampleBranchFormat()
240
244
        self.registry.set_default(format)
241
 
        self.assertEquals(format, self.registry.get_default())
 
245
        self.assertEqual(format, self.registry.get_default())
242
246
 
243
247
    def test_register_unregister_format(self):
244
248
        format = SampleBranchFormat()
245
249
        self.registry.register(format)
246
 
        self.assertEquals(format,
 
250
        self.assertEqual(format,
247
251
            self.registry.get("Sample branch format."))
248
252
        self.registry.remove(format)
249
253
        self.assertRaises(KeyError, self.registry.get,
251
255
 
252
256
    def test_get_all(self):
253
257
        format = SampleBranchFormat()
254
 
        self.assertEquals([], self.registry._get_all())
 
258
        self.assertEqual([], self.registry._get_all())
255
259
        self.registry.register(format)
256
 
        self.assertEquals([format], self.registry._get_all())
 
260
        self.assertEqual([format], self.registry._get_all())
257
261
 
258
262
    def test_register_extra(self):
259
263
        format = SampleExtraBranchFormat()
260
 
        self.assertEquals([], self.registry._get_all())
 
264
        self.assertEqual([], self.registry._get_all())
261
265
        self.registry.register_extra(format)
262
 
        self.assertEquals([format], self.registry._get_all())
 
266
        self.assertEqual([format], self.registry._get_all())
263
267
 
264
268
    def test_register_extra_lazy(self):
265
 
        self.assertEquals([], self.registry._get_all())
 
269
        self.assertEqual([], self.registry._get_all())
266
270
        self.registry.register_extra_lazy("bzrlib.tests.test_branch",
267
271
            "SampleExtraBranchFormat")
268
272
        formats = self.registry._get_all()
269
 
        self.assertEquals(1, len(formats))
 
273
        self.assertEqual(1, len(formats))
270
274
        self.assertIsInstance(formats[0], SampleExtraBranchFormat)
271
275
 
272
276
 
333
337
        self.assertPathDoesNotExist('a/.bzr/branch/parent')
334
338
        self.assertEqual('http://example.com', branch.get_parent())
335
339
        branch.set_push_location('sftp://example.com')
336
 
        config = branch.get_config()._get_branch_data_config()
337
 
        self.assertEqual('sftp://example.com',
338
 
                         config.get_user_option('push_location'))
 
340
        conf = branch.get_config_stack()
 
341
        self.assertEqual('sftp://example.com', conf.get('push_location'))
339
342
        branch.set_bound_location('ftp://example.com')
340
343
        self.assertPathDoesNotExist('a/.bzr/branch/bound')
341
344
        self.assertEqual('ftp://example.com', branch.get_bound_location())
342
345
 
343
 
    def test_set_revision_history(self):
344
 
        builder = self.make_branch_builder('.', format=self.get_format_name())
345
 
        builder.build_snapshot('foo', None,
346
 
            [('add', ('', None, 'directory', None))],
347
 
            message='foo')
348
 
        builder.build_snapshot('bar', None, [], message='bar')
349
 
        branch = builder.get_branch()
350
 
        branch.lock_write()
351
 
        self.addCleanup(branch.unlock)
352
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
353
 
            branch.set_revision_history, ['foo', 'bar'])
354
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
355
 
                branch.set_revision_history, ['foo'])
356
 
        self.assertRaises(errors.NotLefthandHistory,
357
 
            self.applyDeprecated, symbol_versioning.deprecated_in((2, 4, 0)),
358
 
            branch.set_revision_history, ['bar'])
359
 
 
360
346
    def do_checkout_test(self, lightweight=False):
361
347
        tree = self.make_branch_and_tree('source',
362
348
            format=self.get_format_name_subtree())
390
376
    def test_light_checkout_with_references(self):
391
377
        self.do_checkout_test(lightweight=True)
392
378
 
393
 
    def test_set_push(self):
394
 
        branch = self.make_branch('source', format=self.get_format_name())
395
 
        branch.get_config().set_user_option('push_location', 'old',
396
 
            store=config.STORE_LOCATION)
397
 
        warnings = []
398
 
        def warning(*args):
399
 
            warnings.append(args[0] % args[1:])
400
 
        _warning = trace.warning
401
 
        trace.warning = warning
402
 
        try:
403
 
            branch.set_push_location('new')
404
 
        finally:
405
 
            trace.warning = _warning
406
 
        self.assertEqual(warnings[0], 'Value "new" is masked by "old" from '
407
 
                         'locations.conf')
408
 
 
409
379
 
410
380
class TestBranch6(TestBranch67, tests.TestCaseWithTransport):
411
381
 
482
452
 
483
453
    def make_branch(self, location, format=None):
484
454
        if format is None:
485
 
            format = bzrdir.format_registry.make_bzrdir('1.9')
 
455
            format = controldir.format_registry.make_bzrdir('1.9')
486
456
            format.set_branch_format(_mod_branch.BzrBranchFormat8())
487
457
        return tests.TestCaseWithTransport.make_branch(
488
458
            self, location, format=format)
540
510
        self.assertEqual(('path3', 'location3'),
541
511
                         branch.get_reference_info('file-id'))
542
512
 
 
513
    def _recordParentMapCalls(self, repo):
 
514
        self._parent_map_calls = []
 
515
        orig_get_parent_map = repo.revisions.get_parent_map
 
516
        def get_parent_map(q):
 
517
            q = list(q)
 
518
            self._parent_map_calls.extend([e[0] for e in q])
 
519
            return orig_get_parent_map(q)
 
520
        repo.revisions.get_parent_map = get_parent_map
 
521
 
 
522
 
543
523
class TestBranchReference(tests.TestCaseWithTransport):
544
524
    """Tests for the branch reference facility."""
545
525
 
559
539
        self.assertEqual(opened_branch.base, target_branch.base)
560
540
 
561
541
    def test_get_reference(self):
562
 
        """For a BranchReference, get_reference should reutrn the location."""
 
542
        """For a BranchReference, get_reference should return the location."""
563
543
        branch = self.make_branch('target')
564
544
        checkout = branch.create_checkout('checkout', lightweight=True)
565
545
        reference_url = branch.bzrdir.root_transport.abspath('') + '/'
575
555
    def test_constructor(self):
576
556
        """Check that creating a BranchHooks instance has the right defaults."""
577
557
        hooks = _mod_branch.BranchHooks()
578
 
        self.assertTrue("set_rh" in hooks, "set_rh not in %s" % hooks)
579
558
        self.assertTrue("post_push" in hooks, "post_push not in %s" % hooks)
580
559
        self.assertTrue("post_commit" in hooks, "post_commit not in %s" % hooks)
581
560
        self.assertTrue("pre_commit" in hooks, "pre_commit not in %s" % hooks)
645
624
    def setUp(self):
646
625
        super(TestBranchOptions, self).setUp()
647
626
        self.branch = self.make_branch('.')
648
 
        self.config = self.branch.get_config()
 
627
        self.config_stack = self.branch.get_config_stack()
649
628
 
650
629
    def check_append_revisions_only(self, expected_value, value=None):
651
630
        """Set append_revisions_only in config and check its interpretation."""
652
631
        if value is not None:
653
 
            self.config.set_user_option('append_revisions_only', value)
 
632
            self.config_stack.set('append_revisions_only', value)
654
633
        self.assertEqual(expected_value,
655
 
                         self.branch._get_append_revisions_only())
 
634
                         self.branch.get_append_revisions_only())
656
635
 
657
636
    def test_valid_append_revisions_only(self):
658
 
        self.assertEquals(None,
659
 
                          self.config.get_user_option('append_revisions_only'))
 
637
        self.assertEqual(None,
 
638
                          self.config_stack.get('append_revisions_only'))
660
639
        self.check_append_revisions_only(None)
661
640
        self.check_append_revisions_only(False, 'False')
662
641
        self.check_append_revisions_only(True, 'True')
674
653
        self.check_append_revisions_only(None, 'not-a-bool')
675
654
        self.assertLength(1, self.warnings)
676
655
        self.assertEqual(
677
 
            'Value "not-a-bool" is not a boolean for "append_revisions_only"',
 
656
            'Value "not-a-bool" is not valid for "append_revisions_only"',
678
657
            self.warnings[0])
679
658
 
 
659
    def test_use_fresh_values(self):
 
660
        copy = _mod_branch.Branch.open(self.branch.base)
 
661
        copy.lock_write()
 
662
        try:
 
663
            copy.get_config_stack().set('foo', 'bar')
 
664
        finally:
 
665
            copy.unlock()
 
666
        self.assertFalse(self.branch.is_locked())
 
667
        # Since the branch is locked, the option value won't be saved on disk
 
668
        # so trying to access the config of locked branch via another older
 
669
        # non-locked branch object pointing to the same branch is not supported
 
670
        self.assertEqual(None, self.branch.get_config_stack().get('foo'))
 
671
        # Using a newly created branch object works as expected
 
672
        fresh = _mod_branch.Branch.open(self.branch.base)
 
673
        self.assertEqual('bar', fresh.get_config_stack().get('foo'))
 
674
 
 
675
    def test_set_from_config_get_from_config_stack(self):
 
676
        self.branch.lock_write()
 
677
        self.addCleanup(self.branch.unlock)
 
678
        self.branch.get_config().set_user_option('foo', 'bar')
 
679
        result = self.branch.get_config_stack().get('foo')
 
680
        # https://bugs.launchpad.net/bzr/+bug/948344
 
681
        self.expectFailure('BranchStack uses cache after set_user_option',
 
682
                           self.assertEqual, 'bar', result)
 
683
 
 
684
    def test_set_from_config_stack_get_from_config(self):
 
685
        self.branch.lock_write()
 
686
        self.addCleanup(self.branch.unlock)
 
687
        self.branch.get_config_stack().set('foo', 'bar')
 
688
        # Since the branch is locked, the option value won't be saved on disk
 
689
        # so mixing get() and get_user_option() is broken by design.
 
690
        self.assertEqual(None,
 
691
                         self.branch.get_config().get_user_option('foo'))
 
692
 
 
693
    def test_set_delays_write_when_branch_is_locked(self):
 
694
        self.branch.lock_write()
 
695
        self.addCleanup(self.branch.unlock)
 
696
        self.branch.get_config_stack().set('foo', 'bar')
 
697
        copy = _mod_branch.Branch.open(self.branch.base)
 
698
        result = copy.get_config_stack().get('foo')
 
699
        # Accessing from a different branch object is like accessing from a
 
700
        # different process: the option has not been saved yet and the new
 
701
        # value cannot be seen.
 
702
        self.assertIs(None, result)
 
703
 
680
704
 
681
705
class TestPullResult(tests.TestCase):
682
706
 
683
 
    def test_pull_result_to_int(self):
684
 
        # to support old code, the pull result can be used as an int
685
 
        r = _mod_branch.PullResult()
686
 
        r.old_revno = 10
687
 
        r.new_revno = 20
688
 
        # this usage of results is not recommended for new code (because it
689
 
        # doesn't describe very well what happened), but for api stability
690
 
        # it's still supported
691
 
        self.assertEqual(self.applyDeprecated(
692
 
            symbol_versioning.deprecated_in((2, 3, 0)),
693
 
            r.__int__),
694
 
            10)
695
 
 
696
707
    def test_report_changed(self):
697
708
        r = _mod_branch.PullResult()
698
709
        r.old_revid = "old-revid"
702
713
        f = StringIO()
703
714
        r.report(f)
704
715
        self.assertEqual("Now on revision 20.\n", f.getvalue())
 
716
        self.assertEqual("Now on revision 20.\n", f.getvalue())
705
717
 
706
718
    def test_report_unchanged(self):
707
719
        r = _mod_branch.PullResult()
709
721
        r.new_revid = "same-revid"
710
722
        f = StringIO()
711
723
        r.report(f)
712
 
        self.assertEqual("No revisions to pull.\n", f.getvalue())
713
 
 
 
724
        self.assertEqual("No revisions or tags to pull.\n", f.getvalue())