/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/blackbox/test_switch.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_switch.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007-2012, 2016 Canonical Ltd
2
2
# -*- coding: utf-8 -*-
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
20
20
 
21
21
import os
22
22
 
23
 
from bzrlib import osutils
24
 
from bzrlib.workingtree import WorkingTree
25
 
from bzrlib.tests.blackbox import ExternalBase
26
 
from bzrlib.directory_service import directories
27
 
 
28
 
 
29
 
class TestSwitch(ExternalBase):
 
23
from breezy.controldir import ControlDir
 
24
from breezy import (
 
25
    osutils,
 
26
    urlutils,
 
27
    branch,
 
28
    )
 
29
from breezy.workingtree import WorkingTree
 
30
from breezy.tests import (
 
31
    TestCaseWithTransport,
 
32
    script,
 
33
    )
 
34
from breezy.tests.features import UnicodeFilenameFeature
 
35
from breezy.directory_service import directories
 
36
 
 
37
from breezy.tests.matchers import ContainsNoVfsCalls
 
38
 
 
39
 
 
40
class TestSwitch(TestCaseWithTransport):
30
41
 
31
42
    def _create_sample_tree(self):
32
43
        tree = self.make_branch_and_tree('branch-1')
44
55
        os.chdir('checkout')
45
56
        out, err = self.run_bzr('switch ../branch2')
46
57
        self.assertContainsRe(err, 'Tree is up to date at revision 0.\n')
47
 
        self.assertContainsRe(err, 'Switched to branch: .*/branch2.\n')
 
58
        self.assertContainsRe(err, 'Switched to branch at .*/branch2.\n')
48
59
        self.assertEqual('', out)
49
60
 
50
61
    def test_switch_out_of_date_light_checkout(self):
58
69
        out, err = self.run_bzr('switch ../branch2')
59
70
        #self.assertContainsRe(err, '\+N  file')
60
71
        self.assertContainsRe(err, 'Updated to revision 1.\n')
61
 
        self.assertContainsRe(err, 'Switched to branch: .*/branch2.\n')
 
72
        self.assertContainsRe(err, 'Switched to branch at .*/branch2.\n')
62
73
        self.assertEqual('', out)
63
74
 
64
75
    def _test_switch_nick(self, lightweight):
66
77
        tree1 = self.make_branch_and_tree('branch1')
67
78
        tree2 = self.make_branch_and_tree('branch2')
68
79
        tree2.pull(tree1.branch)
69
 
        checkout =  tree1.branch.create_checkout('checkout',
70
 
            lightweight=lightweight)
 
80
        checkout = tree1.branch.create_checkout('checkout',
 
81
                                                lightweight=lightweight)
71
82
        self.assertEqual(checkout.branch.nick, tree1.branch.nick)
72
83
        self.assertEqual(checkout.branch.get_config().has_explicit_nickname(),
73
 
            False)
 
84
                         False)
74
85
        self.run_bzr('switch branch2', working_dir='checkout')
75
86
 
76
87
        # we need to get the tree again, otherwise we don't get the new branch
77
88
        checkout = WorkingTree.open('checkout')
78
89
        self.assertEqual(checkout.branch.nick, tree2.branch.nick)
79
90
        self.assertEqual(checkout.branch.get_config().has_explicit_nickname(),
80
 
            False)
 
91
                         False)
81
92
 
82
93
    def test_switch_nick(self):
83
94
        self._test_switch_nick(lightweight=False)
90
101
        tree1 = self.make_branch_and_tree('branch1')
91
102
        tree2 = self.make_branch_and_tree('branch2')
92
103
        tree2.pull(tree1.branch)
93
 
        checkout =  tree1.branch.create_checkout('checkout',
94
 
            lightweight=lightweight)
 
104
        checkout = tree1.branch.create_checkout('checkout',
 
105
                                                lightweight=lightweight)
95
106
        self.assertEqual(checkout.branch.nick, tree1.branch.nick)
96
107
        checkout.branch.nick = "explicit_nick"
97
108
        self.assertEqual(checkout.branch.nick, "explicit_nick")
98
109
        self.assertEqual(checkout.branch.get_config()._get_explicit_nickname(),
99
 
            "explicit_nick")
 
110
                         "explicit_nick")
100
111
        self.run_bzr('switch branch2', working_dir='checkout')
