← 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: Robert Collins
  • Date: 2007-07-04 01:39:50 UTC
  • mto: This revision was merged to the branch mainline in revision 2581.
  • Revision ID: robertc@robertcollins.net-20070704013950-7pp23plwyqjvgkxg
Review feedback.

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
 
    urlutils,
27
 
    )
28
 
 
29
23
from bzrlib.branch import Branch
30
 
from bzrlib.directory_service import directories
31
 
from bzrlib.osutils import pathjoin
32
24
from bzrlib.tests.blackbox import ExternalBase
33
25
from bzrlib.uncommit import uncommit
34
 
from bzrlib.workingtree import WorkingTree
 
26
from bzrlib import urlutils
35
27
 
36
28
 
37
29
class TestPull(ExternalBase):
38
30
 
39
 
    def example_branch(self, path='.'):
40
 
        tree = self.make_branch_and_tree(path)
41
 
        self.build_tree_contents([
42
 
            (pathjoin(path, 'hello'),   'foo'),
43
 
            (pathjoin(path, 'goodbye'), 'baz')])
44
 
        tree.add('hello')
45
 
        tree.commit(message='setup')
46
 
        tree.add('goodbye')
47
 
        tree.commit(message='setup')
48
 
        return tree
 
31
    def example_branch(test):
 
32
        test.run_bzr('init')
 
33
        file('hello', 'wt').write('foo')
 
34
        test.run_bzr('add hello')
 
35
        test.run_bzr('commit -m setup hello')
 
36
        file('goodbye', 'wt').write('baz')
 
37
        test.run_bzr('add goodbye')
 
38
        test.run_bzr('commit -m setup goodbye')
49
39
 
50
40
    def test_pull(self):
51
41
        """Pull changes from one branch to another."""
52
 
        a_tree = self.example_branch('a')
 
42
        os.mkdir('a')
53
43
        os.chdir('a')
 
44
 
 
45
        self.example_branch()
54
46
        self.run_bzr('pull', retcode=3)
55
47
        self.run_bzr('missing', retcode=3)
56
48
        self.run_bzr('missing .')
63
55
            self.run_bzr('pull')
64
56
 
65
57
        os.chdir('..')
66
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
58
        self.run_bzr('branch a b')
67
59
        os.chdir('b')
68
60
        self.run_bzr('pull')
69
61
        os.mkdir('subdir')
70
 
        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')
 
62
        self.run_bzr('add subdir')
 
