Debian Codegraph @

pkg/services/chat/signal/signal_test.go

raw
1 package signal
2
3 import (
4 "log"
5 "net/url"
6 "testing"
7
8 "github.com/jarcoal/httpmock"
9 "github.com/onsi/ginkgo/v2"
10 "github.com/onsi/gomega"
11
12 "github.com/nicholas-fedor/shoutrrr/internal/testutils"
13 "github.com/nicholas-fedor/shoutrrr/pkg/types"
14 )
15
16 var (
17 logger *log.Logger
18
19 _ = ginkgo.BeforeSuite(func() {
20 logger = log.New(ginkgo.GinkgoWriter, "Test", log.LstdFlags)
21 })
22 )
23
24 var _ = ginkgo.Describe("the signal service", func() {
25 var signal *Service
26
27 ginkgo.BeforeEach(func() {
28 signal = &Service{}
29 })
30
31 ginkgo.Describe("creating configurations", func() {
32 ginkgo.When("given a url", func() {
33 ginkgo.It("should return an error if no source phone number is supplied", func() {
34 serviceURL, _ := url.Parse("signal://localhost:8080")
35 err := signal.Initialize(serviceURL, logger)
36 gomega.Expect(err).To(gomega.HaveOccurred())
37 gomega.Expect(err).To(gomega.MatchError(ErrNoRecipients))
38 })
39
40 ginkgo.It("should return an error if no recipients are supplied", func() {
41 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890")
42 err := signal.Initialize(serviceURL, logger)
43 gomega.Expect(err).To(gomega.HaveOccurred())
44 gomega.Expect(err).To(gomega.MatchError(ErrNoRecipients))
45 })
46
47 ginkgo.It("should return an error for invalid phone number format", func() {
48 serviceURL, _ := url.Parse("signal://localhost:8080/invalid-phone/+1234567890")
49 err := signal.Initialize(serviceURL, logger)
50 gomega.Expect(err).To(gomega.HaveOccurred())
51 gomega.Expect(err.Error()).
52 To(gomega.ContainSubstring("invalid phone number format"))
53 })
54
55 ginkgo.It("should return an error for invalid group ID format", func() {
56 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890/invalid.group!")
57 err := signal.Initialize(serviceURL, logger)
58 gomega.Expect(err).To(gomega.HaveOccurred())
59 gomega.Expect(err.Error()).To(gomega.ContainSubstring("invalid recipient"))
60 })
61
62 ginkgo.It("should accept group IDs with base64 characters / and =", func() {
63 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890/group.ABCD/EFGH=")
64 err := signal.Initialize(serviceURL, logger)
65 gomega.Expect(err).NotTo(gomega.HaveOccurred())
66 })
67
68 ginkgo.It("should accept group IDs with base64 character +", func() {
69 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890/group.ABCD+EFGH")
70 err := signal.Initialize(serviceURL, logger)
71 gomega.Expect(err).NotTo(gomega.HaveOccurred())
72 })
73
74 ginkgo.When("parsing authentication", func() {
75 ginkgo.It("should parse user without password", func() {
76 serviceURL, _ := url.Parse(
77 "signal://user@localhost:8080/+1234567890/+0987654321",
78 )
79 err := signal.Initialize(serviceURL, logger)
80 gomega.Expect(err).NotTo(gomega.HaveOccurred())
81 gomega.Expect(signal.Config.User).To(gomega.Equal("user"))
82 gomega.Expect(signal.Config.Password).To(gomega.BeEmpty())
83 })
84
85 ginkgo.It("should parse user with password", func() {
86 serviceURL, _ := url.Parse(
87 "signal://user:pass@localhost:8080/+1234567890/+0987654321",
88 )
89 err := signal.Initialize(serviceURL, logger)
90 gomega.Expect(err).NotTo(gomega.HaveOccurred())
91 gomega.Expect(signal.Config.User).To(gomega.Equal("user"))
92 gomega.Expect(signal.Config.Password).To(gomega.Equal("pass"))
93 })
94 })
95
96 ginkgo.When("parsing host and port", func() {
97 ginkgo.It("should parse custom host and port", func() {
98 serviceURL, _ := url.Parse("signal://myserver:9999/+1234567890/+0987654321")
99 err := signal.Initialize(serviceURL, logger)
100 gomega.Expect(err).NotTo(gomega.HaveOccurred())
101 gomega.Expect(signal.Config.Host).To(gomega.Equal("myserver"))
102 gomega.Expect(signal.Config.Port).To(gomega.Equal(9999))
103 })
104
105 ginkgo.It("should use default port when not specified", func() {
106 serviceURL, _ := url.Parse("signal://myserver/+1234567890/+0987654321")
107 err := signal.Initialize(serviceURL, logger)
108 gomega.Expect(err).NotTo(gomega.HaveOccurred())
109 gomega.Expect(signal.Config.Host).To(gomega.Equal("myserver"))
110 gomega.Expect(signal.Config.Port).To(gomega.Equal(8080))
111 })
112 })
113
114 ginkgo.When("parsing TLS settings", func() {
115 ginkgo.It("should enable TLS by default", func() {
116 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890/+0987654321")
117 err := signal.Initialize(serviceURL, logger)
118 gomega.Expect(err).NotTo(gomega.HaveOccurred())
119 gomega.Expect(signal.Config.DisableTLS).To(gomega.BeFalse())
120 })
121
122 ginkgo.It("should disable TLS when disabletls=yes", func() {
123 serviceURL, _ := url.Parse(
124 "signal://localhost:8080/+1234567890/+0987654321?disabletls=yes",
125 )
126 err := signal.Initialize(serviceURL, logger)
127 gomega.Expect(err).NotTo(gomega.HaveOccurred())
128 gomega.Expect(signal.Config.DisableTLS).To(gomega.BeTrue())
129 })
130 })
131
132 ginkgo.When("the url is valid", func() {
133 var (
134 config *Config
135 err error
136 )
137
138 ginkgo.BeforeEach(func() {
139 serviceURL, _ := url.Parse(
140 "signal://localhost:8080/+1234567890/+0987654321/group.testgroup",
141 )
142 err = signal.Initialize(serviceURL, logger)
143 config = signal.Config
144 })
145
146 ginkgo.It("should create a config object", func() {
147 gomega.Expect(err).NotTo(gomega.HaveOccurred())
148 gomega.Expect(config).ToNot(gomega.BeNil())
149 })
150
151 ginkgo.It("should parse the source phone number", func() {
152 gomega.Expect(config.Source).To(gomega.Equal("+1234567890"))
153 })
154
155 ginkgo.It("should parse the recipients", func() {
156 gomega.Expect(config.Recipients).
157 To(gomega.Equal([]string{"+0987654321", "group.testgroup"}))
158 })
159
160 ginkgo.It("should set default host and port", func() {
161 gomega.Expect(config.Host).To(gomega.Equal("localhost"))
162 gomega.Expect(config.Port).To(gomega.Equal(8080))
163 })
164 })
165 })
166 })
167
168 ginkgo.Describe("sending the payload", func() {
169 var err error
170
171 ginkgo.BeforeEach(func() {
172 httpmock.Activate()
173 })
174 ginkgo.AfterEach(func() {
175 httpmock.DeactivateAndReset()
176 })
177
178 ginkgo.It("should not report an error if the server accepts the payload", func() {
179 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890/+0987654321")
180 err = signal.Initialize(serviceURL, logger)
181 gomega.Expect(err).NotTo(gomega.HaveOccurred())
182
183 setupResponder(200, `{"timestamp": 1234567890}`)
184
185 err = signal.Send("Test message", nil)
186 gomega.Expect(err).NotTo(gomega.HaveOccurred())
187 })
188
189 ginkgo.It("should report an error if the server returns an error", func() {
190 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890/+0987654321")
191 err = signal.Initialize(serviceURL, logger)
192 gomega.Expect(err).NotTo(gomega.HaveOccurred())
193
194 setupResponder(400, `{"error": "Bad Request"}`)
195
196 err = signal.Send("Test message", nil)
197 gomega.Expect(err).To(gomega.HaveOccurred())
198 gomega.Expect(err.Error()).To(gomega.ContainSubstring("server returned status 400"))
199 })
200
201 ginkgo.It("should handle attachments in parameters", func() {
202 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890/+0987654321")
203 err = signal.Initialize(serviceURL, logger)
204 gomega.Expect(err).NotTo(gomega.HaveOccurred())
205
206 setupResponder(200, `{"timestamp": 1234567890}`)
207
208 params := types.Params{
209 "attachments": "base64data1,base64data2",
210 }
211
212 err = signal.Send("Test message", &params)
213 gomega.Expect(err).NotTo(gomega.HaveOccurred())
214 })
215
216 ginkgo.It("should handle different response formats", func() {
217 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890/+0987654321")
218 err = signal.Initialize(serviceURL, logger)
219 gomega.Expect(err).NotTo(gomega.HaveOccurred())
220
221 setupResponder(201, `{"timestamp": "1234567890"}`) // String timestamp
222
223 err = signal.Send("Test message", nil)
224 gomega.Expect(err).NotTo(gomega.HaveOccurred())
225 })
226
227 ginkgo.It("should handle server errors gracefully", func() {
228 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890/+0987654321")
229 err = signal.Initialize(serviceURL, logger)
230 gomega.Expect(err).NotTo(gomega.HaveOccurred())
231
232 setupResponder(500, `{"error": "Internal Server Error"}`)
233
234 err = signal.Send("Test message", nil)
235 gomega.Expect(err).To(gomega.HaveOccurred())
236 gomega.Expect(err.Error()).To(gomega.ContainSubstring("server returned status 500"))
237 })
238
239 ginkgo.It("should return error when no recipients configured", func() {
240 // Create a config with no recipients
241 signal.Config = &Config{
242 Host: "localhost",
243 Port: 8080,
244 Source: "+1234567890",
245 Recipients: []string{}, // Empty recipients
246 }
247
248 err = signal.Send("Test message", nil)
249 gomega.Expect(err).To(gomega.MatchError(ErrNoRecipients))
250 })
251 })
252
253 ginkgo.Describe("parsing recipients", func() {
254 ginkgo.It("should parse valid phone numbers", func() {
255 recipients, err := parseRecipients([]string{"+1234567890", "+0987654321"})
256 gomega.Expect(err).NotTo(gomega.HaveOccurred())
257 gomega.Expect(recipients).To(gomega.Equal([]string{"+1234567890", "+0987654321"}))
258 })
259
260 ginkgo.It("should parse valid group IDs", func() {
261 recipients, err := parseRecipients([]string{"group.testgroup", "group.abcdef123"})
262 gomega.Expect(err).NotTo(gomega.HaveOccurred())
263 gomega.Expect(recipients).
264 To(gomega.Equal([]string{"group.testgroup", "group.abcdef123"}))
265 })
266
267 ginkgo.It("should parse group IDs with base64 characters", func() {
268 recipients, err := parseRecipients([]string{"group.ABCD/EFGH=", "group.xyz+abc"})
269 gomega.Expect(err).NotTo(gomega.HaveOccurred())
270 gomega.Expect(recipients).
271 To(gomega.Equal([]string{"group.ABCD/EFGH=", "group.xyz+abc"}))
272 })
273
274 ginkgo.It("should parse mixed phone numbers and group IDs", func() {
275 recipients, err := parseRecipients(
276 []string{"+1234567890", "group.testgroup", "+0987654321"},
277 )
278 gomega.Expect(err).NotTo(gomega.HaveOccurred())
279 gomega.Expect(recipients).
280 To(gomega.Equal([]string{"+1234567890", "group.testgroup", "+0987654321"}))
281 })
282
283 ginkgo.It("should return error for invalid recipients", func() {
284 _, err := parseRecipients([]string{"invalid-recipient"})
285 gomega.Expect(err).To(gomega.HaveOccurred())
286 gomega.Expect(err.Error()).To(gomega.ContainSubstring("invalid recipient"))
287 })
288
289 ginkgo.It("should return error for mixed valid and invalid recipients", func() {
290 _, err := parseRecipients([]string{"+1234567890", "invalid-recipient"})
291 gomega.Expect(err).To(gomega.HaveOccurred())
292 gomega.Expect(err.Error()).To(gomega.ContainSubstring("invalid recipient"))
293 })
294
295 ginkgo.It("should return error for empty recipient list", func() {
296 _, err := parseRecipients([]string{})
297 gomega.Expect(err).To(gomega.MatchError(ErrNoRecipients))
298 })
299
300 ginkgo.It("should handle group IDs split across path segments", func() {
301 recipients, err := parseRecipients([]string{"group.ABCD", "EFGH="})
302 gomega.Expect(err).NotTo(gomega.HaveOccurred())
303 gomega.Expect(recipients).To(gomega.Equal([]string{"group.ABCD/EFGH="}))
304 })
305 })
306
307 ginkgo.It("should implement basic service API methods correctly", func() {
308 serviceURL, _ := url.Parse("signal://localhost:8080/+1234567890/+0987654321")
309 err := signal.Initialize(serviceURL, logger)
310 gomega.Expect(err).NotTo(gomega.HaveOccurred())
311
312 config := signal.Config
313 testutils.TestConfigGetInvalidQueryValue(config)
314 testutils.TestConfigSetInvalidQueryValue(
315 config,
316 "signal://localhost:8080/+1234567890/+0987654321?foo=bar",
317 )
318 testutils.TestConfigGetEnumsCount(config, 0)
319 testutils.TestConfigGetFieldsCount(config, 10)
320 })
321
322 ginkgo.It("should return the correct service ID", func() {
323 service := &Service{}
324 gomega.Expect(service.GetID()).To(gomega.Equal("signal"))
325 })
326 })
327
328 func TestSignal(t *testing.T) {
329 t.Parallel()
330 gomega.RegisterFailHandler(ginkgo.Fail)
331 ginkgo.RunSpecs(t, "Shoutrrr Signal Suite")
332 }
333
334 func setupResponder(code int, body string) {
335 targetURL := "https://localhost:8080/v2/send"
336 httpmock.RegisterResponder("POST", targetURL, httpmock.NewStringResponder(code, body))
337 }