← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_bound_branches.py

  • Committer: Jelmer Vernooij
  • Date: 2012-02-20 12:19:29 UTC
  • mfrom: (6437.23.11 2.5)
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: jelmer@samba.org-20120220121929-7ni2psvjoatm1yp4
Merge bzr/2.5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_bound_branches.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2012 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
17
17
 
18
18
"""Tests of bound branches (binding, unbinding, commit, etc) command."""
19
19
 
20
 
import os
21
 
 
22
20
from bzrlib import (
 
21
    branch,
 
22
    bzrdir,
23
23
    errors,
24
24
    tests,
25
25
    )
26
 
from bzrlib.branch import Branch
27
 
from bzrlib.bzrdir import BzrDir
28
26
from bzrlib.tests import script
29
27
 
30
28
 
42
40
        child_tree = branch.create_checkout('child')
43
41
 
44
42
        self.check_revno(1, 'child')
45
 
        d = BzrDir.open('child')
 
43
        d = bzrdir.BzrDir.open('child')
46
44
        self.assertNotEqual(None, d.open_branch().get_master_branch())
47
45
 
48
46
        return base_tree, child_tree
49
47
 
50
48
    def check_revno(self, val, loc='.'):
51
49
        self.assertEqual(
52
 
            val, len(BzrDir.open(loc).open_branch().revision_history()))
 
50
            val, bzrdir.BzrDir.open(loc).open_branch().last_revision_info()[0])
53
51
 
54
52
    def test_simple_binding(self):
55
53
        tree = self.make_branch_and_tree('base')
56
54
        self.build_tree(['base/a', 'base/b'])
57
55
        tree.add('a', 'b')
58
56
        tree.commit(message='init')
59
 
        branch = tree.branch
60
57
 
61
58
        tree.bzrdir.sprout('child')
62
59
 
63
 
        os.chdir('child')
64
 
        self.run_bzr('bind ../base')
 
60
        self.run_bzr('bind ../base', working_dir='child')
65
61
 
66
 
        d = BzrDir.open('')
 
62
        d = bzrdir.BzrDir.open('child')
67
63
        self.assertNotEqual(None, d.open_branch().get_master_branch())
68
64
 
69
 
        self.run_bzr('unbind')
 
65
        self.run_bzr('unbind', working_dir='child')
70
66
        self.assertEqual(None, d.open_branch().get_master_branch())
71
67
 
72
 
        self.run_bzr('unbind', retcode=3)
 
68
        self.run_bzr('unbind', retcode=3, working_dir='child')
73
69
 
74
70
    def test_bind_branch6(self):
75
71
        branch1 = self.make_branch('branch1', format='dirstate-tags')
76
 
        os.chdir('branch1')
77
 
        error = self.run_bzr('bind', retcode=3)[1]
78
 
        self.assertContainsRe(error, 'no previous location known')
 
72
        error = self.run_bzr('bind', retcode=3, working_dir='branch1')[1]
 
73
        self.assertEndsWith(
 
74
            error, 'No location supplied and no previous location known\n')
79
75
 
80
76
    def setup_rebind(self, format):
81
77
        branch1 = self.make_branch('branch1')
85
81
 
86
82
    def test_rebind_branch6(self):
87
83
        self.setup_rebind('dirstate-tags')
88
 
        os.chdir('branch2')
89
 
        self.run_bzr('bind')
90
 
        b = Branch.open('.')
91
 
        self.assertContainsRe(b.get_bound_location(), '\/branch1\/$')
 
84
        self.run_bzr('bind', working_dir='branch2')
 
85
        b = branch.Branch.open('branch2')
 
86
        self.assertEndsWith(b.get_bound_location(), '/branch1/')
92
87
 
93
88
    def test_rebind_branch5(self):
94
89
        self.setup_rebind('knit')
95
 
        os.chdir('branch2')
96
 
        error = self.run_bzr('bind', retcode=3)[1]
97
 
        self.assertContainsRe(error, 'old locations')
 
90
        error = self.run_bzr('bind', retcode=3, working_dir='branch2')[1]
 
91
        self.assertEndsWith(
 
92
            error, 'No location supplied.  This format does not remember'
 
93
            ' old locations.\n')
