← 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: Daniel Watkins
  • Date: 2009-02-10 00:43:48 UTC
  • mto: (4010.1.1 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 4015.
  • Revision ID: daniel@daniel-watkins.co.uk-20090210004348-l5pkl1g9rj9wddpy
Added help option to shelve prompt.

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, 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 import (
24
 
    debug,
25
 
    remote,
26
 
    tests,
27
 
    urlutils,
28
 
    )
29
 
 
30
23
from bzrlib.branch import Branch
31
24
from bzrlib.directory_service import directories
32
25
from bzrlib.osutils import pathjoin
33
 
from bzrlib.tests import (
34
 
    fixtures,
35
 
    script,
36
 
    )
 
26
from bzrlib.tests.blackbox import ExternalBase
37
27
from bzrlib.uncommit import uncommit
38
28
from bzrlib.workingtree import WorkingTree
39
 
 
40
 
 
41
 
class TestPull(tests.TestCaseWithTransport):
 
29
from bzrlib import urlutils
 
30
 
 
31
 
 
32
class TestPull(ExternalBase):
42
33
 
43
34
    def example_branch(self, path='.'):
44
35
        tree = self.make_branch_and_tree(path)
54
45
    def test_pull(self):
55
46
        """Pull changes from one branch to another."""
56
47
        a_tree = self.example_branch('a')
57
 
        base_rev = a_tree.branch.last_revision()
58
48
        os.chdir('a')
59
49
        self.run_bzr('pull', retcode=3)
60
50
        self.run_bzr('missing', retcode=3)
73
63
        self.run_bzr('pull')
74
64
        os.mkdir('subdir')
75
65
        b_tree.add('subdir')
76
 
        new_rev = b_tree.commit(message='blah', allow_pointless=True)
 
66
        b_tree.commit(message='blah', allow_pointless=True)
77
67
 
78
68
        os.chdir('..')
79
69
        a = Branch.open('a')
80
70
        b = Branch.open('b')
81
 
        self.assertEqual(a.last_revision(), base_rev)
82
 
        self.assertEqual(b.last_revision(), new_rev)
 
71
        self.assertEqual(a.revision_history(), b.revision_history()[:-1])
83
72
 
84
73
        os.chdir('a')
85
74
        self.run_bzr('pull ../b')
86
 
        self.assertEqual(a.last_revision(), b.last_revision())
 
75
        self.assertEqual(a.revision_history(), b.revision_history())
87
76
        a_tree.commit(message='blah2', allow_pointless=True)
88
77
        b_tree.commit(message='blah3', allow_pointless=True)
89
78
        # no overwrite
94
83
        os.chdir('overwriteme')
95
84
        self.run_bzr('pull --overwrite ../a')
96
85
        overwritten = Branch.open('.')
97
 
        self.assertEqual(overwritten.last_revision(),
98
 
                         a.last_revision())
 
86
        self.assertEqual(overwritten.revision_history(),
 
87
                         a.revision_history())
99
88
        a_tree.merge_from_branch(b_tree.branch)
100
89
        a_tree.commit(message="blah4", allow_pointless=True)
101
90
        os.chdir('../b/subdir')
102
91
        self.run_bzr('pull ../../a')
103
 
        self.assertEqual(a.last_revision(), b.last_revision())
 
92
        self.assertEqual(a.revision_history()[-1], b.revision_history()[-1])
104
93
        sub_tree = WorkingTree.open_containing('.')[0]
105
94
        sub_tree.commit(message="blah5", allow_pointless=True)
106
95
        sub_tree.commit(message="blah6", allow_pointless=True)
146
135
        self.run_bzr('pull -r 3')
147
136
        self.assertEqual(b.revno(),3)
148
137
        self.run_bzr('pull -r 4')
149
 
        self.assertEqual(a.last_revision(), b.last_revision())
 
138
        self.assertEqual(a.revision_history(), b.revision_history())
150
139
 
151
 
    def test_pull_tags(self):
152
 
        """Tags are updated by pull, and revisions named in those tags are
153
 
        fetched.
154
 
        """
155
 
        # Make a source, sprout a target off it
156
 
        builder = self.make_branch_builder('source')
157
 
        source = fixtures.build_branch_with_non_ancestral_rev(builder)
158
 
        source.get_config().set_user_option('branch.fetch_tags', 'True')
159
 
        target_bzrdir = source.bzrdir.sprout('target')
160
 
        source.tags.set_tag('tag-a', 'rev-2')
161
 
        # Pull from source
162
 
        self.run_bzr('pull -d target source')
163
 
        target = target_bzrdir.open_branch()
164
 
        # The tag is present, and so is its revision.
165
 
        self.assertEqual('rev-2', target.tags.lookup_tag('tag-a'))
166
 
        target.repository.get_revision('rev-2')
167
140
 
168
141
    def test_overwrite_uptodate(self):
169
142
        # Make sure pull --overwrite overwrites
182
155
        self.build_tree_contents([('a/foo', 'a third change')])
183
156
        a_tree.commit(message='a third change')
184
157
 
185
 
        self.assertEqual(a_tree.branch.last_revision_info()[0], 3)
 
158
        rev_history_a = a_tree.branch.revision_history()
 
159
        self.assertEqual(len(rev_history_a), 3)
186
160
 
187
161
        b_tree.merge_from_branch(a_tree.branch)
188
162
        b_tree.commit(message='merge')
189
163
 
190
 
        self.assertEqual(b_tree.branch.last_revision_info()[0], 2)
 
164
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
191
165
 
192
166
        os.chdir('b')
193
167
        self.run_bzr('pull --overwrite ../a')
194
 
        (last_revinfo_b) = b_tree.branch.last_revision_info()
195
 
        self.assertEqual(last_revinfo_b[0], 3)
196
 
        self.assertEqual(last_revinfo_b[1], a_tree.branch.last_revision())
 
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)
197
172
 
