/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-06-10 08:03:41 UTC
  • mto: This revision was merged to the branch mainline in revision 4433.
  • Revision ID: jml@canonical.com-20090610080341-wnsgsy70p5jw279u
Remove unused imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_push.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2007, 2008 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
17
17
 
18
18
"""Black-box tests for bzr push."""
19
19
 
 
20
import os
20
21
import re
21
22
 
22
23
from bzrlib import (
23
 
    branch,
24
 
    bzrdir,
25
24
    errors,
26
 
    osutils,
27
 
    tests,
28
25
    transport,
29
 
    uncommit,
30
26
    urlutils,
31
 
    workingtree
32
 
    )
33
 
from bzrlib.repofmt import knitrepo
34
 
from bzrlib.tests import (
35
 
    blackbox,
36
 
    http_server,
37
 
    test_foreign,
38
 
    test_server,
39
 
    )
40
 
from bzrlib.transport import memory
41
 
 
42
 
 
43
 
def load_tests(standard_tests, module, loader):
44
 
    """Multiply tests for the push command."""
45
 
    result = loader.suiteClass()
46
 
 
47
 
    # one for each king of change
48
 
    changes_tests, remaining_tests = tests.split_suite_by_condition(
49
 
        standard_tests, tests.condition_isinstance((
50
 
                TestPushStrictWithChanges,
51
 
                )))
52
 
    changes_scenarios = [
53
 
        ('uncommitted',
54
 
         dict(_changes_type= '_uncommitted_changes')),
55
 
        ('pending-merges',
56
 
         dict(_changes_type= '_pending_merges')),
57
 
        ('out-of-sync-trees',
58
 
         dict(_changes_type= '_out_of_sync_trees')),
59
 
        ]
60
 
    tests.multiply_tests(changes_tests, changes_scenarios, result)
61
 
    # No parametrization for the remaining tests
62
 
    result.addTests(remaining_tests)
63
 
 
64
 
    return result
65
 
 
66
 
 
67
 
class TestPush(tests.TestCaseWithTransport):
 
27
    )
 
28
from bzrlib.branch import Branch
 
29
from bzrlib.bzrdir import BzrDirMetaFormat1
 
30
from bzrlib.osutils import abspath
 
31
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1
 
32
from bzrlib.tests.blackbox import ExternalBase
 
33
from bzrlib.tests.http_server import HttpServer
 
34
from bzrlib.transport.memory import MemoryServer, MemoryTransport
 
35
from bzrlib.uncommit import uncommit
 
36
from bzrlib.urlutils import local_path_from_url
 
37
from bzrlib.workingtree import WorkingTree
 
38
 
 
39
 
 
40
class TestPush(ExternalBase):
68
41
 
69
42
    def test_push_error_on_vfs_http(self):
70
43
        """ pushing a branch to a HTTP server fails cleanly. """
71
44
        # the trunk is published on a web server
72
 
        self.transport_readonly_server = http_server.HttpServer
 
45
        self.transport_readonly_server = HttpServer
73
46
        self.make_branch('source')
74
47
        public_url = self.get_readonly_url('target')
75
48
        self.run_bzr_error(['http does not support mkdir'],
98
71
        self.assertEqual(None, branch_b.get_push_location())
99
72
 
100
73
        # test push for failure without push location set
101
 
        out = self.run_bzr('push', working_dir='branch_a', retcode=3)
 
74
        os.chdir('branch_a')
 
75
        out = self.run_bzr('push', retcode=3)
102
76
        self.assertEquals(out,
103
77
                ('','bzr: ERROR: No push location known or specified.\n'))
104
78
 
105
79
        # test not remembered if cannot actually push
106
 
        self.run_bzr('push path/which/doesnt/exist',
107
 
                     working_dir='branch_a', retcode=3)
108
 
        out = self.run_bzr('push', working_dir='branch_a', retcode=3)
 
80
        self.run_bzr('push ../path/which/doesnt/exist', retcode=3)
 
81
        out = self.run_bzr('push', retcode=3)
109
82
        self.assertEquals(
110
83
                ('', 'bzr: ERROR: No push location known or specified.\n'),
111
84
                out)
112
85
 
113
86
        # test implicit --remember when no push location set, push fails
114
 
        out = self.run_bzr('push ../branch_b',
115
 
                           working_dir='branch_a', retcode=3)
 
87
        out = self.run_bzr('push ../branch_b', retcode=3)
116
88
        self.assertEquals(out,
117
89
                ('','bzr: ERROR: These branches have diverged.  '
118
 
                 'See "bzr help diverged-branches" for more information.\n'))
119
 
        self.assertEquals(osutils.abspath(branch_a.get_push_location()),
120
 
                          osutils.abspath(branch_b.bzrdir.root_transport.base))
 
90
                    'Try using "merge" and then "push".\n'))
 
