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(ValueError,
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))
247
class TestWorkingTreeIterEntriesByDir_wSubtrees(TestCaseWithTransport):
249
def make_simple_tree(self):
250
tree = self.make_branch_and_tree('tree', format='development-subtree')
251
self.build_tree(['tree/a/', 'tree/a/b/', 'tree/a/b/c'])
252
tree.set_root_id('root-id')
253
tree.add(['a', 'a/b', 'a/b/c'], ['a-id', 'b-id', 'c-id'])
254
tree.commit('initial')
257
def test_just_directory(self):
258
tree = self.make_simple_tree()
259
self.assertEqual([('directory', 'root-id'),
260
('directory', 'a-id'),
261
('directory', 'b-id'),
263
[(ie.kind, ie.file_id)
264
for path, ie in tree.iter_entries_by_dir()])
265
subtree = self.make_branch_and_tree('tree/a/b')
266
self.assertEqual([('tree-reference', 'b-id')],
267
[(ie.kind, ie.file_id)
268
for path, ie in tree.iter_entries_by_dir(['b-id'])])
270
def test_direct_subtree(self):
271
tree = self.make_simple_tree()
272
subtree = self.make_branch_and_tree('tree/a/b')
273
self.assertEqual([('directory', 'root-id'),
274
('directory', 'a-id'),
275
('tree-reference', 'b-id')],
276
[(ie.kind, ie.file_id)
277
for path, ie in tree.iter_entries_by_dir()])
279
def test_indirect_subtree(self):
280
tree = self.make_simple_tree()
281
subtree = self.make_branch_and_tree('tree/a')
282
self.assertEqual([('directory', 'root-id'),
283
('tree-reference', 'a-id')],
284
[(ie.kind, ie.file_id)
285
for path, ie in tree.iter_entries_by_dir()])
288
class TestWorkingTreeFormatRegistry(TestCase):
291
super(TestWorkingTreeFormatRegistry, self).setUp()
292
self.registry = workingtree.WorkingTreeFormatRegistry()
294
def test_register_unregister_format(self):
295
format = SampleTreeFormat()
296
self.registry.register(format)
297
self.assertEquals(format, self.registry.get("Sample tree format."))
298
self.registry.remove(format)
299
self.assertRaises(KeyError, self.registry.get, "Sample tree format.")
301
def test_get_all(self):
302
format = SampleTreeFormat()
303
self.assertEquals([], self.registry._get_all())
304
self.registry.register(format)
305
self.assertEquals([format], self.registry._get_all())
307
def test_register_extra(self):
308
format = SampleExtraTreeFormat()
309
self.assertEquals([], self.registry._get_all())
310
self.registry.register_extra(format)
311
self.assertEquals([format], self.registry._get_all())
313
def test_register_extra_lazy(self):
314
self.assertEquals([], self.registry._get_all())
315
self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
316
"SampleExtraTreeFormat")
317
formats = self.registry._get_all()
318
self.assertEquals(1, len(formats))
319
self.assertIsInstance(formats[0], SampleExtraTreeFormat)
322
class TestWorkingTreeFormat3(TestCaseWithTransport):
323
"""Tests specific to WorkingTreeFormat3."""
325
def test_disk_layout(self):
326
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
327
control.create_repository()
328
control.create_branch()
329
tree = workingtree_3.WorkingTreeFormat3().initialize(control)
331
# format 'Bazaar-NG Working Tree format 3'
332
# inventory = blank inventory
333
# pending-merges = ''
335
# no inventory.basis yet
336
t = control.get_workingtree_transport(None)
337
self.assertEqualDiff('Bazaar-NG Working Tree format 3',
338
t.get('format').read())
339
self.assertEqualDiff(t.get('inventory').read(),
340
'<inventory format="5">\n'
343
self.assertEqualDiff('### bzr hashcache v5\n',
344
t.get('stat-cache').read())
345
self.assertFalse(t.has('inventory.basis'))
346
# no last-revision file means 'None' or 'NULLREVISION'
347
self.assertFalse(t.has('last-revision'))
348
# TODO RBC 20060210 do a commit, check the inventory.basis is created
349
# correctly and last-revision file becomes present.
351
def test_uses_lockdir(self):
352
"""WorkingTreeFormat3 uses its own LockDir:
354
- lock is a directory
355
- when the WorkingTree is locked, LockDir can see that
357
t = self.get_transport()
359
dir = bzrdir.BzrDirMetaFormat1().initialize(url)
360
repo = dir.create_repository()
361
branch = dir.create_branch()
363
tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
364
except errors.NotLocalUrl:
365
raise TestSkipped('Not a local URL')
366
self.assertIsDirectory('.bzr', t)
367
self.assertIsDirectory('.bzr/checkout', t)
368
self.assertIsDirectory('.bzr/checkout/lock', t)
369
our_lock = LockDir(t, '.bzr/checkout/lock')
370
self.assertEquals(our_lock.peek(), None)
372
self.assertTrue(our_lock.peek())
374
self.assertEquals(our_lock.peek(), None)
376
def test_missing_pending_merges(self):
377
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
378
control.create_repository()
379
control.create_branch()
380
tree = workingtree_3.WorkingTreeFormat3().initialize(control)
381
tree._transport.delete("pending-merges")
382
self.assertEqual([], tree.get_parent_ids())
385
class InstrumentedTree(object):
386
"""A instrumented tree to check the needs_tree_write_lock decorator."""
391
def lock_tree_write(self):
392
self._locks.append('t')
394
@needs_tree_write_lock
395
def method_with_tree_write_lock(self, *args, **kwargs):
396
"""A lock_tree_write decorated method that returns its arguments."""
399
@needs_tree_write_lock
400
def method_that_raises(self):
401
"""This method causes an exception when called with parameters.
403
This allows the decorator code to be checked - it should still call
408
self._locks.append('u')
411
class TestInstrumentedTree(TestCase):
413
def test_needs_tree_write_lock(self):
414
"""@needs_tree_write_lock should be semantically transparent."""
415
tree = InstrumentedTree()
417
'method_with_tree_write_lock',
418
tree.method_with_tree_write_lock.__name__)
419
self.assertDocstring(
420
"A lock_tree_write decorated method that returns its arguments.",
421
tree.method_with_tree_write_lock)
424
result = tree.method_with_tree_write_lock(1,2,3, a='b')
425
self.assertEqual((args, kwargs), result)
426
self.assertEqual(['t', 'u'], tree._locks)
427
self.assertRaises(TypeError, tree.method_that_raises, 'foo')
428
self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
431
class TestRevert(TestCaseWithTransport):
433
def test_revert_conflicts_recursive(self):
434
this_tree = self.make_branch_and_tree('this-tree')
435
self.build_tree_contents([('this-tree/foo/',),
436
('this-tree/foo/bar', 'bar')])
437
this_tree.add(['foo', 'foo/bar'])
438
this_tree.commit('created foo/bar')
439
other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
440
self.build_tree_contents([('other-tree/foo/bar', 'baz')])
441
other_tree.commit('changed bar')
442
self.build_tree_contents([('this-tree/foo/bar', 'qux')])
443
this_tree.commit('changed qux')
444
this_tree.merge_from_branch(other_tree.branch)
445
self.assertEqual(1, len(this_tree.conflicts()))
446
this_tree.revert(['foo'])
447
self.assertEqual(0, len(this_tree.conflicts()))
450
class TestAutoResolve(TestCaseWithTransport):
452
def test_auto_resolve(self):
453
base = self.make_branch_and_tree('base')
454
self.build_tree_contents([('base/hello', 'Hello')])
455
base.add('hello', 'hello_id')
457
other = base.bzrdir.sprout('other').open_workingtree()
458
self.build_tree_contents([('other/hello', 'hELLO')])
459
other.commit('Case switch')
460
this = base.bzrdir.sprout('this').open_workingtree()
461
self.assertPathExists('this/hello')
462
self.build_tree_contents([('this/hello', 'Hello World')])
463
this.commit('Add World')
464
this.merge_from_branch(other.branch)
465
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
468
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
470
self.build_tree_contents([('this/hello', '<<<<<<<')])
472
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
474
self.build_tree_contents([('this/hello', '=======')])
476
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
478
self.build_tree_contents([('this/hello', '\n>>>>>>>')])
479
remaining, resolved = this.auto_resolve()
480
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
482
self.assertEqual([], resolved)
483
self.build_tree_contents([('this/hello', 'hELLO wORLD')])
484
remaining, resolved = this.auto_resolve()
485
self.assertEqual([], this.conflicts())
486
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
488
self.assertPathDoesNotExist('this/hello.BASE')
490
def test_auto_resolve_dir(self):
491
tree = self.make_branch_and_tree('tree')
492
self.build_tree(['tree/hello/'])
493
tree.add('hello', 'hello-id')
494
file_conflict = conflicts.TextConflict('file', 'hello-id')
495
tree.set_conflicts(conflicts.ConflictList([file_conflict]))
499
class TestFindTrees(TestCaseWithTransport):
501
def test_find_trees(self):
502
self.make_branch_and_tree('foo')
503
self.make_branch_and_tree('foo/bar')
504
# Sticking a tree inside a control dir is heinous, so let's skip it
505
self.make_branch_and_tree('foo/.bzr/baz')
506
self.make_branch('qux')
507
trees = workingtree.WorkingTree.find_trees('.')
508
self.assertEqual(2, len(list(trees)))
added
removed
bzrlib/tests/test_workingtree.py
