← 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: Patch Queue Manager
  • Date: 2011-10-14 16:54:26 UTC
  • mfrom: (6216.1.1 remove-this-file)
  • Revision ID: pqm@pqm.ubuntu.com-20111014165426-tjix4e6idryf1r2z
(jelmer) Remove an accidentally committed .THIS file. (Jelmer Vernooij)

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-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
20
20
import os
21
21
import sys
22
22
 
 
23
from bzrlib import (
 
24
    debug,
 
25
    remote,
 
26
    tests,
 
27
    urlutils,
 
28
    )
 
29
 
23
30
from bzrlib.branch import Branch
24
31
from bzrlib.directory_service import directories
25
32
from bzrlib.osutils import pathjoin
26
 
from bzrlib.tests.blackbox import ExternalBase
 
33
from bzrlib.tests import (
 
34
    fixtures,
 
35
    script,
 
36
    )
27
37
from bzrlib.uncommit import uncommit
28
38
from bzrlib.workingtree import WorkingTree
29
 
from bzrlib import urlutils
30
 
 
31
 
 
32
 
class TestPull(ExternalBase):
 
39
 
 
40
 
 
41
class TestPull(tests.TestCaseWithTransport):
33
42
 
34
43
    def example_branch(self, path='.'):
35
44
        tree = self.make_branch_and_tree(path)
45
54
    def test_pull(self):
46
55
        """Pull changes from one branch to another."""
47
56
        a_tree = self.example_branch('a')
 
57
        base_rev = a_tree.branch.last_revision()
48
58
        os.chdir('a')
49
59
        self.run_bzr('pull', retcode=3)
50
60
        self.run_bzr('missing', retcode=3)
63
73
        self.run_bzr('pull')
64
74
        os.mkdir('subdir')
65
75
        b_tree.add('subdir')
66
 
        b_tree.commit(message='blah', allow_pointless=True)
 
76
        new_rev = b_tree.commit(message='blah', allow_pointless=True)
67
77
 
68
78
        os.chdir('..')
69
79
        a = Branch.open('a')
70
80
        b = Branch.open('b')
71
 
        self.assertEqual(a.revision_history(), b.revision_history()[:-1])
 
81
        self.assertEqual(a.last_revision(), base_rev)
 
82
        self.assertEqual(b.last_revision(), new_rev)
72
83
 
73
84
        os.chdir('a')
74
85
        self.run_bzr('pull ../b')
75
 
        self.assertEqual(a.revision_history(), b.revision_history())
 
86
        self.assertEqual(a.last_revision(), b.last_revision())
76
87
        a_tree.commit(message='blah2', allow_pointless=True)
77
88
        b_tree.commit(message='blah3', allow_pointless=True)
78
89
        # no overwrite
83
94
        os.chdir('overwriteme')
84
95
        self.run_bzr('pull --overwrite ../a')
85
96
        overwritten = Branch.open('.')
86
 
        self.assertEqual(overwritten.revision_history(),
87
 
                         a.revision_history())
 
97
        self.assertEqual(overwritten.last_revision(),
 
98
                         a.last_revision())
88
99
        a_tree.merge_from_branch(b_tree.branch)
89
100
        a_tree.commit(message="blah4", allow_pointless=True)
90
101
        os.chdir('../b/subdir')
91
102
        self.run_bzr('pull ../../a')
92
 
        self.assertEqual(a.revision_history()[-1], b.revision_history()[-1])
 
103
        self.assertEqual(a.last_revision(), b.last_revision())
93
104
        sub_tree = WorkingTree.open_containing('.')[0]
94
105
        sub_tree.commit(message="blah5", allow_pointless=True)
95
106
        sub_tree.commit(message="blah6", allow_pointless=True)
135
146
        self.run_bzr('pull -r 3')
136
147
        self.assertEqual(b.revno(),3)
137
148
        self.run_bzr('pull -r 4')
138
 
        self.assertEqual(a.revision_history(), b.revision_history())
 
149
        self.assertEqual(a.last_revision(), b.last_revision())
139
150
 
 
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')
140
167
 
141
168
    def test_overwrite_uptodate(self):
142
169
        # Make sure pull --overwrite overwrites
155
182
        self.build_tree_contents([('a/foo', 'a third change')])
156
183
        a_tree.commit(message='a third change')
157
184
 
158
 
        rev_history_a = a_tree.branch.revision_history()
159
 
        self.assertEqual(len(rev_history_a), 3)
 