101
112
 
102
113
        # we need to get the tree again, otherwise we don't get the new branch
103
114
        checkout = WorkingTree.open('checkout')
104
115
        self.assertEqual(checkout.branch.nick, tree2.branch.nick)
105
116
        self.assertEqual(checkout.branch.get_config()._get_explicit_nickname(),
106
 
            tree2.branch.nick)
 
117
                         tree2.branch.nick)
107
118
 
108
119
    def test_switch_explicit_nick(self):
109
120
        self._test_switch_explicit_nick(lightweight=False)
119
130
        tree2 = self.make_branch_and_tree('repo/branchb')
120
131
        tree2.pull(tree1.branch)
121
132
        branchb_id = tree2.commit('bar')
122
 
        checkout =  tree1.branch.create_checkout('checkout', lightweight=True)
 
133
        checkout = tree1.branch.create_checkout('checkout', lightweight=True)
123
134
        self.run_bzr(['switch', 'branchb'], working_dir='checkout')
124
135
        self.assertEqual(branchb_id, checkout.last_revision())
125
 
        checkout = checkout.bzrdir.open_workingtree()
 
136
        checkout = checkout.controldir.open_workingtree()
126
137
        self.assertEqual(tree2.branch.base, checkout.branch.base)
127
138
 
128
139
    def test_switch_finds_relative_bound_branch(self):
129
140
        """Using switch on a heavy checkout should find master sibling
130
141
 
131
142
        The behaviour of lighweight and heavy checkouts should be
132
 
        consistentwhen using the convenient "switch to sibling" feature
 
143
        consistent when using the convenient "switch to sibling" feature
133
144
        Both should switch to a sibling of the branch
134
145
        they are bound to, and not a sibling of themself"""
135
146
 
142
153
        branchb_id = tree2.commit('bar')
143
154
        checkout = tree1.branch.create_checkout('heavyco/a', lightweight=False)
144
155
        self.run_bzr(['switch', 'branchb'], working_dir='heavyco/a')
145
 
        self.assertEqual(branchb_id, checkout.last_revision())
146
 
        self.assertEqual(tree2.branch.base, checkout.branch.get_bound_location())
 
156
        # Refresh checkout as 'switch' modified it
 
157
        checkout = checkout.controldir.open_workingtree()
 
158
        self.assertEqual(branchb_id, checkout.last_revision())
 
159
        self.assertEqual(tree2.branch.base,
 
160
                         checkout.branch.get_bound_location())
 
161
 
 
162
    def test_switch_finds_relative_unicode_branch(self):
 
163
        """Switch will find 'foo' relative to the branch the checkout is of."""
 
164
        self.requireFeature(UnicodeFilenameFeature)
 
165
        self.build_tree(['repo/'])
 
166
        tree1 = self.make_branch_and_tree('repo/brancha')
 
167
        tree1.commit('foo')
 
168
        tree2 = self.make_branch_and_tree(u'repo/branch\xe9')
 
169
        tree2.pull(tree1.branch)
 
170
        branchb_id = tree2.commit('bar')
 
171
        checkout = tree1.branch.create_checkout('checkout', lightweight=True)
 
172
        self.run_bzr(['switch', u'branch\xe9'], working_dir='checkout')
 
173
        self.assertEqual(branchb_id, checkout.last_revision())
 
174
        checkout = checkout.controldir.open_workingtree()
 
175
        self.assertEqual(tree2.branch.base, checkout.branch.base)
 
176
 
 
177
    def test_switch_finds_relative_unicode_branch(self):
 
178
        """Switch will find 'foo' relative to the branch the checkout is of."""
 
179
        self.requireFeature(UnicodeFilenameFeature)
 
180
        self.build_tree(['repo/'])
 
181
        tree1 = self.make_branch_and_tree('repo/brancha')
 
182
        tree1.commit('foo')
 
183
        tree2 = self.make_branch_and_tree(u'repo/branch\xe9')
 
184
        tree2.pull(tree1.branch)
 
185
        branchb_id = tree2.commit('bar')
 
186
        checkout = tree1.branch.create_checkout('checkout', lightweight=True)
 
187
        self.run_bzr(['switch', u'branch\xe9'], working_dir='checkout')
 
188
        self.assertEqual(branchb_id, checkout.last_revision())
 
