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