63
59
class TestDefaultFormat(TestCaseWithTransport):
65
61
def test_get_set_default_format(self):
66
old_format = workingtree.format_registry.get_default()
68
self.assertTrue(isinstance(old_format, workingtree_4.WorkingTreeFormat6))
69
workingtree.format_registry.set_default(SampleTreeFormat())
71
# the default branch format is used by the meta dir format
72
# which is not the default bzrdir format at this point
73
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
74
dir.create_repository()
76
result = dir.create_workingtree()
77
self.assertEqual(result, 'A tree')
79
workingtree.format_registry.set_default(old_format)
80
self.assertEqual(old_format, workingtree.format_registry.get_default())
82
def test_from_string(self):
83
self.assertIsInstance(
84
SampleTreeFormat.from_string("Sample tree format."),
86
self.assertRaises(AssertionError,
87
SampleTreeFormat.from_string, "Different format string.")
89
def test_get_set_default_format_by_key(self):
90
old_format = workingtree.format_registry.get_default()
92
format = SampleTreeFormat()
93
workingtree.format_registry.register(format)
94
self.addCleanup(workingtree.format_registry.remove, format)
95
self.assertTrue(isinstance(old_format, workingtree_4.WorkingTreeFormat6))
96
workingtree.format_registry.set_default_key(format.get_format_string())
98
# the default branch format is used by the meta dir format
99
# which is not the default bzrdir format at this point
100
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
101
dir.create_repository()
103
result = dir.create_workingtree()
104
self.assertEqual(result, 'A tree')
106
workingtree.format_registry.set_default_key(
107
old_format.get_format_string())
108
self.assertEqual(old_format, workingtree.format_registry.get_default())
111
tree = self.make_branch_and_tree('.')
112
open_direct = workingtree.WorkingTree.open('.')
113
self.assertEqual(tree.basedir, open_direct.basedir)
114
open_no_args = workingtree.WorkingTree.open()
115
self.assertEqual(tree.basedir, open_no_args.basedir)
117
def test_open_containing(self):
118
tree = self.make_branch_and_tree('.')
119
open_direct, relpath = workingtree.WorkingTree.open_containing('.')
120
self.assertEqual(tree.basedir, open_direct.basedir)
121
self.assertEqual('', relpath)
122
open_no_args, relpath = workingtree.WorkingTree.open_containing()
123
self.assertEqual(tree.basedir, open_no_args.basedir)
124
self.assertEqual('', relpath)
125
open_subdir, relpath = workingtree.WorkingTree.open_containing('subdir')
126
self.assertEqual(tree.basedir, open_subdir.basedir)
127
self.assertEqual('subdir', relpath)
130
class SampleTreeFormat(workingtree.WorkingTreeFormatMetaDir):
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):
131
80
"""A sample format
133
this format is initializable, unsupported to aid in testing the
82
this format is initializable, unsupported to aid in testing the
134
83
open and open_downlevel routines.
138
def get_format_string(cls):
86
def get_format_string(self):
139
87
"""See WorkingTreeFormat.get_format_string()."""
140
88
return "Sample tree format."
142
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
143
accelerator_tree=None, hardlink=False):
90
def initialize(self, a_bzrdir, revision_id=None):
144
91
"""Sample branches cannot be created."""
145
92
t = a_bzrdir.get_workingtree_transport(self)
146
t.put_bytes('format', self.get_format_string())
93
t.put('format', StringIO(self.get_format_string()))
149
96
def is_supported(self):
215
129
dir.create_branch()
216
130
SampleTreeFormat().initialize(dir)
217
131
self.assertRaises(errors.UnknownFormatError,
218
workingtree.WorkingTreeFormatMetaDir.find_format,
132
workingtree.WorkingTreeFormat.find_format,
221
def test_find_format_with_features(self):
222
tree = self.make_branch_and_tree('.', format='2a')
223
tree.update_feature_flags({"name": "necessity"})
224
found_format = workingtree.WorkingTreeFormatMetaDir.find_format(
226
self.assertIsInstance(found_format, workingtree.WorkingTreeFormat)
227
self.assertEqual(found_format.features.get("name"), "necessity")
228
self.assertRaises(errors.MissingFeature, found_format.check_support_status,
230
self.addCleanup(workingtree.WorkingTreeFormatMetaDir.unregister_feature,
232
workingtree.WorkingTreeFormatMetaDir.register_feature("name")
233
found_format.check_support_status(True)
236
class TestWorkingTreeIterEntriesByDir_wSubtrees(TestCaseWithTransport):
238
def make_simple_tree(self):
239
tree = self.make_branch_and_tree('tree', format='development-subtree')
240
self.build_tree(['tree/a/', 'tree/a/b/', 'tree/a/b/c'])
241
tree.set_root_id('root-id')
242
tree.add(['a', 'a/b', 'a/b/c'], ['a-id', 'b-id', 'c-id'])
243
tree.commit('initial')
246
def test_just_directory(self):
247
tree = self.make_simple_tree()
248
self.assertEqual([('directory', 'root-id'),
249
('directory', 'a-id'),
250
('directory', 'b-id'),
252
[(ie.kind, ie.file_id)
253
for path, ie in tree.iter_entries_by_dir()])
254
subtree = self.make_branch_and_tree('tree/a/b')
255
self.assertEqual([('tree-reference', 'b-id')],
256
[(ie.kind, ie.file_id)
257
for path, ie in tree.iter_entries_by_dir(['b-id'])])
259
def test_direct_subtree(self):
260
tree = self.make_simple_tree()
261
subtree = self.make_branch_and_tree('tree/a/b')
262
self.assertEqual([('directory', 'root-id'),
263
('directory', 'a-id'),
264
('tree-reference', 'b-id')],
265
[(ie.kind, ie.file_id)
266
for path, ie in tree.iter_entries_by_dir()])
268
def test_indirect_subtree(self):
269
tree = self.make_simple_tree()
270
subtree = self.make_branch_and_tree('tree/a')
271
self.assertEqual([('directory', 'root-id'),
272
('tree-reference', 'a-id')],
273
[(ie.kind, ie.file_id)
274
for path, ie in tree.iter_entries_by_dir()])
277
class TestWorkingTreeFormatRegistry(TestCase):
280
super(TestWorkingTreeFormatRegistry, self).setUp()
281
self.registry = workingtree.WorkingTreeFormatRegistry()
283
135
def test_register_unregister_format(self):
284
136
format = SampleTreeFormat()
285
self.registry.register(format)
286
self.assertEqual(format, self.registry.get("Sample tree format."))
287
self.registry.remove(format)
288
self.assertRaises(KeyError, self.registry.get, "Sample tree format.")
290
def test_get_all(self):
291
format = SampleTreeFormat()
292
self.assertEqual([], self.registry._get_all())
293
self.registry.register(format)
294
self.assertEqual([format], self.registry._get_all())
296
def test_register_extra(self):
297
format = SampleExtraTreeFormat()
298
self.assertEqual([], self.registry._get_all())
299
self.registry.register_extra(format)
300
self.assertEqual([format], self.registry._get_all())
302
def test_register_extra_lazy(self):
303
self.assertEqual([], self.registry._get_all())
304
self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
305
"SampleExtraTreeFormat")
306
formats = self.registry._get_all()
307
self.assertEqual(1, len(formats))
308
self.assertIsInstance(formats[0], SampleExtraTreeFormat)
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)
311
153
class TestWorkingTreeFormat3(TestCaseWithTransport):
349
190
repo = dir.create_repository()
350
191
branch = dir.create_branch()
352
tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
193
tree = workingtree.WorkingTreeFormat3().initialize(dir)
353
194
except errors.NotLocalUrl:
354
195
raise TestSkipped('Not a local URL')
355
196
self.assertIsDirectory('.bzr', t)
356
197
self.assertIsDirectory('.bzr/checkout', t)
357
198
self.assertIsDirectory('.bzr/checkout/lock', t)
358
199
our_lock = LockDir(t, '.bzr/checkout/lock')
359
self.assertEqual(our_lock.peek(), None)
200
self.assertEquals(our_lock.peek(), None)
360
201
tree.lock_write()
361
202
self.assertTrue(our_lock.peek())
363
self.assertEqual(our_lock.peek(), None)
204
self.assertEquals(our_lock.peek(), None)
365
206
def test_missing_pending_merges(self):
366
207
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
367
208
control.create_repository()
368
209
control.create_branch()
369
tree = workingtree_3.WorkingTreeFormat3().initialize(control)
370
tree._transport.delete("pending-merges")
371
self.assertEqual([], tree.get_parent_ids())
374
class InstrumentedTree(object):
375
"""A instrumented tree to check the needs_tree_write_lock decorator."""
380
def lock_tree_write(self):
381
self._locks.append('t')
383
@needs_tree_write_lock
384
def method_with_tree_write_lock(self, *args, **kwargs):
385
"""A lock_tree_write decorated method that returns its arguments."""
388
@needs_tree_write_lock
389
def method_that_raises(self):
390
"""This method causes an exception when called with parameters.
392
This allows the decorator code to be checked - it should still call
397
self._locks.append('u')
400
class TestInstrumentedTree(TestCase):
402
def test_needs_tree_write_lock(self):
403
"""@needs_tree_write_lock should be semantically transparent."""
404
tree = InstrumentedTree()
406
'method_with_tree_write_lock',
407
tree.method_with_tree_write_lock.__name__)
408
self.assertDocstring(
409
"A lock_tree_write decorated method that returns its arguments.",
410
tree.method_with_tree_write_lock)
413
result = tree.method_with_tree_write_lock(1,2,3, a='b')
414
self.assertEqual((args, kwargs), result)
415
self.assertEqual(['t', 'u'], tree._locks)
416
self.assertRaises(TypeError, tree.method_that_raises, 'foo')
417
self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
420
class TestRevert(TestCaseWithTransport):
422
def test_revert_conflicts_recursive(self):
423
this_tree = self.make_branch_and_tree('this-tree')
424
self.build_tree_contents([('this-tree/foo/',),
425
('this-tree/foo/bar', 'bar')])
426
this_tree.add(['foo', 'foo/bar'])
427
this_tree.commit('created foo/bar')
428
other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
429
self.build_tree_contents([('other-tree/foo/bar', 'baz')])
430
other_tree.commit('changed bar')
431
self.build_tree_contents([('this-tree/foo/bar', 'qux')])
432
this_tree.commit('changed qux')
433
this_tree.merge_from_branch(other_tree.branch)
434
self.assertEqual(1, len(this_tree.conflicts()))
435
this_tree.revert(['foo'])
436
self.assertEqual(0, len(this_tree.conflicts()))
439
class TestAutoResolve(TestCaseWithTransport):
441
def test_auto_resolve(self):
442
base = self.make_branch_and_tree('base')
443
self.build_tree_contents([('base/hello', 'Hello')])
444
base.add('hello', 'hello_id')
446
other = base.bzrdir.sprout('other').open_workingtree()
447
self.build_tree_contents([('other/hello', 'hELLO')])
448
other.commit('Case switch')
449
this = base.bzrdir.sprout('this').open_workingtree()
450
self.assertPathExists('this/hello')
451
self.build_tree_contents([('this/hello', 'Hello World')])
452
this.commit('Add World')
453
this.merge_from_branch(other.branch)
454
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
457
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
459
self.build_tree_contents([('this/hello', '<<<<<<<')])
461
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
463
self.build_tree_contents([('this/hello', '=======')])
465
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
467
self.build_tree_contents([('this/hello', '\n>>>>>>>')])
468
remaining, resolved = this.auto_resolve()
469
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
471
self.assertEqual([], resolved)
472
self.build_tree_contents([('this/hello', 'hELLO wORLD')])
473
remaining, resolved = this.auto_resolve()
474
self.assertEqual([], this.conflicts())
475
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
477
self.assertPathDoesNotExist('this/hello.BASE')
479
def test_auto_resolve_dir(self):
480
tree = self.make_branch_and_tree('tree')
481
self.build_tree(['tree/hello/'])
482
tree.add('hello', 'hello-id')
483
file_conflict = conflicts.TextConflict('file', 'hello-id')
484
tree.set_conflicts(conflicts.ConflictList([file_conflict]))
488
class TestFindTrees(TestCaseWithTransport):
490
def test_find_trees(self):
491
self.make_branch_and_tree('foo')
492
self.make_branch_and_tree('foo/bar')
493
# Sticking a tree inside a control dir is heinous, so let's skip it
494
self.make_branch_and_tree('foo/.bzr/baz')
495
self.make_branch('qux')
496
trees = workingtree.WorkingTree.find_trees('.')
497
self.assertEqual(2, len(list(trees)))
500
class TestStoredUncommitted(TestCaseWithTransport):
502
def store_uncommitted(self):
503
tree = self.make_branch_and_tree('tree')
504
tree.commit('get root in there')
505
self.build_tree_contents([('tree/file', 'content')])
506
tree.add('file', 'file-id')
507
tree.store_uncommitted()
510
def test_store_uncommitted(self):
511
self.store_uncommitted()
512
self.assertPathDoesNotExist('tree/file')
514
def test_store_uncommitted_no_change(self):
515
tree = self.make_branch_and_tree('tree')
516
tree.commit('get root in there')
517
tree.store_uncommitted()
518
self.assertIs(None, tree.branch.get_unshelver(tree))
520
def test_restore_uncommitted(self):
521
with write_locked(self.store_uncommitted()) as tree:
522
tree.restore_uncommitted()
523
self.assertPathExists('tree/file')
524
self.assertIs(None, tree.branch.get_unshelver(tree))
526
def test_restore_uncommitted_none(self):
527
tree = self.make_branch_and_tree('tree')
528
tree.restore_uncommitted()
210
tree = workingtree.WorkingTreeFormat3().initialize(control)
211
tree._control_files._transport.delete("pending-merges")
212
self.assertEqual([], tree.pending_merges())
215
class TestFormat2WorkingTree(TestCaseWithTransport):
216
"""Tests that are specific to format 2 trees."""
218
def create_format2_tree(self, url):
219
return self.make_branch_and_tree(
220
url, format=bzrlib.bzrdir.BzrDirFormat6())
222
def test_conflicts(self):
223
# test backwards compatability
224
tree = self.create_format2_tree('.')
225
self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
227
file('lala.BASE', 'wb').write('labase')
228
expected = conflicts.ContentsConflict('lala')
229
self.assertEqual(list(tree.conflicts()), [expected])
230
file('lala', 'wb').write('la')
231
tree.add('lala', 'lala-id')
232
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
233
self.assertEqual(list(tree.conflicts()), [expected])
234
file('lala.THIS', 'wb').write('lathis')
235
file('lala.OTHER', 'wb').write('laother')
236
# When "text conflict"s happen, stem, THIS and OTHER are text
237
expected = conflicts.TextConflict('lala', file_id='lala-id')
238
self.assertEqual(list(tree.conflicts()), [expected])
239
os.unlink('lala.OTHER')
240
os.mkdir('lala.OTHER')
241
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
242
self.assertEqual(list(tree.conflicts()), [expected])
245
class TestNonFormatSpecificCode(TestCaseWithTransport):
246
"""This class contains tests of workingtree that are not format specific."""
249
def test_gen_file_id(self):
250
gen_file_id = bzrlib.workingtree.gen_file_id
252
# We try to use the filename if possible
253
self.assertStartsWith(gen_file_id('bar'), 'bar-')
255
# but we squash capitalization, and remove non word characters
256
self.assertStartsWith(gen_file_id('Mwoo oof\t m'), 'mwoooofm-')
258
# We also remove leading '.' characters to prevent hidden file-ids
259
self.assertStartsWith(gen_file_id('..gam.py'), 'gam.py-')
260
self.assertStartsWith(gen_file_id('..Mwoo oof\t m'), 'mwoooofm-')
262
# we remove unicode characters, and still don't end up with a
264
self.assertStartsWith(gen_file_id(u'\xe5\xb5.txt'), 'txt-')
266
# Our current method of generating unique ids adds 33 characters
267
# plus an serial number (log10(N) characters)
268
# to the end of the filename. We now restrict the filename portion to
269
# be <= 20 characters, so the maximum length should now be approx < 60
271
# Test both case squashing and length restriction
272
fid = gen_file_id('A'*50 + '.txt')
273
self.assertStartsWith(fid, 'a'*20 + '-')
274
self.failUnless(len(fid) < 60)
276
# restricting length happens after the other actions, so
277
# we preserve as much as possible
278
fid = gen_file_id('\xe5\xb5..aBcd\tefGhijKLMnop\tqrstuvwxyz')
279
self.assertStartsWith(fid, 'abcdefghijklmnopqrst-')
280
self.failUnless(len(fid) < 60)
282
def test_next_id_suffix(self):
283
bzrlib.workingtree._gen_id_suffix = None
284
bzrlib.workingtree._next_id_suffix()
285
self.assertNotEqual(None, bzrlib.workingtree._gen_id_suffix)
286
bzrlib.workingtree._gen_id_suffix = "foo-"
287
bzrlib.workingtree._gen_id_serial = 1
288
self.assertEqual("foo-2", bzrlib.workingtree._next_id_suffix())
289
self.assertEqual("foo-3", bzrlib.workingtree._next_id_suffix())
290
self.assertEqual("foo-4", bzrlib.workingtree._next_id_suffix())
291
self.assertEqual("foo-5", bzrlib.workingtree._next_id_suffix())
292
self.assertEqual("foo-6", bzrlib.workingtree._next_id_suffix())
293
self.assertEqual("foo-7", bzrlib.workingtree._next_id_suffix())
294
self.assertEqual("foo-8", bzrlib.workingtree._next_id_suffix())
295
self.assertEqual("foo-9", bzrlib.workingtree._next_id_suffix())
296
self.assertEqual("foo-10", bzrlib.workingtree._next_id_suffix())
298
def test__translate_ignore_rule(self):
299
tree = self.make_branch_and_tree('.')
300
# translation should return the regex, the number of groups in it,
301
# and the original rule in a tuple.
302
# there are three sorts of ignore rules:
303
# root only - regex is the rule itself without the leading ./
306
tree._translate_ignore_rule("./rootdirrule"))
307
# full path - regex is the rule itself
309
"(path\\/to\\/file$)",
310
tree._translate_ignore_rule("path/to/file"))
311
# basename only rule - regex is a rule that ignores everything up
312
# to the last / in the filename
314
"((?:.*/)?(?!.*/)basenamerule$)",
315
tree._translate_ignore_rule("basenamerule"))
317
def test__combine_ignore_rules(self):
318
tree = self.make_branch_and_tree('.')
319
# the combined ignore regexs need the outer group indices
320
# placed in a dictionary with the rules that were combined.
321
# an empty set of rules
322
# this is returned as a list of combined regex,rule sets, because
323
# python has a limit of 100 combined regexes.
324
compiled_rules = tree._combine_ignore_rules([])
325
self.assertEqual([], compiled_rules)
326
# one of each type of rule.
327
compiled_rules = tree._combine_ignore_rules(
328
["rule1", "rule/two", "./three"])[0]
329
# what type *is* the compiled regex to do an isinstance of ?
330
self.assertEqual(3, compiled_rules[0].groups)
332
{0:"rule1",1:"rule/two",2:"./three"},
335
def test__combine_ignore_rules_grouping(self):
336
tree = self.make_branch_and_tree('.')
337
# when there are too many rules, the output is split into groups of 100
339
for index in range(198):
341
self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
343
def test__get_ignore_rules_as_regex(self):
344
tree = self.make_branch_and_tree('.')
345
# Setup the default ignore list to be empty
346
ignores._set_user_ignores([])
348
# some plugins (shelf) modifies the DEFAULT_IGNORE list in memory
349
# which causes this test to fail so force the DEFAULT_IGNORE
351
orig_default = bzrlib.DEFAULT_IGNORE
352
# Also make sure the runtime ignore list is empty
353
orig_runtime = ignores._runtime_ignores
355
bzrlib.DEFAULT_IGNORE = []
356
ignores._runtime_ignores = set()
358
self.build_tree_contents([('.bzrignore', 'CVS\n.hg\n')])
359
reference_output = tree._combine_ignore_rules(
360
set(['CVS', '.hg']))[0]
361
regex_rules = tree._get_ignore_rules_as_regex()[0]
362
self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
363
self.assertEqual(reference_output[1], regex_rules[1])
365
bzrlib.DEFAULT_IGNORE = orig_default
366
ignores._runtime_ignores = orig_runtime
added
removed
bzrlib/tests/test_workingtree.py
