dry-validation 0.9.2 → 0.9.3

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,455 +0,0 @@
1
- RSpec.context 'Predicates: Included In' do
2
- context 'with required' do
3
- subject(:schema) do
4
- Dry::Validation.Schema do
5
- required(:foo) { included_in?([1, 3, 5]) }
6
- end
7
- end
8
-
9
- context 'with valid input' do
10
- let(:input) { { foo: 3 } }
11
-
12
- it 'is successful' do
13
- expect(result).to be_successful
14
- end
15
- end
16
-
17
- context 'with missing input' do
18
- let(:input) { {} }
19
-
20
- it 'is not successful' do
21
- expect(result).to be_failing ['is missing', 'must be one of: 1, 3, 5']
22
- end
23
- end
24
-
25
- context 'with nil input' do
26
- let(:input) { { foo: nil } }
27
-
28
- it 'is not successful' do
29
- expect(result).to be_failing ['must be one of: 1, 3, 5']
30
- end
31
- end
32
-
33
- context 'with blank input' do
34
- let(:input) { { foo: '' } }
35
-
36
- it 'is not successful' do
37
- expect(result).to be_failing ['must be one of: 1, 3, 5']
38
- end
39
- end
40
-
41
- context 'with invalid type' do
42
- let(:input) { { foo: { a: 1 } } }
43
-
44
- it 'is not successful' do
45
- expect(result).to be_failing ['must be one of: 1, 3, 5']
46
- end
47
- end
48
-
49
- context 'with invalid input' do
50
- let(:input) { { foo: 4 } }
51
-
52
- it 'is not successful' do
53
- expect(result).to be_failing ['must be one of: 1, 3, 5']
54
- end
55
- end
56
- end
57
-
58
- context 'with optional' do
59
- subject(:schema) do
60
- Dry::Validation.Schema do
61
- optional(:foo) { included_in?([1, 3, 5]) }
62
- end
63
- end
64
-
65
- context 'with valid input' do
66
- let(:input) { { foo: 3 } }
67
-
68
- it 'is successful' do
69
- expect(result).to be_successful
70
- end
71
- end
72
-
73
- context 'with missing input' do
74
- let(:input) { {} }
75
-
76
- it 'is successful' do
77
- expect(result).to be_successful
78
- end
79
- end
80
-
81
- context 'with nil input' do
82
- let(:input) { { foo: nil } }
83
-
84
- it 'is not successful' do
85
- expect(result).to be_failing ['must be one of: 1, 3, 5']
86
- end
87
- end
88
-
89
- context 'with blank input' do
90
- let(:input) { { foo: '' } }
91
-
92
- it 'is not successful' do
93
- expect(result).to be_failing ['must be one of: 1, 3, 5']
94
- end
95
- end
96
-
97
- context 'with invalid type' do
98
- let(:input) { { foo: { a: 1 } } }
99
-
100
- it 'is not successful' do
101
- expect(result).to be_failing ['must be one of: 1, 3, 5']
102
- end
103
- end
104
-
105
- context 'with invalid input' do
106
- let(:input) { { foo: 4 } }
107
-
108
- it 'is not successful' do
109
- expect(result).to be_failing ['must be one of: 1, 3, 5']
110
- end
111
- end
112
- end
113
-
114
- context 'as macro' do
115
- context 'with required' do
116
- context 'with value' do
117
- subject(:schema) do
118
- Dry::Validation.Schema do
119
- required(:foo).value(included_in?: [1, 3, 5])
120
- end
121
- end
122
-
123
- context 'with valid input' do
124
- let(:input) { { foo: 3 } }
125
-
126
- it 'is successful' do
127
- expect(result).to be_successful
128
- end
129
- end
130
-
131
- context 'with missing input' do
132
- let(:input) { {} }
133
-
134
- it 'is not successful' do
135
- expect(result).to be_failing ['is missing', 'must be one of: 1, 3, 5']
136
- end
137
- end
138
-
139
- context 'with nil input' do
140
- let(:input) { { foo: nil } }
141
-
142
- it 'is not successful' do
143
- expect(result).to be_failing ['must be one of: 1, 3, 5']
144
- end
145
- end
146
-
147
- context 'with blank input' do
148
- let(:input) { { foo: '' } }
149
-
150
- it 'is not successful' do
151
- expect(result).to be_failing ['must be one of: 1, 3, 5']
152
- end
153
- end
154
-
155
- context 'with invalid type' do
156
- let(:input) { { foo: { a: 1 } } }
157
-
158
- it 'is not successful' do
159
- expect(result).to be_failing ['must be one of: 1, 3, 5']
160
- end
161
- end
162
-
163
- context 'with invalid input' do
164
- let(:input) { { foo: 4 } }
165
-
166
- it 'is not successful' do
167
- expect(result).to be_failing ['must be one of: 1, 3, 5']
168
- end
169
- end
170
- end
171
-
172
- context 'with filled' do
173
- subject(:schema) do
174
- Dry::Validation.Schema do
175
- required(:foo).filled(included_in?: [1, 3, 5])
176
- end
177
- end
178
-
179
- context 'with valid input' do
180
- let(:input) { { foo: 3 } }
181
-
182
- it 'is successful' do
183
- expect(result).to be_successful
184
- end
185
- end
186
-
187
- context 'with missing input' do
188
- let(:input) { {} }
189
-
190
- it 'is not successful' do
191
- expect(result).to be_failing ['is missing', 'must be one of: 1, 3, 5']
192
- end
193
- end
194
-
195
- context 'with nil input' do
196
- let(:input) { { foo: nil } }
197
-
198
- it 'is not successful' do
199
- expect(result).to be_failing ['must be filled', 'must be one of: 1, 3, 5']
200
- end
201
- end
202
-
203
- context 'with blank input' do
204
- let(:input) { { foo: '' } }
205
-
206
- it 'is not successful' do
207
- expect(result).to be_failing ['must be filled', 'must be one of: 1, 3, 5']
208
- end
209
- end
210
-
211
- context 'with invalid type' do
212
- let(:input) { { foo: { a: 1 } } }
213
-
214
- it 'is not successful' do
215
- expect(result).to be_failing ['must be one of: 1, 3, 5']
216
- end
217
- end
218
-
219
- context 'with invalid input' do
220
- let(:input) { { foo: 4 } }
221
-
222
- it 'is not successful' do
223
- expect(result).to be_failing ['must be one of: 1, 3, 5']
224
- end
225
- end
226
- end
227
-
228
- context 'with maybe' do
229
- subject(:schema) do
230
- Dry::Validation.Schema do
231
- required(:foo).maybe(included_in?: [1, 3, 5])
232
- end
233
- end
234
-
235
- context 'with valid input' do
236
- let(:input) { { foo: 3 } }
237
-
238
- it 'is successful' do
239
- expect(result).to be_successful
240
- end
241
- end
242
-
243
- context 'with missing input' do
244
- let(:input) { {} }
245
-
246
- it 'is not successful' do
247
- expect(result).to be_failing ['is missing', 'must be one of: 1, 3, 5']
248
- end
249
- end
250
-
251
- context 'with nil input' do
252
- let(:input) { { foo: nil } }
253
-
254
- it 'is successful' do
255
- expect(result).to be_successful
256
- end
257
- end
258
-
259
- context 'with blank input' do
260
- let(:input) { { foo: '' } }
261
-
262
- it 'is not successful' do
263
- expect(result).to be_failing ['must be one of: 1, 3, 5']
264
- end
265
- end
266
-
267
- context 'with invalid type' do
268
- let(:input) { { foo: { a: 1 } } }
269
-
270
- it 'is not successful' do
271
- expect(result).to be_failing ['must be one of: 1, 3, 5']
272
- end
273
- end
274
-
275
- context 'with invalid input' do
276
- let(:input) { { foo: 4 } }
277
-
278
- it 'is not successful' do
279
- expect(result).to be_failing ['must be one of: 1, 3, 5']
280
- end
281
- end
282
- end
283
- end
284
-
285
- context 'with optional' do
286
- context 'with value' do
287
- subject(:schema) do
288
- Dry::Validation.Schema do
289
- optional(:foo).value(included_in?: [1, 3, 5])
290
- end
291
- end
292
-
293
- context 'with valid input' do
294
- let(:input) { { foo: 3 } }
295
-
296
- it 'is successful' do
297
- expect(result).to be_successful
298
- end
299
- end
300
-
301
- context 'with missing input' do
302
- let(:input) { {} }
303
-
304
- it 'is successful' do
305
- expect(result).to be_successful
306
- end
307
- end
308
-
309
- context 'with nil input' do
310
- let(:input) { { foo: nil } }
311
-
312
- it 'is not successful' do
313
- expect(result).to be_failing ['must be one of: 1, 3, 5']
314
- end
315
- end
316
-
317
- context 'with blank input' do
318
- let(:input) { { foo: '' } }
319
-
320
- it 'is not successful' do
321
- expect(result).to be_failing ['must be one of: 1, 3, 5']
322
- end
323
- end
324
-
325
- context 'with invalid type' do
326
- let(:input) { { foo: { a: 1 } } }
327
-
328
- it 'is not successful' do
329
- expect(result).to be_failing ['must be one of: 1, 3, 5']
330
- end
331
- end
332
-
333
- context 'with invalid input' do
334
- let(:input) { { foo: 4 } }
335
-
336
- it 'is not successful' do
337
- expect(result).to be_failing ['must be one of: 1, 3, 5']
338
- end
339
- end
340
- end
341
-
342
- context 'with filled' do
343
- subject(:schema) do
344
- Dry::Validation.Schema do
345
- optional(:foo).filled(included_in?: [1, 3, 5])
346
- end
347
- end
348
-
349
- context 'with valid input' do
350
- let(:input) { { foo: 3 } }
351
-
352
- it 'is successful' do
353
- expect(result).to be_successful
354
- end
355
- end
356
-
357
- context 'with missing input' do
358
- let(:input) { {} }
359
-
360
- it 'is successful' do
361
- expect(result).to be_successful
362
- end
363
- end
364
-
365
- context 'with nil input' do
366
- let(:input) { { foo: nil } }
367
-
368
- it 'is not successful' do
369
- expect(result).to be_failing ['must be filled', 'must be one of: 1, 3, 5']
370
- end
371
- end
372
-
373
- context 'with blank input' do
374
- let(:input) { { foo: '' } }
375
-
376
- it 'is not successful' do
377
- expect(result).to be_failing ['must be filled', 'must be one of: 1, 3, 5']
378
- end
379
- end
380
-
381
- context 'with invalid type' do
382
- let(:input) { { foo: { a: 1 } } }
383
-
384
- it 'is not successful' do
385
- expect(result).to be_failing ['must be one of: 1, 3, 5']
386
- end
387
- end
388
-
389
- context 'with invalid input' do
390
- let(:input) { { foo: 4 } }
391
-
392
- it 'is not successful' do
393
- expect(result).to be_failing ['must be one of: 1, 3, 5']
394
- end
395
- end
396
- end
397
-
398
- context 'with maybe' do
399
- subject(:schema) do
400
- Dry::Validation.Schema do
401
- optional(:foo).maybe(included_in?: [1, 3, 5])
402
- end
403
- end
404
-
405
- context 'with valid input' do
406
- let(:input) { { foo: 3 } }
407
-
408
- it 'is successful' do
409
- expect(result).to be_successful
410
- end
411
- end
412
-
413
- context 'with missing input' do
414
- let(:input) { {} }
415
-
416
- it 'is successful' do
417
- expect(result).to be_successful
418
- end
419
- end
420
-
421
- context 'with nil input' do
422
- let(:input) { { foo: nil } }
423
-
424
- it 'is successful' do
425
- expect(result).to be_successful
426
- end
427
- end
428
-
429
- context 'with blank input' do
430
- let(:input) { { foo: '' } }
431
-
432
- it 'is not successful' do
433
- expect(result).to be_failing ['must be one of: 1, 3, 5']
434
- end
435
- end
436
-
437
- context 'with invalid type' do
438
- let(:input) { { foo: { a: 1 } } }
439
-
440
- it 'is not successful' do
441
- expect(result).to be_failing ['must be one of: 1, 3, 5']
442
- end
443
- end
444
-
445
- context 'with invalid input' do
446
- let(:input) { { foo: 4 } }
447
-
448
- it 'is not successful' do
449
- expect(result).to be_failing ['must be one of: 1, 3, 5']
450
- end
451
- end
452
- end
453
- end
454
- end
455
- end