/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: mernst at mit
  • Date: 2008-10-16 10:57:16 UTC
  • mto: This revision was merged to the branch mainline in revision 3799.
  • Revision ID: mernst@csail.mit.edu-20081016105716-v8x8n5t2pf7f6uds
Improved documentation of stacked and lightweight branches

These patches improve the User Guide's documentation of stacked and
lightweight branches.

Section "1.2.6 Putting the concepts together" should mention stacked
branches and the difference between them and lightweight branches.  It
should also contain links to further details of the common scenarios.

Section "5.3.4 Getting a lightweight checkout" should mention stacked
branches as an option, and should link to all the options, not just some of
them.  It should also clarify that lightweight only applies to checkouts,
not to arbitrary branches.

Show diffs side-by-side

added added

removed removed

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