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
18
from cStringIO import StringIO
22
from bzrlib.branch import Branch
23
import bzrlib.bzrdir as bzrdir
24
from bzrlib.bzrdir import BzrDir
25
import bzrlib.errors as errors
26
from bzrlib.errors import NotBranchError, NotVersionedError
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27
from bzrlib.lock import write_locked
27
28
from bzrlib.lockdir import LockDir
28
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
29
from bzrlib.tests import TestCaseWithTransport, TestSkipped
30
from bzrlib.trace import mutter
31
from bzrlib.transport import get_transport
32
import bzrlib.workingtree as workingtree
33
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
29
from bzrlib.mutabletree import needs_tree_write_lock
30
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
31
from bzrlib.workingtree import (
36
39
class TestTreeDirectory(TestCaseWithTransport):
60
63
class TestDefaultFormat(TestCaseWithTransport):
62
65
def test_get_set_default_format(self):
63
old_format = workingtree.WorkingTreeFormat.get_default_format()
65
self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
66
workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
68
# the default branch format is used by the meta dir format
69
# which is not the default bzrdir format at this point
70
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
71
dir.create_repository()
73
result = dir.create_workingtree()
74
self.assertEqual(result, 'A tree')
76
workingtree.WorkingTreeFormat.set_default_format(old_format)
77
self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
80
class SampleTreeFormat(workingtree.WorkingTreeFormat):
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):
81
131
"""A sample format
83
this format is initializable, unsupported to aid in testing the
133
this format is initializable, unsupported to aid in testing the
84
134
open and open_downlevel routines.
87
def get_format_string(self):
138
def get_format_string(cls):
88
139
"""See WorkingTreeFormat.get_format_string()."""
89
140
return "Sample tree format."
91
def initialize(self, a_bzrdir, revision_id=None):
142
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
143
accelerator_tree=None, hardlink=False):
92
144
"""Sample branches cannot be created."""
93
145
t = a_bzrdir.get_workingtree_transport(self)
94
t.put('format', StringIO(self.get_format_string()))
146
t.put_bytes('format', self.get_format_string())
97
149
def is_supported(self):
101
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)
104
176
class TestWorkingTreeFormat(TestCaseWithTransport):
105
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))
107
192
def test_find_format(self):
108
193
# is the right format object found for a working tree?
109
194
# create a branch with a few known format objects.
130
215
dir.create_branch()
131
216
SampleTreeFormat().initialize(dir)
132
217
self.assertRaises(errors.UnknownFormatError,
133
workingtree.WorkingTreeFormat.find_format,
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()
136
283
def test_register_unregister_format(self):
137
284
format = SampleTreeFormat()
139
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
140
dir.create_repository()
143
format.initialize(dir)
144
# register a format for it.
145
workingtree.WorkingTreeFormat.register_format(format)
146
# which branch.Open will refuse (not supported)
147
self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
148
# but open_downlevel will work
149
self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
150
# unregister the format
151
workingtree.WorkingTreeFormat.unregister_format(format)
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)
154
311
class TestWorkingTreeFormat3(TestCaseWithTransport):
203
361
self.assertTrue(our_lock.peek())
205
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
