← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Vincent Ladeuil
  • Date: 2016-01-21 11:42:23 UTC
  • mto: This revision was merged to the branch mainline in revision 6610.
  • Revision ID: v.ladeuil+lp@free.fr-20160121114223-ngcvndi02ydiqs5z
Allow hyphens in option names to unbreak compatibility.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_pull.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2012 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
20
20
import os
21
21
import sys
22
22
 
23
 
from bzrlib.branch import Branch
 
23
from bzrlib import (
 
24
    branch,
 
25
    debug,
 
26
    osutils,
 
27
    remote,
 
28
    tests,
 
29
    uncommit,
 
30
    urlutils,
 
31
    workingtree,
 
32
    )
 
33
 
24
34
from bzrlib.directory_service import directories
25
 
from bzrlib.osutils import pathjoin
26
 
from bzrlib.tests.blackbox import ExternalBase
27
 
from bzrlib.uncommit import uncommit
28
 
from bzrlib.workingtree import WorkingTree
29
 
from bzrlib import urlutils
30
 
 
31
 
 
32
 
class TestPull(ExternalBase):
 
35
from bzrlib.tests import (
 
36
    fixtures,
 
37
    script,
 
38
    )
 
39
 
 
40
 
 
41
class TestPull(tests.TestCaseWithTransport):
33
42
 
34
43
    def example_branch(self, path='.'):
35
44
        tree = self.make_branch_and_tree(path)
36
45
        self.build_tree_contents([
37
 
            (pathjoin(path, 'hello'),   'foo'),
38
 
            (pathjoin(path, 'goodbye'), 'baz')])
 
46
            (osutils.pathjoin(path, 'hello'),   'foo'),
 
47
            (osutils.pathjoin(path, 'goodbye'), 'baz')])
39
48
        tree.add('hello')
40
49
        tree.commit(message='setup')
41
50
        tree.add('goodbye')
45
54
    def test_pull(self):
46
55
        """Pull changes from one branch to another."""
47
56
        a_tree = self.example_branch('a')
48
 
        os.chdir('a')
49
 
        self.run_bzr('pull', retcode=3)
50
 
        self.run_bzr('missing', retcode=3)
51
 
        self.run_bzr('missing .')
52
 
        self.run_bzr('missing')
 
57
        base_rev = a_tree.branch.last_revision()
 
58
        self.run_bzr('pull', retcode=3, working_dir='a')
 
59
        self.run_bzr('missing', retcode=3, working_dir='a')
 
60
        self.run_bzr('missing .', working_dir='a')
 
61
        self.run_bzr('missing', working_dir='a')
53
62
        # this will work on windows because we check for the same branch
54
63
        # in pull - if it fails, it is a regression
55
 
        self.run_bzr('pull')
56
 
        self.run_bzr('pull /', retcode=3)
 
64
        self.run_bzr('pull', working_dir='a')
 
65
        self.run_bzr('pull /', retcode=3, working_dir='a')
57
66
        if sys.platform not in ('win32', 'cygwin'):
58
 
            self.run_bzr('pull')
 
67
            self.run_bzr('pull', working_dir='a')
59
68
 
60
 
        os.chdir('..')
61
69
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
62
 
        os.chdir('b')
63
 
        self.run_bzr('pull')
64
 
        os.mkdir('subdir')
 
70
        self.run_bzr('pull', working_dir='b')
 
71
        os.mkdir('b/subdir')
65
72
        b_tree.add('subdir')
66
 
        b_tree.commit(message='blah', allow_pointless=True)
67
 
 
68
 
        os.chdir('..')
69
 
        a = Branch.open('a')
70
 
        b = Branch.open('b')
71
 
        self.assertEqual(a.revision_history(), b.revision_history()[:-1])
72
 
 
73
 
        os.chdir('a')
74
 
        self.run_bzr('pull ../b')
75
 
        self.assertEqual(a.revision_history(), b.revision_history())
 
73
        new_rev = b_tree.commit(message='blah', allow_pointless=True)
 
74
 
 
75
        a = branch.Branch.open('a')
 
76
        b = branch.Branch.open('b')
 
77
        self.assertEqual(a.last_revision(), base_rev)
 
