← 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

(vila) Fix test failures blocking package builds. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_branch.py
1
 
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2006-2012 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
19
19
 
20
20
import os
21
21
 
22
 
from bzrlib import (branch, bzrdir, errors, repository)
 
22
from bzrlib import (
 
23
    branch,
 
24
    bzrdir,
 
25
    controldir,
 
26
    errors,
 
27
    revision as _mod_revision,
 
28
    tests,
 
29
    )
23
30
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1
24
 
from bzrlib.tests.blackbox import ExternalBase
25
31
from bzrlib.tests import (
26
 
    KnownFailure,
 
32
    fixtures,
 
33
    test_server,
 
34
    )
 
35
from bzrlib.tests.features import (
27
36
    HardlinkFeature,
28
37
    )
 
38
from bzrlib.tests.blackbox import test_switch
 
39
from bzrlib.tests.matchers import ContainsNoVfsCalls
29
40
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
 
41
from bzrlib.tests.script import run_script
30
42
from bzrlib.urlutils import local_path_to_url, strip_trailing_slash
31
43
from bzrlib.workingtree import WorkingTree
32
44
 
33
45
 
34
 
class TestBranch(ExternalBase):
 
46
class TestBranch(tests.TestCaseWithTransport):
35
47
 
36
 
    def example_branch(self, path='.'):
37
 
        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)
38
50
        self.build_tree_contents([(path + '/hello', 'foo')])
39
51
        tree.add('hello')
40
52
        tree.commit(message='setup')
41
53
        self.build_tree_contents([(path + '/goodbye', 'baz')])
42
54
        tree.add('goodbye')
43
55
        tree.commit(message='setup')
 
56
        return tree
44
57
 
45
58
    def test_branch(self):
46
59
        """Branch from one branch to another."""
52
65
        self.assertFalse(b._transport.has('branch-name'))
53
66
        b.bzrdir.open_workingtree().commit(message='foo', allow_pointless=True)
54
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.assertEquals(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
 
 
107
    def test_branch_broken_pack(self):
 
108
        """branching with a corrupted pack file."""
 
109
        self.example_branch('a')
 
110
        # add some corruption
 
111
        packs_dir = 'a/.bzr/repository/packs/'
 
112
        fname = packs_dir + os.listdir(packs_dir)[0]
 
113
        with open(fname, 'rb+') as f:
 
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'],
 
126
                            'branch a b', retcode=3)
 
127
 
 
128
    def test_branch_switch_no_branch(self):
 
129
        # No branch in the current directory:
 
130
        #  => new branch will be created, but switch fails
 
131
        self.example_branch('a')
 
132
        self.make_repository('current')
 
133
        self.run_bzr_error(['No WorkingTree exists for'],
 
134
            'branch --switch ../a ../b', working_dir='current')
 
135
        a = branch.Branch.open('a')
 
136
        b = branch.Branch.open('b')
 
137
        self.assertEqual(a.last_revision(), b.last_revision())
 
138
 
 
139
    def test_branch_switch_no_wt(self):
 
140
        # No working tree in the current directory:
 
141
        #  => new branch will be created, but switch fails and the current
 
142
        #     branch is unmodified
 
143
        self.example_branch('a')
 
144
        self.make_branch('current')
 
145
        self.run_bzr_error(['No WorkingTree exists for'],
 
146
            'branch --switch ../a ../b', working_dir='current')
 
147
        a = branch.Branch.open('a')
 
148
        b = branch.Branch.open('b')
 
149
        self.assertEqual(a.last_revision(), b.last_revision())
 
150
        work = branch.Branch.open('current')
 
151
        self.assertEqual(work.last_revision(), _mod_revision.NULL_REVISION)
 
152
 
 
153
    def test_branch_switch_no_checkout(self):
 
154
        # Standalone branch in the current directory:
 
155
        #  => new branch will be created, but switch fails and the current
 
156
        #     branch is unmodified
 
157
        self.example_branch('a')
 
158
        tree = self.make_branch_and_tree('current')
 
159
        c1 = tree.commit('some diverged change')
 
160
        self.run_bzr_error(['Cannot switch a branch, only a checkout'],
 
161
            'branch --switch ../a ../b', working_dir='current')
 
162
        a = branch.Branch.open('a')
 
163
        b = branch.Branch.open('b')
 
164
        self.assertEqual(a.last_revision(), b.last_revision())
 
