← 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: Aaron Bentley
  • Date: 2012-07-13 19:32:33 UTC
  • mto: This revision was merged to the branch mainline in revision 6540.
  • Revision ID: aaron@aaronbentley.com-20120713193233-l6y0l0twwhd3wmka
Switch to much simpler implementation of restore_uncommitted.

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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
18
"""Black-box tests for bzr pull."""
20
20
import os
21
21
import sys
22
22
 
23
 
from bzrlib.branch import Branch
24
 
from bzrlib.osutils import pathjoin
25
 
from bzrlib.tests.blackbox import ExternalBase
26
 
from bzrlib.uncommit import uncommit
27
 
from bzrlib.workingtree import WorkingTree
28
 
from bzrlib import urlutils
29
 
 
30
 
 
31
 
class TestPull(ExternalBase):
 
23
from bzrlib import (
 
24
    branch,
 
25
    debug,
 
26
    osutils,
 
27
    remote,
 
28
    tests,
 
29
    uncommit,
 
30
    urlutils,
 
31
    workingtree,
 
32
    )
 
33
 
 
34
from bzrlib.directory_service import directories
 
35
from bzrlib.tests import (
 
36
    fixtures,
 
37
    script,
 
38
    )
 
39
 
 
40
 
 
41
class TestPull(tests.TestCaseWithTransport):
32
42
 
33
43
    def example_branch(self, path='.'):
34
44
        tree = self.make_branch_and_tree(path)
35
45
        self.build_tree_contents([
36
 
            (pathjoin(path, 'hello'),   'foo'),
37
 
            (pathjoin(path, 'goodbye'), 'baz')])
 
46
            (osutils.pathjoin(path, 'hello'),   'foo'),
 
47
            (osutils.pathjoin(path, 'goodbye'), 'baz')])
38
48
        tree.add('hello')
39
49
        tree.commit(message='setup')
40
50
        tree.add('goodbye')
44
54
    def test_pull(self):
45
55
        """Pull changes from one branch to another."""
46
56
        a_tree = self.example_branch('a')
47
 
        os.chdir('a')
48
 
        self.run_bzr('pull', retcode=3)
49
 
        self.run_bzr('missing', retcode=3)
50
 
        self.run_bzr('missing .')
51
 
        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')
52
62
        # this will work on windows because we check for the same branch
53
63
        # in pull - if it fails, it is a regression
54
 
        self.run_bzr('pull')
55
 
        self.run_bzr('pull /', retcode=3)
 
64
        self.run_bzr('pull', working_dir='a')
 
65
        self.run_bzr('pull /', retcode=3, working_dir='a')
56
66
        if sys.platform not in ('win32', 'cygwin'):
57
 
            self.run_bzr('pull')
 
67
            self.run_bzr('pull', working_dir='a')
58
68
 
59
 
        os.chdir('..')
60
69
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
61
 
        os.chdir('b')
62
 
        self.run_bzr('pull')
63
 
        os.mkdir('subdir')
 
70
        self.run_bzr('pull', working_dir='b')
 
71
        os.mkdir('b/subdir')
64
72
        b_tree.add('subdir')
65
 
        b_tree.commit(message='blah', allow_pointless=True)
66
 
 
67
 
        os.chdir('..')
68
 
        a = Branch.open('a')
69
 
        b = Branch.open('b')
70
 
        self.assertEqual(a.revision_history(), b.revision_history()[:-1])
71
 
 
72
 
        os.chdir('a')
73
 
        self.run_bzr('pull ../b')
74
 
        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())
75
82
        a_tree.commit(message='blah2', allow_pointless=True)
76
83
        b_tree.commit(message='blah3', allow_pointless=True)
77
84
        # no overwrite
78
 
        os.chdir('../b')
79
 
        self.run_bzr('pull ../a', retcode=3)
80
 
        os.chdir('..')
 
85
        self.run_bzr('pull ../a', retcode=3, working_dir='b')
81
86
        b_tree.bzrdir.sprout('overwriteme')
82
 
        os.chdir('overwriteme')
83
 
        self.run_bzr('pull --overwrite ../a')
84
 
        overwritten = Branch.open('.')
85
 
        self.assertEqual(overwritten.revision_history(),
86
 
                         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())
87
91
        a_tree.merge_from_branch(b_tree.branch)
88
92
        a_tree.commit(message="blah4", allow_pointless=True)
89
 
        os.chdir('../b/subdir')
90
 
        self.run_bzr('pull ../../a')
91
 
        self.assertEqual(a.revision_history()[-1], b.revision_history()[-1])
