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

Move working tree initialisation out from  Branch.initialize, deprecated Branch.initialize to Branch.create.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
 
1
# (C) 2005 Canonical Ltd
 
2
# Authors:  Robert Collins <robert.collins@canonical.com>
 
3
#
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
from cStringIO import StringIO
 
19
import os
 
20
 
 
21
import bzrlib
 
22
from bzrlib.branch import Branch
 
23
from bzrlib.errors import NotBranchError, NotVersionedError
 
24
from bzrlib.tests import TestCaseWithTransport
 
25
from bzrlib.trace import mutter
 
26
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
 
27
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
 
28
                                WorkingTree)
 
29
 
 
30
class TestTreeDirectory(TestCaseWithTransport):
 
31
 
 
32
    def test_kind_character(self):
 
33
        self.assertEqual(TreeDirectory().kind_character(), '/')
 
34
 
 
35
 
 
36
class TestTreeEntry(TestCaseWithTransport):
 
37
 
 
38
    def test_kind_character(self):
 
39
        self.assertEqual(TreeEntry().kind_character(), '???')
 
40
 
 
41
 
 
42
class TestTreeFile(TestCaseWithTransport):
 
43
 
 
44
    def test_kind_character(self):
 
45
        self.assertEqual(TreeFile().kind_character(), '')
 
46
 
 
47
 
 
48
class TestTreeLink(TestCaseWithTransport):
 
49
 
 
50
    def test_kind_character(self):
 
51
        self.assertEqual(TreeLink().kind_character(), '')
 
52
 
 
53
 
 
54
class TestWorkingTree(TestCaseWithTransport):
 
55
 
 
56
    def test_listfiles(self):
 
57
        tree = WorkingTree.create_standalone('.')
 
58
        os.mkdir('dir')
 
59
        print >> open('file', 'w'), "content"
 
60
        if has_symlinks():
 
61
            os.symlink('target', 'symlink')
 
62
        files = list(tree.list_files())
 
63
        self.assertEqual(files[0], ('dir', '?', 'directory', None, TreeDirectory()))
 
64
        self.assertEqual(files[1], ('file', '?', 'file', None, TreeFile()))
 
65
        if has_symlinks():
 
66
            self.assertEqual(files[2], ('symlink', '?', 'symlink', None, TreeLink()))
 
67
 
 
68
    def test_open_containing(self):
 
69
        branch = WorkingTree.create_standalone('.').branch
 
70
        wt, relpath = WorkingTree.open_containing()
 
71
        self.assertEqual('', relpath)
 
72
        self.assertEqual(wt.basedir + '/', branch.base)
 
73
        wt, relpath = WorkingTree.open_containing(u'.')
 
74
        self.assertEqual('', relpath)
 
75
        self.assertEqual(wt.basedir + '/', branch.base)
 
76
        wt, relpath = WorkingTree.open_containing('./foo')
 
77
        self.assertEqual('foo', relpath)
 
78
        self.assertEqual(wt.basedir + '/', branch.base)
 
79
        # paths that are urls are just plain wrong for working trees.
 
80
        self.assertRaises(NotBranchError,
 
81
                          WorkingTree.open_containing, 
 
82
                          'file:///' + getcwd())
 
83
 
 
84
    def test_construct_with_branch(self):
 
85
        branch = WorkingTree.create_standalone('.').branch
 
86
        tree = WorkingTree(branch.base, branch)
 
87
        self.assertEqual(branch, tree.branch)
 
88
        self.assertEqual(branch.base, tree.basedir + '/')
 
89
    
 
90
    def test_construct_without_branch(self):
 
91
        branch = WorkingTree.create_standalone('.').branch
 
92
        tree = WorkingTree(branch.base)
 
93
        self.assertEqual(branch.base, tree.branch.base)
 
94
        self.assertEqual(branch.base, tree.basedir + '/')
 
95
 
 
96
    def test_basic_relpath(self):
 
97
        # for comprehensive relpath tests, see whitebox.py.
 
98
        tree = WorkingTree.create_standalone('.')
 
99
        self.assertEqual('child',
 
100
                         tree.relpath(pathjoin(getcwd(), 'child')))
 
101
 
 
102
    def test_lock_locks_branch(self):
 