98
94
 
99
95
    def test_bound_commit(self):
100
96
        child_tree = self.create_branches()[1]
134
130
 
135
131
        child2_tree = child_tree.bzrdir.sprout('child2').open_workingtree()
136
132
 
137
 
        os.chdir('child2')
138
133
        # Double binding succeeds, but committing to child2 should fail
139
 
        self.run_bzr('bind ../child')
 
134
        self.run_bzr('bind ../child', working_dir='child2')
140
135
 
141
136
        self.assertRaises(errors.CommitToDoubleBoundBranch,
142
137
                child2_tree.commit, message='child2', allow_pointless=True)
152
147
        self.check_revno(2, 'base')
153
148
 
154
149
        self.check_revno(1, 'child')
155
 
        os.chdir('child')
156
 
        self.run_bzr("commit -m child", retcode=3)
157
 
        self.check_revno(1)
158
 
        self.run_bzr('unbind')
 
150
        self.run_bzr("commit -m child", retcode=3, working_dir='child')
 
151
        self.check_revno(1, 'child')
 
152
        self.run_bzr('unbind', working_dir='child')
159
153
        child_tree.commit(message='child')
160
 
        self.check_revno(2)
 
154
        self.check_revno(2, 'child')
161
155
 
162
156
    def test_commit_remote_bound(self):
163
157
        # It is not possible to commit to a branch
165
159
        base_tree, child_tree = self.create_branches()
166
160
        base_tree.bzrdir.sprout('newbase')
167
161
 
168
 
        os.chdir('base')
169
162
        # There is no way to know that B has already
170
163
        # been bound by someone else, otherwise it
171
164
        # might be nice if this would fail
172
 
        self.run_bzr('bind ../newbase')
 
165
        self.run_bzr('bind ../newbase', working_dir='base')
173
166
 
174
 
        os.chdir('../child')
175
 
        self.run_bzr('commit -m failure --unchanged', retcode=3)
 
167
        self.run_bzr('commit -m failure --unchanged', retcode=3,
 
168
                     working_dir='child')
176
169
 
177
170
    def test_pull_updates_both(self):
178
171
        base_tree = self.create_branches()[0]
181
174
        newchild_tree.commit(message='newchild')
182
175
        self.check_revno(2, 'newchild')
183
176
 
184
 
        os.chdir('child')
185
177
        # The pull should succeed, and update
186
178
        # the bound parent branch
187
 
        self.run_bzr('pull ../newchild')
188
 
        self.check_revno(2)
189
 
 
190
 
        self.check_revno(2, '../base')
 
179
        self.run_bzr('pull ../newchild', working_dir='child')
 
180
        self.check_revno(2, 'child')
 
181
        self.check_revno(2, 'base')
191
182
 
192
183
    def test_pull_local_updates_local(self):
193
184
        base_tree = self.create_branches()[0]
196
187
        newchild_tree.commit(message='newchild')
197
188
        self.check_revno(2, 'newchild')
198
189
 
199
 
        os.chdir('child')
200
190
        # The pull should succeed, and update
201
191
        # the bound parent branch
202
 
        self.run_bzr('pull ../newchild --local')
203
 
        self.check_revno(2)
204
 
 
205
 
        self.check_revno(1, '../base')
 
192
        self.run_bzr('pull ../newchild --local', working_dir='child')
 
193
        self.check_revno(2, 'child')
 
194
        self.check_revno(1, 'base')
206
195
 
207
196
    def test_bind_diverged(self):
208
197
        base_tree, child_tree = self.create_branches()
209
198
        base_branch = base_tree.branch
210
199
        child_branch = child_tree.branch
211
200
 
212
 
        os.chdir('child')
213
 
        self.run_bzr('unbind')
 
201
        self.run_bzr('unbind', working_dir='child')
214
202
 
215
203
        child_tree.commit(message='child', allow_pointless=True)
216
 
        self.check_revno(2)
 
204
        self.check_revno(2, 'child')
217
205
 
218
 
        os.chdir('..')
219
206
        self.check_revno(1, 'base')
220
207
        base_tree.commit(message='base', allow_pointless=True)
221
208
        self.check_revno(2, 'base')
