46
46
# so won't modernize them now. - mbp 20080430
47
47
class _TestLockableFiles_mixin(object):
49
def test_read_write(self):
50
self.assertRaises(NoSuchFile,
52
deprecated_in((1, 5, 0)),
53
self.lockable.get, 'foo')
54
self.assertRaises(NoSuchFile,
56
deprecated_in((1, 5, 0)),
57
self.lockable.get_utf8, 'foo')
58
self.lockable.lock_write()
60
unicode_string = u'bar\u1234'
61
self.assertEqual(4, len(unicode_string))
62
byte_string = unicode_string.encode('utf-8')
63
self.assertEqual(6, len(byte_string))
64
self.assertRaises(UnicodeEncodeError,
66
deprecated_in((1, 6, 0)),
67
self.lockable.put, 'foo',
68
StringIO(unicode_string))
70
deprecated_in((1, 6, 0)),
72
'foo', StringIO(byte_string))
73
byte_stream = self.applyDeprecated(
74
deprecated_in((1, 5, 0)),
77
self.assertEqual(byte_string, byte_stream.read())
78
unicode_stream = self.applyDeprecated(
79
deprecated_in((1, 5, 0)),
80
self.lockable.get_utf8,
82
self.assertEqual(unicode_string,
83
unicode_stream.read())
84
self.assertRaises(BzrBadParameterNotString,
86
deprecated_in((1, 6, 0)),
87
self.lockable.put_utf8,
89
StringIO(unicode_string))
91
deprecated_in((1, 6, 0)),
92
self.lockable.put_utf8,
95
unicode_stream = self.applyDeprecated(
96
deprecated_in((1, 5, 0)),
97
self.lockable.get_utf8,
99
self.assertEqual(unicode_string,
100
unicode_stream.read())
101
byte_stream = self.applyDeprecated(
102
deprecated_in((1, 5, 0)),
105
self.assertEqual(byte_string, byte_stream.read())
106
self.applyDeprecated(
107
deprecated_in((1, 6, 0)),
108
self.lockable.put_bytes,
109
'raw', 'raw\xffbytes')
110
byte_stream = self.applyDeprecated(
111
deprecated_in((1, 5, 0)),
114
self.assertEqual('raw\xffbytes', byte_stream.read())
116
self.lockable.unlock()
118
def test_locks(self):
119
self.lockable.lock_read()
121
self.assertRaises(ReadOnlyError, self.lockable.put, 'foo',
122
StringIO('bar\u1234'))
124
self.lockable.unlock()
49
126
def test_transactions(self):
50
127
self.assertIs(self.lockable.get_transaction().__class__,
51
128
PassThroughTransaction)
99
177
def test_lock_write_returns_None_refuses_token(self):
100
178
token = self.lockable.lock_write()
101
self.addCleanup(self.lockable.unlock)
102
if token is not None:
103
# This test does not apply, because this lockable supports
105
raise TestNotApplicable("%r uses tokens" % (self.lockable,))
106
self.assertRaises(errors.TokenLockingNotSupported,
107
self.lockable.lock_write, token='token')
180
if token is not None:
181
# This test does not apply, because this lockable supports
183
raise TestNotApplicable("%r uses tokens" % (self.lockable,))
184
self.assertRaises(errors.TokenLockingNotSupported,
185
self.lockable.lock_write, token='token')
187
self.lockable.unlock()
109
189
def test_lock_write_returns_token_when_given_token(self):
110
190
token = self.lockable.lock_write()
111
self.addCleanup(self.lockable.unlock)
113
# This test does not apply, because this lockable refuses
116
new_lockable = self.get_lockable()
117
token_from_new_lockable = new_lockable.lock_write(token=token)
118
self.addCleanup(new_lockable.unlock)
119
self.assertEqual(token, token_from_new_lockable)
193
# This test does not apply, because this lockable refuses
196
new_lockable = self.get_lockable()
197
token_from_new_lockable = new_lockable.lock_write(token=token)
199
self.assertEqual(token, token_from_new_lockable)
201
new_lockable.unlock()
203
self.lockable.unlock()
121
205
def test_lock_write_raises_on_token_mismatch(self):
122
206
token = self.lockable.lock_write()
123
self.addCleanup(self.lockable.unlock)
125
# This test does not apply, because this lockable refuses
128
different_token = token + 'xxx'
129
# Re-using the same lockable instance with a different token will
130
# raise TokenMismatch.
131
self.assertRaises(errors.TokenMismatch,
132
self.lockable.lock_write, token=different_token)
133
# A separate instance for the same lockable will also raise
135
# This detects the case where a caller claims to have a lock (via
136
# the token) for an external resource, but doesn't (the token is
137
# different). Clients need a separate lock object to make sure the
138
# external resource is probed, whereas the existing lock object
140
new_lockable = self.get_lockable()
141
self.assertRaises(errors.TokenMismatch,
142
new_lockable.lock_write, token=different_token)
209
# This test does not apply, because this lockable refuses
212
different_token = token + 'xxx'
213
# Re-using the same lockable instance with a different token will
214
# raise TokenMismatch.
215
self.assertRaises(errors.TokenMismatch,
216
self.lockable.lock_write, token=different_token)
217
# A separate instance for the same lockable will also raise
219
# This detects the case where a caller claims to have a lock (via
220
# the token) for an external resource, but doesn't (the token is
221
# different). Clients need a separate lock object to make sure the
222
# external resource is probed, whereas the existing lock object
224
new_lockable = self.get_lockable()
225
self.assertRaises(errors.TokenMismatch,
226
new_lockable.lock_write, token=different_token)
228
self.lockable.unlock()
144
230
def test_lock_write_with_matching_token(self):
145
231
# If the token matches, so no exception is raised by lock_write.
146
232
token = self.lockable.lock_write()
147
self.addCleanup(self.lockable.unlock)
149
# This test does not apply, because this lockable refuses
152
# The same instance will accept a second lock_write if the specified
154
self.lockable.lock_write(token=token)
155
self.lockable.unlock()
156
# Calling lock_write on a new instance for the same lockable will
158
new_lockable = self.get_lockable()
159
new_lockable.lock_write(token=token)
160
new_lockable.unlock()
235
# This test does not apply, because this lockable refuses
238
# The same instance will accept a second lock_write if the specified
240
self.lockable.lock_write(token=token)
241
self.lockable.unlock()
242
# Calling lock_write on a new instance for the same lockable will
244
new_lockable = self.get_lockable()
245
new_lockable.lock_write(token=token)
246
new_lockable.unlock()
248
self.lockable.unlock()
162
250
def test_unlock_after_lock_write_with_token(self):
163
251
# If lock_write did not physically acquire the lock (because it was
164
252
# passed a token), then unlock should not physically release it.
165
253
token = self.lockable.lock_write()
166
self.addCleanup(self.lockable.unlock)
168
# This test does not apply, because this lockable refuses
171
new_lockable = self.get_lockable()
172
new_lockable.lock_write(token=token)
173
new_lockable.unlock()
174
self.assertTrue(self.lockable.get_physical_lock_status())
256
# This test does not apply, because this lockable refuses
259
new_lockable = self.get_lockable()
260
new_lockable.lock_write(token=token)
261
new_lockable.unlock()
262
self.assertTrue(self.lockable.get_physical_lock_status())
264
self.lockable.unlock()
176
266
def test_lock_write_with_token_fails_when_unlocked(self):
177
267
# Lock and unlock to get a superficially valid token. This mimics a
added
removed
bzrlib/tests/test_lockable_files.py