92
 
        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]
93
97
        sub_tree.commit(message="blah5", allow_pointless=True)
94
98
        sub_tree.commit(message="blah6", allow_pointless=True)
95
 
        os.chdir('..')
96
 
        self.run_bzr('pull ../a')
97
 
        os.chdir('../a')
 
99
        self.run_bzr('pull ../a', working_dir='b')
98
100
        a_tree.commit(message="blah7", allow_pointless=True)
99
101
        a_tree.merge_from_branch(b_tree.branch)
100
102
        a_tree.commit(message="blah8", allow_pointless=True)
101
 
        self.run_bzr('pull ../b')
102
 
        self.run_bzr('pull ../b')
 
103
        self.run_bzr('pull ../b', working_dir='a')
 
104
        self.run_bzr('pull ../b', working_dir='a')
103
105
 
104
106
    def test_pull_dash_d(self):
105
107
        self.example_branch('a')
125
127
 
126
128
        b_tree = a_tree.bzrdir.sprout('b',
127
129
                   revision_id=a_tree.branch.get_rev_id(1)).open_workingtree()
128
 
        os.chdir('b')
129
 
        self.run_bzr('pull -r 2')
130
 
        a = Branch.open('../a')
131
 
        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')
132
133
        self.assertEqual(a.revno(),4)
133
134
        self.assertEqual(b.revno(),2)
134
 
        self.run_bzr('pull -r 3')
 
135
        self.run_bzr('pull -r 3', working_dir='b')
135
136
        self.assertEqual(b.revno(),3)
136
 
        self.run_bzr('pull -r 4')
137
 
        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())
138
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')
139
156
 
140
157
    def test_overwrite_uptodate(self):
141
158
        # Make sure pull --overwrite overwrites
154
171
        self.build_tree_contents([('a/foo', 'a third change')])
155
172
        a_tree.commit(message='a third change')
156
173
 
157
 
        rev_history_a = a_tree.branch.revision_history()
158
 
        self.assertEqual(len(rev_history_a), 3)
 
174
        self.assertEqual(a_tree.branch.last_revision_info()[0], 3)
159
175
 
160
176
        b_tree.merge_from_branch(a_tree.branch)
161
177
        b_tree.commit(message='merge')
162
178
 
163
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
164
 
 
165
 
        os.chdir('b')
166
 
        self.run_bzr('pull --overwrite ../a')
167
 
        rev_history_b = b_tree.branch.revision_history()
168
 
        self.assertEqual(len(rev_history_b), 3)
169
 
 
170
 
        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())
171
185
 
172
186
    def test_overwrite_children(self):
173
187
        # Make sure pull --overwrite sets the revision-history
185
199
        self.build_tree_contents([('a/foo', 'a third change')])
186
200
        a_tree.commit(message='a third change')
187
201
 
188
 
        self.assertEqual(len(a_tree.branch.revision_history()), 3)
 
202
        self.assertEqual(a_tree.branch.last_revision_info()[0], 3)
189
203
 
190
204
        b_tree.merge_from_branch(a_tree.branch)
191
205
        b_tree.commit(message='merge')
192
206
 
193
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
 
207
        self.assertEqual(b_tree.branch.last_revision_info()[0], 2)
194
208
 
195
209
        self.build_tree_contents([('a/foo', 'a fourth change\n')])
196
210
        a_tree.commit(message='a fourth change')
197
211
 
198
 
        rev_history_a = a_tree.branch.revision_history()
199
 
        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)
200
214
 
201
215
        # With convergence, we could just pull over the
202
216
        # new change, but with --overwrite, we want to switch our history
203
 
        os.chdir('b')
204
 
        self.run_bzr('pull --overwrite ../a')
205
 
        rev_history_b = b_tree.branch.revision_history()
206
 
        self.assertEqual(len(rev_history_b), 4)
207
 
 
208
 
        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)
209
221
 
210
222
    def test_pull_remember(self):
211
223
        """Pull changes from one branch to another and test parent location."""
212
 
        transport = self.get_transport()
 
224
        t = self.get_transport()
213
225
        tree_a = self.make_branch_and_tree('branch_a')
214
226
        branch_a = tree_a.branch
215
227
        self.build_tree(['branch_a/a'])
224
236
        tree_a.commit('commit b')
225
237
        # reset parent
226
238
        parent = branch_b.get_parent()
 
239
        branch_b = branch.Branch.open('branch_b')
227
240
        branch_b.set_parent(None)
228
241
        self.assertEqual(None, branch_b.get_parent())