189
        checkout = checkout.controldir.open_workingtree()
 
190
        self.assertEqual(tree2.branch.base, checkout.branch.base)
147
191
 
148
192
    def test_switch_revision(self):
149
193
        tree = self._create_sample_tree()
150
194
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
151
195
        self.run_bzr(['switch', 'branch-1', '-r1'], working_dir='checkout')
152
 
        self.failUnlessExists('checkout/file-1')
153
 
        self.failIfExists('checkout/file-2')
 
196
        self.assertPathExists('checkout/file-1')
 
197
        self.assertPathDoesNotExist('checkout/file-2')
 
198
 
 
199
    def test_switch_into_colocated(self):
 
200
        # Create a new colocated branch from an existing non-colocated branch.
 
201
        tree = self.make_branch_and_tree('.', format='development-colo')
 
202
        self.build_tree(['file-1', 'file-2'])
 
203
        tree.add('file-1')
 
204
        revid1 = tree.commit('rev1')
 
205
        tree.add('file-2')
 
206
        revid2 = tree.commit('rev2')
 
207
        self.run_bzr(['switch', '-b', 'anotherbranch'])
 
208
        self.assertEqual(
 
209
            {'', 'anotherbranch'},
 
210
            set(tree.branch.controldir.branch_names()))
 
211
 
 
212
    def test_switch_into_unrelated_colocated(self):
 
213
        # Create a new colocated branch from an existing non-colocated branch.
 
214
        tree = self.make_branch_and_tree('.', format='development-colo')
 
215
        self.build_tree(['file-1', 'file-2'])
 
216
        tree.add('file-1')
 
217
        revid1 = tree.commit('rev1')
 
218
        tree.add('file-2')
 
219
        revid2 = tree.commit('rev2')
 
220
        tree.controldir.create_branch(name='foo')
 
221
        self.run_bzr_error(['Cannot switch a branch, only a checkout.'],
 
222
                           'switch foo')
 
223
        self.run_bzr(['switch', '--force', 'foo'])
 
224
 
 
225
    def test_switch_existing_colocated(self):
 
226
        # Create a branch branch-1 that initially is a checkout of 'foo'
 
227
        # Use switch to change it to 'anotherbranch'
 
228
        repo = self.make_repository('branch-1', format='development-colo')
 
229
        target_branch = repo.controldir.create_branch(name='foo')
 
230
        repo.controldir.set_branch_reference(target_branch)
 
231
        tree = repo.controldir.create_workingtree()
 
232
        self.build_tree(['branch-1/file-1', 'branch-1/file-2'])
 
233
        tree.add('file-1')
 
234
        revid1 = tree.commit('rev1')
 
235
        tree.add('file-2')
 
236
        revid2 = tree.commit('rev2')
 
237
        otherbranch = tree.controldir.create_branch(name='anotherbranch')
 
238
        otherbranch.generate_revision_history(revid1)
 
239
        self.run_bzr(['switch', 'anotherbranch'], working_dir='branch-1')
 
240
        tree = WorkingTree.open("branch-1")
 
241
        self.assertEqual(tree.last_revision(), revid1)
 
242
        self.assertEqual(tree.branch.control_url, otherbranch.control_url)
 
243
 
 
244
    def test_switch_new_colocated(self):
 
245
        # Create a branch branch-1 that initially is a checkout of 'foo'
 
246
        # Use switch to create 'anotherbranch' which derives from that
 
247
        repo = self.make_repository('branch-1', format='development-colo')
 
248
        target_branch = repo.controldir.create_branch(name='foo')
 
249
        repo.controldir.set_branch_reference(target_branch)
 
250
        tree = repo.controldir.create_workingtree()
 
251
        self.build_tree(['branch-1/file-1', 'branch-1/file-2'])
 
252
        tree.add('file-1')
 
253
        revid1 = tree.commit('rev1')
 
254
        self.run_bzr(['switch', '-b', 'anotherbranch'], working_dir='branch-1')
 
255
        bzrdir = ControlDir.open("branch-1")
 
256
        self.assertEqual(
 
257
            {b.name for b in bzrdir.list_branches()},
 
258
            {"foo", "anotherbranch"})
 
259
        self.assertEqual(bzrdir.open_branch().name, "anotherbranch")
 
