1
# Copyright (C) 2005, 2006 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
from cStringIO import StringIO
21
from bzrlib import dirstate, ignores
23
from bzrlib.branch import Branch
24
from bzrlib import bzrdir, conflicts, errors, workingtree
25
from bzrlib.bzrdir import BzrDir
26
from bzrlib.errors import NotBranchError, NotVersionedError
27
from bzrlib.lockdir import LockDir
28
from bzrlib.mutabletree import needs_tree_write_lock
29
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
30
from bzrlib.symbol_versioning import zero_thirteen
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
32
from bzrlib.trace import mutter
33
from bzrlib.transport import get_transport
34
from bzrlib.workingtree import (
42
class TestTreeDirectory(TestCaseWithTransport):
44
def test_kind_character(self):
45
self.assertEqual(TreeDirectory().kind_character(), '/')
48
class TestTreeEntry(TestCaseWithTransport):
50
def test_kind_character(self):
51
self.assertEqual(TreeEntry().kind_character(), '???')
54
class TestTreeFile(TestCaseWithTransport):
56
def test_kind_character(self):
57
self.assertEqual(TreeFile().kind_character(), '')
60
class TestTreeLink(TestCaseWithTransport):
62
def test_kind_character(self):
63
self.assertEqual(TreeLink().kind_character(), '')
66
class TestDefaultFormat(TestCaseWithTransport):
68
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):
89
this format is initializable, unsupported to aid in testing the
90
open and open_downlevel routines.
93
def get_format_string(self):
94
"""See WorkingTreeFormat.get_format_string()."""
95
return "Sample tree format."
97
def initialize(self, a_bzrdir, revision_id=None):
98
"""Sample branches cannot be created."""
99
t = a_bzrdir.get_workingtree_transport(self)
100
t.put_bytes('format', self.get_format_string())
103
def is_supported(self):
106
def open(self, transport, _found=False):
107
return "opened tree."
110
class TestWorkingTreeFormat(TestCaseWithTransport):
111
"""Tests for the WorkingTreeFormat facility."""
113
def test_find_format(self):
114
# is the right format object found for a working tree?
115
# create a branch with a few known format objects.
116
self.build_tree(["foo/", "bar/"])
117
def check_format(format, url):
118
dir = format._matchingbzrdir.initialize(url)
119
dir.create_repository()
121
format.initialize(dir)
122
t = get_transport(url)
123
found_format = workingtree.WorkingTreeFormat.find_format(dir)
124
self.failUnless(isinstance(found_format, format.__class__))
125
check_format(workingtree.WorkingTreeFormat3(), "bar")
127
def test_find_format_no_tree(self):
128
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
129
self.assertRaises(errors.NoWorkingTree,
130
workingtree.WorkingTreeFormat.find_format,
133
def test_find_format_unknown_format(self):
134
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
135
dir.create_repository()
137
SampleTreeFormat().initialize(dir)
138
self.assertRaises(errors.UnknownFormatError,
139
workingtree.WorkingTreeFormat.find_format,
142
def test_register_unregister_format(self):
143
format = SampleTreeFormat()
145
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
146
dir.create_repository()
149
format.initialize(dir)
150
# register a format for it.
151
workingtree.WorkingTreeFormat.register_format(format)
152
# which branch.Open will refuse (not supported)
153
self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
154
# but open_downlevel will work
155
self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
156
# unregister the format
157
workingtree.WorkingTreeFormat.unregister_format(format)
160
class TestWorkingTreeFormat3(TestCaseWithTransport):
161
"""Tests specific to WorkingTreeFormat3."""
163
def test_disk_layout(self):
164
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
165
control.create_repository()
166
control.create_branch()
167
tree = workingtree.WorkingTreeFormat3().initialize(control)
169
# format 'Bazaar-NG Working Tree format 3'
170
# inventory = blank inventory
171
# pending-merges = ''
173
# no inventory.basis yet
174
t = control.get_workingtree_transport(None)
175
self.assertEqualDiff('Bazaar-NG Working Tree format 3',
176
t.get('format').read())
177
# self.assertContainsRe(t.get('inventory').read(),
178
# '<inventory file_id="[^"]*" format="5">\n'
181
# WorkingTreeFormat3 doesn't default to creating a unique root id,
182
# because it is incompatible with older bzr versions
183
self.assertContainsRe(t.get('inventory').read(),
184
'<inventory format="5">\n'
187
self.assertEqualDiff('### bzr hashcache v5\n',
188
t.get('stat-cache').read())
189
self.assertFalse(t.has('inventory.basis'))
190
# no last-revision file means 'None' or 'NULLREVISION'
191
self.assertFalse(t.has('last-revision'))
192
# TODO RBC 20060210 do a commit, check the inventory.basis is created
193
# correctly and last-revision file becomes present.
195
def test_uses_lockdir(self):
196
"""WorkingTreeFormat3 uses its own LockDir:
198
- lock is a directory
199
- when the WorkingTree is locked, LockDir can see that
201
t = self.get_transport()
203
dir = bzrdir.BzrDirMetaFormat1().initialize(url)
204
repo = dir.create_repository()
205
branch = dir.create_branch()
207
tree = workingtree.WorkingTreeFormat3().initialize(dir)
208
except errors.NotLocalUrl:
209
raise TestSkipped('Not a local URL')
210
self.assertIsDirectory('.bzr', t)
211
self.assertIsDirectory('.bzr/checkout', t)
212
self.assertIsDirectory('.bzr/checkout/lock', t)
213
our_lock = LockDir(t, '.bzr/checkout/lock')
214
self.assertEquals(our_lock.peek(), None)
216
self.assertTrue(our_lock.peek())
218
self.assertEquals(our_lock.peek(), None)
220
def test_missing_pending_merges(self):
221
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
222
control.create_repository()
223
control.create_branch()
224
tree = workingtree.WorkingTreeFormat3().initialize(control)
225
tree._control_files._transport.delete("pending-merges")
226
self.assertEqual([], tree.get_parent_ids())
229
class TestWorkingTreeFormat4(TestCaseWithTransport):
230
"""Tests specific to WorkingTreeFormat4."""
232
def test_disk_layout(self):
233
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
234
control.create_repository()
235
control.create_branch()
236
tree = workingtree.WorkingTreeFormat4().initialize(control)
238
# format 'Bazaar Working Tree format 4'
240
t = control.get_workingtree_transport(None)
241
self.assertEqualDiff('Bazaar Working Tree format 4\n',
242
t.get('format').read())
243
self.assertEqualDiff('### bzr hashcache v5\n',
244
t.get('stat-cache').read())
245
self.assertFalse(t.has('inventory.basis'))
246
# no last-revision file means 'None' or 'NULLREVISION'
247
self.assertFalse(t.has('last-revision'))
248
# TODO RBC 20060210 do a commit, check the inventory.basis is created
249
# correctly and last-revision file becomes present.
250
# manually make a dirstate toc check the format is as desired.
251
state = dirstate.DirState.on_file(t.local_abspath('dirstate'))
252
self.assertEqual([], state.get_parent_ids())
254
def test_uses_lockdir(self):
255
"""WorkingTreeFormat4 uses its own LockDir:
257
- lock is a directory
258
- when the WorkingTree is locked, LockDir can see that
260
# this test could be factored into a subclass of tests common to both
261
# format 3 and 4, but for now its not much of an issue as there is only one in common.
262
t = self.get_transport()
263
tree = self.make_workingtree()
264
self.assertIsDirectory('.bzr', t)
265
self.assertIsDirectory('.bzr/checkout', t)
266
self.assertIsDirectory('.bzr/checkout/lock', t)
267
our_lock = LockDir(t, '.bzr/checkout/lock')
268
self.assertEquals(our_lock.peek(), None)
270
self.assertTrue(our_lock.peek())
272
self.assertEquals(our_lock.peek(), None)
274
def make_workingtree(self):
276
dir = bzrdir.BzrDirMetaFormat1().initialize(url)
277
repo = dir.create_repository()
278
branch = dir.create_branch()
280
return workingtree.WorkingTreeFormat4().initialize(dir)
281
except errors.NotLocalUrl:
282
raise TestSkipped('Not a local URL')
284
# TODO: test that dirstate also stores & retrieves the parent list of
285
# workingtree-parent revisions, including when they have multiple parents.
286
# (in other words, the case when we're constructing a merge of
287
# revisions which are themselves merges.)
289
# The simplest case is that the the workingtree's primary
290
# parent tree can be retrieved. This is required for all WorkingTrees,
291
# and covered by the generic tests.
293
def test_dirstate_stores_all_parent_inventories(self):
294
tree = self.make_workingtree()
296
# We're going to build in tree a working tree
297
# with three parent trees, with some files in common.
299
# We really don't want to do commit or merge in the new dirstate-based
300
# tree, because that might not work yet. So instead we build
301
# revisions elsewhere and pull them across, doing by hand part of the
302
# work that merge would do.
304
subtree = self.make_branch_and_tree('subdir')
305
# writelock the tree so its repository doesn't get readlocked by
306
# the revision tree locks. This works around the bug where we dont
307
# permit lock upgrading.
309
self.addCleanup(subtree.unlock)
310
self.build_tree(['subdir/file-a',])
311
subtree.add(['file-a'], ['id-a'])
312
rev1 = subtree.commit('commit in subdir')
313
rev1_tree = subtree.basis_tree()
314
rev1_tree.lock_read()
315
self.addCleanup(rev1_tree.unlock)
317
subtree2 = subtree.bzrdir.sprout('subdir2').open_workingtree()
318
self.build_tree(['subdir2/file-b'])
319
subtree2.add(['file-b'], ['id-b'])
320
rev2 = subtree2.commit('commit in subdir2')
321
rev2_tree = subtree2.basis_tree()
322
rev2_tree.lock_read()
323
self.addCleanup(rev2_tree.unlock)
325
subtree.merge_from_branch(subtree2.branch)
326
rev3 = subtree.commit('merge from subdir2')
327
rev3_tree = subtree.basis_tree()
328
rev3_tree.lock_read()
329
self.addCleanup(rev3_tree.unlock)
331
repo = tree.branch.repository
332
repo.fetch(subtree.branch.repository, rev3)
333
# will also pull the others...
335
# tree doesn't contain a text merge yet but we'll just
336
# set the parents as if a merge had taken place.
337
# this should cause the tree data to be folded into the
339
tree.set_parent_trees([
342
(rev3, rev3_tree), ])
344
# now we should be able to get them back out
345
self.assertTreesEqual(tree.revision_tree(rev1), rev1_tree)
346
self.assertTreesEqual(tree.revision_tree(rev2), rev2_tree)
347
self.assertTreesEqual(tree.revision_tree(rev3), rev3_tree)
349
def test_dirstate_doesnt_read_parents_from_repo_when_setting(self):
350
"""Setting parent trees on a dirstate working tree takes
351
the trees it's given and doesn't need to read them from the
354
tree = self.make_workingtree()
356
subtree = self.make_branch_and_tree('subdir')
357
rev1 = subtree.commit('commit in subdir')
358
rev1_tree = subtree.basis_tree()
359
rev1_tree.lock_read()
360
self.addCleanup(rev1_tree.unlock)
362
tree.branch.pull(subtree.branch)
364
# break the repository's legs to make sure it only uses the trees
365
# it's given; any calls to forbidden methods will raise an
367
repo = tree.branch.repository
368
repo.get_revision = self.fail
369
repo.get_inventory = self.fail
370
repo.get_inventory_xml = self.fail
371
# try to set the parent trees.
372
tree.set_parent_trees([(rev1, rev1_tree)])
374
def test_dirstate_doesnt_read_from_repo_when_returning_cache_tree(self):
375
"""Getting parent trees from a dirstate tree does not read from the
376
repos inventory store. This is an important part of the dirstate
377
performance optimisation work.
379
tree = self.make_workingtree()
381
subtree = self.make_branch_and_tree('subdir')
382
# writelock the tree so its repository doesn't get readlocked by
383
# the revision tree locks. This works around the bug where we dont
384
# permit lock upgrading.
386
self.addCleanup(subtree.unlock)
387
rev1 = subtree.commit('commit in subdir')
388
rev1_tree = subtree.basis_tree()
389
rev1_tree.lock_read()
390
self.addCleanup(rev1_tree.unlock)
391
rev2 = subtree.commit('second commit in subdir', allow_pointless=True)
392
rev2_tree = subtree.basis_tree()
393
rev2_tree.lock_read()
394
self.addCleanup(rev2_tree.unlock)
396
tree.branch.pull(subtree.branch)
398
# break the repository's legs to make sure it only uses the trees
399
# it's given; any calls to forbidden methods will raise an
401
repo = tree.branch.repository
402
# dont uncomment this: the revision object must be accessed to
403
# answer 'get_parent_ids' for the revision tree- dirstate does not
404
# cache the parents of a parent tree at this point.
405
#repo.get_revision = self.fail
406
repo.get_inventory = self.fail
407
repo.get_inventory_xml = self.fail
408
# set the parent trees.
409
tree.set_parent_trees([(rev1, rev1_tree), (rev2, rev2_tree)])
410
# read the first tree
411
result_rev1_tree = tree.revision_tree(rev1)
413
result_rev2_tree = tree.revision_tree(rev2)
414
# compare - there should be no differences between the handed and
416
self.assertTreesEqual(rev1_tree, result_rev1_tree)
417
self.assertTreesEqual(rev2_tree, result_rev2_tree)
419
def test_dirstate_doesnt_cache_non_parent_trees(self):
420
"""Getting parent trees from a dirstate tree does not read from the
421
repos inventory store. This is an important part of the dirstate
422
performance optimisation work.
424
tree = self.make_workingtree()
426
# make a tree that we can try for, which is able to be returned but
428
subtree = self.make_branch_and_tree('subdir')
429
rev1 = subtree.commit('commit in subdir')
430
tree.branch.pull(subtree.branch)
432
self.assertRaises(errors.NoSuchRevision, tree.revision_tree, rev1)
434
def test_no_dirstate_outside_lock(self):
435
# temporary test until the code is mature enough to test from outside.
436
"""Getting a dirstate object fails if there is no lock."""
437
def lock_and_call_current_dirstate(tree, lock_method):
438
getattr(tree, lock_method)()
439
tree.current_dirstate()
441
tree = self.make_workingtree()
442
self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
443
lock_and_call_current_dirstate(tree, 'lock_read')
444
self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
445
lock_and_call_current_dirstate(tree, 'lock_write')
446
self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
447
lock_and_call_current_dirstate(tree, 'lock_tree_write')
448
self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
450
def test_new_dirstate_on_new_lock(self):
451
# until we have detection for when a dirstate can be reused, we
452
# want to reparse dirstate on every new lock.
453
known_dirstates = set()
454
def lock_and_compare_all_current_dirstate(tree, lock_method):
455
getattr(tree, lock_method)()
456
state = tree.current_dirstate()
457
self.assertFalse(state in known_dirstates)
458
known_dirstates.add(state)
460
tree = self.make_workingtree()
461
# lock twice with each type to prevent silly per-lock-type bugs.
462
# each lock and compare looks for a unique state object.
463
lock_and_compare_all_current_dirstate(tree, 'lock_read')
464
lock_and_compare_all_current_dirstate(tree, 'lock_read')
465
lock_and_compare_all_current_dirstate(tree, 'lock_tree_write')
466
lock_and_compare_all_current_dirstate(tree, 'lock_tree_write')
467
lock_and_compare_all_current_dirstate(tree, 'lock_write')
468
lock_and_compare_all_current_dirstate(tree, 'lock_write')
471
class TestFormat2WorkingTree(TestCaseWithTransport):
472
"""Tests that are specific to format 2 trees."""
474
def create_format2_tree(self, url):
475
return self.make_branch_and_tree(
476
url, format=bzrlib.bzrdir.BzrDirFormat6())
478
def test_conflicts(self):
479
# test backwards compatability
480
tree = self.create_format2_tree('.')
481
self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
483
file('lala.BASE', 'wb').write('labase')
484
expected = conflicts.ContentsConflict('lala')
485
self.assertEqual(list(tree.conflicts()), [expected])
486
file('lala', 'wb').write('la')
487
tree.add('lala', 'lala-id')
488
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
489
self.assertEqual(list(tree.conflicts()), [expected])
490
file('lala.THIS', 'wb').write('lathis')
491
file('lala.OTHER', 'wb').write('laother')
492
# When "text conflict"s happen, stem, THIS and OTHER are text
493
expected = conflicts.TextConflict('lala', file_id='lala-id')
494
self.assertEqual(list(tree.conflicts()), [expected])
495
os.unlink('lala.OTHER')
496
os.mkdir('lala.OTHER')
497
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
498
self.assertEqual(list(tree.conflicts()), [expected])
501
class TestNonFormatSpecificCode(TestCaseWithTransport):
502
"""This class contains tests of workingtree that are not format specific."""
504
def test_gen_file_id(self):
505
file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_file_id,
507
self.assertStartsWith(file_id, 'filename-')
509
def test_gen_root_id(self):
510
file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_root_id)
511
self.assertStartsWith(file_id, 'tree_root-')
514
class InstrumentedTree(object):
515
"""A instrumented tree to check the needs_tree_write_lock decorator."""
520
def lock_tree_write(self):
521
self._locks.append('t')
523
@needs_tree_write_lock
524
def method_with_tree_write_lock(self, *args, **kwargs):
525
"""A lock_tree_write decorated method that returns its arguments."""
528
@needs_tree_write_lock
529
def method_that_raises(self):
530
"""This method causes an exception when called with parameters.
532
This allows the decorator code to be checked - it should still call
537
self._locks.append('u')
540
class TestInstrumentedTree(TestCase):
542
def test_needs_tree_write_lock(self):
543
"""@needs_tree_write_lock should be semantically transparent."""
544
tree = InstrumentedTree()
546
'method_with_tree_write_lock',
547
tree.method_with_tree_write_lock.__name__)
549
"A lock_tree_write decorated method that returns its arguments.",
550
tree.method_with_tree_write_lock.__doc__)
553
result = tree.method_with_tree_write_lock(1,2,3, a='b')
554
self.assertEqual((args, kwargs), result)
555
self.assertEqual(['t', 'u'], tree._locks)
556
self.assertRaises(TypeError, tree.method_that_raises, 'foo')
557
self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
added
removed
bzrlib/tests/test_workingtree.py