222
209
 
223
 
        os.chdir('child')
224
210
        # These branches have diverged, but bind should succeed anyway
225
 
        self.run_bzr('bind ../base')
 
211
        self.run_bzr('bind ../base', working_dir='child')
226
212
 
227
213
        # This should turn the local commit into a merge
228
214
        child_tree.update()
229
215
        child_tree.commit(message='merged')
230
 
        self.check_revno(3)
231
 
 
232
 
        # After binding, the revision history should be unaltered
233
 
        # take a copy before
234
 
        base_history = base_branch.revision_history()
235
 
        child_history = child_branch.revision_history()
 
216
        self.check_revno(3, 'child')
 
217
        self.assertEquals(child_tree.branch.last_revision(),
 
218
                          base_tree.branch.last_revision())
236
219
 
237
220
    def test_bind_parent_ahead(self):
238
221
        base_tree = self.create_branches()[0]
239
222
 
240
 
        os.chdir('child')
241
 
        self.run_bzr('unbind')
 
223
        self.run_bzr('unbind', working_dir='child')
242
224
 
243
225
        base_tree.commit(message='base', allow_pointless=True)
244
226
 
245
 
        self.check_revno(1)
246
 
        self.run_bzr('bind ../base')
 
227
        self.check_revno(1, 'child')
 
228
        self.run_bzr('bind ../base', working_dir='child')
247
229
 
248
230
        # binding does not pull data:
249
 
        self.check_revno(1)
250
 
        self.run_bzr('unbind')
 
231
        self.check_revno(1, 'child')
 
232
        self.run_bzr('unbind', working_dir='child')
251
233
 
252
234
        # Check and make sure it also works if parent is ahead multiple
253
235
        base_tree.commit(message='base 3', allow_pointless=True)
254
236
        base_tree.commit(message='base 4', allow_pointless=True)
255
237
        base_tree.commit(message='base 5', allow_pointless=True)
256
 
        self.check_revno(5, '../base')
 
238
        self.check_revno(5, 'base')
257
239
 
258
 
        self.check_revno(1)
259
 
        self.run_bzr('bind ../base')
260
 
        self.check_revno(1)
 
240
        self.check_revno(1, 'child')
 
241
        self.run_bzr('bind ../base', working_dir='child')
 
242
        self.check_revno(1, 'child')
261
243
 
262
244
    def test_bind_child_ahead(self):
263
245
        # test binding when the master branches history is a prefix of the
265
247
        # be altered
266
248
        child_tree = self.create_branches()[1]
267
249
 
268
 
        os.chdir('child')
269
 
        self.run_bzr('unbind')
 
250
        self.run_bzr('unbind', working_dir='child')
270
251
        child_tree.commit(message='child', allow_pointless=True)
271
 
        self.check_revno(2)
272
 
        self.check_revno(1, '../base')
 
252
        self.check_revno(2, 'child')
 
253
        self.check_revno(1, 'base')
273
254
 
274
 
        self.run_bzr('bind ../base')
275
 
        self.check_revno(1, '../base')
 
255
        self.run_bzr('bind ../base', working_dir='child')
 
256
        self.check_revno(1, 'base')
276
257
 
277
258
        # Check and make sure it also works if child is ahead multiple
278
 
        self.run_bzr('unbind')
 
259
        self.run_bzr('unbind', working_dir='child')
279
260
        child_tree.commit(message='child 3', allow_pointless=True)
280
261
        child_tree.commit(message='child 4', allow_pointless=True)
281
262
        child_tree.commit(message='child 5', allow_pointless=True)
282
 
        self.check_revno(5)
 
263
        self.check_revno(5, 'child')
283
264
 
284
 
        self.check_revno(1, '../base')
285
 
        self.run_bzr('bind ../base')
286
 
        self.check_revno(1, '../base')
 
265
        self.check_revno(1, 'base')
 
266
        self.run_bzr('bind ../base', working_dir='child')
 
267
        self.check_revno(1, 'base')
287
268
 
288
269
    def test_bind_fail_if_missing(self):
289
270
        """We should not be able to bind to a missing branch."""
290
271
        tree = self.make_branch_and_tree('tree_1')
