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
26
from bzrlib.lockdir import LockDir
27
from bzrlib.mutabletree import needs_tree_write_lock
28
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
29
from bzrlib.workingtree import (
37
class TestTreeDirectory(TestCaseWithTransport):
39
def test_kind_character(self):
40
self.assertEqual(TreeDirectory().kind_character(), '/')
43
class TestTreeEntry(TestCaseWithTransport):
45
def test_kind_character(self):
46
self.assertEqual(TreeEntry().kind_character(), '???')
49
class TestTreeFile(TestCaseWithTransport):
51
def test_kind_character(self):
52
self.assertEqual(TreeFile().kind_character(), '')
55
class TestTreeLink(TestCaseWithTransport):
57
def test_kind_character(self):
58
self.assertEqual(TreeLink().kind_character(), '')
61
class TestDefaultFormat(TestCaseWithTransport):
63
def test_get_set_default_format(self):
64
old_format = workingtree.format_registry.get_default()
66
self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
67
workingtree.format_registry.set_default(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.format_registry.set_default(old_format)
78
self.assertEqual(old_format, workingtree.format_registry.get_default())
81
tree = self.make_branch_and_tree('.')
82
open_direct = workingtree.WorkingTree.open('.')
83
self.assertEqual(tree.basedir, open_direct.basedir)
84
open_no_args = workingtree.WorkingTree.open()
85
self.assertEqual(tree.basedir, open_no_args.basedir)
87
def test_open_containing(self):
88
tree = self.make_branch_and_tree('.')
89
open_direct, relpath = workingtree.WorkingTree.open_containing('.')
90
self.assertEqual(tree.basedir, open_direct.basedir)
91
self.assertEqual('', relpath)
92
open_no_args, relpath = workingtree.WorkingTree.open_containing()
93
self.assertEqual(tree.basedir, open_no_args.basedir)
94
self.assertEqual('', relpath)
95
open_subdir, relpath = workingtree.WorkingTree.open_containing('subdir')
96
self.assertEqual(tree.basedir, open_subdir.basedir)
97
self.assertEqual('subdir', relpath)
100
class SampleTreeFormat(workingtree.WorkingTreeFormat):
103
this format is initializable, unsupported to aid in testing the
104
open and open_downlevel routines.
107
def get_format_string(self):
108
"""See WorkingTreeFormat.get_format_string()."""
109
return "Sample tree format."
111
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
112
accelerator_tree=None, hardlink=False):
113
"""Sample branches cannot be created."""
114
t = a_bzrdir.get_workingtree_transport(self)
115
t.put_bytes('format', self.get_format_string())
118
def is_supported(self):
121
def open(self, transport, _found=False):
122
return "opened tree."
125
class SampleExtraTreeFormat(workingtree.WorkingTreeFormat):
126
"""A sample format that does not support use in a metadir.
130
def get_format_string(self):
131
# Not usable in a metadir, so no format string
134
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
135
accelerator_tree=None, hardlink=False):
136
raise NotImplementedError(self.initialize)
138
def is_supported(self):
141
def open(self, transport, _found=False):
142
raise NotImplementedError(self.open)
145
class TestWorkingTreeFormat(TestCaseWithTransport):
146
"""Tests for the WorkingTreeFormat facility."""
148
def test_find_format(self):
149
# is the right format object found for a working tree?
150
# create a branch with a few known format objects.
151
self.build_tree(["foo/", "bar/"])
152
def check_format(format, url):
153
dir = format._matchingbzrdir.initialize(url)
154
dir.create_repository()
156
format.initialize(dir)
157
t = transport.get_transport(url)
158
found_format = workingtree.WorkingTreeFormat.find_format(dir)
159
self.assertIsInstance(found_format, format.__class__)
160
check_format(workingtree.WorkingTreeFormat3(), "bar")
162
def test_find_format_no_tree(self):
163
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
164
self.assertRaises(errors.NoWorkingTree,
165
workingtree.WorkingTreeFormat.find_format,
168
def test_find_format_unknown_format(self):
169
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
170
dir.create_repository()
172
SampleTreeFormat().initialize(dir)
173
self.assertRaises(errors.UnknownFormatError,
174
workingtree.WorkingTreeFormat.find_format,
177
def test_register_unregister_format(self):
178
format = SampleTreeFormat()
180
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
181
dir.create_repository()
184
format.initialize(dir)
185
# register a format for it.
186
self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
187
workingtree.WorkingTreeFormat.register_format, format)
188
self.assertTrue(format in
189
self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
190
workingtree.WorkingTreeFormat.get_formats))
191
# which branch.Open will refuse (not supported)
192
self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
193
# but open_downlevel will work
194
self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
195
# unregister the format
196
self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
197
workingtree.WorkingTreeFormat.unregister_format, format)
198
self.assertFalse(format in
199
self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
200
workingtree.WorkingTreeFormat.get_formats))
203
class TestWorkingTreeFormatRegistry(TestCase):
206
super(TestWorkingTreeFormatRegistry, self).setUp()
207
self.registry = workingtree.WorkingTreeFormatRegistry()
209
def test_register_unregister_format(self):
210
format = SampleTreeFormat()
211
self.registry.register(format)
212
self.assertEquals(format, self.registry.get("Sample tree format."))
213
self.registry.remove(format)
214
self.assertRaises(KeyError, self.registry.get, "Sample tree format.")
216
def test_get_all(self):
217
format = SampleTreeFormat()
218
self.assertEquals([], self.registry._get_all())
219
self.registry.register(format)
220
self.assertEquals([format], self.registry._get_all())
222
def test_register_extra(self):
223
format = SampleExtraTreeFormat()
224
self.assertEquals([], self.registry._get_all())
225
self.registry.register_extra(format)
226
self.assertEquals([format], self.registry._get_all())
228
def test_register_extra_lazy(self):
229
self.assertEquals([], self.registry._get_all())
230
self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
231
"SampleExtraTreeFormat")
232
formats = self.registry._get_all()
233
self.assertEquals(1, len(formats))
234
self.assertIsInstance(formats[0], SampleExtraTreeFormat)
237
class TestWorkingTreeFormat3(TestCaseWithTransport):
238
"""Tests specific to WorkingTreeFormat3."""
240
def test_disk_layout(self):
241
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
242
control.create_repository()
243
control.create_branch()
244
tree = workingtree.WorkingTreeFormat3().initialize(control)
246
# format 'Bazaar-NG Working Tree format 3'
247
# inventory = blank inventory
248
# pending-merges = ''
250
# no inventory.basis yet
251
t = control.get_workingtree_transport(None)
252
self.assertEqualDiff('Bazaar-NG Working Tree format 3',
253
t.get('format').read())
254
self.assertEqualDiff(t.get('inventory').read(),
255
'<inventory format="5">\n'
258
self.assertEqualDiff('### bzr hashcache v5\n',
259
t.get('stat-cache').read())
260
self.assertFalse(t.has('inventory.basis'))
261
# no last-revision file means 'None' or 'NULLREVISION'
262
self.assertFalse(t.has('last-revision'))
263
# TODO RBC 20060210 do a commit, check the inventory.basis is created
264
# correctly and last-revision file becomes present.
266
def test_uses_lockdir(self):
267
"""WorkingTreeFormat3 uses its own LockDir:
269
- lock is a directory
270
- when the WorkingTree is locked, LockDir can see that
272
t = self.get_transport()
274
dir = bzrdir.BzrDirMetaFormat1().initialize(url)
275
repo = dir.create_repository()
276
branch = dir.create_branch()
278
tree = workingtree.WorkingTreeFormat3().initialize(dir)
279
except errors.NotLocalUrl:
280
raise TestSkipped('Not a local URL')
281
self.assertIsDirectory('.bzr', t)
282
self.assertIsDirectory('.bzr/checkout', t)
283
self.assertIsDirectory('.bzr/checkout/lock', t)
284
our_lock = LockDir(t, '.bzr/checkout/lock')
285
self.assertEquals(our_lock.peek(), None)
287
self.assertTrue(our_lock.peek())
289
self.assertEquals(our_lock.peek(), None)
291
def test_missing_pending_merges(self):
292
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
293
control.create_repository()
294
control.create_branch()
295
tree = workingtree.WorkingTreeFormat3().initialize(control)
296
tree._transport.delete("pending-merges")
297
self.assertEqual([], tree.get_parent_ids())
300
class InstrumentedTree(object):
301
"""A instrumented tree to check the needs_tree_write_lock decorator."""
306
def lock_tree_write(self):
307
self._locks.append('t')
309
@needs_tree_write_lock
310
def method_with_tree_write_lock(self, *args, **kwargs):
311
"""A lock_tree_write decorated method that returns its arguments."""
314
@needs_tree_write_lock
315
def method_that_raises(self):
316
"""This method causes an exception when called with parameters.
318
This allows the decorator code to be checked - it should still call
323
self._locks.append('u')
326
class TestInstrumentedTree(TestCase):
328
def test_needs_tree_write_lock(self):
329
"""@needs_tree_write_lock should be semantically transparent."""
330
tree = InstrumentedTree()
332
'method_with_tree_write_lock',
333
tree.method_with_tree_write_lock.__name__)
334
self.assertDocstring(
335
"A lock_tree_write decorated method that returns its arguments.",
336
tree.method_with_tree_write_lock)
339
result = tree.method_with_tree_write_lock(1,2,3, a='b')
340
self.assertEqual((args, kwargs), result)
341
self.assertEqual(['t', 'u'], tree._locks)
342
self.assertRaises(TypeError, tree.method_that_raises, 'foo')
343
self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
346
class TestRevert(TestCaseWithTransport):
348
def test_revert_conflicts_recursive(self):
349
this_tree = self.make_branch_and_tree('this-tree')
350
self.build_tree_contents([('this-tree/foo/',),
351
('this-tree/foo/bar', 'bar')])
352
this_tree.add(['foo', 'foo/bar'])
353
this_tree.commit('created foo/bar')
354
other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
355
self.build_tree_contents([('other-tree/foo/bar', 'baz')])
356
other_tree.commit('changed bar')
357
self.build_tree_contents([('this-tree/foo/bar', 'qux')])
358
this_tree.commit('changed qux')
359
this_tree.merge_from_branch(other_tree.branch)
360
self.assertEqual(1, len(this_tree.conflicts()))
361
this_tree.revert(['foo'])
362
self.assertEqual(0, len(this_tree.conflicts()))
365
class TestAutoResolve(TestCaseWithTransport):
367
def test_auto_resolve(self):
368
base = self.make_branch_and_tree('base')
369
self.build_tree_contents([('base/hello', 'Hello')])
370
base.add('hello', 'hello_id')
372
other = base.bzrdir.sprout('other').open_workingtree()
373
self.build_tree_contents([('other/hello', 'hELLO')])
374
other.commit('Case switch')
375
this = base.bzrdir.sprout('this').open_workingtree()
376
self.assertPathExists('this/hello')
377
self.build_tree_contents([('this/hello', 'Hello World')])
378
this.commit('Add World')
379
this.merge_from_branch(other.branch)
380
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
383
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
385
self.build_tree_contents([('this/hello', '<<<<<<<')])
387
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
389
self.build_tree_contents([('this/hello', '=======')])
391
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
393
self.build_tree_contents([('this/hello', '\n>>>>>>>')])
394
remaining, resolved = this.auto_resolve()
395
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
397
self.assertEqual([], resolved)
398
self.build_tree_contents([('this/hello', 'hELLO wORLD')])
399
remaining, resolved = this.auto_resolve()
400
self.assertEqual([], this.conflicts())
401
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
403
self.assertPathDoesNotExist('this/hello.BASE')
405
def test_auto_resolve_dir(self):
406
tree = self.make_branch_and_tree('tree')
407
self.build_tree(['tree/hello/'])
408
tree.add('hello', 'hello-id')
409
file_conflict = conflicts.TextConflict('file', 'hello-id')
410
tree.set_conflicts(conflicts.ConflictList([file_conflict]))
414
class TestFindTrees(TestCaseWithTransport):
416
def test_find_trees(self):
417
self.make_branch_and_tree('foo')
418
self.make_branch_and_tree('foo/bar')
419
# Sticking a tree inside a control dir is heinous, so let's skip it
420
self.make_branch_and_tree('foo/.bzr/baz')
421
self.make_branch('qux')
422
trees = workingtree.WorkingTree.find_trees('.')
423
self.assertEqual(2, len(list(trees)))
added
removed
bzrlib/tests/test_workingtree.py
