← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Robert Collins
  • Date: 2005-10-19 10:11:57 UTC
  • mfrom: (1185.16.78)
  • mto: This revision was merged to the branch mainline in revision 1470.
  • Revision ID: robertc@robertcollins.net-20051019101157-17438d311e746b4f
merge from upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_reconfigure.py
1
 
# Copyright (C) 2007, 2009 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
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
16
 
 
17
 
from bzrlib import (
18
 
    bzrdir,
19
 
    errors,
20
 
    tests,
21
 
    workingtree,
22
 
    )
23
 
from bzrlib.branchbuilder import BranchBuilder
24
 
 
25
 
 
26
 
class TestReconfigure(tests.TestCaseWithTransport):
27
 
 
28
 
    def test_no_type(self):
29
 
        branch = self.make_branch('branch')
30
 
        self.run_bzr_error(['No target configuration specified'],
31
 
                           'reconfigure branch')
32
 
 
33
 
    def test_branch_to_tree(self):
34
 
        branch = self.make_branch('branch')
35
 
        self.run_bzr('reconfigure --tree branch')
36
 
        tree = workingtree.WorkingTree.open('branch')
37
 
 
38
 
    def test_tree_to_branch(self):
39
 
        tree = self.make_branch_and_tree('tree')
40
 
        self.run_bzr('reconfigure --branch tree')
41
 
        self.assertRaises(errors.NoWorkingTree,
42
 
                          workingtree.WorkingTree.open, 'tree')
43
 
 
44
 
    def test_branch_to_specified_checkout(self):
45
 
        branch = self.make_branch('branch')
46
 
        parent = self.make_branch('parent')
47
 
        self.run_bzr('reconfigure branch --checkout --bind-to parent')
48
 
 
49
 
    def test_force(self):
50
 
        tree = self.make_branch_and_tree('tree')
51
 
        self.build_tree(['tree/file'])
52
 
        tree.add('file')
53
 
        self.run_bzr_error(['Working tree ".*" has uncommitted changes'],
54
 
                            'reconfigure --branch tree')
55
 
        self.run_bzr('reconfigure --force --branch tree')
56
 
 
57
 
    def test_lightweight_checkout_to_checkout(self):
58
 
        branch = self.make_branch('branch')
59
 
        checkout = branch.create_checkout('checkout', lightweight=True)
60
 
        self.run_bzr('reconfigure --checkout checkout')
61
 
 
62
 
    def test_lightweight_checkout_to_tree(self):
63
 
        branch = self.make_branch('branch')
64
 
        checkout = branch.create_checkout('checkout', lightweight=True)
65
 
        self.run_bzr('reconfigure --tree checkout')
66
 
 
67
 
    def test_no_args(self):
68
 
        branch = self.make_branch('branch')
69
 
        self.run_bzr_error(['No target configuration specified'],
70
 
                           'reconfigure', working_dir='branch')
71
 
 
72
 
    def test_checkout_to_lightweight_checkout(self):
73
 
        branch = self.make_branch('branch')
74
 
        checkout = branch.create_checkout('checkout')
75
 
        self.run_bzr('reconfigure --lightweight-checkout checkout')
76
 
 
77
 
    def test_standalone_to_use_shared(self):
78
 
        self.build_tree(['repo/'])
79
 
        tree = self.make_branch_and_tree('repo/tree')
80
 
        repo = self.make_repository('repo', shared=True)
81
 
        self.run_bzr('reconfigure --use-shared', working_dir='repo/tree')
82
 
        tree = workingtree.WorkingTree.open('repo/tree')
83
 
        self.assertNotEqual(tree.bzrdir.root_transport.base,
84
 
            tree.branch.repository.bzrdir.root_transport.base)
85
 
 
86
 
    def test_use_shared_to_standalone(self):
87
 
        repo = self.make_repository('repo', shared=True)
88
 
        branch = bzrdir.BzrDir.create_branch_convenience('repo/tree')
89
 
        self.assertNotEqual(branch.bzrdir.root_transport.base,
90
 
            branch.repository.bzrdir.root_transport.base)
91
 
        self.run_bzr('reconfigure --standalone', working_dir='repo/tree')