165
        work = branch.Branch.open('current')
 
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.assertEquals(2, len(t.branch.repository.all_revision_ids()))
 
173
 
 
174
    def test_branch_switch_checkout(self):
 
175
        # Checkout in the current directory:
 
176
        #  => new branch will be created and checkout bound to the new branch
 
177
        self.example_branch('a')
 
178
        self.run_bzr('checkout a current')
 
179
        out, err = self.run_bzr('branch --switch ../a ../b',
 
180
                                working_dir='current')
 
181
        a = branch.Branch.open('a')
 
182
        b = branch.Branch.open('b')
 
183
        self.assertEqual(a.last_revision(), b.last_revision())
 
184
        work = WorkingTree.open('current')
 
185
        self.assertEndsWith(work.branch.get_bound_location(), '/b/')
 
186
        self.assertContainsRe(err, "Switched to branch: .*/b/")
 
187
 
 
188
    def test_branch_switch_lightweight_checkout(self):
 
189
        # Lightweight checkout in the current directory:
 
190
        #  => new branch will be created and lightweight checkout pointed to
 
191
        #     the new branch
 
192
        self.example_branch('a')
 
193
        self.run_bzr('checkout --lightweight a current')
 
194
        out, err = self.run_bzr('branch --switch ../a ../b',
 
195
                                working_dir='current')
 
196
        a = branch.Branch.open('a')
 
197
        b = branch.Branch.open('b')
 
198
        self.assertEqual(a.last_revision(), b.last_revision())
 
199
        work = WorkingTree.open('current')
 
200
        self.assertEndsWith(work.branch.base, '/b/')
 
201
        self.assertContainsRe(err, "Switched to branch: .*/b/")
 
202
 
55
203
    def test_branch_only_copies_history(self):
56
204
        # Knit branches should only push the history for the current revision.
57
205
        format = bzrdir.BzrDirMetaFormat1()
61
209
 
62
210
        def make_shared_tree(path):
63
211
            shared_repo.bzrdir.root_transport.mkdir(path)
64
 
            shared_repo.bzrdir.create_branch_convenience('repo/' + path)
 
212
            controldir.ControlDir.create_branch_convenience('repo/' + path)
65
213
            return WorkingTree.open('repo/' + path)
66
214
        tree_a = make_shared_tree('a')
67
215
        self.build_tree(['repo/a/file'])
99
247
        out, err = self.run_bzr(['branch', 'source', 'target', '--hardlink'])
100
248
        source_stat = os.stat('source/file1')
101
249
        target_stat = os.stat('target/file1')
102
 
        same_file = (source_stat == target_stat)
103
 
        if same_file:
104
 
            pass
105
 
        else:
106
 
            # https://bugs.edge.launchpad.net/bzr/+bug/408193
107
 
            self.assertContainsRe(err, "hardlinking working copy files is "
108
 
                "not currently supported")
109
 
            raise KnownFailure("--hardlink doesn't work in formats "
110
 
                "that support content filtering (#408193)")
 
250
        self.assertEqual(source_stat, target_stat)
 
251
 
 
252
    def test_branch_files_from(self):
 
253
        source = self.make_branch_and_tree('source')
 
254
        self.build_tree(['source/file1'])
 
255
        source.add('file1')
 
256
        source.commit('added file')
 
257
        out, err = self.run_bzr('branch source target --files-from source')
 
258
        self.assertPathExists('target/file1')
 
259
 
 
260
    def test_branch_files_from_hardlink(self):
 
261
        self.requireFeature(HardlinkFeature)
 
262
        source = self.make_branch_and_tree('source')
 
263
        self.build_tree(['source/file1'])
 
264
        source.add('file1')
 
265
        source.commit('added file')
 
266
        source.bzrdir.sprout('second')
 
267
        out, err = self.run_bzr('branch source target --files-from second'
 
268
                                ' --hardlink')
 
269
        source_stat = os.stat('source/file1')
 
270
        second_stat = os.stat('second/file1')
 
271
        target_stat = os.stat('target/file1')
 
272
        self.assertNotEqual(source_stat, target_stat)
 
273
        self.assertEqual(second_stat, target_stat)
111
274
 
112
275
    def test_branch_standalone(self):
113
276
        shared_repo = self.make_repository('repo', shared=True)
121
284
    def test_branch_no_tree(self):
122
285
        self.example_branch('source')
123
286
        self.run_bzr('branch --no-tree source target')
124
 
        self.failIfExists('target/hello')
