/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

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