78
        self.assertEqual(b.last_revision(), new_rev)
 
79
 
 
80
        self.run_bzr('pull ../b', working_dir='a')
 
81
        self.assertEqual(a.last_revision(), b.last_revision())
76
82
        a_tree.commit(message='blah2', allow_pointless=True)
77
83
        b_tree.commit(message='blah3', allow_pointless=True)
78
84
        # no overwrite
79
 
        os.chdir('../b')
80
 
        self.run_bzr('pull ../a', retcode=3)
81
 
        os.chdir('..')
 
85
        self.run_bzr('pull ../a', retcode=3, working_dir='b')
82
86
        b_tree.bzrdir.sprout('overwriteme')
83
 
        os.chdir('overwriteme')
84
 
        self.run_bzr('pull --overwrite ../a')
85
 
        overwritten = Branch.open('.')
86
 
        self.assertEqual(overwritten.revision_history(),
87
 
                         a.revision_history())
 
87
        self.run_bzr('pull --overwrite ../a', working_dir='overwriteme')
 
88
        overwritten = branch.Branch.open('overwriteme')
 
89
        self.assertEqual(overwritten.last_revision(),
 
90
                         a.last_revision())
88
91
        a_tree.merge_from_branch(b_tree.branch)
89
92
        a_tree.commit(message="blah4", allow_pointless=True)
90
 
        os.chdir('../b/subdir')
91
 
        self.run_bzr('pull ../../a')
92
 
        self.assertEqual(a.revision_history()[-1], b.revision_history()[-1])
93
 
        sub_tree = WorkingTree.open_containing('.')[0]
 
93
 
 
94
        self.run_bzr('pull ../../a', working_dir='b/subdir')
 
95
        self.assertEqual(a.last_revision(), b.last_revision())
 
96
        sub_tree = workingtree.WorkingTree.open_containing('b/subdir')[0]
94
97
        sub_tree.commit(message="blah5", allow_pointless=True)
95
98
        sub_tree.commit(message="blah6", allow_pointless=True)
96
 
        os.chdir('..')
97
 
        self.run_bzr('pull ../a')
98
 
        os.chdir('../a')
 
99
        self.run_bzr('pull ../a', working_dir='b')
99
100
        a_tree.commit(message="blah7", allow_pointless=True)
100
101
        a_tree.merge_from_branch(b_tree.branch)
101
102
        a_tree.commit(message="blah8", allow_pointless=True)
102
 
        self.run_bzr('pull ../b')
103
 
        self.run_bzr('pull ../b')
 
103
        self.run_bzr('pull ../b', working_dir='a')
 
104
        self.run_bzr('pull ../b', working_dir='a')
104
105
 
105
106
    def test_pull_dash_d(self):
106
107
        self.example_branch('a')
126
127
 
127
128
        b_tree = a_tree.bzrdir.sprout('b',
128
129
                   revision_id=a_tree.branch.get_rev_id(1)).open_workingtree()
129
 
        os.chdir('b')
130
 
        self.run_bzr('pull -r 2')
131
 
        a = Branch.open('../a')
132
 
        b = Branch.open('.')
 
130
        self.run_bzr('pull -r 2', working_dir='b')
 
131
        a = branch.Branch.open('a')
 
132
        b = branch.Branch.open('b')
133
133
        self.assertEqual(a.revno(),4)
134
134
        self.assertEqual(b.revno(),2)
135
 
        self.run_bzr('pull -r 3')
 
135
        self.run_bzr('pull -r 3', working_dir='b')
136
136
        self.assertEqual(b.revno(),3)
137
 
        self.run_bzr('pull -r 4')
138
 
        self.assertEqual(a.revision_history(), b.revision_history())
 
137
        self.run_bzr('pull -r 4', working_dir='b')
 
138
        self.assertEqual(a.last_revision(), b.last_revision())
139
139
 
 
140
    def test_pull_tags(self):
 
141
        """Tags are updated by pull, and revisions named in those tags are
 
142
        fetched.
 
143
        """
 
144
        # Make a source, sprout a target off it
 
145
        builder = self.make_branch_builder('source')
 