125
 
        self.failIfExists('target/goodbye')
 
287
        self.assertPathDoesNotExist('target/hello')
 
288
        self.assertPathDoesNotExist('target/goodbye')
126
289
 
127
290
    def test_branch_into_existing_dir(self):
128
291
        self.example_branch('a')
138
301
        # force operation
139
302
        self.run_bzr('branch a b --use-existing-dir')
140
303
        # check conflicts
141
 
        self.failUnlessExists('b/hello.moved')
142
 
        self.failIfExists('b/godbye.moved')
 
304
        self.assertPathExists('b/hello.moved')
 
305
        self.assertPathDoesNotExist('b/godbye.moved')
143
306
        # we can't branch into branch
144
307
        out,err = self.run_bzr('branch a b --use-existing-dir', retcode=3)
145
308
        self.assertEqual('', out)
146
309
        self.assertEqual('bzr: ERROR: Already a branch: "b".\n', err)
147
310
 
148
 
 
149
 
class TestBranchStacked(ExternalBase):
 
311
    def test_branch_bind(self):
 
312
        self.example_branch('a')
 
313
        out, err = self.run_bzr('branch a b --bind')
 
314
        self.assertEndsWith(err, "New branch bound to a\n")
 
315
        b = branch.Branch.open('b')
 
316
        self.assertEndsWith(b.get_bound_location(), '/a/')
 
317
 
 
318
    def test_branch_with_post_branch_init_hook(self):
 
319
        calls = []
 
320
        branch.Branch.hooks.install_named_hook('post_branch_init',
 
321
            calls.append, None)
 
322
        self.assertLength(0, calls)
 
323
        self.example_branch('a')
 
324
        self.assertLength(1, calls)
 
325
        self.run_bzr('branch a b')
 
326
        self.assertLength(2, calls)
 
327
 
 
328
    def test_checkout_with_post_branch_init_hook(self):
 
329
        calls = []
 
330
        branch.Branch.hooks.install_named_hook('post_branch_init',
 
331
            calls.append, None)
 
332
        self.assertLength(0, calls)
 
333
        self.example_branch('a')
 
334
        self.assertLength(1, calls)
 
335
        self.run_bzr('checkout a b')
 
336
        self.assertLength(2, calls)
 
337
 
 
338
    def test_lightweight_checkout_with_post_branch_init_hook(self):
 
339
        calls = []
 
340
        branch.Branch.hooks.install_named_hook('post_branch_init',
 
341
            calls.append, None)
 
342
        self.assertLength(0, calls)
 
343
        self.example_branch('a')
 
344
        self.assertLength(1, calls)
 
345
        self.run_bzr('checkout --lightweight a b')
 
346
        self.assertLength(2, calls)
 
347
 
 
348
    def test_branch_fetches_all_tags(self):
 
349
        builder = self.make_branch_builder('source')
 
350
        source = fixtures.build_branch_with_non_ancestral_rev(builder)
 
351
        source.tags.set_tag('tag-a', 'rev-2')
 
352
        source.get_config_stack().set('branch.fetch_tags', True)
 
353
        # Now source has a tag not in its ancestry.  Make a branch from it.
 
354
        self.run_bzr('branch source new-branch')
 
355
        new_branch = branch.Branch.open('new-branch')
 
356
        # The tag is present, and so is its revision.
 
357
        self.assertEqual('rev-2', new_branch.tags.lookup_tag('tag-a'))
 
358
        new_branch.repository.get_revision('rev-2')
 
359
 
 
360
 
 
361
class TestBranchStacked(tests.TestCaseWithTransport):
150
362
    """Tests for branch --stacked"""
151
363
 
152
364
    def assertRevisionInRepository(self, repo_path, revid):
153
 
        """Check that a revision is in a repository, disregarding stacking."""
154
 
        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()
155
367
        self.assertTrue(repo.has_revision(revid))
156
368
 
157
369
    def assertRevisionNotInRepository(self, repo_path, revid):
158
 
        """Check that a revision is not in a repository, disregarding stacking."""
159
 
        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()
160
372
        self.assertFalse(repo.has_revision(revid))
161
373
 
162
374
    def assertRevisionsInBranchRepository(self, revid_list, branch_path):
182
394
        # mainline.
183
395
        out, err = self.run_bzr(['branch', 'branch', 'newbranch'])
184
396
        self.assertEqual('', out)
