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 keep_area_codes: ["556"],
143 keep_area_codes_in: {
144 account: "moveto",
145 site_id: "movetosite",
146 sip_peer_id: "movetopeer"
147 },
148 upstream_domain: "example.net",
149 approved_domains: {
150 "approved.example.com": nil,
151 "refer.example.com": "refer_to"
152 },
153 parented_domains: {
154 "parented.example.com" => {
155 customer_id: "1234",
156 plan_name: "test_usd"
157 }
158 },
159 bandwidth_site: "test_site",
160 bandwidth_peer: "test_peer",
161 keepgo: { api_key: "keepgokey", access_token: "keepgotoken" },
162 snikket_hosting_api: "snikket.example.com",
163 onboarding_domain: "onboarding.example.com",
164 adr: "A Mailing Address",
165 interac: "interac@example.com",
166 support_link: ->(*) { "https://support.com" }
167}.freeze
168
169def panic(e)
170 raise e
171end
172
173LOG = Class.new {
174 def child(*)
175 Minitest::Mock.new
176 end
177
178 def debug(*); end
179
180 def info(*); end
181
182 def error(*); end
183}.new.freeze
184
185def log
186 LOG
187end
188
189BLATHER = Class.new {
190 def <<(*); end
191}.new.freeze
192
193def execute_command(
194 iq=Blather::Stanza::Iq::Command.new.tap { |i| i.from = "test@example.com" },
195 blather: BLATHER,
196 &blk
197)
198 Command::Execution.new(
199 Minitest::Mock.new,
200 blather,
201 :to_s.to_proc,
202 iq
203 ).execute(&blk).sync
204end
205
206class NotLoaded < BasicObject
207 def inspect
208 "<NotLoaded #{@name}>"
209 end
210end
211
212class Matching
213 def initialize(&block)
214 @block = block
215 end
216
217 def ===(other)
218 @block.call(other)
219 end
220end
221
222class PromiseMock < Minitest::Mock
223 def then(succ=nil, _=nil)
224 if succ
225 succ.call(self)
226 else
227 yield self
228 end
229 end
230
231 def is_a?(_klass)
232 false
233 end
234end
235
236class FakeTelSelections
237 def initialize
238 @selections = {}
239 end
240
241 def set(jid, tel)
242 @selections[jid] = EMPromise.resolve(
243 TelSelections::HaveTel.new(tel.pending_value)
244 )
245 end
246
247 def delete(jid)
248 @selections.delete(jid)
249 EMPromise.resolve("OK")
250 end
251
252 def [](jid)
253 @selections.fetch(jid) do
254 TelSelections::ChooseTel.new(db: FakeDB.new, memcache: FakeMemcache.new)
255 end
256 end
257end
258
259class FakeRedis
260 def initialize(values={})
261 @values = values
262 end
263
264 def set(key, value)
265 @values[key] = value
266 EMPromise.resolve("OK")
267 end
268
269 def setex(key, _expiry, value)
270 set(key, value)
271 end
272
273 def del(key)
274 @values.delete(key)
275 EMPromise.resolve("OK")
276 end
277
278 def mget(*keys)
279 EMPromise.all(keys.map(&method(:get)))
280 end
281
282 def get(key)
283 EMPromise.resolve(@values[key])
284 end
285
286 def getbit(key, bit)
287 get(key).then { |v| v.to_i.to_s(2)[bit].to_i }
288 end
289
290 def bitfield(key, *ops)
291 get(key).then do |v|
292 bits = v.to_i.to_s(2)
293 ops.each_slice(3).map do |(op, encoding, offset)|
294 raise "unsupported bitfield op" unless op == "GET"
295 raise "unsupported bitfield op" unless encoding == "u1"
296
297 bits[offset].to_i
298 end
299 end
300 end
301
302 def hget(key, field)
303 @values.dig(key, field)
304 end
305
306 def hexists(key, field)
307 hget(key, field).nil? ? 0 : 1
308 end
309
310 def hincrby(key, field, incrby)
311 @values[key] ||= {}
312 @values[key][field] ||= 0
313 @values[key][field] += incrby
314 end
315
316 def sadd(key, member)
317 @values[key] ||= Set.new
318 @values[key] << member
319 end
320
321 def srem(key, member)
322 @values[key]&.delete(member)
323 end
324
325 def scard(key)
326 @values[key]&.size || 0
327 end
328
329 def smembers(key)
330 @values[key]&.to_a || []
331 end
332
333 def sismember(key, value)
334 smembers(key).include?(value)
335 end
336
337 def expire(_, _); end
338
339 def exists(*keys)
340 EMPromise.resolve(
341 @values.select { |k, _| keys.include? k }.size
342 )
343 end
344
345 def lindex(key, index)
346 get(key).then { |v| v&.fetch(index) }
347 end
348
349 def incr(key)
350 get(key).then { |v|
351 n = v ? v + 1 : 0
352 set(key, n).then { n }
353 }
354 end
355end
356
357class FakeDB
358 class MultiResult
359 def initialize(*args)
360 @results = args
361 end
362
363 def to_a
364 @results.shift
365 end
366 end
367
368 def initialize(items={})
369 @items = items
370 end
371
372 def query_defer(_, args)
373 EMPromise.resolve(@items.fetch(args, []).to_a)
374 end
375
376 def query_one(_, *args, field_names_as: :symbol, default: nil)
377 row = @items.fetch(args, []).to_a.first
378 row = row.transform_keys(&:to_sym) if row && field_names_as == :symbol
379 EMPromise.resolve(row || default)
380 end
381
382 def exec_defer(_, _)
383 EMPromise.resolve(nil)
384 end
385end
386
387class FakeMemcache
388 def initialize(data={})
389 @data = data
390 end
391
392 def set(k, v, _expires=nil)
393 raise "No spaces" if k =~ /\s/
394
395 @data[k] = v
396 end
397
398 def get(k)
399 yield @data[k]
400 end
401end
402
403class FakeLog
404 def initialize
405 @logs = []
406 end
407
408 def respond_to_missing?(*)
409 true
410 end
411
412 def method_missing(*args)
413 @logs << args
414 end
415end
416
417class FakeIBRRepo
418 def initialize(registrations={})
419 @registrations = registrations
420 end
421
422 def registered?(jid, from:)
423 @registrations.dig(jid.to_s, from.to_s) || false
424 end
425end
426
427module EventMachine
428 class << self
429 # Patch EM.add_timer to be instant in tests
430 alias old_add_timer add_timer
431 def add_timer(*args, &block)
432 args[0] = 0
433 old_add_timer(*args, &block)
434 end
435 end
436end
437
438module Minitest
439 class Test
440 def self.property(m, &block)
441 define_method("test_#{m}") do
442 property_of(&block).check { |args| send(m, *args) }
443 end
444 end
445
446 def self.em(m)
447 alias_method "raw_#{m}", m
448 define_method(m) do
449 EM.run do
450 Fiber.new {
451 begin
452 send("raw_#{m}")
453 ensure
454 EM.stop
455 end
456 }.resume
457 end
458 end
459 end
460 end
461end