Debian Codegraph @

testing/integration/zulip/errors_test.go

raw
1 package zulip_test
2
3 import (
4 "errors"
5 "net/http"
6 "testing"
7 "testing/synctest"
8
9 "github.com/stretchr/testify/assert"
10 "github.com/stretchr/testify/mock"
11 "github.com/stretchr/testify/require"
12
13 "github.com/nicholas-fedor/shoutrrr/pkg/services/chat/zulip"
14 "github.com/nicholas-fedor/shoutrrr/pkg/services/chat/zulip/mocks"
15 )
16
17 func TestServiceSendWithHTTPError(t *testing.T) {
18 t.Parallel()
19 synctest.Test(t, func(t *testing.T) {
20 tests := []struct {
21 name string
22 statusCode int
23 body string
24 }{
25 {
26 name: "bad request",
27 statusCode: http.StatusBadRequest,
28 body: `{"result": "error", "msg": "Invalid request"}`,
29 },
30 {
31 name: "unauthorized",
32 statusCode: http.StatusUnauthorized,
33 body: `{"result": "error", "msg": "Invalid API key"}`,
34 },
35 {
36 name: "forbidden",
37 statusCode: http.StatusForbidden,
38 body: `{"result": "error", "msg": "Access denied"}`,
39 },
40 {
41 name: "not found",
42 statusCode: http.StatusNotFound,
43 body: `{"result": "error", "msg": "Not found"}`,
44 },
45 {
46 name: "server error",
47 statusCode: http.StatusInternalServerError,
48 body: `{"result": "error", "msg": "Server error"}`,
49 },
50 {
51 name: "service unavailable",
52 statusCode: http.StatusServiceUnavailable,
53 body: `{"result": "error", "msg": "Service unavailable"}`,
54 },
55 }
56
57 for _, tt := range tests {
58 mockClient := mocks.NewMockHTTPClient(t)
59 service := createTestService(
60 t,
61 "zulip://[email protected]:[email protected]?stream=general",
62 mockClient,
63 )
64
65 // each fresh service triggers its own register fetch first
66 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
67 Return(createMockResponse(http.StatusOK, `{"result": "success"}`), nil).
68 Once()
69
70 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
71 Return(createMockResponse(tt.statusCode, tt.body), nil).
72 Once()
73
74 err := service.Send("Test message", nil)
75
76 require.Error(t, err, "Expected error for status %d", tt.statusCode)
77 require.ErrorIs(t, err, zulip.ErrResponseStatusFailure)
78
79 mockClient.AssertExpectations(t)
80 }
81 })
82 }
83
84 func TestServiceSendWithNetworkError(t *testing.T) {
85 t.Parallel()
86 synctest.Test(t, func(t *testing.T) {
87 mockClient := mocks.NewMockHTTPClient(t)
88 service := createTestService(
89 t,
90 "zulip://[email protected]:[email protected]?stream=general",
91 mockClient,
92 )
93
94 // register first
95 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
96 Return(createMockResponse(http.StatusOK, `{"result": "success"}`), nil).
97 Once()
98
99 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
100 Return(nil, errors.New("connection refused")).
101 Once()
102
103 err := service.Send("Test message", nil)
104
105 require.Error(t, err)
106 assert.Contains(t, err.Error(), "making HTTP POST request")
107
108 mockClient.AssertExpectations(t)
109 })
110 }
111
112 func TestServiceSendWithTimeoutError(t *testing.T) {
113 t.Parallel()
114 synctest.Test(t, func(t *testing.T) {
115 mockClient := mocks.NewMockHTTPClient(t)
116 service := createTestService(
117 t,
118 "zulip://[email protected]:[email protected]?stream=general",
119 mockClient,
120 )
121
122 // register
123 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
124 Return(createMockResponse(http.StatusOK, `{"result": "success"}`), nil).
125 Once()
126
127 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
128 Return(nil, errors.New("context deadline exceeded")).
129 Once()
130
131 err := service.Send("Test message", nil)
132
133 require.Error(t, err)
134
135 mockClient.AssertExpectations(t)
136 })
137 }
138
139 func TestServiceSendWithInvalidHost(t *testing.T) {
140 t.Parallel()
141 synctest.Test(t, func(t *testing.T) {
142 mockClient := mocks.NewMockHTTPClient(t)
143 service := createTestService(
144 t,
145 "zulip://[email protected]:[email protected]?stream=general",
146 mockClient,
147 )
148
149 service.Config.Host = "invalid host with spaces!"
150
151 err := service.Send("Test message", nil)
152
153 require.Error(t, err)
154 require.ErrorIs(t, err, zulip.ErrInvalidHost)
155 // Note: fetch may attempt a register Do with the bad host string (req creation may or may not reach transport); we only care that the final error is InvalidHost.
156 })
157 }
158
159 func TestServiceSendWithEmptyStream(t *testing.T) {
160 t.Parallel()
161 synctest.Test(t, func(t *testing.T) {
162 mockClient := mocks.NewMockHTTPClient(t)
163 service := createTestService(
164 t,
165 "zulip://[email protected]:[email protected]",
166 mockClient,
167 )
168
169 // register fetch happens; channel with no stream now errors before messages call
170 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
171 Return(createMockResponse(http.StatusOK, `{"result": "success"}`), nil).
172 Once()
173
174 err := service.Send("Test message", nil)
175
176 require.Error(t, err)
177 require.ErrorIs(t, err, zulip.ErrMissingRecipient)
178
179 assertNoMessagesAPICall(t, mockClient)
180 })
181 }
182
183 func TestServiceSendWithMalformedResponseBody(t *testing.T) {
184 t.Parallel()
185 synctest.Test(t, func(t *testing.T) {
186 mockClient := mocks.NewMockHTTPClient(t)
187 service := createTestService(
188 t,
189 "zulip://[email protected]:[email protected]?stream=general",
190 mockClient,
191 )
192
193 // register with bad body (decode fails -> defaults, still proceeds)
194 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
195 Return(createMockResponse(http.StatusOK, "not valid json"), nil).
196 Once()
197
198 mockClient.On("Do", mock.AnythingOfType("*http.Request")).
199 Return(createMockResponse(http.StatusOK, `{"result": "success"}`), nil).
200 Once()
201
202 err := service.Send("Test message", nil)
203
204 require.NoError(t, err)
205
206 mockClient.AssertExpectations(t)
207 })
208 }