/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 bzrlib/tests/blackbox/test_push.py

  • Committer: Jonathan Lange
  • Date: 2009-07-20 11:27:05 UTC
  • mfrom: (4526.2.6 1.17)
  • mto: This revision was merged to the branch mainline in revision 4554.
  • Revision ID: jml@canonical.com-20090720112705-ss4o5s3zw3dbxsek
Merge 1.17, resolving conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2007, 2008 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Black-box tests for bzr push."""
 
19
 
 
20
import re
 
21
 
 
22
from bzrlib import (
 
23
    branch,
 
24
    bzrdir,
 
25
    errors,
 
26
    osutils,
 
27
    tests,
 
28
    transport,
 
29
    uncommit,
 
30
    urlutils,
 
31
    workingtree
 
32
    )
 
33
from bzrlib.repofmt import knitrepo
 
34
from bzrlib.tests import http_server
 
35
from bzrlib.transport import memory
 
36
 
 
37
 
 
38
def load_tests(standard_tests, module, loader):
 
39
    """Multiply tests for the push command."""
 
40
    result = loader.suiteClass()
 
41
 
 
42
    # one for each king of change
 
43
    changes_tests, remaining_tests = tests.split_suite_by_condition(
 
44
        standard_tests, tests.condition_isinstance((
 
45
                TestPushStrictWithChanges,
 
46
                )))
 
47
    changes_scenarios = [
 
48
        ('uncommitted',
 
49
         dict(_changes_type= '_uncommitted_changes')),
 
50
        ('pending-merges',
 
51
         dict(_changes_type= '_pending_merges')),
 
52
        ('out-of-sync-trees',
 
53
         dict(_changes_type= '_out_of_sync_trees')),
 
54
        ]
 
55
    tests.multiply_tests(changes_tests, changes_scenarios, result)
 
56
    # No parametrization for the remaining tests
 
57
    result.addTests(remaining_tests)
 
58
 
 
59
    return result
 
60
 
 
61
 
 
62
class TestPush(tests.TestCaseWithTransport):
 
63
 
 
64
    def test_push_error_on_vfs_http(self):
 
65
        """ pushing a branch to a HTTP server fails cleanly. """
 
66
        # the trunk is published on a web server
 
67
        self.transport_readonly_server = http_server.HttpServer
 
68
        self.make_branch('source')
 
69
        public_url = self.get_readonly_url('target')
 
70
        self.run_bzr_error(['http does not support mkdir'],
 
71
                           ['push', public_url],
 
72
                           working_dir='source')
 
73
 
 
74
    def test_push_remember(self):
 
75
        """Push changes from one branch to another and test push location."""
 
76
        transport = self.get_transport()
 
77
        tree_a = self.make_branch_and_tree('branch_a')
 
78
        branch_a = tree_a.branch
 
79
        self.build_tree(['branch_a/a'])
 
80
        tree_a.add('a')
 
81
        tree_a.commit('commit a')
 
82
        tree_b = branch_a.bzrdir.sprout('branch_b').open_workingtree()
 
83
        branch_b = tree_b.branch
 
84
        tree_c = branch_a.bzrdir.sprout('branch_c').open_workingtree()
 
85
        branch_c = tree_c.branch
 
86
        self.build_tree(['branch_a/b'])
 
87
        tree_a.add('b')
 
88
        tree_a.commit('commit b')
 
89
        self.build_tree(['branch_b/c'])
 
90
        tree_b.add('c')
 
91
        tree_b.commit('commit c')
 
92
        # initial push location must be empty
 
93
        self.assertEqual(None, branch_b.get_push_location())
 
94
 
 
95
        # test push for failure without push location set
 
96
        out = self.run_bzr('push', working_dir='branch_a', retcode=3)
 
97
        self.assertEquals(out,
 
98
                ('','bzr: ERROR: No push location known or specified.\n'))
 
99
 
 
100
        # test not remembered if cannot actually push
 
101
        self.run_bzr('push path/which/doesnt/exist',
 
102
                     working_dir='branch_a', retcode=3)
 
103
        out = self.run_bzr('push', working_dir='branch_a', retcode=3)
 
104
        self.assertEquals(
 
105
                ('', 'bzr: ERROR: No push location known or specified.\n'),
 
106
                out)
 
107
 
 
108
        # test implicit --remember when no push location set, push fails
 
109
        out = self.run_bzr('push ../branch_b',
 
110
                           working_dir='branch_a', retcode=3)
 
111
        self.assertEquals(out,
 
112
                ('','bzr: ERROR: These branches have diverged.  '
 
113
                 'See "bzr help diverged-branches" for more information.\n'))
 
114
        self.assertEquals(osutils.abspath(branch_a.get_push_location()),
 
115
                          osutils.abspath(branch_b.bzrdir.root_transport.base))
 
116
 
 
117
        # test implicit --remember after resolving previous failure
 
118
        uncommit.uncommit(branch=branch_b, tree=tree_b)
 
119
        transport.delete('branch_b/c')
 
120
        out, err = self.run_bzr('push', working_dir='branch_a')
 
121
        path = branch_a.get_push_location()
 
122
        self.assertEquals(out,
 
123
                          'Using saved push location: %s\n'
 
124
                          % urlutils.local_path_from_url(path))
 
125
        self.assertEqual(err,
 
126
                         'All changes applied successfully.\n'
 
127
                         'Pushed up to revision 2.\n')
 
128
        self.assertEqual(path,
 
129
                         branch_b.bzrdir.root_transport.base)
 
130
        # test explicit --remember
 
131
        self.run_bzr('push ../branch_c --remember', working_dir='branch_a')
 
132
        self.assertEquals(branch_a.get_push_location(),
 
133
                          branch_c.bzrdir.root_transport.base)
 
134
 
 
135
    def test_push_without_tree(self):
 
136
        # bzr push from a branch that does not have a checkout should work.
 
137
        b = self.make_branch('.')
 
138
        out, err = self.run_bzr('push pushed-location')
 
139
        self.assertEqual('', out)
 
140
        self.assertEqual('Created new branch.\n', err)
 
141
        b2 = branch.Branch.open('pushed-location')
 
142
        self.assertEndsWith(b2.base, 'pushed-location/')
 
143
 
 
144
    def test_push_new_branch_revision_count(self):
 
145
        # bzr push of a branch with revisions to a new location
 
146
        # should print the number of revisions equal to the length of the
 
147
        # local branch.
 
148
        t = self.make_branch_and_tree('tree')
 
149
        self.build_tree(['tree/file'])
 
150
        t.add('file')
 
151
        t.commit('commit 1')
 
152
        out, err = self.run_bzr('push -d tree pushed-to')
 
153
        self.assertEqual('', out)
 
154
        self.assertEqual('Created new branch.\n', err)
 
155
 
 
156
    def test_push_only_pushes_history(self):
 
157
        # Knit branches should only push the history for the current revision.
 
158
        format = bzrdir.BzrDirMetaFormat1()
 
159
        format.repository_format = knitrepo.RepositoryFormatKnit1()
 
160
        shared_repo = self.make_repository('repo', format=format, shared=True)
 
161
        shared_repo.set_make_working_trees(True)
 
162
 
 
163
        def make_shared_tree(path):
 
164
            shared_repo.bzrdir.root_transport.mkdir(path)
 
165
            shared_repo.bzrdir.create_branch_convenience('repo/' + path)
 
166
            return workingtree.WorkingTree.open('repo/' + path)
 
167
        tree_a = make_shared_tree('a')
 
168
        self.build_tree(['repo/a/file'])
 
169
        tree_a.add('file')
 
170
        tree_a.commit('commit a-1', rev_id='a-1')
 
171
        f = open('repo/a/file', 'ab')
 
172
        f.write('more stuff\n')
 
173
        f.close()
 
174
        tree_a.commit('commit a-2', rev_id='a-2')
 
175
 
 
176
        tree_b = make_shared_tree('b')
 
177
        self.build_tree(['repo/b/file'])
 
178
        tree_b.add('file')
 
179
        tree_b.commit('commit b-1', rev_id='b-1')
 
180
 
 
181
        self.assertTrue(shared_repo.has_revision('a-1'))
 
182
        self.assertTrue(shared_repo.has_revision('a-2'))
 
183
        self.assertTrue(shared_repo.has_revision('b-1'))
 
184
 
 
185
        # Now that we have a repository with shared files, make sure
 
186
        # that things aren't copied out by a 'push'
 
187
        self.run_bzr('push ../../push-b', working_dir='repo/b')
 
188
        pushed_tree = workingtree.WorkingTree.open('push-b')
 
189
        pushed_repo = pushed_tree.branch.repository
 
190
        self.assertFalse(pushed_repo.has_revision('a-1'))
 
191
        self.assertFalse(pushed_repo.has_revision('a-2'))
 
192
        self.assertTrue(pushed_repo.has_revision('b-1'))
 
193
 
 
194
    def test_push_funky_id(self):
 
195
        t = self.make_branch_and_tree('tree')
 
196
        self.build_tree(['tree/filename'])
 
197
        t.add('filename', 'funky-chars<>%&;"\'')
 
198
        t.commit('commit filename')
 
199
        self.run_bzr('push -d tree new-tree')
 
200
 
 
201
    def test_push_dash_d(self):
 
202
        t = self.make_branch_and_tree('from')
 
203
        t.commit(allow_pointless=True,
 
204
                message='first commit')
 
205
        self.run_bzr('push -d from to-one')
 
206
        self.failUnlessExists('to-one')
 
207
        self.run_bzr('push -d %s %s'
 
208
            % tuple(map(urlutils.local_path_to_url, ['from', 'to-two'])))
 
209
        self.failUnlessExists('to-two')
 
210
 
 
211
    def test_push_smart_non_stacked_streaming_acceptance(self):
 
212
        self.setup_smart_server_with_call_log()
 
213
        t = self.make_branch_and_tree('from')
 
214
        t.commit(allow_pointless=True, message='first commit')
 
215
        self.reset_smart_call_log()
 
216
        self.run_bzr(['push', self.get_url('to-one')], working_dir='from')
 
217
        # This figure represent the amount of work to perform this use case. It
 
218
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
219
        # being too low. If rpc_count increases, more network roundtrips have
 
220
        # become necessary for this use case. Please do not adjust this number
 
221
        # upwards without agreement from bzr's network support maintainers.
 
222
        self.assertLength(9, self.hpss_calls)
 
223
 
 
224
    def test_push_smart_stacked_streaming_acceptance(self):
 
225
        self.setup_smart_server_with_call_log()
 
226
        parent = self.make_branch_and_tree('parent', format='1.9')
 
227
        parent.commit(message='first commit')
 
228
        local = parent.bzrdir.sprout('local').open_workingtree()
 
229
        local.commit(message='local commit')
 
230
        self.reset_smart_call_log()
 
231
        self.run_bzr(['push', '--stacked', '--stacked-on', '../parent',
 
232
            self.get_url('public')], working_dir='local')
 
233
        # This figure represent the amount of work to perform this use case. It
 
234
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
235
        # being too low. If rpc_count increases, more network roundtrips have
 
236
        # become necessary for this use case. Please do not adjust this number
 
237
        # upwards without agreement from bzr's network support maintainers.
 
238
        self.assertLength(14, self.hpss_calls)
 
239
        remote = branch.Branch.open('public')
 
240
        self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
 
241
 
 
242
    def test_push_smart_with_default_stacking_url_path_segment(self):
 
243
        # If the default stacked-on location is a path element then branches
 
244
        # we push there over the smart server are stacked and their
 
245
        # stacked_on_url is that exact path segment. Added to nail bug 385132.
 
246
        self.setup_smart_server_with_call_log()
 
247
        self.make_branch('stack-on', format='1.9')
 
248
        self.make_bzrdir('.').get_config().set_default_stack_on(
 
249
            '/stack-on')
 
250
        self.make_branch('from', format='1.9')
 
251
        out, err = self.run_bzr(['push', '-d', 'from', self.get_url('to')])
 
252
        b = branch.Branch.open(self.get_url('to'))
 
253
        self.assertEqual('/extra/stack-on', b.get_stacked_on_url())
 
254
 
 
255
    def test_push_smart_with_default_stacking_relative_path(self):
 
256
        # If the default stacked-on location is a relative path then branches
 
257
        # we push there over the smart server are stacked and their
 
258
        # stacked_on_url is a relative path. Added to nail bug 385132.
 
259
        self.setup_smart_server_with_call_log()
 
260
        self.make_branch('stack-on', format='1.9')
 
261
        self.make_bzrdir('.').get_config().set_default_stack_on('stack-on')
 
262
        self.make_branch('from', format='1.9')
 
263
        out, err = self.run_bzr(['push', '-d', 'from', self.get_url('to')])
 
264
        b = branch.Branch.open(self.get_url('to'))
 
265
        self.assertEqual('../stack-on', b.get_stacked_on_url())
 
266
 
 
267
    def create_simple_tree(self):
 
268
        tree = self.make_branch_and_tree('tree')
 
269
        self.build_tree(['tree/a'])
 
270
        tree.add(['a'], ['a-id'])
 
271
        tree.commit('one', rev_id='r1')
 
272
        return tree
 
273
 
 
274
    def test_push_create_prefix(self):
 
275
        """'bzr push --create-prefix' will create leading directories."""
 
276
        tree = self.create_simple_tree()
 
277
 
 
278
        self.run_bzr_error(['Parent directory of ../new/tree does not exist'],
 
279
                           'push ../new/tree',
 
280
                           working_dir='tree')
 
281
        self.run_bzr('push ../new/tree --create-prefix',
 
282
                     working_dir='tree')
 
283
        new_tree = workingtree.WorkingTree.open('new/tree')
 
284
        self.assertEqual(tree.last_revision(), new_tree.last_revision())
 
285
        self.failUnlessExists('new/tree/a')
 
286
 
 
287
    def test_push_use_existing(self):
 
288
        """'bzr push --use-existing-dir' can push into an existing dir.
 
