1# frozen_string_literal: true
2
3begin
4 require "simplecov"
5 SimpleCov.start do
6 add_filter "/test/"
7 enable_coverage :branch
8 end
9rescue LoadError
10 nil
11end
12
13require "em_promise"
14require "fiber"
15require "minitest/autorun"
16require "rantly/minitest_extensions"
17require "sentry-ruby"
18require "webmock/minitest"
19begin
20 require "pry-rescue/minitest"
21 require "pry-reload"
22
23 module Minitest
24 class Test
25 alias old_capture_exceptions capture_exceptions
26 def capture_exceptions
27 old_capture_exceptions do
28 yield
29 rescue Minitest::Skip => e
30 failures << e
31 end
32 end
33 end
34 end
35rescue LoadError
36 # Just helpers for dev, no big deal if missing
37 nil
38end
39
40require "backend_sgx"
41require "tel_selections"
42
43$VERBOSE = nil
44Sentry.init
45
46def mksgx(customer_id="bogus", **kwargs)
47 kwargs.delete(:sgx) || BackendSgx.new(
48 jid: Blather::JID.new(CONFIG[:sgx]),
49 creds: CONFIG[:creds],
50 from_jid: ProxiedJID.proxy(
51 "customer_#{customer_id}",
52 CONFIG[:component][:jid]
53 ).__getobj__,
54 ogm_url: NotLoaded.new("ogm_url"),
55 fwd: NotLoaded.new("fwd"),
56 transcription_enabled: NotLoaded.new("transcription_enabled"),
57 registered?: NotLoaded.new("registered?"),
58 **kwargs
59 )
60end
61
62def customer(
63 customer_id="test",
64 plan_name: nil,
65 jid: Blather::JID.new("#{customer_id}@example.net"),
66 expires_at: Time.now,
67 auto_top_up_amount: 0,
68 **kwargs
69)
70 Customer.extract(
71 customer_id,
72 jid,
73 sgx: kwargs.delete(:sgx) || mksgx(customer_id),
74 plan_name: plan_name,
75 expires_at: expires_at,
76 auto_top_up_amount: auto_top_up_amount,
77 **kwargs
78 )
79end
80
81CONFIG = {
82 sgx: "sgx",
83 component: {
84 jid: "component"
85 },
86 creds: {
87 account: "test_bw_account",
88 username: "test_bw_user",
89 password: "test_bw_password"
90 },
91 sgx_creds: {
92 route_value: {
93 username: "test_sgx_user",
94 password: "test_sgx_password",
95 account: "test_sgx_account"
96 }
97 },
98 notify_from: "notify_from@example.org",
99 activation_amount: 1,
100 activation_amount_accept: 1,
101 plans: [
102 {
103 name: "test_usd",
104 currency: :USD,
105 monthly_price: 10000,
106 messages: :unlimited,
107 minutes: { included: 10440, price: 87 },
108 allow_register: true
109 },
110 {
111 name: "test_bad_currency",
112 currency: :BAD
113 },
114 {
115 name: "test_usd_no_register",
116 currency: :USD,
117 monthly_price: 10000,
118 messages: :unlimited,
119 minutes: { included: 10440, price: 87 },
120 allow_register: false
121 },
122 {
123 name: "test_cad",
124 currency: :CAD,
125 monthly_price: 10000
126 }
127 ],
128 braintree: {
129 merchant_accounts: {
130 USD: "merchant_usd"
131 }
132 },
133 sip: {
134 realm: "sip.example.com",
135 app: "sipappid"
136 },
137 xep0157: [
138 { var: "support-addresses", value: "xmpp:tel@cheogram.com" }
139 ],
140 credit_card_url: ->(*) { "http://creditcard.example.com?" },
141 electrum_notify_url: ->(*) { "http://notify.example.com" },
142 sims: {
143 sim: {
144 USD: { price: 500, plan: "1GB" },
145 CAD: { price: 600, plan: "1GB" }
146 },
147 esim: {
148 USD: { price: 300, plan: "500MB" },
149 CAD: { price: 400, plan: "500MB" }
150 }
151 },
152 keep_area_codes: ["556"],
153 keep_area_codes_in: {
154 account: "moveto",
155 site_id: "movetosite",
156 sip_peer_id: "movetopeer"
157 },
158 upstream_domain: "example.net",
159 approved_domains: {
160 "approved.example.com": nil,
161 "refer.example.com": "refer_to"
162 },
163 parented_domains: {
164 "parented.example.com" => {
165 customer_id: "1234",
166 plan_name: "test_usd"
167 }
168 },
169 bandwidth_site: "test_site",
170 bandwidth_peer: "test_peer",
171 keepgo: { api_key: "keepgokey", access_token: "keepgotoken" },
172 snikket_hosting_api: "snikket.example.com",
173 onboarding_domain: "onboarding.example.com",
174 adr: "A Mailing Address",
175 interac: "interac@example.com",
176 support_link: ->(*) { "https://support.com" },
177 bulk_order_tokens: {
178 sometoken: { customer_id: "bulkcustomer", peer_id: "bulkpeer" },
179 lowtoken: { customer_id: "customerid_low", peer_id: "lowpeer" }
180 },
181 public_onboarding_url: "xmpp:example.com?register"
182}.freeze
183
184def panic(e)
185 raise e
186end
187
188LOG = Class.new {
189 def child(*)
190 Minitest::Mock.new
191 end
192
193 def debug(*); end
194
195 def info(*); end
196
197 def error(*); end
198}.new.freeze
199
200def log
201 LOG
202end
203
204BLATHER = Class.new {
205 def <<(*); end
206}.new.freeze
207
208def execute_command(
209 iq=Blather::Stanza::Iq::Command.new.tap { |i| i.from = "test@example.com" },
210 blather: BLATHER,
211 &blk
212)
213 Command::Execution.new(
214 Minitest::Mock.new,
215 blather,
216 :to_s.to_proc,
217 iq
218 ).execute(&blk).sync
219end
220
221class NotLoaded < BasicObject
222 def inspect
223 "<NotLoaded #{@name}>"
224 end
225end
226
227class Matching
228 def initialize(&block)
229 @block = block
230 end
231
232 def ===(other)
233 @block.call(other)
234 end
235end
236
237class PromiseMock < Minitest::Mock
238 def then(succ=nil, _=nil)
239 if succ
240 succ.call(self)
241 else
242 yield self
243 end
244 end
245
246 def is_a?(_klass)
247 false
248 end
249end
250
251class FakeTelSelections
252 def initialize
253 @selections = {}
254 end
255
256 def set(jid, tel)
257 @selections[jid] = EMPromise.resolve(
258 TelSelections::HaveTel.new(tel.pending_value)
259 )
260 end
261
262 def delete(jid)
263 @selections.delete(jid)
264 EMPromise.resolve("OK")
265 end
266
267 def [](jid)
268 @selections.fetch(jid) do
269 TelSelections::ChooseTel.new(db: FakeDB.new, memcache: FakeMemcache.new)
270 end
271 end
272end
273
274class FakeRedis
275 def initialize(values={})
276 @values = values
277 end
278
279 def set(key, value)
280 @values[key] = value
281 EMPromise.resolve("OK")
282 end
283
284 def setex(key, _expiry, value)
285 set(key, value)
286 end
287
288 def del(key)
289 @values.delete(key)
290 EMPromise.resolve("OK")
291 end
292
293 def mget(*keys)
294 EMPromise.all(keys.map(&method(:get)))
295 end
296
297 def get(key)
298 EMPromise.resolve(@values[key])
299 end
300
301 def getbit(key, bit)
302 get(key).then { |v| v.to_i.to_s(2)[bit].to_i }
303 end
304
305 def bitfield(key, *ops)
306 get(key).then do |v|
307 bits = v.to_i.to_s(2)
308 ops.each_slice(3).map do |(op, encoding, offset)|
309 raise "unsupported bitfield op" unless op == "GET"
310 raise "unsupported bitfield op" unless encoding == "u1"
311
312 bits[offset].to_i
313 end
314 end
315 end
316
317 def hget(key, field)
318 EMPromise.resolve(@values.dig(key, field))
319 end
320
321 def hexists(key, field)
322 hget(key, field).nil? ? 0 : 1
323 end
324
325 def hincrby(key, field, incrby)
326 @values[key] ||= {}
327 @values[key][field] ||= 0
328 @values[key][field] += incrby
329 end
330
331 def sadd(key, member)
332 @values[key] ||= Set.new
333 @values[key] << member
334 end
335
336 def srem(key, member)
337 @values[key]&.delete(member)
338 end
339
340 def scard(key)
341 @values[key]&.size || 0
342 end
343
344 def smembers(key)
345 @values[key]&.to_a || []
346 end
347
348 def sismember(key, value)
349 smembers(key).include?(value)
350 end
351
352 def expire(_, _); end
353
354 def exists(*keys)
355 EMPromise.resolve(
356 @values.select { |k, _| keys.include? k }.size
357 )
358 end
359
360 def lindex(key, index)
361 get(key).then { |v| v&.fetch(index) }
362 end
363
364 def incr(key)
365 get(key).then { |v|
366 n = v ? v + 1 : 0
367 set(key, n).then { n }
368 }
369 end
370end
371
372class FakeDB
373 class MultiResult
374 def initialize(*args)
375 @results = args
376 end
377
378 def to_a
379 @results.shift
380 end
381 end
382
383 def initialize(items={})
384 @items = items
385 end
386
387 def query_defer(_, args)
388 EMPromise.resolve(@items.fetch(args, []).to_a)
389 end
390
391 def query_one(_, *args, field_names_as: :symbol, default: nil)
392 row = @items.fetch(args, []).to_a.first
393 row = row.transform_keys(&:to_sym) if row && field_names_as == :symbol
394 EMPromise.resolve(row || default)
395 end
396
397 def exec_defer(_, _)
398 EMPromise.resolve(nil)
399 end
400end
401
402class FakeMemcache
403 def initialize(data={})
404 @data = data
405 end
406
407 def set(k, v, _expires=nil)
408 raise "No spaces" if k =~ /\s/
409
410 @data[k] = v
411 end
412
413 def get(k)
414 yield @data[k]
415 end
416end
417
418class FakeLog
419 def initialize
420 @logs = []
421 end
422
423 def respond_to_missing?(*)
424 true
425 end
426
427 def method_missing(*args)
428 @logs << args
429 end
430end
431
432class FakeIBRRepo
433 def initialize(registrations={})
434 @registrations = registrations
435 end
436
437 def registered?(jid, from:)
438 @registrations.dig(jid.to_s, from.to_s) || false
439 end
440end
441
442module EventMachine
443 class << self
444 # Patch EM.add_timer to be instant in tests
445 alias old_add_timer add_timer
446 def add_timer(*args, &block)
447 args[0] = 0
448 old_add_timer(*args, &block)
449 end
450 end
451end
452
453module Minitest
454 class Test
455 def self.property(m, &block)
456 define_method("test_#{m}") do
457 property_of(&block).check { |args| send(m, *args) }
458 end
459 end
460
461 def self.em(m)
462 alias_method "raw_#{m}", m
463 define_method(m) do
464 EM.run do
465 Fiber.new {
466 begin
467 send("raw_#{m}")
468 ensure
469 EM.stop
470 end
471 }.resume
472 end
473 end
474 end
475 end
476end