198
173
    def test_overwrite_children(self):
199
174
        # Make sure pull --overwrite sets the revision-history
211
186
        self.build_tree_contents([('a/foo', 'a third change')])
212
187
        a_tree.commit(message='a third change')
213
188
 
214
 
        self.assertEqual(a_tree.branch.last_revision_info()[0], 3)
 
189
        self.assertEqual(len(a_tree.branch.revision_history()), 3)
215
190
 
216
191
        b_tree.merge_from_branch(a_tree.branch)
217
192
        b_tree.commit(message='merge')
218
193
 
219
 
        self.assertEqual(b_tree.branch.last_revision_info()[0], 2)
 
194
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
220
195
 
221
196
        self.build_tree_contents([('a/foo', 'a fourth change\n')])
222
197
        a_tree.commit(message='a fourth change')
223
198
 
224
 
        rev_info_a = a_tree.branch.last_revision_info()
225
 
        self.assertEqual(rev_info_a[0], 4)
 
199
        rev_history_a = a_tree.branch.revision_history()
 
200
        self.assertEqual(len(rev_history_a), 4)
226
201
 
227
202
        # With convergence, we could just pull over the
228
203
        # new change, but with --overwrite, we want to switch our history
229
204
        os.chdir('b')
230
205
        self.run_bzr('pull --overwrite ../a')
231
 
        rev_info_b = b_tree.branch.last_revision_info()
232
 
        self.assertEqual(rev_info_b[0], 4)
233
 
        self.assertEqual(rev_info_b, rev_info_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)
234
210
 
235
211
    def test_pull_remember(self):
236
212
        """Pull changes from one branch to another and test parent location."""
263
239
        out = self.run_bzr('pull ../branch_a', retcode=3)
264
240
        self.assertEqual(out,
265
241
                ('','bzr: ERROR: These branches have diverged.'
266
 
                    ' Use the missing command to see how.\n'
267
 
                    'Use the merge command to reconcile them.\n'))
 
242
                    ' Use the merge command to reconcile them.\n'))
268
243
        self.assertEqual(branch_b.get_parent(), parent)
269
244
        # test implicit --remember after resolving previous failure
270
245
        uncommit(branch=branch_b, tree=tree_b)
305
280
        self.assertEqual(err,
306
281
                ' M  a\nAll changes applied successfully.\n')
307
282
 
308
 
        self.assertEqualDiff(tree_a.branch.last_revision(),
309
 
                             tree_b.branch.last_revision())
 
283
        self.assertEqualDiff(tree_a.branch.revision_history(),
 
284
                             tree_b.branch.revision_history())
310
285
 
311
286
        testament_a = Testament.from_revision(tree_a.branch.repository,
312
287
                                              tree_a.get_parent_ids()[0])
318
293
        # it is legal to attempt to pull an already-merged bundle
319
294
        out, err = self.run_bzr('pull ../bundle')
320
295
        self.assertEqual(err, '')
321
 
        self.assertEqual(out, 'No revisions or tags to pull.\n')
 
296
        self.assertEqual(out, 'No revisions to pull.\n')
322
297
 
323
298
    def test_pull_verbose_no_files(self):
324
299
        """Pull --verbose should not list modified files"""
