← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_push.py

  • Committer: Sidnei da Silva
  • Date: 2009-05-29 14:19:29 UTC
  • mto: (4531.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4532.
  • Revision ID: sidnei.da.silva@canonical.com-20090529141929-3heywbvj36po72a5
- Add initial config

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_push.py
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.smart import client, server
 
33
from bzrlib.tests.blackbox import ExternalBase
 
34
from bzrlib.tests.http_server import HttpServer
 
35
from bzrlib.transport.memory import MemoryServer, MemoryTransport
 
36
from bzrlib.uncommit import uncommit
 
37
from bzrlib.urlutils import local_path_from_url
 
38
from bzrlib.workingtree import WorkingTree
 
39
 
 
40
 
 
41
class TestPush(ExternalBase):
68
42
 
69
43
    def test_push_error_on_vfs_http(self):
70
44
        """ pushing a branch to a HTTP server fails cleanly. """
71
45
        # the trunk is published on a web server
72
 
        self.transport_readonly_server = http_server.HttpServer
 
46
        self.transport_readonly_server = HttpServer
73
47
        self.make_branch('source')
74
48
        public_url = self.get_readonly_url('target')
75
49
        self.run_bzr_error(['http does not support mkdir'],
98
72
        self.assertEqual(None, branch_b.get_push_location())
99
73
 
100
74
        # test push for failure without push location set
101
 
        out = self.run_bzr('push', working_dir='branch_a', retcode=3)
 
75
        os.chdir('branch_a')
 
76
        out = self.run_bzr('push', retcode=3)
102
77
        self.assertEquals(out,
103
78
                ('','bzr: ERROR: No push location known or specified.\n'))
104
79
 
105
80
        # 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)
 
81
        self.run_bzr('push ../path/which/doesnt/exist', retcode=3)
 
82
        out = self.run_bzr('push', retcode=3)
109
83
        self.assertEquals(
110
84
                ('', 'bzr: ERROR: No push location known or specified.\n'),
111
85
                out)
112
86
 
113
87
        # 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)
 
88
        out = self.run_bzr('push ../branch_b', retcode=3)
116
89
        self.assertEquals(out,
117
90
                ('','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))
 
91
                    'Try using "merge" and then "push".\n'))
 
92
        self.assertEquals(abspath(branch_a.get_push_location()),
 
93
                          abspath(branch_b.bzrdir.root_transport.base))
121
94
 
122
95
        # test implicit --remember after resolving previous failure
123
 
        uncommit.uncommit(branch=branch_b, tree=tree_b)
 
96
        uncommit(branch=branch_b, tree=tree_b)
124
97
        transport.delete('branch_b/c')
125
 
        out, err = self.run_bzr('push', working_dir='branch_a')
 
98
        out, err = self.run_bzr('push')
126
99
        path = branch_a.get_push_location()
127
100
        self.assertEquals(out,
128
101
                          'Using saved push location: %s\n'
129
 
                          % urlutils.local_path_from_url(path))
 
102
                          % local_path_from_url(path))
130
103
        self.assertEqual(err,
131
104
                         'All changes applied successfully.\n'
132
105
                         'Pushed up to revision 2.\n')
133
106
        self.assertEqual(path,
134
107
                         branch_b.bzrdir.root_transport.base)
135
108
        # test explicit --remember
136
 
        self.run_bzr('push ../branch_c --remember', working_dir='branch_a')
 
109
        self.run_bzr('push ../branch_c --remember')
137
110
        self.assertEquals(branch_a.get_push_location(),
138
111
                          branch_c.bzrdir.root_transport.base)
139
112
 
143
116
        out, err = self.run_bzr('push pushed-location')
144
117
        self.assertEqual('', out)
145
118
        self.assertEqual('Created new branch.\n', err)
146
 
        b2 = branch.Branch.open('pushed-location')
 
119
        b2 = Branch.open('pushed-location')
147
120
        self.assertEndsWith(b2.base, 'pushed-location/')
148
121
 
149
122
    def test_push_new_branch_revision_count(self):
154
127
        self.build_tree(['tree/file'])
155
128
        t.add('file')
156
129
        t.commit('commit 1')
157
 
        out, err = self.run_bzr('push -d tree pushed-to')
 
130
        os.chdir('tree')
 
131
        out, err = self.run_bzr('push pushed-to')
 
132
        os.chdir('..')
158
133
        self.assertEqual('', out)
159
134
        self.assertEqual('Created new branch.\n', err)
160
135
 
161
136
    def test_push_only_pushes_history(self):
162
137
        # Knit branches should only push the history for the current revision.
163
 
        format = bzrdir.BzrDirMetaFormat1()
164
 
        format.repository_format = knitrepo.RepositoryFormatKnit1()
 
138
        format = BzrDirMetaFormat1()
 
139
        format.repository_format = RepositoryFormatKnit1()
165
140
        shared_repo = self.make_repository('repo', format=format, shared=True)
166
141
        shared_repo.set_make_working_trees(True)
167
142
 
168
143
        def make_shared_tree(path):
169
144
            shared_repo.bzrdir.root_transport.mkdir(path)
170
145
            shared_repo.bzrdir.create_branch_convenience('repo/' + path)
171
 
            return workingtree.WorkingTree.open('repo/' + path)
 
146
            return WorkingTree.open('repo/' + path)
172
147
        tree_a = make_shared_tree('a')
173
148
        self.build_tree(['repo/a/file'])
174
149
        tree_a.add('file')
189
164
 
190
165
        # Now that we have a repository with shared files, make sure
191
166
        # 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')
 
167
        os.chdir('repo/b')
 
168
        self.run_bzr('push ../../push-b')
 
169
        pushed_tree = WorkingTree.open('../../push-b')
194
170
        pushed_repo = pushed_tree.branch.repository
195
171
        self.assertFalse(pushed_repo.has_revision('a-1'))
196
172
        self.assertFalse(pushed_repo.has_revision('a-2'))
198
174
 
199
175
    def test_push_funky_id(self):
200
176
        t = self.make_branch_and_tree('tree')
201
 
        self.build_tree(['tree/filename'])
 
177
        os.chdir('tree')
 
178
        self.build_tree(['filename'])
202
179
        t.add('filename', 'funky-chars<>%&;"\'')
203
180
        t.commit('commit filename')
204
 
        self.run_bzr('push -d tree new-tree')
 
181
        self.run_bzr('push ../new-tree')
205
182
 
206
183
    def test_push_dash_d(self):
207
184
        t = self.make_branch_and_tree('from')
241
218
        # become necessary for this use case. Please do not adjust this number
242
219
        # upwards without agreement from bzr's network support maintainers.
243
220
        self.assertLength(14, self.hpss_calls)
244
 
        remote = branch.Branch.open('public')
 
221
        remote = Branch.open('public')
245
222
        self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
246
223
 
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
 
    def test_push_smart_with_default_stacking_url_path_segment(self):
278
 
        # If the default stacked-on location is a path element then branches
279
 
        # we push there over the smart server are stacked and their
280
 
        # stacked_on_url is that exact path segment. Added to nail bug 385132.
281
 
        self.setup_smart_server_with_call_log()
282
 
        self.make_branch('stack-on', format='1.9')
283
 
        self.make_bzrdir('.').get_config().set_default_stack_on(
284
 
            '/stack-on')
285
 
        self.make_branch('from', format='1.9')
286
 
        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())
