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 plan = CustomerPlan.for(
51 customer_id,
52 plan_name: plan_name,
53 expires_at: expires_at,
54 auto_top_up_amount: auto_top_up_amount
55 )
56 Customer.new(customer_id, jid, plan: plan, **kwargs)
57end
58
59CONFIG = {
60 sgx: "sgx",
61 component: {
62 jid: "component"
63 },
64 creds: {
65 account: "test_bw_account",
66 username: "test_bw_user",
67 password: "test_bw_password"
68 },
69 notify_from: "notify_from@example.org",
70 activation_amount: 1,
71 activation_amount_accept: 1,
72 plans: [
73 {
74 name: "test_usd",
75 currency: :USD,
76 monthly_price: 10000,
77 messages: :unlimited,
78 minutes: { included: 10440, price: 87 }
79 },
80 {
81 name: "test_bad_currency",
82 currency: :BAD
83 },
84 {
85 name: "test_cad",
86 currency: :CAD,
87 monthly_price: 10000
88 }
89 ],
90 braintree: {
91 merchant_accounts: {
92 USD: "merchant_usd"
93 }
94 },
95 sip: {
96 realm: "sip.example.com",
97 app: "sipappid"
98 },
99 credit_card_url: ->(*) { "http://creditcard.example.com" },
100 electrum_notify_url: ->(*) { "http://notify.example.com" },
101 keep_area_codes: ["556"],
102 keep_area_codes_in: {
103 account: "moveto",
104 site_id: "movetosite",
105 sip_peer_id: "movetopeer"
106 },
107 upstream_domain: "example.net",
108 approved_domains: {
109 "approved.example.com": nil,
110 "refer.example.com": "refer_to"
111 }
112}.freeze
113
114def panic(e)
115 raise e
116end
117
118LOG = Class.new {
119 def child(*)
120 Minitest::Mock.new
121 end
122}.new.freeze
123
124BLATHER = Class.new {
125 def <<(*); end
126}.new.freeze
127
128def execute_command(
129 iq=Blather::Stanza::Iq::Command.new.tap { |i| i.from = "test@example.com" },
130 blather: BLATHER,
131 &blk
132)
133 Command::Execution.new(
134 Minitest::Mock.new,
135 blather,
136 :to_s.to_proc,
137 iq
138 ).execute(&blk).sync
139end
140
141class Matching
142 def initialize(&block)
143 @block = block
144 end
145
146 def ===(other)
147 @block.call(other)
148 end
149end
150
151class PromiseMock < Minitest::Mock
152 def then(succ=nil, _=nil)
153 if succ
154 succ.call(self)
155 else
156 yield self
157 end
158 end
159end
160
161class FakeTelSelections
162 def initialize
163 @selections = {}
164 end
165
166 def set(jid, tel)
167 @selections[jid] = EMPromise.resolve(TelSelections::HaveTel.new(tel))
168 end
169
170 def delete(jid)
171 @selections.delete(jid)
172 EMPromise.resolve("OK")
173 end
174
175 def [](jid)
176 @selections.fetch(jid) do
177 TelSelections::ChooseTel.new
178 end
179 end
180end
181
182class FakeRedis
183 def initialize(values={})
184 @values = values
185 end
186
187 def set(key, value)
188 @values[key] = value
189 EMPromise.resolve("OK")
190 end
191
192 def setex(key, _expiry, value)
193 set(key, value)
194 end
195
196 def mget(*keys)
197 EMPromise.all(keys.map(&method(:get)))
198 end
199
200 def get(key)
201 EMPromise.resolve(@values[key])
202 end
203
204 def getbit(key, bit)
205 get(key).then { |v| v.to_i.to_s(2)[bit].to_i }
206 end
207
208 def bitfield(key, *ops)
209 get(key).then do |v|
210 bits = v.to_i.to_s(2)
211 ops.each_slice(3).map do |(op, encoding, offset)|
212 raise "unsupported bitfield op" unless op == "GET"
213 raise "unsupported bitfield op" unless encoding == "u1"
214
215 bits[offset].to_i
216 end
217 end
218 end
219
220 def hget(key, field)
221 @values.dig(key, field)
222 end
223
224 def hincrby(key, field, incrby)
225 @values[key] ||= {}
226 @values[key][field] ||= 0
227 @values[key][field] += incrby
228 end
229
230 def sadd(key, member)
231 @values[key] ||= Set.new
232 @values[key] << member
233 end
234
235 def srem(key, member)
236 @values[key].delete(member)
237 end
238
239 def scard(key)
240 @values[key]&.size || 0
241 end
242
243 def expire(_, _); end
244
245 def exists(*keys)
246 EMPromise.resolve(
247 @values.select { |k, _| keys.include? k }.size
248 )
249 end
250
251 def lindex(key, index)
252 get(key).then { |v| v&.fetch(index) }
253 end
254end
255
256class FakeDB
257 class MultiResult
258 def initialize(*args)
259 @results = args
260 end
261
262 def to_a
263 @results.shift
264 end
265 end
266
267 def initialize(items={})
268 @items = items
269 end
270
271 def query_defer(_, args)
272 EMPromise.resolve(@items.fetch(args, []).to_a)
273 end
274
275 def query_one(_, *args, field_names_as: :symbol, default: nil)
276 row = @items.fetch(args, []).to_a.first
277 row = row.transform_keys(&:to_sym) if row && field_names_as == :symbol
278 EMPromise.resolve(row || default)
279 end
280end
281
282class FakeLog
283 def initialize
284 @logs = []
285 end
286
287 def respond_to_missing?(*)
288 true
289 end
290
291 def method_missing(*args)
292 @logs << args
293 end
294end
295
296class FakeIBRRepo
297 def initialize(registrations={})
298 @registrations = registrations
299 end
300
301 def registered?(jid, from:)
302 @registrations.dig(jid.to_s, from.to_s) || false
303 end
304end
305
306module EventMachine
307 class << self
308 # Patch EM.add_timer to be instant in tests
309 alias old_add_timer add_timer
310 def add_timer(*args, &block)
311 args[0] = 0
312 old_add_timer(*args, &block)
313 end
314 end
315end
316
317module Minitest
318 class Test
319 def self.property(m, &block)
320 define_method("test_#{m}") do
321 property_of(&block).check { |args| send(m, *args) }
322 end
323 end
324
325 def self.em(m)
326 alias_method "raw_#{m}", m
327 define_method(m) do
328 EM.run do
329 Fiber.new {
330 begin
331 send("raw_#{m}")
332 ensure
333 EM.stop
334 end
335 }.resume
336 end
337 end
338 end
339 end
340end