← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/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/blackbox/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
22
22
from bzrlib import (
23
23
    branch,
24
24
    bzrdir,
 
25
    controldir,
25
26
    errors,
26
27
    revision as _mod_revision,
 
28
    tests,
27
29
    )
28
30
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1
29
 
from bzrlib.tests import TestCaseWithTransport
30
31
from bzrlib.tests import (
31
32
    fixtures,
32
 
    script,
33
33
    test_server,
34
34
    )
35
35
from bzrlib.tests.features import (
36
36
    HardlinkFeature,
37
37
    )
38
38
from bzrlib.tests.blackbox import test_switch
 
39
from bzrlib.tests.matchers import ContainsNoVfsCalls
39
40
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
40
41
from bzrlib.tests.script import run_script
41
42
from bzrlib.urlutils import local_path_to_url, strip_trailing_slash
42
43
from bzrlib.workingtree import WorkingTree
43
44
 
44
45
 
45
 
class TestBranch(TestCaseWithTransport):
 
46
class TestBranch(tests.TestCaseWithTransport):
46
47
 
47
 
    def example_branch(self, path='.'):
48
 
        tree = self.make_branch_and_tree(path)
 
48
    def example_branch(self, path='.', format=None):
 
49
        tree = self.make_branch_and_tree(path, format=format)
49
50
        self.build_tree_contents([(path + '/hello', 'foo')])
50
51
        tree.add('hello')
51
52
        tree.commit(message='setup')
52
53
        self.build_tree_contents([(path + '/goodbye', 'baz')])
53
54
        tree.add('goodbye')
54
55
        tree.commit(message='setup')
 
56
        return tree
55
57
 
56
58
    def test_branch(self):
57
59
        """Branch from one branch to another."""
63
65
        self.assertFalse(b._transport.has('branch-name'))
64
66
        b.bzrdir.open_workingtree().commit(message='foo', allow_pointless=True)
65
67
 
 
68
    def test_branch_no_to_location(self):
 
69
        """The to_location is derived from the source branch name."""
 
70
        os.mkdir("something")
 
71
        a = self.example_branch('something/a').branch
 
72
        self.run_bzr('branch something/a')
 
73
        b = branch.Branch.open('a')
 
74
        self.assertEqual(b.last_revision_info(), a.last_revision_info())
 
75
 
 
76
    def test_into_colocated(self):
 
77
        """Branch from a branch into a colocated branch."""
 
78
        self.example_branch('a')
 
79
        out, err = self.run_bzr(
 
80
            'init --format=development-colo file:b,branch=orig')
 
81
        self.assertEqual(
 
82
            """Created a lightweight checkout (format: development-colo)\n""",
 
83
            out)
 
84
        self.assertEqual('', err)
 
85
        out, err = self.run_bzr(
 
86
            'branch a file:b,branch=thiswasa')
 
87
        self.assertEqual('', out)
 
88
        self.assertEqual('Branched 2 revisions.\n', err)
 
89
        out, err = self.run_bzr('branches b')
 
90
        self.assertEqual("  orig\n  thiswasa\n", out)
 
91
        self.assertEqual('', err)
 
92
        out,err = self.run_bzr('branch a file:b,branch=orig', retcode=3)
 
93
        self.assertEqual('', out)
 
94
        self.assertEqual(
 
95
            'bzr: ERROR: Already a branch: "file:b,branch=orig".\n', err)
 
96
 
 
97
    def test_from_colocated(self):
 
98
        """Branch from a colocated branch into a regular branch."""
 
99
        tree = self.example_branch('a', format='development-colo')
 
100
        tree.bzrdir.create_branch(name='somecolo')
 
101
        out, err = self.run_bzr('branch %s,branch=somecolo' %
 
102
            local_path_to_url('a'))
 
103
        self.assertEqual('', out)
 
104
        self.assertEqual('Branched 0 revisions.\n', err)
 
105
        self.assertPathExists("somecolo")
 