289
 
 
290
 
    def test_push_smart_with_default_stacking_relative_path(self):
291
 
        # If the default stacked-on location is a relative path then branches
292
 
        # we push there over the smart server are stacked and their
293
 
        # stacked_on_url is a relative path. Added to nail bug 385132.
294
 
        self.setup_smart_server_with_call_log()
295
 
        self.make_branch('stack-on', format='1.9')
296
 
        self.make_bzrdir('.').get_config().set_default_stack_on('stack-on')
297
 
        self.make_branch('from', format='1.9')
298
 
        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())
301
 
 
302
224
    def create_simple_tree(self):
303
225
        tree = self.make_branch_and_tree('tree')
304
226
        self.build_tree(['tree/a'])
315
237
                           working_dir='tree')
316
238
        self.run_bzr('push ../new/tree --create-prefix',
317
239
                     working_dir='tree')
318
 
        new_tree = workingtree.WorkingTree.open('new/tree')
 
240
        new_tree = WorkingTree.open('new/tree')
319
241
        self.assertEqual(tree.last_revision(), new_tree.last_revision())
320
242
        self.failUnlessExists('new/tree/a')
321
243
 
335
257
        self.run_bzr('push --use-existing-dir ../target',
336
258
                     working_dir='tree')
337
259
 
338
 
        new_tree = workingtree.WorkingTree.open('target')
 