260
        self.assertEqual(bzrdir.open_branch().last_revision(), revid1)
 
261
 
 
262
    def test_switch_new_colocated_unicode(self):
 
263
        # Create a branch branch-1 that initially is a checkout of 'foo'
 
264
        # Use switch to create 'branch\xe9' which derives from that
 
265
        self.requireFeature(UnicodeFilenameFeature)
 
266
        repo = self.make_repository('branch-1', format='development-colo')
 
267
        target_branch = repo.controldir.create_branch(name='foo')
 
268
        repo.controldir.set_branch_reference(target_branch)
 
269
        tree = repo.controldir.create_workingtree()
 
270
        self.build_tree(['branch-1/file-1', 'branch-1/file-2'])
 
271
        tree.add('file-1')
 
272
        revid1 = tree.commit('rev1')
 
273
        self.run_bzr(['switch', '-b', u'branch\xe9'], working_dir='branch-1')
 
274
        bzrdir = ControlDir.open("branch-1")
 
275
        self.assertEqual(
 
276
            {b.name for b in bzrdir.list_branches()},
 
277
            {"foo", u"branch\xe9"})
 
278
        self.assertEqual(bzrdir.open_branch().name, u"branch\xe9")
 
279
        self.assertEqual(bzrdir.open_branch().last_revision(), revid1)
154
280
 
155
281
    def test_switch_only_revision(self):
156
282
        tree = self._create_sample_tree()
157
283
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
158
 
        self.failUnlessExists('checkout/file-1')
159
 
        self.failUnlessExists('checkout/file-2')
 
284
        self.assertPathExists('checkout/file-1')
 
285
        self.assertPathExists('checkout/file-2')
160
286
        self.run_bzr(['switch', '-r1'], working_dir='checkout')
161
 
        self.failUnlessExists('checkout/file-1')
162
 
        self.failIfExists('checkout/file-2')
 
287
        self.assertPathExists('checkout/file-1')
 
288
        self.assertPathDoesNotExist('checkout/file-2')
163
289
        # Check that we don't accept a range
164
290
        self.run_bzr_error(
165
 
            ['bzr switch --revision takes exactly one revision identifier'],
 
291
            ['brz switch --revision takes exactly one revision identifier'],
166
292
            ['switch', '-r0..2'], working_dir='checkout')
167
293
 
168
294
    def prepare_lightweight_switch(self):
178
304
 
179
305
    def test_switch_lightweight_after_branch_moved_relative(self):
180
306
        self.prepare_lightweight_switch()
181
 
        self.run_bzr('switch --force branch1', working_dir='tree')
 
307
        self.run_bzr('switch --force branch1',
 
308
                     working_dir='tree')
182
309
        branch_location = WorkingTree.open('tree').branch.base
183
310
        self.assertEndsWith(branch_location, 'branch1/')
184
311
 
185
312
    def test_create_branch_no_branch(self):
186
313
        self.prepare_lightweight_switch()
187
314
        self.run_bzr_error(['cannot create branch without source branch'],
188
 
            'switch --create-branch ../branch2', working_dir='tree')
 
315
                           'switch --create-branch ../branch2', working_dir='tree')
189
316
 
190
317
    def test_create_branch(self):
191
318
        branch = self.make_branch('branch')
192
319
        tree = branch.create_checkout('tree', lightweight=True)
193
 
        tree.commit('one', rev_id='rev-1')
 
320
        tree.commit('one', rev_id=b'rev-1')
194
321
        self.run_bzr('switch --create-branch ../branch2', working_dir='tree')
195
322
        tree = WorkingTree.open('tree')
196
323
        self.assertEndsWith(tree.branch.base, '/branch2/')
198
325
    def test_create_branch_local(self):
199
326
        branch = self.make_branch('branch')
200
327
        tree = branch.create_checkout('tree', lightweight=True)
201
 
        tree.commit('one', rev_id='rev-1')
 
328
        tree.commit('one', rev_id=b'rev-1')
202
329
        self.run_bzr('switch --create-branch branch2', working_dir='tree')
203
330
        tree = WorkingTree.open('tree')
204
331
        # The new branch should have been created at the same level as
208
335
    def test_create_branch_short_name(self):
209
336
        branch = self.make_branch('branch')
210
337
        tree = branch.create_checkout('tree', lightweight=True)
