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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
from bzrlib.branch import Branch
20
from bzrlib.errors import NotVersionedError
21
from bzrlib.selftest import TestCaseInTempDir
22
from bzrlib.trace import mutter
23
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
26
class TestTreeDirectory(TestCaseInTempDir):
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27
from bzrlib.lock import write_locked
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):
28
41
def test_kind_character(self):
29
42
self.assertEqual(TreeDirectory().kind_character(), '/')
32
class TestTreeEntry(TestCaseInTempDir):
45
class TestTreeEntry(TestCaseWithTransport):
34
47
def test_kind_character(self):
35
48
self.assertEqual(TreeEntry().kind_character(), '???')
38
class TestTreeFile(TestCaseInTempDir):
51
class TestTreeFile(TestCaseWithTransport):
40
53
def test_kind_character(self):
41
54
self.assertEqual(TreeFile().kind_character(), '')
44
class TestTreeLink(TestCaseInTempDir):
57
class TestTreeLink(TestCaseWithTransport):
46
59
def test_kind_character(self):
47
60
self.assertEqual(TreeLink().kind_character(), '')
50
class TestWorkingTree(TestCaseInTempDir):
52
def test_listfiles(self):
53
branch = Branch.initialize('.')
55
print >> open('file', 'w'), "content"
56
os.symlink('target', 'symlink')
57
tree = branch.working_tree()
58
files = list(tree.list_files())
59
self.assertEqual(files[0], ('dir', '?', 'directory', None, TreeDirectory()))
60
self.assertEqual(files[1], ('file', '?', 'file', None, TreeFile()))
61
self.assertEqual(files[2], ('symlink', '?', 'symlink', None, TreeLink()))
63
def test_construct_with_branch(self):
64
branch = Branch.initialize('.')
65
tree = WorkingTree(branch.base, branch)
66
self.assertEqual(branch, tree.branch)
67
self.assertEqual(branch.base, tree.basedir)
69
def test_construct_without_branch(self):
70
branch = Branch.initialize('.')
71
tree = WorkingTree(branch.base)
72
self.assertEqual(branch.base, tree.branch.base)
73
self.assertEqual(branch.base, tree.basedir)
75
def test_basic_relpath(self):
76
# for comprehensive relpath tests, see whitebox.py.
77
branch = Branch.initialize('.')
78
tree = WorkingTree(branch.base)
79
self.assertEqual('child',
80
tree.relpath(os.path.join(os.getcwd(), 'child')))
82
def test_lock_locks_branch(self):
83
branch = Branch.initialize('.')
84
tree = WorkingTree(branch.base)
86
self.assertEqual(1, tree.branch._lock_count)
87
self.assertEqual('r', tree.branch._lock_mode)
89
self.assertEqual(None, tree.branch._lock_count)
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_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.assertEquals(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
def test_register_unregister_format(self):
284
format = SampleTreeFormat()
285
self.registry.register(format)
286
self.assertEquals(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.assertEquals([], self.registry._get_all())
293
self.registry.register(format)
294
self.assertEquals([format], self.registry._get_all())
296
def test_register_extra(self):
297
format = SampleExtraTreeFormat()
298
self.assertEquals([], self.registry._get_all())
299
self.registry.register_extra(format)
300
self.assertEquals([format], self.registry._get_all())
302
def test_register_extra_lazy(self):
303
self.assertEquals([], self.registry._get_all())
304
self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
305
"SampleExtraTreeFormat")
306
formats = self.registry._get_all()
307
self.assertEquals(1, len(formats))
308
self.assertIsInstance(formats[0], SampleExtraTreeFormat)
311
class TestWorkingTreeFormat3(TestCaseWithTransport):
312
"""Tests specific to WorkingTreeFormat3."""
314
def test_disk_layout(self):
315
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
316
control.create_repository()
317
control.create_branch()
318
tree = workingtree_3.WorkingTreeFormat3().initialize(control)
320
# format 'Bazaar-NG Working Tree format 3'
321
# inventory = blank inventory
322
# pending-merges = ''
324
# no inventory.basis yet
325
t = control.get_workingtree_transport(None)
326
self.assertEqualDiff('Bazaar-NG Working Tree format 3',
327
t.get('format').read())
328
self.assertEqualDiff(t.get('inventory').read(),
329
'<inventory format="5">\n'
332
self.assertEqualDiff('### bzr hashcache v5\n',
333
t.get('stat-cache').read())
334
self.assertFalse(t.has('inventory.basis'))
335
# no last-revision file means 'None' or 'NULLREVISION'
336
self.assertFalse(t.has('last-revision'))
337
# TODO RBC 20060210 do a commit, check the inventory.basis is created
338
# correctly and last-revision file becomes present.
340
def test_uses_lockdir(self):
341
"""WorkingTreeFormat3 uses its own LockDir:
343
- lock is a directory
344
- when the WorkingTree is locked, LockDir can see that
346
t = self.get_transport()
348
dir = bzrdir.BzrDirMetaFormat1().initialize(url)
349
repo = dir.create_repository()
350
branch = dir.create_branch()
352
tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
353
except errors.NotLocalUrl:
354
raise TestSkipped('Not a local URL')
355
self.assertIsDirectory('.bzr', t)
356
self.assertIsDirectory('.bzr/checkout', t)
357
self.assertIsDirectory('.bzr/checkout/lock', t)
358
our_lock = LockDir(t, '.bzr/checkout/lock')
359
self.assertEquals(our_lock.peek(), None)
91
self.assertEqual(1, tree.branch._lock_count)
92
self.assertEqual('w', tree.branch._lock_mode)
361
self.assertTrue(our_lock.peek())
94
self.assertEqual(None, tree.branch._lock_count)
96
def get_pullable_branches(self):
97
self.build_tree(['from/', 'from/file', 'to/'])
98
br_a = Branch.initialize('from')
100
br_a.working_tree().commit('foo', rev_id='A')
101
br_b = Branch.initialize('to')
105
br_a, br_b = self.get_pullable_branches()
106
br_b.working_tree().pull(br_a)
107
self.failUnless(br_b.has_revision('A'))
108
self.assertEqual(['A'], br_b.revision_history())
110
def test_pull_overwrites(self):
111
br_a, br_b = self.get_pullable_branches()
112
br_b.working_tree().commit('foo', rev_id='B')
113
self.assertEqual(['B'], br_b.revision_history())
114
br_b.working_tree().pull(br_a, overwrite=True)
115
self.failUnless(br_b.has_revision('A'))
116
self.failUnless(br_b.has_revision('B'))
117
self.assertEqual(['A'], br_b.revision_history())
119
def test_revert(self):
120
"""Test selected-file revert"""
121
b = Branch.initialize('.')
123
self.build_tree(['hello.txt'])
124
file('hello.txt', 'w').write('initial hello')
126
self.assertRaises(NotVersionedError,
127
b.working_tree().revert, ['hello.txt'])
130
b.working_tree().commit('create initial hello.txt')
132
self.check_file_contents('hello.txt', 'initial hello')
133
file('hello.txt', 'w').write('new hello')
134
self.check_file_contents('hello.txt', 'new hello')
136
wt = b.working_tree()
138
# revert file modified since last revision
139
wt.revert(['hello.txt'])
140
self.check_file_contents('hello.txt', 'initial hello')
141
self.check_file_contents('hello.txt~', 'new hello')
143
# reverting again does not clobber the backup
144
wt.revert(['hello.txt'])
145
self.check_file_contents('hello.txt', 'initial hello')
146
self.check_file_contents('hello.txt~', 'new hello')
363
self.assertEquals(our_lock.peek(), None)
365
def test_missing_pending_merges(self):
366
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
367
control.create_repository()
368
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()
added
removed
bzrlib/tests/test_workingtree.py
