← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_branch/test_stacking.py

  • Committer: Andrew Bennetts
  • Date: 2010-01-12 03:53:21 UTC
  • mfrom: (4948 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4964.
  • Revision ID: andrew.bennetts@canonical.com-20100112035321-hofpz5p10224ryj3
Merge lp:bzr, resolving conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/per_branch/test_stacking.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., 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
"""Tests for Branch.get_stacked_on_url and set_stacked_on_url."""
18
18
 
19
19
from bzrlib import (
20
20
    branch,
21
21
    bzrdir,
 
22
    check,
22
23
    errors,
23
24
    )
24
25
from bzrlib.revision import NULL_REVISION
25
26
from bzrlib.smart import server
26
27
from bzrlib.tests import TestNotApplicable, KnownFailure, transport_util
27
 
from bzrlib.tests.branch_implementations import TestCaseWithBranch
 
28
from bzrlib.tests.per_branch import TestCaseWithBranch
28
29
from bzrlib.transport import get_transport
29
30
 
30
31
 
58
59
        except unstackable_format_errors:
59
60
            # if the set failed, so must the get
60
61
            self.assertRaises(unstackable_format_errors, branch.get_stacked_on_url)
 
62
            self.assertFalse(branch._format.supports_stacking())
61
63
            return
 
64
        self.assertTrue(branch._format.supports_stacking())
62
65
        # now we have a stacked branch:
63
66
        self.assertEqual(target.base, branch.get_stacked_on_url())
64
67
        branch.set_stacked_on_url(None)
76
79
            return
77
80
        self.assertEqual('../target', branch.get_stacked_on_url())
78
81
 
 
82
    def test_set_stacked_on_same_branch_raises(self):
 
83
        # Stacking on the same branch silently raises and doesn't execute the
 
84
        # change. Reported in bug 376243.
 
85
        branch = self.make_branch('branch')
 
86
        try:
 
87
            self.assertRaises(errors.UnstackableLocationError,
 
88
                branch.set_stacked_on_url, '../branch')
 
89
        except unstackable_format_errors:
 
90
            # if the set failed, so must the get
 
91
            self.assertRaises(unstackable_format_errors, branch.get_stacked_on_url)
 
92
            return
 
93
        self.assertRaises(errors.NotStacked, branch.get_stacked_on_url)
 
94
 
 
95
    def test_set_stacked_on_same_branch_after_being_stacked_raises(self):
 
96
        # Stacking on the same branch silently raises and doesn't execute the
 
97
        # change.
 
98
        branch = self.make_branch('branch')
 
99
        target = self.make_branch('target')
 
100
        try:
 
101
            branch.set_stacked_on_url('../target')
 
102
        except unstackable_format_errors:
 
103
            # if the set failed, so must the get
 
104
            self.assertRaises(unstackable_format_errors, branch.get_stacked_on_url)
 
105
            return
 
106
        self.assertRaises(errors.UnstackableLocationError,
 
107
            branch.set_stacked_on_url, '../branch')
 
108
        self.assertEqual('../target', branch.get_stacked_on_url())
 
109
 
79
110
    def assertRevisionInRepository(self, repo_path, revid):
80
111
        """Check that a revision is in a repository, disregarding stacking."""
81
112
        repo = bzrdir.BzrDir.open(repo_path).open_repository()
119
150
            raise TestNotApplicable(e)
120
151
        # stacked repository
121
152
        self.assertRevisionNotInRepository('newbranch', trunk_revid)
122
 
        new_tree = new_dir.open_workingtree()
123
 
        new_branch_revid = new_tree.commit('something local')
 
153
        tree = new_dir.open_branch().create_checkout('local')
 
154
        new_branch_revid = tree.commit('something local')
124
155
        self.assertRevisionNotInRepository('mainline', new_branch_revid)
125
156
        self.assertRevisionInRepository('newbranch', new_branch_revid)
126
157
 
127
 
    # XXX: this helper probably belongs on TestCaseWithTransport
128
 
    def make_smart_server(self, path):
129
 
        smart_server = server.SmartTCPServer_for_testing()
130
 
        smart_server.setUp(self.get_server())
131
 
        remote_transport = get_transport(smart_server.get_url()).clone(path)
132
 
        self.addCleanup(smart_server.tearDown)
133
 
        return remote_transport
134
 
 
135
158
    def test_sprout_stacked_from_smart_server(self):
136
159
        if isinstance(self.branch_format, branch.BzrBranchFormat4):
137
160
            raise TestNotApplicable('Branch format 4 is not usable via HPSS.')
150
173
        new_dir = remote_bzrdir.sprout('newbranch', stacked=True)
151
174
        # stacked repository
152
175
        self.assertRevisionNotInRepository('newbranch', trunk_revid)
153
 
        new_tree = new_dir.open_workingtree()
154
 
        new_branch_revid = new_tree.commit('something local')
 
176
        tree = new_dir.open_branch().create_checkout('local')
 
177
        new_branch_revid = tree.commit('something local')
155
178
        self.assertRevisionNotInRepository('mainline', new_branch_revid)
156
179
        self.assertRevisionInRepository('newbranch', new_branch_revid)
157
180
 
162
185
        trunk_revid = trunk_tree.commit('revision on mainline')
163
186
        # and make branch from it which is stacked
164
187
        try:
165
 
            new_dir = trunk_tree.bzrdir.sprout('newbranch', stacked=True)
 
188
            new_dir = trunk_tree.bzrdir.sprout(self.get_url('newbranch'),
 
189
                stacked=True)
166
190
        except unstackable_format_errors, e:
167
191
            raise TestNotApplicable(e)
168
192
        # stacked repository
169
193
        self.assertRevisionNotInRepository('newbranch', trunk_revid)
 
194
        # TODO: we'd like to commit in the stacked repository; that requires
 
195
        # some care (maybe a BranchBuilder) if it's remote and has no
 
196
        # workingtree
 
197
        ##newbranch_revid = new_dir.open_workingtree().commit('revision in '
 
198
            ##'newbranch')
170
199
        # now when we unstack that should implicitly fetch, to make sure that
171
200
        # the branch will still work
172
201
        new_branch = new_dir.open_branch()
245
274
        self.assertRaises((errors.NotStacked, errors.UnstackableBranchFormat),
246
275
                          cloned_bzrdir.open_branch().get_stacked_on_url)
247
276
 
 
277
    def make_stacked_on_matching(self, source):
 
278
        if source.repository.supports_rich_root():
 
279
            if source.repository._format.supports_chks:
 
280
                format = "2a"
 
281
            else:
 
282
                format = "1.9-rich-root"
 
283
        else:
 
284
            format = "1.9"
 
285
        return self.make_branch('stack-on', format)
 
286
 
248
287
    def test_sprout_stacking_policy_handling(self):
249
288
        """Obey policy where possible, ignore otherwise."""
250
 
        stack_on = self.make_branch('stack-on')
 
289
        if isinstance(self.branch_format, branch.BzrBranchFormat4):
 
290
            raise TestNotApplicable('Branch format 4 does not autoupgrade.')
 
291
        source = self.make_branch('source')
 
292
        stack_on = self.make_stacked_on_matching(source)
251
293
        parent_bzrdir = self.make_bzrdir('.', format='default')
252
294
        parent_bzrdir.get_config().set_default_stack_on('stack-on')
253
 
        source = self.make_branch('source')
254
295
        target = source.bzrdir.sprout('target').open_branch()
255
 
        try:
 
296
        # When we sprout we upgrade the branch when there is a default stack_on
 
297
        # set by a config *and* the targeted branch supports stacking.
 
298
        if stack_on._format.supports_stacking():
256
299
            self.assertEqual('../stack-on', target.get_stacked_on_url())
257
 
        except errors.UnstackableBranchFormat:
258
 
            pass
 
300
        else:
 
301
            self.assertRaises(
 
302
                errors.UnstackableBranchFormat, target.get_stacked_on_url)
259
303
 
260
304
    def test_clone_stacking_policy_handling(self):
261
305
        """Obey policy where possible, ignore otherwise."""
262
 
        stack_on = self.make_branch('stack-on')
 
306
        if isinstance(self.branch_format, branch.BzrBranchFormat4):
 
307
            raise TestNotApplicable('Branch format 4 does not autoupgrade.')
 
308
        source = self.make_branch('source')
 
309
        stack_on = self.make_stacked_on_matching(source)
263
310
        parent_bzrdir = self.make_bzrdir('.', format='default')
264
311
        parent_bzrdir.get_config().set_default_stack_on('stack-on')
265
 
        source = self.make_branch('source')
266
312
        target = source.bzrdir.clone('target').open_branch()
267
 
        try:
268
 
            self.assertEqual('../stack-on', target.get_stacked_on_url())
269
 
        except errors.UnstackableBranchFormat:
270
 
            pass
 
313
        # When we clone we upgrade the branch when there is a default stack_on
 
314
        # set by a config *and* the targeted branch supports stacking.
 
315
        if stack_on._format.supports_stacking():
 
316
            self.assertEqual('../stack-on', target.get_stacked_on_url())
 
317
        else:
 
318
            self.assertRaises(
 
319
                errors.UnstackableBranchFormat, target.get_stacked_on_url)
 
320
 
 
321
    def test_sprout_to_smart_server_stacking_policy_handling(self):
 
322
        """Obey policy where possible, ignore otherwise."""
 
323
        if isinstance(self.branch_format, branch.BzrBranchFormat4):
 
324
            raise TestNotApplicable('Branch format 4 is not usable via HPSS.')
 
325
        source = self.make_branch('source')
 
326
        stack_on = self.make_stacked_on_matching(source)
 
327
        parent_bzrdir = self.make_bzrdir('.', format='default')
 
328
        parent_bzrdir.get_config().set_default_stack_on('stack-on')
 
329
        url = self.make_smart_server('target').base
 
330
        target = source.bzrdir.sprout(url).open_branch()
 
331
        # When we sprout we upgrade the branch when there is a default stack_on
 
332
        # set by a config *and* the targeted branch supports stacking.
 
333
        if stack_on._format.supports_stacking():
 
334
            self.assertEqual('../stack-on', target.get_stacked_on_url())
 
335
        else:
 
336
            self.assertRaises(
 
337
                errors.UnstackableBranchFormat, target.get_stacked_on_url)
271
338
 
272
339
    def prepare_stacked_on_fetch(self):
273
340
        stack_on = self.make_branch_and_tree('stack-on')
286
353
 
287
354
    def test_fetch_copies_from_stacked_on_and_stacked(self):
288
355
        stacked, unstacked = self.prepare_stacked_on_fetch()
289
 
        stacked.commit('second commit', rev_id='rev2')
 
356
        tree = stacked.branch.create_checkout('local')
 
357
        tree.commit('second commit', rev_id='rev2')
290
358
        unstacked.fetch(stacked.branch.repository, 'rev2')
291
359
        unstacked.get_revision('rev1')
292
360
        unstacked.get_revision('rev2')
299
367
        # repository boundaries.  however, i didn't actually get this test to
300
368
        # fail on that code. -- mbp
301
369
        # see https://bugs.launchpad.net/bzr/+bug/252821
302
 
        if not self.branch_format.supports_stacking():
 
370
        stack_on = self.make_branch_and_tree('stack-on')
 
371
        if not stack_on.branch._format.supports_stacking():
303
372
            raise TestNotApplicable("%r does not support stacking"
304
373
                % self.branch_format)
305
 
        stack_on = self.make_branch_and_tree('stack-on')
306
374
        text_lines = ['line %d blah blah blah\n' % i for i in range(20)]
307
375
        self.build_tree_contents([('stack-on/a', ''.join(text_lines))])
308
376
        stack_on.add('a')
309
377
        stack_on.commit('base commit')
310
378
        stacked_dir = stack_on.bzrdir.sprout('stacked', stacked=True)
311
 
        stacked_tree = stacked_dir.open_workingtree()
 
379
        stacked_branch = stacked_dir.open_branch()
 
380
        local_tree = stack_on.bzrdir.sprout('local').open_workingtree()
312
381
        for i in range(20):
313
382
            text_lines[0] = 'changed in %d\n' % i
314
 
            self.build_tree_contents([('stacked/a', ''.join(text_lines))])
315
 
            stacked_tree.commit('commit %d' % i)
316
 
        stacked_tree.branch.repository.pack()
317
 
        stacked_tree.branch.check()
 
383
            self.build_tree_contents([('local/a', ''.join(text_lines))])
 
384
            local_tree.commit('commit %d' % i)
 
385
            local_tree.branch.push(stacked_branch)
 
386
        stacked_branch.repository.pack()
 
387
        check.check_dwim(stacked_branch.base, False, True, True)
318
388
 
319
389
    def test_pull_delta_when_stacked(self):
320
390
        if not self.branch_format.supports_stacking():
338
408
        # bug 252821 caused a RevisionNotPresent here...
339
409
        stacked_tree.pull(other_tree.branch)
340
410
        stacked_tree.branch.repository.pack()
341
 
        stacked_tree.branch.check()
 
411
        check.check_dwim(stacked_tree.branch.base, False, True, True)
342
412
        self.check_lines_added_or_present(stacked_tree.branch, stacked_revid)
343
413
 
344
414
    def test_fetch_revisions_with_file_changes(self):
409
479
        # Ensure that opening the branch doesn't raise.
410
480
        branch.Branch.open(transport.base)
411
481
 
 
482
    def test_revision_history_of_stacked(self):
 
483
        # See <https://launchpad.net/bugs/380314>.
 
484
        stack_on = self.make_branch_and_tree('stack-on')
 
485
        stack_on.commit('first commit', rev_id='rev1')
 
486
        try:
 
487
            stacked_dir = stack_on.bzrdir.sprout(
 
488
                self.get_url('stacked'), stacked=True)
 
489
        except unstackable_format_errors, e:
 
490
            raise TestNotApplicable('Format does not support stacking.')
 
491
        try:
 
492
            stacked = stacked_dir.open_workingtree()
 
493
        except errors.NoWorkingTree:
 
494
            stacked = stacked_dir.open_branch().create_checkout(
 
495
                'stacked-checkout', lightweight=True)
 
496
        tree = stacked.branch.create_checkout('local')
 
497
        tree.commit('second commit', rev_id='rev2')
 
498
        # Sanity check: stacked's repo should not contain rev1, otherwise this
 
499
        # test isn't testing what it's supposed to.
 
500
        repo = stacked.branch.repository.bzrdir.open_repository()
 
501
        repo.lock_read()
 
502
        self.addCleanup(repo.unlock)
 
503
        self.assertEqual({}, repo.get_parent_map(['rev1']))
 
504
        # revision_history should work, even though the history is spread over
 
505
        # multiple repositories.
 
506
        self.assertLength(2, stacked.branch.revision_history())
 
507
 
412
508
 
413
509
class TestStackingConnections(
414
510
    transport_util.TestCaseWithConnectionHookedTransport):