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 credit_card_url: ->(*) { "http://creditcard.example.com?" },
101 electrum_notify_url: ->(*) { "http://notify.example.com" },
102 keep_area_codes: ["556"],
103 keep_area_codes_in: {
104 account: "moveto",
105 site_id: "movetosite",
106 sip_peer_id: "movetopeer"
107 },
108 upstream_domain: "example.net",
109 approved_domains: {
110 "approved.example.com": nil,
111 "refer.example.com": "refer_to"
112 },
113 bandwidth_site: "test_site",
114 bandwidth_peer: "test_peer",
115 keepgo: { api_key: "keepgokey", access_token: "keepgotoken" },
116 snikket_hosting_api: "snikket.example.com",
117 onboarding_domain: "onboarding.example.com",
118 adr: "A Mailing Address",
119 interac: "interac@example.com",
120 support_link: ->(*) { "https://support.com" }
121}.freeze
122
123def panic(e)
124 raise e
125end
126
127LOG = Class.new {
128 def child(*)
129 Minitest::Mock.new
130 end
131
132 def info(*); end
133
134 def error(*); end
135}.new.freeze
136
137def log
138 LOG
139end
140
141BLATHER = Class.new {
142 def <<(*); end
143}.new.freeze
144
145def execute_command(
146 iq=Blather::Stanza::Iq::Command.new.tap { |i| i.from = "test@example.com" },
147 blather: BLATHER,
148 &blk
149)
150 Command::Execution.new(
151 Minitest::Mock.new,
152 blather,
153 :to_s.to_proc,
154 iq
155 ).execute(&blk).sync
156end
157
158class Matching
159 def initialize(&block)
160 @block = block
161 end
162
163 def ===(other)
164 @block.call(other)
165 end
166end
167
168class PromiseMock < Minitest::Mock
169 def then(succ=nil, _=nil)
170 if succ
171 succ.call(self)
172 else
173 yield self
174 end
175 end
176
177 def is_a?(_klass)
178 false
179 end
180end
181
182class FakeTelSelections
183 def initialize
184 @selections = {}
185 end
186
187 def set(jid, tel)
188 @selections[jid] = EMPromise.resolve(TelSelections::HaveTel.new(tel))
189 end
190
191 def delete(jid)
192 @selections.delete(jid)
193 EMPromise.resolve("OK")
194 end
195
196 def [](jid)
197 @selections.fetch(jid) do
198 TelSelections::ChooseTel.new
199 end
200 end
201end
202
203class FakeRedis
204 def initialize(values={})
205 @values = values
206 end
207
208 def set(key, value)
209 @values[key] = value
210 EMPromise.resolve("OK")
211 end
212
213 def setex(key, _expiry, value)
214 set(key, value)
215 end
216
217 def mget(*keys)
218 EMPromise.all(keys.map(&method(:get)))
219 end
220
221 def get(key)
222 EMPromise.resolve(@values[key])
223 end
224
225 def getbit(key, bit)
226 get(key).then { |v| v.to_i.to_s(2)[bit].to_i }
227 end
228
229 def bitfield(key, *ops)
230 get(key).then do |v|
231 bits = v.to_i.to_s(2)
232 ops.each_slice(3).map do |(op, encoding, offset)|
233 raise "unsupported bitfield op" unless op == "GET"
234 raise "unsupported bitfield op" unless encoding == "u1"
235
236 bits[offset].to_i
237 end
238 end
239 end
240
241 def hget(key, field)
242 @values.dig(key, field)
243 end
244
245 def hincrby(key, field, incrby)
246 @values[key] ||= {}
247 @values[key][field] ||= 0
248 @values[key][field] += incrby
249 end
250
251 def sadd(key, member)
252 @values[key] ||= Set.new
253 @values[key] << member
254 end
255
256 def srem(key, member)
257 @values[key].delete(member)
258 end
259
260 def scard(key)
261 @values[key]&.size || 0
262 end
263
264 def smembers(key)
265 @values[key]&.to_a || []
266 end
267
268 def expire(_, _); end
269
270 def exists(*keys)
271 EMPromise.resolve(
272 @values.select { |k, _| keys.include? k }.size
273 )
274 end
275
276 def lindex(key, index)
277 get(key).then { |v| v&.fetch(index) }
278 end
279
280 def incr(key)
281 get(key).then { |v|
282 n = v ? v + 1 : 0
283 set(key, n).then { n }
284 }
285 end
286end
287
288class FakeDB
289 class MultiResult
290 def initialize(*args)
291 @results = args
292 end
293
294 def to_a
295 @results.shift
296 end
297 end
298
299 def initialize(items={})
300 @items = items
301 end
302
303 def query_defer(_, args)
304 EMPromise.resolve(@items.fetch(args, []).to_a)
305 end
306
307 def query_one(_, *args, field_names_as: :symbol, default: nil)
308 row = @items.fetch(args, []).to_a.first
309 row = row.transform_keys(&:to_sym) if row && field_names_as == :symbol
310 EMPromise.resolve(row || default)
311 end
312
313 def exec_defer(_, _)
314 EMPromise.resolve(nil)
315 end
316end
317
318class FakeLog
319 def initialize
320 @logs = []
321 end
322
323 def respond_to_missing?(*)
324 true
325 end
326
327 def method_missing(*args)
328 @logs << args
329 end
330end
331
332class FakeIBRRepo
333 def initialize(registrations={})
334 @registrations = registrations
335 end
336
337 def registered?(jid, from:)
338 @registrations.dig(jid.to_s, from.to_s) || false
339 end
340end
341
342module EventMachine
343 class << self
344 # Patch EM.add_timer to be instant in tests
345 alias old_add_timer add_timer
346 def add_timer(*args, &block)
347 args[0] = 0
348 old_add_timer(*args, &block)
349 end
350 end
351end
352
353module Minitest
354 class Test
355 def self.property(m, &block)
356 define_method("test_#{m}") do
357 property_of(&block).check { |args| send(m, *args) }
358 end
359 end
360
361 def self.em(m)
362 alias_method "raw_#{m}", m
363 define_method(m) do
364 EM.run do
365 Fiber.new {
366 begin
367 send("raw_#{m}")
368 ensure
369 EM.stop
370 end
371 }.resume
372 end
373 end
374 end
375 end
376end