289
 
 
290
        By default, 'bzr push' will not use an existing, non-versioned dir.
 
291
        """
 
292
        tree = self.create_simple_tree()
 
293
        self.build_tree(['target/'])
 
294
 
 
295
        self.run_bzr_error(['Target directory ../target already exists',
 
296
                            'Supply --use-existing-dir',
 
297
                           ],
 
298
                           'push ../target', working_dir='tree')
 
299
 
 
300
        self.run_bzr('push --use-existing-dir ../target',
 
301
                     working_dir='tree')
 
302
 
 
303
        new_tree = workingtree.WorkingTree.open('target')
 
304
        self.assertEqual(tree.last_revision(), new_tree.last_revision())
 
305
        # The push should have created target/a
 
306
        self.failUnlessExists('target/a')
 
307
 
 
308
    def test_push_onto_repo(self):
 
309
        """We should be able to 'bzr push' into an existing bzrdir."""
 
310
        tree = self.create_simple_tree()
 
311
        repo = self.make_repository('repo', shared=True)
 
312
 
 
313
        self.run_bzr('push ../repo',
 
314
                     working_dir='tree')
 
315
 
 
316
        # Pushing onto an existing bzrdir will create a repository and
 
317
        # branch as needed, but will only create a working tree if there was
 
318
        # no BzrDir before.
 
319
        self.assertRaises(errors.NoWorkingTree,
 
320
                          workingtree.WorkingTree.open, 'repo')
 
321
        new_branch = branch.Branch.open('repo')
 
322
        self.assertEqual(tree.last_revision(), new_branch.last_revision())
 
323
 
 
324
    def test_push_onto_just_bzrdir(self):
 
325
        """We don't handle when the target is just a bzrdir.
 