260
        new_tree = WorkingTree.open('target')
339
261
        self.assertEqual(tree.last_revision(), new_tree.last_revision())
340
262
        # The push should have created target/a
341
263
        self.failUnlessExists('target/a')
342
264
 
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
265
    def test_push_onto_repo(self):
355
266
        """We should be able to 'bzr push' into an existing bzrdir."""
356
267
        tree = self.create_simple_tree()
362
273
        # Pushing onto an existing bzrdir will create a repository and
363
274
        # branch as needed, but will only create a working tree if there was
364
275
        # no BzrDir before.
365
 
        self.assertRaises(errors.NoWorkingTree,
366
 
                          workingtree.WorkingTree.open, 'repo')
367
 
        new_branch = branch.Branch.open('repo')
 
276
        self.assertRaises(errors.NoWorkingTree, WorkingTree.open, 'repo')
 
277
        new_branch = Branch.open('repo')
368
278
        self.assertEqual(tree.last_revision(), new_branch.last_revision())
369
279
 
370
280
    def test_push_onto_just_bzrdir(self):
389
299
 
390
300
        self.run_bzr('push -r1 ../to', working_dir='from')
391
301
 
392
 
        tree_to = workingtree.WorkingTree.open('to')
 
302
        tree_to = WorkingTree.open('to')
393
303
        repo_to = tree_to.branch.repository
394
304
        self.assertTrue(repo_to.has_revision('from-1'))
395
305
        self.assertFalse(repo_to.has_revision('from-2'))
416
326
 
417
327
    def assertPublished(self, branch_revid, stacked_on):
418
328
        """Assert that the branch 'published' has been published correctly."""
419
 
        published_branch = branch.Branch.open('published')
 
329
        published_branch = Branch.open('published')
420
330
        # The published branch refers to the mainline
421
331
        self.assertEqual(stacked_on, published_branch.get_stacked_on_url())
422
332
        # and the branch's work was pushed
444
354
        self.assertEqual('', out)
445
355
        self.assertEqual('Created new stacked branch referring to %s.\n' %
446
356
            trunk_tree.branch.base, err)
447
 
        self.assertPublished(branch_tree.last_revision(),
448
 
                             trunk_tree.branch.base)
 
357
        self.assertPublished(branch_tree.last_revision(), trunk_tree.branch.base)
449
358
 
450
359
    def test_push_new_branch_stacked_uses_parent_public(self):
451
360
        """Pushing a new branch with --stacked creates a stacked branch."""
452
361
        trunk_tree, branch_tree = self.create_trunk_and_feature_branch()
453
362
        # the trunk is published on a web server
454
 
        self.transport_readonly_server = http_server.HttpServer
 
363
        self.transport_readonly_server = HttpServer
455
364
        trunk_public = self.make_branch('public_trunk', format='1.9')
456
365
        trunk_public.pull(trunk_tree.branch)
457
366
        trunk_public_url = self.get_readonly_url('public_trunk')
489
398
        self.make_bzrdir('.').get_config().set_default_stack_on('stack_on')
490
399
        self.make_branch('from', format='pack-0.92')
491
400
        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())
 
401
        branch = Branch.open('to')
 
402
        self.assertEqual('../stack_on', branch.get_stacked_on_url())
494
403
 
495
404
    def test_push_does_not_change_format_with_default_if_target_cannot(self):
496
405
        self.make_branch('stack_on', format='pack-0.92')
497
406
        self.make_bzrdir('.').get_config().set_default_stack_on('stack_on')
498
407
        self.make_branch('from', format='pack-0.92')
499
408
        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)
 
409
        branch = Branch.open('to')
 
410
        self.assertRaises(errors.UnstackableBranchFormat,
 
411
            branch.get_stacked_on_url)
502
412
 
503
413
    def test_push_doesnt_create_broken_branch(self):