185
        self.assertEqual(a_tree.branch.last_revision_info()[0], 3)
160
186
 
161
187
        b_tree.merge_from_branch(a_tree.branch)
162
188
        b_tree.commit(message='merge')
163
189
 
164
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
 
190
        self.assertEqual(b_tree.branch.last_revision_info()[0], 2)
165
191
 
166
192
        os.chdir('b')
167
193
        self.run_bzr('pull --overwrite ../a')
168
 
        rev_history_b = b_tree.branch.revision_history()
169
 
        self.assertEqual(len(rev_history_b), 3)
170
 
 
171
 
        self.assertEqual(rev_history_b, rev_history_a)
 
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())
172
197
 
173
198
    def test_overwrite_children(self):
174
199
        # Make sure pull --overwrite sets the revision-history
186
211
        self.build_tree_contents([('a/foo', 'a third change')])
187
212
        a_tree.commit(message='a third change')
188
213
 
189
 
        self.assertEqual(len(a_tree.branch.revision_history()), 3)
 
214
        self.assertEqual(a_tree.branch.last_revision_info()[0], 3)
190
215
 
191
216
        b_tree.merge_from_branch(a_tree.branch)
192
217
        b_tree.commit(message='merge')
193
218
 
194
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
 
219
        self.assertEqual(b_tree.branch.last_revision_info()[0], 2)
195
220
 
196
221
        self.build_tree_contents([('a/foo', 'a fourth change\n')])
197
222
        a_tree.commit(message='a fourth change')
198
223
 
199
 
        rev_history_a = a_tree.branch.revision_history()
200
 
        self.assertEqual(len(rev_history_a), 4)
 
224
        rev_info_a = a_tree.branch.last_revision_info()
 
225
        self.assertEqual(rev_info_a[0], 4)
201
226
 
202
227
        # With convergence, we could just pull over the
203
228
        # new change, but with --overwrite, we want to switch our history
204
229
        os.chdir('b')
205
230
        self.run_bzr('pull --overwrite ../a')
206
 
        rev_history_b = b_tree.branch.revision_history()
207
 
        self.assertEqual(len(rev_history_b), 4)
208
 
 
209
 
        self.assertEqual(rev_history_b, rev_history_a)
 
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)
210
234
 
211
235
    def test_pull_remember(self):
212
236
        """Pull changes from one branch to another and test parent location."""
281
305
        self.assertEqual(err,
282
306
                ' M  a\nAll changes applied successfully.\n')
283
307
 
284
 
        self.assertEqualDiff(tree_a.branch.revision_history(),
285
 
                             tree_b.branch.revision_history())
 
308
        self.assertEqualDiff(tree_a.branch.last_revision(),
 
309
                             tree_b.branch.last_revision())
286
310
 
287
311
        testament_a = Testament.from_revision(tree_a.branch.repository,
288
312
                                              tree_a.get_parent_ids()[0])
294
318
        # it is legal to attempt to pull an already-merged bundle
295
319
        out, err = self.run_bzr('pull ../bundle')
296
320
        self.assertEqual(err, '')
297
 
        self.assertEqual(out, 'No revisions to pull.\n')
 
321
        self.assertEqual(out, 'No revisions or tags to pull.\n')
298
322
 
299
323
    def test_pull_verbose_no_files(self):
300
324
        """Pull --verbose should not list modified files"""
338
362
            def look_up(self, name, url):
339
363
                return 'source'
340
364
        directories.register('foo:', FooService, 'Testing directory service')
341
 
        self.addCleanup(lambda: directories.remove('foo:'))
 
365
        self.addCleanup(directories.remove, 'foo:')
342
366
        self.run_bzr('pull foo:bar -d target')
343
367
        self.assertEqual(source_last, target.last_revision())
344
368
 
360
384
        self.assertNotContainsRe(
361
385
            out, r'revno: 1\ncommitter: .*\nbranch nick: source')
362
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
 
363
396
    def test_pull_smart_stacked_streaming_acceptance(self):
364
397
        """'bzr pull -r 123' works on stacked, smart branches, even when the
365
398
        revision specified by the revno is only present in the fallback
387
420
        # being too low. If rpc_count increases, more network roundtrips have
388
421
        # become necessary for this use case. Please do not adjust this number
389
422
        # upwards without agreement from bzr's network support maintainers.
390
 
        self.assertLength(18, self.hpss_calls)
 
423
        self.assertLength(19, self.hpss_calls)
391
424
        remote = Branch.open('stacked')
392
425
        self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
393
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
            """)