Debian Codegraph @

testing/integration/twilio/api_compliance_test.go

raw
1 package twilio_test
2
3 import (
4 "bytes"
5 "io"
6 "net/http"
7 "net/url"
8 "testing"
9 "testing/synctest"
10
11 "github.com/stretchr/testify/mock"
12 "github.com/stretchr/testify/require"
13
14 "github.com/nicholas-fedor/shoutrrr/pkg/services/sms/twilio"
15 )
16
17 const (
18 validTwilioURL = "twilio://ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:authToken@+15551234567/+15559876543"
19 twilioAPIURL = "https://api.twilio.com/2010-04-01/Accounts/ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Messages.json"
20 )
21
22 func TestAPIURLFormatCompliance(t *testing.T) {
23 t.Parallel()
24 synctest.Test(t, func(t *testing.T) {
25 mockClient := &MockHTTPClient{}
26 service := createTestService(t, validTwilioURL, mockClient)
27
28 mockClient.On("Do", mock.Anything).
29 Return(createMockResponse(http.StatusCreated, `{"sid": "SM123"}`), nil).
30 Once()
31
32 err := service.Send("Test message", nil)
33 require.NoError(t, err)
34
35 // Verify the request was made to the correct Twilio API endpoint
36 assertRequestMade(t, mockClient, twilioAPIURL)
37
38 mockClient.AssertExpectations(t)
39 })
40 }
41
42 func TestValidURLFormats(t *testing.T) {
43 t.Parallel()
44
45 tests := []struct {
46 name string
47 url string
48 shouldError bool
49 }{
50 {"valid standard URL", validTwilioURL, false},
51 {
52 "valid with messaging service SID",
53 "twilio://ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:authToken@MGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/+15559876543",
54 false,
55 },
56 {
57 "valid with multiple recipients",
58 "twilio://ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:authToken@+15551234567/+15559876543/+15551111111",
59 false,
60 },
61 {"missing account SID", "twilio://:authToken@+15551234567/+15559876543", true},
62 {
63 "missing auth token",
64 "twilio://ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:@+15551234567/+15559876543",
65 true,
66 },
67 {
68 "missing from number",
69 "twilio://ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:authToken@/+15559876543",
70 true,
71 },
72 {
73 "missing to number",
74 "twilio://ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:authToken@+15551234567/",
75 true,
76 },
77 {
78 "same to and from",
79 "twilio://ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:authToken@+15551234567/+15551234567",
80 true,
81 },
82 }
83
84 for _, tt := range tests {
85 t.Run(tt.name, func(t *testing.T) {
86 t.Parallel()
87 synctest.Test(t, func(t *testing.T) {
88 parsedURL, err := url.Parse(tt.url)
89 if err != nil {
90 if tt.shouldError {
91 return
92 }
93
94 t.Fatalf("Unexpected URL parse error: %v", err)
95 }
96
97 service := &twilio.Service{}
98 initErr := service.Initialize(parsedURL, &mockLogger{})
99
100 if tt.shouldError {
101 require.Error(t, initErr)
102 } else {
103 require.NoError(t, initErr)
104 }
105 })
106 })
107 }
108 }
109
110 func TestPayloadStructureCompliance(t *testing.T) {
111 t.Parallel()
112 synctest.Test(t, func(t *testing.T) {
113 mockClient := &MockHTTPClient{}
114 service := createTestService(t, validTwilioURL, mockClient)
115
116 mockClient.On("Do", mock.Anything).
117 Return(createMockResponse(http.StatusCreated, `{"sid": "SM123"}`), nil).
118 Once()
119
120 err := service.Send("Test message", nil)
121 require.NoError(t, err)
122
123 // Verify form-encoded body contains expected fields
124 assertRequestContains(t, mockClient, "To=%2B15559876543")
125 assertRequestContains(t, mockClient, "Body=Test+message")
126 assertRequestContains(t, mockClient, "From=%2B15551234567")
127
128 mockClient.AssertExpectations(t)
129 })
130 }
131
132 func TestBasicAuthCompliance(t *testing.T) {
133 t.Parallel()
134 synctest.Test(t, func(t *testing.T) {
135 mockClient := &MockHTTPClient{}
136 service := createTestService(t, validTwilioURL, mockClient)
137
138 mockClient.On("Do", mock.Anything).
139 Return(createMockResponse(http.StatusCreated, `{"sid": "SM123"}`), nil).
140 Once()
141
142 err := service.Send("Test message", nil)
143 require.NoError(t, err)
144
145 // Verify Basic Auth is set correctly
146 assertRequestMatches(t, mockClient, func(req *http.Request) bool {
147 username, password, ok := req.BasicAuth()
148
149 return ok && username == "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" && password == "authToken"
150 }, "Basic Auth credentials")
151
152 mockClient.AssertExpectations(t)
153 })
154 }
155
156 func TestContentTypeCompliance(t *testing.T) {
157 t.Parallel()
158 synctest.Test(t, func(t *testing.T) {
159 mockClient := &MockHTTPClient{}
160 service := createTestService(t, validTwilioURL, mockClient)
161
162 mockClient.On("Do", mock.Anything).
163 Return(createMockResponse(http.StatusCreated, `{"sid": "SM123"}`), nil).
164 Once()
165
166 err := service.Send("Test message", nil)
167 require.NoError(t, err)
168
169 // Verify Content-Type header is set to form-urlencoded
170 assertRequestMatches(t, mockClient, func(req *http.Request) bool {
171 return req.Header.Get("Content-Type") == "application/x-www-form-urlencoded"
172 }, "Content-Type header")
173
174 mockClient.AssertExpectations(t)
175 })
176 }
177
178 func TestHTTPMethodCompliance(t *testing.T) {
179 t.Parallel()
180 synctest.Test(t, func(t *testing.T) {
181 mockClient := &MockHTTPClient{}
182 service := createTestService(t, validTwilioURL, mockClient)
183
184 mockClient.On("Do", mock.Anything).
185 Return(createMockResponse(http.StatusCreated, `{"sid": "SM123"}`), nil).
186 Once()
187
188 err := service.Send("Test message", nil)
189 require.NoError(t, err)
190
191 // Verify POST method is used
192 assertRequestMatches(t, mockClient, func(req *http.Request) bool {
193 return req.Method == http.MethodPost
194 }, "HTTP POST method")
195
196 mockClient.AssertExpectations(t)
197 })
198 }
199
200 func TestHTTPSRequirementCompliance(t *testing.T) {
201 t.Parallel()
202 synctest.Test(t, func(t *testing.T) {
203 mockClient := &MockHTTPClient{}
204 service := createTestService(t, validTwilioURL, mockClient)
205
206 mockClient.On("Do", mock.Anything).
207 Return(createMockResponse(http.StatusCreated, `{"sid": "SM123"}`), nil).
208 Once()
209
210 err := service.Send("Test message", nil)
211 require.NoError(t, err)
212
213 // Verify HTTPS scheme is used for API calls
214 assertRequestMatches(t, mockClient, func(req *http.Request) bool {
215 return req.URL.Scheme == "https"
216 }, "HTTPS scheme")
217
218 mockClient.AssertExpectations(t)
219 })
220 }
221
222 func TestMessagingServiceSIDCompliance(t *testing.T) {
223 t.Parallel()
224 synctest.Test(t, func(t *testing.T) {
225 mockClient := &MockHTTPClient{}
226 service := createTestService(
227 t,
228 "twilio://ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:authToken@MGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/+15559876543",
229 mockClient,
230 )
231
232 mockClient.On("Do", mock.Anything).
233 Return(createMockResponse(http.StatusCreated, `{"sid": "SM123"}`), nil).
234 Once()
235
236 err := service.Send("Test message", nil)
237 require.NoError(t, err)
238
239 // Verify MessagingServiceSid is used instead of From
240 assertRequestContains(
241 t,
242 mockClient,
243 "MessagingServiceSid=MGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
244 )
245
246 // Should NOT contain a From field
247 assertRequestMatches(t, mockClient, func(req *http.Request) bool {
248 body, readErr := io.ReadAll(req.Body)
249 if readErr != nil {
250 return false
251 }
252
253 req.Body = io.NopCloser(bytes.NewReader(body))
254
255 return !bytes.Contains(body, []byte("From="))
256 }, "no From field when using MessagingServiceSid")
257
258 mockClient.AssertExpectations(t)
259 })
260 }