504
414
        """Pushing a new standalone branch works even when there's a default
545
455
        # subsequent log is accurate
546
456
        self.assertNotContainsRe(out, 'rev1')
547
457
 
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):
 
458
 
 
459
class RedirectingMemoryTransport(MemoryTransport):
559
460
 
560
461
    def mkdir(self, relpath, mode=None):
 
462
        from bzrlib.trace import mutter
 
463
        mutter('cwd: %r, rel: %r, abs: %r' % (self._cwd, relpath, abspath))
561
464
        if self._cwd == '/source/':
562
465
            raise errors.RedirectRequested(self.abspath(relpath),
563
466
                                           self.abspath('../target'),
570
473
            return super(RedirectingMemoryTransport, self).mkdir(
571
474
                relpath, mode)
572
475
 
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
476
    def _redirected_to(self, source, target):
582
477
        # We do accept redirections
583
478
        return transport.get_transport(target)
584
479
 
585
480
 
586
 
class RedirectingMemoryServer(memory.MemoryServer):
 
481
class RedirectingMemoryServer(MemoryServer):
587
482
 
588
 
    def start_server(self):
 
483
    def setUp(self):
589
484
        self._dirs = {'/': None}
590
485
        self._files = {}
591
486
        self._locks = {}
599
494
        result._locks = self._locks
600
495
        return result
601
496
 
602
 
    def stop_server(self):
 
497
    def tearDown(self):
603
498
        transport.unregister_transport(self._scheme, self._memory_factory)
604
499
 
605
500
 
606
 
class TestPushRedirect(tests.TestCaseWithTransport):
 
501
class TestPushRedirect(ExternalBase):
607
502
 
608
503
    def setUp(self):
609
 
        tests.TestCaseWithTransport.setUp(self)
 
504
        ExternalBase.setUp(self)
610
505
        self.memory_server = RedirectingMemoryServer()
611
 
        self.start_server(self.memory_server)
 
506
        self.memory_server.setUp()
 
507
        self.addCleanup(self.memory_server.tearDown)
 
508
 
612
509
        # Make the branch and tree that we'll be pushing.
613
510
        t = self.make_branch_and_tree('tree')
614
511
        self.build_tree(['tree/file'])
624
521
        destination_url = self.memory_server.get_url() + 'source'
625
522
        self.run_bzr(['push', '-d', 'tree', destination_url])
626
523
 
627
 
        local_revision = branch.Branch.open('tree').last_revision()
628
 
        remote_revision = branch.Branch.open(
 
524
        local_revision = Branch.open('tree').last_revision()
 
525
        remote_revision = Branch.open(
629
526
            self.memory_server.get_url() + 'target').last_revision()
630
527
        self.assertEqual(remote_revision, local_revision)
631
528
 
639
536
             % re.escape(destination_url)],
640
537
            ['push', '-d', 'tree', destination_url], retcode=3)
641
538
        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_pushed_revid = 'modified'
665
 
 
666
 
    def assertPushFails(self, args):
667
 
        self.run_bzr_error(self._default_errors, self._default_command + args,
668
 
                           working_dir=self._default_wd, retcode=3)
669
 
 
670
 
    def assertPushSucceeds(self, args, pushed_revid=None):
671
 
        self.run_bzr(self._default_command + args,
672
 
                     working_dir=self._default_wd)
673
 
        if pushed_revid is None:
674
 
            pushed_revid = self._default_pushed_revid
675
 
        tree_to = workingtree.WorkingTree.open('to')
676
 
        repo_to = tree_to.branch.repository
677
 
        self.assertTrue(repo_to.has_revision(pushed_revid))
678
 
        self.assertEqual(tree_to.branch.last_revision_info()[1], pushed_revid)
679
 
 
680
 
 
681
 
 
682
 
class TestPushStrictWithoutChanges(tests.TestCaseWithTransport,
683
 
                                   TestPushStrictMixin):
684
 
 
685
 
    def setUp(self):
686
 
        super(TestPushStrictWithoutChanges, self).setUp()
687
 
        self.make_local_branch_and_tree()
688
 
 
689
 
    def test_push_default(self):
690
 
        self.assertPushSucceeds([])
691
 
 
692
 
    def test_push_strict(self):
693
 
        self.assertPushSucceeds(['--strict'])
694
 
 
695
 
    def test_push_no_strict(self):
696
 
        self.assertPushSucceeds(['--no-strict'])
697
 
 
698
 
    def test_push_config_var_strict(self):
699
 
        self.set_config_push_strict('true')
700
 
        self.assertPushSucceeds([])
701
 
 
702
 
    def test_push_config_var_no_strict(self):
703
 
        self.set_config_push_strict('false')
704
 
        self.assertPushSucceeds([])
705
 
 
706
 
 
707
 
class TestPushStrictWithChanges(tests.TestCaseWithTransport,
708
 
                                TestPushStrictMixin):
709
 
 
710
 
    _changes_type = None # Set by load_tests
711
 
 
712
 
    def setUp(self):
713
 
        super(TestPushStrictWithChanges, self).setUp()
714
 
        # Apply the changes defined in load_tests: one of _uncommitted_changes,
715
 
        # _pending_merges or _out_of_sync_trees
716
 
        getattr(self, self._changes_type)()
717
 
 
718
 
    def _uncommitted_changes(self):
719
 
        self.make_local_branch_and_tree()
720
 
        # Make a change without committing it
721
 
        self.build_tree_contents([('local/file', 'in progress')])
722
 
 
723
 
    def _pending_merges(self):
724
 
        self.make_local_branch_and_tree()
725
 
        # Create 'other' branch containing a new file
726
 
        other_bzrdir = self.tree.bzrdir.sprout('other')
727
 
        other_tree = other_bzrdir.open_workingtree()
728
 
        self.build_tree_contents([('other/other-file', 'other')])
729
 
        other_tree.add('other-file')
730
 
        other_tree.commit('other commit', rev_id='other')
731
 
        # Merge and revert, leaving a pending merge
732
 
        self.tree.merge_from_branch(other_tree.branch)
733
 
        self.tree.revert(filenames=['other-file'], backups=False)
734
 
 
735
 
    def _out_of_sync_trees(self):
736
 
        self.make_local_branch_and_tree()
737
 
        self.run_bzr(['checkout', '--lightweight', 'local', 'checkout'])
738
 
        # Make a change and commit it
739
 
        self.build_tree_contents([('local/file', 'modified in local')])
740
 
        self.tree.commit('modify file', rev_id='modified-in-local')
741
 
        # Exercise commands from the checkout directory
742
 
        self._default_wd = 'checkout'
743
 
        self._default_errors = ["Working tree is out of date, please run"
744
 
                                " 'bzr update'\.",]
745
 
        self._default_pushed_revid = 'modified-in-local'
746
 
 
747
 
    def test_push_default(self):
748
 
        self.assertPushFails([])
749
 
 
750
 
    def test_push_with_revision(self):
751
 
        self.assertPushSucceeds(['-r', 'revid:added'], pushed_revid='added')
752
 
 
753
 
    def test_push_no_strict(self):
754
 
        self.assertPushSucceeds(['--no-strict'])
755
 
 
756
 
    def test_push_strict_with_changes(self):
757
 
        self.assertPushFails(['--strict'])
758
 
 
759
 
    def test_push_respect_config_var_strict(self):
760
 
        self.set_config_push_strict('true')
761
 
        self.assertPushFails([])
762
 
 
763
 
    def test_push_bogus_config_var_ignored(self):
764
 
        self.set_config_push_strict("I don't want you to be strict")
765
 
        self.assertPushFails([])
766
 
 
767
 
    def test_push_no_strict_command_line_override_config(self):
768
 
        self.set_config_push_strict('yES')
769
 
        self.assertPushFails([])
770
 
        self.assertPushSucceeds(['--no-strict'])
771
 
 
772
 
    def test_push_strict_command_line_override_config(self):
773
 
        self.set_config_push_strict('oFF')
774
 
        self.assertPushFails(['--strict'])
775
 
        self.assertPushSucceeds([])
776
 
 
777
 
 
778
 
class TestPushForeign(blackbox.ExternalBase):
779
 
 
780
 
    def setUp(self):
781
 
        super(TestPushForeign, self).setUp()
782
 
        test_foreign.register_dummy_foreign_for_test(self)
783
 
 
784
 
    def make_dummy_builder(self, relpath):
785
 
        builder = self.make_branch_builder(
786
 
            relpath, format=test_foreign.DummyForeignVcsDirFormat())
787
 
        builder.build_snapshot('revid', None,
788
 
            [('add', ('', 'TREE_ROOT', 'directory', None)),
789
 
             ('add', ('foo', 'fooid', 'file', 'bar'))])
790
 
        return builder
791
 
 
792
 
    def test_no_roundtripping(self):
793
 
        target_branch = self.make_dummy_builder('dp').get_branch()
794
 
        source_tree = self.make_branch_and_tree("dc")
795
 
        output, error = self.run_bzr("push -d dc dp", retcode=3)
796
 
        self.assertEquals("", output)
797
 
        self.assertEquals(error, "bzr: ERROR: It is not possible to losslessly"
798
 
            " push to dummy. You may want to use dpush instead.\n")