92
 
        tree = workingtree.WorkingTree.open('repo/tree')
93
 
        self.assertEqual(tree.bzrdir.root_transport.base,
94
 
            tree.branch.repository.bzrdir.root_transport.base)
95
 
 
96
 
    def test_make_with_trees(self):
97
 
        repo = self.make_repository('repo', shared=True)
98
 
        repo.set_make_working_trees(False)
99
 
        self.run_bzr('reconfigure --with-trees', working_dir='repo')
100
 
        self.assertIs(True, repo.make_working_trees())
101
 
 
102
 
    def test_make_with_trees_already_trees(self):
103
 
        repo = self.make_repository('repo', shared=True)
104
 
        repo.set_make_working_trees(True)
105
 
        self.run_bzr_error([" already creates working trees"],
106
 
                            'reconfigure --with-trees repo')
107
 
 
108
 
    def test_make_without_trees(self):
109
 
        repo = self.make_repository('repo', shared=True)
110
 
        repo.set_make_working_trees(True)
111
 
        self.run_bzr('reconfigure --with-no-trees', working_dir='repo')
112
 
        self.assertIs(False, repo.make_working_trees())
113
 
 
114
 
    def test_make_without_trees_already_no_trees(self):
115
 
        repo = self.make_repository('repo', shared=True)
116
 
        repo.set_make_working_trees(False)
117
 
        self.run_bzr_error([" already doesn't create working trees"],
118
 
                            'reconfigure --with-no-trees repo')
119
 
 
120
 
    def test_make_with_trees_nonshared_repo(self):
121
 
        branch = self.make_branch('branch')
122
 
        self.run_bzr_error(
123
 
            ["Requested reconfiguration of '.*' is not supported"],
124
 
            'reconfigure --with-trees branch')
125
 
 
126
 
    def test_make_without_trees_leaves_tree_alone(self):
127
 
        repo = self.make_repository('repo', shared=True)
128
 
        branch = bzrdir.BzrDir.create_branch_convenience('repo/branch')
129
 
        tree = workingtree.WorkingTree.open('repo/branch')
130
 
        self.build_tree(['repo/branch/foo'])
131
 
        tree.add('foo')
132
 
        self.run_bzr('reconfigure --with-no-trees --force',
133
 
            working_dir='repo/branch')
134
 
        self.failUnlessExists('repo/branch/foo')
135
 
        tree = workingtree.WorkingTree.open('repo/branch')
136
 
 
137
 
    def test_shared_format_to_standalone(self, format=None):
138
 
        repo = self.make_repository('repo', shared=True, format=format)
139
 
        branch = bzrdir.BzrDir.create_branch_convenience('repo/tree')
140
 
        self.assertNotEqual(branch.bzrdir.root_transport.base,
141
 
            branch.repository.bzrdir.root_transport.base)
142
 
        tree = workingtree.WorkingTree.open('repo/tree')
143
 
        self.build_tree_contents([('repo/tree/file', 'foo\n')]);
144
 
        tree.add(['file'])
145
 
        tree.commit('added file')
146
 
        self.run_bzr('reconfigure --standalone', working_dir='repo/tree')
147
 
        tree = workingtree.WorkingTree.open('repo/tree')
148
 
        self.build_tree_contents([('repo/tree/file', 'bar\n')]);
149
 
        self.check_file_contents('repo/tree/file', 'bar\n')
150
 
        self.run_bzr('revert', working_dir='repo/tree')
151
 
        self.check_file_contents('repo/tree/file', 'foo\n')
152
 
        self.assertEqual(tree.bzrdir.root_transport.base,
153
 
            tree.branch.repository.bzrdir.root_transport.base)
154
 
 
155
 
    def test_shared_knit_to_standalone(self):
156
 
        self.test_shared_format_to_standalone('knit')
157
 
 
158
 
    def test_shared_pack092_to_standalone(self):
159
 
        self.test_shared_format_to_standalone('pack-0.92')
160
 
 
161
 
    def test_shared_rich_root_pack_to_standalone(self):
162
 
        self.test_shared_format_to_standalone('rich-root-pack')
163
 
 
164
 
    def test_lightweight_format_checkout_to_tree(self, format=None):