229
242
        # test pull for failure without parent set
230
 
        os.chdir('branch_b')
231
 
        out = self.run_bzr('pull', retcode=3)
 
243
        out = self.run_bzr('pull', retcode=3, working_dir='branch_b')
232
244
        self.assertEqual(out,
233
245
                ('','bzr: ERROR: No pull location known or specified.\n'))
234
246
        # test implicit --remember when no parent set, this pull conflicts
235
 
        self.build_tree(['d'])
 
247
        self.build_tree(['branch_b/d'])
236
248
        tree_b.add('d')
237
249
        tree_b.commit('commit d')
238
 
        out = self.run_bzr('pull ../branch_a', retcode=3)
 
250
        out = self.run_bzr('pull ../branch_a', retcode=3,
 
251
                           working_dir='branch_b')
239
252
        self.assertEqual(out,
240
253
                ('','bzr: ERROR: These branches have diverged.'
241
 
                    ' Use the merge command to reconcile them.\n'))
242
 
        self.assertEqual(branch_b.get_parent(), parent)
 
254
                    ' Use the missing command to see how.\n'
 
255
                    'Use the merge command to reconcile them.\n'))
 
256
        tree_b = tree_b.bzrdir.open_workingtree()
 
257
        branch_b = tree_b.branch
 
258
        self.assertEqual(parent, branch_b.get_parent())
243
259
        # test implicit --remember after resolving previous failure
244
 
        uncommit(branch=branch_b, tree=tree_b)
245
 
        transport.delete('branch_b/d')
246
 
        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()
247
265
        self.assertEqual(branch_b.get_parent(), parent)
248
266
        # test explicit --remember
249
 
        self.run_bzr('pull ../branch_c --remember')
250
 
        self.assertEqual(branch_b.get_parent(),
251
 
                          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())
252
272
 
253
273
    def test_pull_bundle(self):
254
274
        from bzrlib.testament import Testament
255
275
        # Build up 2 trees and prepare for a pull
256
276
        tree_a = self.make_branch_and_tree('branch_a')
257
 
        f = open('branch_a/a', 'wb')
258
 
        f.write('hello')
259
 
        f.close()
 
277
        with open('branch_a/a', 'wb') as f:
 
278
            f.write('hello')
260
279
        tree_a.add('a')
261
280
        tree_a.commit('message')
262
281
 
263
282
        tree_b = tree_a.bzrdir.sprout('branch_b').open_workingtree()
264
283
 
265
284
        # Make a change to 'a' that 'b' can pull
266
 
        f = open('branch_a/a', 'wb')
267
 
        f.write('hey there')
268
 
        f.close()
 
285
        with open('branch_a/a', 'wb') as f:
 
286
            f.write('hey there')
269
287
        tree_a.commit('message')
270
288
 
271
289
        # Create the bundle for 'b' to pull
272
 
        os.chdir('branch_a')
273
 
        self.run_bzr('bundle ../branch_b -o ../bundle')
 
290
        self.run_bzr('bundle ../branch_b -o ../bundle', working_dir='branch_a')
274
291
 
275
 
        os.chdir('../branch_b')
276
 
        out, err = self.run_bzr('pull ../bundle')
 
292
        out, err = self.run_bzr('pull ../bundle', working_dir='branch_b')
277
293
        self.assertEqual(out,
278
294
                         'Now on revision 2.\n')
279
295
        self.assertEqual(err,
280
296
                ' M  a\nAll changes applied successfully.\n')
281
297
 
282
 
        self.assertEqualDiff(tree_a.branch.revision_history(),
283
 
                             tree_b.branch.revision_history())
 
298
        self.assertEqualDiff(tree_a.branch.last_revision(),
 
299
                             tree_b.branch.last_revision())
284
300
 
285
301
        testament_a = Testament.from_revision(tree_a.branch.repository,
286
302
                                              tree_a.get_parent_ids()[0])
290
306
                             testament_b.as_text())
291
307
 
292
308
        # it is legal to attempt to pull an already-merged bundle
293
 
        out, err = self.run_bzr('pull ../bundle')
 
309
        out, err = self.run_bzr('pull ../bundle', working_dir='branch_b')
294
310
        self.assertEqual(err, '')
295
 
        self.assertEqual(out, 'No revisions to pull.\n')
 
311
        self.assertEqual(out, 'No revisions or tags to pull.\n')
296
312
 
297
313
    def test_pull_verbose_no_files(self):
298
314
        """Pull --verbose should not list modified files"""
305
321
        self.assertContainsRe(out, 'bar')