146
        source = fixtures.build_branch_with_non_ancestral_rev(builder)
 
147
        source.get_config_stack().set('branch.fetch_tags', True)
 
148
        target_bzrdir = source.bzrdir.sprout('target')
 
149
        source.tags.set_tag('tag-a', 'rev-2')
 
150
        # Pull from source
 
151
        self.run_bzr('pull -d target source')
 
152
        target = target_bzrdir.open_branch()
 
153
        # The tag is present, and so is its revision.
 
154
        self.assertEqual('rev-2', target.tags.lookup_tag('tag-a'))
 
155
        target.repository.get_revision('rev-2')
140
156
 
141
157
    def test_overwrite_uptodate(self):
142
158
        # Make sure pull --overwrite overwrites
155
171
        self.build_tree_contents([('a/foo', 'a third change')])
156
172
        a_tree.commit(message='a third change')
157
173
 
158
 
        rev_history_a = a_tree.branch.revision_history()
159
 
        self.assertEqual(len(rev_history_a), 3)
 
174
        self.assertEqual(a_tree.branch.last_revision_info()[0], 3)
160
175
 
161
176
        b_tree.merge_from_branch(a_tree.branch)
162
177
        b_tree.commit(message='merge')
163
178
 
164
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
165
 
 
166
 
        os.chdir('b')
167
 
        self.run_bzr('pull --overwrite ../a')
168
 
        rev_history_b = b_tree.branch.revision_history()
169
 
        self.assertEqual(len(rev_history_b), 3)
170
 
 
171
 
        self.assertEqual(rev_history_b, rev_history_a)
 
179
        self.assertEqual(b_tree.branch.last_revision_info()[0], 2)
 
180
 
 
181
        self.run_bzr('pull --overwrite ../a', working_dir='b')
 
182
        (last_revinfo_b) = b_tree.branch.last_revision_info()
 
183
        self.assertEqual(last_revinfo_b[0], 3)
 
184
        self.assertEqual(last_revinfo_b[1], a_tree.branch.last_revision())
172
185
 
173
186
    def test_overwrite_children(self):
174
187
        # Make sure pull --overwrite sets the revision-history
186
199
        self.build_tree_contents([('a/foo', 'a third change')])
187
200
        a_tree.commit(message='a third change')
188
201
 
189
 
        self.assertEqual(len(a_tree.branch.revision_history()), 3)
 
202
        self.assertEqual(a_tree.branch.last_revision_info()[0], 3)
190
203
 
191
204
        b_tree.merge_from_branch(a_tree.branch)
192
205
        b_tree.commit(message='merge')
193
206
 
194
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
 
207
        self.assertEqual(b_tree.branch.last_revision_info()[0], 2)
195
208
 
196
209
        self.build_tree_contents([('a/foo', 'a fourth change\n')])
197
210
        a_tree.commit(message='a fourth change')
198
211
 
199
 
        rev_history_a = a_tree.branch.revision_history()
200
 
        self.assertEqual(len(rev_history_a), 4)
 
212
        rev_info_a = a_tree.branch.last_revision_info()
 
213
        self.assertEqual(rev_info_a[0], 4)
201
214
 
202
215
        # With convergence, we could just pull over the
203
216
        # new change, but with --overwrite, we want to switch our history
204
 
        os.chdir('b')
205
 
        self.run_bzr('pull --overwrite ../a')
206
 
        rev_history_b = b_tree.branch.revision_history()
207
 
        self.assertEqual(len(rev_history_b), 4)
208
 
 
209
 
        self.assertEqual(rev_history_b, rev_history_a)
 
217
        self.run_bzr('pull --overwrite ../a', working_dir='b')
 
218
        rev_info_b = b_tree.branch.last_revision_info()
 
219
        self.assertEqual(rev_info_b[0], 4)
 
220
        self.assertEqual(rev_info_b, rev_info_a)
210
221
 
211
222
    def test_pull_remember(self):
212
223
        """Pull changes from one branch to another and test parent location."""
213
 
        transport = self.get_transport()
 
224
        t = self.get_transport()
214
225
        tree_a = self.make_branch_and_tree('branch_a')
215
226
        branch_a = tree_a.branch
