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
|
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, "can not 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 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 errors.has_key?(:foo), 'errors should have key :foo'
end
test "should be able to clear the 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 error by the provided key" do
errors = ActiveModel::Errors.new(self)
errors[:foo] = "omg"
assert_equal ["omg"], errors.get(:foo)
end
test "sets the error with the provided key" do
errors = ActiveModel::Errors.new(self)
errors.set(:foo, "omg")
assert_equal({ foo: "omg" }, errors.messages)
end
test "values returns an array of messages" do
errors = ActiveModel::Errors.new(self)
errors.set(:foo, "omg")
errors.set(:baz, "zomg")
assert_equal ["omg", "zomg"], errors.values
end
test "keys returns the error keys" do
errors = ActiveModel::Errors.new(self)
errors.set(:foo, "omg")
errors.set(:baz, "zomg")
assert_equal [:foo, :baz], errors.keys
end
test "as_json returns a json formatted representation of the errors hash" do
person = Person.new
person.validate!
assert_equal({ name: ["can not be nil"] }, person.errors.as_json)
end
test "as_json with :full_messages option" do
person = Person.new
person.validate!
assert_equal({ name: ["name can not be nil"] }, person.errors.as_json(full_messages: true))
end
test "should return true if no errors" do
person = Person.new
person.errors[:foo]
assert person.errors.empty?
assert person.errors.blank?
assert !person.errors.include?(:foo)
end
test "method validate! should work" do
person = Person.new
person.validate!
assert_equal ["name can not be nil"], person.errors.full_messages
assert_equal ["can not be nil"], person.errors[:name]
end
test 'should be able to assign error' do
person = Person.new
person.errors[:name] = 'should not be nil'
assert_equal ["should not be nil"], person.errors[:name]
end
test 'should be able to add an error on an attribute' do
person = Person.new
person.errors.add(:name, "can not be blank")
assert_equal ["can not be blank"], person.errors[:name]
end
test "should be able to 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 "should be able to add an error with a proc" do
person = Person.new
message = Proc.new { "can not be blank" }
person.errors.add(:name, message)
assert_equal ["can not be blank"], person.errors[:name]
end
test "added? should be true if that error was added" do
person = Person.new
person.errors.add(:name, "can not be blank")
assert person.errors.added?(:name, "can not be blank")
end
test "added? should handle when message is a symbol" do
person = Person.new
person.errors.add(:name, :blank)
assert person.errors.added?(:name, :blank)
end
test "added? should handle when message is a proc" do
person = Person.new
message = Proc.new { "can not be blank" }
person.errors.add(:name, message)
assert person.errors.added?(:name, message)
end
test "added? should default message to :invalid" do
person = Person.new
person.errors.add(:name)
assert person.errors.added?(:name)
end
test "added? should be true when several errors are present, and we ask for one of them" do
person = Person.new
person.errors.add(:name, "can not be blank")
person.errors.add(:name, "is invalid")
assert person.errors.added?(:name, "can not be blank")
end
test "added? should be false if no errors are present" do
person = Person.new
assert !person.errors.added?(:name)
end
test "added? should be false when an error is present, but we check for another error" do
person = Person.new
person.errors.add(:name, "is invalid")
assert !person.errors.added?(:name, "can not be blank")
end
test 'should respond to size' do
person = Person.new
person.errors.add(:name, "can not be blank")
assert_equal 1, person.errors.size
end
test 'to_a should return an array' do
person = Person.new
person.errors.add(:name, "can not be blank")
person.errors.add(:name, "can not be nil")
assert_equal ["name can not be blank", "name can not be nil"], person.errors.to_a
end
test 'to_hash should return a hash' do
person = Person.new
person.errors.add(:name, "can not be blank")
assert_instance_of ::Hash, person.errors.to_hash
end
test 'full_messages should return an array of error messages, with the attribute name included' do
person = Person.new
person.errors.add(:name, "can not be blank")
person.errors.add(:name, "can not be nil")
assert_equal ["name can not be blank", "name can not be nil"], person.errors.full_messages
end
test 'full_message should return the given message if attribute equals :base' do
person = Person.new
assert_equal "press the button", person.errors.full_message(:base, "press the button")
end
test 'full_message should return the given message with the attribute name included' do
person = Person.new
assert_equal "name can not be blank", person.errors.full_message(:name, "can not be blank")
end
test 'should return a JSON hash representation of the errors' do
person = Person.new
person.errors.add(:name, "can not be blank")
person.errors.add(:name, "can not be nil")
person.errors.add(:email, "is invalid")
hash = person.errors.as_json
assert_equal ["can not be blank", "can not be nil"], hash[:name]
assert_equal ["is invalid"], hash[:email]
end
test 'should return a JSON hash representation of the errors with full messages' do
person = Person.new
person.errors.add(:name, "can not be blank")
person.errors.add(:name, "can not be nil")
person.errors.add(:email, "is invalid")
hash = person.errors.as_json(:full_messages => true)
assert_equal ["name can not be blank", "name can not be nil"], hash[:name]
assert_equal ["email is invalid"], hash[:email]
end
test "generate_message should work 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
person.errors.expects(:generate_message).with(:name, :empty, {})
person.errors.add_on_empty :name
end
test "add_on_empty generates message for multiple attributes" do
person = Person.new
person.errors.expects(:generate_message).with(:name, :empty, {})
person.errors.expects(:generate_message).with(:age, :empty, {})
person.errors.add_on_empty [:name, :age]
end
test "add_on_empty generates message with custom default message" do
person = Person.new
person.errors.expects(:generate_message).with(:name, :empty, {:message => 'custom'})
person.errors.add_on_empty :name, :message => 'custom'
end
test "add_on_empty generates message with empty string value" do
person = Person.new
person.name = ''
person.errors.expects(:generate_message).with(:name, :empty, {})
person.errors.add_on_empty :name
end
test "add_on_blank generates message" do
person = Person.new
person.errors.expects(:generate_message).with(:name, :blank, {})
person.errors.add_on_blank :name
end
test "add_on_blank generates message for multiple attributes" do
person = Person.new
person.errors.expects(:generate_message).with(:name, :blank, {})
person.errors.expects(:generate_message).with(:age, :blank, {})
person.errors.add_on_blank [:name, :age]
end
test "add_on_blank generates message with custom default message" do
person = Person.new
person.errors.expects(:generate_message).with(:name, :blank, {:message => 'custom'})
person.errors.add_on_blank :name, :message => 'custom'
end
end
|