306
322
        self.assertNotContainsRe(out, 'added:')
307
323
        self.assertNotContainsRe(out, 'foo')
 
324
 
 
325
    def test_pull_quiet(self):
 
326
        """Check that bzr pull --quiet does not print anything"""
 
327
        tree_a = self.make_branch_and_tree('tree_a')
 
328
        self.build_tree(['tree_a/foo'])
 
329
        tree_a.add('foo')
 
330
        revision_id = tree_a.commit('bar')
 
331
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
 
332
        out, err = self.run_bzr('pull --quiet -d tree_b')
 
333
        self.assertEqual(out, '')
 
334
        self.assertEqual(err, '')
 
335
        self.assertEqual(tree_b.last_revision(), revision_id)
 
336
        self.build_tree(['tree_a/moo'])
 
337
        tree_a.add('moo')
 
338
        revision_id = tree_a.commit('quack')
 
339
        out, err = self.run_bzr('pull --quiet -d tree_b')
 
340
        self.assertEqual(out, '')
 
341
        self.assertEqual(err, '')
 
342
        self.assertEqual(tree_b.last_revision(), revision_id)
 
343
 
 
344
    def test_pull_from_directory_service(self):
 
345
        source = self.make_branch_and_tree('source')
 
346
        source.commit('commit 1')
 
347
        target = source.bzrdir.sprout('target').open_workingtree()
 
348
        source_last = source.commit('commit 2')
 
349
        class FooService(object):
 
350
            """A directory service that always returns source"""
 
351
 
 
352
            def look_up(self, name, url):
 
353
                return 'source'
 
354
        directories.register('foo:', FooService, 'Testing directory service')
 
355
        self.addCleanup(directories.remove, 'foo:')
 
356
        self.run_bzr('pull foo:bar -d target')
 
357
        self.assertEqual(source_last, target.last_revision())
 
358
 
 
359
    def test_pull_verbose_defaults_to_long(self):
 
360
        tree = self.example_branch('source')
 
361
        target = self.make_branch_and_tree('target')
 
362
        out = self.run_bzr('pull -v source -d target')[0]
 
363
        self.assertContainsRe(out,
 
364
                              r'revno: 1\ncommitter: .*\nbranch nick: source')
 
365
        self.assertNotContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
 
366
 
 
367
    def test_pull_verbose_uses_default_log(self):
 
368
        tree = self.example_branch('source')
 
369
        target = self.make_branch_and_tree('target')
 
370
        target.branch.get_config_stack().set('log_format', 'short')
 
371
        out = self.run_bzr('pull -v source -d target')[0]
 
372
        self.assertContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
 
373
        self.assertNotContainsRe(
 
374
            out, r'revno: 1\ncommitter: .*\nbranch nick: source')
 
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
 
 
385
    def test_pull_smart_stacked_streaming_acceptance(self):
 
386
        """'bzr pull -r 123' works on stacked, smart branches, even when the
 
387
        revision specified by the revno is only present in the fallback
 
388
        repository.
 
389
 
 
390
        See <https://launchpad.net/bugs/380314>
 
391
        """
 
392
        self.setup_smart_server_with_call_log()
 
393
        # Make a stacked-on branch with two commits so that the
 
394
        # revision-history can't be determined just by looking at the parent
 
395
        # field in the revision in the stacked repo.
 
396
        parent = self.make_branch_and_tree('parent', format='1.9')
 
397
        parent.commit(message='first commit')
 
398
        parent.commit(message='second commit')
 
399
        local = parent.bzrdir.sprout('local').open_workingtree()
 
400
        local.commit(message='local commit')
 
401
        local.branch.create_clone_on_transport(
 
402
            self.get_transport('stacked'), stacked_on=self.get_url('parent'))
 
403
        empty = self.make_branch_and_tree('empty', format='1.9')
 
404
        self.reset_smart_call_log()
 
405
        self.run_bzr(['pull', '-r', '1', self.get_url('stacked')],
 
406
            working_dir='empty')
 
407
        # This figure represent the amount of work to perform this use case. It
 
408
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
409
        # being too low. If rpc_count increases, more network roundtrips have
 
410
        # become necessary for this use case. Please do not adjust this number
 
411
        # upwards without agreement from bzr's network support maintainers.
 
412
        self.assertLength(19, self.hpss_calls)
 
413
        self.assertLength(1, self.hpss_connections)
 
414
        remote = branch.Branch.open('stacked')
 
415
        self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
 
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_show_base_working_tree_only(self):
 