211
 
        tree.commit('one', rev_id='rev-1')
 
338
        tree.commit('one', rev_id=b'rev-1')
212
339
        self.run_bzr('switch -b branch2', working_dir='tree')
213
340
        tree = WorkingTree.open('tree')
214
341
        # The new branch should have been created at the same level as
218
345
    def test_create_branch_directory_services(self):
219
346
        branch = self.make_branch('branch')
220
347
        tree = branch.create_checkout('tree', lightweight=True)
 
348
 
221
349
        class FooLookup(object):
222
 
            def look_up(self, name, url):
223
 
                return 'foo-'+name
 
350
            def look_up(self, name, url, purpose=None):
 
351
                return 'foo-' + name
224
352
        directories.register('foo:', FooLookup, 'Create branches named foo-')
225
353
        self.addCleanup(directories.remove, 'foo:')
226
354
        self.run_bzr('switch -b foo:branch2', working_dir='tree')
228
356
        self.assertEndsWith(tree.branch.base, 'foo-branch2/')
229
357
 
230
358
    def test_switch_with_post_switch_hook(self):
231
 
        from bzrlib import branch as _mod_branch
 
359
        from breezy import branch as _mod_branch
232
360
        calls = []
233
361
        _mod_branch.Branch.hooks.install_named_hook('post_switch',
234
 
            calls.append, None)
 
362
                                                    calls.append, None)
235
363
        self.make_branch_and_tree('branch')
236
364
        self.run_bzr('branch branch branch2')
237
365
        self.run_bzr('checkout branch checkout')
241
369
        self.assertLength(1, calls)
242
370
 
243
371
    def test_switch_lightweight_co_with_post_switch_hook(self):
244
 
        from bzrlib import branch as _mod_branch
 
372
        from breezy import branch as _mod_branch
245
373
        calls = []
246
374
        _mod_branch.Branch.hooks.install_named_hook('post_switch',
247
 
            calls.append, None)
 
375
                                                    calls.append, None)
248
376
        self.make_branch_and_tree('branch')
249
377
        self.run_bzr('branch branch branch2')
250
378
        self.run_bzr('checkout --lightweight branch checkout')
252
380
        self.assertLength(0, calls)
253
381
        out, err = self.run_bzr('switch ../branch2')
254
382
        self.assertLength(1, calls)
 
383
 
 
384
    def test_switch_lightweight_directory(self):
 
385
        """Test --directory option"""
 
386
 
 
387
        # create a source branch
 
388
        a_tree = self.make_branch_and_tree('a')
 
389
        self.build_tree_contents([('a/a', b'initial\n')])
 
390
        a_tree.add('a')
 
391
        a_tree.commit(message='initial')
 
392
 
 
393
        # clone and add a differing revision
 
394
        b_tree = a_tree.controldir.sprout('b').open_workingtree()
 
395
        self.build_tree_contents([('b/a', b'initial\nmore\n')])
 
396
        b_tree.commit(message='more')
 
397
 
 
398
        self.run_bzr('checkout --lightweight a checkout')
 
399
        self.run_bzr('switch --directory checkout b')
 
400
        self.assertFileEqual(b'initial\nmore\n', 'checkout/a')
 
401
 
 
402
 
 
403
class TestSwitchParentLocationBase(TestCaseWithTransport):
 
404
 
 
405
    def setUp(self):
 
406
        """Set up a repository and branch ready for testing."""
 
407
        super(TestSwitchParentLocationBase, self).setUp()
 
408
        self.script_runner = script.ScriptRunner()
 
409
        self.script_runner.run_script(self, '''
 
410
                $ brz init-shared-repo --no-trees repo
 
411
                Shared repository...
 
412
                Location:
 
413
                  shared repository: repo
 
414
                $ brz init repo/trunk
 
415
                Created a repository branch...
 
416
                Using shared repository: ...
 
417
                ''')
 
418
 
 
419
    def assertParent(self, expected_parent, branch):
 
420
        """Verify that the parent is not None and is set correctly."""
 
421
        actual_parent = branch.get_parent()
 
422
        self.assertIsSameRealPath(urlutils.local_path_to_url(expected_parent),
 
423
                                  branch.get_parent())
 
424
 
 
425
 
 
426
class TestSwitchParentLocation(TestSwitchParentLocationBase):
 