63
        self.run_bzr('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])
79
68
        self.run_bzr('pull ../b')
80
 
        self.assertEqual(a.revision_history(), b.revision_history())
81
 
        a_tree.commit(message='blah2', allow_pointless=True)
82
 
        b_tree.commit(message='blah3', allow_pointless=True)
 
69
        self.assertEquals(a.revision_history(), b.revision_history())
 
70
        self.run_bzr('commit -m blah2 --unchanged')
 
71
        os.chdir('../b')
 
72
        self.run_bzr('commit -m blah3 --unchanged')
83
73
        # no overwrite
84
 
        os.chdir('../b')
85
74
        self.run_bzr('pull ../a', retcode=3)
86
75
        os.chdir('..')
87
 
        b_tree.bzrdir.sprout('overwriteme')
 
76
        self.run_bzr('branch b overwriteme')
88
77
        os.chdir('overwriteme')
89
78
        self.run_bzr('pull --overwrite ../a')
90
79
        overwritten = Branch.open('.')
91
80
        self.assertEqual(overwritten.revision_history(),
92
81
                         a.revision_history())
93
 
        a_tree.merge_from_branch(b_tree.branch)
94
 
        a_tree.commit(message="blah4", allow_pointless=True)
 
82
        os.chdir('../a')
 
83
        self.run_bzr('merge ../b')
 
84
        self.run_bzr('commit -m blah4 --unchanged')
95
85
        os.chdir('../b/subdir')
96
86
        self.run_bzr('pull ../../a')
97
 
        self.assertEqual(a.revision_history()[-1], b.revision_history()[-1])
98
 
        sub_tree = WorkingTree.open_containing('.')[0]
99
 
        sub_tree.commit(message="blah5", allow_pointless=True)
100
 
        sub_tree.commit(message="blah6", allow_pointless=True)
 
87
        self.assertEquals(a.revision_history()[-1], b.revision_history()[-1])
 
88
        self.run_bzr('commit -m blah5 --unchanged')
 
89
        self.run_bzr('commit -m blah6 --unchanged')
101
90
        os.chdir('..')
102
91
        self.run_bzr('pull ../a')
103
92
        os.chdir('../a')
104
 
        a_tree.commit(message="blah7", allow_pointless=True)
105
 
        a_tree.merge_from_branch(b_tree.branch)
106
 
        a_tree.commit(message="blah8", allow_pointless=True)
 
93
        self.run_bzr('commit -m blah7 --unchanged')
 
94
        self.run_bzr('merge ../b')
 
95
        self.run_bzr('commit -m blah8 --unchanged')
107
96
        self.run_bzr('pull ../b')
108
97
        self.run_bzr('pull ../b')
109
98
 
110
99
    def test_pull_dash_d(self):
111
 
        self.example_branch('a')
112
 
        self.make_branch_and_tree('b')
113
 
        self.make_branch_and_tree('c')
 
100
        os.mkdir('a')
 
101
        os.chdir('a')
 
102
        self.example_branch()
 
103
        self.run_bzr('init ../b')
 
104
        self.run_bzr('init ../c')
114
105
        # pull into that branch
115
 
        self.run_bzr('pull -d b a')
 
106
        self.run_bzr('pull -d ../b .')
116
107
        # pull into a branch specified by a url
117
 
        c_url = urlutils.local_path_to_url('c')
 
108
        c_url = urlutils.local_path_to_url('../c')
118
109
        self.assertStartsWith(c_url, 'file://')
119
 
        self.run_bzr(['pull', '-d', c_url, 'a'])
 
110
        self.run_bzr('pull -d %s .' % c_url)
120
111
 
121
112
    def test_pull_revision(self):
122
113
        """Pull some changes from one branch to another."""
123
 
        a_tree = self.example_branch('a')
124
 
        self.build_tree_contents([
125
 
            ('a/hello2',   'foo'),
126
 
            ('a/goodbye2', 'baz')])
127
 
        a_tree.add('hello2')
128
 
        a_tree.commit(message="setup")
129
 
        a_tree.add('goodbye2')
130
 
        a_tree.commit(message="setup")
131
 
 
132
 
        b_tree = a_tree.bzrdir.sprout('b',
133
 
                   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.run_bzr('add hello2')
 
120
        self.run_bzr('commit -m setup hello2')
 
121
        file('goodbye2', 'wt').write('baz')
 
122
        self.run_bzr('add goodbye2')
 
123
        self.run_bzr('commit -m setup goodbye2')
 
124
 
 
125
        os.chdir('..')
 
126
        self.run_bzr('branch -r 1 a b')
134
127
        os.chdir('b')
135
128
        self.run_bzr('pull -r 2')
136
129
        a = Branch.open('../a')
137
130
        b = Branch.open('.')
138
 
        self.assertEqual(a.revno(),4)
139
 
        self.assertEqual(b.revno(),2)
 
131
        self.assertEquals(a.revno(),4)
 
132
        self.assertEquals(b.revno(),2)
140
133
        self.run_bzr('pull -r 3')
141
 
        self.assertEqual(b.revno(),3)
 
134
        self.assertEquals(b.revno(),3)
142
135
        self.run_bzr('pull -r 4')
143
 
        self.assertEqual(a.revision_history(), b.revision_history())
 
136
        self.assertEquals(a.revision_history(), b.revision_history())
144
137
 
145
138
 
146
139
    def test_overwrite_uptodate(self):
147
140
        # Make sure pull --overwrite overwrites
148
141
        # even if the target branch has merged
149
142
        # everything already.
150
 
        a_tree = self.make_branch_and_tree('a')
151
 
        self.build_tree_contents([('a/foo', 'original\n')])
152
 
        a_tree.add('foo')
153
 
        a_tree.commit(message='initial commit')
154
 
 
155
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
156
 
 
157
 
        self.build_tree_contents([('a/foo', 'changed\n')])
158
 
        a_tree.commit(message='later change')
159
 
 
160
 
        self.build_tree_contents([('a/foo', 'a third change')])
161
 
        a_tree.commit(message='a third change')
162
 
 
163
 
        rev_history_a = a_tree.branch.revision_history()
164
 
        self.assertEqual(len(rev_history_a), 3)
165
 
 
166
 
        b_tree.merge_from_branch(a_tree.branch)
167
 
        b_tree.commit(message='merge')
168
 
 
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)
 
143
        bzr = self.run_bzr
 
144
 
 
145
        def get_rh(expected_len):
 
146
            rh = self.run_bzr(['revision-history'])[0]
 
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)
175
179
 