505
        """--show-base only allowed if there's a working tree
 
506
 
 
507
        see https://bugs.launchpad.net/bzr/+bug/202374"""
 
508
        # create a branch, see that --show-base fails
 
509
        self.make_branch('from')
 
510
        self.make_branch('to')
 
511
        out=self.run_bzr(['pull','-d','to','from','--show-base'],retcode=3)
 
512
        self.assertEqual(
 
513
            out, ('','bzr: ERROR: Need working tree for --show-base.\n'))
 
514
 
 
515
    def test_pull_tag_conflicts(self):
 
516
        """pulling tags with conflicts will change the exit code"""
 
517
        # create a branch, see that --show-base fails
 
518
        from_tree = self.make_branch_and_tree('from')
 
519
        from_tree.branch.tags.set_tag("mytag", "somerevid")
 
520
        to_tree = self.make_branch_and_tree('to')
 
521
        to_tree.branch.tags.set_tag("mytag", "anotherrevid")
 
522
        out = self.run_bzr(['pull','-d','to','from'],retcode=1)
 
523
        self.assertEqual(out,
 
524
            ('No revisions to pull.\nConflicting tags:\n    mytag\n', ''))
 
525
 
 
526
    def test_pull_tag_notification(self):
 
527
        """pulling tags with conflicts will change the exit code"""
 
528
        # create a branch, see that --show-base fails
 
529
        from_tree = self.make_branch_and_tree('from')
 
530
        from_tree.branch.tags.set_tag("mytag", "somerevid")
 
531
        to_tree = self.make_branch_and_tree('to')
 
532
        out = self.run_bzr(['pull', '-d', 'to', 'from'])
 
533
        self.assertEqual(out,
 
534
            ('1 tag(s) updated.\n', ''))
 
535
 
 
536
    def test_overwrite_tags(self):
 
537
        """--overwrite-tags only overwrites tags, not revisions."""
 
538
        from_tree = self.make_branch_and_tree('from')
 
539
        from_tree.branch.tags.set_tag("mytag", "somerevid")
 
540
        to_tree = self.make_branch_and_tree('to')
 
541
        to_tree.branch.tags.set_tag("mytag", "anotherrevid")
 
542
        revid1 = to_tree.commit('my commit')
 
543
        out = self.run_bzr(['pull', '-d', 'to', 'from'], retcode=1)
 
544
        self.assertEquals(out,
 
545
            ('No revisions to pull.\nConflicting tags:\n    mytag\n', ''))
 
546
        out = self.run_bzr(['pull', '-d', 'to', '--overwrite-tags', 'from'])
 
547
        self.assertEquals(out, ('1 tag(s) updated.\n', ''))
 
548
 
 
549
        self.assertEquals(to_tree.branch.tags.lookup_tag('mytag'),
 
550
                          'somerevid')
 
551
        self.assertEquals(to_tree.branch.last_revision(), revid1)
 
552
 
 
553
    def test_pull_tag_overwrite(self):
 
554
        """pulling tags with --overwrite only reports changed tags."""
 
555
        # create a branch, see that --show-base fails
 
556
        from_tree = self.make_branch_and_tree('from')
 
557
        from_tree.branch.tags.set_tag("mytag", "somerevid")
 
558
        to_tree = self.make_branch_and_tree('to')
 
559
        to_tree.branch.tags.set_tag("mytag", "somerevid")
 
560
        out = self.run_bzr(['pull', '--overwrite', '-d', 'to', 'from'])
 
561
        self.assertEqual(out,
 
562
            ('No revisions or tags to pull.\n', ''))
 
563
 
 
564
 
 
565
class TestPullOutput(script.TestCaseWithTransportAndScript):
 
566
 
 
567
    def test_pull_log_format(self):
 
568
        self.run_script("""
 
569
            $ bzr init trunk
 
570
            Created a standalone tree (format: 2a)
 
571
            $ cd trunk
 
572
            $ echo foo > file
 
573
            $ bzr add
 
574
            adding file
 
575
            $ bzr commit -m 'we need some foo'
 
576
            2>Committing to:...trunk/
 
577
            2>added file
 
578
            2>Committed revision 1.
 
579
            $ cd ..
 
580
            $ bzr init feature
 
581
            Created a standalone tree (format: 2a)
 
582
            $ cd feature
 
583
            $ bzr pull -v ../trunk -Olog_format=line
 
584
            Now on revision 1.
 
585
            Added Revisions:
 
586
            1: jrandom@example.com ...we need some foo
 
587
            2>+N  file
 
588
            2>All changes applied successfully.
 
589
            """)