427
 
 
428
    def _checkout_and_switch(self, option=''):
 
429
        self.script_runner.run_script(self, '''
 
430
                $ brz checkout %(option)s repo/trunk checkout
 
431
                $ cd checkout
 
432
                $ brz switch --create-branch switched
 
433
                2>Tree is up to date at revision 0.
 
434
                2>Switched to branch at .../switched/
 
435
                $ cd ..
 
436
                ''' % locals())
 
437
        bound_branch = branch.Branch.open_containing('checkout')[0]
 
438
        master_branch = branch.Branch.open_containing('repo/switched')[0]
 
439
        return (bound_branch, master_branch)
 
440
 
 
441
    def test_switch_parent_lightweight(self):
 
442
        """Lightweight checkout using brz switch."""
 
443
        bb, mb = self._checkout_and_switch(option='--lightweight')
 
444
        self.assertParent('repo/trunk', bb)
 
445
        self.assertParent('repo/trunk', mb)
 
446
 
 
447
    def test_switch_parent_heavyweight(self):
 
448
        """Heavyweight checkout using brz switch."""
 
449
        bb, mb = self._checkout_and_switch()
 
450
        self.assertParent('repo/trunk', bb)
 
451
        self.assertParent('repo/trunk', mb)
 
452
 
 
453
 
 
454
class TestSwitchDoesntOpenMasterBranch(TestCaseWithTransport):
 
455
    # See https://bugs.launchpad.net/bzr/+bug/812285
 
456
    # "brz switch --create-branch" can point the new branch's parent to the
 
457
    # master branch, but it doesn't have to open it to do so.
 
458
 
 
459
    def test_switch_create_doesnt_open_master_branch(self):
 
460
        master = self.make_branch_and_tree('master')
 
461
        master.commit('one')
 
462
        # Note: not a lightweight checkout
 
463
        checkout = master.branch.create_checkout('checkout')
 
464
        opened = []
 
465
 
 
466
        def open_hook(branch):
 
467
            # Just append the final directory of the branch
 
468
            name = branch.base.rstrip('/').rsplit('/', 1)[1]
 
469
            opened.append(name)
 
470
        branch.Branch.hooks.install_named_hook('open', open_hook,
 
471
                                               'open_hook_logger')
 
472
        self.run_bzr('switch --create-branch -d checkout feature')
 
473
        # We only open the master branch 1 time.
 
474
        # This test should be cleaner to write, but see bug:
 
475
        #  https://bugs.launchpad.net/bzr/+bug/812295
 
476
        self.assertEqual(1, opened.count('master'))
 
477
 
 
478
 
 
479
class TestSmartServerSwitch(TestCaseWithTransport):
 
480
 
 
481
    def test_switch_lightweight(self):
 
482
        self.setup_smart_server_with_call_log()
 
483
        t = self.make_branch_and_tree('from')
 
484
        for count in range(9):
 
485
            t.commit(message='commit %d' % count)
 
486
        out, err = self.run_bzr(['checkout', '--lightweight', self.get_url('from'),
 
487
                                 'target'])
 
488
        self.reset_smart_call_log()
 
489
        self.run_bzr(['switch', self.get_url('from')], working_dir='target')
 
490
        # This figure represent the amount of work to perform this use case. It
 
491
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
492
        # being too low. If rpc_count increases, more network roundtrips have
 
493
        # become necessary for this use case. Please do not adjust this number
 
494
        # upwards without agreement from bzr's network support maintainers.
 
495
        self.assertLength(21, self.hpss_calls)
 
496
        self.assertLength(3, self.hpss_connections)
 
497
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
 
498
 
 
499
 
 
500
class TestSwitchUncommitted(TestCaseWithTransport):
 
501
 
 
502
    def prepare(self):
 
503
        tree = self.make_branch_and_tree('orig')
 
504
        tree.commit('')
 
505
        tree.branch.controldir.sprout('new')
 
506
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
 
507
        self.build_tree(['checkout/a'])
 
508
        self.assertPathExists('checkout/a')
 
509
        checkout.add('a')
 
510
        return checkout
 
511
 
 
512
    def test_store_and_restore_uncommitted(self):
 
513
        checkout = self.prepare()
 
514
        self.run_bzr(['switch', '--store', '-d', 'checkout', 'new'])
 
