measured 1.6.0 → 2.0.0.pre1

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.
@@ -1,227 +0,0 @@
1
- require "test_helper"
2
-
3
- class Measured::CaseSensitiveMeasurableTest < ActiveSupport::TestCase
4
-
5
- setup do
6
- @magic = CaseSensitiveMagic.new(10, :magic_missile)
7
- end
8
-
9
- test "#initialize requires two params, the amount and the unit" do
10
- assert_nothing_raised do
11
- CaseSensitiveMagic.new(1, "fireball")
12
- end
13
-
14
- assert_raises ArgumentError do
15
- CaseSensitiveMagic.new(1)
16
- end
17
- end
18
-
19
- test "#initialize converts unit to string from symbol" do
20
- magic = CaseSensitiveMagic.new(1, :arcane)
21
- assert_equal "arcane", magic.unit
22
- end
23
-
24
- test "#initialize raises if it is an unknown unit" do
25
- assert_raises Measured::UnitError do
26
- CaseSensitiveMagic.new(1, "slash")
27
- end
28
- end
29
-
30
- test "#initialize converts numbers and strings into BigDecimal" do
31
- assert_equal BigDecimal(1), CaseSensitiveMagic.new(1, :arcane).value
32
- assert_equal BigDecimal("2.3"), CaseSensitiveMagic.new("2.3", :arcane).value
33
- assert_equal BigDecimal("5"), CaseSensitiveMagic.new("5", :arcane).value
34
- end
35
-
36
- test "#initialize converts floats to strings and then to BigDecimal so it does not raise" do
37
- assert_equal BigDecimal("1.2345"), CaseSensitiveMagic.new(1.2345, :fire).value
38
- end
39
-
40
- test "#initialize converts numbers and strings BigDecimal and does not round large numbers" do
41
- assert_equal BigDecimal(9.1234572342342, 14), CaseSensitiveMagic.new(9.1234572342342, :fire).value
42
- assert_equal BigDecimal("9.1234572342342"), CaseSensitiveMagic.new(9.1234572342342, :fire).value
43
- end
44
-
45
- test "#initialize converts to the base unit name" do
46
- assert_equal "fireball", CaseSensitiveMagic.new(1, :fire).unit
47
- end
48
-
49
- test "#initialize raises an expected error when initializing with nil value" do
50
- exception = assert_raises(Measured::UnitError) do
51
- CaseSensitiveMagic.new(nil, :fire)
52
- end
53
- assert_equal "Unit value cannot be nil", exception.message
54
- end
55
-
56
- test "#initialize raises an expected error when initializing with nil unit" do
57
- exception = assert_raises(Measured::UnitError) do
58
- CaseSensitiveMagic.new(1, nil)
59
- end
60
- assert_equal "Unit cannot be blank", exception.message
61
- end
62
-
63
- test "#initialize raises an expected error when initializing with empty string value" do
64
- exception = assert_raises(Measured::UnitError) do
65
- CaseSensitiveMagic.new("", :fire)
66
- end
67
- assert_equal "Unit value cannot be blank", exception.message
68
- end
69
-
70
- test "#initialize raises an expected error when initializing with empty string unit" do
71
- exception = assert_raises(Measured::UnitError) do
72
- CaseSensitiveMagic.new(1, "")
73
- end
74
- assert_equal "Unit cannot be blank", exception.message
75
- end
76
-
77
- test "#unit allows you to read the unit string" do
78
- assert_equal "magic_missile", @magic.unit
79
- end
80
-
81
- test "#value allows you to read the numeric value" do
82
- assert_equal BigDecimal(10), @magic.value
83
- end
84
-
85
- test ".conversion is set and cached" do
86
- conversion = CaseSensitiveMagic.conversion
87
-
88
- assert_instance_of Measured::Conversion, conversion
89
- assert_equal conversion, CaseSensitiveMagic.conversion
90
- end
91
-
92
- test ".conversion is set to case sensitive" do
93
- conversion = CaseSensitiveMagic.conversion
94
-
95
- assert_instance_of Measured::Conversion, conversion
96
- assert_equal conversion, CaseSensitiveMagic.conversion
97
- assert_equal true, conversion.case_sensitive
98
- end
99
-
100
- test ".units returns just the base units" do
101
- assert_equal ["arcane", "fireball", "ice", "magic_missile", "ultima"], CaseSensitiveMagic.units
102
- end
103
-
104
- test ".units_with_aliases returns all units" do
105
- assert_equal ["arcane", "fire", "fireball", "fireballs", "ice", "magic_missile", "magic_missiles", "ultima"], CaseSensitiveMagic.units_with_aliases
106
- end
107
-
108
- test ".valid_unit? looks at the list of units and aliases" do
109
- assert CaseSensitiveMagic.valid_unit?("fire")
110
- assert CaseSensitiveMagic.valid_unit?("fireball")
111
- assert CaseSensitiveMagic.valid_unit?(:ice)
112
- refute CaseSensitiveMagic.valid_unit?("junk")
113
- end
114
-
115
- test ".name looks at the class name" do
116
- module Example
117
- class VeryComplexThing < Measured::Measurable ; end
118
- end
119
-
120
- assert_equal "case sensitive magic", CaseSensitiveMagic.name
121
- assert_equal "measurable", Measured::Measurable.name
122
- assert_equal "very complex thing", Example::VeryComplexThing.name
123
- end
124
-
125
- test "#convert_to raises on an invalid unit" do
126
- assert_raises Measured::UnitError do
127
- @magic.convert_to(:punch)
128
- end
129
- end
130
-
131
- test "#convert_to returns a new object of the same type in the new unit" do
132
- converted = @magic.convert_to(:arcane)
133
-
134
- assert_equal converted, @magic
135
- refute_equal converted.object_id, @magic.object_id
136
- assert_equal BigDecimal(10), @magic.value
137
- assert_equal "magic_missile", @magic.unit
138
- assert_equal BigDecimal(1), converted.value
139
- assert_equal "arcane", converted.unit
140
- end
141
-
142
- test "#convert_to from and to the same unit returns the same object" do
143
- converted = @magic.convert_to(@magic.unit)
144
- assert_equal converted.object_id, @magic.object_id
145
- end
146
-
147
- test "#convert_to! replaces the existing object with a new version in the new unit" do
148
- converted = @magic.convert_to!(:arcane)
149
-
150
- assert_equal converted, @magic
151
- assert_equal BigDecimal(1), @magic.value
152
- assert_equal "arcane", @magic.unit
153
- assert_equal BigDecimal(1), converted.value
154
- assert_equal "arcane", converted.unit
155
- end
156
-
157
- test "#to_s outputs the number and the unit" do
158
- assert_equal "10 fireball", CaseSensitiveMagic.new(10, :fire).to_s
159
- assert_equal "1.234 magic_missile", CaseSensitiveMagic.new("1.234", :magic_missile).to_s
160
- end
161
-
162
- test "#inspect shows the number and the unit" do
163
- assert_equal "#<CaseSensitiveMagic: 10.0 fireball>", CaseSensitiveMagic.new(10, :fire).inspect
164
- assert_equal "#<CaseSensitiveMagic: 1.234 magic_missile>", CaseSensitiveMagic.new(1.234, :magic_missile).inspect
165
- end
166
-
167
- test "#<=> compares regardless of the unit" do
168
- assert_equal -1, @magic <=> CaseSensitiveMagic.new(10, :fire)
169
- assert_equal 1, @magic <=> CaseSensitiveMagic.new(9, :magic_missile)
170
- assert_equal 0, @magic <=> CaseSensitiveMagic.new(10, :magic_missile)
171
- assert_equal -1, @magic <=> CaseSensitiveMagic.new(11, :magic_missile)
172
- end
173
-
174
- test "#<=> compares against zero" do
175
- assert_equal 1, @magic <=> 0
176
- assert_equal 1, @magic <=> BigDecimal.new(0)
177
- assert_equal 1, @magic <=> 0.00
178
- assert_equal -1, CaseSensitiveMagic.new(-1, :magic_missile) <=> 0
179
- end
180
-
181
- test "#== should be the same if the classes, unit, and amount match" do
182
- assert @magic == @magic
183
- assert CaseSensitiveMagic.new(10, :magic_missile) == CaseSensitiveMagic.new("10", "magic_missile")
184
- assert CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10, :magic_missile)
185
- refute CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10.1, :magic_missile)
186
- end
187
-
188
- test "#== should be the same if the classes and amount match but the unit does not so they convert" do
189
- assert CaseSensitiveMagic.new(2, :magic_missile) == CaseSensitiveMagic.new("1", "ice")
190
- end
191
-
192
- test "#== compares against zero" do
193
- assert CaseSensitiveMagic.new(0, :fire) == 0
194
- assert CaseSensitiveMagic.new(0, :magic_missile) == 0
195
- assert CaseSensitiveMagic.new(0, :fire) == BigDecimal.new(0)
196
- assert CaseSensitiveMagic.new(0, :fire) == 0.00
197
- refute @magic == 0
198
- refute @magic == BigDecimal.new(0)
199
- end
200
-
201
- test "#> and #< should compare measurements" do
202
- assert CaseSensitiveMagic.new(10, :magic_missile) < CaseSensitiveMagic.new(20, :magic_missile)
203
- refute CaseSensitiveMagic.new(10, :magic_missile) > CaseSensitiveMagic.new(20, :magic_missile)
204
- end
205
-
206
- test "#> and #< should compare measurements of different units" do
207
- assert CaseSensitiveMagic.new(10, :magic_missile) < CaseSensitiveMagic.new(100, :ice)
208
- refute CaseSensitiveMagic.new(10, :magic_missile) > CaseSensitiveMagic.new(100, :ice)
209
- end
210
-
211
- test "#> and #< should compare against zero" do
212
- assert @magic > 0
213
- assert @magic > BigDecimal.new(0)
214
- assert @magic > 0.00
215
- assert CaseSensitiveMagic.new(-1, :arcane) < 0
216
- refute @magic < 0
217
- refute CaseSensitiveMagic.new(-1, :arcane) > 0
218
- end
219
-
220
- test "#eql? should be the same if the classes and amount match, and unit is converted" do
221
- assert @magic == @magic
222
- assert CaseSensitiveMagic.new(10, :magic_missile) == CaseSensitiveMagic.new("10", "magic_missile")
223
- assert CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10, :magic_missile)
224
- refute CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10.1, :magic_missile)
225
- end
226
-
227
- end
@@ -1,243 +0,0 @@
1
- require "test_helper"
2
-
3
- class Measured::ConversionTest < ActiveSupport::TestCase
4
- setup do
5
- @conversion = Measured::Conversion.new
6
- end
7
-
8
- test "#base sets the base unit" do
9
- @conversion.set_base :m, aliases: [:metre]
10
- assert_equal ["m", "metre"], @conversion.base_unit.names
11
- end
12
-
13
- test "#base doesn't allow a second base to be added" do
14
- @conversion.set_base :m, aliases: [:metre]
15
-
16
- assert_raises Measured::UnitError do
17
- @conversion.set_base :in
18
- end
19
- end
20
-
21
- test "#add adds a new unit" do
22
- @conversion.set_base :m
23
- @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
24
-
25
- assert_equal 2, @conversion.units.count
26
- end
27
-
28
- test "#add cannot add duplicate unit names" do
29
- @conversion.set_base :m
30
- @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
31
-
32
- assert_raises Measured::UnitError do
33
- @conversion.add :in, aliases: [:thing], value: "123 m"
34
- end
35
-
36
- assert_raises Measured::UnitError do
37
- @conversion.add :inch, value: "123 m"
38
- end
39
- end
40
-
41
- test "#add does not allow you to add a unit before the base" do
42
- assert_raises Measured::UnitError do
43
- @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
44
- end
45
- end
46
-
47
- test "#unit_names_with_aliases lists all allowed unit names" do
48
- @conversion.set_base :m
49
- @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
50
- @conversion.add :ft, aliases: [:feet, :foot], value: "0.3048 meter"
51
-
52
- assert_equal ["feet", "foot", "ft", "in", "inch", "m"], @conversion.unit_names_with_aliases
53
- end
54
-
55
- test "#unit_names lists all base unit names without aliases" do
56
- @conversion.set_base :m
57
- @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
58
- @conversion.add :ft, aliases: [:feet, :foot], value: "0.3048 meter"
59
-
60
- assert_equal ["ft", "in", "m"], @conversion.unit_names
61
- end
62
-
63
- test "#unit? checks if the unit is part of the units and aliases" do
64
- @conversion.set_base :m
65
- @conversion.add :inch, aliases: [:in], value: "0.0254 meter"
66
-
67
- assert @conversion.unit?(:inch)
68
- assert @conversion.unit?("m")
69
- assert @conversion.unit?("M")
70
- refute @conversion.unit?("in")
71
- refute @conversion.unit?(:yard)
72
- end
73
-
74
- test "#unit? takes into account case_sensitive flag" do
75
- conversion = Measured::Conversion.new(case_sensitive: true)
76
- conversion.set_base :m
77
- conversion.add :inch, aliases: [:in], value: "0.0254 meter"
78
-
79
- assert conversion.unit?(:inch)
80
- assert conversion.unit?("m")
81
- refute conversion.unit?("M")
82
- refute conversion.unit?("in")
83
- end
84
-
85
- test "#unit? with blank and nil arguments" do
86
- refute @conversion.unit?("")
87
- refute @conversion.unit?(nil)
88
- end
89
-
90
- test "#unit_or_alias? checks if the unit is part of the units but not aliases" do
91
- @conversion.set_base :m
92
- @conversion.add :inch, aliases: [:in], value: "0.0254 meter"
93
-
94
- assert @conversion.unit_or_alias?(:inch)
95
- assert @conversion.unit_or_alias?("m")
96
- assert @conversion.unit_or_alias?(:IN)
97
- assert @conversion.unit_or_alias?("in")
98
- refute @conversion.unit_or_alias?(:yard)
99
- end
100
-
101
- test "#unit_or_alias? takes into account case_sensitive flag" do
102
- conversion = Measured::Conversion.new(case_sensitive: true)
103
- conversion.set_base :m
104
- conversion.add :inch, aliases: [:in], value: "0.0254 meter"
105
-
106
- assert conversion.unit_or_alias?(:inch)
107
- assert conversion.unit_or_alias?("m")
108
- refute conversion.unit_or_alias?(:M)
109
- refute conversion.unit_or_alias?("IN")
110
- end
111
-
112
- test "#unit_or_alias? with blank and nil arguments" do
113
- @conversion.set_base :m
114
- @conversion.add :inch, aliases: [:in], value: "0.0254 meter"
115
-
116
- refute @conversion.unit_or_alias?("")
117
- refute @conversion.unit_or_alias?(nil)
118
- end
119
-
120
- test "#to_unit_name converts a unit name to its base unit" do
121
- assert_equal "fireball", Magic.conversion.to_unit_name("fire")
122
- end
123
-
124
- test "#to_unit_name does not care about string or symbol" do
125
- assert_equal "fireball", Magic.conversion.to_unit_name(:fire)
126
- end
127
-
128
- test "#to_unit_name passes through if already base unit name" do
129
- assert_equal "fireball", Magic.conversion.to_unit_name("fireball")
130
- end
131
-
132
- test "#to_unit_name raises if not found" do
133
- assert_raises Measured::UnitError do
134
- Magic.conversion.to_unit_name("thunder")
135
- end
136
- end
137
-
138
- test "#convert raises if either unit is not found" do
139
- assert_raises Measured::UnitError do
140
- Magic.conversion.convert(1, from: "fire", to: "doesnt_exist")
141
- end
142
-
143
- assert_raises Measured::UnitError do
144
- Magic.conversion.convert(1, from: "doesnt_exist", to: "fire")
145
- end
146
- end
147
-
148
- test "#convert converts betwen two known units" do
149
- @conversion.set_base :m
150
- @conversion.add :cm, value: "0.01 m"
151
-
152
- assert_equal BigDecimal("10"), @conversion.convert(BigDecimal("1000"), from: "cm", to: "m")
153
- assert_equal BigDecimal("250"), @conversion.convert(BigDecimal("2.5"), from: "m", to: "cm")
154
- end
155
-
156
- test "#convert handles the same unit" do
157
- @conversion.set_base :m
158
- @conversion.add :cm, value: "0.01 m"
159
-
160
- assert_equal BigDecimal("2"), @conversion.convert(BigDecimal("2"), from: "cm", to: "cm")
161
- end
162
-
163
- test "#conversion_table returns expected nested hashes with BigDecimal conversion factors in a tiny data set" do
164
- @conversion.set_base :m
165
- @conversion.add :cm, value: "0.01 m"
166
-
167
- expected = {
168
- "m" => {
169
- "m" => BigDecimal("1"),
170
- "cm" => BigDecimal("100")
171
- },
172
- "cm" => {
173
- "cm" => BigDecimal("1"),
174
- "m" => BigDecimal("0.01")
175
- }
176
- }
177
-
178
- assert_equal expected, @conversion.conversion_table
179
- end
180
-
181
- test "#conversion_table returns expected nested hashes with BigDecimal conversion factors" do
182
- @conversion.set_base :m
183
- @conversion.add :cm, value: "0.01 m"
184
- @conversion.add :mm, value: "0.001 m"
185
-
186
- expected = {
187
- "m" => {
188
- "m" => BigDecimal("1"),
189
- "cm" => BigDecimal("100"),
190
- "mm" => BigDecimal("1000")
191
- },
192
- "cm" => {
193
- "cm" => BigDecimal("1"),
194
- "m" => BigDecimal("0.01"),
195
- "mm" => BigDecimal("10")
196
- },
197
- "mm" => {
198
- "mm" => BigDecimal("1"),
199
- "m" => BigDecimal("0.001"),
200
- "cm" => BigDecimal("0.1")
201
- }
202
- }
203
-
204
- assert_equal expected, @conversion.conversion_table
205
- end
206
-
207
- test "#conversion_table returns expected nested hashes with BigDecimal conversion factors in an indrect path" do
208
- @conversion.set_base :mm
209
- @conversion.add :cm, value: "10 mm"
210
- @conversion.add :dm, value: "10 cm"
211
- @conversion.add :m, value: "10 dm"
212
-
213
- expected = {
214
- "m" => {
215
- "m" => BigDecimal("1"),
216
- "cm" => BigDecimal("100"),
217
- "dm" => BigDecimal("10"),
218
- "mm" => BigDecimal("1000")
219
- },
220
- "cm" => {
221
- "cm" => BigDecimal("1"),
222
- "dm" => BigDecimal("0.1"),
223
- "m" => BigDecimal("0.01"),
224
- "mm" => BigDecimal("10")
225
- },
226
- "dm" => {
227
- "dm" => BigDecimal("1"),
228
- "cm" => BigDecimal("10"),
229
- "m" => BigDecimal("0.1"),
230
- "mm" => BigDecimal("100")
231
- },
232
- "mm" => {
233
- "mm" => BigDecimal("1"),
234
- "m" => BigDecimal("0.001"),
235
- "dm" => BigDecimal("0.01"),
236
- "cm" => BigDecimal("0.1")
237
- }
238
- }
239
-
240
- assert_equal expected, @conversion.conversion_table
241
- end
242
-
243
- end