/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_init.py

  • Committer: Vincent Ladeuil
  • Date: 2012-01-18 14:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120118140919-rlvdrhpc0nq1lbwi
Change set/remove to require a lock for the branch config files.

This means that tests (or any plugin for that matter) do not requires an
explicit lock on the branch anymore to change a single option. This also
means the optimisation becomes "opt-in" and as such won't be as
spectacular as it may be and/or harder to get right (nothing fails
anymore).

This reduces the diff by ~300 lines.

Code/tests that were updating more than one config option is still taking
a lock to at least avoid some IOs and demonstrate the benefits through
the decreased number of hpss calls.

The duplication between BranchStack and BranchOnlyStack will be removed
once the same sharing is in place for local config files, at which point
the Stack class itself may be able to host the changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_init.py
 
1
# Copyright (C) 2006-2011 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
 
 
18
"""Test 'bzr init'"""
 
19
 
 
20
import os
 
21
import re
 
22
 
 
23
from bzrlib import (
 
24
    branch as _mod_branch,
 
25
    config as _mod_config,
 
26
    osutils,
 
27
    urlutils,
 
28
    )
 
29
from bzrlib.bzrdir import BzrDirMetaFormat1
 
30
from bzrlib.tests import TestSkipped
 
31
from bzrlib.tests import TestCaseWithTransport
 
32
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
 
33
from bzrlib.workingtree import WorkingTree
 
34
 
 
35
 
 
36
class TestInit(TestCaseWithTransport):
 
37
 
 
38
    def setUp(self):
 
39
        TestCaseWithTransport.setUp(self)
 
40
        self._default_label = '2a'
 
41
 
 
42
    def test_init_with_format(self):
 
43
        # Verify bzr init --format constructs something plausible
 
44
        t = self.get_transport()
 
45
        self.run_bzr('init --format default')
 
46
        self.assertIsDirectory('.bzr', t)
 
47
        self.assertIsDirectory('.bzr/checkout', t)
 
48
        self.assertIsDirectory('.bzr/checkout/lock', t)
 
49
 
 
50
    def test_init_format_2a(self):
 
51
        """Smoke test for constructing a format 2a repository."""
 
52
        out, err = self.run_bzr('init --format=2a')
 
53
        self.assertEqual("""Created a standalone tree (format: 2a)\n""",
 
54
            out)
 
55
        self.assertEqual('', err)
 
56
 
 
57
    def test_init_colocated(self):
 
58
        """Smoke test for constructing a colocated branch."""
 
59
        out, err = self.run_bzr('init --format=development-colo file:,branch=abranch')
 
60
        self.assertEqual("""Created a lightweight checkout (format: development-colo)\n""",
 
61
            out)
 
62
        self.assertEqual('', err)
 
63
        out, err = self.run_bzr('branches')
 
64
        self.assertEqual("  abranch\n", out)
 
65
        self.assertEqual('', err)
 
66
 
 
67
    def test_init_at_repository_root(self):
 
68
        # bzr init at the root of a repository should create a branch
 
69
        # and working tree even when creation of working trees is disabled.
 
70
        t = self.get_transport()
 
71
        t.mkdir('repo')
 
72
        format = BzrDirMetaFormat1()
 
73
        newdir = format.initialize(t.abspath('repo'))
 
74
        repo = newdir.create_repository(shared=True)
 
75
        repo.set_make_working_trees(False)
 
76
        out, err = self.run_bzr('init repo')
 
77
        self.assertEqual("""Created a repository tree (format: %s)
 
78
Using shared repository: %s
 
79
""" % (self._default_label, urlutils.local_path_from_url(
 
80
            repo.bzrdir.root_transport.external_url())), out)
 
81
        cwd = osutils.getcwd()
 
82
        self.assertEndsWith(out, cwd + '/repo/\n')
 
83
        self.assertEqual('', err)
 
84
        newdir.open_branch()
 
85
        newdir.open_workingtree()
 
86
 
 
87
    def test_init_branch(self):
 
88
        out, err = self.run_bzr('init')
 
89
        self.assertEqual("Created a standalone tree (format: %s)\n" % (
 
90
            self._default_label,), out)
 
91
        self.assertEqual('', err)
 
92
 
 
93
        # Can it handle subdirectories of branches too ?
 
94
        out, err = self.run_bzr('init subdir1')
 
95
        self.assertEqual("Created a standalone tree (format: %s)\n" % (
 
96
            self._default_label,), out)
 
97
        self.assertEqual('', err)
 
98
        WorkingTree.open('subdir1')
 
99
 
 
100
        self.run_bzr_error(['Parent directory of subdir2/nothere does not exist'],
 
101
                            'init subdir2/nothere')
 
102
        out, err = self.run_bzr('init subdir2/nothere', retcode=3)
 
103
        self.assertEqual('', out)
 
104
 
 
105
        os.mkdir('subdir2')
 
106
        out, err = self.run_bzr('init subdir2')
 
107
        self.assertEqual("Created a standalone tree (format: %s)\n" % (
 
108
            self._default_label,), out)
 
109
        self.assertEqual('', err)
 
110
        # init an existing branch.
 
111
        out, err = self.run_bzr('init subdir2', retcode=3)
 
112
        self.assertEqual('', out)
 
113
        self.assertTrue(err.startswith('bzr: ERROR: Already a branch:'))
 
114
 
 
115
    def test_init_branch_quiet(self):
 
116
        out, err = self.run_bzr('init -q')
 
117
        self.assertEqual('', out)
 
118
        self.assertEqual('', err)
 
119
 
 
120
    def test_init_existing_branch(self):
 
121
        self.run_bzr('init')
 