176
180
        self.assertEqual(rev_history_b, rev_history_a)
177
181
 
178
182
    def test_overwrite_children(self):
179
183
        # Make sure pull --overwrite sets the revision-history
180
184
        # to be identical to the pull source, even if we have convergence
181
 
        a_tree = self.make_branch_and_tree('a')
182
 
        self.build_tree_contents([('a/foo', 'original\n')])
183
 
        a_tree.add('foo')
184
 
        a_tree.commit(message='initial commit')
185
 
 
186
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
187
 
 
188
 
        self.build_tree_contents([('a/foo', 'changed\n')])
189
 
        a_tree.commit(message='later change')
190
 
 
191
 
        self.build_tree_contents([('a/foo', 'a third change')])
192
 
        a_tree.commit(message='a third change')
193
 
 
194
 
        self.assertEqual(len(a_tree.branch.revision_history()), 3)
195
 
 
196
 
        b_tree.merge_from_branch(a_tree.branch)
197
 
        b_tree.commit(message='merge')
198
 
 
199
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
200
 
 
201
 
        self.build_tree_contents([('a/foo', 'a fourth change\n')])
202
 
        a_tree.commit(message='a fourth change')
203
 
 
204
 
        rev_history_a = a_tree.branch.revision_history()
205
 
        self.assertEqual(len(rev_history_a), 4)
 
185
        bzr = self.run_bzr
 
186
 
 
187
        def get_rh(expected_len):
 
188
            rh = self.run_bzr(['revision-history'])[0]
 
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)
206
224
 
207
225
        # With convergence, we could just pull over the
208
226
        # 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)
 
227
        os.chdir('../b')
 
228
        bzr('pull', '--overwrite', '../a')
 
229
        rev_history_b = get_rh(4)
213
230
 
214
231
        self.assertEqual(rev_history_b, rev_history_a)
215
232
 
235
252
        # test pull for failure without parent set
236
253
        os.chdir('branch_b')
237
254
        out = self.run_bzr('pull', retcode=3)
