kharon 0.1.0 → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/lib/validate.rb +2 -2
- data/lib/validator.rb +26 -3
- data/spec/lib/validator_spec.rb +99 -44
- metadata +1 -1
data/lib/validate.rb
CHANGED
@@ -1,4 +1,4 @@
|
|
1
|
-
module
|
1
|
+
module Kharon
|
2
2
|
module Helpers
|
3
3
|
|
4
4
|
# Validates the datas passed as parameter with a Phenix::Validator and the given instructions.
|
@@ -6,7 +6,7 @@ module Charon
|
|
6
6
|
# @param [Proc] the instructions to apply on the validator.
|
7
7
|
# @return [Hash] the validated and filtered datas.
|
8
8
|
def validate(datas, &block)
|
9
|
-
validator =
|
9
|
+
validator = Kharon::Validator.new(datas)
|
10
10
|
validator.instance_eval(&block)
|
11
11
|
return validator.filtered
|
12
12
|
end
|
data/lib/validator.rb
CHANGED
@@ -1,4 +1,4 @@
|
|
1
|
-
module
|
1
|
+
module Kharon
|
2
2
|
# The validator uses aquarium as an AOP DSL to provide "before" and "after" joint point to its main methods.
|
3
3
|
# @author Vincent Courtois <vincent.courtois@mycar-innovations.com>
|
4
4
|
class Validator
|
@@ -32,7 +32,7 @@ module Charon
|
|
32
32
|
# @param [Object] key the key about which verify the type.
|
33
33
|
# @param [Hash] options a hash of options passed to this method (see documentation to know which options pass).
|
34
34
|
def numeric(key, options = {})
|
35
|
-
match?(key, /\A([+-]?\d+)([,.](\d+))?\Z/) ? store(key, ->(item){item.sub(/,/, ".").to_f}, options) : raise_type_error(key, "Numeric")
|
35
|
+
match?(key, /\A([+-]?\d+)([,.](\d+))?\Z/) ? store(key, ->(item){item.to_s.sub(/,/, ".").to_f}, options) : raise_type_error(key, "Numeric")
|
36
36
|
end
|
37
37
|
|
38
38
|
# Checks if the given key is a not-empty string or not.
|
@@ -108,7 +108,7 @@ module Charon
|
|
108
108
|
end
|
109
109
|
|
110
110
|
# After advice checking in numerics if limits are given, and if there are, if they are respected.
|
111
|
-
|
111
|
+
before calls_to: [:integer, :numeric] do |joint_point, validator, *args|
|
112
112
|
unless !defined?(args[1]) or args[1].nil? or args[1].empty?
|
113
113
|
if(args[1].has_key?(:between))
|
114
114
|
validator.check_min_value(args[0], args[1][:between][0])
|
@@ -120,6 +120,18 @@ module Charon
|
|
120
120
|
end
|
121
121
|
end
|
122
122
|
|
123
|
+
after calls_to: [:numeric] do |joint_point, validator, *args|
|
124
|
+
unless !defined?(args[1]) or args[1].nil? or args[1].empty?
|
125
|
+
if(args[1].has_key?(:round) and args[1][:round].kind_of?(Integer))
|
126
|
+
validator.filtered[args[0]] = validator.filtered[args[0]].round(args[1][:round]) if validator.filtered.has_key?(args[0])
|
127
|
+
elsif(args[1].has_key?(:floor) and args[1][:floor] == true)
|
128
|
+
validator.filtered[args[0]] = validator.filtered[args[0]].floor if validator.filtered.has_key?(args[0])
|
129
|
+
elsif(args[1].has_key?(:ceil) and args[1][:ceil] == true)
|
130
|
+
validator.filtered[args[0]] = validator.filtered[args[0]].ceil if validator.filtered.has_key?(args[0])
|
131
|
+
end
|
132
|
+
end
|
133
|
+
end
|
134
|
+
|
123
135
|
# After advcie for all methods, checking the "in" and "equals" options.
|
124
136
|
after calls_to: self.instance_methods(false), exclude_methods: [:initialize, :new, :required, :dependency, :dependencies] do |joint_point, validator, *args|
|
125
137
|
unless !defined?(args[1]) or args[1].nil? or args[1].empty?
|
@@ -146,6 +158,12 @@ module Charon
|
|
146
158
|
end
|
147
159
|
end
|
148
160
|
|
161
|
+
after calls_to: [:text] do |joint_point, validator, *args|
|
162
|
+
unless !defined?(args[1]) or args[1].nil? or args[1].empty?
|
163
|
+
validator.match_regex?(args[0], validator.datas[args[0]], args[1][:regex]) if(args[1].has_key?(:regex))
|
164
|
+
end
|
165
|
+
end
|
166
|
+
|
149
167
|
# @!endgroup Advices
|
150
168
|
|
151
169
|
# Checks if a required key is present in provided datas.
|
@@ -220,6 +238,11 @@ module Charon
|
|
220
238
|
raise ArgumentError.new("The key #{key} was supposed to contains values [#{required_values.join(", ")}]") if (values & required_values) != required_values
|
221
239
|
end
|
222
240
|
|
241
|
+
def match_regex?(key, value, regex)
|
242
|
+
regex = Regexp.new(regex) if regex.kind_of?(String)
|
243
|
+
raise ArgumentError.new("The key #{key} was supposed to match the regex #{regex} but its value was #{value}") unless regex.match(value)
|
244
|
+
end
|
245
|
+
|
223
246
|
private
|
224
247
|
|
225
248
|
# Check if the value associated with the given key matches the given regular expression.
|
data/spec/lib/validator_spec.rb
CHANGED
@@ -4,103 +4,103 @@ require './lib/validator.rb'
|
|
4
4
|
shared_examples "options" do |process|
|
5
5
|
context ":rename" do
|
6
6
|
it "correctly renames a key when the value is valid" do
|
7
|
-
validator =
|
7
|
+
validator = Kharon::Validator.new(valid_datas)
|
8
8
|
validator.send(process, valid_datas.keys.first, rename: :another_name)
|
9
9
|
expect(validator.filtered[:another_name]).to eq(valid_filtered[valid_datas.keys.first])
|
10
10
|
end
|
11
11
|
|
12
12
|
it "correctly doesn't rename a key when the value is invalid" do
|
13
|
-
validator =
|
13
|
+
validator = Kharon::Validator.new(invalid_datas)
|
14
14
|
expect(->{validator.send(process, invalid_datas.keys.first, rename: :another_name)}).to raise_error(ArgumentError)
|
15
15
|
end
|
16
16
|
end
|
17
17
|
|
18
18
|
context ":dependency" do
|
19
19
|
it "succeeds when a dependency is given as a key and respected" do
|
20
|
-
validator =
|
20
|
+
validator = Kharon::Validator.new(valid_datas.merge({dep: "anything"}))
|
21
21
|
validator.send(process, valid_datas.keys.first, dependency: :dep)
|
22
22
|
expect(validator.filtered).to eq(valid_filtered)
|
23
23
|
end
|
24
24
|
|
25
25
|
it "fails when a dependency is not respected" do
|
26
|
-
validator =
|
26
|
+
validator = Kharon::Validator.new(valid_datas)
|
27
27
|
expect(->{validator.send(process, valid_datas.keys.first, dependency: :another_key_not_existing)}).to raise_error(ArgumentError)
|
28
28
|
end
|
29
29
|
end
|
30
30
|
|
31
31
|
context ":dependencies" do
|
32
32
|
it "succeeds when dependencies are given as an array and respected" do
|
33
|
-
validator =
|
33
|
+
validator = Kharon::Validator.new(valid_datas.merge({dep1: "something", dep2: "something else"}))
|
34
34
|
validator.send(process, valid_datas.keys.first, dependencies: [:dep1, :dep2])
|
35
35
|
expect(validator.filtered).to eq(valid_filtered)
|
36
36
|
end
|
37
37
|
|
38
38
|
it "fails when one of the dependencies is not respected" do
|
39
|
-
validator =
|
39
|
+
validator = Kharon::Validator.new(valid_datas.merge({dep1: "anything"}))
|
40
40
|
expect(->{validator.send(process, valid_datas.keys.first, dependencies: [:dep1, :dep2])}).to raise_error(ArgumentError)
|
41
41
|
end
|
42
42
|
end
|
43
43
|
|
44
44
|
context ":required" do
|
45
45
|
it "succeeds when a not required key is not given, but filters nothing" do
|
46
|
-
validator =
|
46
|
+
validator = Kharon::Validator.new(valid_datas)
|
47
47
|
validator.send(process, :not_required_key)
|
48
48
|
expect(validator.filtered).to be_empty
|
49
49
|
end
|
50
50
|
|
51
51
|
it "suceeds when a key has a required option to false, and is not given, but filters nothing" do
|
52
|
-
validator =
|
52
|
+
validator = Kharon::Validator.new(valid_datas)
|
53
53
|
validator.send(process, :not_in_hash, required: false)
|
54
54
|
expect(validator.filtered).to be_empty
|
55
55
|
end
|
56
56
|
|
57
57
|
it "fails when a required key is not given" do
|
58
|
-
validator =
|
58
|
+
validator = Kharon::Validator.new(valid_datas)
|
59
59
|
expect(->{validator.send(process, :not_in_hash, required: true)}).to raise_error(ArgumentError)
|
60
60
|
end
|
61
61
|
end
|
62
62
|
|
63
63
|
context ":in" do
|
64
64
|
it "succeeds when the value is effectively in the possible values" do
|
65
|
-
validator =
|
65
|
+
validator = Kharon::Validator.new(valid_datas)
|
66
66
|
validator.send(process, valid_datas.keys.first, :in => [valid_datas[valid_datas.keys.first], "another random data"])
|
67
67
|
expect(validator.filtered).to eq(valid_filtered)
|
68
68
|
end
|
69
69
|
|
70
70
|
it "succeeds if there are no values" do
|
71
|
-
validator =
|
71
|
+
validator = Kharon::Validator.new(valid_datas)
|
72
72
|
validator.send(process, valid_datas.keys.first, :in => [])
|
73
73
|
expect(validator.filtered).to eq(valid_filtered)
|
74
74
|
end
|
75
75
|
|
76
76
|
it "fails if the value is not in the possible values" do
|
77
|
-
validator =
|
77
|
+
validator = Kharon::Validator.new(valid_datas)
|
78
78
|
expect(->{validator.send(process, valid_datas.keys.first, :in => ["anything but the value", "another impossible thing"])}).to raise_error(ArgumentError)
|
79
79
|
end
|
80
80
|
end
|
81
81
|
|
82
82
|
context ":equals" do
|
83
83
|
it "succeeds when the value is equal to the given value" do
|
84
|
-
validator =
|
84
|
+
validator = Kharon::Validator.new(valid_datas)
|
85
85
|
validator.send(process, valid_datas.keys.first, :equals => valid_datas[valid_datas.keys.first])
|
86
86
|
expect(validator.filtered).to eq(valid_filtered)
|
87
87
|
end
|
88
88
|
|
89
89
|
it "fails if the value is not equal to the given value" do
|
90
|
-
validator =
|
90
|
+
validator = Kharon::Validator.new(valid_datas)
|
91
91
|
expect(->{validator.send(process, valid_datas.keys.first, :equals => "anything but the given value")}).to raise_error(ArgumentError)
|
92
92
|
end
|
93
93
|
end
|
94
94
|
|
95
95
|
context ":extract" do
|
96
96
|
it "etracts the data when given at true" do
|
97
|
-
validator =
|
97
|
+
validator = Kharon::Validator.new(valid_datas)
|
98
98
|
validator.send(process, valid_datas.keys.first, :extract => false)
|
99
99
|
expect(validator.filtered).to eq({})
|
100
100
|
end
|
101
101
|
|
102
102
|
it "doesn't extract the data when given at false" do
|
103
|
-
validator =
|
103
|
+
validator = Kharon::Validator.new(valid_datas)
|
104
104
|
validator.send(process, valid_datas.keys.first, :extract => true)
|
105
105
|
expect(validator.filtered).to eq(valid_filtered)
|
106
106
|
end
|
@@ -108,13 +108,13 @@ shared_examples "options" do |process|
|
|
108
108
|
|
109
109
|
context ":cast" do
|
110
110
|
it "casts the data when given at true" do
|
111
|
-
validator =
|
111
|
+
validator = Kharon::Validator.new(valid_datas)
|
112
112
|
validator.send(process, valid_datas.keys.first, :cast => true)
|
113
113
|
expect(validator.filtered).to eq(valid_filtered)
|
114
114
|
end
|
115
115
|
|
116
116
|
it "doesn't cast the data when given at false" do
|
117
|
-
validator =
|
117
|
+
validator = Kharon::Validator.new(valid_datas)
|
118
118
|
validator.send(process, valid_datas.keys.first, :cast => false)
|
119
119
|
expect(validator.filtered).to eq(valid_datas)
|
120
120
|
end
|
@@ -123,20 +123,20 @@ end
|
|
123
123
|
|
124
124
|
shared_examples "type checker" do |type, process|
|
125
125
|
it "succeeds when given an instance of #{type}" do
|
126
|
-
validator =
|
126
|
+
validator = Kharon::Validator.new(valid_datas)
|
127
127
|
validator.send(process, valid_datas.keys.first)
|
128
128
|
expect(validator.filtered).to eq(valid_filtered)
|
129
129
|
end
|
130
130
|
|
131
131
|
it "fails when given something else than an instance of #{type}" do
|
132
|
-
validator =
|
132
|
+
validator = Kharon::Validator.new(invalid_datas)
|
133
133
|
expect(->{validator.send(process, invalid_datas.keys.first)}).to raise_error(ArgumentError)
|
134
134
|
end
|
135
135
|
end
|
136
136
|
|
137
137
|
shared_examples "min/max checker" do |process, key, transformation|
|
138
138
|
let(:value) { valid_datas[key].send(transformation) }
|
139
|
-
let(:validator) {
|
139
|
+
let(:validator) { Kharon::Validator.new(valid_datas) }
|
140
140
|
|
141
141
|
context ":min" do
|
142
142
|
it "succeeds when a min option is given, and the value is strictly greater than it" do
|
@@ -200,18 +200,18 @@ end
|
|
200
200
|
shared_examples "contains option" do |process, key|
|
201
201
|
context ":contains" do
|
202
202
|
it "succeeds if all values are contained" do
|
203
|
-
validator =
|
203
|
+
validator = Kharon::Validator.new(valid_datas)
|
204
204
|
validator.send(process, key, contains: ["val1", "val2"])
|
205
205
|
expect(validator.filtered).to eq(valid_filtered)
|
206
206
|
end
|
207
207
|
|
208
208
|
it "fails if only some values are contained" do
|
209
|
-
validator =
|
209
|
+
validator = Kharon::Validator.new(valid_datas)
|
210
210
|
expect(->{validator.send(process, key, contains: ["val1", "val3"])}).to raise_error(ArgumentError)
|
211
211
|
end
|
212
212
|
|
213
213
|
it "fails if none of the values are contained" do
|
214
|
-
validator =
|
214
|
+
validator = Kharon::Validator.new(valid_datas)
|
215
215
|
expect(->{validator.send(process, key, contains: ["val3", "val4"])}).to raise_error(ArgumentError)
|
216
216
|
end
|
217
217
|
end
|
@@ -224,18 +224,18 @@ describe "Validator" do
|
|
224
224
|
let(:invalid_datas) { {is_not_an_integer: "something else"} }
|
225
225
|
|
226
226
|
it "succeeds when given an integer" do
|
227
|
-
validator =
|
227
|
+
validator = Kharon::Validator.new(valid_datas)
|
228
228
|
validator.integer(:is_an_integer)
|
229
229
|
expect(validator.filtered).to eq(valid_filtered)
|
230
230
|
end
|
231
231
|
|
232
232
|
it "fails when given a float" do
|
233
|
-
validator =
|
233
|
+
validator = Kharon::Validator.new({is_not_an_integer: 1000.5})
|
234
234
|
expect(->{validator.integer(:is_not_an_integer)}).to raise_error(ArgumentError)
|
235
235
|
end
|
236
236
|
|
237
237
|
it "fails when not given a numeric" do
|
238
|
-
validator =
|
238
|
+
validator = Kharon::Validator.new(invalid_datas)
|
239
239
|
expect(->{validator.integer(:is_not_an_integer)}).to raise_error(ArgumentError)
|
240
240
|
end
|
241
241
|
|
@@ -251,31 +251,73 @@ describe "Validator" do
|
|
251
251
|
let(:invalid_datas) { {is_not_a_numeric: "something else"} }
|
252
252
|
|
253
253
|
it "succeeds when given an integer" do
|
254
|
-
validator =
|
254
|
+
validator = Kharon::Validator.new({is_an_integer: "1000"})
|
255
255
|
validator.numeric(:is_an_integer)
|
256
256
|
expect(validator.filtered).to eq({is_an_integer: 1000})
|
257
257
|
end
|
258
258
|
|
259
259
|
it "succeeds when given an decimal number with a dot" do
|
260
|
-
validator =
|
260
|
+
validator = Kharon::Validator.new(valid_datas)
|
261
261
|
validator.numeric(:is_a_double)
|
262
262
|
expect(validator.filtered).to eq(valid_filtered)
|
263
263
|
end
|
264
264
|
|
265
265
|
it "succeeds when given an decimal number with a comma" do
|
266
|
-
validator =
|
266
|
+
validator = Kharon::Validator.new({is_a_double: "1000,5"})
|
267
267
|
validator.numeric(:is_a_double)
|
268
268
|
expect(validator.filtered).to eq(valid_filtered)
|
269
269
|
end
|
270
270
|
|
271
271
|
it "fails when not given a numeric" do
|
272
|
-
validator =
|
272
|
+
validator = Kharon::Validator.new(invalid_datas)
|
273
273
|
expect(->{validator.integer(:is_not_a_numeric)}).to raise_error(ArgumentError)
|
274
274
|
end
|
275
275
|
|
276
276
|
context "options" do
|
277
277
|
include_examples "options", :numeric
|
278
278
|
include_examples "min/max checker", :numeric, :is_a_double, :to_f
|
279
|
+
|
280
|
+
context ":round" do
|
281
|
+
it "rounds the number when the option is passed as an integer" do
|
282
|
+
validator = Kharon::Validator.new({is_a_double: 1.02363265})
|
283
|
+
validator.numeric(:is_a_double, round: 4)
|
284
|
+
expect(validator.filtered).to eq({is_a_double: 1.0236})
|
285
|
+
end
|
286
|
+
|
287
|
+
it "doesn't round the number if passed with another type" do
|
288
|
+
validator = Kharon::Validator.new({is_a_double: "1.02363265"})
|
289
|
+
validator.numeric(:is_a_double, round: "anything here")
|
290
|
+
expect(validator.filtered).to eq({is_a_double: 1.02363265})
|
291
|
+
end
|
292
|
+
end
|
293
|
+
|
294
|
+
context ":floor" do
|
295
|
+
it "floors the number if passed to true" do
|
296
|
+
validator = Kharon::Validator.new(valid_datas)
|
297
|
+
validator.numeric(:is_a_double, floor: true)
|
298
|
+
expect(validator.filtered).to eq({is_a_double: 1000})
|
299
|
+
end
|
300
|
+
|
301
|
+
it "doesn't floor the number if passed to false" do
|
302
|
+
validator = Kharon::Validator.new(valid_datas)
|
303
|
+
validator.numeric(:is_a_double, floor: false)
|
304
|
+
expect(validator.filtered).to eq({is_a_double: 1000.5})
|
305
|
+
end
|
306
|
+
end
|
307
|
+
|
308
|
+
context ":ceil" do
|
309
|
+
it "ceils the number if passed to true" do
|
310
|
+
validator = Kharon::Validator.new(valid_datas)
|
311
|
+
validator.numeric(:is_a_double, ceil: true)
|
312
|
+
expect(validator.filtered).to eq({is_a_double: 1001})
|
313
|
+
end
|
314
|
+
|
315
|
+
it "doesn't ceil the number if passed to false" do
|
316
|
+
validator = Kharon::Validator.new(valid_datas)
|
317
|
+
validator.numeric(:is_a_double, ceil: false)
|
318
|
+
expect(validator.filtered).to eq({is_a_double: 1000.5})
|
319
|
+
end
|
320
|
+
end
|
279
321
|
end
|
280
322
|
end
|
281
323
|
|
@@ -288,6 +330,19 @@ describe "Validator" do
|
|
288
330
|
|
289
331
|
context "options" do
|
290
332
|
include_examples "options", :text
|
333
|
+
|
334
|
+
context ":regex" do
|
335
|
+
it "succeeds when the regular expression is respected" do
|
336
|
+
validator = Kharon::Validator.new(valid_datas)
|
337
|
+
validator.text(:is_a_string, regex: "some")
|
338
|
+
expect(validator.filtered).to eq(valid_filtered)
|
339
|
+
end
|
340
|
+
|
341
|
+
it "fails when the regular expression is not respected" do
|
342
|
+
validator = Kharon::Validator.new(valid_datas)
|
343
|
+
expect(->{validator.text(:is_a_string, regex: "anything else")}).to raise_error(ArgumentError)
|
344
|
+
end
|
345
|
+
end
|
291
346
|
end
|
292
347
|
end
|
293
348
|
|
@@ -298,19 +353,19 @@ describe "Validator" do
|
|
298
353
|
let(:invalid_datas) { {is_not_a_datetime: "something else"} }
|
299
354
|
|
300
355
|
it "succeeds when given a valid datetime as a string" do
|
301
|
-
validator =
|
356
|
+
validator = Kharon::Validator.new(valid_datas)
|
302
357
|
validator.datetime(:is_a_datetime)
|
303
358
|
expect(validator.filtered).to eq(valid_filtered)
|
304
359
|
end
|
305
360
|
|
306
361
|
it "succeeds when given a valid datetime as a DateTime Object" do
|
307
|
-
validator =
|
362
|
+
validator = Kharon::Validator.new(valid_filtered)
|
308
363
|
validator.datetime(:is_a_datetime)
|
309
364
|
expect(validator.filtered).to eq(valid_filtered)
|
310
365
|
end
|
311
366
|
|
312
367
|
it "fails when given something else than a valid datetime" do
|
313
|
-
validator =
|
368
|
+
validator = Kharon::Validator.new(invalid_datas)
|
314
369
|
expect(->{validator.datetime(:is_not_a_datetime)}).to raise_error(ArgumentError)
|
315
370
|
end
|
316
371
|
|
@@ -326,19 +381,19 @@ describe "Validator" do
|
|
326
381
|
let(:invalid_datas) { {is_not_a_date: "something else"} }
|
327
382
|
|
328
383
|
it "succeeds when given a valid date as a string" do
|
329
|
-
validator =
|
384
|
+
validator = Kharon::Validator.new(valid_datas)
|
330
385
|
validator.date(:is_a_date)
|
331
386
|
expect(validator.filtered).to eq(valid_filtered)
|
332
387
|
end
|
333
388
|
|
334
389
|
it "succeeds when given a valid date as a Date Object" do
|
335
|
-
validator =
|
390
|
+
validator = Kharon::Validator.new(valid_filtered)
|
336
391
|
validator.date(:is_a_date)
|
337
392
|
expect(validator.filtered).to eq(valid_filtered)
|
338
393
|
end
|
339
394
|
|
340
395
|
it "fails when given something else than a valid date" do
|
341
|
-
validator =
|
396
|
+
validator = Kharon::Validator.new(invalid_datas)
|
342
397
|
expect(->{validator.date(:is_not_a_date)}).to raise_error(ArgumentError)
|
343
398
|
end
|
344
399
|
|
@@ -373,18 +428,18 @@ describe "Validator" do
|
|
373
428
|
|
374
429
|
context ":has_keys" do
|
375
430
|
it "succeeds if all keys are contained in the hash" do
|
376
|
-
validator =
|
431
|
+
validator = Kharon::Validator.new(valid_datas)
|
377
432
|
validator.hash(:is_a_hash, has_keys: [:key1, :key2])
|
378
433
|
expect(validator.filtered).to eq(valid_filtered)
|
379
434
|
end
|
380
435
|
|
381
436
|
it "fails if not all keys are given in the hash" do
|
382
|
-
validator =
|
437
|
+
validator = Kharon::Validator.new(valid_datas)
|
383
438
|
expect(->{validator.hash(:is_a_hash, has_keys: [:key1, :key3])}).to raise_error(ArgumentError)
|
384
439
|
end
|
385
440
|
|
386
441
|
it "fails if no keys are contained in the hash" do
|
387
|
-
validator =
|
442
|
+
validator = Kharon::Validator.new(valid_datas)
|
388
443
|
expect(->{validator.hash(:is_a_hash, has_keys: [:key3, :key4])}).to raise_error(ArgumentError)
|
389
444
|
end
|
390
445
|
end
|
@@ -397,13 +452,13 @@ describe "Validator" do
|
|
397
452
|
let(:invalid_datas) { {is_not_a_boolean: "anything else"} }
|
398
453
|
|
399
454
|
it "succeeds when given a boolean" do
|
400
|
-
validator =
|
455
|
+
validator = Kharon::Validator.new(valid_datas)
|
401
456
|
validator.boolean(:is_a_boolean)
|
402
457
|
expect(validator.filtered).to eq(valid_filtered)
|
403
458
|
end
|
404
459
|
|
405
460
|
it "fails when not given a boolean" do
|
406
|
-
validator =
|
461
|
+
validator = Kharon::Validator.new(invalid_datas)
|
407
462
|
expect(->{validator.boolean(:is_not_a_boolean)}).to raise_error(ArgumentError)
|
408
463
|
end
|
409
464
|
|
@@ -419,13 +474,13 @@ describe "Validator" do
|
|
419
474
|
let(:invalid_datas) { {is_not_a_ssid: "anything else"} }
|
420
475
|
|
421
476
|
it "succeeds when given a valid SSID" do
|
422
|
-
validator =
|
477
|
+
validator = Kharon::Validator.new(valid_datas)
|
423
478
|
validator.ssid(:is_a_ssid)
|
424
479
|
expect(validator.filtered).to eq(valid_filtered)
|
425
480
|
end
|
426
481
|
|
427
482
|
it "fails when not given a SSID" do
|
428
|
-
validator =
|
483
|
+
validator = Kharon::Validator.new(invalid_datas)
|
429
484
|
expect(->{validator.ssid(:is_not_a_ssid)}).to raise_error(ArgumentError)
|
430
485
|
end
|
431
486
|
|