216
227
        self.build_tree(['branch_a/a'])
225
236
        tree_a.commit('commit b')
226
237
        # reset parent
227
238
        parent = branch_b.get_parent()
 
239
        branch_b = branch.Branch.open('branch_b')
228
240
        branch_b.set_parent(None)
229
241
        self.assertEqual(None, branch_b.get_parent())
230
242
        # test pull for failure without parent set
231
 
        os.chdir('branch_b')
232
 
        out = self.run_bzr('pull', retcode=3)
 
243
        out = self.run_bzr('pull', retcode=3, working_dir='branch_b')
233
244
        self.assertEqual(out,
234
245
                ('','bzr: ERROR: No pull location known or specified.\n'))
235
246
        # test implicit --remember when no parent set, this pull conflicts
236
 
        self.build_tree(['d'])
 
247
        self.build_tree(['branch_b/d'])
237
248
        tree_b.add('d')
238
249
        tree_b.commit('commit d')
239
 
        out = self.run_bzr('pull ../branch_a', retcode=3)
 
250
        out = self.run_bzr('pull ../branch_a', retcode=3,
 
251
                           working_dir='branch_b')
240
252
        self.assertEqual(out,
241
253
                ('','bzr: ERROR: These branches have diverged.'
242
254
                    ' Use the missing command to see how.\n'
243
255
                    'Use the merge command to reconcile them.\n'))
244
 
        self.assertEqual(branch_b.get_parent(), parent)
 
256
        tree_b = tree_b.bzrdir.open_workingtree()
 
257
        branch_b = tree_b.branch
 
258
        self.assertEqual(parent, branch_b.get_parent())
245
259
        # test implicit --remember after resolving previous failure
246
 
        uncommit(branch=branch_b, tree=tree_b)
247
 
        transport.delete('branch_b/d')
248
 
        self.run_bzr('pull')
 
260
        uncommit.uncommit(branch=branch_b, tree=tree_b)
 
261
        t.delete('branch_b/d')
 
262
        self.run_bzr('pull', working_dir='branch_b')
 
263
        # Refresh the branch object as 'pull' modified it
 
264
        branch_b = branch_b.bzrdir.open_branch()
249
265
        self.assertEqual(branch_b.get_parent(), parent)
250
266
        # test explicit --remember
251
 
        self.run_bzr('pull ../branch_c --remember')
252
 
        self.assertEqual(branch_b.get_parent(),
253
 
                          branch_c.bzrdir.root_transport.base)
 
267
        self.run_bzr('pull ../branch_c --remember', working_dir='branch_b')
 
268
        # Refresh the branch object as 'pull' modified it
 
269
        branch_b = branch_b.bzrdir.open_branch()
 
270
        self.assertEqual(branch_c.bzrdir.root_transport.base,
 
271
                         branch_b.get_parent())
254
272
 
255
273
    def test_pull_bundle(self):
256
274
        from bzrlib.testament import Testament
257
275
        # Build up 2 trees and prepare for a pull
258
276
        tree_a = self.make_branch_and_tree('branch_a')
259
 
        f = open('branch_a/a', 'wb')
260
 
        f.write('hello')
261
 
        f.close()
 
277
        with open('branch_a/a', 'wb') as f:
 
278
            f.write('hello')
262
279
        tree_a.add('a')
263
280
        tree_a.commit('message')
264
281
 
265
282
        tree_b = tree_a.bzrdir.sprout('branch_b').open_workingtree()
266
283
 
267
284
        # Make a change to 'a' that 'b' can pull
268
 
        f = open('branch_a/a', 'wb')
269
 
        f.write('hey there')
270
 
        f.close()
 
285
        with open('branch_a/a', 'wb') as f:
 
286
            f.write('hey there')
271
287
        tree_a.commit('message')
272
288
 
273
289
        # Create the bundle for 'b' to pull
274
 
        os.chdir('branch_a')
275
 
        self.run_bzr('bundle ../branch_b -o ../bundle')
 
290
        self.run_bzr('bundle ../branch_b -o ../bundle', working_dir='branch_a')
276
291
 
277
 
        os.chdir('../branch_b')
