← 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: Canonical.com Patch Queue Manager
  • Date: 2010-07-07 21:30:06 UTC
  • mfrom: (5333.1.2 better_pyqt_include)
  • Revision ID: pqm@pqm.ubuntu.com-20100707213006-lriphkkbzwwrl7ne
(jameinel) Use a better list of PyQt includes and excludes. (Gary van der
 Merwe)

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
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
 
23
29
from bzrlib.branch import Branch
24
 
from bzrlib.tests.blackbox import ExternalBase
 
30
from bzrlib.directory_service import directories
 
31
from bzrlib.osutils import pathjoin
 
32
from bzrlib.tests import TestCaseWithTransport
25
33
from bzrlib.uncommit import uncommit
26
 
from bzrlib import urlutils
27
 
 
28
 
 
29
 
class TestPull(ExternalBase):
30
 
 
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')
 
34
from bzrlib.workingtree import WorkingTree
 
35
 
 
36
 
 
37
class TestPull(TestCaseWithTransport):
 
38
 
 
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
39
49
 
40
50
    def test_pull(self):
41
51
        """Pull changes from one branch to another."""
42
 
        os.mkdir('a')
 
52
        a_tree = self.example_branch('a')
43
53
        os.chdir('a')
44
 
 
45
 
        self.example_branch()
46
54
        self.run_bzr('pull', retcode=3)
47
55
        self.run_bzr('missing', retcode=3)
48
56
        self.run_bzr('missing .')
55
63
            self.run_bzr('pull')
56
64
 
57
65
        os.chdir('..')
58
 
        self.run_bzr('branch a b')
 
66
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
59
67
        os.chdir('b')
60
68
        self.run_bzr('pull')
61
69
        os.mkdir('subdir')
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])
 
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')
68
79
        self.run_bzr('pull ../b')
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')
 
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)
73
83
        # no overwrite
 
84
        os.chdir('../b')
74
85
        self.run_bzr('pull ../a', retcode=3)
75
86
        os.chdir('..')
76
 
        self.run_bzr('branch b overwriteme')
 
87
        b_tree.bzrdir.sprout('overwriteme')
77
88
        os.chdir('overwriteme')
78
89
        self.run_bzr('pull --overwrite ../a')
79
90
        overwritten = Branch.open('.')
80
91
        self.assertEqual(overwritten.revision_history(),
81
92
                         a.revision_history())
82
 
        os.chdir('../a')
83
 
        self.run_bzr('merge ../b')
84
 
        self.run_bzr('commit -m blah4 --unchanged')
 
93
        a_tree.merge_from_branch(b_tree.branch)
 
94
        a_tree.commit(message="blah4", allow_pointless=True)
85
95
        os.chdir('../b/subdir')
86
96
        self.run_bzr('pull ../../a')
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')
 
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)
90
101
        os.chdir('..')
91
102
        self.run_bzr('pull ../a')
92
103
        os.chdir('../a')
93
 
        self.run_bzr('commit -m blah7 --unchanged')
94
 
        self.run_bzr('merge ../b')
95
 
        self.run_bzr('commit -m blah8 --unchanged')
 
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)
96
107
        self.run_bzr('pull ../b')
97
108
        self.run_bzr('pull ../b')
98
109
 
99
110
    def test_pull_dash_d(self):
100
 
        os.mkdir('a')
101
 
        os.chdir('a')
102
 
        self.example_branch()
103
 
        self.run_bzr('init ../b')
104
 
        self.run_bzr('init ../c')
 
111
        self.example_branch('a')
 
112
        self.make_branch_and_tree('b')
 
113
        self.make_branch_and_tree('c')
105
114
        # pull into that branch
106
 
        self.run_bzr('pull -d ../b .')
 
115
        self.run_bzr('pull -d b a')
107
116
        # pull into a branch specified by a url
108
 
        c_url = urlutils.local_path_to_url('../c')
 
117
        c_url = urlutils.local_path_to_url('c')
109
118
        self.assertStartsWith(c_url, 'file://')
110
 
        self.run_bzr('pull -d %s .' % c_url)
 