106
 
66
107
    def test_branch_broken_pack(self):
67
108
        """branching with a corrupted pack file."""
68
109
        self.example_branch('a')
69
 
        #now add some random corruption
70
 
        fname = 'a/.bzr/repository/packs/' + os.listdir('a/.bzr/repository/packs')[0]
 
110
        # add some corruption
 
111
        packs_dir = 'a/.bzr/repository/packs/'
 
112
        fname = packs_dir + os.listdir(packs_dir)[0]
71
113
        with open(fname, 'rb+') as f:
72
 
            f.seek(750)
73
 
            f.write("\xff")
74
 
        self.run_bzr_error(['Corruption while decompressing repository file'], 
 
114
            # Start from the end of the file to avoid choosing a place bigger
 
115
            # than the file itself.
 
116
            f.seek(-5, os.SEEK_END)
 
117
            c = f.read(1)
 
118
            f.seek(-5, os.SEEK_END)
 
119
            # Make sure we inject a value different than the one we just read
 
120
            if c == '\xFF':
 
121
                corrupt = '\x00'
 
122
            else:
 
123
                corrupt = '\xFF'
 
124
            f.write(corrupt) # make sure we corrupt something
 
125
        self.run_bzr_error(['Corruption while decompressing repository file'],
75
126
                            'branch a b', retcode=3)
76
127
 
77
128
    def test_branch_switch_no_branch(self):
104
155
        #  => new branch will be created, but switch fails and the current
105
156
        #     branch is unmodified
106
157
        self.example_branch('a')
107
 
        self.make_branch_and_tree('current')
 
158
        tree = self.make_branch_and_tree('current')
 
159
        c1 = tree.commit('some diverged change')
108
160
        self.run_bzr_error(['Cannot switch a branch, only a checkout'],
109
161
            'branch --switch ../a ../b', working_dir='current')
110
162
        a = branch.Branch.open('a')
111
163
        b = branch.Branch.open('b')
112
164
        self.assertEqual(a.last_revision(), b.last_revision())
113
165
        work = branch.Branch.open('current')
114
 
        self.assertEqual(work.last_revision(), _mod_revision.NULL_REVISION)
 
166
        self.assertEqual(work.last_revision(), c1)
 
167
 
 
168
    def test_branch_into_empty_dir(self):
 
169
        t = self.example_branch('source')
 
170
        self.make_bzrdir('target')
 
171
        self.run_bzr("branch source target")
 
172
        self.assertEqual(2, len(t.branch.repository.all_revision_ids()))
115
173
 
116
174
    def test_branch_switch_checkout(self):
117
175
        # Checkout in the current directory:
118
176
        #  => new branch will be created and checkout bound to the new branch
119
177
        self.example_branch('a')
120
178
        self.run_bzr('checkout a current')
121
 
        out, err = self.run_bzr('branch --switch ../a ../b', working_dir='current')
 
179
        out, err = self.run_bzr('branch --switch ../a ../b',
 
180
                                working_dir='current')
122
181
        a = branch.Branch.open('a')
123
182
        b = branch.Branch.open('b')
124
183
        self.assertEqual(a.last_revision(), b.last_revision())
132
191
        #     the new branch
133
192
        self.example_branch('a')
134
193
        self.run_bzr('checkout --lightweight a current')
135
 
        out, err = self.run_bzr('branch --switch ../a ../b', working_dir='current')
 
194
        out, err = self.run_bzr('branch --switch ../a ../b',
 
195
                                working_dir='current')
136
196
        a = branch.Branch.open('a')
137
197
        b = branch.Branch.open('b')
138
198
        self.assertEqual(a.last_revision(), b.last_revision())
149
209
 
150
210
        def make_shared_tree(path):
151
211
            shared_repo.bzrdir.root_transport.mkdir(path)
152
 
            shared_repo.bzrdir.create_branch_convenience('repo/' + path)
 
212
            controldir.ControlDir.create_branch_convenience('repo/' + path)
153
213
            return WorkingTree.open('repo/' + path)
154
214
        tree_a = make_shared_tree('a')
155
215
        self.build_tree(['repo/a/file'])
289
349
        builder = self.make_branch_builder('source')
290
350
        source = fixtures.build_branch_with_non_ancestral_rev(builder)
291
351
        source.tags.set_tag('tag-a', 'rev-2')
292
 
        source.get_config().set_user_option('branch.fetch_tags', 'True')
 
352
        source.get_config_stack().set('branch.fetch_tags', True)
293
353
        # Now source has a tag not in its ancestry.  Make a branch from it.
294
354
        self.run_bzr('branch source new-branch')
295
355
        new_branch = branch.Branch.open('new-branch')
298
358
        new_branch.repository.get_revision('rev-2')
299
359
 
300
360
 
301
 
class TestBranchStacked(TestCaseWithTransport):
 
361
class TestBranchStacked(tests.TestCaseWithTransport):
302
362
    """Tests for branch --stacked"""
303
363
 
304
364
    def assertRevisionInRepository(self, repo_path, revid):
305
 
        """Check that a revision is in a repository, disregarding stacking."""
306
 
        repo = bzrdir.BzrDir.open(repo_path).open_repository()
 
365
        """Check that a revision is in a repo, disregarding stacking."""
 
366
        repo = controldir.ControlDir.open(repo_path).open_repository()
307
367
        self.assertTrue(repo.has_revision(revid))
308
368
 
309
369
    def assertRevisionNotInRepository(self, repo_path, revid):
310
 
        """Check that a revision is not in a repository, disregarding stacking."""
311
 
        repo = bzrdir.BzrDir.open(repo_path).open_repository()
 
370
        """Check that a revision is not in a repo, disregarding stacking."""
 
371
        repo = controldir.ControlDir.open(repo_path).open_repository()
312
372
        self.assertFalse(repo.has_revision(revid))
313
373
 
314
374
    def assertRevisionsInBranchRepository(self, revid_list, branch_path):
334
394
        # mainline.
335
395
        out, err = self.run_bzr(['branch', 'branch', 'newbranch'])
336
396
        self.assertEqual('', out)
337
 
        self.assertEqual('Branched 2 revision(s).\n',
 
397
        self.assertEqual('Branched 2 revisions.\n',
338
398
            err)
339
399
        # it should have preserved the branch format, and so it should be
340
400
        # capable of supporting stacking, but not actually have a stacked_on
341
401
        # branch configured
342
402
        self.assertRaises(errors.NotStacked,
343
 
            bzrdir.BzrDir.open('newbranch').open_branch().get_stacked_on_url)
 
403
            controldir.ControlDir.open('newbranch').open_branch().get_stacked_on_url)
344
404
 
345
405
    def test_branch_stacked_branch_stacked(self):
346
406
        """Asking to stack on a stacked branch does work"""
385
445
            trunk_tree.branch.base, err)