278
 
        out, err = self.run_bzr('pull ../bundle')
 
292
        out, err = self.run_bzr('pull ../bundle', working_dir='branch_b')
279
293
        self.assertEqual(out,
280
294
                         'Now on revision 2.\n')
281
295
        self.assertEqual(err,
282
296
                ' M  a\nAll changes applied successfully.\n')
283
297
 
284
 
        self.assertEqualDiff(tree_a.branch.revision_history(),
285
 
                             tree_b.branch.revision_history())
 
298
        self.assertEqualDiff(tree_a.branch.last_revision(),
 
299
                             tree_b.branch.last_revision())
286
300
 
287
301
        testament_a = Testament.from_revision(tree_a.branch.repository,
288
302
                                              tree_a.get_parent_ids()[0])
292
306
                             testament_b.as_text())
293
307
 
294
308
        # it is legal to attempt to pull an already-merged bundle
295
 
        out, err = self.run_bzr('pull ../bundle')
 
309
        out, err = self.run_bzr('pull ../bundle', working_dir='branch_b')
296
310
        self.assertEqual(err, '')
297
 
        self.assertEqual(out, 'No revisions to pull.\n')
 
311
        self.assertEqual(out, 'No revisions or tags to pull.\n')
298
312
 
299
313
    def test_pull_verbose_no_files(self):
300
314
        """Pull --verbose should not list modified files"""
338
352
            def look_up(self, name, url):
339
353
                return 'source'
340
354
        directories.register('foo:', FooService, 'Testing directory service')
341
 
        self.addCleanup(lambda: directories.remove('foo:'))
 
355
        self.addCleanup(directories.remove, 'foo:')
342
356
        self.run_bzr('pull foo:bar -d target')
343
357
        self.assertEqual(source_last, target.last_revision())
344
358
 
353
367
    def test_pull_verbose_uses_default_log(self):
354
368
        tree = self.example_branch('source')
355
369
        target = self.make_branch_and_tree('target')
356
 
        target_config = target.branch.get_config()
357
 
        target_config.set_user_option('log_format', 'short')
 
370
        target.branch.get_config_stack().set('log_format', 'short')
358
371
        out = self.run_bzr('pull -v source -d target')[0]
359
372
        self.assertContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
360
373
        self.assertNotContainsRe(
361
374
            out, r'revno: 1\ncommitter: .*\nbranch nick: source')
362
375
 
 
376
    def test_pull_smart_bound_branch(self):
 
377
        self.setup_smart_server_with_call_log()
 
378
        parent = self.make_branch_and_tree('parent')
 
379
        parent.commit(message='first commit')
 
380
        child = parent.bzrdir.sprout('child').open_workingtree()
 
381
        child.commit(message='second commit')
 
382
        checkout = parent.branch.create_checkout('checkout')
 
383
        self.run_bzr(['pull', self.get_url('child')], working_dir='checkout')
 
384
 
363
385
    def test_pull_smart_stacked_streaming_acceptance(self):
364
386
        """'bzr pull -r 123' works on stacked, smart branches, even when the
365
387
        revision specified by the revno is only present in the fallback
387
409
        # being too low. If rpc_count increases, more network roundtrips have
388
410
        # become necessary for this use case. Please do not adjust this number
389
411
        # upwards without agreement from bzr's network support maintainers.
390
 
        self.assertLength(18, self.hpss_calls)
391
 
        remote = Branch.open('stacked')
 
412
        self.assertLength(19, self.hpss_calls)
 
413
        self.assertLength(1, self.hpss_connections)
 
414
        remote = branch.Branch.open('stacked')
392
415
        self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
393
416
 
 
417
    def test_pull_cross_format_warning(self):
 
418
        """You get a warning for probably slow cross-format pulls.
 
419
        """
 
420
        # this is assumed to be going through InterDifferingSerializer
 
421
        from_tree = self.make_branch_and_tree('from', format='2a')
 
422
        to_tree = self.make_branch_and_tree('to', format='1.14-rich-root')
 
423
        from_tree.commit(message='first commit')
 
424
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
 
425
        self.assertContainsRe(err,
 
426
            "(?m)Doing on-the-fly conversion")
 
427
 
 
428
    def test_pull_cross_format_warning_no_IDS(self):
 
429
        """You get a warning for probably slow cross-format pulls.
 