238
 
        self.assertEqual(out,
 
255
        self.assertEquals(out,
239
256
                ('','bzr: ERROR: No pull location known or specified.\n'))
240
257
        # test implicit --remember when no parent set, this pull conflicts
241
258
        self.build_tree(['d'])
242
259
        tree_b.add('d')
243
260
        tree_b.commit('commit d')
244
261
        out = self.run_bzr('pull ../branch_a', retcode=3)
245
 
        self.assertEqual(out,
 
262
        self.assertEquals(out,
246
263
                ('','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)
 
264
                    ' Use the merge command to reconcile them.\n'))
 
265
        self.assertEquals(branch_b.get_parent(), parent)
250
266
        # test implicit --remember after resolving previous failure
251
267
        uncommit(branch=branch_b, tree=tree_b)
252
268
        transport.delete('branch_b/d')
253
269
        self.run_bzr('pull')
254
 
        self.assertEqual(branch_b.get_parent(), parent)
 
270
        self.assertEquals(branch_b.get_parent(), parent)
255
271
        # test explicit --remember
256
272
        self.run_bzr('pull ../branch_c --remember')
257
 
        self.assertEqual(branch_b.get_parent(),
 
273
        self.assertEquals(branch_b.get_parent(),
258
274
                          branch_c.bzrdir.root_transport.base)
259
275
 
260
276
    def test_pull_bundle(self):
277
293
 
278
294
        # Create the bundle for 'b' to pull
279
295
        os.chdir('branch_a')
280
 
        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()
281
299
 
282
300
        os.chdir('../branch_b')
283
 
        out, err = self.run_bzr('pull ../bundle')
 
301
        out, err = self.run_bzr('pull', '../bundle')
284
302
        self.assertEqual(out,
285
303
                         'Now on revision 2.\n')
286
304
        self.assertEqual(err,
297
315
                             testament_b.as_text())
298
316
 
299
317
        # it is legal to attempt to pull an already-merged bundle
300
 
        out, err = self.run_bzr('pull ../bundle')
 
318
        out, err = self.run_bzr('pull', '../bundle')
301
319
        self.assertEqual(err, '')
302
320
        self.assertEqual(out, 'No revisions to pull.\n')
303
 
 
304
 
    def test_pull_verbose_no_files(self):
305
 
        """Pull --verbose should not list modified files"""
306
 
        tree_a = self.make_branch_and_tree('tree_a')
307
 
        self.build_tree(['tree_a/foo'])
308
 
        tree_a.add('foo')
309
 
        tree_a.commit('bar')
310
 
        tree_b = self.make_branch_and_tree('tree_b')
311
 
        out = self.run_bzr('pull --verbose -d tree_b tree_a')[0]
312
 
        self.assertContainsRe(out, 'bar')
313
 
        self.assertNotContainsRe(out, 'added:')
314
 
        self.assertNotContainsRe(out, 'foo')
315
 
 
316
 
    def test_pull_quiet(self):
317
 
        """Check that bzr pull --quiet does not print anything"""
318
 
        tree_a = self.make_branch_and_tree('tree_a')
319
 
        self.build_tree(['tree_a/foo'])
320
 
        tree_a.add('foo')
321
 
        revision_id = tree_a.commit('bar')
322
 
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
323
 
        out, err = self.run_bzr('pull --quiet -d tree_b')
324
 
        self.assertEqual(out, '')
325
 
        self.assertEqual(err, '')
326
 
        self.assertEqual(tree_b.last_revision(), revision_id)
327
 
        self.build_tree(['tree_a/moo'])
328
 
        tree_a.add('moo')
329
 
        revision_id = tree_a.commit('quack')
330
 
        out, err = self.run_bzr('pull --quiet -d tree_b')
331
 
        self.assertEqual(out, '')
332
 
        self.assertEqual(err, '')
333
 
        self.assertEqual(tree_b.last_revision(), revision_id)
334
 
 
335
 
    def test_pull_from_directory_service(self):
336
 
        source = self.make_branch_and_tree('source')
337
 
        source.commit('commit 1')
338
 
        target = source.bzrdir.sprout('target').open_workingtree()
339
 
        source_last = source.commit('commit 2')
340
 
        class FooService(object):
341
 
            """A directory service that always returns source"""
342
 
 
343
 
            def look_up(self, name, url):
344
 
                return 'source'
345
 
        directories.register('foo:', FooService, 'Testing directory service')
346
 
        self.addCleanup(directories.remove, 'foo:')
347
 
        self.run_bzr('pull foo:bar -d target')
348
 
        self.assertEqual(source_last, target.last_revision())
349
 
 
350
 
    def test_pull_verbose_defaults_to_long(self):
351
 
        tree = self.example_branch('source')
352
 
        target = self.make_branch_and_tree('target')
353
 
        out = self.run_bzr('pull -v source -d target')[0]
354
 
        self.assertContainsRe(out,
355
 
                              r'revno: 1\ncommitter: .*\nbranch nick: source')
356
 
        self.assertNotContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
357
 
 
358
 
    def test_pull_verbose_uses_default_log(self):
359
 
        tree = self.example_branch('source')
360
 
        target = self.make_branch_and_tree('target')
361
 
        target_config = target.branch.get_config()
362
 
        target_config.set_user_option('log_format', 'short')
363
 
        out = self.run_bzr('pull -v source -d target')[0]
364
 
        self.assertContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
365
 
        self.assertNotContainsRe(
366
 
            out, r'revno: 1\ncommitter: .*\nbranch nick: source')
367
 
 
368
 
    def test_pull_smart_stacked_streaming_acceptance(self):
369
 
        """'bzr pull -r 123' works on stacked, smart branches, even when the
370
 
        revision specified by the revno is only present in the fallback
371
 
        repository.
372
 
 
373
 
        See <https://launchpad.net/bugs/380314>
374
 
        """
375
 
        self.setup_smart_server_with_call_log()
376
 
        # Make a stacked-on branch with two commits so that the
377
 
        # revision-history can't be determined just by looking at the parent
378
 
        # field in the revision in the stacked repo.
379
 
        parent = self.make_branch_and_tree('parent', format='1.9')
380
 
        parent.commit(message='first commit')
381
 
        parent.commit(message='second commit')
382
 
        local = parent.bzrdir.sprout('local').open_workingtree()
383
 
        local.commit(message='local commit')
384
 
        local.branch.create_clone_on_transport(
385
 
            self.get_transport('stacked'), stacked_on=self.get_url('parent'))
386
 
        empty = self.make_branch_and_tree('empty', format='1.9')
387
 
        self.reset_smart_call_log()
388
 
        self.run_bzr(['pull', '-r', '1', self.get_url('stacked')],
389
 
            working_dir='empty')
390
 
        # This figure represent the amount of work to perform this use case. It
391
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
392
 
        # being too low. If rpc_count increases, more network roundtrips have
393
 
        # become necessary for this use case. Please do not adjust this number
394
 
        # upwards without agreement from bzr's network support maintainers.
395
 
        self.assertLength(18, self.hpss_calls)
396
 
        remote = Branch.open('stacked')
397
 
        self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
398
 
    
399
 
    def test_pull_cross_format_warning(self):
400
 
        """You get a warning for probably slow cross-format pulls.
401
 
        """
402
 
        # this is assumed to be going through InterDifferingSerializer
403
 
        from_tree = self.make_branch_and_tree('from', format='2a')
404
 
        to_tree = self.make_branch_and_tree('to', format='1.14-rich-root')
405
 
        from_tree.commit(message='first commit')
406
 
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
407
 
        self.assertContainsRe(err,
408
 
            "(?m)Doing on-the-fly conversion")
409
 
 
410
 
    def test_pull_cross_format_warning_no_IDS(self):
411
 
        """You get a warning for probably slow cross-format pulls.
412
 
        """
413
 
        # this simulates what would happen across the network, where
414
 
        # interdifferingserializer is not active
415
 
 
416
 
        debug.debug_flags.add('IDS_never')
417
 
        # TestCase take care of restoring them
418
 
 
419
 
        from_tree = self.make_branch_and_tree('from', format='2a')
420
 
        to_tree = self.make_branch_and_tree('to', format='1.14-rich-root')
421
 
        from_tree.commit(message='first commit')
422
 
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
423
 
        self.assertContainsRe(err,
424
 
            "(?m)Doing on-the-fly conversion")
425
 
 
426
 
    def test_pull_cross_format_from_network(self):
427
 
        self.setup_smart_server_with_call_log()
428
 
        from_tree = self.make_branch_and_tree('from', format='2a')
429
 
        to_tree = self.make_branch_and_tree('to', format='1.14-rich-root')
430
 
        self.assertIsInstance(from_tree.branch, remote.RemoteBranch)
431
 
        from_tree.commit(message='first commit')
432
 
        out, err = self.run_bzr(['pull', '-d', 'to',
433
 
            from_tree.branch.bzrdir.root_transport.base])
434
 
        self.assertContainsRe(err,
435
 
            "(?m)Doing on-the-fly conversion")
436
 
 
437
 
    def test_pull_to_experimental_format_warning(self):
438
 
        """You get a warning for pulling into experimental formats.
439
 
        """
440
 
        from_tree = self.make_branch_and_tree('from', format='development-subtree')
441
 
        to_tree = self.make_branch_and_tree('to', format='development-subtree')
442
 
        from_tree.commit(message='first commit')
443
 
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
444
 
        self.assertContainsRe(err,
445
 
            "(?m)Fetching into experimental format")
446
 
 
447
 
    def test_pull_cross_to_experimental_format_warning(self):
448
 
        """You get a warning for pulling into experimental formats.
449
 
        """
450
 
        from_tree = self.make_branch_and_tree('from', format='2a')
451
 
        to_tree = self.make_branch_and_tree('to', format='development-subtree')
452
 
        from_tree.commit(message='first commit')
453
 
        out, err = self.run_bzr(['pull', '-d', 'to', 'from'])
454
 
        self.assertContainsRe(err,
455
 
            "(?m)Fetching into experimental format")