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
|
# frozen_string_literal: true
require "abstract_unit"
class NumberHelperTest < ActionView::TestCase
tests ActionView::Helpers::NumberHelper
def test_number_to_phone
assert_nil number_to_phone(nil)
assert_equal "555-1234", number_to_phone(5551234)
assert_equal "(800) 555-1212 x 123", number_to_phone(8005551212, area_code: true, extension: 123)
assert_equal "+18005551212", number_to_phone(8005551212, country_code: 1, delimiter: "")
assert_equal "+<script></script>8005551212", number_to_phone(8005551212, country_code: "<script></script>", delimiter: "")
assert_equal "8005551212 x <script></script>", number_to_phone(8005551212, extension: "<script></script>", delimiter: "")
end
def test_number_to_currency
assert_nil number_to_currency(nil)
assert_equal "$1,234,567,890.50", number_to_currency(1234567890.50)
assert_equal "$1,234,567,892", number_to_currency(1234567891.50, precision: 0)
assert_equal "1,234,567,890.50 - Kč", number_to_currency("-1234567890.50", unit: raw("Kč"), format: "%n %u", negative_format: "%n - %u")
assert_equal "&pound;1,234,567,890.50", number_to_currency("1234567890.50", unit: "£")
assert_equal "<b>1,234,567,890.50</b> $", number_to_currency("1234567890.50", format: "<b>%n</b> %u")
assert_equal "<b>1,234,567,890.50</b> $", number_to_currency("-1234567890.50", negative_format: "<b>%n</b> %u")
assert_equal "<b>1,234,567,890.50</b> $", number_to_currency("-1234567890.50", "negative_format" => "<b>%n</b> %u")
assert_equal "₹ 12,30,000.00", number_to_currency(1230000, delimiter_pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/, unit: "₹", format: "%u %n")
end
def test_number_to_percentage
assert_nil number_to_percentage(nil)
assert_equal "100.000%", number_to_percentage(100)
assert_equal "100.000 %", number_to_percentage(100, format: "%n %")
assert_equal "<b>100.000</b> %", number_to_percentage(100, format: "<b>%n</b> %")
assert_equal "<b>100.000</b> %", number_to_percentage(100, format: raw("<b>%n</b> %"))
assert_equal "100%", number_to_percentage(100, precision: 0)
assert_equal "123.4%", number_to_percentage(123.400, precision: 3, strip_insignificant_zeros: true)
assert_equal "1.000,000%", number_to_percentage(1000, delimiter: ".", separator: ",")
assert_equal "98a%", number_to_percentage("98a")
assert_equal "NaN%", number_to_percentage(Float::NAN)
assert_equal "Inf%", number_to_percentage(Float::INFINITY)
assert_equal "NaN%", number_to_percentage(Float::NAN, precision: 0)
assert_equal "Inf%", number_to_percentage(Float::INFINITY, precision: 0)
assert_equal "NaN%", number_to_percentage(Float::NAN, precision: 1)
assert_equal "Inf%", number_to_percentage(Float::INFINITY, precision: 1)
end
def test_number_with_delimiter
assert_nil number_with_delimiter(nil)
assert_equal "12,345,678", number_with_delimiter(12345678)
assert_equal "0", number_with_delimiter(0)
end
def test_number_with_precision
assert_nil number_with_precision(nil)
assert_equal "-111.235", number_with_precision(-111.2346)
assert_equal "111.00", number_with_precision(111, precision: 2)
assert_equal "0.00100", number_with_precision(0.001, precision: 5)
assert_equal "3.33", number_with_precision(Rational(10, 3), precision: 2)
end
def test_number_to_human_size
assert_nil number_to_human_size(nil)
assert_equal "3 Bytes", number_to_human_size(3.14159265)
assert_equal "1.2 MB", number_to_human_size(1234567, precision: 2)
end
def test_number_to_human
assert_nil number_to_human(nil)
assert_equal "0", number_to_human(0)
assert_equal "1.23 Thousand", number_to_human(1234)
assert_equal "489.0 Thousand", number_to_human(489000, precision: 4, strip_insignificant_zeros: false)
end
def test_number_to_human_escape_units
volume = { unit: "<b>ml</b>", thousand: "<b>lt</b>", million: "<b>m3</b>", trillion: "<b>km3</b>", quadrillion: "<b>Pl</b>" }
assert_equal "123 <b>lt</b>", number_to_human(123456, units: volume)
assert_equal "12 <b>ml</b>", number_to_human(12, units: volume)
assert_equal "1.23 <b>m3</b>", number_to_human(1234567, units: volume)
assert_equal "1.23 <b>km3</b>", number_to_human(1_234_567_000_000, units: volume)
assert_equal "1.23 <b>Pl</b>", number_to_human(1_234_567_000_000_000, units: volume)
# Including fractionals
distance = { mili: "<b>mm</b>", centi: "<b>cm</b>", deci: "<b>dm</b>", unit: "<b>m</b>",
ten: "<b>dam</b>", hundred: "<b>hm</b>", thousand: "<b>km</b>",
micro: "<b>um</b>", nano: "<b>nm</b>", pico: "<b>pm</b>", femto: "<b>fm</b>" }
assert_equal "1.23 <b>mm</b>", number_to_human(0.00123, units: distance)
assert_equal "1.23 <b>cm</b>", number_to_human(0.0123, units: distance)
assert_equal "1.23 <b>dm</b>", number_to_human(0.123, units: distance)
assert_equal "1.23 <b>m</b>", number_to_human(1.23, units: distance)
assert_equal "1.23 <b>dam</b>", number_to_human(12.3, units: distance)
assert_equal "1.23 <b>hm</b>", number_to_human(123, units: distance)
assert_equal "1.23 <b>km</b>", number_to_human(1230, units: distance)
assert_equal "1.23 <b>um</b>", number_to_human(0.00000123, units: distance)
assert_equal "1.23 <b>nm</b>", number_to_human(0.00000000123, units: distance)
assert_equal "1.23 <b>pm</b>", number_to_human(0.00000000000123, units: distance)
assert_equal "1.23 <b>fm</b>", number_to_human(0.00000000000000123, units: distance)
end
def test_number_helpers_escape_delimiter_and_separator
assert_equal "111<script></script>111<script></script>1111", number_to_phone(1111111111, delimiter: "<script></script>")
assert_equal "$1<script></script>01", number_to_currency(1.01, separator: "<script></script>")
assert_equal "$1<script></script>000.00", number_to_currency(1000, delimiter: "<script></script>")
assert_equal "1<script></script>010%", number_to_percentage(1.01, separator: "<script></script>")
assert_equal "1<script></script>000.000%", number_to_percentage(1000, delimiter: "<script></script>")
assert_equal "1<script></script>01", number_with_delimiter(1.01, separator: "<script></script>")
assert_equal "1<script></script>000", number_with_delimiter(1000, delimiter: "<script></script>")
assert_equal "1<script></script>010", number_with_precision(1.01, separator: "<script></script>")
assert_equal "1<script></script>000.000", number_with_precision(1000, delimiter: "<script></script>")
assert_equal "9<script></script>86 KB", number_to_human_size(10100, separator: "<script></script>")
assert_equal "1<script></script>01", number_to_human(1.01, separator: "<script></script>")
assert_equal "100<script></script>000 Quadrillion", number_to_human(10**20, delimiter: "<script></script>")
end
def test_number_to_human_with_custom_translation_scope
I18n.backend.store_translations "ts",
custom_units_for_number_to_human: { mili: "mm", centi: "cm", deci: "dm", unit: "m", ten: "dam", hundred: "hm", thousand: "km" }
assert_equal "1.01 cm", number_to_human(0.0101, locale: "ts", units: :custom_units_for_number_to_human)
ensure
I18n.reload!
end
def test_number_helpers_outputs_are_html_safe
assert_predicate number_to_human(1), :html_safe?
assert_not_predicate number_to_human("<script></script>"), :html_safe?
assert_predicate number_to_human("asdf".html_safe), :html_safe?
assert_predicate number_to_human("1".html_safe), :html_safe?
assert_predicate number_to_human_size(1), :html_safe?
assert_predicate number_to_human_size(1000000), :html_safe?
assert_not_predicate number_to_human_size("<script></script>"), :html_safe?
assert_predicate number_to_human_size("asdf".html_safe), :html_safe?
assert_predicate number_to_human_size("1".html_safe), :html_safe?
assert_predicate number_with_precision(1, strip_insignificant_zeros: false), :html_safe?
assert_predicate number_with_precision(1, strip_insignificant_zeros: true), :html_safe?
assert_not_predicate number_with_precision("<script></script>"), :html_safe?
assert_predicate number_with_precision("asdf".html_safe), :html_safe?
assert_predicate number_with_precision("1".html_safe), :html_safe?
assert_predicate number_to_currency(1), :html_safe?
assert_not_predicate number_to_currency("<script></script>"), :html_safe?
assert_predicate number_to_currency("asdf".html_safe), :html_safe?
assert_predicate number_to_currency("1".html_safe), :html_safe?
assert_predicate number_to_percentage(1), :html_safe?
assert_not_predicate number_to_percentage("<script></script>"), :html_safe?
assert_predicate number_to_percentage("asdf".html_safe), :html_safe?
assert_predicate number_to_percentage("1".html_safe), :html_safe?
assert_predicate number_to_phone(1), :html_safe?
assert_equal "<script></script>", number_to_phone("<script></script>")
assert_predicate number_to_phone("<script></script>"), :html_safe?
assert_predicate number_to_phone("asdf".html_safe), :html_safe?
assert_predicate number_to_phone("1".html_safe), :html_safe?
assert_predicate number_with_delimiter(1), :html_safe?
assert_not_predicate number_with_delimiter("<script></script>"), :html_safe?
assert_predicate number_with_delimiter("asdf".html_safe), :html_safe?
assert_predicate number_with_delimiter("1".html_safe), :html_safe?
end
def test_number_helpers_should_raise_error_if_invalid_when_specified
exception = assert_raise InvalidNumberError do
number_to_human("x", raise: true)
end
assert_equal "x", exception.number
exception = assert_raise InvalidNumberError do
number_to_human_size("x", raise: true)
end
assert_equal "x", exception.number
exception = assert_raise InvalidNumberError do
number_with_precision("x", raise: true)
end
assert_equal "x", exception.number
exception = assert_raise InvalidNumberError do
number_to_currency("x", raise: true)
end
assert_equal "x", exception.number
exception = assert_raise InvalidNumberError do
number_to_percentage("x", raise: true)
end
assert_equal "x", exception.number
exception = assert_raise InvalidNumberError do
number_with_delimiter("x", raise: true)
end
assert_equal "x", exception.number
exception = assert_raise InvalidNumberError do
number_to_phone("x", raise: true)
end
assert_equal "x", exception.number
end
end
|
