forked from thoughtbot/shoulda-matchers
-
Notifications
You must be signed in to change notification settings - Fork 0
/
serialize_matcher.rb
203 lines (185 loc) · 5.15 KB
/
serialize_matcher.rb
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
module Shoulda
module Matchers
module ActiveRecord
# The `serialize` matcher tests usage of the `serialize` macro.
#
# class Product < ActiveRecord::Base
# serialize :customizations
# end
#
# # RSpec
# RSpec.describe Product, type: :model do
# it { should serialize(:customizations) }
# end
#
# # Minitest (Shoulda)
# class ProductTest < ActiveSupport::TestCase
# should serialize(:customizations)
# end
#
# #### Qualifiers
#
# ##### as
#
# Use `as` if you are using a custom serializer class.
#
# class ProductSpecsSerializer
# def load(string)
# # ...
# end
#
# def dump(options)
# # ...
# end
# end
#
# class Product < ActiveRecord::Base
# serialize :specifications, ProductSpecsSerializer
# end
#
# # RSpec
# RSpec.describe Product, type: :model do
# it do
# should serialize(:specifications).
# as(ProductSpecsSerializer)
# end
# end
#
# # Minitest (Shoulda)
# class ProductTest < ActiveSupport::TestCase
# should serialize(:specifications).
# as(ProductSpecsSerializer)
# end
#
# ##### as_instance_of
#
# Use `as_instance_of` if you are using a custom serializer object.
#
# class ProductOptionsSerializer
# def load(string)
# # ...
# end
#
# def dump(options)
# # ...
# end
# end
#
# class Product < ActiveRecord::Base
# serialize :options, ProductOptionsSerializer.new
# end
#
# # RSpec
# RSpec.describe Product, type: :model do
# it do
# should serialize(:options).
# as_instance_of(ProductOptionsSerializer)
# end
# end
#
# # Minitest (Shoulda)
# class ProductTest < ActiveSupport::TestCase
# should serialize(:options).
# as_instance_of(ProductOptionsSerializer)
# end
#
# @return [SerializeMatcher]
#
def serialize(name)
SerializeMatcher.new(name)
end
# @private
class SerializeMatcher
def initialize(name)
@name = name.to_s
@options = {}
end
def as(type)
@options[:type] = type
self
end
def as_instance_of(type)
@options[:instance_type] = type
self
end
def matches?(subject)
@subject = subject
serialization_valid? && type_valid?
end
def failure_message
"Expected #{expectation} (#{@missing})"
end
def failure_message_when_negated
"Did not expect #{expectation}"
end
def description
description = "serialize :#{@name}"
description += " class_name => #{@options[:type]}" if @options.key?(:type)
description
end
protected
def serialization_valid?
if attribute_is_serialized?
true
else
@missing = "no serialized attribute called :#{@name}"
false
end
end
def class_valid?
if @options[:type]
klass = serialization_coder
if klass == @options[:type]
true
else
if klass.respond_to?(:object_class) && klass.object_class == @options[:type]
true
else
@missing = ":#{@name} should be a type of #{@options[:type]}"
false
end
end
else
true
end
end
def model_class
@subject.class
end
def instance_class_valid?
if @options.key?(:instance_type)
if serialization_coder.is_a?(@options[:instance_type])
true
else
@missing = ":#{@name} should be an instance of #{@options[:type]}"
false
end
else
true
end
end
def type_valid?
class_valid? && instance_class_valid?
end
def expectation
expectation = "#{model_class.name} to serialize the attribute called :#{@name}"
expectation += " with a type of #{@options[:type]}" if @options[:type]
expectation += " with an instance of #{@options[:instance_type]}" if @options[:instance_type]
expectation
end
def attribute_is_serialized?
serialized_attributes.include?(@name)
end
def serialization_coder
serialized_attributes[@name]
end
def serialized_attributes
Shoulda::Matchers::RailsShim.serialized_attributes_for(model)
end
def model
@subject.class
end
end
end
end
end