165
 
        branch = self.make_branch('branch', format=format)
166
 
        checkout = branch.create_checkout('checkout', lightweight=True)
167
 
        tree = workingtree.WorkingTree.open('checkout')
168
 
        self.build_tree_contents([('checkout/file', 'foo\n')]);
169
 
        tree.add(['file'])
170
 
        tree.commit('added file')
171
 
        self.run_bzr('reconfigure --tree', working_dir='checkout')
172
 
        tree = workingtree.WorkingTree.open('checkout')
173
 
        self.build_tree_contents([('checkout/file', 'bar\n')]);
174
 
        self.check_file_contents('checkout/file', 'bar\n')
175
 
        self.run_bzr('revert', working_dir='checkout')
176
 
        self.check_file_contents('checkout/file', 'foo\n')
177
 
 
178
 
    def test_lightweight_knit_checkout_to_tree(self, format=None):
179
 
        self.test_lightweight_format_checkout_to_tree('knit')
180
 
 
181
 
    def test_lightweight_pack092_checkout_to_tree(self, format=None):
182
 
        self.test_lightweight_format_checkout_to_tree('pack-0.92')
183
 
 
184
 
    def test_lightweight_rich_root_pack_checkout_to_tree(self, format=None):
185
 
        self.test_lightweight_format_checkout_to_tree('rich-root-pack')
186
 
 
187
 
 
188
 
class TestReconfigureStacking(tests.TestCaseWithTransport):
189
 
 
190
 
    def test_reconfigure_stacking(self):
191
 
        """Test a fairly realistic scenario for stacking:
192
 
 
193
 
         * make a branch with some history
194
 
         * branch it
195
 
         * make the second branch stacked on the first
196
 
         * commit in the second
197
 
         * then make the second unstacked, so it has to fill in history from
198
 
           the original fallback lying underneath its original content
199
 
 
200
 
        See discussion in <https://bugs.launchpad.net/bzr/+bug/391411>
201
 
        """
202
 
        # there are also per_branch tests that exercise remote operation etc
203
 
        tree_1 = self.make_branch_and_tree('b1', format='2a')
204
 
        self.build_tree(['b1/foo'])
205
 
        tree_1.add(['foo'])
206
 
        tree_1.commit('add foo')
207
 
        branch_1 = tree_1.branch
208
 
        # now branch and commit again
209
 
        bzrdir_2 = tree_1.bzrdir.sprout('b2')
210
 
        tree_2 = bzrdir_2.open_workingtree()
211
 
        branch_2 = tree_2.branch
212
 
        # now reconfigure to be stacked
213
 
        out, err = self.run_bzr('reconfigure --stacked-on b1 b2')
214
 
        self.assertContainsRe(out,
215
 
            '^.*/b2/ is now stacked on ../b1\n$')
216
 
        self.assertEquals('', err)
217
 
        # can also give the absolute URL of the branch, and it gets stored 
218
 
        # as a relative path if possible
219
 
        out, err = self.run_bzr('reconfigure --stacked-on %s b2'
220
 
            % (self.get_url('b1'),))
221
 
        self.assertContainsRe(out,
222
 
            '^.*/b2/ is now stacked on ../b1\n$')
223
 
        self.assertEquals('', err)
224
 
        # It should be given a relative URL to the destination, if possible,
225
 
        # because that's most likely to work across different transports
226
 
        self.assertEquals(branch_2.get_stacked_on_url(),
227
 
            '../b1')
228
 
        # commit, and it should be stored into b2's repo
229
 
        self.build_tree_contents([('foo', 'new foo')])
230
 
        tree_2.commit('update foo')
231
 
        # Now turn it off again
232
 
        out, err = self.run_bzr('reconfigure --unstacked b2')
233
 
        self.assertContainsRe(out,
234
 
            '^.*/b2/ is now not stacked\n$')
235
 
        self.assertEquals('', err)
236
 
        self.assertRaises(errors.NotStacked,
237
 
            branch_2.get_stacked_on_url)
238
 
 
239
 
    # XXX: Needs a test for reconfiguring stacking and shape at the same time;
240
 
    # no branch at location; stacked-on is not a branch; quiet mode.
241
 
    # -- mbp 20090706