103
        tree = WorkingTree.create_standalone('.')
 
104
        tree.lock_read()
 
105
        self.assertEqual(1, tree.branch._lock_count)
 
106
        self.assertEqual('r', tree.branch._lock_mode)
 
107
        tree.unlock()
 
108
        self.assertEqual(None, tree.branch._lock_count)
 
109
        tree.lock_write()
 
110
        self.assertEqual(1, tree.branch._lock_count)
 
111
        self.assertEqual('w', tree.branch._lock_mode)
 
112
        tree.unlock()
 
113
        self.assertEqual(None, tree.branch._lock_count)
 
114
 
 
115
    def get_pullable_trees(self):
 
116
        self.build_tree(['from/', 'from/file', 'to/'])
 
117
        tree = WorkingTree.create_standalone('from')
 
118
        tree.add('file')
 
119
        tree.commit('foo', rev_id='A')
 
120
        tree_b = WorkingTree.create_standalone('to')
 
121
        return tree, tree_b
 
122
 
 
123
    def test_pull(self):
 
124
        tree_a, tree_b = self.get_pullable_trees()
 
125
        tree_b.pull(tree_a.branch)
 
126
        self.failUnless(tree_b.branch.has_revision('A'))
 
127
        self.assertEqual(['A'], tree_b.branch.revision_history())
 
128
 
 
129
    def test_pull_overwrites(self):
 
130
        tree_a, tree_b = self.get_pullable_trees()
 
131
        tree_b.commit('foo', rev_id='B')
 
132
        self.assertEqual(['B'], tree_b.branch.revision_history())
 
133
        tree_b.pull(tree_a.branch, overwrite=True)
 
134
        self.failUnless(tree_b.branch.has_revision('A'))
 
135
        self.failUnless(tree_b.branch.has_revision('B'))
 
136
        self.assertEqual(['A'], tree_b.branch.revision_history())
 
137
 
 
138
    def test_revert(self):
 
139
        """Test selected-file revert"""
 
140
        tree = WorkingTree.create_standalone('.')
 
141
 
 
142
        self.build_tree(['hello.txt'])
 
143
        file('hello.txt', 'w').write('initial hello')
 
144
 
 
145
        self.assertRaises(NotVersionedError,
 
146
                          tree.revert, ['hello.txt'])
 
147
        tree.add(['hello.txt'])
 
148
        tree.commit('create initial hello.txt')
 
149
 
 
150
        self.check_file_contents('hello.txt', 'initial hello')
 
151
        file('hello.txt', 'w').write('new hello')
 
152
        self.check_file_contents('hello.txt', 'new hello')
 
153
 
 
154
        # revert file modified since last revision
 
155
        tree.revert(['hello.txt'])
 
156
        self.check_file_contents('hello.txt', 'initial hello')
 
157
        self.check_file_contents('hello.txt~', 'new hello')
 
158
 
 
159
        # reverting again does not clobber the backup
 
160
        tree.revert(['hello.txt'])
 
161
        self.check_file_contents('hello.txt', 'initial hello')
 
162
        self.check_file_contents('hello.txt~', 'new hello')
 
163
 
 
164
    def test_unknowns(self):
 
165
        tree = WorkingTree.create_standalone('.')
 
166
        self.build_tree(['hello.txt',
 
167
                         'hello.txt~'])
 
168
        self.assertEquals(list(tree.unknowns()),
 
169
                          ['hello.txt'])
 
170
 
 
171
    def test_hashcache(self):
 
172
        from bzrlib.tests.test_hashcache import pause
 
173
        tree = WorkingTree.create_standalone('.')
 
174
        self.build_tree(['hello.txt',
 
175
                         'hello.txt~'])
 
176
        tree.add('hello.txt')
 
177
        pause()
 
178
        sha = tree.get_file_sha1(tree.path2id('hello.txt'))
 
179
        self.assertEqual(1, tree._hashcache.miss_count)
 
180
        tree2 = WorkingTree('.', tree.branch)
 
181
        sha2 = tree2.get_file_sha1(tree2.path2id('hello.txt'))
 
182
        self.assertEqual(0, tree2._hashcache.miss_count)
 
183
        self.assertEqual(1, tree2._hashcache.hit_count)
 
