← 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: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/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
21
21
import sys
22
22
 
23
23
from bzrlib import (
 
24
    branch,
24
25
    debug,
 
26
    osutils,
25
27
    remote,
 
28
    tests,
 
29
    uncommit,
26
30
    urlutils,
 
31
    workingtree,
27
32
    )
28
33
 
29
 
from bzrlib.branch import Branch
30
34
from bzrlib.directory_service import directories
31
 
from bzrlib.osutils import pathjoin
32
35
from bzrlib.tests import (
33
36
    fixtures,
34
 
    TestCaseWithTransport,
 
37
    script,
35
38
    )
36
 
from bzrlib.uncommit import uncommit
37
 
from bzrlib.workingtree import WorkingTree
38
 
 
39
 
 
40
 
class TestPull(TestCaseWithTransport):
 
39
 
 
40
 
 
41
class TestPull(tests.TestCaseWithTransport):
41
42
 
42
43
    def example_branch(self, path='.'):
43
44
        tree = self.make_branch_and_tree(path)
44
45
        self.build_tree_contents([
45
 
            (pathjoin(path, 'hello'),   'foo'),
46
 
            (pathjoin(path, 'goodbye'), 'baz')])
 
46
            (osutils.pathjoin(path, 'hello'),   'foo'),
 
47
            (osutils.pathjoin(path, 'goodbye'), 'baz')])
47
48
        tree.add('hello')
48
49
        tree.commit(message='setup')
49
50
        tree.add('goodbye')
53
54
    def test_pull(self):
54
55
        """Pull changes from one branch to another."""
55
56
        a_tree = self.example_branch('a')
56
 
        os.chdir('a')
57
 
        self.run_bzr('pull', retcode=3)
58
 
        self.run_bzr('missing', retcode=3)
59
 
        self.run_bzr('missing .')
60
 
        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')
61
62
        # this will work on windows because we check for the same branch
62
63
        # in pull - if it fails, it is a regression
63
 
        self.run_bzr('pull')
64
 
        self.run_bzr('pull /', retcode=3)
 
64
        self.run_bzr('pull', working_dir='a')
 
65
        self.run_bzr('pull /', retcode=3, working_dir='a')
65
66
        if sys.platform not in ('win32', 'cygwin'):
66
 
            self.run_bzr('pull')
 
67
            self.run_bzr('pull', working_dir='a')
67
68
 
68
 
        os.chdir('..')
69
69
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
70
 
        os.chdir('b')
71
 
        self.run_bzr('pull')
72
 
        os.mkdir('subdir')
 
70
        self.run_bzr('pull', working_dir='b')
 
71
        os.mkdir('b/subdir')
73
72
        b_tree.add('subdir')
74
 
        b_tree.commit(message='blah', allow_pointless=True)
75
 
 
76
 
        os.chdir('..')
77
 
        a = Branch.open('a')
78
 
        b = Branch.open('b')
79
 
        self.assertEqual(a.revision_history(), b.revision_history()[:-1])
80
 
 
81
 
        os.chdir('a')
82
 
        self.run_bzr('pull ../b')
83
 
        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())
84
82
        a_tree.commit(message='blah2', allow_pointless=True)
85
83
        b_tree.commit(message='blah3', allow_pointless=True)
86
84
        # no overwrite
87
 
        os.chdir('../b')
88
 
        self.run_bzr('pull ../a', retcode=3)
89
 
        os.chdir('..')
 
85
        self.run_bzr('pull ../a', retcode=3, working_dir='b')
90
86
        b_tree.bzrdir.sprout('overwriteme')
91
 
        os.chdir('overwriteme')
92
 
        self.run_bzr('pull --overwrite ../a')
93
 
        overwritten = Branch.open('.')
94
 
        self.assertEqual(overwritten.revision_history(),
95
 
                         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())
96
91
        a_tree.merge_from_branch(b_tree.branch)
97
92
        a_tree.commit(message="blah4", allow_pointless=True)
98
 
        os.chdir('../b/subdir')
99
 
        self.run_bzr('pull ../../a')
100
 
        self.assertEqual(a.revision_history()[-1], b.revision_history()[-1])
101
 
        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]
102
97
        sub_tree.commit(message="blah5", allow_pointless=True)
103
98
        sub_tree.commit(message="blah6", allow_pointless=True)