326
 
 
327
        Because you shouldn't be able to create *just* a bzrdir in the wild.
 
328
        """
 
329
        # TODO: jam 20070109 Maybe it would be better to create the repository
 
330
        #       if at this point
 
331
        tree = self.create_simple_tree()
 
332
        a_bzrdir = self.make_bzrdir('dir')
 
333
 
 
334
        self.run_bzr_error(['At ../dir you have a valid .bzr control'],
 
335
                'push ../dir',
 
336
                working_dir='tree')
 
337
 
 
338
    def test_push_with_revisionspec(self):
 
339
        """We should be able to push a revision older than the tip."""
 
340
        tree_from = self.make_branch_and_tree('from')
 
341
        tree_from.commit("One.", rev_id="from-1")
 
342
        tree_from.commit("Two.", rev_id="from-2")
 
343
 
 
344
        self.run_bzr('push -r1 ../to', working_dir='from')
 
345
 
 
346
        tree_to = workingtree.WorkingTree.open('to')
 
347
        repo_to = tree_to.branch.repository
 
348
        self.assertTrue(repo_to.has_revision('from-1'))
 
349
        self.assertFalse(repo_to.has_revision('from-2'))
 
350
        self.assertEqual(tree_to.branch.last_revision_info()[1], 'from-1')
 
351
 
 
352
        self.run_bzr_error(
 
353
            ['bzr: ERROR: bzr push --revision '
 
354
             'takes exactly one revision identifier\n'],
 
355
            'push -r0..2 ../to', working_dir='from')
 
356
 
 
357
    def create_trunk_and_feature_branch(self):
 
358
        # We have a mainline
 
359
        trunk_tree = self.make_branch_and_tree('target',
 
360
            format='1.9')
 
361
        trunk_tree.commit('mainline')
 
362
        # and a branch from it
 
363
        branch_tree = self.make_branch_and_tree('branch',
 
364
            format='1.9')
 
365
        branch_tree.pull(trunk_tree.branch)
 
366
        branch_tree.branch.set_parent(trunk_tree.branch.base)
 
367
        # with some work on it
 
368
        branch_tree.commit('moar work plz')
 
369
        return trunk_tree, branch_tree
 
370
 
 
371
    def assertPublished(self, branch_revid, stacked_on):
 
372
        """Assert that the branch 'published' has been published correctly."""
 
373
        published_branch = branch.Branch.open('published')
 
374
        # The published branch refers to the mainline
 
375
        self.assertEqual(stacked_on, published_branch.get_stacked_on_url())
 
376
        # and the branch's work was pushed
 
377
        self.assertTrue(published_branch.repository.has_revision(branch_revid))
 
378
 
 
379
    def test_push_new_branch_stacked_on(self):
 
380
        """Pushing a new branch with --stacked-on creates a stacked branch."""
 
381
        trunk_tree, branch_tree = self.create_trunk_and_feature_branch()
 
382
        # we publish branch_tree with a reference to the mainline.
 
383
        out, err = self.run_bzr(['push', '--stacked-on', trunk_tree.branch.base,
 
384
            self.get_url('published')], working_dir='branch')
 
385
        self.assertEqual('', out)
 
386
        self.assertEqual('Created new stacked branch referring to %s.\n' %
 
387
            trunk_tree.branch.base, err)
 
388
        self.assertPublished(branch_tree.last_revision(),
 
389
            trunk_tree.branch.base)
 
390
 
 
391
    def test_push_new_branch_stacked_uses_parent_when_no_public_url(self):
 
392
        """When the parent has no public url the parent is used as-is."""
 
393
        trunk_tree, branch_tree = self.create_trunk_and_feature_branch()
 
394
        # now we do a stacked push, which should determine the public location
 
395
        # for us.
 
396
        out, err = self.run_bzr(['push', '--stacked',
 
397
            self.get_url('published')], working_dir='branch')
 
398
        self.assertEqual('', out)
 
399
        self.assertEqual('Created new stacked branch referring to %s.\n' %
 
400
            trunk_tree.branch.base, err)
 
401
        self.assertPublished(branch_tree.last_revision(),
 
402
                             trunk_tree.branch.base)
 
403
 
 
404
    def test_push_new_branch_stacked_uses_parent_public(self):
 
405
        """Pushing a new branch with --stacked creates a stacked branch."""
 
406
        trunk_tree, branch_tree = self.create_trunk_and_feature_branch()
 
407
        # the trunk is published on a web server
 
408
        self.transport_readonly_server = http_server.HttpServer
 
409
        trunk_public = self.make_branch('public_trunk', format='1.9')
 
410
        trunk_public.pull(trunk_tree.branch)
 
411
        trunk_public_url = self.get_readonly_url('public_trunk')
 
412
        trunk_tree.branch.set_public_branch(trunk_public_url)
 
413
        # now we do a stacked push, which should determine the public location
 
414
        # for us.
 
415
        out, err = self.run_bzr(['push', '--stacked',
 
416
            self.get_url('published')], working_dir='branch')
 
417
        self.assertEqual('', out)
 
418
        self.assertEqual('Created new stacked branch referring to %s.\n' %
 
419
            trunk_public_url, err)
 
420
        self.assertPublished(branch_tree.last_revision(), trunk_public_url)
 
421
 
 
422
    def test_push_new_branch_stacked_no_parent(self):
 
423
        """Pushing with --stacked and no parent branch errors."""
 
424
        branch = self.make_branch_and_tree('branch', format='1.9')
 
425
        # now we do a stacked push, which should fail as the place to refer too
 
426
        # cannot be determined.
 
427
        out, err = self.run_bzr_error(
 
428
            ['Could not determine branch to refer to\\.'], ['push', '--stacked',
 
429
            self.get_url('published')], working_dir='branch')
 
430
        self.assertEqual('', out)
 
431
        self.assertFalse(self.get_transport('published').has('.'))
 
432
 
 
433
    def test_push_notifies_default_stacking(self):
 
434
        self.make_branch('stack_on', format='1.6')
 
435
        self.make_bzrdir('.').get_config().set_default_stack_on('stack_on')
 
436
        self.make_branch('from', format='1.6')
 
437
        out, err = self.run_bzr('push -d from to')
 
438
        self.assertContainsRe(err,
 
439
                              'Using default stacking branch stack_on at .*')
 
440
 
 
441
    def test_push_stacks_with_default_stacking_if_target_is_stackable(self):
 
442
        self.make_branch('stack_on', format='1.6')
 
443
        self.make_bzrdir('.').get_config().set_default_stack_on('stack_on')
 
444
        self.make_branch('from', format='pack-0.92')
 
445
        out, err = self.run_bzr('push -d from to')
 
446
        b = branch.Branch.open('to')
 
447
        self.assertEqual('../stack_on', b.get_stacked_on_url())
 
448
 
 
449
    def test_push_does_not_change_format_with_default_if_target_cannot(self):
 
450
        self.make_branch('stack_on', format='pack-0.92')
 
451
        self.make_bzrdir('.').get_config().set_default_stack_on('stack_on')
 
452
        self.make_branch('from', format='pack-0.92')
 
453
        out, err = self.run_bzr('push -d from to')
 
454
        b = branch.Branch.open('to')
 
455
        self.assertRaises(errors.UnstackableBranchFormat, b.get_stacked_on_url)
 
456
 
 
457
    def test_push_doesnt_create_broken_branch(self):
 
458
        """Pushing a new standalone branch works even when there's a default
 