386
446
        self.assertRevisionNotInRepository('newbranch', original_revid)
387
447
        new_branch = branch.Branch.open('newbranch')
388
 
        self.assertEqual(trunk_tree.branch.base, new_branch.get_stacked_on_url())
 
448
        self.assertEqual(trunk_tree.branch.base,
 
449
                         new_branch.get_stacked_on_url())
389
450
 
390
451
    def test_branch_stacked_from_smart_server(self):
391
452
        # We can branch stacking on a smart server
426
487
            err)
427
488
 
428
489
 
429
 
class TestSmartServerBranching(TestCaseWithTransport):
 
490
class TestSmartServerBranching(tests.TestCaseWithTransport):
430
491
 
431
492
    def test_branch_from_trivial_branch_to_same_server_branch_acceptance(self):
432
493
        self.setup_smart_server_with_call_log()
441
502
        # being too low. If rpc_count increases, more network roundtrips have
442
503
        # become necessary for this use case. Please do not adjust this number
443
504
        # upwards without agreement from bzr's network support maintainers.
444
 
        self.assertLength(37, self.hpss_calls)
 
505
        self.assertLength(2, self.hpss_connections)
 
506
        self.assertLength(33, self.hpss_calls)
 
507
        self.expectFailure("branching to the same branch requires VFS access",
 
508
            self.assertThat, self.hpss_calls, ContainsNoVfsCalls)
