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
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
18
from bzrlib import (
27
from bzrlib.branch import Branch
28
from bzrlib.bzrdir import BzrDir
29
28
from bzrlib.lockdir import LockDir
30
29
from bzrlib.mutabletree import needs_tree_write_lock
31
from bzrlib.symbol_versioning import zero_thirteen
32
30
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
33
from bzrlib.transport import get_transport
34
31
from bzrlib.workingtree import (
66
63
class TestDefaultFormat(TestCaseWithTransport):
68
65
def test_get_set_default_format(self):
69
old_format = workingtree.WorkingTreeFormat.get_default_format()
71
self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
72
workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
74
# the default branch format is used by the meta dir format
75
# which is not the default bzrdir format at this point
76
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
77
dir.create_repository()
79
result = dir.create_workingtree()
80
self.assertEqual(result, 'A tree')
82
workingtree.WorkingTreeFormat.set_default_format(old_format)
83
self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
86
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):
87
131
"""A sample format
89
this format is initializable, unsupported to aid in testing the
133
this format is initializable, unsupported to aid in testing the
90
134
open and open_downlevel routines.
93
def get_format_string(self):
138
def get_format_string(cls):
94
139
"""See WorkingTreeFormat.get_format_string()."""
95
140
return "Sample tree format."
97
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):
98
144
"""Sample branches cannot be created."""
99
145
t = a_bzrdir.get_workingtree_transport(self)
100
146
t.put_bytes('format', self.get_format_string())
107
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)
110
176
class TestWorkingTreeFormat(TestCaseWithTransport):
111
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))
113
192
def test_find_format(self):
114
193
# is the right format object found for a working tree?
115
194
# create a branch with a few known format objects.
149
228
format.initialize(dir)
150
229
# register a format for it.
151
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))
152
235
# which branch.Open will refuse (not supported)
153
236
self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
154
237
# but open_downlevel will work
155
238
self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
156
239
# unregister the format
157
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))
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)
160
336
class TestWorkingTreeFormat3(TestCaseWithTransport):
215
391
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
216
392
control.create_repository()
217
393
control.create_branch()
218
tree = workingtree.WorkingTreeFormat3().initialize(control)
219
tree._control_files._transport.delete("pending-merges")
394
tree = workingtree_3.WorkingTreeFormat3().initialize(control)
395
tree._transport.delete("pending-merges")
220
396
self.assertEqual([], tree.get_parent_ids())
223
class TestFormat2WorkingTree(TestCaseWithTransport):
224
"""Tests that are specific to format 2 trees."""
226
def create_format2_tree(self, url):
227
return self.make_branch_and_tree(
228
url, format=bzrdir.BzrDirFormat6())
230
def test_conflicts(self):
231
# test backwards compatability
232
tree = self.create_format2_tree('.')
233
self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
235
file('lala.BASE', 'wb').write('labase')
236
expected = conflicts.ContentsConflict('lala')
237
self.assertEqual(list(tree.conflicts()), [expected])
238
file('lala', 'wb').write('la')
239
tree.add('lala', 'lala-id')
240
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
241
self.assertEqual(list(tree.conflicts()), [expected])
242
file('lala.THIS', 'wb').write('lathis')
243
file('lala.OTHER', 'wb').write('laother')
244
# When "text conflict"s happen, stem, THIS and OTHER are text
245
expected = conflicts.TextConflict('lala', file_id='lala-id')
246
self.assertEqual(list(tree.conflicts()), [expected])
247
os.unlink('lala.OTHER')
248
os.mkdir('lala.OTHER')
249
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
250
self.assertEqual(list(tree.conflicts()), [expected])
253
class TestNonFormatSpecificCode(TestCaseWithTransport):
254
"""This class contains tests of workingtree that are not format specific."""
256
def test_gen_file_id(self):
257
file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_file_id,
259
self.assertStartsWith(file_id, 'filename-')
261
def test_gen_root_id(self):
262
file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_root_id)
263
self.assertStartsWith(file_id, 'tree_root-')
266
399
class InstrumentedTree(object):
267
400
"""A instrumented tree to check the needs_tree_write_lock decorator."""
309
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()))
312
464
class TestAutoResolve(TestCaseWithTransport):
314
466
def test_auto_resolve(self):
320
472
self.build_tree_contents([('other/hello', 'hELLO')])
321
473
other.commit('Case switch')
322
474
this = base.bzrdir.sprout('this').open_workingtree()
323
self.failUnlessExists('this/hello')
475
self.assertPathExists('this/hello')
324
476
self.build_tree_contents([('this/hello', 'Hello World')])
325
477
this.commit('Add World')
326
478
this.merge_from_branch(other.branch)
327
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
479
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
328
480
this.conflicts())
329
481
this.auto_resolve()
330
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
482
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
331
483
this.conflicts())
332
484
self.build_tree_contents([('this/hello', '<<<<<<<')])
333
485
this.auto_resolve()
334
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
486
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
335
487
this.conflicts())
336
488
self.build_tree_contents([('this/hello', '=======')])
337
489
this.auto_resolve()
338
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
490
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
339
491
this.conflicts())
340
492
self.build_tree_contents([('this/hello', '\n>>>>>>>')])
341
493
remaining, resolved = this.auto_resolve()
342
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
494
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
343
495
this.conflicts())
344
496
self.assertEqual([], resolved)
345
497
self.build_tree_contents([('this/hello', 'hELLO wORLD')])
346
498
remaining, resolved = this.auto_resolve()
347
499
self.assertEqual([], this.conflicts())
348
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
500
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
350
self.failIfExists('this/hello.BASE')
502
self.assertPathDoesNotExist('this/hello.BASE')
352
504
def test_auto_resolve_dir(self):
353
505
tree = self.make_branch_and_tree('tree')
354
506
self.build_tree(['tree/hello/'])
355
507
tree.add('hello', 'hello-id')
356
file_conflict = conflicts.TextConflict('file', None, 'hello-id')
508
file_conflict = conflicts.TextConflict('file', 'hello-id')
357
509
tree.set_conflicts(conflicts.ConflictList([file_conflict]))
358
510
tree.auto_resolve()
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
