Debian Codegraph @

testing/integration/mqtt/publish_test.go

raw
1 package mqtt_test
2
3 import (
4 "testing"
5 "testing/synctest"
6
7 "github.com/stretchr/testify/mock"
8 "github.com/stretchr/testify/require"
9
10 "github.com/nicholas-fedor/shoutrrr/pkg/services/push/mqtt"
11 )
12
13 func TestPublishBasicMessage(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 mockManager.On("Publish", mock.Anything, mock.Anything).
19 Return(createMockPublishResponse(0), nil).
20 Once()
21
22 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
23
24 err := service.Send("Hello, MQTT!", nil)
25 require.NoError(t, err)
26
27 // Verify the publish was called with correct parameters
28 assertPublishCalled(t, mockManager, "test/topic")
29 assertPublishPayload(t, mockManager, "Hello, MQTT!")
30 assertPublishQoS(t, mockManager, 0) // Default QoS
31
32 mockManager.AssertExpectations(t)
33 })
34 }
35
36 func TestPublishWithDifferentQoSLevels(t *testing.T) {
37 t.Parallel()
38 synctest.Test(t, func(t *testing.T) {
39 tests := []struct {
40 name string
41 qos byte
42 }{
43 {"QoS 0 - fire and forget", 0},
44 {"QoS 1 - at least once", 1},
45 {"QoS 2 - exactly once", 2},
46 }
47
48 for _, tt := range tests {
49 mockManager := &MockConnectionManager{}
50 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
51 mockManager.On("Publish", mock.Anything, mock.Anything).
52 Return(createMockPublishResponse(0), nil).
53 Once()
54
55 url := "mqtt://broker.example.com/test/topic?qos=" + string(rune('0'+tt.qos))
56 service := createTestService(t, url, mockManager)
57
58 err := service.Send("Test message", nil)
59 require.NoError(t, err)
60
61 assertPublishQoS(t, mockManager, tt.qos)
62
63 mockManager.AssertExpectations(t)
64 }
65 })
66 }
67
68 func TestPublishWithRetainedFlag(t *testing.T) {
69 t.Parallel()
70 synctest.Test(t, func(t *testing.T) {
71 tests := []struct {
72 name string
73 url string
74 expectedRetained bool
75 }{
76 {"retained not set", "mqtt://broker.example.com/test/topic", false},
77 {"retained yes", "mqtt://broker.example.com/test/topic?retained=yes", true},
78 {"retained true", "mqtt://broker.example.com/test/topic?retained=true", true},
79 }
80
81 for _, tt := range tests {
82 mockManager := &MockConnectionManager{}
83 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
84 mockManager.On("Publish", mock.Anything, mock.Anything).
85 Return(createMockPublishResponse(0), nil).
86 Once()
87
88 service := createTestService(t, tt.url, mockManager)
89
90 err := service.Send("Test message", nil)
91 require.NoError(t, err)
92
93 assertPublishRetained(t, mockManager, tt.expectedRetained)
94
95 mockManager.AssertExpectations(t)
96 }
97 })
98 }
99
100 func TestPublishWithParamsOverride(t *testing.T) {
101 t.Parallel()
102 synctest.Test(t, func(t *testing.T) {
103 mockManager := &MockConnectionManager{}
104 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
105 mockManager.On("Publish", mock.Anything, mock.Anything).
106 Return(createMockPublishResponse(0), nil).
107 Once()
108
109 // Create service with default QoS 0
110 service := createTestService(t, "mqtt://broker.example.com/test/topic?qos=0", mockManager)
111
112 // Override QoS via params
113 params := createTestParams("qos", "2", "retained", "yes")
114 err := service.Send("Test message", params)
115 require.NoError(t, err)
116
117 // Verify the override was applied
118 assertPublishQoS(t, mockManager, 2)
119 assertPublishRetained(t, mockManager, true)
120
121 mockManager.AssertExpectations(t)
122 })
123 }
124
125 func TestPublishMultipleMessages(t *testing.T) {
126 t.Parallel()
127 synctest.Test(t, func(t *testing.T) {
128 mockManager := &MockConnectionManager{}
129 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
130
131 // Set up mock for multiple publish calls
132 for range 3 {
133 mockManager.On("Publish", mock.Anything, mock.Anything).
134 Return(createMockPublishResponse(0), nil).
135 Once()
136 }
137
138 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
139
140 messages := []string{
141 "First message",
142 "Second message",
143 "Third message",
144 }
145
146 for _, msg := range messages {
147 err := service.Send(msg, nil)
148 require.NoError(t, err)
149 }
150
151 mockManager.AssertExpectations(t)
152 })
153 }
154
155 func TestPublishTopicVariations(t *testing.T) {
156 t.Parallel()
157 synctest.Test(t, func(t *testing.T) {
158 tests := []struct {
159 name string
160 url string
161 expectedTopic string
162 }{
163 {"simple topic", "mqtt://broker.example.com/alerts", "alerts"},
164 {
165 "nested topic",
166 "mqtt://broker.example.com/home/sensors/temperature",
167 "home/sensors/temperature",
168 },
169 {"deep topic", "mqtt://broker.example.com/a/b/c/d/e/f", "a/b/c/d/e/f"},
170 }
171
172 for _, tt := range tests {
173 mockManager := &MockConnectionManager{}
174 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
175 mockManager.On("Publish", mock.Anything, mock.Anything).
176 Return(createMockPublishResponse(0), nil).
177 Once()
178
179 service := createTestService(t, tt.url, mockManager)
180
181 err := service.Send("Test message", nil)
182 require.NoError(t, err)
183
184 assertPublishCalled(t, mockManager, tt.expectedTopic)
185
186 mockManager.AssertExpectations(t)
187 }
188 })
189 }
190
191 func TestPublishVerifyPublishStructFields(t *testing.T) {
192 t.Parallel()
193 synctest.Test(t, func(t *testing.T) {
194 mockManager := &MockConnectionManager{}
195 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
196 mockManager.On("Publish", mock.Anything, mock.Anything).
197 Return(createMockPublishResponse(0), nil).
198 Once()
199
200 service := createTestService(
201 t,
202 "mqtt://broker.example.com/test/topic?qos=1&retained=yes",
203 mockManager,
204 )
205
206 err := service.Send("Test payload", nil)
207 require.NoError(t, err)
208
209 // Get the publish struct and verify all fields
210 publish := getPublishCall(mockManager)
211 require.NotNil(t, publish)
212 require.Equal(t, "test/topic", publish.Topic)
213 require.Equal(t, byte(1), publish.QoS)
214 require.True(t, publish.Retain)
215 require.Equal(t, []byte("Test payload"), publish.Payload)
216
217 mockManager.AssertExpectations(t)
218 })
219 }
220
221 func TestPublishWithReasonCodeZero(t *testing.T) {
222 t.Parallel()
223 synctest.Test(t, func(t *testing.T) {
224 mockManager := &MockConnectionManager{}
225 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
226 mockManager.On("Publish", mock.Anything, mock.Anything).
227 Return(createMockPublishResponse(0), nil). // Success
228 Once()
229
230 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
231
232 err := service.Send("Test message", nil)
233 require.NoError(t, err)
234
235 mockManager.AssertExpectations(t)
236 })
237 }
238
239 func TestPublishWithNonFailureReasonCode(t *testing.T) {
240 t.Parallel()
241 synctest.Test(t, func(t *testing.T) {
242 mockManager := &MockConnectionManager{}
243 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
244 // Reason code 1 is a non-failure code (success with continuation)
245 mockManager.On("Publish", mock.Anything, mock.Anything).
246 Return(createMockPublishResponse(1), nil).
247 Once()
248
249 service := createTestService(t, "mqtt://broker.example.com/test/topic", mockManager)
250
251 // Non-failure reason codes should not return an error
252 err := service.Send("Test message", nil)
253 require.NoError(t, err)
254
255 mockManager.AssertExpectations(t)
256 })
257 }
258
259 func TestPublishServiceConfigAfterInit(t *testing.T) {
260 t.Parallel()
261 synctest.Test(t, func(t *testing.T) {
262 mockManager := &MockConnectionManager{}
263 mockManager.On("AwaitConnection", mock.Anything).Return(nil)
264 mockManager.On("Publish", mock.Anything, mock.Anything).
265 Return(createMockPublishResponse(0), nil).
266 Once()
267
268 service := createTestService(
269 t,
270 "mqtt://user:[email protected]:1883/test/topic?qos=1&retained=yes&clientid=testclient",
271 mockManager,
272 )
273
274 // Verify config is properly set
275 require.Equal(t, "broker.example.com", service.Config.Host)
276 require.Equal(t, 1883, service.Config.Port)
277 require.Equal(t, "test/topic", service.Config.Topic)
278 require.Equal(t, "user", service.Config.Username)
279 require.Equal(t, "pass", service.Config.Password)
280 require.Equal(t, mqtt.QoS(1), service.Config.QoS)
281 require.True(t, service.Config.Retained)
282 require.Equal(t, "testclient", service.Config.ClientID)
283
284 err := service.Send("Test message", nil)
285 require.NoError(t, err)
286
287 mockManager.AssertExpectations(t)
288 })
289 }