430
        """
 
431
        # this simulates what would happen across the network, where
 
432
        # interdifferingserializer is not active
 
433
 
 
434
        debug.debug_flags.add('IDS_never')
 
435
        # TestCase take care of restoring them
 
436
 
 
437
        from_tree = self.make_branch_and_tree('from', format='2a')
 
438
        to_tree = self.make_branch_and_tree('to', format='1.14-rich-root')
 
439
        from_tree.commit(message='first commit')
 
440
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
 
441
        self.assertContainsRe(err,
 
442
            "(?m)Doing on-the-fly conversion")
 
443
 
 
444
    def test_pull_cross_format_from_network(self):
 
445
        self.setup_smart_server_with_call_log()
 
446
        from_tree = self.make_branch_and_tree('from', format='2a')
 
447
        to_tree = self.make_branch_and_tree('to', format='1.14-rich-root')
 
448
        self.assertIsInstance(from_tree.branch, remote.RemoteBranch)
 
449
        from_tree.commit(message='first commit')
 
450
        out, err = self.run_bzr(['pull', '-d', 'to',
 
451
            from_tree.branch.bzrdir.root_transport.base])
 
452
        self.assertContainsRe(err,
 
453
            "(?m)Doing on-the-fly conversion")
 
454
 
 
455
    def test_pull_to_experimental_format_warning(self):
 
456
        """You get a warning for pulling into experimental formats.
 
457
        """
 
458
        from_tree = self.make_branch_and_tree('from', format='development-subtree')
 
459
        to_tree = self.make_branch_and_tree('to', format='development-subtree')
 
460
        from_tree.commit(message='first commit')
 
461
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
 
462
        self.assertContainsRe(err,
 
463
            "(?m)Fetching into experimental format")
 
464
 
 
465
    def test_pull_cross_to_experimental_format_warning(self):
 
466
        """You get a warning for pulling into experimental formats.
 
467
        """
 
468
        from_tree = self.make_branch_and_tree('from', format='2a')
 
469
        to_tree = self.make_branch_and_tree('to', format='development-subtree')
 
470
        from_tree.commit(message='first commit')
 
471
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
 
472
        self.assertContainsRe(err,
 
473
            "(?m)Fetching into experimental format")
 
474
 
 
475
    def test_pull_show_base(self):
 
476
        """bzr pull supports --show-base
 
477
 
 
478
        see https://bugs.launchpad.net/bzr/+bug/202374"""
 
479
        # create two trees with conflicts, setup conflict, check that
 
480
        # conflicted file looks correct
 
481
        a_tree = self.example_branch('a')
 
482
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
483
 
 
484
        with open(osutils.pathjoin('a', 'hello'),'wt') as f:
 
485
            f.write('fee')
 
486
        a_tree.commit('fee')
 
487
 
 
488
        with open(osutils.pathjoin('b', 'hello'),'wt') as f:
 
489
            f.write('fie')
 
490
 
 
491
        out,err=self.run_bzr(['pull','-d','b','a','--show-base'])
 
492
 
 
493
        # check for message here
 
494
        self.assertEqual(
 
495
            err,
 
496
            ' M  hello\nText conflict in hello\n1 conflicts encountered.\n')
 
497
 
 
498
        self.assertEqualDiff('<<<<<<< TREE\n'
 
499
                             'fie||||||| BASE-REVISION\n'
 
500
                             'foo=======\n'
 
501
                             'fee>>>>>>> MERGE-SOURCE\n',
 
502
                             open(osutils.pathjoin('b', 'hello')).read())
 
503
 
 
504
    def test_pull_warns_about_show_base_when_no_working_tree(self):
 
505
        """--show-base is useless if there's no working tree
 
506
 
 
507
        see https://bugs.launchpad.net/bzr/+bug/1022160"""
 
508
        self.make_branch('from')
 
509
        self.make_branch('to')
 
510
        out = self.run_bzr(['pull','-d','to','from','--show-base'])
 
511
        self.assertEqual(out, ('No revisions or tags to pull.\n',
 
512
                               'No working tree, ignoring --show-base\n'))
 
