1
# Copyright (C) 2005-2011 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28
from bzrlib.lockdir import LockDir
29
from bzrlib.mutabletree import needs_tree_write_lock
30
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
31
from bzrlib.workingtree import (
39
class TestTreeDirectory(TestCaseWithTransport):
41
def test_kind_character(self):
42
self.assertEqual(TreeDirectory().kind_character(), '/')
45
class TestTreeEntry(TestCaseWithTransport):
47
def test_kind_character(self):
48
self.assertEqual(TreeEntry().kind_character(), '???')
51
class TestTreeFile(TestCaseWithTransport):
53
def test_kind_character(self):
54
self.assertEqual(TreeFile().kind_character(), '')
57
class TestTreeLink(TestCaseWithTransport):
59
def test_kind_character(self):
60
self.assertEqual(TreeLink().kind_character(), '')
63
class TestDefaultFormat(TestCaseWithTransport):
65
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):
133
this format is initializable, unsupported to aid in testing the
134
open and open_downlevel routines.
138
def get_format_string(cls):
139
"""See WorkingTreeFormat.get_format_string()."""
140
return "Sample tree format."
142
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
143
accelerator_tree=None, hardlink=False):
144
"""Sample branches cannot be created."""
145
t = a_bzrdir.get_workingtree_transport(self)
146
t.put_bytes('format', self.get_format_string())
149
def is_supported(self):
152
def open(self, transport, _found=False):
153
return "opened tree."
156
class SampleExtraTreeFormat(workingtree.WorkingTreeFormat):
157
"""A sample format that does not support use in a metadir.
161
def get_format_string(self):
162
# Not usable in a metadir, so no format string
165
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
166
accelerator_tree=None, hardlink=False):
167
raise NotImplementedError(self.initialize)
169
def is_supported(self):
172
def open(self, transport, _found=False):
173
raise NotImplementedError(self.open)
176
class TestWorkingTreeFormat(TestCaseWithTransport):
177
"""Tests for the WorkingTreeFormat facility."""
179
def test_find_format_string(self):
180
# is the right format object found for a working tree?
181
branch = self.make_branch('branch')
182
self.assertRaises(errors.NoWorkingTree,
183
workingtree.WorkingTreeFormatMetaDir.find_format_string, branch.bzrdir)
184
transport = branch.bzrdir.get_workingtree_transport(None)
186
transport.put_bytes("format", "some format name")
187
# The format does not have to be known by Bazaar,
188
# find_format_string just retrieves the name
189
self.assertEquals("some format name",
190
workingtree.WorkingTreeFormatMetaDir.find_format_string(branch.bzrdir))
192
def test_find_format(self):
193
# is the right format object found for a working tree?
194
# create a branch with a few known format objects.
195
self.build_tree(["foo/", "bar/"])
196
def check_format(format, url):
197
dir = format._matchingbzrdir.initialize(url)
198
dir.create_repository()
200
format.initialize(dir)
201
t = transport.get_transport(url)
202
found_format = workingtree.WorkingTreeFormatMetaDir.find_format(dir)
203
self.assertIsInstance(found_format, format.__class__)
204
check_format(workingtree_3.WorkingTreeFormat3(), "bar")
206
def test_find_format_no_tree(self):
207
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
208
self.assertRaises(errors.NoWorkingTree,
209
workingtree.WorkingTreeFormatMetaDir.find_format,
212
def test_find_format_unknown_format(self):
213
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
214
dir.create_repository()
216
SampleTreeFormat().initialize(dir)
217
self.assertRaises(errors.UnknownFormatError,
218
workingtree.WorkingTreeFormatMetaDir.find_format,
221
def test_register_unregister_format(self):
222
format = SampleTreeFormat()
224
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
225
dir.create_repository()
228
format.initialize(dir)
229
# register a format for it.
230
self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
231
workingtree.WorkingTreeFormat.register_format, format)
232
self.assertTrue(format in
233
self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
234
workingtree.WorkingTreeFormat.get_formats))
235
# which branch.Open will refuse (not supported)
236
self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
237
# but open_downlevel will work
238
self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
239
# unregister the format
240
self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
241
workingtree.WorkingTreeFormat.unregister_format, format)
242
self.assertFalse(format in
243
self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
244
workingtree.WorkingTreeFormat.get_formats))
246
def test_find_format_with_features(self):
247
tree = self.make_branch_and_tree('.', format='2a')
248
tree.update_feature_flags({"name": "necessity"})
249
found_format = workingtree.WorkingTreeFormatMetaDir.find_format(
251
self.assertIsInstance(found_format, workingtree.WorkingTreeFormat)
252
self.assertEquals(found_format.features.get("name"), "necessity")
253
self.assertRaises(errors.MissingFeature, found_format.check_support_status,
255
self.addCleanup(workingtree.WorkingTreeFormatMetaDir.unregister_feature,
257
workingtree.WorkingTreeFormatMetaDir.register_feature("name")
258
found_format.check_support_status(True)
261
class TestWorkingTreeIterEntriesByDir_wSubtrees(TestCaseWithTransport):
263
def make_simple_tree(self):
264
tree = self.make_branch_and_tree('tree', format='development-subtree')
265
self.build_tree(['tree/a/', 'tree/a/b/', 'tree/a/b/c'])
266
tree.set_root_id('root-id')
267
tree.add(['a', 'a/b', 'a/b/c'], ['a-id', 'b-id', 'c-id'])
268
tree.commit('initial')
271
def test_just_directory(self):
272
tree = self.make_simple_tree()
273
self.assertEqual([('directory', 'root-id'),
274
('directory', 'a-id'),
275
('directory', 'b-id'),
277
[(ie.kind, ie.file_id)
278
for path, ie in tree.iter_entries_by_dir()])
279
subtree = self.make_branch_and_tree('tree/a/b')
280
self.assertEqual([('tree-reference', 'b-id')],
281
[(ie.kind, ie.file_id)
282
for path, ie in tree.iter_entries_by_dir(['b-id'])])
284
def test_direct_subtree(self):
285
tree = self.make_simple_tree()
286
subtree = self.make_branch_and_tree('tree/a/b')
287
self.assertEqual([('directory', 'root-id'),
288
('directory', 'a-id'),
289
('tree-reference', 'b-id')],
290
[(ie.kind, ie.file_id)
291
for path, ie in tree.iter_entries_by_dir()])
293
def test_indirect_subtree(self):
294
tree = self.make_simple_tree()
295
subtree = self.make_branch_and_tree('tree/a')
296
self.assertEqual([('directory', 'root-id'),
297
('tree-reference', 'a-id')],
298
[(ie.kind, ie.file_id)
299
for path, ie in tree.iter_entries_by_dir()])
302
class TestWorkingTreeFormatRegistry(TestCase):
305
super(TestWorkingTreeFormatRegistry, self).setUp()
306
self.registry = workingtree.WorkingTreeFormatRegistry()
308
def test_register_unregister_format(self):
309
format = SampleTreeFormat()
310
self.registry.register(format)
311
self.assertEquals(format, self.registry.get("Sample tree format."))
312
self.registry.remove(format)
313
self.assertRaises(KeyError, self.registry.get, "Sample tree format.")
315
def test_get_all(self):
316
format = SampleTreeFormat()
317
self.assertEquals([], self.registry._get_all())
318
self.registry.register(format)
319
self.assertEquals([format], self.registry._get_all())
321
def test_register_extra(self):
322
format = SampleExtraTreeFormat()
323
self.assertEquals([], self.registry._get_all())
324
self.registry.register_extra(format)
325
self.assertEquals([format], self.registry._get_all())
327
def test_register_extra_lazy(self):
328
self.assertEquals([], self.registry._get_all())
329
self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
330
"SampleExtraTreeFormat")
331
formats = self.registry._get_all()
332
self.assertEquals(1, len(formats))
333
self.assertIsInstance(formats[0], SampleExtraTreeFormat)
336
class TestWorkingTreeFormat3(TestCaseWithTransport):
337
"""Tests specific to WorkingTreeFormat3."""
339
def test_disk_layout(self):
340
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
341
control.create_repository()
342
control.create_branch()
343
tree = workingtree_3.WorkingTreeFormat3().initialize(control)
345
# format 'Bazaar-NG Working Tree format 3'
346
# inventory = blank inventory
347
# pending-merges = ''
349
# no inventory.basis yet
350
t = control.get_workingtree_transport(None)
351
self.assertEqualDiff('Bazaar-NG Working Tree format 3',
352
t.get('format').read())
353
self.assertEqualDiff(t.get('inventory').read(),
354
'<inventory format="5">\n'
357
self.assertEqualDiff('### bzr hashcache v5\n',
358
t.get('stat-cache').read())
359
self.assertFalse(t.has('inventory.basis'))
360
# no last-revision file means 'None' or 'NULLREVISION'
361
self.assertFalse(t.has('last-revision'))
362
# TODO RBC 20060210 do a commit, check the inventory.basis is created
363
# correctly and last-revision file becomes present.
365
def test_uses_lockdir(self):
366
"""WorkingTreeFormat3 uses its own LockDir:
368
- lock is a directory
369
- when the WorkingTree is locked, LockDir can see that
371
t = self.get_transport()
373
dir = bzrdir.BzrDirMetaFormat1().initialize(url)
374
repo = dir.create_repository()
375
branch = dir.create_branch()
377
tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
378
except errors.NotLocalUrl:
379
raise TestSkipped('Not a local URL')
380
self.assertIsDirectory('.bzr', t)
381
self.assertIsDirectory('.bzr/checkout', t)
382
self.assertIsDirectory('.bzr/checkout/lock', t)
383
our_lock = LockDir(t, '.bzr/checkout/lock')
384
self.assertEquals(our_lock.peek(), None)
386
self.assertTrue(our_lock.peek())
388
self.assertEquals(our_lock.peek(), None)
390
def test_missing_pending_merges(self):
391
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
392
control.create_repository()
393
control.create_branch()
394
tree = workingtree_3.WorkingTreeFormat3().initialize(control)
395
tree._transport.delete("pending-merges")
396
self.assertEqual([], tree.get_parent_ids())
399
class InstrumentedTree(object):
400
"""A instrumented tree to check the needs_tree_write_lock decorator."""
405
def lock_tree_write(self):
406
self._locks.append('t')
408
@needs_tree_write_lock
409
def method_with_tree_write_lock(self, *args, **kwargs):
410
"""A lock_tree_write decorated method that returns its arguments."""
413
@needs_tree_write_lock
414
def method_that_raises(self):
415
"""This method causes an exception when called with parameters.
417
This allows the decorator code to be checked - it should still call
422
self._locks.append('u')
425
class TestInstrumentedTree(TestCase):
427
def test_needs_tree_write_lock(self):
428
"""@needs_tree_write_lock should be semantically transparent."""
429
tree = InstrumentedTree()
431
'method_with_tree_write_lock',
432
tree.method_with_tree_write_lock.__name__)
433
self.assertDocstring(
434
"A lock_tree_write decorated method that returns its arguments.",
435
tree.method_with_tree_write_lock)
438
result = tree.method_with_tree_write_lock(1,2,3, a='b')
439
self.assertEqual((args, kwargs), result)
440
self.assertEqual(['t', 'u'], tree._locks)
441
self.assertRaises(TypeError, tree.method_that_raises, 'foo')
442
self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
445
class TestRevert(TestCaseWithTransport):
447
def test_revert_conflicts_recursive(self):
448
this_tree = self.make_branch_and_tree('this-tree')
449
self.build_tree_contents([('this-tree/foo/',),
450
('this-tree/foo/bar', 'bar')])
451
this_tree.add(['foo', 'foo/bar'])
452
this_tree.commit('created foo/bar')
453
other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
454
self.build_tree_contents([('other-tree/foo/bar', 'baz')])
455
other_tree.commit('changed bar')
456
self.build_tree_contents([('this-tree/foo/bar', 'qux')])
457
this_tree.commit('changed qux')
458
this_tree.merge_from_branch(other_tree.branch)
459
self.assertEqual(1, len(this_tree.conflicts()))
460
this_tree.revert(['foo'])
461
self.assertEqual(0, len(this_tree.conflicts()))
464
class TestAutoResolve(TestCaseWithTransport):
466
def test_auto_resolve(self):
467
base = self.make_branch_and_tree('base')
468
self.build_tree_contents([('base/hello', 'Hello')])
469
base.add('hello', 'hello_id')
471
other = base.bzrdir.sprout('other').open_workingtree()
472
self.build_tree_contents([('other/hello', 'hELLO')])
473
other.commit('Case switch')
474
this = base.bzrdir.sprout('this').open_workingtree()
475
self.assertPathExists('this/hello')
476
self.build_tree_contents([('this/hello', 'Hello World')])
477
this.commit('Add World')
478
this.merge_from_branch(other.branch)
479
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
482
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
484
self.build_tree_contents([('this/hello', '<<<<<<<')])
486
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
488
self.build_tree_contents([('this/hello', '=======')])
490
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
492
self.build_tree_contents([('this/hello', '\n>>>>>>>')])
493
remaining, resolved = this.auto_resolve()
494
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
496
self.assertEqual([], resolved)
497
self.build_tree_contents([('this/hello', 'hELLO wORLD')])
498
remaining, resolved = this.auto_resolve()
499
self.assertEqual([], this.conflicts())
500
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
502
self.assertPathDoesNotExist('this/hello.BASE')
504
def test_auto_resolve_dir(self):
505
tree = self.make_branch_and_tree('tree')
506
self.build_tree(['tree/hello/'])
507
tree.add('hello', 'hello-id')
508
file_conflict = conflicts.TextConflict('file', 'hello-id')
509
tree.set_conflicts(conflicts.ConflictList([file_conflict]))
513
class TestFindTrees(TestCaseWithTransport):
515
def test_find_trees(self):
516
self.make_branch_and_tree('foo')
517
self.make_branch_and_tree('foo/bar')
518
# Sticking a tree inside a control dir is heinous, so let's skip it
519
self.make_branch_and_tree('foo/.bzr/baz')
520
self.make_branch('qux')
521
trees = workingtree.WorkingTree.find_trees('.')
522
self.assertEqual(2, len(list(trees)))
added
removed
bzrlib/tests/test_workingtree.py
