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
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
|
require "cases/helper"
class ErrorsTest < ActiveModel::TestCase
class Person
extend ActiveModel::Naming
def initialize
@errors = ActiveModel::Errors.new(self)
end
attr_accessor :name, :age
attr_reader :errors
def validate!
errors.add(:name, "cannot be nil") if name == nil
end
def read_attribute_for_validation(attr)
send(attr)
end
def self.human_attribute_name(attr, options = {})
attr
end
def self.lookup_ancestors
[self]
end
end
def setup
@mock_generator = MiniTest::Mock.new
end
def teardown
@mock_generator.verify
end
def test_delete
errors = ActiveModel::Errors.new(self)
errors[:foo] << 'omg'
errors.delete(:foo)
assert_empty errors[:foo]
end
def test_include?
errors = ActiveModel::Errors.new(self)
errors[:foo] << 'omg'
assert errors.include?(:foo), 'errors should include :foo'
end
def test_dup
errors = ActiveModel::Errors.new(self)
errors[:foo] << 'bar'
errors_dup = errors.dup
errors_dup[:bar] << 'omg'
assert_not_same errors_dup.messages, errors.messages
end
def test_has_key?
errors = ActiveModel::Errors.new(self)
errors[:foo] << 'omg'
assert_equal true, errors.has_key?(:foo), 'errors should have key :foo'
end
def test_has_no_key
errors = ActiveModel::Errors.new(self)
assert_equal false, errors.has_key?(:name), 'errors should not have key :name'
end
def test_key?
errors = ActiveModel::Errors.new(self)
errors[:foo] << 'omg'
assert_equal true, errors.key?(:foo), 'errors should have key :foo'
end
def test_no_key
errors = ActiveModel::Errors.new(self)
assert_equal false, errors.key?(:name), 'errors should not have key :name'
end
test "clear errors" do
person = Person.new
person.validate!
assert_equal 1, person.errors.count
person.errors.clear
assert person.errors.empty?
end
test "get returns the errors for the provided key" do
errors = ActiveModel::Errors.new(self)
errors[:foo] << "omg"
assert_deprecated do
assert_equal ["omg"], errors.get(:foo)
end
end
test "sets the error with the provided key" do
errors = ActiveModel::Errors.new(self)
assert_deprecated do
errors.set(:foo, "omg")
end
assert_equal({ foo: "omg" }, errors.messages)
end
test "error access is indifferent" do
errors = ActiveModel::Errors.new(self)
errors[:foo] << "omg"
assert_equal ["omg"], errors["foo"]
end
test "values returns an array of messages" do
errors = ActiveModel::Errors.new(self)
errors.messages[:foo] = "omg"
errors.messages[:baz] = "zomg"
assert_equal ["omg", "zomg"], errors.values
end
test "keys returns the error keys" do
errors = ActiveModel::Errors.new(self)
errors.messages[:foo] << "omg"
errors.messages[:baz] << "zomg"
assert_equal [:foo, :baz], errors.keys
end
test "detecting whether there are errors with empty?, blank?, include?" do
person = Person.new
person.errors[:foo]
assert person.errors.empty?
assert person.errors.blank?
assert !person.errors.include?(:foo)
end
test "adding errors using conditionals with Person#validate!" do
person = Person.new
person.validate!
assert_equal ["name cannot be nil"], person.errors.full_messages
assert_equal ["cannot be nil"], person.errors[:name]
end
test "assign error" do
person = Person.new
assert_deprecated do
person.errors[:name] = 'should not be nil'
end
assert_equal ["should not be nil"], person.errors[:name]
end
test "add an error message on a specific attribute" do
person = Person.new
person.errors.add(:name, "cannot be blank")
assert_equal ["cannot be blank"], person.errors[:name]
end
test "add an error message on a specific attribute with a defined type" do
person = Person.new
person.errors.add(:name, :blank, message: "cannot be blank")
assert_equal ["cannot be blank"], person.errors[:name]
end
test "add an error with a symbol" do
person = Person.new
person.errors.add(:name, :blank)
message = person.errors.generate_message(:name, :blank)
assert_equal [message], person.errors[:name]
end
test "add an error with a proc" do
person = Person.new
message = Proc.new { "cannot be blank" }
person.errors.add(:name, message)
assert_equal ["cannot be blank"], person.errors[:name]
end
test "added? detects if a specific error was added to the object" do
person = Person.new
person.errors.add(:name, "cannot be blank")
assert person.errors.added?(:name, "cannot be blank")
end
test "added? handles symbol message" do
person = Person.new
person.errors.add(:name, :blank)
assert person.errors.added?(:name, :blank)
end
test "added? handles proc messages" do
person = Person.new
message = Proc.new { "cannot be blank" }
person.errors.add(:name, message)
assert person.errors.added?(:name, message)
end
test "added? defaults message to :invalid" do
person = Person.new
person.errors.add(:name)
assert person.errors.added?(:name)
end
test "added? matches the given message when several errors are present for the same attribute" do
person = Person.new
person.errors.add(:name, "cannot be blank")
person.errors.add(:name, "is invalid")
assert person.errors.added?(:name, "cannot be blank")
end
test "added? returns false when no errors are present" do
person = Person.new
assert !person.errors.added?(:name)
end
test "added? returns false when checking a nonexisting error and other errors are present for the given attribute" do
person = Person.new
person.errors.add(:name, "is invalid")
assert !person.errors.added?(:name, "cannot be blank")
end
test "size calculates the number of error messages" do
person = Person.new
person.errors.add(:name, "cannot be blank")
assert_equal 1, person.errors.size
end
test "count calculates the number of error messages" do
person = Person.new
person.errors.add(:name, "cannot be blank")
assert_equal 1, person.errors.count
end
test "to_a returns the list of errors with complete messages containing the attribute names" do
person = Person.new
person.errors.add(:name, "cannot be blank")
person.errors.add(:name, "cannot be nil")
assert_equal ["name cannot be blank", "name cannot be nil"], person.errors.to_a
end
test "to_hash returns the error messages hash" do
person = Person.new
person.errors.add(:name, "cannot be blank")
assert_equal({ name: ["cannot be blank"] }, person.errors.to_hash)
end
test "full_messages creates a list of error messages with the attribute name included" do
person = Person.new
person.errors.add(:name, "cannot be blank")
person.errors.add(:name, "cannot be nil")
assert_equal ["name cannot be blank", "name cannot be nil"], person.errors.full_messages
end
test "full_messages_for contains all the error messages for the given attribute" do
person = Person.new
person.errors.add(:name, "cannot be blank")
person.errors.add(:name, "cannot be nil")
assert_equal ["name cannot be blank", "name cannot be nil"], person.errors.full_messages_for(:name)
end
test "full_messages_for does not contain error messages from other attributes" do
person = Person.new
person.errors.add(:name, "cannot be blank")
person.errors.add(:email, "cannot be blank")
assert_equal ["name cannot be blank"], person.errors.full_messages_for(:name)
end
test "full_messages_for returns an empty list in case there are no errors for the given attribute" do
person = Person.new
person.errors.add(:name, "cannot be blank")
assert_equal [], person.errors.full_messages_for(:email)
end
test "full_message returns the given message when attribute is :base" do
person = Person.new
assert_equal "press the button", person.errors.full_message(:base, "press the button")
end
test "full_message returns the given message with the attribute name included" do
person = Person.new
assert_equal "name cannot be blank", person.errors.full_message(:name, "cannot be blank")
assert_equal "name_test cannot be blank", person.errors.full_message(:name_test, "cannot be blank")
end
test "as_json creates a json formatted representation of the errors hash" do
person = Person.new
person.validate!
assert_equal({ name: ["cannot be nil"] }, person.errors.as_json)
end
test "as_json with :full_messages option creates a json formatted representation of the errors containing complete messages" do
person = Person.new
person.validate!
assert_equal({ name: ["name cannot be nil"] }, person.errors.as_json(full_messages: true))
end
test "generate_message works without i18n_scope" do
person = Person.new
assert !Person.respond_to?(:i18n_scope)
assert_nothing_raised {
person.errors.generate_message(:name, :blank)
}
end
test "add_on_empty generates message" do
person = Person.new
@mock_generator.expect(:call, nil, [:name, :empty, {}])
person.errors.stub(:generate_message, @mock_generator) do
assert_deprecated do
person.errors.add_on_empty :name
end
end
end
test "add_on_empty generates message for multiple attributes" do
person = Person.new
@mock_generator.expect(:call, nil, [:name, :empty, {}])
@mock_generator.expect(:call, nil, [:age, :empty, {}])
person.errors.stub(:generate_message, @mock_generator) do
assert_deprecated do
person.errors.add_on_empty [:name, :age]
end
end
end
test "add_on_empty generates message with custom default message" do
person = Person.new
@mock_generator.expect(:call, nil, [:name, :empty, { message: 'custom' }])
person.errors.stub(:generate_message, @mock_generator) do
assert_deprecated do
person.errors.add_on_empty :name, message: 'custom'
end
end
end
test "add_on_empty generates message with empty string value" do
person = Person.new
person.name = ''
@mock_generator.expect(:call, nil, [:name, :empty, {}])
person.errors.stub(:generate_message, @mock_generator) do
assert_deprecated do
person.errors.add_on_empty :name
end
end
end
test "add_on_blank generates message" do
person = Person.new
@mock_generator.expect(:call, nil, [:name, :blank, {}])
person.errors.stub(:generate_message, @mock_generator) do
assert_deprecated do
person.errors.add_on_blank :name
end
end
end
test "add_on_blank generates message for multiple attributes" do
person = Person.new
@mock_generator.expect(:call, nil, [:name, :blank, {}])
@mock_generator.expect(:call, nil, [:age, :blank, {}])
person.errors.stub(:generate_message, @mock_generator) do
assert_deprecated do
person.errors.add_on_blank [:name, :age]
end
end
end
test "add_on_blank generates message with custom default message" do
person = Person.new
@mock_generator.expect(:call, nil, [:name, :blank, { message: 'custom' }])
person.errors.stub(:generate_message, @mock_generator) do
assert_deprecated do
person.errors.add_on_blank :name, message: 'custom'
end
end
end
test "details returns added error detail" do
person = Person.new
person.errors.add(:name, :invalid)
assert_equal({ name: [{ error: :invalid }] }, person.errors.details)
end
test "details returns added error detail with custom option" do
person = Person.new
person.errors.add(:name, :greater_than, count: 5)
assert_equal({ name: [{ error: :greater_than, count: 5 }] }, person.errors.details)
end
test "details do not include message option" do
person = Person.new
person.errors.add(:name, :invalid, message: "is bad")
assert_equal({ name: [{ error: :invalid }] }, person.errors.details)
end
test "dup duplicates details" do
errors = ActiveModel::Errors.new(Person.new)
errors.add(:name, :invalid)
errors_dup = errors.dup
errors_dup.add(:name, :taken)
assert_not_equal errors_dup.details, errors.details
end
test "delete removes details on given attribute" do
errors = ActiveModel::Errors.new(Person.new)
errors.add(:name, :invalid)
errors.delete(:name)
assert_empty errors.details[:name]
end
test "delete returns the deleted messages" do
errors = ActiveModel::Errors.new(Person.new)
errors.add(:name, :invalid)
assert_equal ["is invalid"], errors.delete(:name)
end
test "clear removes details" do
person = Person.new
person.errors.add(:name, :invalid)
assert_equal 1, person.errors.details.count
person.errors.clear
assert person.errors.details.empty?
end
end
|