aboutsummaryrefslogtreecommitdiffhomepage
path: root/server/tests/api/notifications/comments-notifications.ts
diff options
context:
space:
mode:
Diffstat (limited to 'server/tests/api/notifications/comments-notifications.ts')
-rw-r--r--server/tests/api/notifications/comments-notifications.ts305
1 files changed, 0 insertions, 305 deletions
diff --git a/server/tests/api/notifications/comments-notifications.ts b/server/tests/api/notifications/comments-notifications.ts
deleted file mode 100644
index 0a4bfc5e4..000000000
--- a/server/tests/api/notifications/comments-notifications.ts
+++ /dev/null
@@ -1,305 +0,0 @@
1/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
2
3import { expect } from 'chai'
4import {
5 checkCommentMention,
6 CheckerBaseParams,
7 checkNewCommentOnMyVideo,
8 MockSmtpServer,
9 prepareNotificationsTest
10} from '@server/tests/shared'
11import { UserNotification } from '@shared/models'
12import { cleanupTests, PeerTubeServer, waitJobs } from '@shared/server-commands'
13
14describe('Test comments notifications', function () {
15 let servers: PeerTubeServer[] = []
16 let userToken: string
17 let userNotifications: UserNotification[] = []
18 let emails: object[] = []
19
20 const commentText = '**hello** <a href="https://joinpeertube.org">world</a>, <h1>what do you think about peertube?</h1>'
21 const expectedHtml = '<strong>hello</strong> <a href="https://joinpeertube.org" target="_blank" rel="noopener noreferrer">world</a>' +
22 ', </p>what do you think about peertube?'
23
24 before(async function () {
25 this.timeout(120000)
26
27 const res = await prepareNotificationsTest(2)
28 emails = res.emails
29 userToken = res.userAccessToken
30 servers = res.servers
31 userNotifications = res.userNotifications
32 })
33
34 describe('Comment on my video notifications', function () {
35 let baseParams: CheckerBaseParams
36
37 before(() => {
38 baseParams = {
39 server: servers[0],
40 emails,
41 socketNotifications: userNotifications,
42 token: userToken
43 }
44 })
45
46 it('Should not send a new comment notification after a comment on another video', async function () {
47 this.timeout(30000)
48
49 const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
50
51 const created = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
52 const commentId = created.id
53
54 await waitJobs(servers)
55 await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'absence' })
56 })
57
58 it('Should not send a new comment notification if I comment my own video', async function () {
59 this.timeout(30000)
60
61 const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
62
63 const created = await servers[0].comments.createThread({ token: userToken, videoId: uuid, text: 'comment' })
64 const commentId = created.id
65
66 await waitJobs(servers)
67 await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'absence' })
68 })
69
70 it('Should not send a new comment notification if the account is muted', async function () {
71 this.timeout(30000)
72
73 await servers[0].blocklist.addToMyBlocklist({ token: userToken, account: 'root' })
74
75 const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
76
77 const created = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
78 const commentId = created.id
79
80 await waitJobs(servers)
81 await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'absence' })
82
83 await servers[0].blocklist.removeFromMyBlocklist({ token: userToken, account: 'root' })
84 })
85
86 it('Should send a new comment notification after a local comment on my video', async function () {
87 this.timeout(30000)
88
89 const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
90
91 const created = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
92 const commentId = created.id
93
94 await waitJobs(servers)
95 await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'presence' })
96 })
97
98 it('Should send a new comment notification after a remote comment on my video', async function () {
99 this.timeout(30000)
100
101 const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
102
103 await waitJobs(servers)
104
105 await servers[1].comments.createThread({ videoId: uuid, text: 'comment' })
106
107 await waitJobs(servers)
108
109 const { data } = await servers[0].comments.listThreads({ videoId: uuid })
110 expect(data).to.have.lengthOf(1)
111
112 const commentId = data[0].id
113 await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'presence' })
114 })
115
116 it('Should send a new comment notification after a local reply on my video', async function () {
117 this.timeout(30000)
118
119 const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
120
121 const { id: threadId } = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
122
123 const { id: commentId } = await servers[0].comments.addReply({ videoId: uuid, toCommentId: threadId, text: 'reply' })
124
125 await waitJobs(servers)
126 await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId, commentId, checkType: 'presence' })
127 })
128
129 it('Should send a new comment notification after a remote reply on my video', async function () {
130 this.timeout(30000)
131
132 const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
133 await waitJobs(servers)
134
135 {
136 const created = await servers[1].comments.createThread({ videoId: uuid, text: 'comment' })
137 const threadId = created.id
138 await servers[1].comments.addReply({ videoId: uuid, toCommentId: threadId, text: 'reply' })
139 }
140
141 await waitJobs(servers)
142
143 const { data } = await servers[0].comments.listThreads({ videoId: uuid })
144 expect(data).to.have.lengthOf(1)
145
146 const threadId = data[0].id
147 const tree = await servers[0].comments.getThread({ videoId: uuid, threadId })
148
149 expect(tree.children).to.have.lengthOf(1)
150 const commentId = tree.children[0].comment.id
151
152 await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId, commentId, checkType: 'presence' })
153 })
154
155 it('Should convert markdown in comment to html', async function () {
156 this.timeout(30000)
157
158 const { uuid } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'cool video' } })
159
160 await servers[0].comments.createThread({ videoId: uuid, text: commentText })
161
162 await waitJobs(servers)
163
164 const latestEmail = emails[emails.length - 1]
165 expect(latestEmail['html']).to.contain(expectedHtml)
166 })
167 })
168
169 describe('Mention notifications', function () {
170 let baseParams: CheckerBaseParams
171 const byAccountDisplayName = 'super root name'
172
173 before(async function () {
174 baseParams = {
175 server: servers[0],
176 emails,
177 socketNotifications: userNotifications,
178 token: userToken
179 }
180
181 await servers[0].users.updateMe({ displayName: 'super root name' })
182 await servers[1].users.updateMe({ displayName: 'super root 2 name' })
183 })
184
185 it('Should not send a new mention comment notification if I mention the video owner', async function () {
186 this.timeout(30000)
187
188 const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
189
190 const { id: commentId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hello' })
191
192 await waitJobs(servers)
193 await checkCommentMention({ ...baseParams, shortUUID, threadId: commentId, commentId, byAccountDisplayName, checkType: 'absence' })
194 })
195
196 it('Should not send a new mention comment notification if I mention myself', async function () {
197 this.timeout(30000)
198
199 const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
200
201 const { id: commentId } = await servers[0].comments.createThread({ token: userToken, videoId: uuid, text: '@user_1 hello' })
202
203 await waitJobs(servers)
204 await checkCommentMention({ ...baseParams, shortUUID, threadId: commentId, commentId, byAccountDisplayName, checkType: 'absence' })
205 })
206
207 it('Should not send a new mention notification if the account is muted', async function () {
208 this.timeout(30000)
209
210 await servers[0].blocklist.addToMyBlocklist({ token: userToken, account: 'root' })
211
212 const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
213
214 const { id: commentId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hello' })
215
216 await waitJobs(servers)
217 await checkCommentMention({ ...baseParams, shortUUID, threadId: commentId, commentId, byAccountDisplayName, checkType: 'absence' })
218
219 await servers[0].blocklist.removeFromMyBlocklist({ token: userToken, account: 'root' })
220 })
221
222 it('Should not send a new mention notification if the remote account mention a local account', async function () {
223 this.timeout(30000)
224
225 const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
226
227 await waitJobs(servers)
228 const { id: threadId } = await servers[1].comments.createThread({ videoId: uuid, text: '@user_1 hello' })
229
230 await waitJobs(servers)
231
232 const byAccountDisplayName = 'super root 2 name'
233 await checkCommentMention({ ...baseParams, shortUUID, threadId, commentId: threadId, byAccountDisplayName, checkType: 'absence' })
234 })
235
236 it('Should send a new mention notification after local comments', async function () {
237 this.timeout(30000)
238
239 const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
240
241 const { id: threadId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hellotext: 1' })
242
243 await waitJobs(servers)
244 await checkCommentMention({ ...baseParams, shortUUID, threadId, commentId: threadId, byAccountDisplayName, checkType: 'presence' })
245
246 const { id: commentId } = await servers[0].comments.addReply({ videoId: uuid, toCommentId: threadId, text: 'hello 2 @user_1' })
247
248 await waitJobs(servers)
249 await checkCommentMention({ ...baseParams, shortUUID, commentId, threadId, byAccountDisplayName, checkType: 'presence' })
250 })
251
252 it('Should send a new mention notification after remote comments', async function () {
253 this.timeout(30000)
254
255 const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
256
257 await waitJobs(servers)
258
259 const text1 = `hello @user_1@${servers[0].host} 1`
260 const { id: server2ThreadId } = await servers[1].comments.createThread({ videoId: uuid, text: text1 })
261
262 await waitJobs(servers)
263
264 const { data } = await servers[0].comments.listThreads({ videoId: uuid })
265 expect(data).to.have.lengthOf(1)
266
267 const byAccountDisplayName = 'super root 2 name'
268 const threadId = data[0].id
269 await checkCommentMention({ ...baseParams, shortUUID, commentId: threadId, threadId, byAccountDisplayName, checkType: 'presence' })
270
271 const text2 = `@user_1@${servers[0].host} hello 2 @root@${servers[0].host}`
272 await servers[1].comments.addReply({ videoId: uuid, toCommentId: server2ThreadId, text: text2 })
273
274 await waitJobs(servers)
275
276 const tree = await servers[0].comments.getThread({ videoId: uuid, threadId })
277
278 expect(tree.children).to.have.lengthOf(1)
279 const commentId = tree.children[0].comment.id
280
281 await checkCommentMention({ ...baseParams, shortUUID, commentId, threadId, byAccountDisplayName, checkType: 'presence' })
282 })
283
284 it('Should convert markdown in comment to html', async function () {
285 this.timeout(30000)
286
287 const { uuid } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
288
289 const { id: threadId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hello 1' })
290
291 await servers[0].comments.addReply({ videoId: uuid, toCommentId: threadId, text: '@user_1 ' + commentText })
292
293 await waitJobs(servers)
294
295 const latestEmail = emails[emails.length - 1]
296 expect(latestEmail['html']).to.contain(expectedHtml)
297 })
298 })
299
300 after(async function () {
301 MockSmtpServer.Instance.kill()
302
303 await cleanupTests(servers)
304 })
305})
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-30 00:42:18 +0000