/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: John Arbash Meinel
  • Date: 2009-12-22 16:28:47 UTC
  • mto: This revision was merged to the branch mainline in revision 4922.
  • Revision ID: john@arbash-meinel.com-20091222162847-tvnsc69to4l4uf5r
Implement a permute_for_extension helper.

Use it for all of the 'simple' extension permutations.
It basically permutes all tests in the current module, by setting TestCase.module.
Which works well for most of our extension tests. Some had more advanced
handling of permutations (extra permutations, custom vars, etc.)

Show diffs side-by-side

added added

removed removed

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