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
from bzrlib.conflicts import *
26
import bzrlib.errors as errors
27
from bzrlib.errors import NotBranchError, NotVersionedError
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28
28
from bzrlib.lockdir import LockDir
29
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
30
from bzrlib.tests import TestCaseWithTransport, TestSkipped
31
from bzrlib.trace import mutter
32
from bzrlib.transport import get_transport
33
import bzrlib.workingtree as workingtree
34
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 (
37
39
class TestTreeDirectory(TestCaseWithTransport):
61
63
class TestDefaultFormat(TestCaseWithTransport):
63
65
def test_get_set_default_format(self):
64
old_format = workingtree.WorkingTreeFormat.get_default_format()
66
self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
67
workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
69
# the default branch format is used by the meta dir format
70
# which is not the default bzrdir format at this point
71
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
72
dir.create_repository()
74
result = dir.create_workingtree()
75
self.assertEqual(result, 'A tree')
77
workingtree.WorkingTreeFormat.set_default_format(old_format)
78
self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
81
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(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):
82
131
"""A sample format
84
this format is initializable, unsupported to aid in testing the
133
this format is initializable, unsupported to aid in testing the
85
134
open and open_downlevel routines.
88
def get_format_string(self):
138
def get_format_string(cls):
89
139
"""See WorkingTreeFormat.get_format_string()."""
90
140
return "Sample tree format."
92
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):
93
144
"""Sample branches cannot be created."""
94
145
t = a_bzrdir.get_workingtree_transport(self)
95
t.put('format', StringIO(self.get_format_string()))
146
t.put_bytes('format', self.get_format_string())
98
149
def is_supported(self):
102
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)
105
176
class TestWorkingTreeFormat(TestCaseWithTransport):
106
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))
108
192
def test_find_format(self):
109
193
# is the right format object found for a working tree?
110
194
# create a branch with a few known format objects.
144
228
format.initialize(dir)
145
229
# register a format for it.
146
workingtree.WorkingTreeFormat.register_format(format)
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))
147
235
# which branch.Open will refuse (not supported)
148
236
self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
149
237
# but open_downlevel will work
150
238
self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
151
239
# unregister the format
152
workingtree.WorkingTreeFormat.unregister_format(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)
155
322
class TestWorkingTreeFormat3(TestCaseWithTransport):
206
374
self.assertEquals(our_lock.peek(), None)
208
def create_format2_tree(self, url):
209
return BzrDir.create_standalone_workingtree(url)
211
def test_conflicts_format2(self):
212
# test backwards compatability
213
tree = self.create_format2_tree('.')
214
self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
216
file('lala.BASE', 'wb').write('labase')
217
expected = ContentsConflict('lala')
218
self.assertEqual(list(tree.conflicts()), [expected])
219
file('lala', 'wb').write('la')
220
tree.add('lala', 'lala-id')
221
expected = ContentsConflict('lala', file_id='lala-id')
222
self.assertEqual(list(tree.conflicts()), [expected])
223
file('lala.THIS', 'wb').write('lathis')
224
file('lala.OTHER', 'wb').write('laother')
225
# When "text conflict"s happen, stem, THIS and OTHER are text
226
expected = TextConflict('lala', file_id='lala-id')
227
self.assertEqual(list(tree.conflicts()), [expected])
228
os.unlink('lala.OTHER')
229
os.mkdir('lala.OTHER')
230
expected = ContentsConflict('lala', file_id='lala-id')
231
self.assertEqual(list(tree.conflicts()), [expected])
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
