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