91
        self.assertEquals(abspath(branch_a.get_push_location()),
 
92
                          abspath(branch_b.bzrdir.root_transport.base))
121
93
 
122
94
        # test implicit --remember after resolving previous failure
123
 
        uncommit.uncommit(branch=branch_b, tree=tree_b)
 
95
        uncommit(branch=branch_b, tree=tree_b)
124
96
        transport.delete('branch_b/c')
125
 
        out, err = self.run_bzr('push', working_dir='branch_a')
 
97
        out, err = self.run_bzr('push')
126
98
        path = branch_a.get_push_location()
127
99
        self.assertEquals(out,
128
100
                          'Using saved push location: %s\n'
129
 
                          % urlutils.local_path_from_url(path))
 
101
                          % local_path_from_url(path))
130
102
        self.assertEqual(err,
131
103
                         'All changes applied successfully.\n'
132
104
                         'Pushed up to revision 2.\n')
133
105
        self.assertEqual(path,
134
106
                         branch_b.bzrdir.root_transport.base)
135
107
        # test explicit --remember
136
 
        self.run_bzr('push ../branch_c --remember', working_dir='branch_a')
 
108
        self.run_bzr('push ../branch_c --remember')
137
109
        self.assertEquals(branch_a.get_push_location(),
138
110
                          branch_c.bzrdir.root_transport.base)
139
111
 
143
115
        out, err = self.run_bzr('push pushed-location')
144
116
        self.assertEqual('', out)
145
117
        self.assertEqual('Created new branch.\n', err)
146
 
        b2 = branch.Branch.open('pushed-location')
 
118
        b2 = Branch.open('pushed-location')
147
119
        self.assertEndsWith(b2.base, 'pushed-location/')
148
120
 
149
121
    def test_push_new_branch_revision_count(self):
154
126
        self.build_tree(['tree/file'])
155
127
        t.add('file')
156
128
        t.commit('commit 1')
157
 
        out, err = self.run_bzr('push -d tree pushed-to')
 
129
        os.chdir('tree')
 
130
        out, err = self.run_bzr('push pushed-to')
 
131
        os.chdir('..')
158
132
        self.assertEqual('', out)
159
133
        self.assertEqual('Created new branch.\n', err)
160
134
 
161
135
    def test_push_only_pushes_history(self):
162
136
        # Knit branches should only push the history for the current revision.
163
 
        format = bzrdir.BzrDirMetaFormat1()
164
 
        format.repository_format = knitrepo.RepositoryFormatKnit1()
 
137
        format = BzrDirMetaFormat1()
 
138
        format.repository_format = RepositoryFormatKnit1()
165
139
        shared_repo = self.make_repository('repo', format=format, shared=True)
166
140
        shared_repo.set_make_working_trees(True)
167
141
 
168
142
        def make_shared_tree(path):
169
143
            shared_repo.bzrdir.root_transport.mkdir(path)
170
144
            shared_repo.bzrdir.create_branch_convenience('repo/' + path)
171
 
            return workingtree.WorkingTree.open('repo/' + path)
 
145
            return WorkingTree.open('repo/' + path)
172
146
        tree_a = make_shared_tree('a')
173
147
        self.build_tree(['repo/a/file'])
174
148
        tree_a.add('file')
189
163
 
190
164
        # Now that we have a repository with shared files, make sure
191
165
        # that things aren't copied out by a 'push'
192
 
        self.run_bzr('push ../../push-b', working_dir='repo/b')
193
 
        pushed_tree = workingtree.WorkingTree.open('push-b')
 
166
        os.chdir('repo/b')
 
167
        self.run_bzr('push ../../push-b')
 
168
        pushed_tree = WorkingTree.open('../../push-b')
194
169
        pushed_repo = pushed_tree.branch.repository
195
170
        self.assertFalse(pushed_repo.has_revision('a-1'))
196
171
        self.assertFalse(pushed_repo.has_revision('a-2'))
198
173
 
199
174
    def test_push_funky_id(self):
