Debian Codegraph @

pkg/services/sms/twilio/twilio_service_test.go

raw
1 package twilio
2
3 import (
4 "errors"
5 "io"
6 "net/http"
7 "net/url"
8 "strings"
9
10 "github.com/onsi/ginkgo/v2"
11 "github.com/onsi/gomega"
12
13 "github.com/nicholas-fedor/shoutrrr/internal/testutils"
14 "github.com/nicholas-fedor/shoutrrr/pkg/format"
15 "github.com/nicholas-fedor/shoutrrr/pkg/types"
16 )
17
18 // mockLogger is a test helper that implements StdLogger interface.
19 type mockLogger struct{}
20
21 // mockServiceHTTPClient is a test helper that implements HTTPClient interface.
22 type mockServiceHTTPClient struct {
23 response *http.Response
24 err error
25 callCount int
26 captureBody bool
27 captureHeaders bool
28 lastBody string
29 lastRequest *http.Request
30 }
31
32 var _ = ginkgo.Describe("Service Unit Tests", func() {
33 var (
34 service *Service
35 mockClient *mockServiceHTTPClient
36 )
37
38 ginkgo.BeforeEach(func() {
39 service = &Service{
40 Config: &Config{
41 AccountSID: "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
42 AuthToken: "authToken",
43 FromNumber: "+15551234567",
44 ToNumbers: []string{"+15559876543"},
45 },
46 HTTPClient: &mockServiceHTTPClient{},
47 }
48 service.SetLogger(&mockLogger{})
49 service.pkr = *initPKR(service.Config)
50 mockClient = service.HTTPClient.(*mockServiceHTTPClient)
51 mockClient.response = &http.Response{
52 StatusCode: http.StatusCreated,
53 Body: io.NopCloser(strings.NewReader(`{"sid": "SM123"}`)),
54 }
55 })
56
57 ginkgo.Describe("Initialize", func() {
58 ginkgo.It("should initialize from a valid URL", func() {
59 svc := &Service{}
60 serviceURL, err := url.Parse(
61 "twilio://ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:authToken@+15551234567/+15559876543",
62 )
63 gomega.Expect(err).NotTo(gomega.HaveOccurred())
64
65 err = svc.Initialize(serviceURL, testutils.TestLogger())
66 gomega.Expect(err).NotTo(gomega.HaveOccurred())
67 gomega.Expect(svc.Config.AccountSID).
68 To(gomega.Equal("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"))
69 gomega.Expect(svc.HTTPClient).NotTo(gomega.BeNil())
70 })
71
72 ginkgo.It("should return an error for invalid URL", func() {
73 svc := &Service{}
74 serviceURL, err := url.Parse("twilio://:@/")
75 gomega.Expect(err).NotTo(gomega.HaveOccurred())
76
77 err = svc.Initialize(serviceURL, testutils.TestLogger())
78 gomega.Expect(err).To(gomega.HaveOccurred())
79 })
80 })
81
82 ginkgo.Describe("GetID", func() {
83 ginkgo.It("should return 'twilio'", func() {
84 gomega.Expect(service.GetID()).To(gomega.Equal("twilio"))
85 })
86 })
87
88 ginkgo.Describe("Send", func() {
89 ginkgo.It("should send successfully to a single recipient", func() {
90 err := service.Send("Test message", nil)
91 gomega.Expect(err).NotTo(gomega.HaveOccurred())
92 gomega.Expect(mockClient.callCount).To(gomega.Equal(1))
93 })
94
95 ginkgo.It("should send to multiple recipients", func() {
96 service.Config.ToNumbers = []string{"+15559876543", "+15551111111"}
97 mockClient.response = &http.Response{
98 StatusCode: http.StatusCreated,
99 Body: io.NopCloser(strings.NewReader("")),
100 }
101
102 err := service.Send("Test message", nil)
103 gomega.Expect(err).NotTo(gomega.HaveOccurred())
104 gomega.Expect(mockClient.callCount).To(gomega.Equal(2))
105 })
106
107 ginkgo.It("should prepend title to message body when title is set", func() {
108 service.Config.Title = "Alert"
109 mockClient.captureBody = true
110
111 err := service.Send("Something happened", nil)
112 gomega.Expect(err).NotTo(gomega.HaveOccurred())
113 // Body is URL-encoded form data
114 gomega.Expect(mockClient.lastBody).To(gomega.ContainSubstring("Alert"))
115 gomega.Expect(mockClient.lastBody).To(gomega.ContainSubstring("Something"))
116 })
117
118 ginkgo.It("should return an error on HTTP failure", func() {
119 mockClient.err = errors.New("network error")
120
121 err := service.Send("Message", nil)
122 gomega.Expect(err).To(gomega.HaveOccurred())
123 })
124
125 ginkgo.It("should return an error for non-2xx status codes", func() {
126 mockClient.response = &http.Response{
127 StatusCode: http.StatusUnauthorized,
128 Body: io.NopCloser(strings.NewReader("")),
129 }
130
131 err := service.Send("Message", nil)
132 gomega.Expect(err).To(gomega.HaveOccurred())
133 })
134 })
135
136 ginkgo.Describe("Params update", func() {
137 ginkgo.It("should update config from params", func() {
138 params := types.Params{"title": "Updated Title"}
139
140 err := service.Send("Message", &params)
141 gomega.Expect(err).NotTo(gomega.HaveOccurred())
142 gomega.Expect(service.Config.Title).To(gomega.Equal("Updated Title"))
143 })
144 })
145 })
146
147 // initPKR initializes a PropKeyResolver for testing.
148 func initPKR(config *Config) *format.PropKeyResolver {
149 pkr := format.NewPropKeyResolver(config)
150
151 return &pkr
152 }
153
154 func (m *mockServiceHTTPClient) Do(req *http.Request) (*http.Response, error) {
155 m.callCount++
156
157 if m.captureHeaders {
158 m.lastRequest = req
159 }
160
161 if m.captureBody && req.Body != nil {
162 body, err := io.ReadAll(req.Body)
163 if err == nil {
164 m.lastBody = string(body)
165 }
166 }
167
168 if m.err != nil {
169 return nil, m.err
170 }
171
172 // Return a fresh response body for each call (io.NopCloser can only be read once)
173 if m.response != nil && m.callCount > 1 {
174 return &http.Response{
175 StatusCode: m.response.StatusCode,
176 Body: io.NopCloser(strings.NewReader("")),
177 }, nil
178 }
179
180 return m.response, nil
181 }
182
183 func (m *mockLogger) Print(_ ...any) {}
184 func (m *mockLogger) Printf(_ string, _ ...any) {}
185 func (m *mockLogger) Println(_ ...any) {}