1# frozen_string_literal: true
2
3require "simplecov"
4SimpleCov.start do
5 add_filter "/test/"
6 enable_coverage :branch
7 command_name ENV.fetch("COVERAGE_NAME", "tests")
8end
9
10require "minitest/autorun"
11require "webmock/minitest"
12require "fakefs/safe"
13
14MMS_PROXY = "https://proxy.test.example.com/"
15BW_MESSAGES_URL = "https://messaging.bandwidth.com/api/v2/users/account/messages"
16
17_saved_argv = ARGV.dup
18
19ARGV[0] = "component"
20ARGV[6] = MMS_PROXY
21
22require_relative "../sgx-bwmsgsv2"
23ARGV.replace(_saved_argv)
24
25LOG.level = :fatal
26
27def SGXbwmsgsv2.write_to_stream(s)
28 @written ||= []
29 @written << s
30end
31
32def reset_stanzas!
33 SGXbwmsgsv2.instance_variable_set(:@written, [])
34end
35
36def reset_redis!(tn: "+15550000000", jid: "test@example.com")
37 REDIS.reset!
38 REDIS.set("catapult_jid-", "HERE")
39 REDIS.set("catapult_jid-#{tn}", jid)
40 REDIS.set("catapult_cred-#{jid}", [
41 'account', 'user', 'password', tn
42 ])
43end
44
45def written
46 SGXbwmsgsv2.instance_variable_get(:@written)
47end
48
49def invoke_webhook(payload, extra_env: {})
50 with_stubs([
51 [
52 SGXbwmsgsv2,
53 :write,
54 ->(data) { SGXbwmsgsv2.write_to_stream(data) }
55 ]
56 ]) do
57 handler = WebhookHandler.new
58 env = {
59 "REQUEST_URI" => "/",
60 "REQUEST_METHOD" => "POST",
61 "params" => { "_json" => [payload] }
62 }.merge(extra_env)
63 handler.instance_variable_set(:@env, env)
64 def handler.params
65 @env["params"]
66 end
67 EMPromise.resolve(nil).then {
68 handler.response(env)
69 }.sync
70 end
71end
72
73def process_stanza(s)
74 SGXbwmsgsv2.send(:client).receive_data(s)
75 raise $panic if $panic
76end
77
78def xmpp_error_name(error)
79 error.find_first(
80 "child::*[name()!='text']",
81 Blather::StanzaError::STANZA_ERR_NS
82 ).element_name
83end
84
85def xmpp_error_text(error)
86 error.find_first("ns:text", ns: Blather::StanzaError::STANZA_ERR_NS)&.text
87end
88
89def with_mms_env(path: "/mms", url: "https://mms.test.example.com")
90 old_path = ENV["MMS_PATH"]
91 old_url = ENV["MMS_URL"]
92 ENV["MMS_PATH"] = path
93 ENV["MMS_URL"] = url
94 yield
95ensure
96 ENV["MMS_PATH"] = old_path
97 ENV["MMS_URL"] = old_url
98end
99
100
101begin
102 require "pry-byebug"
103
104 module Minitest
105 class Test
106 alias old_capture_exceptions capture_exceptions
107 def capture_exceptions
108 old_capture_exceptions do
109 yield
110 rescue Minitest::Skip => e
111 failures << e
112 end
113 end
114 end
115 end
116rescue LoadError, NameError
117 # Just helpers for dev, no big deal if missing
118 nil
119end
120
121# @param body [String]
122# @param dests [Array<String>]
123# @param from [String]
124# @return [Blather::Stanza::Message]
125def build_group_mms(body, dests, from: "test@example.com", id: nil)
126 m = Blather::Stanza::Message.new(ARGV[0], body)
127 m.from = from
128 m.id = id if id
129 addrs = Nokogiri::XML::Node.new('addresses', m.document)
130 addrs['xmlns'] = 'http://jabber.org/protocol/address'
131 dests.each do |dest|
132 addr = Nokogiri::XML::Node.new('address', m.document)
133 addr['type'] = 'to'
134 addr['uri'] = "sms:#{dest}"
135 addrs.add_child(addr)
136 end
137 m.add_child(addrs)
138 m
139end
140
141# @param body [String]
142# @param dests [Array<String>]
143# @param from [String]
144# @param id [String, nil]
145# @return [Blather::Stanza::Message]
146def build_outbound_message(body, dests, from: "test@example.com", id: nil)
147 if dests.length == 1 || dests.is_a?(String)
148 dests = [dests] if dests.is_a?(String)
149
150 m = Blather::Stanza::Message.new("#{dests.first}@#{ARGV[0]}", body)
151 m.from = from
152 m.id = id if id
153 m
154 else
155 build_group_mms(body, dests, from: from, id: id)
156 end
157end
158
159
160$VERBOSE = nil
161
162class FakeRedis
163 def initialize(values={})
164 @values = values
165 end
166
167 def reset!(values={})
168 @values = values
169 end
170
171 def set(key, value, *)
172 @values[key] = value
173 EMPromise.resolve("OK")
174 end
175
176 def setex(key, _expiry, value)
177 set(key, value)
178 end
179
180 def del(*keys)
181 keys.each { |key| @values.delete(key) }
182 end
183
184 def mget(*keys)
185 EMPromise.all(keys.map(&method(:get)))
186 end
187
188 def get(key)
189 EMPromise.resolve(@values[key])
190 end
191
192 def getbit(key, bit)
193 get(key).then { |v| v.to_i.to_s(2)[bit].to_i }
194 end
195
196 def bitfield(key, *ops)
197 get(key).then do |v|
198 bits = v.to_i.to_s(2)
199 ops.each_slice(3).map do |(op, encoding, offset)|
200 raise "unsupported bitfield op" unless op == "GET"
201 raise "unsupported bitfield op" unless encoding == "u1"
202
203 bits[offset].to_i
204 end
205 end
206 end
207
208 def hget(key, field)
209 @values.dig(key, field)
210 end
211
212 def hincrby(key, field, incrby)
213 @values[key] ||= {}
214 @values[key][field] ||= 0
215 @values[key][field] += incrby
216 end
217
218 def sadd(key, member)
219 @values[key] ||= Set.new
220 @values[key] << member
221 end
222
223 def srem(key, member)
224 @values[key].delete(member)
225 end
226
227 def scard(key)
228 @values[key]&.size || 0
229 end
230
231 def expire(_, _); end
232
233 def exists(*keys)
234 EMPromise.resolve(
235 @values.select { |k, _| keys.include? k }.size.to_s
236 )
237 end
238
239 def lindex(key, index)
240 get(key).then { |v| v&.fetch(index) }
241 end
242
243 def lrange(key, sindex, eindex)
244 get(key).then { |v| v ? v[sindex..eindex] : [] }
245 end
246
247 def rpush(key, *values)
248 @values[key] ||= []
249 values.each { |v| @values[key].push(v) }
250 end
251
252 def multi
253 end
254
255 def exec
256 end
257
258 def discard
259 end
260
261 def xadd(stream, id, *args)
262 @values[stream] ||= []
263 entry_id = id == "*" ? "#{Time.now.to_i}-0" : id
264 fields = Hash[*args]
265 @values[stream] << { id: entry_id, fields: fields }
266 EMPromise.resolve(entry_id)
267 end
268
269 def stream_entries(stream)
270 EMPromise.resolve(@values[stream] || [])
271 end
272end
273
274REDIS = FakeRedis.new
275
276module Minitest
277 class Test
278 def with_stubs(stubs, &block)
279 if stubs.empty?
280 block.call
281 else
282 obj, method, value = stubs.first
283 obj.stub(method, value) do
284 with_stubs(stubs[1..], &block)
285 end
286 end
287 end
288
289 def self.em(m)
290 alias_method "raw_#{m}", m
291 define_method(m) do
292 $panic = nil
293 e = nil
294 FakeFS do
295 FakeFS::FileSystem.clear
296 FileUtils.mkdir_p("/mms")
297 EM.run do
298 Fiber.new {
299 with_mms_env do
300 ARGV[0] = "component"
301 ARGV[6] = MMS_PROXY
302 begin
303 send("raw_#{m}")
304 rescue
305 e = $!
306 ensure
307 EM.stop
308 end
309 end # with_mms_env do
310 }.resume
311 end # EM.run do
312 end # FakeFs do
313 if e
314 LOG.error("Error in test: #{m}", e)
315 raise e
316 end
317 raise e if e
318 end
319 end
320 end
321end