13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
"""Tests for the (un)lock interfaces on all working tree implemenations."""
56
56
self.assertFalse(wt.is_locked())
57
57
self.assertFalse(wt.branch.is_locked())
59
59
def test_trivial_lock_tree_write_unlock(self):
60
60
"""Locking for tree write is ok when the branch is not locked."""
61
61
wt = self.make_branch_and_tree('.')
71
71
self.assertFalse(wt.is_locked())
72
72
self.assertFalse(wt.branch.is_locked())
74
74
def test_trivial_lock_tree_write_branch_read_locked(self):
75
75
"""It is ok to lock_tree_write when the branch is read locked."""
76
76
wt = self.make_branch_and_tree('.')
82
82
wt.lock_tree_write()
83
83
except errors.ReadOnlyError:
84
# When ReadOnlyError is raised, it indicates that the
84
# When ReadOnlyError is raised, it indicates that the
85
85
# workingtree shares its lock with the branch, which is what
86
86
# the git/hg/bzr0.6 formats do.
87
87
# in this case, no lock should have been taken - but the tree
99
99
self.assertFalse(wt.is_locked())
100
100
self.assertTrue(wt.branch.is_locked())
101
101
wt.branch.unlock()
103
103
def _test_unlock_with_lock_method(self, methodname):
104
104
"""Create a tree and then test its unlocking behaviour.
109
109
# the tree should do a flush().
110
110
# we test that by changing the inventory using set_root_id
111
111
tree = self.make_branch_and_tree('tree')
112
# prepare for a series of changes that will modify the
112
# prepare for a series of changes that will modify the
114
114
getattr(tree, methodname)()
115
115
# note that we dont have a try:finally here because of two reasons:
116
# firstly there will only be errors reported if the test fails, and
116
# firstly there will only be errors reported if the test fails, and
117
117
# when it fails thats ok as long as the test suite cleanup still works,
118
# which it will as the lock objects are released (thats where the
119
# warning comes from. Secondly, it is hard in this test to be
118
# which it will as the lock objects are released (thats where the
119
# warning comes from. Secondly, it is hard in this test to be
120
120
# sure that we've got the right interactions between try:finally
121
121
# and the lock/unlocks we are doing.
122
122
getattr(tree, methodname)()
123
123
# this should really do something within the public api
124
124
# e.g. mkdir('foo') but all the mutating methods at the
125
# moment trigger inventory writes and thus will not
125
# moment trigger inventory writes and thus will not
126
126
# let us trigger a read-when-dirty situation.
127
127
old_root = tree.get_root_id()
128
128
tree.set_root_id('new-root')
143
143
def test_unlock_from_tree_write_lock_flushes(self):
144
144
self._test_unlock_with_lock_method("lock_tree_write")
146
146
def test_unlock_from_write_lock_flushes(self):
147
147
self._test_unlock_with_lock_method("lock_write")
149
149
def test_unlock_branch_failures(self):
150
150
"""If the branch unlock fails the tree must still unlock."""
151
151
# The public interface for WorkingTree requires a branch, but
155
155
# in order to test that implementations which *do* unlock via the branch
156
156
# do so correctly, we unlock the branch after locking the working tree.
157
157
# The next unlock on working tree should trigger a LockNotHeld exception
158
# from the branch object, which must be exposed to the caller. To meet
158
# from the branch object, which must be exposed to the caller. To meet
159
159
# our object model - where locking a tree locks its branch, and
160
# unlocking a branch does not unlock a working tree, *even* for
160
# unlocking a branch does not unlock a working tree, *even* for
161
161
# all-in-one implementations like bzr 0.6, git, and hg, implementations
162
# must have some separate counter for each object, so our explicit
163
# unlock should trigger some error on all implementations, and
162
# must have some separate counter for each object, so our explicit
163
# unlock should trigger some error on all implementations, and
164
164
# requiring that to be LockNotHeld seems reasonable.
166
166
# we use this approach rather than decorating the Branch, because the
167
167
# public interface of WorkingTree does not permit altering the branch
168
# object - and we cannot tell which attribute might allow us to
168
# object - and we cannot tell which attribute might allow us to
169
169
# backdoor-in and change it reliably. For implementation specific tests
170
170
# we can do such skullduggery, but not for interface specific tests.
171
171
# And, its simpler :)
218
218
def test_failing_to_lock_write_branch_does_not_lock(self):
219
219
"""If the branch cannot be write locked, dont lock the tree."""
220
# all implementations of branch are required to treat write
220
# all implementations of branch are required to treat write
221
221
# locks as blocking (compare to repositories which are not required
223
223
# Accordingly we test this by opening the branch twice, and locking the
added
removed
bzrlib/tests/workingtree_implementations/test_locking.py