200
175
        t = self.make_branch_and_tree('tree')
201
 
        self.build_tree(['tree/filename'])
 
176
        os.chdir('tree')
 
177
        self.build_tree(['filename'])
202
178
        t.add('filename', 'funky-chars<>%&;"\'')
203
179
        t.commit('commit filename')
204
 
        self.run_bzr('push -d tree new-tree')
 
180
        self.run_bzr('push ../new-tree')
205
181
 
206
182
    def test_push_dash_d(self):
207
183
        t = self.make_branch_and_tree('from')
241
217
        # become necessary for this use case. Please do not adjust this number
242
218
        # upwards without agreement from bzr's network support maintainers.
243
219
        self.assertLength(14, self.hpss_calls)
244
 
        remote = branch.Branch.open('public')
 
220
        remote = Branch.open('public')
245
221
        self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
246
222
 
247
 
    def test_push_smart_tags_streaming_acceptance(self):
248
 
        self.setup_smart_server_with_call_log()
249
 
        t = self.make_branch_and_tree('from')
250
 
        rev_id = t.commit(allow_pointless=True, message='first commit')
251
 
        t.branch.tags.set_tag('new-tag', rev_id)
252
 
        self.reset_smart_call_log()
253
 
        self.run_bzr(['push', self.get_url('to-one')], working_dir='from')
254
 
        # This figure represent the amount of work to perform this use case. It
255
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
256
 
        # being too low. If rpc_count increases, more network roundtrips have
257
 
        # become necessary for this use case. Please do not adjust this number
258
 
        # upwards without agreement from bzr's network support maintainers.
259
 
        self.assertLength(11, self.hpss_calls)
260
 
 
261
 
    def test_push_smart_incremental_acceptance(self):
262
 
        self.setup_smart_server_with_call_log()
263
 
        t = self.make_branch_and_tree('from')
264
 
        rev_id1 = t.commit(allow_pointless=True, message='first commit')
265
 
        rev_id2 = t.commit(allow_pointless=True, message='second commit')
266
 
        self.run_bzr(
267
 
            ['push', self.get_url('to-one'), '-r1'], working_dir='from')
268
 
        self.reset_smart_call_log()
269
 
        self.run_bzr(['push', self.get_url('to-one')], working_dir='from')
270
 
        # This figure represent the amount of work to perform this use case. It
271
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
272
 
        # being too low. If rpc_count increases, more network roundtrips have
273
 
        # become necessary for this use case. Please do not adjust this number
274
 
        # upwards without agreement from bzr's network support maintainers.
275
 
        self.assertLength(11, self.hpss_calls)
276
 
 
277
223
    def test_push_smart_with_default_stacking_url_path_segment(self):
278
224
        # If the default stacked-on location is a path element then branches
279
225
        # we push there over the smart server are stacked and their
280
226
        # stacked_on_url is that exact path segment. Added to nail bug 385132.
281
227
        self.setup_smart_server_with_call_log()
282
228
        self.make_branch('stack-on', format='1.9')
283
 
        self.make_bzrdir('.').get_config().set_default_stack_on(
284
 
            '/stack-on')
 
229
        self.make_bzrdir('.').get_config().set_default_stack_on('/stack-on')
285
230
        self.make_branch('from', format='1.9')
 
231
        self.reset_smart_call_log()
286
232
        out, err = self.run_bzr(['push', '-d', 'from', self.get_url('to')])
287
 
        b = branch.Branch.open(self.get_url('to'))
288
 
        self.assertEqual('/extra/stack-on', b.get_stacked_on_url())
 
233
        branch = Branch.open(self.get_url('to'))
 
234
        self.assertEqual('/stack-on', branch.get_stacked_on_url())
289
235
 
290
236
    def test_push_smart_with_default_stacking_relative_path(self):
291
237
        # If the default stacked-on location is a relative path then branches
295
241
        self.make_branch('stack-on', format='1.9')
296
242
        self.make_bzrdir('.').get_config().set_default_stack_on('stack-on')
297
243
        self.make_branch('from', format='1.9')
 
244
        self.reset_smart_call_log()
298
245
        out, err = self.run_bzr(['push', '-d', 'from', self.get_url('to')])
299
 
        b = branch.Branch.open(self.get_url('to'))
300
 
        self.assertEqual('../stack-on', b.get_stacked_on_url())
 
246
        branch = Branch.open(self.get_url('to'))
 
