← 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: Martin Pool
  • Date: 2007-04-04 06:17:31 UTC
  • mto: This revision was merged to the branch mainline in revision 2397.
  • Revision ID: mbp@sourcefrog.net-20070404061731-tt2xrzllqhbodn83
Contents of TODO file moved into bug tracker

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_pull.py
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."""
21
21
import sys
22
22
 
23
23
from bzrlib.branch import Branch
24
 
from bzrlib.directory_service import directories
25
 
from bzrlib.osutils import pathjoin
26
24
from bzrlib.tests.blackbox import ExternalBase
27
25
from bzrlib.uncommit import uncommit
28
 
from bzrlib.workingtree import WorkingTree
29
26
from bzrlib import urlutils
30
27
 
31
28
 
32
29
class TestPull(ExternalBase):
33
30
 
34
 
    def example_branch(self, path='.'):
35
 
        tree = self.make_branch_and_tree(path)
36
 
        self.build_tree_contents([
37
 
            (pathjoin(path, 'hello'),   'foo'),
38
 
            (pathjoin(path, 'goodbye'), 'baz')])
39
 
        tree.add('hello')
40
 
        tree.commit(message='setup')
41
 
        tree.add('goodbye')
42
 
        tree.commit(message='setup')
43
 
        return tree
 
31
    def example_branch(test):
 
32
        test.runbzr('init')
 
33
        file('hello', 'wt').write('foo')
 
34
        test.runbzr('add hello')
 
35
        test.runbzr('commit -m setup hello')
 
36
        file('goodbye', 'wt').write('baz')
 
37
        test.runbzr('add goodbye')
 
38
        test.runbzr('commit -m setup goodbye')
44
39
 
45
40
    def test_pull(self):
46
41
        """Pull changes from one branch to another."""
47
 
        a_tree = self.example_branch('a')
 
42
        os.mkdir('a')
48
43
        os.chdir('a')
49
 
        self.run_bzr('pull', retcode=3)
50
 
        self.run_bzr('missing', retcode=3)
51
 
        self.run_bzr('missing .')
52
 
        self.run_bzr('missing')
 
44
 
 
45
        self.example_branch()
 
46
        self.runbzr('pull', retcode=3)
 
47
        self.runbzr('missing', retcode=3)
 
48
        self.runbzr('missing .')
 
49
        self.runbzr('missing')
53
50
        # this will work on windows because we check for the same branch
54
51
        # in pull - if it fails, it is a regression
55
 
        self.run_bzr('pull')
56
 
        self.run_bzr('pull /', retcode=3)
 
52
        self.runbzr('pull')
 
53
        self.runbzr('pull /', retcode=3)
57
54
        if sys.platform not in ('win32', 'cygwin'):
58
 
            self.run_bzr('pull')
 
55
            self.runbzr('pull')
59
56
 
60
57
        os.chdir('..')
61
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
58
        self.runbzr('branch a b')
62
59
        os.chdir('b')
63
 
        self.run_bzr('pull')
 
60
        self.runbzr('pull')
64
61
        os.mkdir('subdir')
65
 
        b_tree.add('subdir')
66
 
        b_tree.commit(message='blah', allow_pointless=True)
67
 
 
68
 
        os.chdir('..')
69
 
        a = Branch.open('a')
70
 
        b = Branch.open('b')
71
 
        self.assertEqual(a.revision_history(), b.revision_history()[:-1])
72
 
 
73
 
        os.chdir('a')
74
 
        self.run_bzr('pull ../b')
75
 
        self.assertEqual(a.revision_history(), b.revision_history())
76
 
        a_tree.commit(message='blah2', allow_pointless=True)
77
 
        b_tree.commit(message='blah3', allow_pointless=True)
 
62
        self.runbzr('add subdir')
 
63
        self.runbzr('commit -m blah --unchanged')
 
64
        os.chdir('../a')
 
65
        a = Branch.open('.')
 
66
        b = Branch.open('../b')
 
67
        self.assertEquals(a.revision_history(), b.revision_history()[:-1])
 
68
        self.runbzr('pull ../b')
 
69
        self.assertEquals(a.revision_history(), b.revision_history())
 
70
        self.runbzr('commit -m blah2 --unchanged')
 
71
        os.chdir('../b')
 
72
        self.runbzr('commit -m blah3 --unchanged')
78
73
        # no overwrite
79
 
        os.chdir('../b')
80
 
        self.run_bzr('pull ../a', retcode=3)
 
74
        self.runbzr('pull ../a', retcode=3)
81
75
        os.chdir('..')
82
 
        b_tree.bzrdir.sprout('overwriteme')
 
76
        self.runbzr('branch b overwriteme')
83
77
        os.chdir('overwriteme')
84
 
        self.run_bzr('pull --overwrite ../a')
 
78
        self.runbzr('pull --overwrite ../a')
85
79
        overwritten = Branch.open('.')
86
80
        self.assertEqual(overwritten.revision_history(),
87
81
                         a.revision_history())
88
 
        a_tree.merge_from_branch(b_tree.branch)
89
 
        a_tree.commit(message="blah4", allow_pointless=True)
 
82
        os.chdir('../a')
 
83
        self.runbzr('merge ../b')
 
84
        self.runbzr('commit -m blah4 --unchanged')
90
85
        os.chdir('../b/subdir')
91
 
        self.run_bzr('pull ../../a')
92
 
        self.assertEqual(a.revision_history()[-1], b.revision_history()[-1])
93
 
        sub_tree = WorkingTree.open_containing('.')[0]
94
 
        sub_tree.commit(message="blah5", allow_pointless=True)
95
 
        sub_tree.commit(message="blah6", allow_pointless=True)
 
86
        self.runbzr('pull ../../a')
 
87
        self.assertEquals(a.revision_history()[-1], b.revision_history()[-1])
 
88
        self.runbzr('commit -m blah5 --unchanged')
 
89
        self.runbzr('commit -m blah6 --unchanged')
96
90
        os.chdir('..')
97
 
        self.run_bzr('pull ../a')
 
91
        self.runbzr('pull ../a')
98
92
        os.chdir('../a')
99
 
        a_tree.commit(message="blah7", allow_pointless=True)
100
 
        a_tree.merge_from_branch(b_tree.branch)
101
 
        a_tree.commit(message="blah8", allow_pointless=True)
102
 
        self.run_bzr('pull ../b')
103
 
        self.run_bzr('pull ../b')
 
93
        self.runbzr('commit -m blah7 --unchanged')
 
94
        self.runbzr('merge ../b')
 
95
        self.runbzr('commit -m blah8 --unchanged')
 
96
        self.runbzr('pull ../b')
 
97
        self.runbzr('pull ../b')
104
98
 
105
99
    def test_pull_dash_d(self):
106
 
        self.example_branch('a')
107
 
        self.make_branch_and_tree('b')
108
 
        self.make_branch_and_tree('c')
 
100
        os.mkdir('a')
 
101
        os.chdir('a')
 
102
        self.example_branch()
 
103
        self.runbzr('init ../b')
 
104
        self.runbzr('init ../c')
109
105
        # pull into that branch
110
 
        self.run_bzr('pull -d b a')
 
106
        self.runbzr('pull -d ../b .')
111
107
        # pull into a branch specified by a url
112
 
        c_url = urlutils.local_path_to_url('c')
 
108
        c_url = urlutils.local_path_to_url('../c')
113
109
        self.assertStartsWith(c_url, 'file://')
114
 
        self.run_bzr(['pull', '-d', c_url, 'a'])
 
110
        self.runbzr('pull -d %s .' % c_url)
115
111
 
116
112
    def test_pull_revision(self):
117
113
        """Pull some changes from one branch to another."""
118
 
        a_tree = self.example_branch('a')
119
 
        self.build_tree_contents([
120
 
            ('a/hello2',   'foo'),
121
 
            ('a/goodbye2', 'baz')])
122
 
        a_tree.add('hello2')
123
 
        a_tree.commit(message="setup")
124
 
        a_tree.add('goodbye2')
125
 
        a_tree.commit(message="setup")
126
 
 
127
 
        b_tree = a_tree.bzrdir.sprout('b',
128
 
                   revision_id=a_tree.branch.get_rev_id(1)).open_workingtree()
 
114
        os.mkdir('a')
 
115
        os.chdir('a')
 
116
 
 
117
        self.example_branch()
 
118
        file('hello2', 'wt').write('foo')
 
119
        self.runbzr('add hello2')
 
120
        self.runbzr('commit -m setup hello2')
 
121
        file('goodbye2', 'wt').write('baz')
 
122
        self.runbzr('add goodbye2')
 
123
        self.runbzr('commit -m setup goodbye2')
 
124
 
 
125
        os.chdir('..')
 
126
        self.runbzr('branch -r 1 a b')
129
127
        os.chdir('b')
130
 
        self.run_bzr('pull -r 2')
 
128
        self.runbzr('pull -r 2')
131
129
        a = Branch.open('../a')
132
130
        b = Branch.open('.')
133
 
        self.assertEqual(a.revno(),4)
134
 
        self.assertEqual(b.revno(),2)
135
 
        self.run_bzr('pull -r 3')
136
 
        self.assertEqual(b.revno(),3)
137
 
        self.run_bzr('pull -r 4')
138
 
        self.assertEqual(a.revision_history(), b.revision_history())
 
131
        self.assertEquals(a.revno(),4)
 
132
        self.assertEquals(b.revno(),2)
 
133
        self.runbzr('pull -r 3')
 
134
        self.assertEquals(b.revno(),3)
 
135
        self.runbzr('pull -r 4')
 
136
        self.assertEquals(a.revision_history(), b.revision_history())
139
137
 
140
138
 
141
139
    def test_overwrite_uptodate(self):
142
140
        # Make sure pull --overwrite overwrites
143
141
        # even if the target branch has merged
144
142
        # everything already.
145
 
        a_tree = self.make_branch_and_tree('a')
146
 
        self.build_tree_contents([('a/foo', 'original\n')])
147
 
        a_tree.add('foo')
148
 
        a_tree.commit(message='initial commit')
149
 
 
150
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
151
 
 
152
 
        self.build_tree_contents([('a/foo', 'changed\n')])
153
 
        a_tree.commit(message='later change')
154
 
 
155
 
        self.build_tree_contents([('a/foo', 'a third change')])
156
 
        a_tree.commit(message='a third change')
157
 
 
158
 
        rev_history_a = a_tree.branch.revision_history()
159
 
        self.assertEqual(len(rev_history_a), 3)
160
 
 
161
 
        b_tree.merge_from_branch(a_tree.branch)
162
 
        b_tree.commit(message='merge')
163
 
 
164
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
165
 
 
166
 
        os.chdir('b')
167
 
        self.run_bzr('pull --overwrite ../a')
168
 
        rev_history_b = b_tree.branch.revision_history()
169
 
        self.assertEqual(len(rev_history_b), 3)
 
143
        bzr = self.run_bzr
 
144
 
 
145
        def get_rh(expected_len):
 
146
            rh = self.capture('revision-history')
 
147
            # Make sure we don't have trailing empty revisions
 
148
            rh = rh.strip().split('\n')
 
149
            self.assertEqual(len(rh), expected_len)
 
150
            return rh
 
151
 
 
152
        os.mkdir('a')
 
153
        os.chdir('a')
 
154
        bzr('init')
 
155
        open('foo', 'wb').write('original\n')
 
156
        bzr('add', 'foo')
 
157
        bzr('commit', '-m', 'initial commit')
 
158
 
 
159
        os.chdir('..')
 
160
        bzr('branch', 'a', 'b')
 
161
 
 
162
        os.chdir('a')
 
163
        open('foo', 'wb').write('changed\n')
 
164
        bzr('commit', '-m', 'later change')
 
165
 
 
166
        open('foo', 'wb').write('another\n')
 
167
        bzr('commit', '-m', 'a third change')
 
168
 
 
169
        rev_history_a = get_rh(3)
 
170
 
 
171
        os.chdir('../b')
 
172
        bzr('merge', '../a')
 
173
        bzr('commit', '-m', 'merge')
 
174
 
 
175
        rev_history_b = get_rh(2)
 
176
 
 
177
        bzr('pull', '--overwrite', '../a')
 
178
        rev_history_b = get_rh(3)
170
179
 
171
180
        self.assertEqual(rev_history_b, rev_history_a)
172
181
 
173
182
    def test_overwrite_children(self):
174
183
        # Make sure pull --overwrite sets the revision-history
175
184
        # to be identical to the pull source, even if we have convergence
176
 
        a_tree = self.make_branch_and_tree('a')
177
 
        self.build_tree_contents([('a/foo', 'original\n')])
178
 
        a_tree.add('foo')
179
 
        a_tree.commit(message='initial commit')
180
 
 
181
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
182
 
 
183
 
        self.build_tree_contents([('a/foo', 'changed\n')])
184
 
        a_tree.commit(message='later change')
185
 
 
186
 
        self.build_tree_contents([('a/foo', 'a third change')])
187
 
        a_tree.commit(message='a third change')
188
 
 
189
 
        self.assertEqual(len(a_tree.branch.revision_history()), 3)
190
 
 
191
 
        b_tree.merge_from_branch(a_tree.branch)
192
 
        b_tree.commit(message='merge')
193
 
 
194
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
195
 
 
196
 
        self.build_tree_contents([('a/foo', 'a fourth change\n')])
197
 
        a_tree.commit(message='a fourth change')
198
 
 
199
 
        rev_history_a = a_tree.branch.revision_history()
200
 
        self.assertEqual(len(rev_history_a), 4)
 
185
        bzr = self.run_bzr
 
186
 
 
187
        def get_rh(expected_len):
 
188
            rh = self.capture('revision-history')
 
189
            # Make sure we don't have trailing empty revisions
 
190
            rh = rh.strip().split('\n')
 
191
            self.assertEqual(len(rh), expected_len)
 
192
            return rh
 
193
 
 
194
        os.mkdir('a')
 
195
        os.chdir('a')
 
196
        bzr('init')
 
197
        open('foo', 'wb').write('original\n')
 
198
        bzr('add', 'foo')
 
199
        bzr('commit', '-m', 'initial commit')
 
200
 
 
201
        os.chdir('..')
 
202
        bzr('branch', 'a', 'b')
 
203
 
 
204
        os.chdir('a')
 
205
        open('foo', 'wb').write('changed\n')
 
206
        bzr('commit', '-m', 'later change')
 
207
 
 
208
        open('foo', 'wb').write('another\n')
 
209
        bzr('commit', '-m', 'a third change')
 
210
 
 
211
        rev_history_a = get_rh(3)
 
212
 
 
213
        os.chdir('../b')
 
214
        bzr('merge', '../a')
 
215
        bzr('commit', '-m', 'merge')
 
216
 
 
217
        rev_history_b = get_rh(2)
 
218
 
 
219
        os.chdir('../a')
 
220
        open('foo', 'wb').write('a fourth change\n')
 
221
        bzr('commit', '-m', 'a fourth change')
 
222
 
 
223
        rev_history_a = get_rh(4)
201
224
 
202
225
        # With convergence, we could just pull over the
203
226
        # new change, but with --overwrite, we want to switch our history
204
 
        os.chdir('b')
205
 
        self.run_bzr('pull --overwrite ../a')
206
 
        rev_history_b = b_tree.branch.revision_history()
207
 
        self.assertEqual(len(rev_history_b), 4)
 
227
        os.chdir('../b')
 
228
        bzr('pull', '--overwrite', '../a')
 
229
        rev_history_b = get_rh(4)
208
230
 
209
231
        self.assertEqual(rev_history_b, rev_history_a)
210
232
 
229
251
        self.assertEqual(None, branch_b.get_parent())
230
252
        # test pull for failure without parent set
231
253
        os.chdir('branch_b')
232
 
        out = self.run_bzr('pull', retcode=3)
233
 
        self.assertEqual(out,
 
254
        out = self.runbzr('pull', retcode=3)
 
255
        self.assertEquals(out,
234
256
                ('','bzr: ERROR: No pull location known or specified.\n'))
235
257
        # test implicit --remember when no parent set, this pull conflicts
236
258
        self.build_tree(['d'])
237
259
        tree_b.add('d')
238
260
        tree_b.commit('commit d')
239
 
        out = self.run_bzr('pull ../branch_a', retcode=3)
240
 
        self.assertEqual(out,
 
261
        out = self.runbzr('pull ../branch_a', retcode=3)
 
262
        self.assertEquals(out,
241
263
                ('','bzr: ERROR: These branches have diverged.'
242
 
                    ' Use the missing command to see how.\n'
243
 
                    'Use the merge command to reconcile them.\n'))
244
 
        self.assertEqual(branch_b.get_parent(), parent)
 
264
                    ' Use the merge command to reconcile them.\n'))
 
265
        self.assertEquals(branch_b.get_parent(), parent)
245
266
        # test implicit --remember after resolving previous failure
246
267
        uncommit(branch=branch_b, tree=tree_b)
247
268
        transport.delete('branch_b/d')
248
 
        self.run_bzr('pull')
249
 
        self.assertEqual(branch_b.get_parent(), parent)
 
269
        self.runbzr('pull')
 
270
        self.assertEquals(branch_b.get_parent(), parent)
250
271
        # test explicit --remember
251
 
        self.run_bzr('pull ../branch_c --remember')
252
 
        self.assertEqual(branch_b.get_parent(),
 
272
        self.runbzr('pull ../branch_c --remember')
 
273
        self.assertEquals(branch_b.get_parent(),
253
274
                          branch_c.bzrdir.root_transport.base)
254
275
 
255
276
    def test_pull_bundle(self):
272
293
 
273
294
        # Create the bundle for 'b' to pull
274
295
        os.chdir('branch_a')
275
 
        self.run_bzr('bundle ../branch_b -o ../bundle')
 
296
        bundle_file = open('../bundle', 'wb')
 
297
        bundle_file.write(self.run_bzr('bundle', '../branch_b')[0])
 
298
        bundle_file.close()
276
299
 
277
300
        os.chdir('../branch_b')
278
 
        out, err = self.run_bzr('pull ../bundle')
 
301
        out, err = self.run_bzr('pull', '../bundle')
279
302
        self.assertEqual(out,
280
303
                         'Now on revision 2.\n')
281
304
        self.assertEqual(err,
292
315
                             testament_b.as_text())
293
316
 
294
317
        # it is legal to attempt to pull an already-merged bundle
295
 
        out, err = self.run_bzr('pull ../bundle')
 
318
        out, err = self.run_bzr('pull', '../bundle')
296
319
        self.assertEqual(err, '')
297
320
        self.assertEqual(out, 'No revisions to pull.\n')
298
 
 
299
 
    def test_pull_verbose_no_files(self):
300
 
        """Pull --verbose should not list modified files"""
301
 
        tree_a = self.make_branch_and_tree('tree_a')
302
 
        self.build_tree(['tree_a/foo'])
303
 
        tree_a.add('foo')
304
 
        tree_a.commit('bar')
305
 
        tree_b = self.make_branch_and_tree('tree_b')
306
 
        out = self.run_bzr('pull --verbose -d tree_b tree_a')[0]
307
 
        self.assertContainsRe(out, 'bar')
308
 
        self.assertNotContainsRe(out, 'added:')
309
 
        self.assertNotContainsRe(out, 'foo')
310
 
 
311
 
    def test_pull_quiet(self):
312
 
        """Check that bzr pull --quiet does not print anything"""
313
 
        tree_a = self.make_branch_and_tree('tree_a')
314
 
        self.build_tree(['tree_a/foo'])
315
 
        tree_a.add('foo')
316
 
        revision_id = tree_a.commit('bar')
317
 
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
318
 
        out, err = self.run_bzr('pull --quiet -d tree_b')
319
 
        self.assertEqual(out, '')
320
 
        self.assertEqual(err, '')
321
 
        self.assertEqual(tree_b.last_revision(), revision_id)
322
 
        self.build_tree(['tree_a/moo'])
323
 
        tree_a.add('moo')
324
 
        revision_id = tree_a.commit('quack')
325
 
        out, err = self.run_bzr('pull --quiet -d tree_b')
326
 
        self.assertEqual(out, '')
327
 
        self.assertEqual(err, '')
328
 
        self.assertEqual(tree_b.last_revision(), revision_id)
329
 
 
330
 
    def test_pull_from_directory_service(self):
331
 
        source = self.make_branch_and_tree('source')
332
 
        source.commit('commit 1')
333
 
        target = source.bzrdir.sprout('target').open_workingtree()
334
 
        source_last = source.commit('commit 2')
335
 
        class FooService(object):
336
 
            """A directory service that always returns source"""
337
 
 
338
 
            def look_up(self, name, url):
339
 
                return 'source'
340
 
        directories.register('foo:', FooService, 'Testing directory service')
341
 
        self.addCleanup(lambda: directories.remove('foo:'))
342
 
        self.run_bzr('pull foo:bar -d target')
343
 
        self.assertEqual(source_last, target.last_revision())
344
 
 
345
 
    def test_pull_verbose_defaults_to_long(self):
346
 
        tree = self.example_branch('source')
347
 
        target = self.make_branch_and_tree('target')
348
 
        out = self.run_bzr('pull -v source -d target')[0]
349
 
        self.assertContainsRe(out,
350
 
                              r'revno: 1\ncommitter: .*\nbranch nick: source')
351
 
        self.assertNotContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
352
 
 
353
 
    def test_pull_verbose_uses_default_log(self):
354
 
        tree = self.example_branch('source')
355
 
        target = self.make_branch_and_tree('target')
356
 
        target_config = target.branch.get_config()
357
 
        target_config.set_user_option('log_format', 'short')
358
 
        out = self.run_bzr('pull -v source -d target')[0]
359
 
        self.assertContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
360
 
        self.assertNotContainsRe(
361
 
            out, r'revno: 1\ncommitter: .*\nbranch nick: source')