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