104
 
        os.chdir('..')
105
 
        self.run_bzr('pull ../a')
106
 
        os.chdir('../a')
 
99
        self.run_bzr('pull ../a', working_dir='b')
107
100
        a_tree.commit(message="blah7", allow_pointless=True)
108
101
        a_tree.merge_from_branch(b_tree.branch)
109
102
        a_tree.commit(message="blah8", allow_pointless=True)
110
 
        self.run_bzr('pull ../b')
111
 
        self.run_bzr('pull ../b')
 
103
        self.run_bzr('pull ../b', working_dir='a')
 
104
        self.run_bzr('pull ../b', working_dir='a')
112
105
 
113
106
    def test_pull_dash_d(self):
114
107
        self.example_branch('a')
134
127
 
135
128
        b_tree = a_tree.bzrdir.sprout('b',
136
129
                   revision_id=a_tree.branch.get_rev_id(1)).open_workingtree()
137
 
        os.chdir('b')
138
 
        self.run_bzr('pull -r 2')
139
 
        a = Branch.open('../a')
140
 
        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')
141
133
        self.assertEqual(a.revno(),4)
142
134
        self.assertEqual(b.revno(),2)
143
 
        self.run_bzr('pull -r 3')
 
135
        self.run_bzr('pull -r 3', working_dir='b')
144
136
        self.assertEqual(b.revno(),3)
145
 
        self.run_bzr('pull -r 4')
146
 
        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())
147
139
 
148
140
    def test_pull_tags(self):
