1# frozen_string_literal: true
2
3require "test_helper"
4require_relative "../../sgx-bwmsgsv2"
5require "rantly/minitest_extensions"
6require_relative "generators/webhook"
7require_relative "generators/message"
8
9def panic(e)
10 $panic = e
11end
12
13MMS_PROXY = "https://proxy.test.example.com/"
14
15class WebhookPropertyTest < Minitest::Test
16 def setup
17 reset_stanzas!
18 reset_redis!
19 end
20
21 def test_single_recipient_message_delivered_sends_one_receipt
22 property_of {
23 Webhook
24 .new(REDIS)
25 .type { "message-delivered" }
26 .message { |registered, jid, dir, top_level_to|
27 Message
28 .new(REDIS)
29 .to { [top_level_to] }
30 .generate(registered, jid, dir)
31 }
32 .generate
33 }.check { |metadata, example|
34 result = invoke_webhook(example)
35 assert_equal 200, result[0]
36 assert_equal 1, written.length, "Should only send the delivery receipt"
37 receipt = written.shift
38 assert_equal(
39 receipt.to,
40 metadata["jid"],
41 "Should send receipt to customer's jid"
42 )
43 assert_equal(
44 receipt.from.to_s,
45 "#{example["to"]}@#{ARGV[0]}",
46 "Should send receipt from sender's Cheogram jid"
47 )
48 }
49 end
50 em :test_single_recipient_message_delivered_sends_one_receipt
51
52 def test_multi_recipient_outbound_sends_no_receipts
53 property_of {
54 Webhook
55 .new(REDIS)
56 .type { choose(*Webhook::OUTBOUND_TYPES) }
57 .message { |registered, jid, dir, top_level_to|
58 Message
59 .new(REDIS)
60 .to {
61 array(integer(2)) { nanpa_phone } +
62 [top_level_to] +
63 array(range(1, 3)) { nanpa_phone }
64 }
65 .generate(registered, jid, dir)
66 }
67 .generate
68 }.check { |metadata, example|
69 result = invoke_webhook(example)
70 assert_equal 200, result[0]
71 assert_equal 0, written.length, "Should not group chat receipts"
72 }
73 end
74 em :test_multi_recipient_outbound_sends_no_receipts
75
76 def test_single_recipient_message_failed_sends_one_error
77 property_of {
78 Webhook
79 .new(REDIS)
80 .type { "message-failed" }
81 .message { |registered, jid, dir, top_level_to|
82 Message
83 .new(REDIS)
84 .to { [top_level_to] }
85 .generate(registered, jid, dir)
86 }
87 .generate
88 }.check { |metadata, example|
89 result = invoke_webhook(example)
90 assert_equal 200, result[0]
91 assert_equal(
92 written.length,
93 1,
94 "Message failed should only send one notification"
95 )
96 assert_kind_of(
97 ::Blather::StanzaError,
98 written.shift,
99 "Should not notify message-failed"
100 )
101 }
102 end
103 em :test_single_recipient_message_failed_sends_one_error
104
105 def test_outbound_unregistered_returns_403
106 property_of {
107 Webhook
108 .new(REDIS)
109 .registered {
110 false
111 }
112 .type {
113 choose(*Webhook::OUTBOUND_TYPES)
114 }
115 .generate
116 }.check { |metadata, example|
117 result = invoke_webhook(example)
118 assert_equal [403, {}, "Customer not found\n"], result
119 assert_empty written
120 entries = REDIS.stream_entries("messages").sync
121 assert_empty entries
122 }
123 end
124 em :test_outbound_unregistered_returns_403
125
126 def test_unknown_outbound_returns_200
127 property_of {
128 Webhook
129 .new(REDIS)
130 .type { "unknown" }
131 .direction { "out" }
132 .generate
133 }.check { |metadata, example|
134 result = invoke_webhook(example)
135 assert_equal [200, {}, "OK"], result
136 assert_empty written
137 entries = REDIS.stream_entries("messages").sync
138 assert_empty entries
139 }
140 end
141 em :test_unknown_outbound_returns_200
142
143 def test_unknown_direction_returns_400_ok_except_when_message_failed
144 property_of {
145 Webhook
146 .new(REDIS)
147 .direction { "unknown" }
148 .type {
149 choose(*(Webhook::INBOUND_TYPES << Webhook::OUTBOUND_TYPES)
150 .reject { |ty|
151 ty == "message-failed"
152 }
153 )
154 }
155 .generate
156 }.check { |metadata, example|
157 result = invoke_webhook(example)
158 assert_equal [400, {}, "OK"], result
159 assert_empty written
160 entries = REDIS.stream_entries("messages").sync
161 assert_empty entries
162 }
163 end
164 em :test_unknown_direction_returns_400_ok_except_when_message_failed
165
166 def test_unknown_direction_returns_400_missing_params_when_message_failed
167 property_of {
168 Webhook
169 .new(REDIS)
170 .direction { "unknown" }
171 .type {
172 "message-failed"
173 }
174 .generate
175 }.check { |metadata, example|
176 result = invoke_webhook(example)
177 assert_equal [400, {}, "Missing params\n"], result
178 assert_empty written
179 entries = REDIS.stream_entries("messages").sync
180 assert_empty entries
181 }
182 end
183 em :test_unknown_direction_returns_400_missing_params_when_message_failed
184
185 def test_delivered_emits_correct_stream_event
186 property_of {
187 Webhook
188 .new(REDIS)
189 .type { "message-delivered" }
190 .generate
191 }.check { |metadata, example|
192 invoke_webhook(example)
193
194 entries = REDIS.stream_entries("messages").sync
195 assert_equal 1, entries.length
196
197 fields = entries.first[:fields]
198 expected_keys = %w[
199 event source timestamp stanza_id bandwidth_id
200 ].sort
201 assert_equal expected_keys, fields.keys.sort
202
203 assert_equal "delivered", fields["event"]
204 assert_equal "bwmsgsv2", fields["source"]
205
206 assert_equal metadata["stanza_id"], fields["stanza_id"]
207 assert_equal example["message"]["id"], fields["bandwidth_id"]
208 assert_equal example["message"]["time"], fields["timestamp"]
209 }
210 end
211 em :test_delivered_emits_correct_stream_event
212
213 def test_failed_emits_correct_stream_event
214 property_of {
215 Webhook
216 .new(REDIS)
217 .type { "message-failed" }
218 .generate
219 }.check { |metadata, example|
220 invoke_webhook(example)
221
222 entries = REDIS.stream_entries("messages").sync
223 assert_equal 1, entries.length
224
225 fields = entries.first[:fields]
226 expected_keys = %w[
227 event source timestamp stanza_id bandwidth_id
228 error_code error_description
229 ].sort
230 assert_equal expected_keys, fields.keys.sort
231
232 assert_equal "failed", fields["event"]
233 assert_equal "bwmsgsv2", fields["source"]
234
235 tag_parts = example["message"]["tag"].split(/ /, 2)
236 expected_stanza_id = WEBrick::HTTPUtils.unescape(tag_parts[0])
237 assert_equal expected_stanza_id, fields["stanza_id"]
238 assert_equal example["message"]["id"], fields["bandwidth_id"]
239 assert_equal example["message"]["time"], fields["timestamp"]
240 assert_equal example["message"]["errorCode"].to_s, fields["error_code"]
241 assert_equal example["message"]["description"].to_s, fields["error_description"]
242 }
243 end
244 em :test_failed_emits_correct_stream_event
245end