1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
|
# frozen_string_literal: true
require_relative '../helper'
describe Dalli::Protocol::ValueSerializer do
describe 'options' do
subject { Dalli::Protocol::ValueSerializer.new(options) }
describe 'serializer' do
describe 'when the serializer option is unspecified' do
let(:options) { {} }
it 'defaults to Marshal' do
assert_equal subject.serializer, Marshal
end
end
describe 'when the serializer option is explicitly specified' do
let(:dummy_serializer) { Object.new }
let(:options) { { serializer: dummy_serializer } }
it 'uses the explicit option' do
assert_equal subject.serializer, dummy_serializer
end
end
end
end
describe 'store' do
let(:bitflags) { rand(32) }
let(:serializer) { Minitest::Mock.new }
let(:serialized_dummy) { SecureRandom.hex(8) }
let(:serializer_options) { { serializer: serializer } }
let(:vs) { Dalli::Protocol::ValueSerializer.new(vs_options) }
let(:vs_options) { { serializer: serializer } }
let(:raw_value) { Object.new }
describe 'when the request options are nil' do
let(:req_options) { nil }
it 'serializes the value' do
serializer.expect :dump, serialized_dummy, [raw_value]
val, newbitflags = vs.store(raw_value, req_options, bitflags)
assert_equal val, serialized_dummy
assert_equal newbitflags, (bitflags | 0x1)
serializer.verify
end
end
describe 'when the request options do not specify a value for the :raw key' do
let(:req_options) { { other: SecureRandom.hex(4) } }
it 'serializes the value' do
serializer.expect :dump, serialized_dummy, [raw_value]
val, newbitflags = vs.store(raw_value, req_options, bitflags)
assert_equal val, serialized_dummy
assert_equal newbitflags, (bitflags | 0x1)
serializer.verify
end
end
describe 'when the request options value for the :raw key is false' do
let(:req_options) { { raw: false } }
it 'serializes the value' do
serializer.expect :dump, serialized_dummy, [raw_value]
val, newbitflags = vs.store(raw_value, req_options, bitflags)
assert_equal val, serialized_dummy
assert_equal newbitflags, (bitflags | 0x1)
serializer.verify
end
end
describe 'when the request options value for the :raw key is true' do
let(:req_options) { { raw: true } }
it 'does not call the serializer and just converts the input value to a string' do
val, newbitflags = vs.store(raw_value, req_options, bitflags)
assert_equal val, raw_value.to_s
assert_equal newbitflags, bitflags
serializer.verify
end
end
describe 'when serialization raises a TimeoutError' do
let(:error_message) { SecureRandom.hex(10) }
let(:serializer) { Marshal }
let(:req_options) { {} }
it 'reraises the Timeout::Error' do
error = ->(_arg) { raise Timeout::Error, error_message }
serializer.stub :dump, error do
exception = assert_raises Timeout::Error do
vs.store(raw_value, req_options, bitflags)
end
assert_equal exception.message, error_message
end
end
end
describe 'when serialization raises an Error that is not a TimeoutError' do
let(:error_message) { SecureRandom.hex(10) }
let(:serializer) { Marshal }
let(:req_options) { {} }
it 'translates that into a MarshalError' do
error = ->(_arg) { raise StandardError, error_message }
serializer.stub :dump, error do
exception = assert_raises Dalli::MarshalError do
vs.store(raw_value, req_options, bitflags)
end
assert_equal exception.message, error_message
end
end
end
describe 'when serialization raises an Error that is not a TimeoutError' do
let(:error_message) { SecureRandom.hex(10) }
let(:serializer) { Marshal }
let(:req_options) { {} }
it 'translates that into a MarshalError' do
error = ->(_arg) { raise StandardError, error_message }
serializer.stub :dump, error do
exception = assert_raises Dalli::MarshalError do
vs.store(raw_value, req_options, bitflags)
end
assert_equal exception.message, error_message
end
end
end
end
describe 'retrieve' do
let(:raw_value) { SecureRandom.hex(8) }
let(:deserialized_dummy) { SecureRandom.hex(8) }
let(:serializer) { Minitest::Mock.new }
let(:vs_options) { { serializer: serializer } }
let(:vs) { Dalli::Protocol::ValueSerializer.new(vs_options) }
describe 'when the bitflags do not specify serialization' do
it 'should return the value without deserializing' do
bitflags = rand(32)
bitflags &= 0xFFFE
assert_equal(0, bitflags & 0x1)
assert_equal vs.retrieve(raw_value, bitflags), raw_value
serializer.verify
end
end
describe 'when the bitflags specify serialization' do
it 'should deserialize the value' do
serializer.expect :load, deserialized_dummy, [raw_value]
bitflags = rand(32)
bitflags |= 0x1
assert_equal(0x1, bitflags & 0x1)
assert_equal vs.retrieve(raw_value, bitflags), deserialized_dummy
serializer.verify
end
end
describe 'when deserialization raises a TypeError for needs to have method `_load' do
let(:error_message) { "needs to have method `_load'" }
let(:serializer) { Marshal }
# TODO: Determine what scenario causes this error
it 'raises UnmarshalError on uninitialized constant' do
error = ->(_arg) { raise TypeError, error_message }
exception = serializer.stub :load, error do
assert_raises Dalli::UnmarshalError do
vs.retrieve(raw_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
end
assert_equal exception.message, "Unable to unmarshal value: #{error_message}"
end
end
describe 'when deserialization raises a TypeError for exception class/object expected' do
let(:error_message) { 'exception class/object expected' }
let(:serializer) { Marshal }
# TODO: Determine what scenario causes this error
it 'raises UnmarshalError on uninitialized constant' do
error = ->(_arg) { raise TypeError, error_message }
exception = serializer.stub :load, error do
assert_raises Dalli::UnmarshalError do
vs.retrieve(raw_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
end
assert_equal exception.message, "Unable to unmarshal value: #{error_message}"
end
end
describe 'when deserialization raises an TypeError for an instance of IO needed' do
let(:error_message) { 'instance of IO needed' }
let(:serializer) { Marshal }
let(:raw_value) { Object.new }
it 'raises UnmarshalError on uninitialized constant' do
exception = assert_raises Dalli::UnmarshalError do
vs.retrieve(raw_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
assert_equal exception.message, "Unable to unmarshal value: #{error_message}"
end
end
describe "when deserialization raises an TypeError for an incompatible marshal file format (can't be read)" do
let(:error_message) { "incompatible marshal file format (can't be read)" }
let(:serializer) { Marshal }
let(:raw_value) { '{"a":"b"}' }
it 'raises UnmarshalError on uninitialized constant' do
exception = assert_raises Dalli::UnmarshalError do
vs.retrieve(raw_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
assert exception.message.start_with?("Unable to unmarshal value: #{error_message}")
end
end
describe 'when deserialization raises a TypeError with a non-matching message' do
let(:error_message) { SecureRandom.hex(10) }
let(:serializer) { Marshal }
it 're-raises TypeError' do
error = ->(_arg) { raise TypeError, error_message }
exception = serializer.stub :load, error do
assert_raises TypeError do
vs.retrieve(raw_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
end
assert_equal error_message, exception.message
end
end
describe 'when deserialization raises a NameError for an uninitialized constant' do
let(:error_message) { 'uninitialized constant Ddd' }
let(:serializer) { Marshal }
# TODO: Determine what scenario causes this error
it 'raises UnmarshalError on uninitialized constant' do
error = ->(_arg) { raise NameError, error_message }
exception = serializer.stub :load, error do
assert_raises Dalli::UnmarshalError do
vs.retrieve(raw_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
end
assert exception.message.start_with?("Unable to unmarshal value: #{error_message}")
end
end
describe 'when deserialization raises a NameError with a non-matching message' do
let(:error_message) { SecureRandom.hex(10) }
let(:serializer) { Marshal }
it 're-raises NameError' do
error = ->(_arg) { raise NameError, error_message }
exception = serializer.stub :load, error do
assert_raises NameError do
vs.retrieve(raw_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
end
assert exception.message.start_with?(error_message)
end
end
describe 'when deserialization raises an ArgumentError for an undefined class' do
let(:error_message) { 'undefined class/module NonexistentClass' }
let(:serializer) { Marshal }
let(:raw_value) { "\x04\bo:\x15NonexistentClass\x00" }
it 'raises UnmarshalError on uninitialized constant' do
exception = assert_raises Dalli::UnmarshalError do
vs.retrieve(raw_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
assert_equal exception.message, "Unable to unmarshal value: #{error_message}"
end
end
describe 'when deserialization raises an ArgumentError for marshal data too short' do
let(:error_message) { 'marshal data too short' }
let(:serializer) { Marshal }
let(:raw_value) { "\x04\bo:\vObj" }
it 'raises UnmarshalError on uninitialized constant' do
exception = assert_raises Dalli::UnmarshalError do
vs.retrieve(raw_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
assert_equal exception.message, "Unable to unmarshal value: #{error_message}"
end
end
describe 'when deserialization raises an ArgumentError with a non-matching message' do
let(:error_message) { SecureRandom.hex(10) }
let(:serializer) { Marshal }
it 're-raises ArgumentError' do
error = ->(_arg) { raise ArgumentError, error_message }
exception = serializer.stub :load, error do
assert_raises ArgumentError do
vs.retrieve(raw_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
end
assert_equal exception.message, error_message
end
end
describe 'when using the default serializer' do
let(:deserialized_value) { SecureRandom.hex(1024) }
let(:serialized_value) { Marshal.dump(deserialized_value) }
let(:vs_options) { {} }
let(:vs) { Dalli::Protocol::ValueSerializer.new(vs_options) }
it 'properly deserializes the serialized value' do
assert_equal vs.retrieve(serialized_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED),
deserialized_value
end
it 'raises UnmarshalError for non-seriaized data' do
assert_raises Dalli::UnmarshalError do
vs.retrieve(:not_serialized_value, Dalli::Protocol::ValueSerializer::FLAG_SERIALIZED)
end
end
end
end
end
|
