14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
18
from cStringIO import StringIO
21
from bzrlib import ignores
27
23
from bzrlib.branch import Branch
24
from bzrlib import bzrdir, conflicts, errors, workingtree
28
25
from bzrlib.bzrdir import BzrDir
26
from bzrlib.errors import NotBranchError, NotVersionedError
29
27
from bzrlib.lockdir import LockDir
30
28
from bzrlib.mutabletree import needs_tree_write_lock
29
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
31
30
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
31
from bzrlib.trace import mutter
32
32
from bzrlib.transport import get_transport
33
33
from bzrlib.workingtree import (
41
41
class TestTreeDirectory(TestCaseWithTransport):
43
43
def test_kind_character(self):
81
81
workingtree.WorkingTreeFormat.set_default_format(old_format)
82
82
self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
85
tree = self.make_branch_and_tree('.')
86
open_direct = workingtree.WorkingTree.open('.')
87
self.assertEqual(tree.basedir, open_direct.basedir)
88
open_no_args = workingtree.WorkingTree.open()
89
self.assertEqual(tree.basedir, open_no_args.basedir)
91
def test_open_containing(self):
92
tree = self.make_branch_and_tree('.')
93
open_direct, relpath = workingtree.WorkingTree.open_containing('.')
94
self.assertEqual(tree.basedir, open_direct.basedir)
95
self.assertEqual('', relpath)
96
open_no_args, relpath = workingtree.WorkingTree.open_containing()
97
self.assertEqual(tree.basedir, open_no_args.basedir)
98
self.assertEqual('', relpath)
99
open_subdir, relpath = workingtree.WorkingTree.open_containing('subdir')
100
self.assertEqual(tree.basedir, open_subdir.basedir)
101
self.assertEqual('subdir', relpath)
104
85
class SampleTreeFormat(workingtree.WorkingTreeFormat):
105
86
"""A sample format
107
this format is initializable, unsupported to aid in testing the
88
this format is initializable, unsupported to aid in testing the
108
89
open and open_downlevel routines.
269
255
self.assertEqual(list(tree.conflicts()), [expected])
258
class TestNonFormatSpecificCode(TestCaseWithTransport):
259
"""This class contains tests of workingtree that are not format specific."""
262
def test_gen_file_id(self):
263
gen_file_id = bzrlib.workingtree.gen_file_id
265
# We try to use the filename if possible
266
self.assertStartsWith(gen_file_id('bar'), 'bar-')
268
# but we squash capitalization, and remove non word characters
269
self.assertStartsWith(gen_file_id('Mwoo oof\t m'), 'mwoooofm-')
271
# We also remove leading '.' characters to prevent hidden file-ids
272
self.assertStartsWith(gen_file_id('..gam.py'), 'gam.py-')
273
self.assertStartsWith(gen_file_id('..Mwoo oof\t m'), 'mwoooofm-')
275
# we remove unicode characters, and still don't end up with a
277
self.assertStartsWith(gen_file_id(u'\xe5\xb5.txt'), 'txt-')
279
# Our current method of generating unique ids adds 33 characters
280
# plus an serial number (log10(N) characters)
281
# to the end of the filename. We now restrict the filename portion to
282
# be <= 20 characters, so the maximum length should now be approx < 60
284
# Test both case squashing and length restriction
285
fid = gen_file_id('A'*50 + '.txt')
286
self.assertStartsWith(fid, 'a'*20 + '-')
287
self.failUnless(len(fid) < 60)
289
# restricting length happens after the other actions, so
290
# we preserve as much as possible
291
fid = gen_file_id('\xe5\xb5..aBcd\tefGhijKLMnop\tqrstuvwxyz')
292
self.assertStartsWith(fid, 'abcdefghijklmnopqrst-')
293
self.failUnless(len(fid) < 60)
295
def test_next_id_suffix(self):
296
bzrlib.workingtree._gen_id_suffix = None
297
bzrlib.workingtree._next_id_suffix()
298
self.assertNotEqual(None, bzrlib.workingtree._gen_id_suffix)
299
bzrlib.workingtree._gen_id_suffix = "foo-"
300
bzrlib.workingtree._gen_id_serial = 1
301
self.assertEqual("foo-2", bzrlib.workingtree._next_id_suffix())
302
self.assertEqual("foo-3", bzrlib.workingtree._next_id_suffix())
303
self.assertEqual("foo-4", bzrlib.workingtree._next_id_suffix())
304
self.assertEqual("foo-5", bzrlib.workingtree._next_id_suffix())
305
self.assertEqual("foo-6", bzrlib.workingtree._next_id_suffix())
306
self.assertEqual("foo-7", bzrlib.workingtree._next_id_suffix())
307
self.assertEqual("foo-8", bzrlib.workingtree._next_id_suffix())
308
self.assertEqual("foo-9", bzrlib.workingtree._next_id_suffix())
309
self.assertEqual("foo-10", bzrlib.workingtree._next_id_suffix())
311
def test__translate_ignore_rule(self):
312
tree = self.make_branch_and_tree('.')
313
# translation should return the regex, the number of groups in it,
314
# and the original rule in a tuple.
315
# there are three sorts of ignore rules:
316
# root only - regex is the rule itself without the leading ./
319
tree._translate_ignore_rule("./rootdirrule"))
320
# full path - regex is the rule itself
322
"(path\\/to\\/file$)",
323
tree._translate_ignore_rule("path/to/file"))
324
# basename only rule - regex is a rule that ignores everything up
325
# to the last / in the filename
327
"((?:.*/)?(?!.*/)basenamerule$)",
328
tree._translate_ignore_rule("basenamerule"))
330
def test__combine_ignore_rules(self):
331
tree = self.make_branch_and_tree('.')
332
# the combined ignore regexs need the outer group indices
333
# placed in a dictionary with the rules that were combined.
334
# an empty set of rules
335
# this is returned as a list of combined regex,rule sets, because
336
# python has a limit of 100 combined regexes.
337
compiled_rules = tree._combine_ignore_rules([])
338
self.assertEqual([], compiled_rules)
339
# one of each type of rule.
340
compiled_rules = tree._combine_ignore_rules(
341
["rule1", "rule/two", "./three"])[0]
342
# what type *is* the compiled regex to do an isinstance of ?
343
self.assertEqual(3, compiled_rules[0].groups)
345
{0:"rule1",1:"rule/two",2:"./three"},
348
def test__combine_ignore_rules_grouping(self):
349
tree = self.make_branch_and_tree('.')
350
# when there are too many rules, the output is split into groups of 100
352
for index in range(198):
354
self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
356
def test__get_ignore_rules_as_regex(self):
357
tree = self.make_branch_and_tree('.')
358
# Setup the default ignore list to be empty
359
ignores._set_user_ignores([])
361
# some plugins (shelf) modifies the DEFAULT_IGNORE list in memory
362
# which causes this test to fail so force the DEFAULT_IGNORE
364
orig_default = bzrlib.DEFAULT_IGNORE
365
# Also make sure the runtime ignore list is empty
366
orig_runtime = ignores._runtime_ignores
368
bzrlib.DEFAULT_IGNORE = []
369
ignores._runtime_ignores = set()
371
self.build_tree_contents([('.bzrignore', 'CVS\n.hg\n')])
372
reference_output = tree._combine_ignore_rules(
373
set(['CVS', '.hg']))[0]
374
regex_rules = tree._get_ignore_rules_as_regex()[0]
375
self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
376
self.assertEqual(reference_output[1], regex_rules[1])
378
bzrlib.DEFAULT_IGNORE = orig_default
379
ignores._runtime_ignores = orig_runtime
272
382
class InstrumentedTree(object):
273
383
"""A instrumented tree to check the needs_tree_write_lock decorator."""
313
423
self.assertEqual(['t', 'u'], tree._locks)
314
424
self.assertRaises(TypeError, tree.method_that_raises, 'foo')
315
425
self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
318
class TestRevert(TestCaseWithTransport):
320
def test_revert_conflicts_recursive(self):
321
this_tree = self.make_branch_and_tree('this-tree')
322
self.build_tree_contents([('this-tree/foo/',),
323
('this-tree/foo/bar', 'bar')])
324
this_tree.add(['foo', 'foo/bar'])
325
this_tree.commit('created foo/bar')
326
other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
327
self.build_tree_contents([('other-tree/foo/bar', 'baz')])
328
other_tree.commit('changed bar')
329
self.build_tree_contents([('this-tree/foo/bar', 'qux')])
330
this_tree.commit('changed qux')
331
this_tree.merge_from_branch(other_tree.branch)
332
self.assertEqual(1, len(this_tree.conflicts()))
333
this_tree.revert(['foo'])
334
self.assertEqual(0, len(this_tree.conflicts()))
337
class TestAutoResolve(TestCaseWithTransport):
339
def test_auto_resolve(self):
340
base = self.make_branch_and_tree('base')
341
self.build_tree_contents([('base/hello', 'Hello')])
342
base.add('hello', 'hello_id')
344
other = base.bzrdir.sprout('other').open_workingtree()
345
self.build_tree_contents([('other/hello', 'hELLO')])
346
other.commit('Case switch')
347
this = base.bzrdir.sprout('this').open_workingtree()
348
self.failUnlessExists('this/hello')
349
self.build_tree_contents([('this/hello', 'Hello World')])
350
this.commit('Add World')
351
this.merge_from_branch(other.branch)
352
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
355
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
357
self.build_tree_contents([('this/hello', '<<<<<<<')])
359
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
361
self.build_tree_contents([('this/hello', '=======')])
363
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
365
self.build_tree_contents([('this/hello', '\n>>>>>>>')])
366
remaining, resolved = this.auto_resolve()
367
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
369
self.assertEqual([], resolved)
370
self.build_tree_contents([('this/hello', 'hELLO wORLD')])
371
remaining, resolved = this.auto_resolve()
372
self.assertEqual([], this.conflicts())
373
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
375
self.failIfExists('this/hello.BASE')
377
def test_auto_resolve_dir(self):
378
tree = self.make_branch_and_tree('tree')
379
self.build_tree(['tree/hello/'])
380
tree.add('hello', 'hello-id')
381
file_conflict = conflicts.TextConflict('file', None, 'hello-id')
382
tree.set_conflicts(conflicts.ConflictList([file_conflict]))
386
class TestFindTrees(TestCaseWithTransport):
388
def test_find_trees(self):
389
self.make_branch_and_tree('foo')
390
self.make_branch_and_tree('foo/bar')
391
# Sticking a tree inside a control dir is heinous, so let's skip it
392
self.make_branch_and_tree('foo/.bzr/baz')
393
self.make_branch('qux')
394
trees = workingtree.WorkingTree.find_trees('.')
395
self.assertEqual(2, len(list(trees)))
added
removed
bzrlib/tests/test_workingtree.py