184
 
 
185
    def test_checkout(self):
 
186
        # at this point as we dont have checkout versions, checkout simply
 
187
        # populates the required files for a working tree at the dir.
 
188
        self.build_tree(['branch/'])
 
189
        b = Branch.create('branch')
 
190
        t = WorkingTree.create(b, 'tree')
 
191
        # as we are moving the ownership to working tree, we will check here
 
192
        # that its split out correctly
 
193
        self.failIfExists('branch/.bzr/inventory')
 
194
        self.failIfExists('branch/.bzr/pending-merges')
 
195
        sio = StringIO()
 
196
        bzrlib.xml5.serializer_v5.write_inventory(bzrlib.inventory.Inventory(),
 
197
                                                  sio)
 
198
        self.assertFileEqual(sio.getvalue(), 'tree/.bzr/inventory')
 
199
        self.assertFileEqual('', 'tree/.bzr/pending-merges')
 
200
 
 
201
    def test_initialize(self):
 
202
        # initialize should create a working tree and branch in an existing dir
 
203
        t = WorkingTree.create_standalone('.')
 
204
        b = Branch.open('.')
 
205
        self.assertEqual(t.branch.base, b.base)
 
206
        t2 = WorkingTree('.')
 
207
        self.assertEqual(t.basedir, t2.basedir)
 
208
        self.assertEqual(b.base, t2.branch.base)
 
209
        # TODO maybe we should check the branch format? not sure if its
 
210
        # appropriate here.
 
211
 
 
212
    def test_rename_dirs(self):
 
213
        """Test renaming directories and the files within them."""
 
214
        wt = self.make_branch_and_tree('.')
 
215
        b = wt.branch
 
216
        self.build_tree(['dir/', 'dir/sub/', 'dir/sub/file'])
 
217
        wt.add(['dir', 'dir/sub', 'dir/sub/file'])
 
218
 
 
219
        wt.commit('create initial state')
 
220
 
 
221
        revid = b.revision_history()[0]
 
222
        self.log('first revision_id is {%s}' % revid)
 
223
        
 
224
        inv = b.get_revision_inventory(revid)
 
225
        self.log('contents of inventory: %r' % inv.entries())
 
226
 
 
227
        self.check_inventory_shape(inv,
 
228
                                   ['dir', 'dir/sub', 'dir/sub/file'])
 
229
 
 
230
        wt.rename_one('dir', 'newdir')
 
231
 
 
232
        self.check_inventory_shape(wt.read_working_inventory(),
 
233
                                   ['newdir', 'newdir/sub', 'newdir/sub/file'])
 
234
 
 
235
        wt.rename_one('newdir/sub', 'newdir/newsub')
 
236
        self.check_inventory_shape(wt.read_working_inventory(),
 
237
                                   ['newdir', 'newdir/newsub',
 
238
                                    'newdir/newsub/file'])
 
239
 
 
240
    def test_add_in_unversioned(self):
 
241
        """Try to add a file in an unversioned directory.
 
242
 
 
243
        "bzr add" adds the parent as necessary, but simple working tree add
 
244
        doesn't do that.
 
245
        """
 
246
        from bzrlib.errors import NotVersionedError
 
247
        wt = self.make_branch_and_tree('.')
 
248
        self.build_tree(['foo/',
 
249
                         'foo/hello'])
 
250
        self.assertRaises(NotVersionedError,
 
251
                          wt.add,
 
252
                          'foo/hello')
 
253
 
 
254
    def test_remove_verbose(self):
 
255
        #FIXME the remove api should not print or otherwise depend on the
 
256
        # text UI - RBC 20060124
 
257
        wt = self.make_branch_and_tree('.')
 
258
        self.build_tree(['hello'])
 
259
        wt.add(['hello'])
 
260
        wt.commit(message='add hello')
 
261
        stdout = StringIO()
 
262
        stderr = StringIO()
 
263
        self.assertEqual(None, self.apply_redirected(None, stdout, stderr,
 
264
                                                     wt.remove,
 
265
                                                     ['hello'],
 
266
                                                     verbose=True))
 
267
        self.assertEqual('?       hello\n', stdout.getvalue())
 
268
        self.assertEqual('', stderr.getvalue())