Debian Codegraph @

testing/integration/discord/content_test.go

raw
1 package discord_test
2
3 import (
4 "net/http"
5 "testing"
6 "testing/synctest"
7 "time"
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/types"
14 )
15
16 func TestServiceInitialization(t *testing.T) {
17 t.Parallel()
18 synctest.Test(t, func(t *testing.T) {
19 mockClient := &MockHTTPClient{}
20 service := createTestService(
21 t,
22 "discord://test-token@test-webhook",
23 mockClient,
24 )
25
26 // Test that service initializes correctly
27 assert.NotNil(t, service)
28 assert.Equal(t, "discord", service.GetID())
29
30 mockClient.AssertExpectations(t)
31 })
32 }
33
34 func TestSendItemsWithPlainText(t *testing.T) {
35 t.Parallel()
36 synctest.Test(t, func(t *testing.T) {
37 mockClient := &MockHTTPClient{}
38 service := createTestService(
39 t,
40 "discord://test-token@test-webhook",
41 mockClient,
42 )
43
44 // Test SendItems with plain text message
45 mockClient.On("Do", mock.Anything).
46 Return(createMockResponse(http.StatusNoContent, ""), nil).
47 Once()
48
49 items := []types.MessageItem{
50 createTestMessageItem("Test plain text message"),
51 }
52
53 err := service.SendItems(items, nil)
54 require.NoError(t, err)
55
56 mockClient.AssertExpectations(t)
57 })
58 }
59
60 func TestSendItemsWithEmptyMessage(t *testing.T) {
61 t.Parallel()
62 synctest.Test(t, func(t *testing.T) {
63 mockClient := &MockHTTPClient{}
64 service := createTestService(
65 t,
66 "discord://test-token@test-webhook",
67 mockClient,
68 )
69
70 // Test SendItems with empty message
71 mockClient.On("Do", mock.Anything).
72 Return(createMockResponse(http.StatusNoContent, ""), nil).
73 Once()
74
75 items := []types.MessageItem{
76 createTestMessageItem(""),
77 }
78
79 err := service.SendItems(items, nil)
80 require.NoError(t, err)
81
82 mockClient.AssertExpectations(t)
83 })
84 }
85
86 func TestSendItemsWithMultipleItems(t *testing.T) {
87 t.Parallel()
88 synctest.Test(t, func(t *testing.T) {
89 mockClient := &MockHTTPClient{}
90 service := createTestService(
91 t,
92 "discord://test-token@test-webhook",
93 mockClient,
94 )
95
96 // Test SendItems with multiple plain text items
97 mockClient.On("Do", mock.Anything).
98 Return(createMockResponse(http.StatusNoContent, ""), nil).
99 Once()
100
101 items := []types.MessageItem{
102 createTestMessageItem("First message"),
103 createTestMessageItem("Second message"),
104 createTestMessageItem("Third message"),
105 }
106
107 err := service.SendItems(items, nil)
108 require.NoError(t, err)
109
110 mockClient.AssertExpectations(t)
111 })
112 }
113
114 func TestSendItemsWithParams(t *testing.T) {
115 t.Parallel()
116 synctest.Test(t, func(t *testing.T) {
117 mockClient := &MockHTTPClient{}
118 service := createTestService(
119 t,
120 "discord://test-token@test-webhook",
121 mockClient,
122 )
123
124 // Test SendItems with parameters
125 mockClient.On("Do", mock.Anything).
126 Return(createMockResponse(http.StatusNoContent, ""), nil).
127 Once()
128
129 items := []types.MessageItem{
130 createTestMessageItem("Message with params"),
131 }
132
133 params := createTestParams(
134 "username",
135 "TestBot",
136 "avatar",
137 "https://example.com/avatar.png",
138 )
139 err := service.SendItems(items, params)
140 require.NoError(t, err)
141
142 mockClient.AssertExpectations(t)
143 })
144 }
145
146 func TestSendItemsWithTimestamp(t *testing.T) {
147 t.Parallel()
148 synctest.Test(t, func(t *testing.T) {
149 mockClient := &MockHTTPClient{}
150 service := createTestService(
151 t,
152 "discord://test-token@test-webhook",
153 mockClient,
154 )
155
156 // Test SendItems with timestamp
157 mockClient.On("Do", mock.Anything).
158 Return(createMockResponse(http.StatusNoContent, ""), nil).
159 Once()
160
161 items := []types.MessageItem{
162 {
163 Text: "Message with timestamp",
164 Timestamp: time.Now(),
165 },
166 }
167
168 err := service.SendItems(items, nil)
169 require.NoError(t, err)
170
171 mockClient.AssertExpectations(t)
172 })
173 }
174
175 func TestSendItemsWithLevel(t *testing.T) {
176 t.Parallel()
177 synctest.Test(t, func(t *testing.T) {
178 mockClient := &MockHTTPClient{}
179 service := createTestService(
180 t,
181 "discord://test-token@test-webhook",
182 mockClient,
183 )
184
185 // Test SendItems with different message levels
186 tests := []struct {
187 name string
188 level types.MessageLevel
189 }{
190 {"info level", types.Info},
191 {"warning level", types.Warning},
192 {"error level", types.Error},
193 }
194
195 for _, tt := range tests {
196 mockClient.On("Do", mock.Anything).
197 Return(createMockResponse(http.StatusNoContent, ""), nil).
198 Once()
199
200 items := []types.MessageItem{
201 {
202 Text: "Message with level",
203 Level: tt.level,
204 },
205 }
206
207 err := service.SendItems(items, nil)
208 require.NoError(t, err)
209 }
210
211 mockClient.AssertExpectations(t)
212 })
213 }