1
# Copyright (C) 2005, 2006 Canonical Ltd
2
# Authors: Robert Collins <robert.collins@canonical.com>
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.
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.
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
18
from cStringIO import StringIO
21
from bzrlib import ignores
23
from bzrlib.branch import Branch
24
from bzrlib import bzrdir, conflicts, errors, workingtree
25
from bzrlib.bzrdir import BzrDir
26
from bzrlib.errors import NotBranchError, NotVersionedError
27
from bzrlib.lockdir import LockDir
28
from bzrlib.mutabletree import needs_tree_write_lock
29
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
30
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
31
from bzrlib.trace import mutter
32
from bzrlib.transport import get_transport
33
from bzrlib.workingtree import (
41
class TestTreeDirectory(TestCaseWithTransport):
43
def test_kind_character(self):
44
self.assertEqual(TreeDirectory().kind_character(), '/')
47
class TestTreeEntry(TestCaseWithTransport):
49
def test_kind_character(self):
50
self.assertEqual(TreeEntry().kind_character(), '???')
53
class TestTreeFile(TestCaseWithTransport):
55
def test_kind_character(self):
56
self.assertEqual(TreeFile().kind_character(), '')
59
class TestTreeLink(TestCaseWithTransport):
61
def test_kind_character(self):
62
self.assertEqual(TreeLink().kind_character(), '')
65
class TestDefaultFormat(TestCaseWithTransport):
67
def test_get_set_default_format(self):
68
old_format = workingtree.WorkingTreeFormat.get_default_format()
70
self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
71
workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
73
# the default branch format is used by the meta dir format
74
# which is not the default bzrdir format at this point
75
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
76
dir.create_repository()
78
result = dir.create_workingtree()
79
self.assertEqual(result, 'A tree')
81
workingtree.WorkingTreeFormat.set_default_format(old_format)
82
self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
85
class SampleTreeFormat(workingtree.WorkingTreeFormat):
88
this format is initializable, unsupported to aid in testing the
89
open and open_downlevel routines.
92
def get_format_string(self):
93
"""See WorkingTreeFormat.get_format_string()."""
94
return "Sample tree format."
96
def initialize(self, a_bzrdir, revision_id=None):
97
"""Sample branches cannot be created."""
98
t = a_bzrdir.get_workingtree_transport(self)
99
t.put_bytes('format', self.get_format_string())
102
def is_supported(self):
105
def open(self, transport, _found=False):
106
return "opened tree."
109
class TestWorkingTreeFormat(TestCaseWithTransport):
110
"""Tests for the WorkingTreeFormat facility."""
112
def test_find_format(self):
113
# is the right format object found for a working tree?
114
# create a branch with a few known format objects.
115
self.build_tree(["foo/", "bar/"])
116
def check_format(format, url):
117
dir = format._matchingbzrdir.initialize(url)
118
dir.create_repository()
120
format.initialize(dir)
121
t = get_transport(url)
122
found_format = workingtree.WorkingTreeFormat.find_format(dir)
123
self.failUnless(isinstance(found_format, format.__class__))
124
check_format(workingtree.WorkingTreeFormat3(), "bar")
126
def test_find_format_no_tree(self):
127
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
128
self.assertRaises(errors.NoWorkingTree,
129
workingtree.WorkingTreeFormat.find_format,
132
def test_find_format_unknown_format(self):
133
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
134
dir.create_repository()
136
SampleTreeFormat().initialize(dir)
137
self.assertRaises(errors.UnknownFormatError,
138
workingtree.WorkingTreeFormat.find_format,
141
def test_register_unregister_format(self):
142
format = SampleTreeFormat()
144
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
145
dir.create_repository()
148
format.initialize(dir)
149
# register a format for it.
150
workingtree.WorkingTreeFormat.register_format(format)
151
# which branch.Open will refuse (not supported)
152
self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
153
# but open_downlevel will work
154
self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
155
# unregister the format
156
workingtree.WorkingTreeFormat.unregister_format(format)
159
class TestWorkingTreeFormat3(TestCaseWithTransport):
160
"""Tests specific to WorkingTreeFormat3."""
162
def test_disk_layout(self):
163
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
164
control.create_repository()
165
control.create_branch()
166
tree = workingtree.WorkingTreeFormat3().initialize(control)
168
# format 'Bazaar-NG Working Tree format 3'
169
# inventory = blank inventory
170
# pending-merges = ''
172
# no inventory.basis yet
173
t = control.get_workingtree_transport(None)
174
self.assertEqualDiff('Bazaar-NG Working Tree format 3',
175
t.get('format').read())
176
self.assertContainsRe(t.get('inventory').read(),
177
'<inventory file_id="[^"]*" format="5">\n'
180
self.assertEqualDiff('### bzr hashcache v5\n',
181
t.get('stat-cache').read())
182
self.assertFalse(t.has('inventory.basis'))
183
# no last-revision file means 'None' or 'NULLREVISION'
184
self.assertFalse(t.has('last-revision'))
185
# TODO RBC 20060210 do a commit, check the inventory.basis is created
186
# correctly and last-revision file becomes present.
188
def test_uses_lockdir(self):
189
"""WorkingTreeFormat3 uses its own LockDir:
191
- lock is a directory
192
- when the WorkingTree is locked, LockDir can see that
194
t = self.get_transport()
196
dir = bzrdir.BzrDirMetaFormat1().initialize(url)
197
repo = dir.create_repository()
198
branch = dir.create_branch()
200
tree = workingtree.WorkingTreeFormat3().initialize(dir)
201
except errors.NotLocalUrl:
202
raise TestSkipped('Not a local URL')
203
self.assertIsDirectory('.bzr', t)
204
self.assertIsDirectory('.bzr/checkout', t)
205
self.assertIsDirectory('.bzr/checkout/lock', t)
206
our_lock = LockDir(t, '.bzr/checkout/lock')
207
self.assertEquals(our_lock.peek(), None)
209
self.assertTrue(our_lock.peek())
211
self.assertEquals(our_lock.peek(), None)
213
def test_missing_pending_merges(self):
214
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
215
control.create_repository()
216
control.create_branch()
217
tree = workingtree.WorkingTreeFormat3().initialize(control)
218
tree._control_files._transport.delete("pending-merges")
219
self.assertEqual([], tree.get_parent_ids())
222
class TestFormat2WorkingTree(TestCaseWithTransport):
223
"""Tests that are specific to format 2 trees."""
225
def create_format2_tree(self, url):
226
return self.make_branch_and_tree(
227
url, format=bzrlib.bzrdir.BzrDirFormat6())
229
def test_conflicts(self):
230
# test backwards compatability
231
tree = self.create_format2_tree('.')
232
self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
234
file('lala.BASE', 'wb').write('labase')
235
expected = conflicts.ContentsConflict('lala')
236
self.assertEqual(list(tree.conflicts()), [expected])
237
file('lala', 'wb').write('la')
238
tree.add('lala', 'lala-id')
239
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
240
self.assertEqual(list(tree.conflicts()), [expected])
241
file('lala.THIS', 'wb').write('lathis')
242
file('lala.OTHER', 'wb').write('laother')
243
# When "text conflict"s happen, stem, THIS and OTHER are text
244
expected = conflicts.TextConflict('lala', file_id='lala-id')
245
self.assertEqual(list(tree.conflicts()), [expected])
246
os.unlink('lala.OTHER')
247
os.mkdir('lala.OTHER')
248
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
249
self.assertEqual(list(tree.conflicts()), [expected])
252
class TestNonFormatSpecificCode(TestCaseWithTransport):
253
"""This class contains tests of workingtree that are not format specific."""
256
def test_gen_file_id(self):
257
gen_file_id = bzrlib.workingtree.gen_file_id
259
# We try to use the filename if possible
260
self.assertStartsWith(gen_file_id('bar'), 'bar-')
262
# but we squash capitalization, and remove non word characters
263
self.assertStartsWith(gen_file_id('Mwoo oof\t m'), 'mwoooofm-')
265
# We also remove leading '.' characters to prevent hidden file-ids
266
self.assertStartsWith(gen_file_id('..gam.py'), 'gam.py-')
267
self.assertStartsWith(gen_file_id('..Mwoo oof\t m'), 'mwoooofm-')
269
# we remove unicode characters, and still don't end up with a
271
self.assertStartsWith(gen_file_id(u'\xe5\xb5.txt'), 'txt-')
273
# Our current method of generating unique ids adds 33 characters
274
# plus an serial number (log10(N) characters)
275
# to the end of the filename. We now restrict the filename portion to
276
# be <= 20 characters, so the maximum length should now be approx < 60
278
# Test both case squashing and length restriction
279
fid = gen_file_id('A'*50 + '.txt')
280
self.assertStartsWith(fid, 'a'*20 + '-')
281
self.failUnless(len(fid) < 60)
283
# restricting length happens after the other actions, so
284
# we preserve as much as possible
285
fid = gen_file_id('\xe5\xb5..aBcd\tefGhijKLMnop\tqrstuvwxyz')
286
self.assertStartsWith(fid, 'abcdefghijklmnopqrst-')
287
self.failUnless(len(fid) < 60)
289
def test_next_id_suffix(self):
290
bzrlib.workingtree._gen_id_suffix = None
291
bzrlib.workingtree._next_id_suffix()
292
self.assertNotEqual(None, bzrlib.workingtree._gen_id_suffix)
293
bzrlib.workingtree._gen_id_suffix = "foo-"
294
bzrlib.workingtree._gen_id_serial = 1
295
self.assertEqual("foo-2", bzrlib.workingtree._next_id_suffix())
296
self.assertEqual("foo-3", bzrlib.workingtree._next_id_suffix())
297
self.assertEqual("foo-4", bzrlib.workingtree._next_id_suffix())
298
self.assertEqual("foo-5", bzrlib.workingtree._next_id_suffix())
299
self.assertEqual("foo-6", bzrlib.workingtree._next_id_suffix())
300
self.assertEqual("foo-7", bzrlib.workingtree._next_id_suffix())
301
self.assertEqual("foo-8", bzrlib.workingtree._next_id_suffix())
302
self.assertEqual("foo-9", bzrlib.workingtree._next_id_suffix())
303
self.assertEqual("foo-10", bzrlib.workingtree._next_id_suffix())
305
def test__translate_ignore_rule(self):
306
tree = self.make_branch_and_tree('.')
307
# translation should return the regex, the number of groups in it,
308
# and the original rule in a tuple.
309
# there are three sorts of ignore rules:
310
# root only - regex is the rule itself without the leading ./
313
tree._translate_ignore_rule("./rootdirrule"))
314
# full path - regex is the rule itself
316
"(path\\/to\\/file$)",
317
tree._translate_ignore_rule("path/to/file"))
318
# basename only rule - regex is a rule that ignores everything up
319
# to the last / in the filename
321
"((?:.*/)?(?!.*/)basenamerule$)",
322
tree._translate_ignore_rule("basenamerule"))
324
def test__combine_ignore_rules(self):
325
tree = self.make_branch_and_tree('.')
326
# the combined ignore regexs need the outer group indices
327
# placed in a dictionary with the rules that were combined.
328
# an empty set of rules
329
# this is returned as a list of combined regex,rule sets, because
330
# python has a limit of 100 combined regexes.
331
compiled_rules = tree._combine_ignore_rules([])
332
self.assertEqual([], compiled_rules)
333
# one of each type of rule.
334
compiled_rules = tree._combine_ignore_rules(
335
["rule1", "rule/two", "./three"])[0]
336
# what type *is* the compiled regex to do an isinstance of ?
337
self.assertEqual(3, compiled_rules[0].groups)
339
{0:"rule1",1:"rule/two",2:"./three"},
342
def test__combine_ignore_rules_grouping(self):
343
tree = self.make_branch_and_tree('.')
344
# when there are too many rules, the output is split into groups of 100
346
for index in range(198):
348
self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
350
def test__get_ignore_rules_as_regex(self):
351
tree = self.make_branch_and_tree('.')
352
# Setup the default ignore list to be empty
353
ignores._set_user_ignores([])
355
# some plugins (shelf) modifies the DEFAULT_IGNORE list in memory
356
# which causes this test to fail so force the DEFAULT_IGNORE
358
orig_default = bzrlib.DEFAULT_IGNORE
359
# Also make sure the runtime ignore list is empty
360
orig_runtime = ignores._runtime_ignores
362
bzrlib.DEFAULT_IGNORE = []
363
ignores._runtime_ignores = set()
365
self.build_tree_contents([('.bzrignore', 'CVS\n.hg\n')])
366
reference_output = tree._combine_ignore_rules(
367
set(['CVS', '.hg']))[0]
368
regex_rules = tree._get_ignore_rules_as_regex()[0]
369
self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
370
self.assertEqual(reference_output[1], regex_rules[1])
372
bzrlib.DEFAULT_IGNORE = orig_default
373
ignores._runtime_ignores = orig_runtime
376
class InstrumentedTree(object):
377
"""A instrumented tree to check the needs_tree_write_lock decorator."""
382
def lock_tree_write(self):
383
self._locks.append('t')
385
@needs_tree_write_lock
386
def method_with_tree_write_lock(self, *args, **kwargs):
387
"""A lock_tree_write decorated method that returns its arguments."""
390
@needs_tree_write_lock
391
def method_that_raises(self):
392
"""This method causes an exception when called with parameters.
394
This allows the decorator code to be checked - it should still call
399
self._locks.append('u')
402
class TestInstrumentedTree(TestCase):
404
def test_needs_tree_write_lock(self):
405
"""@needs_tree_write_lock should be semantically transparent."""
406
tree = InstrumentedTree()
408
'method_with_tree_write_lock',
409
tree.method_with_tree_write_lock.__name__)
411
"A lock_tree_write decorated method that returns its arguments.",
412
tree.method_with_tree_write_lock.__doc__)
415
result = tree.method_with_tree_write_lock(1,2,3, a='b')
416
self.assertEqual((args, kwargs), result)
417
self.assertEqual(['t', 'u'], tree._locks)
418
self.assertRaises(TypeError, tree.method_that_raises, 'foo')
419
self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
added
removed
bzrlib/tests/test_workingtree.py
