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.osutils import pathjoin, getcwd, has_symlinks
29
from bzrlib.tests import TestCaseWithTransport, TestSkipped
30
from bzrlib.trace import mutter
31
from bzrlib.transport import get_transport
32
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
35
class TestTreeDirectory(TestCaseWithTransport):
37
def test_kind_character(self):
38
self.assertEqual(TreeDirectory().kind_character(), '/')
41
class TestTreeEntry(TestCaseWithTransport):
43
def test_kind_character(self):
44
self.assertEqual(TreeEntry().kind_character(), '???')
47
class TestTreeFile(TestCaseWithTransport):
49
def test_kind_character(self):
50
self.assertEqual(TreeFile().kind_character(), '')
53
class TestTreeLink(TestCaseWithTransport):
55
def test_kind_character(self):
56
self.assertEqual(TreeLink().kind_character(), '')
59
class TestDefaultFormat(TestCaseWithTransport):
61
def test_get_set_default_format(self):
62
old_format = workingtree.WorkingTreeFormat.get_default_format()
64
self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
65
workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
67
# the default branch format is used by the meta dir format
68
# which is not the default bzrdir format at this point
69
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
70
dir.create_repository()
72
result = dir.create_workingtree()
73
self.assertEqual(result, 'A tree')
75
workingtree.WorkingTreeFormat.set_default_format(old_format)
76
self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
79
class SampleTreeFormat(workingtree.WorkingTreeFormat):
82
this format is initializable, unsupported to aid in testing the
83
open and open_downlevel routines.
86
def get_format_string(self):
87
"""See WorkingTreeFormat.get_format_string()."""
88
return "Sample tree format."
90
def initialize(self, a_bzrdir, revision_id=None):
91
"""Sample branches cannot be created."""
92
t = a_bzrdir.get_workingtree_transport(self)
93
t.put_bytes('format', self.get_format_string())
96
def is_supported(self):
99
def open(self, transport, _found=False):
100
return "opened tree."
103
class TestWorkingTreeFormat(TestCaseWithTransport):
104
"""Tests for the WorkingTreeFormat facility."""
106
def test_find_format(self):
107
# is the right format object found for a working tree?
108
# create a branch with a few known format objects.
109
self.build_tree(["foo/", "bar/"])
110
def check_format(format, url):
111
dir = format._matchingbzrdir.initialize(url)
112
dir.create_repository()
114
format.initialize(dir)
115
t = get_transport(url)
116
found_format = workingtree.WorkingTreeFormat.find_format(dir)
117
self.failUnless(isinstance(found_format, format.__class__))
118
check_format(workingtree.WorkingTreeFormat3(), "bar")
120
def test_find_format_no_tree(self):
121
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
122
self.assertRaises(errors.NoWorkingTree,
123
workingtree.WorkingTreeFormat.find_format,
126
def test_find_format_unknown_format(self):
127
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
128
dir.create_repository()
130
SampleTreeFormat().initialize(dir)
131
self.assertRaises(errors.UnknownFormatError,
132
workingtree.WorkingTreeFormat.find_format,
135
def test_register_unregister_format(self):
136
format = SampleTreeFormat()
138
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
139
dir.create_repository()
142
format.initialize(dir)
143
# register a format for it.
144
workingtree.WorkingTreeFormat.register_format(format)
145
# which branch.Open will refuse (not supported)
146
self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
147
# but open_downlevel will work
148
self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
149
# unregister the format
150
workingtree.WorkingTreeFormat.unregister_format(format)
153
class TestWorkingTreeFormat3(TestCaseWithTransport):
154
"""Tests specific to WorkingTreeFormat3."""
156
def test_disk_layout(self):
157
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
158
control.create_repository()
159
control.create_branch()
160
tree = workingtree.WorkingTreeFormat3().initialize(control)
162
# format 'Bazaar-NG Working Tree format 3'
163
# inventory = blank inventory
164
# pending-merges = ''
166
# no inventory.basis yet
167
t = control.get_workingtree_transport(None)
168
self.assertEqualDiff('Bazaar-NG Working Tree format 3',
169
t.get('format').read())
170
self.assertContainsRe(t.get('inventory').read(),
171
'<inventory file_id="[^"]*" format="5">\n'
174
self.assertEqualDiff('### bzr hashcache v5\n',
175
t.get('stat-cache').read())
176
self.assertFalse(t.has('inventory.basis'))
177
# no last-revision file means 'None' or 'NULLREVISION'
178
self.assertFalse(t.has('last-revision'))
179
# TODO RBC 20060210 do a commit, check the inventory.basis is created
180
# correctly and last-revision file becomes present.
182
def test_uses_lockdir(self):
183
"""WorkingTreeFormat3 uses its own LockDir:
185
- lock is a directory
186
- when the WorkingTree is locked, LockDir can see that
188
t = self.get_transport()
190
dir = bzrdir.BzrDirMetaFormat1().initialize(url)
191
repo = dir.create_repository()
192
branch = dir.create_branch()
194
tree = workingtree.WorkingTreeFormat3().initialize(dir)
195
except errors.NotLocalUrl:
196
raise TestSkipped('Not a local URL')
197
self.assertIsDirectory('.bzr', t)
198
self.assertIsDirectory('.bzr/checkout', t)
199
self.assertIsDirectory('.bzr/checkout/lock', t)
200
our_lock = LockDir(t, '.bzr/checkout/lock')
201
self.assertEquals(our_lock.peek(), None)
203
self.assertTrue(our_lock.peek())
205
self.assertEquals(our_lock.peek(), None)
207
def test_missing_pending_merges(self):
208
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
209
control.create_repository()
210
control.create_branch()
211
tree = workingtree.WorkingTreeFormat3().initialize(control)
212
tree._control_files._transport.delete("pending-merges")
213
self.assertEqual([], tree.get_parent_ids())
216
class TestFormat2WorkingTree(TestCaseWithTransport):
217
"""Tests that are specific to format 2 trees."""
219
def create_format2_tree(self, url):
220
return self.make_branch_and_tree(
221
url, format=bzrlib.bzrdir.BzrDirFormat6())
223
def test_conflicts(self):
224
# test backwards compatability
225
tree = self.create_format2_tree('.')
226
self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
228
file('lala.BASE', 'wb').write('labase')
229
expected = conflicts.ContentsConflict('lala')
230
self.assertEqual(list(tree.conflicts()), [expected])
231
file('lala', 'wb').write('la')
232
tree.add('lala', 'lala-id')
233
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
234
self.assertEqual(list(tree.conflicts()), [expected])
235
file('lala.THIS', 'wb').write('lathis')
236
file('lala.OTHER', 'wb').write('laother')
237
# When "text conflict"s happen, stem, THIS and OTHER are text
238
expected = conflicts.TextConflict('lala', file_id='lala-id')
239
self.assertEqual(list(tree.conflicts()), [expected])
240
os.unlink('lala.OTHER')
241
os.mkdir('lala.OTHER')
242
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
243
self.assertEqual(list(tree.conflicts()), [expected])
246
class TestNonFormatSpecificCode(TestCaseWithTransport):
247
"""This class contains tests of workingtree that are not format specific."""
250
def test_gen_file_id(self):
251
gen_file_id = bzrlib.workingtree.gen_file_id
253
# We try to use the filename if possible
254
self.assertStartsWith(gen_file_id('bar'), 'bar-')
256
# but we squash capitalization, and remove non word characters
257
self.assertStartsWith(gen_file_id('Mwoo oof\t m'), 'mwoooofm-')
259
# We also remove leading '.' characters to prevent hidden file-ids
260
self.assertStartsWith(gen_file_id('..gam.py'), 'gam.py-')
261
self.assertStartsWith(gen_file_id('..Mwoo oof\t m'), 'mwoooofm-')
263
# we remove unicode characters, and still don't end up with a
265
self.assertStartsWith(gen_file_id(u'\xe5\xb5.txt'), 'txt-')
267
# Our current method of generating unique ids adds 33 characters
268
# plus an serial number (log10(N) characters)
269
# to the end of the filename. We now restrict the filename portion to
270
# be <= 20 characters, so the maximum length should now be approx < 60
272
# Test both case squashing and length restriction
273
fid = gen_file_id('A'*50 + '.txt')
274
self.assertStartsWith(fid, 'a'*20 + '-')
275
self.failUnless(len(fid) < 60)
277
# restricting length happens after the other actions, so
278
# we preserve as much as possible
279
fid = gen_file_id('\xe5\xb5..aBcd\tefGhijKLMnop\tqrstuvwxyz')
280
self.assertStartsWith(fid, 'abcdefghijklmnopqrst-')
281
self.failUnless(len(fid) < 60)
283
def test_next_id_suffix(self):
284
bzrlib.workingtree._gen_id_suffix = None
285
bzrlib.workingtree._next_id_suffix()
286
self.assertNotEqual(None, bzrlib.workingtree._gen_id_suffix)
287
bzrlib.workingtree._gen_id_suffix = "foo-"
288
bzrlib.workingtree._gen_id_serial = 1
289
self.assertEqual("foo-2", bzrlib.workingtree._next_id_suffix())
290
self.assertEqual("foo-3", bzrlib.workingtree._next_id_suffix())
291
self.assertEqual("foo-4", bzrlib.workingtree._next_id_suffix())
292
self.assertEqual("foo-5", bzrlib.workingtree._next_id_suffix())
293
self.assertEqual("foo-6", bzrlib.workingtree._next_id_suffix())
294
self.assertEqual("foo-7", bzrlib.workingtree._next_id_suffix())
295
self.assertEqual("foo-8", bzrlib.workingtree._next_id_suffix())
296
self.assertEqual("foo-9", bzrlib.workingtree._next_id_suffix())
297
self.assertEqual("foo-10", bzrlib.workingtree._next_id_suffix())
299
def test__translate_ignore_rule(self):
300
tree = self.make_branch_and_tree('.')
301
# translation should return the regex, the number of groups in it,
302
# and the original rule in a tuple.
303
# there are three sorts of ignore rules:
304
# root only - regex is the rule itself without the leading ./
307
tree._translate_ignore_rule("./rootdirrule"))
308
# full path - regex is the rule itself
310
"(path\\/to\\/file$)",
311
tree._translate_ignore_rule("path/to/file"))
312
# basename only rule - regex is a rule that ignores everything up
313
# to the last / in the filename
315
"((?:.*/)?(?!.*/)basenamerule$)",
316
tree._translate_ignore_rule("basenamerule"))
318
def test__combine_ignore_rules(self):
319
tree = self.make_branch_and_tree('.')
320
# the combined ignore regexs need the outer group indices
321
# placed in a dictionary with the rules that were combined.
322
# an empty set of rules
323
# this is returned as a list of combined regex,rule sets, because
324
# python has a limit of 100 combined regexes.
325
compiled_rules = tree._combine_ignore_rules([])
326
self.assertEqual([], compiled_rules)
327
# one of each type of rule.
328
compiled_rules = tree._combine_ignore_rules(
329
["rule1", "rule/two", "./three"])[0]
330
# what type *is* the compiled regex to do an isinstance of ?
331
self.assertEqual(3, compiled_rules[0].groups)
333
{0:"rule1",1:"rule/two",2:"./three"},
336
def test__combine_ignore_rules_grouping(self):
337
tree = self.make_branch_and_tree('.')
338
# when there are too many rules, the output is split into groups of 100
340
for index in range(198):
342
self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
344
def test__get_ignore_rules_as_regex(self):
345
tree = self.make_branch_and_tree('.')
346
# Setup the default ignore list to be empty
347
ignores._set_user_ignores([])
349
# some plugins (shelf) modifies the DEFAULT_IGNORE list in memory
350
# which causes this test to fail so force the DEFAULT_IGNORE
352
orig_default = bzrlib.DEFAULT_IGNORE
353
# Also make sure the runtime ignore list is empty
354
orig_runtime = ignores._runtime_ignores
356
bzrlib.DEFAULT_IGNORE = []
357
ignores._runtime_ignores = set()
359
self.build_tree_contents([('.bzrignore', 'CVS\n.hg\n')])
360
reference_output = tree._combine_ignore_rules(
361
set(['CVS', '.hg']))[0]
362
regex_rules = tree._get_ignore_rules_as_regex()[0]
363
self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
364
self.assertEqual(reference_output[1], regex_rules[1])
366
bzrlib.DEFAULT_IGNORE = orig_default
367
ignores._runtime_ignores = orig_runtime
added
removed
bzrlib/tests/test_workingtree.py
