Debian Codegraph @

testing/integration/mqtt/timeout_test.go

raw
1 package mqtt_test
2
3 import (
4 "context"
5 "errors"
6 "testing"
7 "testing/synctest"
8
9 "github.com/stretchr/testify/mock"
10 "github.com/stretchr/testify/require"
11 )
12
13 func TestPublishTimeout(t *testing.T) {
14 t.Parallel()
15 synctest.Test(t, func(t *testing.T) {
16 mockManager := &MockConnectionManager{}
17 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
18
19 // Simulate a timeout error from publish
20 mockManager.On("Publish", mock.Anything, mock.Anything).
21 Return(nil, context.DeadlineExceeded).
22 Once()
23
24 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
25
26 err := service.Send("Test message", nil)
27 require.Error(t, err)
28 require.Contains(t, err.Error(), "publishing to MQTT topic")
29
30 mockManager.AssertExpectations(t)
31 })
32 }
33
34 func TestAwaitConnectionTimeout(t *testing.T) {
35 t.Parallel()
36 synctest.Test(t, func(t *testing.T) {
37 mockManager := &MockConnectionManager{}
38
39 // Simulate a connection timeout
40 mockManager.On("AwaitConnection", mock.Anything).
41 Return(context.DeadlineExceeded).
42 Once()
43
44 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
45
46 err := service.Send("Test message", nil)
47 require.Error(t, err)
48 require.Contains(t, err.Error(), "connecting to MQTT broker")
49
50 mockManager.AssertExpectations(t)
51 })
52 }
53
54 func TestDisconnectTimeout(t *testing.T) {
55 t.Parallel()
56 synctest.Test(t, func(t *testing.T) {
57 mockManager := &MockConnectionManager{}
58 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
59 mockManager.On("Publish", mock.Anything, mock.Anything).
60 Return(createMockPublishResponse(0), nil).
61 Once()
62
63 // Simulate a disconnect timeout
64 mockManager.On("Disconnect", mock.Anything).
65 Return(context.DeadlineExceeded).
66 Once()
67
68 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
69
70 // Send a message first
71 err := service.Send("Test message", nil)
72 require.NoError(t, err)
73
74 err = service.Close()
75 require.Error(t, err)
76 require.Contains(t, err.Error(), "disconnecting from MQTT broker")
77
78 mockManager.AssertExpectations(t)
79 })
80 }
81
82 func TestContextCancellationDuringPublish(t *testing.T) {
83 t.Parallel()
84 synctest.Test(t, func(t *testing.T) {
85 mockManager := &MockConnectionManager{}
86 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
87
88 // Simulate context cancellation
89 mockManager.On("Publish", mock.Anything, mock.Anything).
90 Return(nil, context.Canceled).
91 Once()
92
93 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
94
95 err := service.Send("Test message", nil)
96 require.Error(t, err)
97 require.Contains(t, err.Error(), "publishing to MQTT topic")
98
99 mockManager.AssertExpectations(t)
100 })
101 }
102
103 func TestContextCancellationDuringDisconnect(t *testing.T) {
104 t.Parallel()
105 synctest.Test(t, func(t *testing.T) {
106 mockManager := &MockConnectionManager{}
107 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
108 mockManager.On("Publish", mock.Anything, mock.Anything).
109 Return(createMockPublishResponse(0), nil).
110 Once()
111 mockManager.On("Disconnect", mock.Anything).
112 Return(context.Canceled).
113 Once()
114
115 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
116
117 // Send a message first
118 err := service.Send("Test message", nil)
119 require.NoError(t, err)
120
121 err = service.Close()
122 require.Error(t, err)
123 require.Contains(t, err.Error(), "disconnecting from MQTT broker")
124
125 mockManager.AssertExpectations(t)
126 })
127 }
128
129 func TestFastOperationCompletesBeforeTimeout(t *testing.T) {
130 t.Parallel()
131 synctest.Test(t, func(t *testing.T) {
132 mockManager := &MockConnectionManager{}
133 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
134 mockManager.On("Publish", mock.Anything, mock.Anything).
135 Return(createMockPublishResponse(0), nil).
136 Once()
137
138 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
139
140 err := service.Send("Test message", nil)
141 require.NoError(t, err)
142
143 mockManager.AssertExpectations(t)
144 })
145 }
146
147 func TestTimeoutErrorWrapping(t *testing.T) {
148 t.Parallel()
149 synctest.Test(t, func(t *testing.T) {
150 mockManager := &MockConnectionManager{}
151 mockManager.On("AwaitConnection", mock.Anything).
152 Return(context.DeadlineExceeded).
153 Once()
154
155 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
156
157 err := service.Send("Test message", nil)
158 require.Error(t, err)
159
160 // Verify the error is properly wrapped
161 require.ErrorIs(t, err, context.DeadlineExceeded)
162 require.Contains(t, err.Error(), "connecting to MQTT broker")
163
164 mockManager.AssertExpectations(t)
165 })
166 }
167
168 func TestCancelledContextErrorWrapping(t *testing.T) {
169 t.Parallel()
170 synctest.Test(t, func(t *testing.T) {
171 mockManager := &MockConnectionManager{}
172 mockManager.On("AwaitConnection", mock.Anything).
173 Return(context.Canceled).
174 Once()
175
176 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
177
178 err := service.Send("Test message", nil)
179 require.Error(t, err)
180
181 // Verify the error is properly wrapped
182 require.ErrorIs(t, err, context.Canceled)
183 require.Contains(t, err.Error(), "connecting to MQTT broker")
184
185 mockManager.AssertExpectations(t)
186 })
187 }
188
189 func TestMultipleOperationsWithTimeouts(t *testing.T) {
190 t.Parallel()
191 synctest.Test(t, func(t *testing.T) {
192 mockManager := &MockConnectionManager{}
193
194 // First call succeeds
195 mockManager.On("AwaitConnection", mock.Anything).Return(nil).Once()
196 mockManager.On("Publish", mock.Anything, mock.Anything).
197 Return(createMockPublishResponse(0), nil).
198 Once()
199
200 // Second call times out
201 mockManager.On("AwaitConnection", mock.Anything).
202 Return(context.DeadlineExceeded).
203 Once()
204
205 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
206
207 // First send should succeed
208 err := service.Send("First message", nil)
209 require.NoError(t, err)
210
211 // Second send should fail with timeout
212 err = service.Send("Second message", nil)
213 require.Error(t, err)
214 require.ErrorIs(t, err, context.DeadlineExceeded)
215
216 mockManager.AssertExpectations(t)
217 })
218 }
219
220 func TestTimeoutWithCustomNetworkError(t *testing.T) {
221 t.Parallel()
222 synctest.Test(t, func(t *testing.T) {
223 customErr := errors.New("custom network timeout error")
224
225 mockManager := &MockConnectionManager{}
226 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
227 mockManager.On("Publish", mock.Anything, mock.Anything).
228 Return(nil, customErr).
229 Once()
230
231 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
232
233 err := service.Send("Test message", nil)
234 require.Error(t, err)
235 require.Contains(t, err.Error(), "publishing to MQTT topic")
236 require.Contains(t, err.Error(), customErr.Error())
237
238 mockManager.AssertExpectations(t)
239 })
240 }