149
141
        """Tags are updated by pull, and revisions named in those tags are
152
144
        # Make a source, sprout a target off it
153
145
        builder = self.make_branch_builder('source')
154
146
        source = fixtures.build_branch_with_non_ancestral_rev(builder)
155
 
        source.get_config().set_user_option('branch.fetch_tags', 'True')
 
147
        source.get_config_stack().set('branch.fetch_tags', True)
156
148
        target_bzrdir = source.bzrdir.sprout('target')
157
149
        source.tags.set_tag('tag-a', 'rev-2')
158
150
        # Pull from source
179
171
        self.build_tree_contents([('a/foo', 'a third change')])
180
172
        a_tree.commit(message='a third change')
181
173
 
182
 
        rev_history_a = a_tree.branch.revision_history()
183
 
        self.assertEqual(len(rev_history_a), 3)
 
174
        self.assertEqual(a_tree.branch.last_revision_info()[0], 3)
184
175
 
185
176
        b_tree.merge_from_branch(a_tree.branch)
186
177
        b_tree.commit(message='merge')
187
178
 
188
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
189
 
 
190
 
        os.chdir('b')
191
 
        self.run_bzr('pull --overwrite ../a')
192
 
        rev_history_b = b_tree.branch.revision_history()
193
 
        self.assertEqual(len(rev_history_b), 3)
194
 
 
195
 
        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())
196
185
 
197
186
    def test_overwrite_children(self):
198
187
        # Make sure pull --overwrite sets the revision-history
210
199
        self.build_tree_contents([('a/foo', 'a third change')])
211
200
        a_tree.commit(message='a third change')
212
201
 
213
 
        self.assertEqual(len(a_tree.branch.revision_history()), 3)
 
202
        self.assertEqual(a_tree.branch.last_revision_info()[0], 3)
214
203
 
215
204
        b_tree.merge_from_branch(a_tree.branch)
216
205
        b_tree.commit(message='merge')
217
206
 
218
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
 
207
        self.assertEqual(b_tree.branch.last_revision_info()[0], 2)
219
208
 
220
209
        self.build_tree_contents([('a/foo', 'a fourth change\n')])
221
210
        a_tree.commit(message='a fourth change')
222
211
 
223
 
        rev_history_a = a_tree.branch.revision_history()
224
 
        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)
225
214
 
226
215
        # With convergence, we could just pull over the
227
216
        # new change, but with --overwrite, we want to switch our history
228
 
        os.chdir('b')
229
 
        self.run_bzr('pull --overwrite ../a')
230
 
        rev_history_b = b_tree.branch.revision_history()
231
 
        self.assertEqual(len(rev_history_b), 4)
232
 
 
233
 
        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)
234
221
 
235
222
    def test_pull_remember(self):
236
223
        """Pull changes from one branch to another and test parent location."""
237
 
        transport = self.get_transport()
 
224
        t = self.get_transport()
238
225
        tree_a = self.make_branch_and_tree('branch_a')
239
226
        branch_a = tree_a.branch
240
227
        self.build_tree(['branch_a/a'])
249
236
        tree_a.commit('commit b')
250
237
        # reset parent
251
238
        parent = branch_b.get_parent()
 
239
        branch_b = branch.Branch.open('branch_b')
252
240
        branch_b.set_parent(None)
253
241
        self.assertEqual(None, branch_b.get_parent())
254
242
        # test pull for failure without parent set
255
 
        os.chdir('branch_b')
256
 
        out = self.run_bzr('pull', retcode=3)
 
243
        out = self.run_bzr('pull', retcode=3, working_dir='branch_b')
257
244
        self.assertEqual(out,
258
245
                ('','bzr: ERROR: No pull location known or specified.\n'))
259
246
        # test implicit --remember when no parent set, this pull conflicts
260
 
        self.build_tree(['d'])
 
247
        self.build_tree(['branch_b/d'])
261
248
        tree_b.add('d')
262
249
        tree_b.commit('commit d')
263
 
        out = self.run_bzr('pull ../branch_a', retcode=3)
 
250
        out = self.run_bzr('pull ../branch_a', retcode=3,
 
251
                           working_dir='branch_b')
264
252
        self.assertEqual(out,
265
253
                ('','bzr: ERROR: These branches have diverged.'
266
254
                    ' Use the missing command to see how.\n'
267
255
                    'Use the merge command to reconcile them.\n'))
268
 
        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())
269
259
        # test implicit --remember after resolving previous failure
270
 
        uncommit(branch=branch_b, tree=tree_b)
271
 
        transport.delete('branch_b/d')
272
 
        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()
273
265
        self.assertEqual(branch_b.get_parent(), parent)
274
266
        # test explicit --remember
275
 
        self.run_bzr('pull ../branch_c --remember')
276
 
        self.assertEqual(branch_b.get_parent(),
277
 
                          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())
278
272
 
279
273
    def test_pull_bundle(self):
280
274
        from bzrlib.testament import Testament
281
275
        # Build up 2 trees and prepare for a pull
282
276
        tree_a = self.make_branch_and_tree('branch_a')
283
 
        f = open('branch_a/a', 'wb')
284
 
        f.write('hello')
285
 
        f.close()
 
277
        with open('branch_a/a', 'wb') as f:
 
278
            f.write('hello')
286
279
        tree_a.add('a')
287
280
        tree_a.commit('message')
288
281
 
289
282
        tree_b = tree_a.bzrdir.sprout('branch_b').open_workingtree()
290
283
 
291
284
        # Make a change to 'a' that 'b' can pull
292
 
        f = open('branch_a/a', 'wb')
293
 
        f.write('hey there')
294
 
        f.close()
 
285
        with open('branch_a/a', 'wb') as f:
 
286
            f.write('hey there')
295
287
        tree_a.commit('message')
296
288
 
297
289
        # Create the bundle for 'b' to pull
298
 
        os.chdir('branch_a')
299
 
        self.run_bzr('bundle ../branch_b -o ../bundle')
 
290
        self.run_bzr('bundle ../branch_b -o ../bundle', working_dir='branch_a')
300
291
 
301
 
        os.chdir('../branch_b')
302
 
        out, err = self.run_bzr('pull ../bundle')
 
292
        out, err = self.run_bzr('pull ../bundle', working_dir='branch_b')
303
293
        self.assertEqual(out,
304
294
                         'Now on revision 2.\n')
305
295
        self.assertEqual(err,
306
296
                ' M  a\nAll changes applied successfully.\n')
307
297
 
308
 
        self.assertEqualDiff(tree_a.branch.revision_history(),
309
 
                             tree_b.branch.revision_history())
 
298
        self.assertEqualDiff(tree_a.branch.last_revision(),
 
299
                             tree_b.branch.last_revision())
310
300
 
311
301
        testament_a = Testament.from_revision(tree_a.branch.repository,
312
302
                                              tree_a.get_parent_ids()[0])
316
306
                             testament_b.as_text())
317
307
 
318
308
        # it is legal to attempt to pull an already-merged bundle
319
 
        out, err = self.run_bzr('pull ../bundle')
 
309
        out, err = self.run_bzr('pull ../bundle', working_dir='branch_b')
320
310
        self.assertEqual(err, '')
321
311
        self.assertEqual(out, 'No revisions or tags to pull.\n')
322
312
 
377
367
    def test_pull_verbose_uses_default_log(self):
378
368
        tree = self.example_branch('source')
379
369
        target = self.make_branch_and_tree('target')
380
 
        target_config = target.branch.get_config()
381
 
        target_config.set_user_option('log_format', 'short')
 
370
        target.branch.get_config_stack().set('log_format', 'short')
382
371
        out = self.run_bzr('pull -v source -d target')[0]
383
372
        self.assertContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
384
373
        self.assertNotContainsRe(
421
410
        # become necessary for this use case. Please do not adjust this number
422
411
        # upwards without agreement from bzr's network support maintainers.
423
412
        self.assertLength(19, self.hpss_calls)
424
 
        remote = Branch.open('stacked')
 
413
        self.assertLength(1, self.hpss_connections)
 
414
        remote = branch.Branch.open('stacked')
425
415
        self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
426
 
    
 
416
 
427
417
    def test_pull_cross_format_warning(self):
428
418
        """You get a warning for probably slow cross-format pulls.