513
 
 
514
    def test_pull_tag_conflicts(self):
 
515
        """pulling tags with conflicts will change the exit code"""
 
516
        # create a branch, see that --show-base fails
 
517
        from_tree = self.make_branch_and_tree('from')
 
518
        from_tree.branch.tags.set_tag("mytag", "somerevid")
 
519
        to_tree = self.make_branch_and_tree('to')
 
520
        to_tree.branch.tags.set_tag("mytag", "anotherrevid")
 
521
        out = self.run_bzr(['pull','-d','to','from'],retcode=1)
 
522
        self.assertEqual(out,
 
523
            ('No revisions to pull.\nConflicting tags:\n    mytag\n', ''))
 
524
 
 
525
    def test_pull_tag_notification(self):
 
526
        """pulling tags with conflicts will change the exit code"""
 
527
        # create a branch, see that --show-base fails
 
528
        from_tree = self.make_branch_and_tree('from')
 
529
        from_tree.branch.tags.set_tag("mytag", "somerevid")
 
530
        to_tree = self.make_branch_and_tree('to')
 
531
        out = self.run_bzr(['pull', '-d', 'to', 'from'])
 
532
        self.assertEqual(out,
 
533
            ('1 tag(s) updated.\n', ''))
 
534
 
 
535
    def test_overwrite_tags(self):
 
536
        """--overwrite-tags only overwrites tags, not revisions."""
 
537
        from_tree = self.make_branch_and_tree('from')
 
538
        from_tree.branch.tags.set_tag("mytag", "somerevid")
 
539
        to_tree = self.make_branch_and_tree('to')
 
540
        to_tree.branch.tags.set_tag("mytag", "anotherrevid")
 
541
        revid1 = to_tree.commit('my commit')
 
542
        out = self.run_bzr(['pull', '-d', 'to', 'from'], retcode=1)
 
543
        self.assertEquals(out,
 
544
            ('No revisions to pull.\nConflicting tags:\n    mytag\n', ''))
 
545
        out = self.run_bzr(['pull', '-d', 'to', '--overwrite-tags', 'from'])
 
546
        self.assertEquals(out, ('1 tag(s) updated.\n', ''))
 
547
 
 
548
        self.assertEquals(to_tree.branch.tags.lookup_tag('mytag'),
 
549
                          'somerevid')
 
550
        self.assertEquals(to_tree.branch.last_revision(), revid1)
 
551
 
 
552
    def test_pull_tag_overwrite(self):
 
553
        """pulling tags with --overwrite only reports changed tags."""
 
554
        # create a branch, see that --show-base fails
 
555
        from_tree = self.make_branch_and_tree('from')
 
556
        from_tree.branch.tags.set_tag("mytag", "somerevid")
 
557
        to_tree = self.make_branch_and_tree('to')
 
558
        to_tree.branch.tags.set_tag("mytag", "somerevid")
 
559
        out = self.run_bzr(['pull', '--overwrite', '-d', 'to', 'from'])
 
560
        self.assertEqual(out,
 
561
            ('No revisions or tags to pull.\n', ''))
 
562
 
 
563
 
 
564
class TestPullOutput(script.TestCaseWithTransportAndScript):
 
565
 
 
566
    def test_pull_log_format(self):
 
567
        self.run_script("""
 
568
            $ bzr init trunk
 
569
            Created a standalone tree (format: 2a)
 
570
            $ cd trunk
 
571
            $ echo foo > file
 
572
            $ bzr add
 
573
            adding file
 
574
            $ bzr commit -m 'we need some foo'
 
575
            2>Committing to:...trunk/
 
576
            2>added file
 
577
            2>Committed revision 1.
 
578
            $ cd ..
 
579
            $ bzr init feature
 
580
            Created a standalone tree (format: 2a)
 
581
            $ cd feature
 
582
            $ bzr pull -v ../trunk -Olog_format=line
 
583
            Now on revision 1.
 
584
            Added Revisions:
 
585
            1: jrandom@example.com ...we need some foo
 
586
            2>+N  file
 
587
            2>All changes applied successfully.
 
588
            """)