/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

merge bzr.dev r3564

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_branch.py
19
19
 
20
20
import os
21
21
 
22
 
from bzrlib import branch, bzrdir
 
22
from bzrlib import (branch, bzrdir, errors, repository)
23
23
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1
24
24
from bzrlib.tests.blackbox import ExternalBase
25
25
from bzrlib.tests import HardlinkFeature
45
45
        b = branch.Branch.open('b')
46
46
        self.run_bzr('branch a c -r 1')
47
47
        # previously was erroneously created by branching
48
 
        self.assertFalse(b.control_files._transport.has('branch-name'))
 
48
        self.assertFalse(b._transport.has('branch-name'))
49
49
        b.bzrdir.open_workingtree().commit(message='foo', allow_pointless=True)
50
50
 
51
51
    def test_branch_only_copies_history(self):
97
97
        target_stat = os.stat('target/file1')
98
98
        self.assertEqual(source_stat, target_stat)
99
99
 
 
100
    def check_shallow_branch(self, branch_revid, stacked_on):
 
101
        """Assert that the branch 'newbranch' has been published correctly.
 
102
        
 
103
        :param stacked_on: url of a branch this one is stacked upon.
 
104
        :param branch_revid: a revision id that should be the only 
 
105
            revision present in the stacked branch, and it should not be in
 
106
            the reference branch.
 
107
        """
 
108
        new_branch = branch.Branch.open('newbranch')
 
109
        # The branch refers to the mainline
 
110
        self.assertEqual(stacked_on, new_branch.get_stacked_on_url())
 
111
        # and the branch's work was pushed
 
112
        self.assertTrue(new_branch.repository.has_revision(branch_revid))
 
113
        # The newly committed revision shoud be present in the stacked branch,
 
114
        # but not in the stacked-on branch.  Because stacking is set up by the
 
115
        # branch object, if we open the stacked branch's repository directly,
 
116
        # bypassing the branch, we see only what's in the stacked repository.
 
117
        stacked_repo = bzrdir.BzrDir.open('newbranch').open_repository()
 
118
        stacked_repo_revisions = set(stacked_repo.all_revision_ids())
 
119
        if len(stacked_repo_revisions) != 1:
 
120
            self.fail("wrong revisions in stacked repository: %r"
 
121
                % (stacked_repo_revisions,))
 
122
 
 
123
    def assertRevisionInRepository(self, repo_path, revid):
 
124
        """Check that a revision is in a repository, disregarding stacking."""
 
125
        repo = bzrdir.BzrDir.open(repo_path).open_repository()
 
126
        self.assertTrue(repo.has_revision(revid))
 
127
 
 
128
    def assertRevisionNotInRepository(self, repo_path, revid):
 
129
        """Check that a revision is not in a repository, disregarding stacking."""
 
130
        repo = bzrdir.BzrDir.open(repo_path).open_repository()
 
131
        self.assertFalse(repo.has_revision(revid))
 
132
 
 
133
    def assertRevisionsInBranchRepository(self, revid_list, branch_path):
 
134
        repo = branch.Branch.open(branch_path).repository
 
135
        self.assertEqual(set(revid_list),
 
136
            repo.has_revisions(revid_list))
 
137
 
 
138
    def test_branch_stacked_branch_not_stacked(self):
 
139
        """Branching a stacked branch is not stacked by default"""
 
140
        # We have a mainline
 
141
        trunk_tree = self.make_branch_and_tree('target',
 
142
            format='development')
 
143
        trunk_tree.commit('mainline')
 
144
        # and a branch from it which is stacked
 
145
        branch_tree = self.make_branch_and_tree('branch',
 
146
            format='development')
 
147
        branch_tree.branch.set_stacked_on_url(trunk_tree.branch.base)
 
148
        # with some work on it
 
149
        branch_tree.commit('moar work plz')
 
150
        # branching our local branch gives us a new stacked branch pointing at
 
151
        # mainline.
 
152
        out, err = self.run_bzr(['branch', 'branch', 'newbranch'])
 
153
        self.assertEqual('', out)
 
154
        self.assertEqual('Branched 1 revision(s).\n',
 
155
            err)
 
156
        self.assertRaises(errors.NotStacked,
 
157
            bzrdir.BzrDir.open('newbranch').open_branch().get_stacked_on_url)
 
158
 
 
159
    def test_branch_stacked_branch_stacked(self):
 
160
        """Asking to stack on a stacked branch does work"""
 
161
        # We have a mainline
 
162
        trunk_tree = self.make_branch_and_tree('target',
 
163
            format='development')
 
164
        trunk_revid = trunk_tree.commit('mainline')
 
165
        # and a branch from it which is stacked
 
166
        branch_tree = self.make_branch_and_tree('branch',
 
167
            format='development')
 
168
        branch_tree.branch.set_stacked_on_url(trunk_tree.branch.base)
 
169
        # with some work on it
 
170
        branch_revid = branch_tree.commit('moar work plz')
 
171
        # you can chain branches on from there
 
172
        out, err = self.run_bzr(['branch', 'branch', '--stacked', 'branch2'])
 
173
        self.assertEqual('', out)
 
174
        self.assertEqual('Created new stacked branch referring to %s.\n' %
 
175
            branch_tree.branch.base, err)
 
176
        self.assertEqual(branch_tree.branch.base,
 
177
            branch.Branch.open('branch2').get_stacked_on_url())
 
178
        branch2_tree = WorkingTree.open('branch2')
 
179
        branch2_revid = branch2_tree.commit('work on second stacked branch')
 
180
        self.assertRevisionInRepository('branch2', branch2_revid)
 
181
        self.assertRevisionsInBranchRepository(
 
182
            [trunk_revid, branch_revid, branch2_revid],
 
183
            'branch2')
 
184
 
 
185
    def test_branch_stacked(self):
 
186
        # We have a mainline
 
187
        trunk_tree = self.make_branch_and_tree('mainline',
 
188
            format='development')
 
189
        original_revid = trunk_tree.commit('mainline')
 
190
        self.assertRevisionInRepository('mainline', original_revid)
 
191
        # and a branch from it which is stacked
 
192
        out, err = self.run_bzr(['branch', '--stacked', 'mainline',
 
193
            'newbranch'])
 
194
        self.assertEqual('', out)
 
195
        self.assertEqual('Created new stacked branch referring to %s.\n' %
 
196
            trunk_tree.branch.base, err)
 
197
        self.assertRevisionNotInRepository('newbranch', original_revid)
 
198
        new_tree = WorkingTree.open('newbranch')
 
199
        new_revid = new_tree.commit('new work')
 
200
        self.check_shallow_branch(new_revid, trunk_tree.branch.base)
 
201
 
 
202
    def test_branch_stacked_from_smart_server(self):
 
203
        # We can branch stacking on a smart server
 
204
        from bzrlib.smart.server import SmartTCPServer_for_testing
 
205
        self.transport_server = SmartTCPServer_for_testing
 
206
        trunk = self.make_branch('mainline', format='development')
 
207
        out, err = self.run_bzr(
 
208
            ['branch', '--stacked', self.get_url('mainline'), 'shallow'])
 
209
 
100
210
 
101
211
class TestRemoteBranch(TestCaseWithSFTPServer):
102
212