185
 
        self.assertEqual('Branched 2 revision(s).\n',
 
397
        self.assertEqual('Branched 2 revisions.\n',
186
398
            err)
187
399
        # it should have preserved the branch format, and so it should be
188
400
        # capable of supporting stacking, but not actually have a stacked_on
189
401
        # branch configured
190
402
        self.assertRaises(errors.NotStacked,
191
 
            bzrdir.BzrDir.open('newbranch').open_branch().get_stacked_on_url)
 
403
            controldir.ControlDir.open('newbranch').open_branch().get_stacked_on_url)
192
404
 
193
405
    def test_branch_stacked_branch_stacked(self):
194
406
        """Asking to stack on a stacked branch does work"""
233
445
            trunk_tree.branch.base, err)
234
446
        self.assertRevisionNotInRepository('newbranch', original_revid)
235
447
        new_branch = branch.Branch.open('newbranch')
236
 
        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())
237
450
 
238
451
    def test_branch_stacked_from_smart_server(self):
239
452
        # We can branch stacking on a smart server
240
 
        from bzrlib.smart.server import SmartTCPServer_for_testing
241
 
        self.transport_server = SmartTCPServer_for_testing
 
453
        self.transport_server = test_server.SmartTCPServer_for_testing
242
454
        trunk = self.make_branch('mainline', format='1.9')
243
455
        out, err = self.run_bzr(
244
456
            ['branch', '--stacked', self.get_url('mainline'), 'shallow'])
254
466
            '  Packs 5 (adds stacking support, requires bzr 1.6)\n'
255
467
            'Source branch format does not support stacking, using format:\n'
256
468
            '  Branch format 7\n'
 
469
            'Doing on-the-fly conversion from RepositoryFormatKnitPack1() to RepositoryFormatKnitPack5().\n'
 
470
            'This may take some time. Upgrade the repositories to the same format for better performance.\n'
257
471
            'Created new stacked branch referring to %s.\n' % (trunk.base,),
258
472
            err)
259
473
 
267
481
            '  Packs 5 rich-root (adds stacking support, requires bzr 1.6.1)\n'
268
482
            'Source branch format does not support stacking, using format:\n'
269
483
            '  Branch format 7\n'
 
484
            'Doing on-the-fly conversion from RepositoryFormatKnitPack4() to RepositoryFormatKnitPack5RichRoot().\n'
 
485
            'This may take some time. Upgrade the repositories to the same format for better performance.\n'
270
486
            'Created new stacked branch referring to %s.\n' % (trunk.base,),
271
487
            err)
272
488
 
273
489
 
274
 
class TestSmartServerBranching(ExternalBase):
 
490
class TestSmartServerBranching(tests.TestCaseWithTransport):
275
491
 
276
492
    def test_branch_from_trivial_branch_to_same_server_branch_acceptance(self):
277
493
        self.setup_smart_server_with_call_log()
286
502
        # being too low. If rpc_count increases, more network roundtrips have
287
503
        # become necessary for this use case. Please do not adjust this number
288
504
        # upwards without agreement from bzr's network support maintainers.
289
 
        self.assertLength(38, 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)
290
509
 
291
510
    def test_branch_from_trivial_branch_streaming_acceptance(self):
292
511
        self.setup_smart_server_with_call_log()
301
520
        # being too low. If rpc_count increases, more network roundtrips have
302
521
        # become necessary for this use case. Please do not adjust this number
303
522
        # upwards without agreement from bzr's network support maintainers.
 
523
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
304
524
        self.assertLength(10, self.hpss_calls)
 
525
        self.assertLength(1, self.hpss_connections)
305
526
 
306
527
    def test_branch_from_trivial_stacked_branch_streaming_acceptance(self):
307
528
        self.setup_smart_server_with_call_log()
322
543
        # become necessary for this use case. Please do not adjust this number
323
544
        # upwards without agreement from bzr's network support maintainers.
324
545
        self.assertLength(15, self.hpss_calls)
 
546
        self.assertLength(1, self.hpss_connections)
 
547
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
 
548
 
 
549
    def test_branch_from_branch_with_tags(self):
 
550
        self.setup_smart_server_with_call_log()
 
551
        builder = self.make_branch_builder('source')
 
552
        source = fixtures.build_branch_with_non_ancestral_rev(builder)
 
553
        source.get_config_stack().set('branch.fetch_tags', True)
 
554
        source.tags.set_tag('tag-a', 'rev-2')
 
