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
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
272
376
class InstrumentedTree(object):
273
377
"""A instrumented tree to check the needs_tree_write_lock decorator."""
313
417
self.assertEqual(['t', 'u'], tree._locks)
314
418
self.assertRaises(TypeError, tree.method_that_raises, 'foo')
315
419
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
