1
# Copyright (C) 2005, 2007, 2008 Canonical Ltd
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.
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.
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
18
"""Black-box tests for bzr push."""
33
from bzrlib.repofmt import knitrepo
34
from bzrlib.tests import http_server
35
from bzrlib.transport import memory
38
def load_tests(standard_tests, module, loader):
39
"""Multiply tests for the push command."""
40
result = loader.suiteClass()
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,
49
dict(_changes_type= '_uncommitted_changes')),
51
dict(_changes_type= '_pending_merges')),
53
tests.multiply_tests(changes_tests, changes_scenarios, result)
54
# No parametrization for the remaining tests
55
result.addTests(remaining_tests)
60
class TestPush(tests.TestCaseWithTransport):
62
def test_push_error_on_vfs_http(self):
63
""" pushing a branch to a HTTP server fails cleanly. """
64
# the trunk is published on a web server
65
self.transport_readonly_server = http_server.HttpServer
66
self.make_branch('source')
67
public_url = self.get_readonly_url('target')
68
self.run_bzr_error(['http does not support mkdir'],
72
def test_push_remember(self):
73
"""Push changes from one branch to another and test push location."""
74
transport = self.get_transport()
75
tree_a = self.make_branch_and_tree('branch_a')
76
branch_a = tree_a.branch
77
self.build_tree(['branch_a/a'])
79
tree_a.commit('commit a')
80
tree_b = branch_a.bzrdir.sprout('branch_b').open_workingtree()
81
branch_b = tree_b.branch
82
tree_c = branch_a.bzrdir.sprout('branch_c').open_workingtree()
83
branch_c = tree_c.branch
84
self.build_tree(['branch_a/b'])
86
tree_a.commit('commit b')
87
self.build_tree(['branch_b/c'])
89
tree_b.commit('commit c')
90
# initial push location must be empty
91
self.assertEqual(None, branch_b.get_push_location())
93
# test push for failure without push location set
94
out = self.run_bzr('push', working_dir='branch_a', retcode=3)
95
self.assertEquals(out,
96
('','bzr: ERROR: No push location known or specified.\n'))
98
# test not remembered if cannot actually push
99
self.run_bzr('push path/which/doesnt/exist',
100
working_dir='branch_a', retcode=3)
101
out = self.run_bzr('push', working_dir='branch_a', retcode=3)
103
('', 'bzr: ERROR: No push location known or specified.\n'),
106
# test implicit --remember when no push location set, push fails
107
out = self.run_bzr('push ../branch_b',
108
working_dir='branch_a', retcode=3)
109
self.assertEquals(out,
110
('','bzr: ERROR: These branches have diverged. '
111
'See "bzr help diverged-branches" for more information.\n'))
112
self.assertEquals(osutils.abspath(branch_a.get_push_location()),
113
osutils.abspath(branch_b.bzrdir.root_transport.base))
115
# test implicit --remember after resolving previous failure
116
uncommit.uncommit(branch=branch_b, tree=tree_b)
117
transport.delete('branch_b/c')
118
out, err = self.run_bzr('push', working_dir='branch_a')
119
path = branch_a.get_push_location()
120
self.assertEquals(out,
121
'Using saved push location: %s\n'
122
% urlutils.local_path_from_url(path))
123
self.assertEqual(err,
124
'All changes applied successfully.\n'
125
'Pushed up to revision 2.\n')
126
self.assertEqual(path,
127
branch_b.bzrdir.root_transport.base)
128
# test explicit --remember
129
self.run_bzr('push ../branch_c --remember', working_dir='branch_a')
130
self.assertEquals(branch_a.get_push_location(),
131
branch_c.bzrdir.root_transport.base)
133
def test_push_without_tree(self):
134
# bzr push from a branch that does not have a checkout should work.
135
b = self.make_branch('.')
136
out, err = self.run_bzr('push pushed-location')
137
self.assertEqual('', out)
138
self.assertEqual('Created new branch.\n', err)
139
b2 = branch.Branch.open('pushed-location')
140
self.assertEndsWith(b2.base, 'pushed-location/')
142
def test_push_new_branch_revision_count(self):
143
# bzr push of a branch with revisions to a new location
144
# should print the number of revisions equal to the length of the
146
t = self.make_branch_and_tree('tree')
147
self.build_tree(['tree/file'])
150
out, err = self.run_bzr('push -d tree pushed-to')
151
self.assertEqual('', out)
152
self.assertEqual('Created new branch.\n', err)
154
def test_push_only_pushes_history(self):
155
# Knit branches should only push the history for the current revision.
156
format = bzrdir.BzrDirMetaFormat1()
157
format.repository_format = knitrepo.RepositoryFormatKnit1()
158
shared_repo = self.make_repository('repo', format=format, shared=True)
159
shared_repo.set_make_working_trees(True)
161
def make_shared_tree(path):
162
shared_repo.bzrdir.root_transport.mkdir(path)
163
shared_repo.bzrdir.create_branch_convenience('repo/' + path)
164
return workingtree.WorkingTree.open('repo/' + path)
165
tree_a = make_shared_tree('a')
166
self.build_tree(['repo/a/file'])
168
tree_a.commit('commit a-1', rev_id='a-1')
169
f = open('repo/a/file', 'ab')
170
f.write('more stuff\n')
172
tree_a.commit('commit a-2', rev_id='a-2')
174
tree_b = make_shared_tree('b')
175
self.build_tree(['repo/b/file'])
177
tree_b.commit('commit b-1', rev_id='b-1')
179
self.assertTrue(shared_repo.has_revision('a-1'))
180
self.assertTrue(shared_repo.has_revision('a-2'))
181
self.assertTrue(shared_repo.has_revision('b-1'))
183
# Now that we have a repository with shared files, make sure
184
# that things aren't copied out by a 'push'
185
self.run_bzr('push ../../push-b', working_dir='repo/b')
186
pushed_tree = workingtree.WorkingTree.open('push-b')
187
pushed_repo = pushed_tree.branch.repository
188
self.assertFalse(pushed_repo.has_revision('a-1'))
189
self.assertFalse(pushed_repo.has_revision('a-2'))
190
self.assertTrue(pushed_repo.has_revision('b-1'))
192
def test_push_funky_id(self):
193
t = self.make_branch_and_tree('tree')
194
self.build_tree(['tree/filename'])
195
t.add('filename', 'funky-chars<>%&;"\'')
196
t.commit('commit filename')
197
self.run_bzr('push -d tree new-tree')
199
def test_push_dash_d(self):
200
t = self.make_branch_and_tree('from')
201
t.commit(allow_pointless=True,
202
message='first commit')
203
self.run_bzr('push -d from to-one')
204
self.failUnlessExists('to-one')
205
self.run_bzr('push -d %s %s'
206
% tuple(map(urlutils.local_path_to_url, ['from', 'to-two'])))
207
self.failUnlessExists('to-two')
209
def test_push_smart_non_stacked_streaming_acceptance(self):
210
self.setup_smart_server_with_call_log()
211
t = self.make_branch_and_tree('from')
212
t.commit(allow_pointless=True, message='first commit')
213
self.reset_smart_call_log()
214
self.run_bzr(['push', self.get_url('to-one')], working_dir='from')
215
# This figure represent the amount of work to perform this use case. It
216
# is entirely ok to reduce this number if a test fails due to rpc_count
217
# being too low. If rpc_count increases, more network roundtrips have
218
# become necessary for this use case. Please do not adjust this number
219
# upwards without agreement from bzr's network support maintainers.
220
self.assertLength(9, self.hpss_calls)
222
def test_push_smart_stacked_streaming_acceptance(self):
223
self.setup_smart_server_with_call_log()
224
parent = self.make_branch_and_tree('parent', format='1.9')
225
parent.commit(message='first commit')
226
local = parent.bzrdir.sprout('local').open_workingtree()
227
local.commit(message='local commit')
228
self.reset_smart_call_log()
229
self.run_bzr(['push', '--stacked', '--stacked-on', '../parent',
230
self.get_url('public')], working_dir='local')
231
# This figure represent the amount of work to perform this use case. It
232
# is entirely ok to reduce this number if a test fails due to rpc_count
233
# being too low. If rpc_count increases, more network roundtrips have
234
# become necessary for this use case. Please do not adjust this number
235
# upwards without agreement from bzr's network support maintainers.
236
self.assertLength(14, self.hpss_calls)
237
remote = branch.Branch.open('public')
238
self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
240
def test_push_smart_with_default_stacking_url_path_segment(self):
241
# If the default stacked-on location is a path element then branches
242
# we push there over the smart server are stacked and their
243
# stacked_on_url is that exact path segment. Added to nail bug 385132.
244
self.setup_smart_server_with_call_log()
245
self.make_branch('stack-on', format='1.9')
246
self.make_bzrdir('.').get_config().set_default_stack_on(
248
self.make_branch('from', format='1.9')
249
out, err = self.run_bzr(['push', '-d', 'from', self.get_url('to')])
250
b = branch.Branch.open(self.get_url('to'))
251
self.assertEqual('/extra/stack-on', b.get_stacked_on_url())
253
def test_push_smart_with_default_stacking_relative_path(self):
254
# If the default stacked-on location is a relative path then branches
255
# we push there over the smart server are stacked and their
256
# stacked_on_url is a relative path. Added to nail bug 385132.
257
self.setup_smart_server_with_call_log()
258
self.make_branch('stack-on', format='1.9')
259
self.make_bzrdir('.').get_config().set_default_stack_on('stack-on')
260
self.make_branch('from', format='1.9')
261
out, err = self.run_bzr(['push', '-d', 'from', self.get_url('to')])
262
b = branch.Branch.open(self.get_url('to'))
263
self.assertEqual('../stack-on', b.get_stacked_on_url())
265
def create_simple_tree(self):
266
tree = self.make_branch_and_tree('tree')
267
self.build_tree(['tree/a'])
268
tree.add(['a'], ['a-id'])
269
tree.commit('one', rev_id='r1')
272
def test_push_create_prefix(self):
273
"""'bzr push --create-prefix' will create leading directories."""
274
tree = self.create_simple_tree()
276
self.run_bzr_error(['Parent directory of ../new/tree does not exist'],
279
self.run_bzr('push ../new/tree --create-prefix',
281
new_tree = workingtree.WorkingTree.open('new/tree')
282
self.assertEqual(tree.last_revision(), new_tree.last_revision())
283
self.failUnlessExists('new/tree/a')
285
def test_push_use_existing(self):
286
"""'bzr push --use-existing-dir' can push into an existing dir.
288
By default, 'bzr push' will not use an existing, non-versioned dir.
290
tree = self.create_simple_tree()
291
self.build_tree(['target/'])
293
self.run_bzr_error(['Target directory ../target already exists',
294
'Supply --use-existing-dir',
296
'push ../target', working_dir='tree')
298
self.run_bzr('push --use-existing-dir ../target',
301
new_tree = workingtree.WorkingTree.open('target')
302
self.assertEqual(tree.last_revision(), new_tree.last_revision())
303
# The push should have created target/a
304
self.failUnlessExists('target/a')
306
def test_push_onto_repo(self):
307
"""We should be able to 'bzr push' into an existing bzrdir."""
308
tree = self.create_simple_tree()
309
repo = self.make_repository('repo', shared=True)
311
self.run_bzr('push ../repo',
314
# Pushing onto an existing bzrdir will create a repository and
315
# branch as needed, but will only create a working tree if there was
317
self.assertRaises(errors.NoWorkingTree,
318
workingtree.WorkingTree.open, 'repo')
319
new_branch = branch.Branch.open('repo')
320
self.assertEqual(tree.last_revision(), new_branch.last_revision())
322
def test_push_onto_just_bzrdir(self):
323
"""We don't handle when the target is just a bzrdir.
325
Because you shouldn't be able to create *just* a bzrdir in the wild.
327
# TODO: jam 20070109 Maybe it would be better to create the repository
329
tree = self.create_simple_tree()
330
a_bzrdir = self.make_bzrdir('dir')
332
self.run_bzr_error(['At ../dir you have a valid .bzr control'],
336
def test_push_with_revisionspec(self):
337
"""We should be able to push a revision older than the tip."""
338
tree_from = self.make_branch_and_tree('from')
339
tree_from.commit("One.", rev_id="from-1")
340
tree_from.commit("Two.", rev_id="from-2")
342
self.run_bzr('push -r1 ../to', working_dir='from')
344
tree_to = workingtree.WorkingTree.open('to')
345
repo_to = tree_to.branch.repository
346
self.assertTrue(repo_to.has_revision('from-1'))
347
self.assertFalse(repo_to.has_revision('from-2'))
348
self.assertEqual(tree_to.branch.last_revision_info()[1], 'from-1')
351
['bzr: ERROR: bzr push --revision '
352
'takes exactly one revision identifier\n'],
353
'push -r0..2 ../to', working_dir='from')
355
def create_trunk_and_feature_branch(self):
357
trunk_tree = self.make_branch_and_tree('target',
359
trunk_tree.commit('mainline')
360
# and a branch from it
361
branch_tree = self.make_branch_and_tree('branch',
363
branch_tree.pull(trunk_tree.branch)
364
branch_tree.branch.set_parent(trunk_tree.branch.base)
365
# with some work on it
366
branch_tree.commit('moar work plz')
367
return trunk_tree, branch_tree
369
def assertPublished(self, branch_revid, stacked_on):
370
"""Assert that the branch 'published' has been published correctly."""
371
published_branch = branch.Branch.open('published')
372
# The published branch refers to the mainline
373
self.assertEqual(stacked_on, published_branch.get_stacked_on_url())
374
# and the branch's work was pushed
375
self.assertTrue(published_branch.repository.has_revision(branch_revid))
377
def test_push_new_branch_stacked_on(self):
378
"""Pushing a new branch with --stacked-on creates a stacked branch."""
379
trunk_tree, branch_tree = self.create_trunk_and_feature_branch()
380
# we publish branch_tree with a reference to the mainline.
381
out, err = self.run_bzr(['push', '--stacked-on', trunk_tree.branch.base,
382
self.get_url('published')], working_dir='branch')
383
self.assertEqual('', out)
384
self.assertEqual('Created new stacked branch referring to %s.\n' %
385
trunk_tree.branch.base, err)
386
self.assertPublished(branch_tree.last_revision(),
387
trunk_tree.branch.base)
389
def test_push_new_branch_stacked_uses_parent_when_no_public_url(self):
390
"""When the parent has no public url the parent is used as-is."""
391
trunk_tree, branch_tree = self.create_trunk_and_feature_branch()
392
# now we do a stacked push, which should determine the public location
394
out, err = self.run_bzr(['push', '--stacked',
395
self.get_url('published')], working_dir='branch')
396
self.assertEqual('', out)
397
self.assertEqual('Created new stacked branch referring to %s.\n' %
398
trunk_tree.branch.base, err)
399
self.assertPublished(branch_tree.last_revision(),
400
trunk_tree.branch.base)
402
def test_push_new_branch_stacked_uses_parent_public(self):
403
"""Pushing a new branch with --stacked creates a stacked branch."""
404
trunk_tree, branch_tree = self.create_trunk_and_feature_branch()
405
# the trunk is published on a web server
406
self.transport_readonly_server = http_server.HttpServer
407
trunk_public = self.make_branch('public_trunk', format='1.9')
408
trunk_public.pull(trunk_tree.branch)
409
trunk_public_url = self.get_readonly_url('public_trunk')
410
trunk_tree.branch.set_public_branch(trunk_public_url)
411
# now we do a stacked push, which should determine the public location
413
out, err = self.run_bzr(['push', '--stacked',
414
self.get_url('published')], working_dir='branch')
415
self.assertEqual('', out)
416
self.assertEqual('Created new stacked branch referring to %s.\n' %
417
trunk_public_url, err)
418
self.assertPublished(branch_tree.last_revision(), trunk_public_url)
420
def test_push_new_branch_stacked_no_parent(self):
421
"""Pushing with --stacked and no parent branch errors."""
422
branch = self.make_branch_and_tree('branch', format='1.9')
423
# now we do a stacked push, which should fail as the place to refer too
424
# cannot be determined.
425
out, err = self.run_bzr_error(
426
['Could not determine branch to refer to\\.'], ['push', '--stacked',
427
self.get_url('published')], working_dir='branch')
428
self.assertEqual('', out)
429
self.assertFalse(self.get_transport('published').has('.'))
431
def test_push_notifies_default_stacking(self):
432
self.make_branch('stack_on', format='1.6')
433
self.make_bzrdir('.').get_config().set_default_stack_on('stack_on')
434
self.make_branch('from', format='1.6')
435
out, err = self.run_bzr('push -d from to')
436
self.assertContainsRe(err,
437
'Using default stacking branch stack_on at .*')
439
def test_push_stacks_with_default_stacking_if_target_is_stackable(self):
440
self.make_branch('stack_on', format='1.6')
441
self.make_bzrdir('.').get_config().set_default_stack_on('stack_on')
442
self.make_branch('from', format='pack-0.92')
443
out, err = self.run_bzr('push -d from to')
444
b = branch.Branch.open('to')
445
self.assertEqual('../stack_on', b.get_stacked_on_url())
447
def test_push_does_not_change_format_with_default_if_target_cannot(self):
448
self.make_branch('stack_on', format='pack-0.92')
449
self.make_bzrdir('.').get_config().set_default_stack_on('stack_on')
450
self.make_branch('from', format='pack-0.92')
451
out, err = self.run_bzr('push -d from to')
452
b = branch.Branch.open('to')
453
self.assertRaises(errors.UnstackableBranchFormat, b.get_stacked_on_url)
455
def test_push_doesnt_create_broken_branch(self):
456
"""Pushing a new standalone branch works even when there's a default
457
stacking policy at the destination.
459
The new branch will preserve the repo format (even if it isn't the
460
default for the branch), and will be stacked when the repo format
461
allows (which means that the branch format isn't necessarly preserved).
463
self.make_repository('repo', shared=True, format='1.6')
464
builder = self.make_branch_builder('repo/local', format='pack-0.92')
465
builder.start_series()
466
builder.build_snapshot('rev-1', None, [
467
('add', ('', 'root-id', 'directory', '')),
468
('add', ('filename', 'f-id', 'file', 'content\n'))])
469
builder.build_snapshot('rev-2', ['rev-1'], [])
470
builder.build_snapshot('rev-3', ['rev-2'],
471
[('modify', ('f-id', 'new-content\n'))])
472
builder.finish_series()
473
branch = builder.get_branch()
474
# Push rev-1 to "trunk", so that we can stack on it.
475
self.run_bzr('push -d repo/local trunk -r 1')
476
# Set a default stacking policy so that new branches will automatically
478
self.make_bzrdir('.').get_config().set_default_stack_on('trunk')
479
# Push rev-2 to a new branch "remote". It will be stacked on "trunk".
480
out, err = self.run_bzr('push -d repo/local remote -r 2')
481
self.assertContainsRe(
482
err, 'Using default stacking branch trunk at .*')
483
# Push rev-3 onto "remote". If "remote" not stacked and is missing the
484
# fulltext record for f-id @ rev-1, then this will fail.
485
out, err = self.run_bzr('push -d repo/local remote -r 3')
487
def test_push_verbose_shows_log(self):
488
tree = self.make_branch_and_tree('source')
490
out, err = self.run_bzr('push -v -d source target')
491
# initial push contains log
492
self.assertContainsRe(out, 'rev1')
494
out, err = self.run_bzr('push -v -d source target')
495
# subsequent push contains log
496
self.assertContainsRe(out, 'rev2')
497
# subsequent log is accurate
498
self.assertNotContainsRe(out, 'rev1')
500
def test_push_from_subdir(self):
501
t = self.make_branch_and_tree('tree')
502
self.build_tree(['tree/dir/', 'tree/dir/file'])
503
t.add('dir', 'dir/file')
505
out, err = self.run_bzr('push ../../pushloc', working_dir='tree/dir')
506
self.assertEqual('', out)
507
self.assertEqual('Created new branch.\n', err)
510
class RedirectingMemoryTransport(memory.MemoryTransport):
512
def mkdir(self, relpath, mode=None):
513
from bzrlib.trace import mutter
514
if self._cwd == '/source/':
515
raise errors.RedirectRequested(self.abspath(relpath),
516
self.abspath('../target'),
518
elif self._cwd == '/infinite-loop/':
519
raise errors.RedirectRequested(self.abspath(relpath),
520
self.abspath('../infinite-loop'),
523
return super(RedirectingMemoryTransport, self).mkdir(
526
def _redirected_to(self, source, target):
527
# We do accept redirections
528
return transport.get_transport(target)
531
class RedirectingMemoryServer(memory.MemoryServer):
534
self._dirs = {'/': None}
537
self._scheme = 'redirecting-memory+%s:///' % id(self)
538
transport.register_transport(self._scheme, self._memory_factory)
540
def _memory_factory(self, url):
541
result = RedirectingMemoryTransport(url)
542
result._dirs = self._dirs
543
result._files = self._files
544
result._locks = self._locks
548
transport.unregister_transport(self._scheme, self._memory_factory)
551
class TestPushRedirect(tests.TestCaseWithTransport):
554
tests.TestCaseWithTransport.setUp(self)
555
self.memory_server = RedirectingMemoryServer()
556
self.memory_server.setUp()
557
self.addCleanup(self.memory_server.tearDown)
559
# Make the branch and tree that we'll be pushing.
560
t = self.make_branch_and_tree('tree')
561
self.build_tree(['tree/file'])
565
def test_push_redirects_on_mkdir(self):
566
"""If the push requires a mkdir, push respects redirect requests.
568
This is added primarily to handle lp:/ URI support, so that users can
569
push to new branches by specifying lp:/ URIs.
571
destination_url = self.memory_server.get_url() + 'source'
572
self.run_bzr(['push', '-d', 'tree', destination_url])
574
local_revision = branch.Branch.open('tree').last_revision()
575
remote_revision = branch.Branch.open(
576
self.memory_server.get_url() + 'target').last_revision()
577
self.assertEqual(remote_revision, local_revision)
579
def test_push_gracefully_handles_too_many_redirects(self):
580
"""Push fails gracefully if the mkdir generates a large number of
583
destination_url = self.memory_server.get_url() + 'infinite-loop'
584
out, err = self.run_bzr_error(
585
['Too many redirections trying to make %s\\.\n'
586
% re.escape(destination_url)],
587
['push', '-d', 'tree', destination_url], retcode=3)
588
self.assertEqual('', out)
591
class TestPushStrict(tests.TestCaseWithTransport):
593
def make_local_branch_and_tree(self):
594
self.tree = self.make_branch_and_tree('local')
595
self.build_tree_contents([('local/file', 'initial')])
596
self.tree.add('file')
597
self.tree.commit('adding file', rev_id='added')
598
self.build_tree_contents([('local/file', 'modified')])
599
self.tree.commit('modify file', rev_id='modified')
601
def set_config_push_strict(self, value):
602
# set config var (any of bazaar.conf, locations.conf, branch.conf
604
conf = self.tree.branch.get_config()
605
conf.set_user_option('push_strict', value)
607
def assertPushFails(self, args):
608
self.run_bzr_error(['Working tree ".*/local/"'
609
' has uncommitted changes \(See bzr status\)\.',],
610
['push', '../to'] + args,
611
working_dir='local', retcode=3)
613
def assertPushSucceeds(self, args, pushed_revid=None):
614
self.run_bzr(['push', '../to'] + args,
616
if pushed_revid is None:
617
pushed_revid = 'modified'
618
tree_to = workingtree.WorkingTree.open('to')
619
repo_to = tree_to.branch.repository
620
self.assertTrue(repo_to.has_revision(pushed_revid))
621
self.assertEqual(tree_to.branch.last_revision_info()[1], pushed_revid)
625
class TestPushStrictWithoutChanges(TestPushStrict):
628
super(TestPushStrictWithoutChanges, self).setUp()
629
self.make_local_branch_and_tree()
631
def test_push_default(self):
632
self.assertPushSucceeds([])
634
def test_push_strict(self):
635
self.assertPushSucceeds(['--strict'])
637
def test_push_no_strict(self):
638
self.assertPushSucceeds(['--no-strict'])
640
def test_push_config_var_strict(self):
641
self.set_config_push_strict('true')
642
self.assertPushSucceeds([])
644
def test_push_config_var_no_strict(self):
645
self.set_config_push_strict('false')
646
self.assertPushSucceeds([])
649
class TestPushStrictWithChanges(TestPushStrict):
651
_changes_type = None # Set by load_tests
654
super(TestPushStrictWithChanges, self).setUp()
655
getattr(self, self._changes_type)()
657
def _uncommitted_changes(self):
658
self.make_local_branch_and_tree()
659
# Make a change without committing it
660
self.build_tree_contents([('local/file', 'in progress')])
662
def _pending_merges(self):
663
self.make_local_branch_and_tree()
664
# Create 'other' branch containing a new file
665
other_bzrdir = self.tree.bzrdir.sprout('other')
666
other_tree = other_bzrdir.open_workingtree()
667
self.build_tree_contents([('other/other-file', 'other')])
668
other_tree.add('other-file')
669
other_tree.commit('other commit', rev_id='other')
670
# Merge and revert, leaving a pending merge
671
self.tree.merge_from_branch(other_tree.branch)
672
self.tree.revert(filenames=['other-file'], backups=False)
674
def test_push_default(self):
675
self.assertPushFails([])
677
def test_push_with_revision(self):
678
self.assertPushSucceeds(['-r', 'revid:added'], pushed_revid='added')
680
def test_push_no_strict(self):
681
self.assertPushSucceeds(['--no-strict'])
683
def test_push_strict_with_changes(self):
684
self.assertPushFails(['--strict'])
686
def test_push_respect_config_var_strict(self):
687
self.set_config_push_strict('true')
688
self.assertPushFails([])
690
def test_push_bogus_config_var_ignored(self):
691
self.set_config_push_strict("I don't want you to be strict")
692
self.assertPushFails([])
694
def test_push_no_strict_command_line_override_config(self):
695
self.set_config_push_strict('yES')
696
self.assertPushFails([])
697
self.assertPushSucceeds(['--no-strict'])
699
def test_push_strict_command_line_override_config(self):
700
self.set_config_push_strict('oFF')
701
self.assertPushFails(['--strict'])
702
self.assertPushSucceeds([])
added
removed
bzrlib/tests/blackbox/test_push.py