515
        self.build_tree(['checkout/b'])
 
516
        checkout.add('b')
 
517
        self.assertPathDoesNotExist('checkout/a')
 
518
        self.assertPathExists('checkout/b')
 
519
        self.run_bzr(['switch', '--store', '-d', 'checkout', 'orig'])
 
520
        self.assertPathExists('checkout/a')
 
521
        self.assertPathDoesNotExist('checkout/b')
 
522
 
 
523
    def test_does_not_store(self):
 
524
        self.prepare()
 
525
        self.run_bzr(['switch', '-d', 'checkout', 'new'])
 
526
        self.assertPathExists('checkout/a')
 
527
 
 
528
    def test_does_not_restore_changes(self):
 
529
        self.prepare()
 
530
        self.run_bzr(['switch', '--store', '-d', 'checkout', 'new'])
 
531
        self.assertPathDoesNotExist('checkout/a')
 
532
        self.run_bzr(['switch', '-d', 'checkout', 'orig'])
 
533
        self.assertPathDoesNotExist('checkout/a')
 
534
 
 
535
 
 
536
class TestSwitchStandAloneCorruption(TestCaseWithTransport):
 
537
 
 
538
    def test_empty_tree_switch(self):
 
539
        """switch . on an empty tree gets infinite recursion
 
540
 
 
541
        Inspired by: https://bugs.launchpad.net/bzr/+bug/1018628
 
542
        """
 
543
        self.script_runner = script.ScriptRunner()
 
544
        self.script_runner.run_script(self, '''
 
545
            $ brz init
 
546
            Created a standalone tree (format: 2a)
 
547
            $ brz switch .
 
548
            2>brz: ERROR: switching would create a branch reference loop. Use the "bzr up" command to switch to a different revision.
 
549
            ''')
 
550
 
 
551
    def test_switch_on_previous_rev(self):
 
552
        """switch to previous rev in a standalone directory
 
553
 
 
554
        Inspired by: https://bugs.launchpad.net/brz/+bug/1018628
 
555
        """
 
556
        self.script_runner = script.ScriptRunner()
 
557
        self.script_runner.run_script(self, '''
 
558
           $ brz init
 
559
           Created a standalone tree (format: 2a)
 
560
           $ brz commit -m 1 --unchanged
 
561
           $ brz commit -m 2 --unchanged
 
562
           $ brz switch -r 1
 
563
           2>brz: ERROR: switching would create a branch reference loop. Use the "bzr up" command to switch to a different revision.''',
 
564
                                      null_output_matches_anything=True)
 
565
 
 
566
    def test_switch_create_colo_locks_repo_path(self):
 
567
        self.script_runner = script.ScriptRunner()
 
568
        self.script_runner.run_script(self, '''
 
569
            $ mkdir mywork
 
570
            $ cd mywork
 
571
            $ brz init
 
572
            Created a standalone tree (format: 2a)
 
573
            $ echo A > a && brz add a && brz commit -m A
 
574
            $ brz switch -b br1
 
575
            $ cd ..
 
576
            $ mv mywork mywork1
 
577
            $ cd mywork1
 
578
            $ brz branches
 
579
              br1
 
580
            ''', null_output_matches_anything=True)
 
581
 
 
582
    def test_switch_to_new_branch_on_old_rev(self):
 
583
        """switch to previous rev in a standalone directory
 
584
 
 
585
        Inspired by: https://bugs.launchpad.net/brz/+bug/933362
 
586
        """
 
587
        self.script_runner = script.ScriptRunner()
 
588
        self.script_runner.run_script(self, '''
 
589
           $ brz init
 
590
           Created a standalone tree (format: 2a)
 
591
           $ brz switch -b trunk
 
592
           2>Tree is up to date at revision 0.
 
593
           2>Switched to branch trunk
 
594
           $ brz commit -m 1 --unchanged
 
595
           2>Committing to: ...
 
596
           2>Committed revision 1.
 
597
           $ brz commit -m 2 --unchanged
 
598
           2>Committing to: ...
 
599
           2>Committed revision 2.
 
600
           $ brz switch -b blah -r1
 
601
           2>Updated to revision 1.
 
602
           2>Switched to branch blah
 
603
           $ brz branches
 
604
           * blah
 
605
             trunk
 
606
           $ brz st
 
607
           ''')