362
337
            def look_up(self, name, url):
363
338
                return 'source'
364
339
        directories.register('foo:', FooService, 'Testing directory service')
365
 
        self.addCleanup(directories.remove, 'foo:')
 
340
        self.addCleanup(lambda: directories.remove('foo:'))
366
341
        self.run_bzr('pull foo:bar -d target')
367
342
        self.assertEqual(source_last, target.last_revision())
368
343
 
383
358
        self.assertContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
384
359
        self.assertNotContainsRe(
385
360
            out, r'revno: 1\ncommitter: .*\nbranch nick: source')
386
 
 
387
 
    def test_pull_smart_bound_branch(self):
388
 
        self.setup_smart_server_with_call_log()
389
 
        parent = self.make_branch_and_tree('parent')
390
 
        parent.commit(message='first commit')
391
 
        child = parent.bzrdir.sprout('child').open_workingtree()
392
 
        child.commit(message='second commit')
393
 
        checkout = parent.branch.create_checkout('checkout')
394
 
        self.run_bzr(['pull', self.get_url('child')], working_dir='checkout')
395
 
 
396
 
    def test_pull_smart_stacked_streaming_acceptance(self):
397
 
        """'bzr pull -r 123' works on stacked, smart branches, even when the
398
 
        revision specified by the revno is only present in the fallback
399
 
        repository.
400
 
 
401
 
        See <https://launchpad.net/bugs/380314>
402
 
        """
403
 
        self.setup_smart_server_with_call_log()
404
 
        # Make a stacked-on branch with two commits so that the
405
 
        # revision-history can't be determined just by looking at the parent
406
 
        # field in the revision in the stacked repo.
407
 
        parent = self.make_branch_and_tree('parent', format='1.9')
408
 
        parent.commit(message='first commit')
409
 
        parent.commit(message='second commit')
410
 
        local = parent.bzrdir.sprout('local').open_workingtree()
411
 
        local.commit(message='local commit')
412
 
        local.branch.create_clone_on_transport(
413
 
            self.get_transport('stacked'), stacked_on=self.get_url('parent'))
414
 
        empty = self.make_branch_and_tree('empty', format='1.9')
415
 
        self.reset_smart_call_log()
416
 
        self.run_bzr(['pull', '-r', '1', self.get_url('stacked')],
417
 
            working_dir='empty')
418
 
        # This figure represent the amount of work to perform this use case. It
419
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
420
 
        # being too low. If rpc_count increases, more network roundtrips have
421
 
        # become necessary for this use case. Please do not adjust this number
422
 
        # upwards without agreement from bzr's network support maintainers.
423
 
        self.assertLength(19, self.hpss_calls)
424
 
        remote = Branch.open('stacked')
425
 
        self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
426
 
 
427
 
    def test_pull_cross_format_warning(self):
428
 
        """You get a warning for probably slow cross-format pulls.
429
 
        """
430
 
        # this is assumed to be going through InterDifferingSerializer
431
 
        from_tree = self.make_branch_and_tree('from', format='2a')
432
 
        to_tree = self.make_branch_and_tree('to', format='1.14-rich-root')
433
 
        from_tree.commit(message='first commit')
434
 
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
435
 
        self.assertContainsRe(err,
436
 
            "(?m)Doing on-the-fly conversion")
437
 
 
438
 
    def test_pull_cross_format_warning_no_IDS(self):
439
 
        """You get a warning for probably slow cross-format pulls.
440
 
        """
441
 
        # this simulates what would happen across the network, where
442
 
        # interdifferingserializer is not active
443
 
 
444
 
        debug.debug_flags.add('IDS_never')
445
 
        # TestCase take care of restoring them
446
 
 
447
 
        from_tree = self.make_branch_and_tree('from', format='2a')
448
 
        to_tree = self.make_branch_and_tree('to', format='1.14-rich-root')
449
 
        from_tree.commit(message='first commit')
450
 
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
451
 
        self.assertContainsRe(err,
452
 
            "(?m)Doing on-the-fly conversion")
453
 
 
454
 
    def test_pull_cross_format_from_network(self):
455
 
        self.setup_smart_server_with_call_log()
456
 
        from_tree = self.make_branch_and_tree('from', format='2a')
457
 
        to_tree = self.make_branch_and_tree('to', format='1.14-rich-root')
458
 
        self.assertIsInstance(from_tree.branch, remote.RemoteBranch)
459
 
        from_tree.commit(message='first commit')
460
 
        out, err = self.run_bzr(['pull', '-d', 'to',
461
 
            from_tree.branch.bzrdir.root_transport.base])