555
        source.tags.set_tag('tag-missing', 'missing-rev')
 
556
        # Now source has a tag not in its ancestry.  Make a branch from it.
 
557
        self.reset_smart_call_log()
 
558
        out, err = self.run_bzr(['branch', self.get_url('source'), 'target'])
 
559
        # This figure represent the amount of work to perform this use case. It
 
560
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
561
        # being too low. If rpc_count increases, more network roundtrips have
 
562
        # become necessary for this use case. Please do not adjust this number
 
563
        # upwards without agreement from bzr's network support maintainers.
 
564
        self.assertLength(10, self.hpss_calls)
 
565
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
 
566
        self.assertLength(1, self.hpss_connections)
 
567
 
 
568
    def test_branch_to_stacked_from_trivial_branch_streaming_acceptance(self):
 
569
        self.setup_smart_server_with_call_log()
 
570
        t = self.make_branch_and_tree('from')
 
571
        for count in range(9):
 
572
            t.commit(message='commit %d' % count)
 
573
        self.reset_smart_call_log()
 
574
        out, err = self.run_bzr(['branch', '--stacked', self.get_url('from'),
 
575
            'local-target'])
 
576
        # XXX: the number of hpss calls for this case isn't deterministic yet,
 
577
        # so we can't easily assert about the number of calls.
 
578
        #self.assertLength(XXX, self.hpss_calls)
 
579
        # We can assert that none of the calls were readv requests for rix
 
580
        # files, though (demonstrating that at least get_parent_map calls are
 
581
        # not using VFS RPCs).
 
582
        readvs_of_rix_files = [
 
583
            c for c in self.hpss_calls
 
584
            if c.call.method == 'readv' and c.call.args[-1].endswith('.rix')]
 
585
        self.assertLength(1, self.hpss_connections)
 
586
        self.assertLength(0, readvs_of_rix_files)
 
587
        self.expectFailure("branching to stacked requires VFS access",
 
588
            self.assertThat, self.hpss_calls, ContainsNoVfsCalls)
325
589
 
326
590
 
327
591
class TestRemoteBranch(TestCaseWithSFTPServer):
347
611
        # Ensure that no working tree what created remotely
348
612
        self.assertFalse(t.has('remote/file'))
349
613
 
 
614
 
 
615
class TestDeprecatedAliases(tests.TestCaseWithTransport):
 
616
 
 
617
    def test_deprecated_aliases(self):
 
618
        """bzr branch can be called clone or get, but those names are
 
619
        deprecated.
 
620
 
 
621
        See bug 506265.
 
622
        """
 
623
        for command in ['clone', 'get']:
 
624
            run_script(self, """
 
625
            $ bzr %(command)s A B
 
626
            2>The command 'bzr %(command)s' has been deprecated in bzr 2.4. Please use 'bzr branch' instead.
 
627
            2>bzr: ERROR: Not a branch...
 
628
            """ % locals())
 
629
 
 
630
 
 
631
class TestBranchParentLocation(test_switch.TestSwitchParentLocationBase):
 
632
 
 
633
    def _checkout_and_branch(self, option=''):
 
634
        self.script_runner.run_script(self, '''
 
635
                $ bzr checkout %(option)s repo/trunk checkout
 
636
                $ cd checkout
 
637
                $ bzr branch --switch ../repo/trunk ../repo/branched
 
638
                2>Branched 0 revisions.
 
639
                2>Tree is up to date at revision 0.
 
640
                2>Switched to branch:...branched...
 
641
                $ cd ..
 
642
                ''' % locals())
 
643
        bound_branch = branch.Branch.open_containing('checkout')[0]
 
644
        master_branch = branch.Branch.open_containing('repo/branched')[0]
 
645
        return (bound_branch, master_branch)
 
646
 
 
647
    def test_branch_switch_parent_lightweight(self):
 
648
        """Lightweight checkout using bzr branch --switch."""
 
649
        bb, mb = self._checkout_and_branch(option='--lightweight')
 
650
        self.assertParent('repo/trunk', bb)
 
651
        self.assertParent('repo/trunk', mb)
 
652
 
 
653
    def test_branch_switch_parent_heavyweight(self):
 
654
        """Heavyweight checkout using bzr branch --switch."""
 
655
        bb, mb = self._checkout_and_branch()
 
656
        self.assertParent('repo/trunk', bb)
 
657
        self.assertParent('repo/trunk', mb)