247
        self.assertEqual('../stack-on', branch.get_stacked_on_url())
301
248
 
302
249
    def create_simple_tree(self):
303
250
        tree = self.make_branch_and_tree('tree')
315
262
                           working_dir='tree')
316
263
        self.run_bzr('push ../new/tree --create-prefix',
317
264
                     working_dir='tree')
318
 
        new_tree = workingtree.WorkingTree.open('new/tree')
 
265
        new_tree = WorkingTree.open('new/tree')
319
266
        self.assertEqual(tree.last_revision(), new_tree.last_revision())
320
267
        self.failUnlessExists('new/tree/a')
321
268
 
335
282
        self.run_bzr('push --use-existing-dir ../target',
336
283
                     working_dir='tree')
337
284
 
338
 
        new_tree = workingtree.WorkingTree.open('target')
 
285
        new_tree = WorkingTree.open('target')
339
286
        self.assertEqual(tree.last_revision(), new_tree.last_revision())
340
287
        # The push should have created target/a
341
288
        self.failUnlessExists('target/a')
342
289
 
343
 
    def test_push_use_existing_into_empty_bzrdir(self):
344
 
        """'bzr push --use-existing-dir' into a dir with an empty .bzr dir
345
 
        fails.
346
 
        """
347
 
        tree = self.create_simple_tree()
348
 
        self.build_tree(['target/', 'target/.bzr/'])
349
 
        self.run_bzr_error(
350
 
            ['Target directory ../target already contains a .bzr directory, '
351
 
             'but it is not valid.'],
352
 
            'push ../target --use-existing-dir', working_dir='tree')
353
 
 
354
290
    def test_push_onto_repo(self):
355
291
        """We should be able to 'bzr push' into an existing bzrdir."""
356
292
        tree = self.create_simple_tree()
362
298
        # Pushing onto an existing bzrdir will create a repository and
363
299
        # branch as needed, but will only create a working tree if there was
364
300
        # no BzrDir before.
365
 
        self.assertRaises(errors.NoWorkingTree,
366
 
                          workingtree.WorkingTree.open, 'repo')
367
 
        new_branch = branch.Branch.open('repo')
 
301
        self.assertRaises(errors.NoWorkingTree, WorkingTree.open, 'repo')
 
302
        new_branch = Branch.open('repo')
368
303
        self.assertEqual(tree.last_revision(), new_branch.last_revision())
369
304
 
370
305
    def test_push_onto_just_bzrdir(self):
389
324
 
390
325
        self.run_bzr('push -r1 ../to', working_dir='from')
391
326
 
392
 
        tree_to = workingtree.WorkingTree.open('to')
 
327
        tree_to = WorkingTree.open('to')
393
328
        repo_to = tree_to.branch.repository
394
329
        self.assertTrue(repo_to.has_revision('from-1'))
395
330
        self.assertFalse(repo_to.has_revision('from-2'))
416
351
 
417
352
    def assertPublished(self, branch_revid, stacked_on):
418
353
        """Assert that the branch 'published' has been published correctly."""
419
 
        published_branch = branch.Branch.open('published')
 
354
        published_branch = Branch.open('published')
420
355
        # The published branch refers to the mainline
421
356
        self.assertEqual(stacked_on, published_branch.get_stacked_on_url())
422
357
        # and the branch's work was pushed
444
379
        self.assertEqual('', out)
445
380
        self.assertEqual('Created new stacked branch referring to %s.\n' %
446
381
            trunk_tree.branch.base, err)
447
 
        self.assertPublished(branch_tree.last_revision(),
448
 
                             trunk_tree.branch.base)
 
382
        self.assertPublished(branch_tree.last_revision(), trunk_tree.branch.base)
449
383
 
450
384
    def test_push_new_branch_stacked_uses_parent_public(self):
451
385
        """Pushing a new branch with --stacked creates a stacked branch."""
452
386
        trunk_tree, branch_tree = self.create_trunk_and_feature_branch()
453
387
        # the trunk is published on a web server
454
 
        self.transport_readonly_server = http_server.HttpServer
 
388
        self.transport_readonly_server = HttpServer
455
389
        trunk_public = self.make_branch('public_trunk', format='1.9')
456
390
        trunk_public.pull(trunk_tree.branch)
457
391
        trunk_public_url = self.get_readonly_url('public_trunk')
489
423
        self.make_bzrdir('.').get_config().set_default_stack_on('stack_on')