459
        stacking policy at the destination.
 
460
 
 
461
        The new branch will preserve the repo format (even if it isn't the
 
462
        default for the branch), and will be stacked when the repo format
 
463
        allows (which means that the branch format isn't necessarly preserved).
 
464
        """
 
465
        self.make_repository('repo', shared=True, format='1.6')
 
466
        builder = self.make_branch_builder('repo/local', format='pack-0.92')
 
467
        builder.start_series()
 
468
        builder.build_snapshot('rev-1', None, [
 
469
            ('add', ('', 'root-id', 'directory', '')),
 
470
            ('add', ('filename', 'f-id', 'file', 'content\n'))])
 
471
        builder.build_snapshot('rev-2', ['rev-1'], [])
 
472
        builder.build_snapshot('rev-3', ['rev-2'],
 
473
            [('modify', ('f-id', 'new-content\n'))])
 
474
        builder.finish_series()
 
475
        branch = builder.get_branch()
 
476
        # Push rev-1 to "trunk", so that we can stack on it.
 
477
        self.run_bzr('push -d repo/local trunk -r 1')
 
478
        # Set a default stacking policy so that new branches will automatically
 
479
        # stack on trunk.
 
480
        self.make_bzrdir('.').get_config().set_default_stack_on('trunk')
 
481
        # Push rev-2 to a new branch "remote".  It will be stacked on "trunk".
 
482
        out, err = self.run_bzr('push -d repo/local remote -r 2')
 
483
        self.assertContainsRe(
 
484
            err, 'Using default stacking branch trunk at .*')
 
485
        # Push rev-3 onto "remote".  If "remote" not stacked and is missing the
 
486
        # fulltext record for f-id @ rev-1, then this will fail.
 
487
        out, err = self.run_bzr('push -d repo/local remote -r 3')
 
488
 
 
489
    def test_push_verbose_shows_log(self):
 
490
        tree = self.make_branch_and_tree('source')
 
491
        tree.commit('rev1')
 
492
        out, err = self.run_bzr('push -v -d source target')
 
493
        # initial push contains log
 
494
        self.assertContainsRe(out, 'rev1')
 
495
        tree.commit('rev2')
 
496
        out, err = self.run_bzr('push -v -d source target')
 
497
        # subsequent push contains log
 
498
        self.assertContainsRe(out, 'rev2')
 
499
        # subsequent log is accurate
 
500
        self.assertNotContainsRe(out, 'rev1')
 
501
 
 
502
    def test_push_from_subdir(self):
 
503
        t = self.make_branch_and_tree('tree')
 
504
        self.build_tree(['tree/dir/', 'tree/dir/file'])
 
505
        t.add('dir', 'dir/file')
 
506
        t.commit('r1')
 
507
        out, err = self.run_bzr('push ../../pushloc', working_dir='tree/dir')
 
508
        self.assertEqual('', out)
 
509
        self.assertEqual('Created new branch.\n', err)
 
510
 
 
511
 
 
512
class RedirectingMemoryTransport(memory.MemoryTransport):
 
513
 
 
514
    def mkdir(self, relpath, mode=None):
 
515
        if self._cwd == '/source/':
 
516
            raise errors.RedirectRequested(self.abspath(relpath),
 
517
                                           self.abspath('../target'),
 
518
                                           is_permanent=True)
 
519
        elif self._cwd == '/infinite-loop/':
 
520
            raise errors.RedirectRequested(self.abspath(relpath),
 
521
                                           self.abspath('../infinite-loop'),
 
522
                                           is_permanent=True)
 
523
        else:
 
524
            return super(RedirectingMemoryTransport, self).mkdir(
 
525
                relpath, mode)
 
526
 
 
527
    def get(self, relpath):
 
528
        if self.clone(relpath)._cwd == '/infinite-loop/':
 
529
            raise errors.RedirectRequested(self.abspath(relpath),
 
530
                                           self.abspath('../infinite-loop'),
 
531
                                           is_permanent=True)
 
532
        else:
 
533
            return super(RedirectingMemoryTransport, self).get(relpath)
 
534
 
 
535
    def _redirected_to(self, source, target):
 
536
        # We do accept redirections
 
537
        return transport.get_transport(target)
 
538
 
 
539
 
 
540
class RedirectingMemoryServer(memory.MemoryServer):
 
541
 
 
542
    def setUp(self):
 
543
        self._dirs = {'/': None}
 
544
        self._files = {}
 
545
        self._locks = {}
 
546
        self._scheme = 'redirecting-memory+%s:///' % id(self)
 
547
        transport.register_transport(self._scheme, self._memory_factory)
 
548
 
 
549
    def _memory_factory(self, url):
 
550
        result = RedirectingMemoryTransport(url)
 
551
        result._dirs = self._dirs
 
552
        result._files = self._files
 
553
        result._locks = self._locks
 
554
        return result
 
555
 
 
556
    def tearDown(self):
 
557
        transport.unregister_transport(self._scheme, self._memory_factory)
 
558
 
 
559
 
 
560
class TestPushRedirect(tests.TestCaseWithTransport):
 
561
 
 
562
    def setUp(self):
 
563
        tests.TestCaseWithTransport.setUp(self)
 
564
        self.memory_server = RedirectingMemoryServer()
 
565
        self.memory_server.setUp()
 
566
        self.addCleanup(self.memory_server.tearDown)
 
567
 
 
568
        # Make the branch and tree that we'll be pushing.
 
569
        t = self.make_branch_and_tree('tree')
 
570
        self.build_tree(['tree/file'])
 
571
        t.add('file')
 
572
        t.commit('commit 1')
 
573
 
 
574
    def test_push_redirects_on_mkdir(self):
 
575
        """If the push requires a mkdir, push respects redirect requests.
 
576
 
 
577
        This is added primarily to handle lp:/ URI support, so that users can
 
578
        push to new branches by specifying lp:/ URIs.
 
579
        """
 
580
        destination_url = self.memory_server.get_url() + 'source'
 
581
        self.run_bzr(['push', '-d', 'tree', destination_url])
 
582
 
 
583
        local_revision = branch.Branch.open('tree').last_revision()
 
584
        remote_revision = branch.Branch.open(
 
585
            self.memory_server.get_url() + 'target').last_revision()
 
586
        self.assertEqual(remote_revision, local_revision)
 
587
 
 
588
    def test_push_gracefully_handles_too_many_redirects(self):
 
589
        """Push fails gracefully if the mkdir generates a large number of
 
590
        redirects.
 
591
        """
 
592
        destination_url = self.memory_server.get_url() + 'infinite-loop'
 
593
        out, err = self.run_bzr_error(
 
594
            ['Too many redirections trying to make %s\\.\n'
 
595
             % re.escape(destination_url)],
 
596
            ['push', '-d', 'tree', destination_url], retcode=3)
 
597
        self.assertEqual('', out)
 
598
 
 
599
 
 
600
class TestPushStrictMixin(object):
 
601
 
 
602
    def make_local_branch_and_tree(self):
 
603
        self.tree = self.make_branch_and_tree('local')
 
604
        self.build_tree_contents([('local/file', 'initial')])
 
605
        self.tree.add('file')
 
606
        self.tree.commit('adding file', rev_id='added')
 
607
        self.build_tree_contents([('local/file', 'modified')])
 
608
        self.tree.commit('modify file', rev_id='modified')
 
609
 
 
610
    def set_config_push_strict(self, value):
 
611
        # set config var (any of bazaar.conf, locations.conf, branch.conf
 
612
        # should do)
 
613
        conf = self.tree.branch.get_config()
 
614
        conf.set_user_option('push_strict', value)
 
615
 
 
616
    _default_command = ['push', '../to']
 
617
    _default_wd = 'local'
 
618
    _default_errors = ['Working tree ".*/local/" has uncommitted '
 
619
                       'changes \(See bzr status\)\.',]
 
620
    _default_pushed_revid = 'modified'
 
621
 
 
622
    def assertPushFails(self, args):
 
623
        self.run_bzr_error(self._default_errors, self._default_command + args,
 
624
                           working_dir=self._default_wd, retcode=3)
 
625
 
 
626
    def assertPushSucceeds(self, args, pushed_revid=None):
 
627
        self.run_bzr(self._default_command + args,
 
628
                     working_dir=self._default_wd)
 
629
        if pushed_revid is None:
 
630
            pushed_revid = self._default_pushed_revid
 
631
        tree_to = workingtree.WorkingTree.open('to')
 
632
        repo_to = tree_to.branch.repository
 
633
        self.assertTrue(repo_to.has_revision(pushed_revid))
 
634
        self.assertEqual(tree_to.branch.last_revision_info()[1], pushed_revid)
 
635
 
 
636
 
 
637
 
 
638
class TestPushStrictWithoutChanges(tests.TestCaseWithTransport,
 
639
                                   TestPushStrictMixin):
 
640
 
 
641
    def setUp(self):
 
642
        super(TestPushStrictWithoutChanges, self).setUp()
 
643
        self.make_local_branch_and_tree()
 
644
 
 
645
    def test_push_default(self):
 
646
        self.assertPushSucceeds([])
 
647
 
 
648
    def test_push_strict(self):
 
649
        self.assertPushSucceeds(['--strict'])
 
650
 
 
651
    def test_push_no_strict(self):
 
652
        self.assertPushSucceeds(['--no-strict'])
 
653
 
 
654
    def test_push_config_var_strict(self):
 
655
        self.set_config_push_strict('true')
 
656
        self.assertPushSucceeds([])
 
657
 
 
658
    def test_push_config_var_no_strict(self):
 
659
        self.set_config_push_strict('false')
 
660
        self.assertPushSucceeds([])
 
661
 
 
662
 
 
663
class TestPushStrictWithChanges(tests.TestCaseWithTransport,
 
664
                                TestPushStrictMixin):
 
665
 
 
666
    _changes_type = None # Set by load_tests
 
667
 
 
668
    def setUp(self):
 
669
        super(TestPushStrictWithChanges, self).setUp()
 
670
        getattr(self, self._changes_type)()
 
671
 
 
672
    def _uncommitted_changes(self):
 
673
        self.make_local_branch_and_tree()
 
674
        # Make a change without committing it
 
675
        self.build_tree_contents([('local/file', 'in progress')])
 
676
 
 
677
    def _pending_merges(self):
 
678
        self.make_local_branch_and_tree()
 
679
        # Create 'other' branch containing a new file
 
680
        other_bzrdir = self.tree.bzrdir.sprout('other')
 
681
        other_tree = other_bzrdir.open_workingtree()
 
682
        self.build_tree_contents([('other/other-file', 'other')])
 
683
        other_tree.add('other-file')
 
684
        other_tree.commit('other commit', rev_id='other')
 
685
        # Merge and revert, leaving a pending merge
 
686
        self.tree.merge_from_branch(other_tree.branch)
 
687
        self.tree.revert(filenames=['other-file'], backups=False)
 
688
 
 
689
    def _out_of_sync_trees(self):
 
690
        self.make_local_branch_and_tree()
 
691
        self.run_bzr(['checkout', '--lightweight', 'local', 'checkout'])
 
692
        # Make a change and commit it
 
693
        self.build_tree_contents([('local/file', 'modified in local')])
 
694
        self.tree.commit('modify file', rev_id='modified-in-local')
 
695
        # Exercise commands from the checkout directory
 
696
        self._default_wd = 'checkout'
 
697
        self._default_errors = ["Working tree is out of date, please run"
 
698
                                " 'bzr update'\.",]
 
699
        self._default_pushed_revid = 'modified-in-local'
 
700
 
 
701
    def test_push_default(self):
 
702
        self.assertPushFails([])
 
703
 
 
704
    def test_push_with_revision(self):
 
705
        self.assertPushSucceeds(['-r', 'revid:added'], pushed_revid='added')
 
706
 
 
707
    def test_push_no_strict(self):
 
708
        self.assertPushSucceeds(['--no-strict'])
 
709
 
 
710
    def test_push_strict_with_changes(self):
 
711
        self.assertPushFails(['--strict'])
 
712
 
 
713
    def test_push_respect_config_var_strict(self):
 
714
        self.set_config_push_strict('true')
 
715
        self.assertPushFails([])
 
716
 
 
717
    def test_push_bogus_config_var_ignored(self):
 
718
        self.set_config_push_strict("I don't want you to be strict")
 
719
        self.assertPushFails([])
 
720
 
 
721
    def test_push_no_strict_command_line_override_config(self):
 
722
        self.set_config_push_strict('yES')
 
723
        self.assertPushFails([])
 
724
        self.assertPushSucceeds(['--no-strict'])
 
725
 
 
726
    def test_push_strict_command_line_override_config(self):
 
727
        self.set_config_push_strict('oFF')
 
728
        self.assertPushFails(['--strict'])
 
729
        self.assertPushSucceeds([])