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
|
require 'cases/helper'
require 'minitest/mock'
module ActiveRecord
class AttributeTest < ActiveRecord::TestCase
setup do
@type = Minitest::Mock.new
@type.expect(:==, false, [false])
end
teardown do
assert @type.verify
end
test "from_database + read type casts from database" do
@type.expect(:deserialize, 'type cast from database', ['a value'])
attribute = Attribute.from_database(nil, 'a value', @type)
type_cast_value = attribute.value
assert_equal 'type cast from database', type_cast_value
end
test "from_user + read type casts from user" do
@type.expect(:cast, 'type cast from user', ['a value'])
attribute = Attribute.from_user(nil, 'a value', @type)
type_cast_value = attribute.value
assert_equal 'type cast from user', type_cast_value
end
test "reading memoizes the value" do
@type.expect(:deserialize, 'from the database', ['whatever'])
attribute = Attribute.from_database(nil, 'whatever', @type)
type_cast_value = attribute.value
second_read = attribute.value
assert_equal 'from the database', type_cast_value
assert_same type_cast_value, second_read
end
test "reading memoizes falsy values" do
@type.expect(:deserialize, false, ['whatever'])
attribute = Attribute.from_database(nil, 'whatever', @type)
attribute.value
attribute.value
end
test "read_before_typecast returns the given value" do
attribute = Attribute.from_database(nil, 'raw value', @type)
raw_value = attribute.value_before_type_cast
assert_equal 'raw value', raw_value
end
test "from_database + read_for_database type casts to and from database" do
@type.expect(:deserialize, 'read from database', ['whatever'])
@type.expect(:serialize, 'ready for database', ['read from database'])
attribute = Attribute.from_database(nil, 'whatever', @type)
serialize = attribute.value_for_database
assert_equal 'ready for database', serialize
end
test "from_user + read_for_database type casts from the user to the database" do
@type.expect(:cast, 'read from user', ['whatever'])
@type.expect(:serialize, 'ready for database', ['read from user'])
attribute = Attribute.from_user(nil, 'whatever', @type)
serialize = attribute.value_for_database
assert_equal 'ready for database', serialize
end
test "duping dups the value" do
@type.expect(:deserialize, 'type cast', ['a value'])
attribute = Attribute.from_database(nil, 'a value', @type)
value_from_orig = attribute.value
value_from_clone = attribute.dup.value
value_from_orig << ' foo'
assert_equal 'type cast foo', value_from_orig
assert_equal 'type cast', value_from_clone
end
test "duping does not dup the value if it is not dupable" do
@type.expect(:deserialize, false, ['a value'])
attribute = Attribute.from_database(nil, 'a value', @type)
assert_same attribute.value, attribute.dup.value
end
test "duping does not eagerly type cast if we have not yet type cast" do
attribute = Attribute.from_database(nil, 'a value', @type)
attribute.dup
end
class MyType
def cast(value)
value + " from user"
end
def deserialize(value)
value + " from database"
end
end
test "with_value_from_user returns a new attribute with the value from the user" do
old = Attribute.from_database(nil, "old", MyType.new)
new = old.with_value_from_user("new")
assert_equal "old from database", old.value
assert_equal "new from user", new.value
end
test "with_value_from_database returns a new attribute with the value from the database" do
old = Attribute.from_user(nil, "old", MyType.new)
new = old.with_value_from_database("new")
assert_equal "old from user", old.value
assert_equal "new from database", new.value
end
test "uninitialized attributes yield their name if a block is given to value" do
block = proc { |name| name.to_s + "!" }
foo = Attribute.uninitialized(:foo, nil)
bar = Attribute.uninitialized(:bar, nil)
assert_equal "foo!", foo.value(&block)
assert_equal "bar!", bar.value(&block)
end
test "uninitialized attributes have no value" do
assert_nil Attribute.uninitialized(:foo, nil).value
end
test "attributes equal other attributes with the same constructor arguments" do
first = Attribute.from_database(:foo, 1, Type::Integer.new)
second = Attribute.from_database(:foo, 1, Type::Integer.new)
assert_equal first, second
end
test "attributes do not equal attributes with different names" do
first = Attribute.from_database(:foo, 1, Type::Integer.new)
second = Attribute.from_database(:bar, 1, Type::Integer.new)
assert_not_equal first, second
end
test "attributes do not equal attributes with different types" do
first = Attribute.from_database(:foo, 1, Type::Integer.new)
second = Attribute.from_database(:foo, 1, Type::Float.new)
assert_not_equal first, second
end
test "attributes do not equal attributes with different values" do
first = Attribute.from_database(:foo, 1, Type::Integer.new)
second = Attribute.from_database(:foo, 2, Type::Integer.new)
assert_not_equal first, second
end
test "attributes do not equal attributes of other classes" do
first = Attribute.from_database(:foo, 1, Type::Integer.new)
second = Attribute.from_user(:foo, 1, Type::Integer.new)
assert_not_equal first, second
end
test "an attribute has not been read by default" do
attribute = Attribute.from_database(:foo, 1, Type::Value.new)
assert_not attribute.has_been_read?
end
test "an attribute has been read when its value is calculated" do
attribute = Attribute.from_database(:foo, 1, Type::Value.new)
attribute.value
assert attribute.has_been_read?
end
test "an attribute can not be mutated if it has not been read,
and skips expensive calculations" do
type_which_raises_from_all_methods = Object.new
attribute = Attribute.from_database(:foo, "bar", type_which_raises_from_all_methods)
assert_not attribute.changed_in_place_from?("bar")
end
end
end
|