119
        self.run_bzr(['pull', '-d', c_url, 'a'])
111
120
 
112
121
    def test_pull_revision(self):
113
122
        """Pull some changes from one branch to another."""
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')
 
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()
127
134
        os.chdir('b')
128
135
        self.run_bzr('pull -r 2')
129
136
        a = Branch.open('../a')
130
137
        b = Branch.open('.')
131
 
        self.assertEquals(a.revno(),4)
132
 
        self.assertEquals(b.revno(),2)
 
138
        self.assertEqual(a.revno(),4)
 
139
        self.assertEqual(b.revno(),2)
133
140
        self.run_bzr('pull -r 3')
134
 
        self.assertEquals(b.revno(),3)
 
141
        self.assertEqual(b.revno(),3)
135
142
        self.run_bzr('pull -r 4')
136
 
        self.assertEquals(a.revision_history(), b.revision_history())
 
143
        self.assertEqual(a.revision_history(), b.revision_history())
137
144
 
138
145
 
139
146
    def test_overwrite_uptodate(self):
140
147
        # Make sure pull --overwrite overwrites
141
148
        # even if the target branch has merged
142
149
        # everything already.
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)
 
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)
179
175
 
180
176
        self.assertEqual(rev_history_b, rev_history_a)
181
177
 
182
178
    def test_overwrite_children(self):
183
179
        # Make sure pull --overwrite sets the revision-history
184
180
        # to be identical to the pull source, even if we have convergence
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)
 
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)
224
206
 
225
207
        # With convergence, we could just pull over the
226
208
        # new change, but with --overwrite, we want to switch our history
227
 
        os.chdir('../b')
228
 
        bzr('pull --overwrite ../a')
229
 
        rev_history_b = get_rh(4)
 
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)
230
213
 
231
214
        self.assertEqual(rev_history_b, rev_history_a)
232
215
 
252
235
        # test pull for failure without parent set
253
236
        os.chdir('branch_b')
254
237
        out = self.run_bzr('pull', retcode=3)
255
 
        self.assertEquals(out,
 
238
        self.assertEqual(out,
256
239
                ('','bzr: ERROR: No pull location known or specified.\n'))
257
240
        # test implicit --remember when no parent set, this pull conflicts
258
241
        self.build_tree(['d'])
259
242
        tree_b.add('d')
260
243
        tree_b.commit('commit d')
261
244
        out = self.run_bzr('pull ../branch_a', retcode=3)
262
 
        self.assertEquals(out,
 
245
        self.assertEqual(out,
263
246
                ('','bzr: ERROR: These branches have diverged.'
264
 
                    ' Use the merge command to reconcile them.\n'))
265
 
        self.assertEquals(branch_b.get_parent(), parent)
 
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)
266
250
        # test implicit --remember after resolving previous failure
267
251
        uncommit(branch=branch_b, tree=tree_b)
268
252
        transport.delete('branch_b/d')
269
253
        self.run_bzr('pull')
270
 
        self.assertEquals(branch_b.get_parent(), parent)
 
254
        self.assertEqual(branch_b.get_parent(), parent)
271
255
        # test explicit --remember
272
256
        self.run_bzr('pull ../branch_c --remember')
273
 
        self.assertEquals(branch_b.get_parent(),
 
257
        self.assertEqual(branch_b.get_parent(),
274
258
                          branch_c.bzrdir.root_transport.base)
275
259
 
276
260
    def test_pull_bundle(self):
293
277
 
294
278
        # Create the bundle for 'b' to pull
295
279
        os.chdir('branch_a')
296
 
        bundle_file = open('../bundle', 'wb')
297
 
        bundle_file.write(self.run_bzr('bundle ../branch_b')[0])
298
 
        bundle_file.close()
 
280
        self.run_bzr('bundle ../branch_b -o ../bundle')
299
281
 
300
282
        os.chdir('../branch_b')
301
283
        out, err = self.run_bzr('pull ../bundle')
318
300
        out, err = self.run_bzr('pull ../bundle')
319
301
        self.assertEqual(err, '')
320
302
        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")