445
509
 
446
510
    def test_branch_from_trivial_branch_streaming_acceptance(self):
447
511
        self.setup_smart_server_with_call_log()
456
520
        # being too low. If rpc_count increases, more network roundtrips have
457
521
        # become necessary for this use case. Please do not adjust this number
458
522
        # upwards without agreement from bzr's network support maintainers.
 
523
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
459
524
        self.assertLength(10, self.hpss_calls)
 
525
        self.assertLength(1, self.hpss_connections)
460
526
 
461
527
    def test_branch_from_trivial_stacked_branch_streaming_acceptance(self):
462
528
        self.setup_smart_server_with_call_log()
477
543
        # become necessary for this use case. Please do not adjust this number
478
544
        # upwards without agreement from bzr's network support maintainers.
479
545
        self.assertLength(15, self.hpss_calls)
 
546
        self.assertLength(1, self.hpss_connections)
 
547
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
480
548
 
481
549
    def test_branch_from_branch_with_tags(self):
482
550
        self.setup_smart_server_with_call_log()
483
551
        builder = self.make_branch_builder('source')
484
552
        source = fixtures.build_branch_with_non_ancestral_rev(builder)
485
 
        source.get_config().set_user_option('branch.fetch_tags', 'True')
 
553
        source.get_config_stack().set('branch.fetch_tags', True)
486
554
        source.tags.set_tag('tag-a', 'rev-2')
487
555
        source.tags.set_tag('tag-missing', 'missing-rev')
488
556
        # Now source has a tag not in its ancestry.  Make a branch from it.
494
562
        # become necessary for this use case. Please do not adjust this number
495
563
        # upwards without agreement from bzr's network support maintainers.
496
564
        self.assertLength(10, self.hpss_calls)
 
565
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
 
566
        self.assertLength(1, self.hpss_connections)
497
567
 
498
568
    def test_branch_to_stacked_from_trivial_branch_streaming_acceptance(self):
499
569
        self.setup_smart_server_with_call_log()
512
582
        readvs_of_rix_files = [
513
583
            c for c in self.hpss_calls
514
584
            if c.call.method == 'readv' and c.call.args[-1].endswith('.rix')]
 
585
        self.assertLength(1, self.hpss_connections)
515
586
        self.assertLength(0, readvs_of_rix_files)
 
587
        self.expectFailure("branching to stacked requires VFS access",
 
588
            self.assertThat, self.hpss_calls, ContainsNoVfsCalls)
516
589
 
517
590
 
518
591
class TestRemoteBranch(TestCaseWithSFTPServer):
539
612
        self.assertFalse(t.has('remote/file'))
540
613
 
541
614
 
542
 
class TestDeprecatedAliases(TestCaseWithTransport):
 
615
class TestDeprecatedAliases(tests.TestCaseWithTransport):
543
616
 
544
617
    def test_deprecated_aliases(self):
545
 
        """bzr branch can be called clone or get, but those names are deprecated.
 
618
        """bzr branch can be called clone or get, but those names are
 
619
        deprecated.
546
620
 
547
621
        See bug 506265.
548
622
        """
561
635
                $ bzr checkout %(option)s repo/trunk checkout
562
636
                $ cd checkout
563
637
                $ bzr branch --switch ../repo/trunk ../repo/branched
564
 
                2>Branched 0 revision(s).
 
638
                2>Branched 0 revisions.
565
639
                2>Tree is up to date at revision 0.
566
640
                2>Switched to branch:...branched...
567
641
                $ cd ..