122
        out, err = self.run_bzr('init', retcode=3)
 
123
        self.assertContainsRe(err, 'Already a branch')
 
124
        # don't suggest making a checkout, there's already a working tree
 
125
        self.assertFalse(re.search(r'checkout', err))
 
126
 
 
127
    def test_init_existing_without_workingtree(self):
 
128
        # make a repository
 
129
        repo = self.make_repository('.', shared=True)
 
130
        repo.set_make_working_trees(False)
 
131
        # make a branch; by default without a working tree
 
132
        self.run_bzr('init subdir')
 
133
        # fail
 
134
        out, err = self.run_bzr('init subdir', retcode=3)
 
135
        # suggests using checkout
 
136
        self.assertContainsRe(err,
 
137
                              'ontains a branch.*but no working tree.*checkout')
 
138
 
 
139
    def test_no_defaults(self):
 
140
        """Init creates no default ignore rules."""
 
141
        self.run_bzr('init')
 
142
        self.assertFalse(os.path.exists('.bzrignore'))
 
143
 
 
144
    def test_init_unicode(self):
 
145
        # Make sure getcwd can handle unicode filenames
 
146
        try:
 
147
            os.mkdir(u'mu-\xb5')
 
148
        except UnicodeError:
 
149
            raise TestSkipped("Unable to create Unicode filename")
 
150
        # try to init unicode dir
 
151
        self.run_bzr(['init', '-q', u'mu-\xb5'])
 
152
 
 
153
    def create_simple_tree(self):
 
154
        tree = self.make_branch_and_tree('tree')
 
155
        self.build_tree(['tree/a'])
 
156
        tree.add(['a'], ['a-id'])
 
157
        tree.commit('one', rev_id='r1')
 
158
        return tree
 
159
 
 
160
    def test_init_create_prefix(self):
 
161
        """'bzr init --create-prefix; will create leading directories."""
 
162
        tree = self.create_simple_tree()
 
163
 
 
164
        self.run_bzr_error(['Parent directory of ../new/tree does not exist'],
 
165
                            'init ../new/tree', working_dir='tree')
 
166
        self.run_bzr('init ../new/tree --create-prefix', working_dir='tree')
 
167
        self.assertPathExists('new/tree/.bzr')
 
168
 
 
169
    def test_init_default_format_option(self):
 
170
        """bzr init should read default format from option default_format"""
 
171
        conf = _mod_config.GlobalConfig.from_string('''
 
172
[DEFAULT]
 
173
default_format = 1.9
 
174
''', save=True)
 
175
        out, err = self.run_bzr_subprocess('init')
 
176
        self.assertContainsRe(out, '1.9')
 
177
 
 
178
    def test_init_no_tree(self):
 
179
        """'bzr init --no-tree' creates a branch with no working tree."""
 
180
        out, err = self.run_bzr('init --no-tree')
 
181
        self.assertStartsWith(out, 'Created a standalone branch')
 
182
 
 
183
 
 
184
class TestSFTPInit(TestCaseWithSFTPServer):
 
185
 
 
186
    def test_init(self):
 
187
        # init on a remote url should succeed.
 
188
        out, err = self.run_bzr(['init', '--pack-0.92', self.get_url()])
 
189
        self.assertEqual(out,
 
190
            """Created a standalone branch (format: pack-0.92)\n""")
 
191
        self.assertEqual('', err)
 
192
 
 
193
    def test_init_existing_branch(self):
 
194
        # when there is already a branch present, make mention
 
195
        self.make_branch('.')
 
196
 
 
197
        # rely on SFTPServer get_url() pointing at '.'
 
198
        out, err = self.run_bzr_error(['Already a branch'],
 
199
                                      ['init', self.get_url()])
 
200
 
 
201
        # make sure using 'bzr checkout' is not suggested
 
202
        # for remote locations missing a working tree
 
203
        self.assertFalse(re.search(r'use bzr checkout', err))
 
204
 
 
205
    def test_init_existing_branch_with_workingtree(self):
 
206
        # don't distinguish between the branch having a working tree or not
 
207
        # when the branch itself is remote.
 
208
        self.make_branch_and_tree('.')
 
209
 
 
210
        # rely on SFTPServer get_url() pointing at '.'
 
211
        self.run_bzr_error(['Already a branch'], ['init', self.get_url()])
 
212
 
 
213
    def test_init_append_revisions_only(self):
 
214
        self.run_bzr('init --dirstate-tags normal_branch6')
 
215
        branch = _mod_branch.Branch.open('normal_branch6')
 
216
        self.assertEqual(None, branch.get_append_revisions_only())
 
217
        self.run_bzr('init --append-revisions-only --dirstate-tags branch6')
 
218
        branch = _mod_branch.Branch.open('branch6')
 
219
        self.assertEqual(True, branch.get_append_revisions_only())
 
220
        self.run_bzr_error(['cannot be set to append-revisions-only'],
 
221
                           'init --append-revisions-only --knit knit')
 
222
 
 
223
    def test_init_without_username(self):
 
224
        """Ensure init works if username is not set.
 
225
        """
 
226
        # bzr makes user specified whoami mandatory for operations
 
227
        # like commit as whoami is recorded. init however is not so final
 
228
        # and uses whoami only in a lock file. Without whoami the login name
 
229
        # is used. This test is to ensure that init passes even when whoami
 
230
        # is not available.
 
231
        self.overrideEnv('EMAIL', None)
 
232
        self.overrideEnv('BZR_EMAIL', None)
 
233
        out, err = self.run_bzr(['init', 'foo'])
 
234
        self.assertEqual(err, '')
 
235
        self.assertTrue(os.path.exists('foo'))
 
236