Merge lp:~vila/bzr/failing-lock-tests into lp:~bzr/bzr/trunk-old
- failing-lock-tests
- Merge into trunk-old
Proposed by
Vincent Ladeuil
Status: | Merged |
---|---|
Merged at revision: | not available |
Proposed branch: | lp:~vila/bzr/failing-lock-tests |
Merge into: | lp:~bzr/bzr/trunk-old |
Diff against target: | 526 lines |
To merge this branch: | bzr merge lp:~vila/bzr/failing-lock-tests |
Related bugs: |
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
Robert Collins (community) | Approve | ||
Review via email: mp+6418@code.launchpad.net |
Commit message
Description of the change
To post a comment you must log in.
Revision history for this message
Vincent Ladeuil (vila) wrote : | # |
Revision history for this message
Robert Collins (lifeless) wrote : | # |
review approve
I think you should invert the sense of the test, so that
selftest -> lock mismatch is fatal
selftest -Dlock -> lock mismatch warns.
That will give plugin authors immediate feedback even if they use build
scripts or whatever.
We can loosen it up again for 1.15 if plugin authors are having
trouble.
-Rob
review:
Approve
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1 | === modified file 'NEWS' | |||
2 | --- NEWS 2009-05-12 03:47:18 +0000 | |||
3 | +++ NEWS 2009-05-12 08:35:12 +0000 | |||
4 | @@ -167,6 +167,12 @@ | |||
5 | 167 | 167 | ||
6 | 168 | * Updated the bundled ``ConfigObj`` library to 4.6.0 (Matt Nordhoff) | 168 | * Updated the bundled ``ConfigObj`` library to 4.6.0 (Matt Nordhoff) |
7 | 169 | 169 | ||
8 | 170 | Testing | ||
9 | 171 | ******* | ||
10 | 172 | |||
11 | 173 | * ``bzr selftest`` will now fail if lock/unlock are not correctly balanced in | ||
12 | 174 | tests. Using ``-Dlock`` will turn the related failures into warnings. | ||
13 | 175 | (Vincent Ladeuil, Robert Collins) | ||
14 | 170 | 176 | ||
15 | 171 | bzr 1.14 | 177 | bzr 1.14 |
16 | 172 | ########### | 178 | ########### |
17 | 173 | 179 | ||
18 | === modified file 'bzrlib/tests/__init__.py' | |||
19 | --- bzrlib/tests/__init__.py 2009-05-11 06:44:30 +0000 | |||
20 | +++ bzrlib/tests/__init__.py 2009-05-12 08:35:12 +0000 | |||
21 | @@ -884,7 +884,7 @@ | |||
22 | 884 | def _track_locks(self): | 884 | def _track_locks(self): |
23 | 885 | """Track lock activity during tests.""" | 885 | """Track lock activity during tests.""" |
24 | 886 | self._lock_actions = [] | 886 | self._lock_actions = [] |
26 | 887 | self._lock_check_thorough = 'lock' in debug.debug_flags | 887 | self._lock_check_thorough = 'lock' not in debug.debug_flags |
27 | 888 | self.addCleanup(self._check_locks) | 888 | self.addCleanup(self._check_locks) |
28 | 889 | _mod_lock.Lock.hooks.install_named_hook('lock_acquired', | 889 | _mod_lock.Lock.hooks.install_named_hook('lock_acquired', |
29 | 890 | self._lock_acquired, None) | 890 | self._lock_acquired, None) |
30 | 891 | 891 | ||
31 | === modified file 'bzrlib/tests/branch_implementations/test_locking.py' | |||
32 | --- bzrlib/tests/branch_implementations/test_locking.py 2009-04-15 05:39:38 +0000 | |||
33 | +++ bzrlib/tests/branch_implementations/test_locking.py 2009-05-12 08:35:12 +0000 | |||
34 | @@ -432,6 +432,10 @@ | |||
35 | 432 | branch.unlock() | 432 | branch.unlock() |
36 | 433 | # We should be unable to relock the repo. | 433 | # We should be unable to relock the repo. |
37 | 434 | self.assertRaises(errors.LockContention, branch.lock_write) | 434 | self.assertRaises(errors.LockContention, branch.lock_write) |
38 | 435 | # Cleanup | ||
39 | 436 | branch.lock_write(token) | ||
40 | 437 | branch.dont_leave_lock_in_place() | ||
41 | 438 | branch.unlock() | ||
42 | 435 | 439 | ||
43 | 436 | def test_dont_leave_lock_in_place(self): | 440 | def test_dont_leave_lock_in_place(self): |
44 | 437 | branch = self.make_branch('b') | 441 | branch = self.make_branch('b') |
45 | 438 | 442 | ||
46 | === modified file 'bzrlib/tests/per_repository/test_repository.py' | |||
47 | --- bzrlib/tests/per_repository/test_repository.py 2009-04-09 20:23:07 +0000 | |||
48 | +++ bzrlib/tests/per_repository/test_repository.py 2009-05-12 08:35:12 +0000 | |||
49 | @@ -1046,6 +1046,10 @@ | |||
50 | 1046 | repo.unlock() | 1046 | repo.unlock() |
51 | 1047 | # We should be unable to relock the repo. | 1047 | # We should be unable to relock the repo. |
52 | 1048 | self.assertRaises(errors.LockContention, repo.lock_write) | 1048 | self.assertRaises(errors.LockContention, repo.lock_write) |
53 | 1049 | # Cleanup | ||
54 | 1050 | repo.lock_write(token) | ||
55 | 1051 | repo.dont_leave_lock_in_place() | ||
56 | 1052 | repo.unlock() | ||
57 | 1049 | 1053 | ||
58 | 1050 | def test_dont_leave_lock_in_place(self): | 1054 | def test_dont_leave_lock_in_place(self): |
59 | 1051 | repo = self.make_repository('r') | 1055 | repo = self.make_repository('r') |
60 | 1052 | 1056 | ||
61 | === modified file 'bzrlib/tests/per_repository/test_write_group.py' | |||
62 | --- bzrlib/tests/per_repository/test_write_group.py 2009-05-12 01:36:08 +0000 | |||
63 | +++ bzrlib/tests/per_repository/test_write_group.py 2009-05-12 08:35:12 +0000 | |||
64 | @@ -112,13 +112,13 @@ | |||
65 | 112 | self.addCleanup(repo.unlock) | 112 | self.addCleanup(repo.unlock) |
66 | 113 | repo.start_write_group() | 113 | repo.start_write_group() |
67 | 114 | # Damage the repository on the filesystem | 114 | # Damage the repository on the filesystem |
69 | 115 | self.get_transport('').rename('repo', 'foo') | 115 | t = self.get_transport('') |
70 | 116 | t.rename('repo', 'foo') | ||
71 | 117 | self.addCleanup(t.rename, 'foo', 'repo') | ||
72 | 116 | # abort_write_group will not raise an error, because either an | 118 | # abort_write_group will not raise an error, because either an |
73 | 117 | # exception was not generated, or the exception was caught and | 119 | # exception was not generated, or the exception was caught and |
74 | 118 | # suppressed. See also test_pack_repository's test of the same name. | 120 | # suppressed. See also test_pack_repository's test of the same name. |
75 | 119 | self.assertEqual(None, repo.abort_write_group(suppress_errors=True)) | 121 | self.assertEqual(None, repo.abort_write_group(suppress_errors=True)) |
76 | 120 | if token is not None: | ||
77 | 121 | repo.leave_lock_in_place() | ||
78 | 122 | 122 | ||
79 | 123 | class TestGetMissingParentInventories(TestCaseWithRepository): | 123 | class TestGetMissingParentInventories(TestCaseWithRepository): |
80 | 124 | 124 | ||
81 | 125 | 125 | ||
82 | === modified file 'bzrlib/tests/test_lockable_files.py' | |||
83 | --- bzrlib/tests/test_lockable_files.py 2009-04-04 02:50:01 +0000 | |||
84 | +++ bzrlib/tests/test_lockable_files.py 2009-05-12 08:35:12 +0000 | |||
85 | @@ -56,72 +56,68 @@ | |||
86 | 56 | deprecated_in((1, 5, 0)), | 56 | deprecated_in((1, 5, 0)), |
87 | 57 | self.lockable.get_utf8, 'foo') | 57 | self.lockable.get_utf8, 'foo') |
88 | 58 | self.lockable.lock_write() | 58 | self.lockable.lock_write() |
147 | 59 | try: | 59 | self.addCleanup(self.lockable.unlock) |
148 | 60 | unicode_string = u'bar\u1234' | 60 | unicode_string = u'bar\u1234' |
149 | 61 | self.assertEqual(4, len(unicode_string)) | 61 | self.assertEqual(4, len(unicode_string)) |
150 | 62 | byte_string = unicode_string.encode('utf-8') | 62 | byte_string = unicode_string.encode('utf-8') |
151 | 63 | self.assertEqual(6, len(byte_string)) | 63 | self.assertEqual(6, len(byte_string)) |
152 | 64 | self.assertRaises(UnicodeEncodeError, | 64 | self.assertRaises(UnicodeEncodeError, |
153 | 65 | self.applyDeprecated, | 65 | self.applyDeprecated, |
154 | 66 | deprecated_in((1, 6, 0)), | 66 | deprecated_in((1, 6, 0)), |
155 | 67 | self.lockable.put, 'foo', | 67 | self.lockable.put, 'foo', |
156 | 68 | StringIO(unicode_string)) | 68 | StringIO(unicode_string)) |
157 | 69 | self.applyDeprecated( | 69 | self.applyDeprecated( |
158 | 70 | deprecated_in((1, 6, 0)), | 70 | deprecated_in((1, 6, 0)), |
159 | 71 | self.lockable.put, | 71 | self.lockable.put, |
160 | 72 | 'foo', StringIO(byte_string)) | 72 | 'foo', StringIO(byte_string)) |
161 | 73 | byte_stream = self.applyDeprecated( | 73 | byte_stream = self.applyDeprecated( |
162 | 74 | deprecated_in((1, 5, 0)), | 74 | deprecated_in((1, 5, 0)), |
163 | 75 | self.lockable.get, | 75 | self.lockable.get, |
164 | 76 | 'foo') | 76 | 'foo') |
165 | 77 | self.assertEqual(byte_string, byte_stream.read()) | 77 | self.assertEqual(byte_string, byte_stream.read()) |
166 | 78 | unicode_stream = self.applyDeprecated( | 78 | unicode_stream = self.applyDeprecated( |
167 | 79 | deprecated_in((1, 5, 0)), | 79 | deprecated_in((1, 5, 0)), |
168 | 80 | self.lockable.get_utf8, | 80 | self.lockable.get_utf8, |
169 | 81 | 'foo') | 81 | 'foo') |
170 | 82 | self.assertEqual(unicode_string, | 82 | self.assertEqual(unicode_string, |
171 | 83 | unicode_stream.read()) | 83 | unicode_stream.read()) |
172 | 84 | self.assertRaises(BzrBadParameterNotString, | 84 | self.assertRaises(BzrBadParameterNotString, |
173 | 85 | self.applyDeprecated, | 85 | self.applyDeprecated, |
174 | 86 | deprecated_in((1, 6, 0)), | 86 | deprecated_in((1, 6, 0)), |
175 | 87 | self.lockable.put_utf8, | 87 | self.lockable.put_utf8, |
176 | 88 | 'bar', | 88 | 'bar', |
177 | 89 | StringIO(unicode_string)) | 89 | StringIO(unicode_string)) |
178 | 90 | self.applyDeprecated( | 90 | self.applyDeprecated( |
179 | 91 | deprecated_in((1, 6, 0)), | 91 | deprecated_in((1, 6, 0)), |
180 | 92 | self.lockable.put_utf8, | 92 | self.lockable.put_utf8, |
181 | 93 | 'bar', | 93 | 'bar', |
182 | 94 | unicode_string) | 94 | unicode_string) |
183 | 95 | unicode_stream = self.applyDeprecated( | 95 | unicode_stream = self.applyDeprecated( |
184 | 96 | deprecated_in((1, 5, 0)), | 96 | deprecated_in((1, 5, 0)), |
185 | 97 | self.lockable.get_utf8, | 97 | self.lockable.get_utf8, |
186 | 98 | 'bar') | 98 | 'bar') |
187 | 99 | self.assertEqual(unicode_string, | 99 | self.assertEqual(unicode_string, |
188 | 100 | unicode_stream.read()) | 100 | unicode_stream.read()) |
189 | 101 | byte_stream = self.applyDeprecated( | 101 | byte_stream = self.applyDeprecated( |
190 | 102 | deprecated_in((1, 5, 0)), | 102 | deprecated_in((1, 5, 0)), |
191 | 103 | self.lockable.get, | 103 | self.lockable.get, |
192 | 104 | 'bar') | 104 | 'bar') |
193 | 105 | self.assertEqual(byte_string, byte_stream.read()) | 105 | self.assertEqual(byte_string, byte_stream.read()) |
194 | 106 | self.applyDeprecated( | 106 | self.applyDeprecated( |
195 | 107 | deprecated_in((1, 6, 0)), | 107 | deprecated_in((1, 6, 0)), |
196 | 108 | self.lockable.put_bytes, | 108 | self.lockable.put_bytes, |
197 | 109 | 'raw', 'raw\xffbytes') | 109 | 'raw', 'raw\xffbytes') |
198 | 110 | byte_stream = self.applyDeprecated( | 110 | byte_stream = self.applyDeprecated( |
199 | 111 | deprecated_in((1, 5, 0)), | 111 | deprecated_in((1, 5, 0)), |
200 | 112 | self.lockable.get, | 112 | self.lockable.get, |
201 | 113 | 'raw') | 113 | 'raw') |
202 | 114 | self.assertEqual('raw\xffbytes', byte_stream.read()) | 114 | self.assertEqual('raw\xffbytes', byte_stream.read()) |
145 | 115 | finally: | ||
146 | 116 | self.lockable.unlock() | ||
203 | 117 | 115 | ||
204 | 118 | def test_locks(self): | 116 | def test_locks(self): |
205 | 119 | self.lockable.lock_read() | 117 | self.lockable.lock_read() |
211 | 120 | try: | 118 | self.addCleanup(self.lockable.unlock) |
212 | 121 | self.assertRaises(ReadOnlyError, self.lockable.put, 'foo', | 119 | self.assertRaises(ReadOnlyError, self.lockable.put, 'foo', |
213 | 122 | StringIO('bar\u1234')) | 120 | StringIO('bar\u1234')) |
209 | 123 | finally: | ||
210 | 124 | self.lockable.unlock() | ||
214 | 125 | 121 | ||
215 | 126 | def test_transactions(self): | 122 | def test_transactions(self): |
216 | 127 | self.assertIs(self.lockable.get_transaction().__class__, | 123 | self.assertIs(self.lockable.get_transaction().__class__, |
217 | @@ -176,92 +172,80 @@ | |||
218 | 176 | 172 | ||
219 | 177 | def test_lock_write_returns_None_refuses_token(self): | 173 | def test_lock_write_returns_None_refuses_token(self): |
220 | 178 | token = self.lockable.lock_write() | 174 | token = self.lockable.lock_write() |
230 | 179 | try: | 175 | self.addCleanup(self.lockable.unlock) |
231 | 180 | if token is not None: | 176 | if token is not None: |
232 | 181 | # This test does not apply, because this lockable supports | 177 | # This test does not apply, because this lockable supports |
233 | 182 | # tokens. | 178 | # tokens. |
234 | 183 | raise TestNotApplicable("%r uses tokens" % (self.lockable,)) | 179 | raise TestNotApplicable("%r uses tokens" % (self.lockable,)) |
235 | 184 | self.assertRaises(errors.TokenLockingNotSupported, | 180 | self.assertRaises(errors.TokenLockingNotSupported, |
236 | 185 | self.lockable.lock_write, token='token') | 181 | self.lockable.lock_write, token='token') |
228 | 186 | finally: | ||
229 | 187 | self.lockable.unlock() | ||
237 | 188 | 182 | ||
238 | 189 | def test_lock_write_returns_token_when_given_token(self): | 183 | def test_lock_write_returns_token_when_given_token(self): |
239 | 190 | token = self.lockable.lock_write() | 184 | token = self.lockable.lock_write() |
253 | 191 | try: | 185 | self.addCleanup(self.lockable.unlock) |
254 | 192 | if token is None: | 186 | if token is None: |
255 | 193 | # This test does not apply, because this lockable refuses | 187 | # This test does not apply, because this lockable refuses |
256 | 194 | # tokens. | 188 | # tokens. |
257 | 195 | return | 189 | return |
258 | 196 | new_lockable = self.get_lockable() | 190 | new_lockable = self.get_lockable() |
259 | 197 | token_from_new_lockable = new_lockable.lock_write(token=token) | 191 | token_from_new_lockable = new_lockable.lock_write(token=token) |
260 | 198 | try: | 192 | self.addCleanup(new_lockable.unlock) |
261 | 199 | self.assertEqual(token, token_from_new_lockable) | 193 | self.assertEqual(token, token_from_new_lockable) |
249 | 200 | finally: | ||
250 | 201 | new_lockable.unlock() | ||
251 | 202 | finally: | ||
252 | 203 | self.lockable.unlock() | ||
262 | 204 | 194 | ||
263 | 205 | def test_lock_write_raises_on_token_mismatch(self): | 195 | def test_lock_write_raises_on_token_mismatch(self): |
264 | 206 | token = self.lockable.lock_write() | 196 | token = self.lockable.lock_write() |
287 | 207 | try: | 197 | self.addCleanup(self.lockable.unlock) |
288 | 208 | if token is None: | 198 | if token is None: |
289 | 209 | # This test does not apply, because this lockable refuses | 199 | # This test does not apply, because this lockable refuses |
290 | 210 | # tokens. | 200 | # tokens. |
291 | 211 | return | 201 | return |
292 | 212 | different_token = token + 'xxx' | 202 | different_token = token + 'xxx' |
293 | 213 | # Re-using the same lockable instance with a different token will | 203 | # Re-using the same lockable instance with a different token will |
294 | 214 | # raise TokenMismatch. | 204 | # raise TokenMismatch. |
295 | 215 | self.assertRaises(errors.TokenMismatch, | 205 | self.assertRaises(errors.TokenMismatch, |
296 | 216 | self.lockable.lock_write, token=different_token) | 206 | self.lockable.lock_write, token=different_token) |
297 | 217 | # A separate instance for the same lockable will also raise | 207 | # A separate instance for the same lockable will also raise |
298 | 218 | # TokenMismatch. | 208 | # TokenMismatch. |
299 | 219 | # This detects the case where a caller claims to have a lock (via | 209 | # This detects the case where a caller claims to have a lock (via |
300 | 220 | # the token) for an external resource, but doesn't (the token is | 210 | # the token) for an external resource, but doesn't (the token is |
301 | 221 | # different). Clients need a separate lock object to make sure the | 211 | # different). Clients need a separate lock object to make sure the |
302 | 222 | # external resource is probed, whereas the existing lock object | 212 | # external resource is probed, whereas the existing lock object |
303 | 223 | # might cache. | 213 | # might cache. |
304 | 224 | new_lockable = self.get_lockable() | 214 | new_lockable = self.get_lockable() |
305 | 225 | self.assertRaises(errors.TokenMismatch, | 215 | self.assertRaises(errors.TokenMismatch, |
306 | 226 | new_lockable.lock_write, token=different_token) | 216 | new_lockable.lock_write, token=different_token) |
285 | 227 | finally: | ||
286 | 228 | self.lockable.unlock() | ||
307 | 229 | 217 | ||
308 | 230 | def test_lock_write_with_matching_token(self): | 218 | def test_lock_write_with_matching_token(self): |
309 | 231 | # If the token matches, so no exception is raised by lock_write. | 219 | # If the token matches, so no exception is raised by lock_write. |
310 | 232 | token = self.lockable.lock_write() | 220 | token = self.lockable.lock_write() |
327 | 233 | try: | 221 | self.addCleanup(self.lockable.unlock) |
328 | 234 | if token is None: | 222 | if token is None: |
329 | 235 | # This test does not apply, because this lockable refuses | 223 | # This test does not apply, because this lockable refuses |
330 | 236 | # tokens. | 224 | # tokens. |
331 | 237 | return | 225 | return |
332 | 238 | # The same instance will accept a second lock_write if the specified | 226 | # The same instance will accept a second lock_write if the specified |
333 | 239 | # token matches. | 227 | # token matches. |
334 | 240 | self.lockable.lock_write(token=token) | 228 | self.lockable.lock_write(token=token) |
335 | 241 | self.lockable.unlock() | 229 | self.lockable.unlock() |
336 | 242 | # Calling lock_write on a new instance for the same lockable will | 230 | # Calling lock_write on a new instance for the same lockable will |
337 | 243 | # also succeed. | 231 | # also succeed. |
338 | 244 | new_lockable = self.get_lockable() | 232 | new_lockable = self.get_lockable() |
339 | 245 | new_lockable.lock_write(token=token) | 233 | new_lockable.lock_write(token=token) |
340 | 246 | new_lockable.unlock() | 234 | new_lockable.unlock() |
325 | 247 | finally: | ||
326 | 248 | self.lockable.unlock() | ||
341 | 249 | 235 | ||
342 | 250 | def test_unlock_after_lock_write_with_token(self): | 236 | def test_unlock_after_lock_write_with_token(self): |
343 | 251 | # If lock_write did not physically acquire the lock (because it was | 237 | # If lock_write did not physically acquire the lock (because it was |
344 | 252 | # passed a token), then unlock should not physically release it. | 238 | # passed a token), then unlock should not physically release it. |
345 | 253 | token = self.lockable.lock_write() | 239 | token = self.lockable.lock_write() |
357 | 254 | try: | 240 | self.addCleanup(self.lockable.unlock) |
358 | 255 | if token is None: | 241 | if token is None: |
359 | 256 | # This test does not apply, because this lockable refuses | 242 | # This test does not apply, because this lockable refuses |
360 | 257 | # tokens. | 243 | # tokens. |
361 | 258 | return | 244 | return |
362 | 259 | new_lockable = self.get_lockable() | 245 | new_lockable = self.get_lockable() |
363 | 260 | new_lockable.lock_write(token=token) | 246 | new_lockable.lock_write(token=token) |
364 | 261 | new_lockable.unlock() | 247 | new_lockable.unlock() |
365 | 262 | self.assertTrue(self.lockable.get_physical_lock_status()) | 248 | self.assertTrue(self.lockable.get_physical_lock_status()) |
355 | 263 | finally: | ||
356 | 264 | self.lockable.unlock() | ||
366 | 265 | 249 | ||
367 | 266 | def test_lock_write_with_token_fails_when_unlocked(self): | 250 | def test_lock_write_with_token_fails_when_unlocked(self): |
368 | 267 | # Lock and unlock to get a superficially valid token. This mimics a | 251 | # Lock and unlock to get a superficially valid token. This mimics a |
369 | @@ -332,6 +316,11 @@ | |||
370 | 332 | # But should be relockable with a token. | 316 | # But should be relockable with a token. |
371 | 333 | self.lockable.lock_write(token=token) | 317 | self.lockable.lock_write(token=token) |
372 | 334 | self.lockable.unlock() | 318 | self.lockable.unlock() |
373 | 319 | # Cleanup: we should still be able to get the lock, but we restore the | ||
374 | 320 | # behavior to clearing the lock when unlocking. | ||
375 | 321 | self.lockable.lock_write(token=token) | ||
376 | 322 | self.lockable.dont_leave_in_place() | ||
377 | 323 | self.lockable.unlock() | ||
378 | 335 | 324 | ||
379 | 336 | def test_dont_leave_in_place(self): | 325 | def test_dont_leave_in_place(self): |
380 | 337 | token = self.lockable.lock_write() | 326 | token = self.lockable.lock_write() |
381 | 338 | 327 | ||
382 | === modified file 'bzrlib/tests/test_selftest.py' | |||
383 | --- bzrlib/tests/test_selftest.py 2009-04-30 06:16:30 +0000 | |||
384 | +++ bzrlib/tests/test_selftest.py 2009-05-12 08:35:12 +0000 | |||
385 | @@ -622,9 +622,6 @@ | |||
386 | 622 | self.assertRaises(AssertionError, self._check_safety_net) | 622 | self.assertRaises(AssertionError, self._check_safety_net) |
387 | 623 | 623 | ||
388 | 624 | def test_dangling_locks_cause_failures(self): | 624 | def test_dangling_locks_cause_failures(self): |
389 | 625 | # This is currently only enabled during debug runs, so turn debugging | ||
390 | 626 | # on. | ||
391 | 627 | debug.debug_flags.add('lock') | ||
392 | 628 | class TestDanglingLock(TestCaseWithMemoryTransport): | 625 | class TestDanglingLock(TestCaseWithMemoryTransport): |
393 | 629 | def test_function(self): | 626 | def test_function(self): |
394 | 630 | t = self.get_transport('.') | 627 | t = self.get_transport('.') |
395 | 631 | 628 | ||
396 | === modified file 'bzrlib/tests/test_smart.py' | |||
397 | --- bzrlib/tests/test_smart.py 2009-04-28 03:55:56 +0000 | |||
398 | +++ bzrlib/tests/test_smart.py 2009-05-12 08:35:12 +0000 | |||
399 | @@ -586,6 +586,8 @@ | |||
400 | 586 | '') | 586 | '') |
401 | 587 | self.assertEqual(SuccessfulSmartServerResponse(()), result) | 587 | self.assertEqual(SuccessfulSmartServerResponse(()), result) |
402 | 588 | self.assertEqual('bar', config.get_option('foo')) | 588 | self.assertEqual('bar', config.get_option('foo')) |
403 | 589 | # Cleanup | ||
404 | 590 | branch.unlock() | ||
405 | 589 | 591 | ||
406 | 590 | def test_value_name_section(self): | 592 | def test_value_name_section(self): |
407 | 591 | branch = self.make_branch('.') | 593 | branch = self.make_branch('.') |
408 | @@ -597,6 +599,8 @@ | |||
409 | 597 | 'gam') | 599 | 'gam') |
410 | 598 | self.assertEqual(SuccessfulSmartServerResponse(()), result) | 600 | self.assertEqual(SuccessfulSmartServerResponse(()), result) |
411 | 599 | self.assertEqual('bar', config.get_option('foo', 'gam')) | 601 | self.assertEqual('bar', config.get_option('foo', 'gam')) |
412 | 602 | # Cleanup | ||
413 | 603 | branch.unlock() | ||
414 | 600 | 604 | ||
415 | 601 | 605 | ||
416 | 602 | class SetLastRevisionTestBase(TestLockedBranch): | 606 | class SetLastRevisionTestBase(TestLockedBranch): |
417 | @@ -915,17 +919,24 @@ | |||
418 | 915 | # with a new branch object. | 919 | # with a new branch object. |
419 | 916 | new_branch = repository.bzrdir.open_branch() | 920 | new_branch = repository.bzrdir.open_branch() |
420 | 917 | self.assertRaises(errors.LockContention, new_branch.lock_write) | 921 | self.assertRaises(errors.LockContention, new_branch.lock_write) |
421 | 922 | # Cleanup | ||
422 | 923 | request = smart.branch.SmartServerBranchRequestUnlock(backing) | ||
423 | 924 | response = request.execute('', branch_nonce, repository_nonce) | ||
424 | 918 | 925 | ||
425 | 919 | def test_lock_write_on_locked_branch(self): | 926 | def test_lock_write_on_locked_branch(self): |
426 | 920 | backing = self.get_transport() | 927 | backing = self.get_transport() |
427 | 921 | request = smart.branch.SmartServerBranchRequestLockWrite(backing) | 928 | request = smart.branch.SmartServerBranchRequestLockWrite(backing) |
428 | 922 | branch = self.make_branch('.') | 929 | branch = self.make_branch('.') |
430 | 923 | branch.lock_write() | 930 | branch_token = branch.lock_write() |
431 | 924 | branch.leave_lock_in_place() | 931 | branch.leave_lock_in_place() |
432 | 925 | branch.unlock() | 932 | branch.unlock() |
433 | 926 | response = request.execute('') | 933 | response = request.execute('') |
434 | 927 | self.assertEqual( | 934 | self.assertEqual( |
435 | 928 | SmartServerResponse(('LockContention',)), response) | 935 | SmartServerResponse(('LockContention',)), response) |
436 | 936 | # Cleanup | ||
437 | 937 | branch.lock_write(branch_token) | ||
438 | 938 | branch.dont_leave_lock_in_place() | ||
439 | 939 | branch.unlock() | ||
440 | 929 | 940 | ||
441 | 930 | def test_lock_write_with_tokens_on_locked_branch(self): | 941 | def test_lock_write_with_tokens_on_locked_branch(self): |
442 | 931 | backing = self.get_transport() | 942 | backing = self.get_transport() |
443 | @@ -941,6 +952,13 @@ | |||
444 | 941 | branch_token, repo_token) | 952 | branch_token, repo_token) |
445 | 942 | self.assertEqual( | 953 | self.assertEqual( |
446 | 943 | SmartServerResponse(('ok', branch_token, repo_token)), response) | 954 | SmartServerResponse(('ok', branch_token, repo_token)), response) |
447 | 955 | # Cleanup | ||
448 | 956 | branch.repository.lock_write(repo_token) | ||
449 | 957 | branch.repository.dont_leave_lock_in_place() | ||
450 | 958 | branch.repository.unlock() | ||
451 | 959 | branch.lock_write(branch_token) | ||
452 | 960 | branch.dont_leave_lock_in_place() | ||
453 | 961 | branch.unlock() | ||
454 | 944 | 962 | ||
455 | 945 | def test_lock_write_with_mismatched_tokens_on_locked_branch(self): | 963 | def test_lock_write_with_mismatched_tokens_on_locked_branch(self): |
456 | 946 | backing = self.get_transport() | 964 | backing = self.get_transport() |
457 | @@ -956,17 +974,29 @@ | |||
458 | 956 | branch_token+'xxx', repo_token) | 974 | branch_token+'xxx', repo_token) |
459 | 957 | self.assertEqual( | 975 | self.assertEqual( |
460 | 958 | SmartServerResponse(('TokenMismatch',)), response) | 976 | SmartServerResponse(('TokenMismatch',)), response) |
461 | 977 | # Cleanup | ||
462 | 978 | branch.repository.lock_write(repo_token) | ||
463 | 979 | branch.repository.dont_leave_lock_in_place() | ||
464 | 980 | branch.repository.unlock() | ||
465 | 981 | branch.lock_write(branch_token) | ||
466 | 982 | branch.dont_leave_lock_in_place() | ||
467 | 983 | branch.unlock() | ||
468 | 959 | 984 | ||
469 | 960 | def test_lock_write_on_locked_repo(self): | 985 | def test_lock_write_on_locked_repo(self): |
470 | 961 | backing = self.get_transport() | 986 | backing = self.get_transport() |
471 | 962 | request = smart.branch.SmartServerBranchRequestLockWrite(backing) | 987 | request = smart.branch.SmartServerBranchRequestLockWrite(backing) |
472 | 963 | branch = self.make_branch('.', format='knit') | 988 | branch = self.make_branch('.', format='knit') |
476 | 964 | branch.repository.lock_write() | 989 | repo = branch.repository |
477 | 965 | branch.repository.leave_lock_in_place() | 990 | repo_token = repo.lock_write() |
478 | 966 | branch.repository.unlock() | 991 | repo.leave_lock_in_place() |
479 | 992 | repo.unlock() | ||
480 | 967 | response = request.execute('') | 993 | response = request.execute('') |
481 | 968 | self.assertEqual( | 994 | self.assertEqual( |
482 | 969 | SmartServerResponse(('LockContention',)), response) | 995 | SmartServerResponse(('LockContention',)), response) |
483 | 996 | # Cleanup | ||
484 | 997 | repo.lock_write(repo_token) | ||
485 | 998 | repo.dont_leave_lock_in_place() | ||
486 | 999 | repo.unlock() | ||
487 | 970 | 1000 | ||
488 | 971 | def test_lock_write_on_readonly_transport(self): | 1001 | def test_lock_write_on_readonly_transport(self): |
489 | 972 | backing = self.get_readonly_transport() | 1002 | backing = self.get_readonly_transport() |
490 | @@ -1031,6 +1061,10 @@ | |||
491 | 1031 | '', 'branch token', repo_token) | 1061 | '', 'branch token', repo_token) |
492 | 1032 | self.assertEqual( | 1062 | self.assertEqual( |
493 | 1033 | SmartServerResponse(('TokenMismatch',)), response) | 1063 | SmartServerResponse(('TokenMismatch',)), response) |
494 | 1064 | # Cleanup | ||
495 | 1065 | branch.repository.lock_write(repo_token) | ||
496 | 1066 | branch.repository.dont_leave_lock_in_place() | ||
497 | 1067 | branch.repository.unlock() | ||
498 | 1034 | 1068 | ||
499 | 1035 | 1069 | ||
500 | 1036 | class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport): | 1070 | class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport): |
501 | @@ -1282,17 +1316,24 @@ | |||
502 | 1282 | # object. | 1316 | # object. |
503 | 1283 | new_repo = repository.bzrdir.open_repository() | 1317 | new_repo = repository.bzrdir.open_repository() |
504 | 1284 | self.assertRaises(errors.LockContention, new_repo.lock_write) | 1318 | self.assertRaises(errors.LockContention, new_repo.lock_write) |
505 | 1319 | # Cleanup | ||
506 | 1320 | request = smart.repository.SmartServerRepositoryUnlock(backing) | ||
507 | 1321 | response = request.execute('', nonce) | ||
508 | 1285 | 1322 | ||
509 | 1286 | def test_lock_write_on_locked_repo(self): | 1323 | def test_lock_write_on_locked_repo(self): |
510 | 1287 | backing = self.get_transport() | 1324 | backing = self.get_transport() |
511 | 1288 | request = smart.repository.SmartServerRepositoryLockWrite(backing) | 1325 | request = smart.repository.SmartServerRepositoryLockWrite(backing) |
512 | 1289 | repository = self.make_repository('.', format='knit') | 1326 | repository = self.make_repository('.', format='knit') |
514 | 1290 | repository.lock_write() | 1327 | repo_token = repository.lock_write() |
515 | 1291 | repository.leave_lock_in_place() | 1328 | repository.leave_lock_in_place() |
516 | 1292 | repository.unlock() | 1329 | repository.unlock() |
517 | 1293 | response = request.execute('') | 1330 | response = request.execute('') |
518 | 1294 | self.assertEqual( | 1331 | self.assertEqual( |
519 | 1295 | SmartServerResponse(('LockContention',)), response) | 1332 | SmartServerResponse(('LockContention',)), response) |
520 | 1333 | # Cleanup | ||
521 | 1334 | repository.lock_write(repo_token) | ||
522 | 1335 | repository.dont_leave_lock_in_place() | ||
523 | 1336 | repository.unlock() | ||
524 | 1296 | 1337 | ||
525 | 1297 | def test_lock_write_on_readonly_transport(self): | 1338 | def test_lock_write_on_readonly_transport(self): |
526 | 1298 | backing = self.get_readonly_transport() | 1339 | backing = self.get_readonly_transport() |
This fixed all the remaining failures (~30) encountered when running:
bzr selftest -Dlock --no-plugins
We may want to wait a bit before switching to unconditional failure (-Dlock transform the warning into a failure for now), so that plugin authors have a bit more time to address their own failures (1.15rc1 is a bit too close to switch IMHO).