490
424
        self.make_branch('from', format='pack-0.92')
491
425
        out, err = self.run_bzr('push -d from to')
492
 
        b = branch.Branch.open('to')
493
 
        self.assertEqual('../stack_on', b.get_stacked_on_url())
 
426
        branch = Branch.open('to')
 
427
        self.assertEqual('../stack_on', branch.get_stacked_on_url())
494
428
 
495
429
    def test_push_does_not_change_format_with_default_if_target_cannot(self):
496
430
        self.make_branch('stack_on', format='pack-0.92')
497
431
        self.make_bzrdir('.').get_config().set_default_stack_on('stack_on')
498
432
        self.make_branch('from', format='pack-0.92')
499
433
        out, err = self.run_bzr('push -d from to')
500
 
        b = branch.Branch.open('to')
501
 
        self.assertRaises(errors.UnstackableBranchFormat, b.get_stacked_on_url)
 
434
        branch = Branch.open('to')
 
435
        self.assertRaises(errors.UnstackableBranchFormat,
 
436
            branch.get_stacked_on_url)
502
437
 
503
438
    def test_push_doesnt_create_broken_branch(self):
504
439
        """Pushing a new standalone branch works even when there's a default
545
480
        # subsequent log is accurate
546
481
        self.assertNotContainsRe(out, 'rev1')
547
482
 
548
 
    def test_push_from_subdir(self):
549
 
        t = self.make_branch_and_tree('tree')
550
 
        self.build_tree(['tree/dir/', 'tree/dir/file'])
551
 
        t.add('dir', 'dir/file')
552
 
        t.commit('r1')
553
 
        out, err = self.run_bzr('push ../../pushloc', working_dir='tree/dir')
554
 
        self.assertEqual('', out)
555
 
        self.assertEqual('Created new branch.\n', err)
556
 
 
557
 
 
558
 
class RedirectingMemoryTransport(memory.MemoryTransport):
 
483
 
 
484
class RedirectingMemoryTransport(MemoryTransport):
559
485
 
560
486
    def mkdir(self, relpath, mode=None):
 
487
        from bzrlib.trace import mutter
 
488
        mutter('cwd: %r, rel: %r, abs: %r' % (self._cwd, relpath, abspath))
561
489
        if self._cwd == '/source/':
562
490
            raise errors.RedirectRequested(self.abspath(relpath),
563
491
                                           self.abspath('../target'),
570
498
            return super(RedirectingMemoryTransport, self).mkdir(
571
499
                relpath, mode)
572
500
 
573
 
    def get(self, relpath):
574
 
        if self.clone(relpath)._cwd == '/infinite-loop/':
575
 
            raise errors.RedirectRequested(self.abspath(relpath),
576
 
                                           self.abspath('../infinite-loop'),
577
 
                                           is_permanent=True)
578
 
        else:
579
 
            return super(RedirectingMemoryTransport, self).get(relpath)
580
 
 
581
501
    def _redirected_to(self, source, target):
582
502
        # We do accept redirections
583
503
        return transport.get_transport(target)
584
504
 
585
505
 
586
 
class RedirectingMemoryServer(memory.MemoryServer):
 
506
class RedirectingMemoryServer(MemoryServer):
587
507
 
588
 
    def start_server(self):
 
508
    def setUp(self):
589
509
        self._dirs = {'/': None}
590
510
        self._files = {}
591
511
        self._locks = {}
599
519
        result._locks = self._locks
600
520
        return result
601
521
 
602
 
    def stop_server(self):
 
522
    def tearDown(self):
603
523
        transport.unregister_transport(self._scheme, self._memory_factory)
604
524
 
605
525
 
606
 
class TestPushRedirect(tests.TestCaseWithTransport):
 
526
class TestPushRedirect(ExternalBase):
607
527
 
608
528
    def setUp(self):
609
 
        tests.TestCaseWithTransport.setUp(self)
 
529
        ExternalBase.setUp(self)
610
530
        self.memory_server = RedirectingMemoryServer()
611
 
        self.start_server(self.memory_server)
 
531
        self.memory_server.setUp()
 
532
        self.addCleanup(self.memory_server.tearDown)
 
533
 
612
534
        # Make the branch and tree that we'll be pushing.
613
535
        t = self.make_branch_and_tree('tree')
614
536
        self.build_tree(['tree/file'])
624
546
        destination_url = self.memory_server.get_url() + 'source'
625
547
        self.run_bzr(['push', '-d', 'tree', destination_url])
626
548
 
627
 
        local_revision = branch.Branch.open('tree').last_revision()
628
 
        remote_revision = branch.Branch.open(
 
549
        local_revision = Branch.open('tree').last_revision()
 
550
        remote_revision = Branch.open(
629
551
            self.memory_server.get_url() + 'target').last_revision()
630
552
        self.assertEqual(remote_revision, local_revision)
631
553
 
639
561
             % re.escape(destination_url)],
640
562
            ['push', '-d', 'tree', destination_url], retcode=3)
641
563
        self.assertEqual('', out)
642
 
 
643
 
 
644
 
class TestPushStrictMixin(object):
645
 
 
646
 
    def make_local_branch_and_tree(self):
647
 
        self.tree = self.make_branch_and_tree('local')
648
 
        self.build_tree_contents([('local/file', 'initial')])
649
 
        self.tree.add('file')
650
 
        self.tree.commit('adding file', rev_id='added')
651
 
        self.build_tree_contents([('local/file', 'modified')])
652
 
        self.tree.commit('modify file', rev_id='modified')
653
 
 
654
 
    def set_config_push_strict(self, value):
655
 
        # set config var (any of bazaar.conf, locations.conf, branch.conf
656
 
        # should do)
657
 
        conf = self.tree.branch.get_config()
658
 
        conf.set_user_option('push_strict', value)
659
 
 
660
 
    _default_command = ['push', '../to']
661
 
    _default_wd = 'local'
662
 
    _default_errors = ['Working tree ".*/local/" has uncommitted '
663
 
                       'changes \(See bzr status\)\.',]
664
 
    _default_additional_error = 'Use --no-strict to force the push.\n'
665
 
    _default_additional_warning = 'Uncommitted changes will not be pushed.'
666
 
 
667
 
 
668
 
    def assertPushFails(self, args):
669
 
        out, err = self.run_bzr_error(self._default_errors,
670
 
                                      self._default_command + args,
671
 
                                      working_dir=self._default_wd, retcode=3)
672
 
        self.assertContainsRe(err, self._default_additional_error)
673
 
 
674
 
    def assertPushSucceeds(self, args, with_warning=False, revid_to_push=None):
675
 
        if with_warning:
676
 
            error_regexes = self._default_errors
677
 
        else:
678
 
            error_regexes = []
679
 
        out, err = self.run_bzr(self._default_command + args,
680
 
                                working_dir=self._default_wd,
681
 
                                error_regexes=error_regexes)
682
 
        if with_warning:
683
 
            self.assertContainsRe(err, self._default_additional_warning)
684
 
        else:
685
 
            self.assertNotContainsRe(err, self._default_additional_warning)
686
 
        branch_from = branch.Branch.open(self._default_wd)
687
 
        if revid_to_push is None:
688
 
            revid_to_push = branch_from.last_revision()
689
 
        branch_to = branch.Branch.open('to')
690
 
        repo_to = branch_to.repository
691
 
        self.assertTrue(repo_to.has_revision(revid_to_push))
692
 
        self.assertEqual(revid_to_push, branch_to.last_revision())
693
 
 
694
 
 
695
 
 
696
 
class TestPushStrictWithoutChanges(tests.TestCaseWithTransport,
697
 
                                   TestPushStrictMixin):
698
 
 
699
 
    def setUp(self):
700
 
        super(TestPushStrictWithoutChanges, self).setUp()
701
 
        self.make_local_branch_and_tree()
702
 
 
703
 
    def test_push_default(self):
704
 
        self.assertPushSucceeds([])
705
 
 
706
 
    def test_push_strict(self):
707
 
        self.assertPushSucceeds(['--strict'])
708
 
 
709
 
    def test_push_no_strict(self):
710
 
        self.assertPushSucceeds(['--no-strict'])
711
 
 
712
 
    def test_push_config_var_strict(self):
713
 
        self.set_config_push_strict('true')
714
 
        self.assertPushSucceeds([])
715
 
 
716
 
    def test_push_config_var_no_strict(self):
717
 
        self.set_config_push_strict('false')
718
 
        self.assertPushSucceeds([])
719
 
 
720
 
 
721
 
class TestPushStrictWithChanges(tests.TestCaseWithTransport,
722
 
                                TestPushStrictMixin):
723
 
 
724
 
    _changes_type = None # Set by load_tests
725
 
 
726
 
    def setUp(self):
727
 
        super(TestPushStrictWithChanges, self).setUp()
728
 
        # Apply the changes defined in load_tests: one of _uncommitted_changes,
729
 
        # _pending_merges or _out_of_sync_trees
730
 
        getattr(self, self._changes_type)()
731
 
 
732
 
    def _uncommitted_changes(self):
733
 
        self.make_local_branch_and_tree()
734
 
        # Make a change without committing it
735
 
        self.build_tree_contents([('local/file', 'in progress')])
736
 
 
737
 
    def _pending_merges(self):
738
 
        self.make_local_branch_and_tree()
739
 
        # Create 'other' branch containing a new file
740
 
        other_bzrdir = self.tree.bzrdir.sprout('other')
741
 
        other_tree = other_bzrdir.open_workingtree()
742
 
        self.build_tree_contents([('other/other-file', 'other')])
743
 
        other_tree.add('other-file')
744
 
        other_tree.commit('other commit', rev_id='other')
745
 
        # Merge and revert, leaving a pending merge
746
 
        self.tree.merge_from_branch(other_tree.branch)
747
 
        self.tree.revert(filenames=['other-file'], backups=False)
748
 
 
749
 
    def _out_of_sync_trees(self):
750
 
        self.make_local_branch_and_tree()
751
 
        self.run_bzr(['checkout', '--lightweight', 'local', 'checkout'])
752
 
        # Make a change and commit it
753
 
        self.build_tree_contents([('local/file', 'modified in local')])
754
 
        self.tree.commit('modify file', rev_id='modified-in-local')
755
 
        # Exercise commands from the checkout directory
756
 
        self._default_wd = 'checkout'
757
 
        self._default_errors = ["Working tree is out of date, please run"
758
 
                                " 'bzr update'\.",]
759
 
 
760
 
    def test_push_default(self):
761
 
        self.assertPushSucceeds([], with_warning=True)
762
 
 
763
 
    def test_push_with_revision(self):
764
 
        self.assertPushSucceeds(['-r', 'revid:added'], revid_to_push='added')
765
 
 
766
 
    def test_push_no_strict(self):
767
 
        self.assertPushSucceeds(['--no-strict'])
768
 
 
769
 
    def test_push_strict_with_changes(self):
770
 
        self.assertPushFails(['--strict'])
771
 
 
772
 
    def test_push_respect_config_var_strict(self):
773
 
        self.set_config_push_strict('true')
774
 
        self.assertPushFails([])
775
 
 
776
 
    def test_push_bogus_config_var_ignored(self):
777
 
        self.set_config_push_strict("I don't want you to be strict")
778
 
        self.assertPushSucceeds([], with_warning=True)
779
 
 
780
 
    def test_push_no_strict_command_line_override_config(self):
781
 
        self.set_config_push_strict('yES')
782
 
        self.assertPushFails([])
783
 
        self.assertPushSucceeds(['--no-strict'])
784
 
 
785
 
    def test_push_strict_command_line_override_config(self):
786
 
        self.set_config_push_strict('oFF')
787
 
        self.assertPushFails(['--strict'])
788
 
        self.assertPushSucceeds([])
789
 
 
790
 
 
791
 
class TestPushForeign(blackbox.ExternalBase):
792
 
 
793
 
    def setUp(self):
794
 
        super(TestPushForeign, self).setUp()
795
 
        test_foreign.register_dummy_foreign_for_test(self)
796
 
 
797
 
    def make_dummy_builder(self, relpath):
798
 
        builder = self.make_branch_builder(
799
 
            relpath, format=test_foreign.DummyForeignVcsDirFormat())
800
 
        builder.build_snapshot('revid', None,
801
 
            [('add', ('', 'TREE_ROOT', 'directory', None)),
802
 
             ('add', ('foo', 'fooid', 'file', 'bar'))])
803
 
        return builder
804
 
 
805
 
    def test_no_roundtripping(self):
806
 
        target_branch = self.make_dummy_builder('dp').get_branch()
807
 
        source_tree = self.make_branch_and_tree("dc")
808
 
        output, error = self.run_bzr("push -d dc dp", retcode=3)
809
 
        self.assertEquals("", output)
810
 
        self.assertEquals(error, "bzr: ERROR: It is not possible to losslessly"
811
 
            " push to dummy. You may want to use dpush instead.\n")