462
 
        self.assertContainsRe(err,
463
 
            "(?m)Doing on-the-fly conversion")
464
 
 
465
 
    def test_pull_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='development-subtree')
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_cross_to_experimental_format_warning(self):
476
 
        """You get a warning for pulling into experimental formats.
477
 
        """
478
 
        from_tree = self.make_branch_and_tree('from', format='2a')
479
 
        to_tree = self.make_branch_and_tree('to', format='development-subtree')
480
 
        from_tree.commit(message='first commit')
481
 
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
482
 
        self.assertContainsRe(err,
483
 
            "(?m)Fetching into experimental format")
484
 
 
485
 
    def test_pull_show_base(self):
486
 
        """bzr pull supports --show-base
487
 
 
488
 
        see https://bugs.launchpad.net/bzr/+bug/202374"""
489
 
        # create two trees with conflicts, setup conflict, check that
490
 
        # conflicted file looks correct
491
 
        a_tree = self.example_branch('a')
492
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
493
 
 
494
 
        f = open(pathjoin('a', 'hello'),'wt')
495
 
        f.write('fee')
496
 
        f.close()
497
 
        a_tree.commit('fee')
498
 
 
499
 
        f = open(pathjoin('b', 'hello'),'wt')
500
 
        f.write('fie')
501
 
        f.close()
502
 
 
503
 
        out,err=self.run_bzr(['pull','-d','b','a','--show-base'])
504
 
 
505
 
        # check for message here
506
 
        self.assertEqual(err,
507
 
                         ' M  hello\nText conflict in hello\n1 conflicts encountered.\n')
508
 
 
509
 
        self.assertEqualDiff('<<<<<<< TREE\n'
510
 
                             'fie||||||| BASE-REVISION\n'
511
 
                             'foo=======\n'
512
 
                             '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
520
 
        self.make_branch('from')
521
 
        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'))
525
 
 
526
 
    def test_pull_tag_conflicts(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
 
        to_tree.branch.tags.set_tag("mytag", "anotherrevid")
533
 
        out = self.run_bzr(['pull','-d','to','from'],retcode=1)
534
 
        self.assertEqual(out,
535
 
            ('No revisions to pull.\nConflicting tags:\n    mytag\n', ''))
536
 
 
537
 
    def test_pull_tag_notification(self):
538
 
        """pulling tags with conflicts will change the exit code"""
539
 
        # create a branch, see that --show-base fails
540
 
        from_tree = self.make_branch_and_tree('from')
541
 
        from_tree.branch.tags.set_tag("mytag", "somerevid")
542
 
        to_tree = self.make_branch_and_tree('to')
543
 
        out = self.run_bzr(['pull', '-d', 'to', 'from'])
544
 
        self.assertEqual(out,
545
 
            ('1 tag(s) updated.\n', ''))
546
 
 
547
 
    def test_pull_tag_overwrite(self):
548
 
        """pulling tags with --overwrite only reports changed tags."""
549
 
        # create a branch, see that --show-base fails
550
 
        from_tree = self.make_branch_and_tree('from')
551
 
        from_tree.branch.tags.set_tag("mytag", "somerevid")
552
 
        to_tree = self.make_branch_and_tree('to')
553
 
        to_tree.branch.tags.set_tag("mytag", "somerevid")
554
 
        out = self.run_bzr(['pull', '--overwrite', '-d', 'to', 'from'])
555
 
        self.assertEqual(out,
556
 
            ('No revisions or tags to pull.\n', ''))
557
 
 
558
 
 
559
 
class TestPullOutput(script.TestCaseWithTransportAndScript):
560
 
 
561
 
    def test_pull_log_format(self):
562
 
        self.run_script("""
563
 
            $ bzr init trunk
564
 
            Created a standalone tree (format: 2a)
565
 
            $ cd trunk
566
 
            $ echo foo > file
567
 
            $ bzr add
568
 
            adding file
569
 
            $ bzr commit -m 'we need some foo'
570
 
            2>Committing to:...trunk/
571
 
            2>added file
572
 
            2>Committed revision 1.
573
 
            $ cd ..
574
 
            $ bzr init feature
575
 
            Created a standalone tree (format: 2a)
576
 
            $ cd feature
577
 
            $ bzr pull -v ../trunk -Olog_format=line
578
 
            Now on revision 1.
579
 
            Added Revisions:
580
 
            1: jrandom@example.com ...we need some foo
581
 
            2>+N  file
582
 
            2>All changes applied successfully.
583
 
            """)