429
419
        """
491
481
        a_tree = self.example_branch('a')
492
482
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
493
483
 
494
 
        f = open(pathjoin('a', 'hello'),'wt')
495
 
        f.write('fee')
496
 
        f.close()
 
484
        with open(osutils.pathjoin('a', 'hello'),'wt') as f:
 
485
            f.write('fee')
497
486
        a_tree.commit('fee')
498
487
 
499
 
        f = open(pathjoin('b', 'hello'),'wt')
500
 
        f.write('fie')
501
 
        f.close()
 
488
        with open(osutils.pathjoin('b', 'hello'),'wt') as f:
 
489
            f.write('fie')
502
490
 
503
491
        out,err=self.run_bzr(['pull','-d','b','a','--show-base'])
504
492
 
505
493
        # check for message here
506
 
        self.assertEqual(err,
507
 
                         ' M  hello\nText conflict in hello\n1 conflicts encountered.\n')
 
494
        self.assertEqual(
 
495
            err,
 
496
            ' M  hello\nText conflict in hello\n1 conflicts encountered.\n')
508
497
 
509
498
        self.assertEqualDiff('<<<<<<< TREE\n'
510
499
                             'fie||||||| BASE-REVISION\n'
511
500
                             'foo=======\n'
512
501
                             'fee>>>>>>> MERGE-SOURCE\n',
513
 
                             open(pathjoin('b', 'hello')).read())
514
 
 
515
 
    def test_pull_show_base_working_tree_only(self):
516
 
        """--show-base only allowed if there's a working tree
517
 
 
518
 
        see https://bugs.launchpad.net/bzr/+bug/202374"""
519
 
        # create a branch, see that --show-base fails
 
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"""
520
508
        self.make_branch('from')
521
509
        self.make_branch('to')
522
 
        out=self.run_bzr(['pull','-d','to','from','--show-base'],retcode=3)
523
 
        self.assertEqual(out,
524
 
                         ('','bzr: ERROR: Need working tree for --show-base.\n'))
 
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'))
525
513
 
526
514
    def test_pull_tag_conflicts(self):
527
515
        """pulling tags with conflicts will change the exit code"""
544
532
        self.assertEqual(out,
545
533
            ('1 tag(s) updated.\n', ''))
546
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.assertEqual(out,
 
544
            ('No revisions to pull.\nConflicting tags:\n    mytag\n', ''))
 
545
        out = self.run_bzr(['pull', '-d', 'to', '--overwrite-tags', 'from'])
 
546
        self.assertEqual(out, ('1 tag(s) updated.\n', ''))
 
547
 
 
548
        self.assertEqual(to_tree.branch.tags.lookup_tag('mytag'),
 
549
                          'somerevid')
 
550
        self.assertEqual(to_tree.branch.last_revision(), revid1)
 
551
 
547
552
    def test_pull_tag_overwrite(self):
548
553
        """pulling tags with --overwrite only reports changed tags."""
549
554
        # create a branch, see that --show-base fails
554
559
        out = self.run_bzr(['pull', '--overwrite', '-d', 'to', 'from'])
555
560
        self.assertEqual(out,
556
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
            """)