291
272
        tree.commit('dummy commit')
292
 
        self.run_bzr_error(['Not a branch.*no-such-branch/'], ['bind', '../no-such-branch'],
293
 
                            working_dir='tree_1')
 
273
        self.run_bzr_error(['Not a branch.*no-such-branch/'],
 
274
                           ['bind', '../no-such-branch'],
 
275
                           working_dir='tree_1')
294
276
        self.assertIs(None, tree.branch.get_bound_location())
295
277
 
296
 
    def test_bind_nick(self):
297
 
        """Bind should not update implicit nick."""
298
 
        base = self.make_branch_and_tree('base')
299
 
        child = self.make_branch_and_tree('child')
300
 
        os.chdir('child')
301
 
        self.assertEqual(child.branch.nick, 'child')
302
 
        self.assertEqual(child.branch.get_config().has_explicit_nickname(),
303
 
            False)
304
 
        self.run_bzr('bind ../base')
305
 
        self.assertEqual(child.branch.nick, base.branch.nick)
306
 
        self.assertEqual(child.branch.get_config().has_explicit_nickname(),
307
 
            False)
308
 
 
309
 
    def test_bind_explicit_nick(self):
310
 
        """Bind should update explicit nick."""
311
 
        base = self.make_branch_and_tree('base')
312
 
        child = self.make_branch_and_tree('child')
313
 
        os.chdir('child')
314
 
        child.branch.nick = "explicit_nick"
315
 
        self.assertEqual(child.branch.nick, "explicit_nick")
316
 
        self.assertEqual(child.branch.get_config()._get_explicit_nickname(),
317
 
            "explicit_nick")
318
 
        self.run_bzr('bind ../base')
319
 
        self.assertEqual(child.branch.nick, base.branch.nick)
320
 
        self.assertEqual(child.branch.get_config()._get_explicit_nickname(),
321
 
            base.branch.nick)
322
 
 
323
278
    def test_commit_after_merge(self):
324
279
        base_tree, child_tree = self.create_branches()
325
280
 
333
288
        self.build_tree_contents([('other/c', 'file c\n')])
334
289
        other_tree.add('c')
335
290
        other_tree.commit(message='adding c')
336
 
        new_rev_id = other_branch.revision_history()[-1]
 
291
        new_rev_id = other_branch.last_revision()
337
292
 
338
293
        child_tree.merge_from_branch(other_branch)
339
294
 
348
303
 
349
304
        # Commit should succeed, and cause merged revisions to
350
305
        # be pulled into base
351
 
        os.chdir('child')
352
 
        self.run_bzr(['commit', '-m', 'merge other'])
353
 
 
354
 
        self.check_revno(2)
355
 
 
356
 
        self.check_revno(2, '../base')
357
 
 
 
306
        self.run_bzr(['commit', '-m', 'merge other'], working_dir='child')
 
307
        self.check_revno(2, 'child')
 
308
        self.check_revno(2, 'base')
358
309
        self.assertTrue(base_tree.branch.repository.has_revision(new_rev_id))
359
310
 
360
311
    def test_pull_overwrite(self):
381
332
        self.check_revno(2, 'child')
382
333
        self.check_revno(2, 'base')
383
334
 
384
 
        os.chdir('child')
385
 
        self.run_bzr('pull --overwrite ../other')
 
335
        self.run_bzr('pull --overwrite ../other', working_dir='child')
386
336
 
387
337
        # both the local and master should have been updated.
388
 
        self.check_revno(4)
389
 
        self.check_revno(4, '../base')
 
338
        self.check_revno(4, 'child')
 
339
        self.check_revno(4, 'base')
390
340
 
391
341
    def test_bind_directory(self):
392
342
        """Test --directory option"""
397
347
        branch = tree.branch
398
348
        tree.bzrdir.sprout('child')
399
349
        self.run_bzr('bind --directory=child base')
400
 
        d = BzrDir.open('child')
 
350
        d = bzrdir.BzrDir.open('child')
401
351
        self.assertNotEqual(None, d.open_branch().get_master_branch())
402
352
        self.run_bzr('unbind -d child')
403
353
        self.assertEqual(None, d.open_branch().get_master_branch())