1# frozen_string_literal: true
2
3require "test_helper"
4require "tel_selections"
5
6class TelSelectionsTest < Minitest::Test
7 def setup
8 @manager = TelSelections.new(
9 redis: FakeRedis.new,
10 db: FakeDB.new,
11 memcache: FakeMemcache.new
12 )
13 end
14
15 def test_set_get
16 assert_kind_of TelSelections::ChooseTel, @manager["jid@example.com"].sync
17 @manager.set(
18 "jid@example.com",
19 TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
20 ).sync
21 assert_kind_of TelSelections::HaveTel, @manager["jid@example.com"].sync
22 end
23 em :test_set_get
24
25 def test_choose_tel_have_tel
26 jid = "jid@example.com"
27 @manager.set(
28 jid,
29 TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
30 ).sync
31 assert_equal "+15555550000", @manager[jid].then(&:choose_tel).sync.tel
32 end
33 em :test_choose_tel_have_tel
34
35 class AvailableNumberTest < Minitest::Test
36 def test_for_no_rsm
37 form = Blather::Stanza::X.new
38 form.fields = [{ var: "q", value: "226" }]
39 iris_query = TelSelections::ChooseTel::AvailableNumber
40 .for(form, db: FakeDB.new, memcache: FakeMemcache.new)
41 .instance_variable_get(:@iris_query)
42 assert_equal(
43 { areaCode: "226", enableTNDetail: true, LCA: false, quantity: 10 },
44 iris_query
45 )
46 end
47
48 def test_for_rsm
49 form = Blather::Stanza::X.new
50 form.fields = [{ var: "q", value: "226" }]
51 Nokogiri::XML::Builder.with(form) do
52 set(xmlns: "http://jabber.org/protocol/rsm") do
53 max 500
54 end
55 end
56 iris_query = TelSelections::ChooseTel::AvailableNumber
57 .for(form, db: FakeDB.new, memcache: FakeMemcache.new)
58 .instance_variable_get(:@iris_query)
59 assert_equal(
60 { areaCode: "226", enableTNDetail: true, LCA: false, quantity: 500 },
61 iris_query
62 )
63 end
64
65 def test_for_feelinglucky
66 form = Blather::Stanza::X.new
67 form.fields = [
68 { var: "q", value: "" },
69 {
70 var: "http://jabber.org/protocol/commands#actions",
71 value: "feelinglucky"
72 }
73 ]
74 iris_query = TelSelections::ChooseTel::AvailableNumber
75 .for(form, db: FakeDB.new, memcache: FakeMemcache.new)
76 .instance_variable_get(:@iris_query)
77 assert_equal(
78 { areaCode: "810", enableTNDetail: true, LCA: false, quantity: 10 },
79 iris_query
80 )
81 end
82
83 def test_fallback
84 stub_request(
85 :get,
86 "https://dashboard.bandwidth.com/v1.0/accounts//availableNumbers" \
87 "?city=Kitchener-Waterloo&enableTNDetail=true&lCA=false&" \
88 "quantity=10&state=ON"
89 ).to_return(status: 200, body: "")
90
91 stub_request(
92 :get,
93 "https://geocoder.ca/?json=1&locate=Kitchener-Waterloo,%20ON"
94 ).to_return(status: 200, body: {
95 postal: "N2H", longt: 0, latt: 0
96 }.to_json)
97
98 stub_request(
99 :get,
100 "https://dashboard.bandwidth.com/v1.0/accounts//availableNumbers" \
101 "?areaCode=226&enableTNDetail=true&quantity=10"
102 ).to_return(status: 200, body: <<~XML)
103 <SearchResult>
104 <TelephoneNumberList>
105 <TelephoneNumber>
106 <FullNumber>22655512345</FullNumber>
107 <City>Somewhere</City>
108 <State>ON</State>
109 </TelephoneNumber>
110 </TelephoneNumberList>
111 </SearchResult>
112 XML
113
114 db = FakeDB.new(
115 ["CA", "POINT(0.0000000000 0.0000000000)", 3] =>
116 [{ "area_code" => "226" }]
117 )
118 form = Blather::Stanza::X.new
119 form.fields = [{ var: "q", value: "Kitchener, ON" }]
120 tns = execute_command do
121 TelSelections::ChooseTel::AvailableNumber
122 .for(form, db: db, memcache: FakeMemcache.new)
123 .tns
124 end
125 assert_equal(
126 ["(226) 555-12345 (Somewhere, ON)"],
127 tns.map(&:to_s)
128 )
129 end
130 em :test_fallback
131
132 def test_local_inventory
133 stub_request(
134 :get,
135 "https://dashboard.bandwidth.com/v1.0/accounts//availableNumbers" \
136 "?city=Kitchener-Waterloo&enableTNDetail=true&lCA=false&" \
137 "quantity=10&state=ON"
138 ).to_return(status: 200, body: "")
139
140 db = FakeDB.new(
141 ["ON", "Kitchener-Waterloo"] => [{
142 "tel" => "+122655512345",
143 "region" => "ON",
144 "locality" => "Kitchener-Waterloo"
145 }]
146 )
147 form = Blather::Stanza::X.new
148 form.fields = [{ var: "q", value: "Kitchener, ON" }]
149 tns = execute_command do
150 TelSelections::ChooseTel::AvailableNumber
151 .for(form, db: db, memcache: FakeMemcache.new)
152 .tns
153 end
154 assert_equal(
155 ["(226) 555-12345 (Kitchener-Waterloo, ON)"],
156 tns.map(&:to_s)
157 )
158 end
159 em :test_local_inventory
160 end
161
162 class TnOptionTest < Minitest::Test
163 def setup
164 @tn = TelSelections::ChooseTel::Tn::Option.new(
165 full_number: "5551234567",
166 city: "Toronto",
167 state: "ON",
168 garbage: "stuff"
169 )
170 end
171
172 def test_to_s
173 assert_equal "(555) 123-4567 (Toronto, ON)", @tn.to_s
174 end
175
176 def test_tel
177 assert_equal "+15551234567", @tn.tel
178 end
179
180 def test_option
181 assert_equal(
182 Blather::Stanza::X::Field::Option.new(
183 label: "(555) 123-4567 (Toronto, ON)",
184 value: "+15551234567"
185 ),
186 @tn.option
187 )
188 end
189
190 def test_option_reference
191 ref = @tn.option.find("ns:reference", ns: "urn:xmpp:reference:0").first
192 assert_equal(
193 @tn.formatted_tel,
194 @tn.option.label[ref["begin"].to_i..ref["end"].to_i]
195 )
196 assert_equal "tel:+15551234567", ref["uri"]
197 end
198 end
199
200 class QTest < Minitest::Test
201 def test_for_area_code
202 q = TelSelections::ChooseTel::Q.for("226")
203 assert_equal({ areaCode: "226" }, q.iris_query)
204 end
205
206 def test_for_area_code_sql
207 q = TelSelections::ChooseTel::Q.for("226")
208 assert_equal(
209 ["SELECT * FROM tel_inventory WHERE tel LIKE ?", "+1226%"],
210 q.sql_query
211 )
212 end
213
214 def test_for_npanxx
215 q = TelSelections::ChooseTel::Q.for("226666")
216 assert_equal({ npaNxx: "226666" }, q.iris_query)
217 end
218
219 def test_for_npanxx_sql
220 q = TelSelections::ChooseTel::Q.for("226666")
221 assert_equal(
222 ["SELECT * FROM tel_inventory WHERE tel LIKE ?", "+1226666%"],
223 q.sql_query
224 )
225 end
226
227 def test_for_npanxxx
228 q = TelSelections::ChooseTel::Q.for("2266667")
229 assert_equal({ npaNxxx: "2266667" }, q.iris_query)
230 end
231
232 def test_for_npanxxx_sql
233 q = TelSelections::ChooseTel::Q.for("2266667")
234 assert_equal(
235 ["SELECT * FROM tel_inventory WHERE tel LIKE ?", "+12266667%"],
236 q.sql_query
237 )
238 end
239
240 def test_for_zip
241 q = TelSelections::ChooseTel::Q.for("90210")
242 assert_equal({ zip: "90210" }, q.iris_query)
243 end
244
245 def test_for_zip_sql
246 q = TelSelections::ChooseTel::Q.for("90210")
247 refute q.sql_query
248 end
249
250 def test_for_localvanity
251 q = TelSelections::ChooseTel::Q.for("~mboa")
252 assert_equal({ localVanity: "mboa" }, q.iris_query)
253 end
254
255 def test_for_localvanity_sql
256 q = TelSelections::ChooseTel::Q.for("~mboa")
257 assert_equal(
258 ["SELECT * FROM tel_inventory WHERE tel LIKE ?", "%6262%"],
259 q.sql_query
260 )
261 end
262
263 def test_for_state
264 q = TelSelections::ChooseTel::Q.for("ON")
265 assert_equal({ state: "ON" }, q.iris_query)
266 end
267
268 def test_for_state_sql
269 q = TelSelections::ChooseTel::Q.for("ON")
270 assert_equal(
271 ["SELECT * FROM tel_inventory WHERE region = ?", "ON"],
272 q.sql_query
273 )
274 end
275
276 def test_for_state_name
277 q = TelSelections::ChooseTel::Q.for("ontario")
278 assert_equal({ state: "ON" }, q.iris_query)
279 end
280
281 def test_for_state_name_sql
282 q = TelSelections::ChooseTel::Q.for("ontario")
283 assert_equal(
284 ["SELECT * FROM tel_inventory WHERE region = ?", "ON"],
285 q.sql_query
286 )
287 end
288
289 def test_for_new_york
290 q = TelSelections::ChooseTel::Q.for("New York")
291 assert_equal({ state: "NY" }, q.iris_query)
292 end
293
294 def test_for_new_york_sql
295 q = TelSelections::ChooseTel::Q.for("New York")
296 assert_equal(
297 ["SELECT * FROM tel_inventory WHERE region = ?", "NY"],
298 q.sql_query
299 )
300 end
301
302 def test_for_new_york_ny
303 q = TelSelections::ChooseTel::Q.for(
304 "New York, NY",
305 db: FakeDB.new,
306 memcache: FakeMemcache.new
307 )
308 assert_equal({ city: "New York City", state: "NY" }, q.iris_query)
309 end
310
311 def test_for_new_york_ny_sql
312 q = TelSelections::ChooseTel::Q.for(
313 "New York, NY",
314 db: FakeDB.new,
315 memcache: FakeMemcache.new
316 )
317 assert_equal(
318 [
319 "SELECT * FROM tel_inventory WHERE region = ? AND locality = ?",
320 "NY", "New York City"
321 ],
322 q.sql_query
323 )
324 end
325
326 def test_for_new_york_new_york
327 q = TelSelections::ChooseTel::Q.for(
328 "New York, New York",
329 db: FakeDB.new,
330 memcache: FakeMemcache.new
331 )
332 assert_equal({ city: "New York City", state: "NY" }, q.iris_query)
333 end
334
335 def test_for_new_york_new_york_sql
336 q = TelSelections::ChooseTel::Q.for(
337 "New York, New York",
338 db: FakeDB.new,
339 memcache: FakeMemcache.new
340 )
341 assert_equal(
342 [
343 "SELECT * FROM tel_inventory WHERE region = ? AND locality = ?",
344 "NY", "New York City"
345 ],
346 q.sql_query
347 )
348 end
349
350 def test_for_citystate
351 q = TelSelections::ChooseTel::Q.for(
352 "Toronto, ON",
353 db: FakeDB.new,
354 memcache: FakeMemcache.new
355 )
356 assert_equal({ city: "Toronto", state: "ON" }, q.iris_query)
357 end
358
359 def test_for_citystate_sql
360 q = TelSelections::ChooseTel::Q.for(
361 "Toronto, ON",
362 db: FakeDB.new,
363 memcache: FakeMemcache.new
364 )
365 assert_equal(
366 [
367 "SELECT * FROM tel_inventory WHERE region = ? AND locality = ?",
368 "ON", "Toronto"
369 ],
370 q.sql_query
371 )
372 end
373
374 def test_for_citystate_name
375 q = TelSelections::ChooseTel::Q.for(
376 "Toronto, Ontario",
377 db: FakeDB.new,
378 memcache: FakeMemcache.new
379 )
380 assert_equal({ city: "Toronto", state: "ON" }, q.iris_query)
381 end
382
383 def test_for_citystate_name_sql
384 q = TelSelections::ChooseTel::Q.for(
385 "Toronto, Ontario",
386 db: FakeDB.new,
387 memcache: FakeMemcache.new
388 )
389 assert_equal(
390 [
391 "SELECT * FROM tel_inventory WHERE region = ? AND locality = ?",
392 "ON", "Toronto"
393 ],
394 q.sql_query
395 )
396 end
397
398 def test_for_garbage
399 assert_raises { TelSelections::ChooseTel::Q.for("garbage") }
400 end
401 end
402end