]>
Commit | Line | Data |
---|---|---|
1 | /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ | |
2 | ||
3 | import * as chai from 'chai' | |
4 | import 'mocha' | |
5 | import { | |
6 | addVideoToBlacklist, | |
7 | cleanupTests, | |
8 | createUser, | |
9 | doubleFollow, | |
10 | flushAndRunMultipleServers, | |
11 | follow, | |
12 | getCustomConfig, | |
13 | getMyUserInformation, | |
14 | getVideoCommentThreads, | |
15 | getVideoThreadComments, | |
16 | immutableAssign, | |
17 | MockInstancesIndex, | |
18 | registerUser, | |
19 | removeVideoFromBlacklist, | |
20 | reportVideoAbuse, | |
21 | unfollow, | |
22 | updateCustomConfig, | |
23 | updateCustomSubConfig, | |
24 | updateMyUser, | |
25 | updateVideo, | |
26 | updateVideoChannel, | |
27 | userLogin, | |
28 | wait | |
29 | } from '../../../../shared/extra-utils' | |
30 | import { ServerInfo, uploadVideo } from '../../../../shared/extra-utils/index' | |
31 | import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login' | |
32 | import { waitJobs } from '../../../../shared/extra-utils/server/jobs' | |
33 | import { getUserNotificationSocket } from '../../../../shared/extra-utils/socket/socket-io' | |
34 | import { | |
35 | checkAutoInstanceFollowing, | |
36 | checkCommentMention, | |
37 | CheckerBaseParams, | |
38 | checkMyVideoImportIsFinished, | |
39 | checkNewActorFollow, | |
40 | checkNewBlacklistOnMyVideo, | |
41 | checkNewCommentOnMyVideo, | |
42 | checkNewInstanceFollower, | |
43 | checkNewVideoAbuseForModerators, | |
44 | checkNewVideoFromSubscription, | |
45 | checkUserRegistered, | |
46 | checkVideoAutoBlacklistForModerators, | |
47 | checkVideoIsPublished, | |
48 | getLastNotification, | |
49 | getUserNotifications, | |
50 | markAsReadAllNotifications, | |
51 | markAsReadNotifications, | |
52 | updateMyNotificationSettings | |
53 | } from '../../../../shared/extra-utils/users/user-notifications' | |
54 | import { | |
55 | User, | |
56 | UserNotification, | |
57 | UserNotificationSetting, | |
58 | UserNotificationSettingValue, | |
59 | UserNotificationType | |
60 | } from '../../../../shared/models/users' | |
61 | import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email' | |
62 | import { addUserSubscription, removeUserSubscription } from '../../../../shared/extra-utils/users/user-subscriptions' | |
63 | import { VideoPrivacy } from '../../../../shared/models/videos' | |
64 | import { getBadVideoUrl, getYoutubeVideoUrl, importVideo } from '../../../../shared/extra-utils/videos/video-imports' | |
65 | import { addVideoCommentReply, addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments' | |
66 | import { v4 as uuidv4 } from 'uuid' | |
67 | import { addAccountToAccountBlocklist, removeAccountFromAccountBlocklist } from '../../../../shared/extra-utils/users/blocklist' | |
68 | import { CustomConfig } from '../../../../shared/models/server' | |
69 | import { VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model' | |
70 | ||
71 | const expect = chai.expect | |
72 | ||
73 | async function uploadVideoByRemoteAccount (servers: ServerInfo[], additionalParams: any = {}) { | |
74 | const name = 'remote video ' + uuidv4() | |
75 | ||
76 | const data = Object.assign({ name }, additionalParams) | |
77 | const res = await uploadVideo(servers[1].url, servers[1].accessToken, data) | |
78 | ||
79 | await waitJobs(servers) | |
80 | ||
81 | return { uuid: res.body.video.uuid, name } | |
82 | } | |
83 | ||
84 | async function uploadVideoByLocalAccount (servers: ServerInfo[], additionalParams: any = {}) { | |
85 | const name = 'local video ' + uuidv4() | |
86 | ||
87 | const data = Object.assign({ name }, additionalParams) | |
88 | const res = await uploadVideo(servers[0].url, servers[0].accessToken, data) | |
89 | ||
90 | await waitJobs(servers) | |
91 | ||
92 | return { uuid: res.body.video.uuid, name } | |
93 | } | |
94 | ||
95 | describe('Test users notifications', function () { | |
96 | let servers: ServerInfo[] = [] | |
97 | let userAccessToken: string | |
98 | const userNotifications: UserNotification[] = [] | |
99 | const adminNotifications: UserNotification[] = [] | |
100 | const adminNotificationsServer2: UserNotification[] = [] | |
101 | const emails: object[] = [] | |
102 | let channelId: number | |
103 | ||
104 | const allNotificationSettings: UserNotificationSetting = { | |
105 | newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
106 | newCommentOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
107 | videoAbuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
108 | videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
109 | blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
110 | myVideoImportFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
111 | myVideoPublished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
112 | commentMention: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
113 | newFollow: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
114 | newUserRegistration: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
115 | newInstanceFollower: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
116 | autoInstanceFollowing: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL | |
117 | } | |
118 | ||
119 | before(async function () { | |
120 | this.timeout(120000) | |
121 | ||
122 | const port = await MockSmtpServer.Instance.collectEmails(emails) | |
123 | ||
124 | const overrideConfig = { | |
125 | smtp: { | |
126 | hostname: 'localhost', | |
127 | port | |
128 | } | |
129 | } | |
130 | servers = await flushAndRunMultipleServers(3, overrideConfig) | |
131 | ||
132 | // Get the access tokens | |
133 | await setAccessTokensToServers(servers) | |
134 | ||
135 | // Server 1 and server 2 follow each other | |
136 | await doubleFollow(servers[0], servers[1]) | |
137 | ||
138 | await waitJobs(servers) | |
139 | ||
140 | const user = { | |
141 | username: 'user_1', | |
142 | password: 'super password' | |
143 | } | |
144 | await createUser({ | |
145 | url: servers[0].url, | |
146 | accessToken: servers[0].accessToken, | |
147 | username: user.username, | |
148 | password: user.password, | |
149 | videoQuota: 10 * 1000 * 1000 | |
150 | }) | |
151 | userAccessToken = await userLogin(servers[0], user) | |
152 | ||
153 | await updateMyNotificationSettings(servers[0].url, userAccessToken, allNotificationSettings) | |
154 | await updateMyNotificationSettings(servers[0].url, servers[0].accessToken, allNotificationSettings) | |
155 | await updateMyNotificationSettings(servers[1].url, servers[1].accessToken, allNotificationSettings) | |
156 | ||
157 | { | |
158 | const socket = getUserNotificationSocket(servers[0].url, userAccessToken) | |
159 | socket.on('new-notification', n => userNotifications.push(n)) | |
160 | } | |
161 | { | |
162 | const socket = getUserNotificationSocket(servers[0].url, servers[0].accessToken) | |
163 | socket.on('new-notification', n => adminNotifications.push(n)) | |
164 | } | |
165 | { | |
166 | const socket = getUserNotificationSocket(servers[1].url, servers[1].accessToken) | |
167 | socket.on('new-notification', n => adminNotificationsServer2.push(n)) | |
168 | } | |
169 | ||
170 | { | |
171 | const resChannel = await getMyUserInformation(servers[0].url, servers[0].accessToken) | |
172 | channelId = resChannel.body.videoChannels[0].id | |
173 | } | |
174 | }) | |
175 | ||
176 | describe('New video from my subscription notification', function () { | |
177 | let baseParams: CheckerBaseParams | |
178 | ||
179 | before(() => { | |
180 | baseParams = { | |
181 | server: servers[0], | |
182 | emails, | |
183 | socketNotifications: userNotifications, | |
184 | token: userAccessToken | |
185 | } | |
186 | }) | |
187 | ||
188 | it('Should not send notifications if the user does not follow the video publisher', async function () { | |
189 | this.timeout(10000) | |
190 | ||
191 | await uploadVideoByLocalAccount(servers) | |
192 | ||
193 | const notification = await getLastNotification(servers[0].url, userAccessToken) | |
194 | expect(notification).to.be.undefined | |
195 | ||
196 | expect(emails).to.have.lengthOf(0) | |
197 | expect(userNotifications).to.have.lengthOf(0) | |
198 | }) | |
199 | ||
200 | it('Should send a new video notification if the user follows the local video publisher', async function () { | |
201 | this.timeout(15000) | |
202 | ||
203 | await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:' + servers[0].port) | |
204 | await waitJobs(servers) | |
205 | ||
206 | const { name, uuid } = await uploadVideoByLocalAccount(servers) | |
207 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') | |
208 | }) | |
209 | ||
210 | it('Should send a new video notification from a remote account', async function () { | |
211 | this.timeout(50000) // Server 2 has transcoding enabled | |
212 | ||
213 | await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:' + servers[1].port) | |
214 | await waitJobs(servers) | |
215 | ||
216 | const { name, uuid } = await uploadVideoByRemoteAccount(servers) | |
217 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') | |
218 | }) | |
219 | ||
220 | it('Should send a new video notification on a scheduled publication', async function () { | |
221 | this.timeout(20000) | |
222 | ||
223 | // In 2 seconds | |
224 | const updateAt = new Date(new Date().getTime() + 2000) | |
225 | ||
226 | const data = { | |
227 | privacy: VideoPrivacy.PRIVATE, | |
228 | scheduleUpdate: { | |
229 | updateAt: updateAt.toISOString(), | |
230 | privacy: VideoPrivacy.PUBLIC | |
231 | } | |
232 | } | |
233 | const { name, uuid } = await uploadVideoByLocalAccount(servers, data) | |
234 | ||
235 | await wait(6000) | |
236 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') | |
237 | }) | |
238 | ||
239 | it('Should send a new video notification on a remote scheduled publication', async function () { | |
240 | this.timeout(50000) | |
241 | ||
242 | // In 2 seconds | |
243 | const updateAt = new Date(new Date().getTime() + 2000) | |
244 | ||
245 | const data = { | |
246 | privacy: VideoPrivacy.PRIVATE, | |
247 | scheduleUpdate: { | |
248 | updateAt: updateAt.toISOString(), | |
249 | privacy: VideoPrivacy.PUBLIC | |
250 | } | |
251 | } | |
252 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) | |
253 | await waitJobs(servers) | |
254 | ||
255 | await wait(6000) | |
256 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') | |
257 | }) | |
258 | ||
259 | it('Should not send a notification before the video is published', async function () { | |
260 | this.timeout(20000) | |
261 | ||
262 | const updateAt = new Date(new Date().getTime() + 1000000) | |
263 | ||
264 | const data = { | |
265 | privacy: VideoPrivacy.PRIVATE, | |
266 | scheduleUpdate: { | |
267 | updateAt: updateAt.toISOString(), | |
268 | privacy: VideoPrivacy.PUBLIC | |
269 | } | |
270 | } | |
271 | const { name, uuid } = await uploadVideoByLocalAccount(servers, data) | |
272 | ||
273 | await wait(6000) | |
274 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') | |
275 | }) | |
276 | ||
277 | it('Should send a new video notification when a video becomes public', async function () { | |
278 | this.timeout(10000) | |
279 | ||
280 | const data = { privacy: VideoPrivacy.PRIVATE } | |
281 | const { name, uuid } = await uploadVideoByLocalAccount(servers, data) | |
282 | ||
283 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') | |
284 | ||
285 | await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.PUBLIC }) | |
286 | ||
287 | await wait(500) | |
288 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') | |
289 | }) | |
290 | ||
291 | it('Should send a new video notification when a remote video becomes public', async function () { | |
292 | this.timeout(20000) | |
293 | ||
294 | const data = { privacy: VideoPrivacy.PRIVATE } | |
295 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) | |
296 | ||
297 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') | |
298 | ||
299 | await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.PUBLIC }) | |
300 | ||
301 | await waitJobs(servers) | |
302 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') | |
303 | }) | |
304 | ||
305 | it('Should not send a new video notification when a video becomes unlisted', async function () { | |
306 | this.timeout(20000) | |
307 | ||
308 | const data = { privacy: VideoPrivacy.PRIVATE } | |
309 | const { name, uuid } = await uploadVideoByLocalAccount(servers, data) | |
310 | ||
311 | await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED }) | |
312 | ||
313 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') | |
314 | }) | |
315 | ||
316 | it('Should not send a new video notification when a remote video becomes unlisted', async function () { | |
317 | this.timeout(20000) | |
318 | ||
319 | const data = { privacy: VideoPrivacy.PRIVATE } | |
320 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) | |
321 | ||
322 | await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED }) | |
323 | ||
324 | await waitJobs(servers) | |
325 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') | |
326 | }) | |
327 | ||
328 | it('Should send a new video notification after a video import', async function () { | |
329 | this.timeout(100000) | |
330 | ||
331 | const name = 'video import ' + uuidv4() | |
332 | ||
333 | const attributes = { | |
334 | name, | |
335 | channelId, | |
336 | privacy: VideoPrivacy.PUBLIC, | |
337 | targetUrl: getYoutubeVideoUrl() | |
338 | } | |
339 | const res = await importVideo(servers[0].url, servers[0].accessToken, attributes) | |
340 | const uuid = res.body.video.uuid | |
341 | ||
342 | await waitJobs(servers) | |
343 | ||
344 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') | |
345 | }) | |
346 | }) | |
347 | ||
348 | describe('Comment on my video notifications', function () { | |
349 | let baseParams: CheckerBaseParams | |
350 | ||
351 | before(() => { | |
352 | baseParams = { | |
353 | server: servers[0], | |
354 | emails, | |
355 | socketNotifications: userNotifications, | |
356 | token: userAccessToken | |
357 | } | |
358 | }) | |
359 | ||
360 | it('Should not send a new comment notification after a comment on another video', async function () { | |
361 | this.timeout(10000) | |
362 | ||
363 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
364 | const uuid = resVideo.body.video.uuid | |
365 | ||
366 | const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment') | |
367 | const commentId = resComment.body.comment.id | |
368 | ||
369 | await wait(500) | |
370 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence') | |
371 | }) | |
372 | ||
373 | it('Should not send a new comment notification if I comment my own video', async function () { | |
374 | this.timeout(10000) | |
375 | ||
376 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
377 | const uuid = resVideo.body.video.uuid | |
378 | ||
379 | const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, 'comment') | |
380 | const commentId = resComment.body.comment.id | |
381 | ||
382 | await wait(500) | |
383 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence') | |
384 | }) | |
385 | ||
386 | it('Should not send a new comment notification if the account is muted', async function () { | |
387 | this.timeout(10000) | |
388 | ||
389 | await addAccountToAccountBlocklist(servers[0].url, userAccessToken, 'root') | |
390 | ||
391 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
392 | const uuid = resVideo.body.video.uuid | |
393 | ||
394 | const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment') | |
395 | const commentId = resComment.body.comment.id | |
396 | ||
397 | await wait(500) | |
398 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence') | |
399 | ||
400 | await removeAccountFromAccountBlocklist(servers[0].url, userAccessToken, 'root') | |
401 | }) | |
402 | ||
403 | it('Should send a new comment notification after a local comment on my video', async function () { | |
404 | this.timeout(10000) | |
405 | ||
406 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
407 | const uuid = resVideo.body.video.uuid | |
408 | ||
409 | const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment') | |
410 | const commentId = resComment.body.comment.id | |
411 | ||
412 | await wait(500) | |
413 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence') | |
414 | }) | |
415 | ||
416 | it('Should send a new comment notification after a remote comment on my video', async function () { | |
417 | this.timeout(10000) | |
418 | ||
419 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
420 | const uuid = resVideo.body.video.uuid | |
421 | ||
422 | await waitJobs(servers) | |
423 | ||
424 | await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment') | |
425 | ||
426 | await waitJobs(servers) | |
427 | ||
428 | const resComment = await getVideoCommentThreads(servers[0].url, uuid, 0, 5) | |
429 | expect(resComment.body.data).to.have.lengthOf(1) | |
430 | const commentId = resComment.body.data[0].id | |
431 | ||
432 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence') | |
433 | }) | |
434 | ||
435 | it('Should send a new comment notification after a local reply on my video', async function () { | |
436 | this.timeout(10000) | |
437 | ||
438 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
439 | const uuid = resVideo.body.video.uuid | |
440 | ||
441 | const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment') | |
442 | const threadId = resThread.body.comment.id | |
443 | ||
444 | const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'reply') | |
445 | const commentId = resComment.body.comment.id | |
446 | ||
447 | await wait(500) | |
448 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence') | |
449 | }) | |
450 | ||
451 | it('Should send a new comment notification after a remote reply on my video', async function () { | |
452 | this.timeout(10000) | |
453 | ||
454 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
455 | const uuid = resVideo.body.video.uuid | |
456 | await waitJobs(servers) | |
457 | ||
458 | { | |
459 | const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment') | |
460 | const threadId = resThread.body.comment.id | |
461 | await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, threadId, 'reply') | |
462 | } | |
463 | ||
464 | await waitJobs(servers) | |
465 | ||
466 | const resThread = await getVideoCommentThreads(servers[0].url, uuid, 0, 5) | |
467 | expect(resThread.body.data).to.have.lengthOf(1) | |
468 | const threadId = resThread.body.data[0].id | |
469 | ||
470 | const resComments = await getVideoThreadComments(servers[0].url, uuid, threadId) | |
471 | const tree = resComments.body as VideoCommentThreadTree | |
472 | ||
473 | expect(tree.children).to.have.lengthOf(1) | |
474 | const commentId = tree.children[0].comment.id | |
475 | ||
476 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence') | |
477 | }) | |
478 | }) | |
479 | ||
480 | describe('Mention notifications', function () { | |
481 | let baseParams: CheckerBaseParams | |
482 | ||
483 | before(async () => { | |
484 | baseParams = { | |
485 | server: servers[0], | |
486 | emails, | |
487 | socketNotifications: userNotifications, | |
488 | token: userAccessToken | |
489 | } | |
490 | ||
491 | await updateMyUser({ | |
492 | url: servers[0].url, | |
493 | accessToken: servers[0].accessToken, | |
494 | displayName: 'super root name' | |
495 | }) | |
496 | ||
497 | await updateMyUser({ | |
498 | url: servers[1].url, | |
499 | accessToken: servers[1].accessToken, | |
500 | displayName: 'super root 2 name' | |
501 | }) | |
502 | }) | |
503 | ||
504 | it('Should not send a new mention comment notification if I mention the video owner', async function () { | |
505 | this.timeout(10000) | |
506 | ||
507 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
508 | const uuid = resVideo.body.video.uuid | |
509 | ||
510 | const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello') | |
511 | const commentId = resComment.body.comment.id | |
512 | ||
513 | await wait(500) | |
514 | await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence') | |
515 | }) | |
516 | ||
517 | it('Should not send a new mention comment notification if I mention myself', async function () { | |
518 | this.timeout(10000) | |
519 | ||
520 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
521 | const uuid = resVideo.body.video.uuid | |
522 | ||
523 | const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, '@user_1 hello') | |
524 | const commentId = resComment.body.comment.id | |
525 | ||
526 | await wait(500) | |
527 | await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence') | |
528 | }) | |
529 | ||
530 | it('Should not send a new mention notification if the account is muted', async function () { | |
531 | this.timeout(10000) | |
532 | ||
533 | await addAccountToAccountBlocklist(servers[0].url, userAccessToken, 'root') | |
534 | ||
535 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
536 | const uuid = resVideo.body.video.uuid | |
537 | ||
538 | const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello') | |
539 | const commentId = resComment.body.comment.id | |
540 | ||
541 | await wait(500) | |
542 | await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence') | |
543 | ||
544 | await removeAccountFromAccountBlocklist(servers[0].url, userAccessToken, 'root') | |
545 | }) | |
546 | ||
547 | it('Should not send a new mention notification if the remote account mention a local account', async function () { | |
548 | this.timeout(20000) | |
549 | ||
550 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
551 | const uuid = resVideo.body.video.uuid | |
552 | ||
553 | await waitJobs(servers) | |
554 | const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, '@user_1 hello') | |
555 | const threadId = resThread.body.comment.id | |
556 | ||
557 | await waitJobs(servers) | |
558 | await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root 2 name', 'absence') | |
559 | }) | |
560 | ||
561 | it('Should send a new mention notification after local comments', async function () { | |
562 | this.timeout(10000) | |
563 | ||
564 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
565 | const uuid = resVideo.body.video.uuid | |
566 | ||
567 | const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello 1') | |
568 | const threadId = resThread.body.comment.id | |
569 | ||
570 | await wait(500) | |
571 | await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root name', 'presence') | |
572 | ||
573 | const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'hello 2 @user_1') | |
574 | const commentId = resComment.body.comment.id | |
575 | ||
576 | await wait(500) | |
577 | await checkCommentMention(baseParams, uuid, commentId, threadId, 'super root name', 'presence') | |
578 | }) | |
579 | ||
580 | it('Should send a new mention notification after remote comments', async function () { | |
581 | this.timeout(20000) | |
582 | ||
583 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
584 | const uuid = resVideo.body.video.uuid | |
585 | ||
586 | await waitJobs(servers) | |
587 | ||
588 | const text1 = `hello @user_1@localhost:${servers[0].port} 1` | |
589 | const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, text1) | |
590 | const server2ThreadId = resThread.body.comment.id | |
591 | ||
592 | await waitJobs(servers) | |
593 | ||
594 | const resThread2 = await getVideoCommentThreads(servers[0].url, uuid, 0, 5) | |
595 | expect(resThread2.body.data).to.have.lengthOf(1) | |
596 | const server1ThreadId = resThread2.body.data[0].id | |
597 | await checkCommentMention(baseParams, uuid, server1ThreadId, server1ThreadId, 'super root 2 name', 'presence') | |
598 | ||
599 | const text2 = `@user_1@localhost:${servers[0].port} hello 2 @root@localhost:${servers[0].port}` | |
600 | await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, server2ThreadId, text2) | |
601 | ||
602 | await waitJobs(servers) | |
603 | ||
604 | const resComments = await getVideoThreadComments(servers[0].url, uuid, server1ThreadId) | |
605 | const tree = resComments.body as VideoCommentThreadTree | |
606 | ||
607 | expect(tree.children).to.have.lengthOf(1) | |
608 | const commentId = tree.children[0].comment.id | |
609 | ||
610 | await checkCommentMention(baseParams, uuid, commentId, server1ThreadId, 'super root 2 name', 'presence') | |
611 | }) | |
612 | }) | |
613 | ||
614 | describe('Video abuse for moderators notification', function () { | |
615 | let baseParams: CheckerBaseParams | |
616 | ||
617 | before(() => { | |
618 | baseParams = { | |
619 | server: servers[0], | |
620 | emails, | |
621 | socketNotifications: adminNotifications, | |
622 | token: servers[0].accessToken | |
623 | } | |
624 | }) | |
625 | ||
626 | it('Should send a notification to moderators on local video abuse', async function () { | |
627 | this.timeout(10000) | |
628 | ||
629 | const name = 'video for abuse ' + uuidv4() | |
630 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name }) | |
631 | const uuid = resVideo.body.video.uuid | |
632 | ||
633 | await reportVideoAbuse(servers[0].url, servers[0].accessToken, uuid, 'super reason') | |
634 | ||
635 | await waitJobs(servers) | |
636 | await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence') | |
637 | }) | |
638 | ||
639 | it('Should send a notification to moderators on remote video abuse', async function () { | |
640 | this.timeout(10000) | |
641 | ||
642 | const name = 'video for abuse ' + uuidv4() | |
643 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name }) | |
644 | const uuid = resVideo.body.video.uuid | |
645 | ||
646 | await waitJobs(servers) | |
647 | ||
648 | await reportVideoAbuse(servers[1].url, servers[1].accessToken, uuid, 'super reason') | |
649 | ||
650 | await waitJobs(servers) | |
651 | await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence') | |
652 | }) | |
653 | }) | |
654 | ||
655 | describe('Video blacklist on my video', function () { | |
656 | let baseParams: CheckerBaseParams | |
657 | ||
658 | before(() => { | |
659 | baseParams = { | |
660 | server: servers[0], | |
661 | emails, | |
662 | socketNotifications: userNotifications, | |
663 | token: userAccessToken | |
664 | } | |
665 | }) | |
666 | ||
667 | it('Should send a notification to video owner on blacklist', async function () { | |
668 | this.timeout(10000) | |
669 | ||
670 | const name = 'video for abuse ' + uuidv4() | |
671 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name }) | |
672 | const uuid = resVideo.body.video.uuid | |
673 | ||
674 | await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid) | |
675 | ||
676 | await waitJobs(servers) | |
677 | await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'blacklist') | |
678 | }) | |
679 | ||
680 | it('Should send a notification to video owner on unblacklist', async function () { | |
681 | this.timeout(10000) | |
682 | ||
683 | const name = 'video for abuse ' + uuidv4() | |
684 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name }) | |
685 | const uuid = resVideo.body.video.uuid | |
686 | ||
687 | await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid) | |
688 | ||
689 | await waitJobs(servers) | |
690 | await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, uuid) | |
691 | await waitJobs(servers) | |
692 | ||
693 | await wait(500) | |
694 | await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'unblacklist') | |
695 | }) | |
696 | }) | |
697 | ||
698 | describe('My video is published', function () { | |
699 | let baseParams: CheckerBaseParams | |
700 | ||
701 | before(() => { | |
702 | baseParams = { | |
703 | server: servers[1], | |
704 | emails, | |
705 | socketNotifications: adminNotificationsServer2, | |
706 | token: servers[1].accessToken | |
707 | } | |
708 | }) | |
709 | ||
710 | it('Should not send a notification if transcoding is not enabled', async function () { | |
711 | this.timeout(10000) | |
712 | ||
713 | const { name, uuid } = await uploadVideoByLocalAccount(servers) | |
714 | await waitJobs(servers) | |
715 | ||
716 | await checkVideoIsPublished(baseParams, name, uuid, 'absence') | |
717 | }) | |
718 | ||
719 | it('Should not send a notification if the wait transcoding is false', async function () { | |
720 | this.timeout(50000) | |
721 | ||
722 | await uploadVideoByRemoteAccount(servers, { waitTranscoding: false }) | |
723 | await waitJobs(servers) | |
724 | ||
725 | const notification = await getLastNotification(servers[0].url, userAccessToken) | |
726 | if (notification) { | |
727 | expect(notification.type).to.not.equal(UserNotificationType.MY_VIDEO_PUBLISHED) | |
728 | } | |
729 | }) | |
730 | ||
731 | it('Should send a notification even if the video is not transcoded in other resolutions', async function () { | |
732 | this.timeout(50000) | |
733 | ||
734 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, { waitTranscoding: true, fixture: 'video_short_240p.mp4' }) | |
735 | await waitJobs(servers) | |
736 | ||
737 | await checkVideoIsPublished(baseParams, name, uuid, 'presence') | |
738 | }) | |
739 | ||
740 | it('Should send a notification with a transcoded video', async function () { | |
741 | this.timeout(50000) | |
742 | ||
743 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, { waitTranscoding: true }) | |
744 | await waitJobs(servers) | |
745 | ||
746 | await checkVideoIsPublished(baseParams, name, uuid, 'presence') | |
747 | }) | |
748 | ||
749 | it('Should send a notification when an imported video is transcoded', async function () { | |
750 | this.timeout(50000) | |
751 | ||
752 | const name = 'video import ' + uuidv4() | |
753 | ||
754 | const attributes = { | |
755 | name, | |
756 | channelId, | |
757 | privacy: VideoPrivacy.PUBLIC, | |
758 | targetUrl: getYoutubeVideoUrl(), | |
759 | waitTranscoding: true | |
760 | } | |
761 | const res = await importVideo(servers[1].url, servers[1].accessToken, attributes) | |
762 | const uuid = res.body.video.uuid | |
763 | ||
764 | await waitJobs(servers) | |
765 | await checkVideoIsPublished(baseParams, name, uuid, 'presence') | |
766 | }) | |
767 | ||
768 | it('Should send a notification when the scheduled update has been proceeded', async function () { | |
769 | this.timeout(70000) | |
770 | ||
771 | // In 2 seconds | |
772 | const updateAt = new Date(new Date().getTime() + 2000) | |
773 | ||
774 | const data = { | |
775 | privacy: VideoPrivacy.PRIVATE, | |
776 | scheduleUpdate: { | |
777 | updateAt: updateAt.toISOString(), | |
778 | privacy: VideoPrivacy.PUBLIC | |
779 | } | |
780 | } | |
781 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) | |
782 | ||
783 | await wait(6000) | |
784 | await checkVideoIsPublished(baseParams, name, uuid, 'presence') | |
785 | }) | |
786 | ||
787 | it('Should not send a notification before the video is published', async function () { | |
788 | this.timeout(20000) | |
789 | ||
790 | const updateAt = new Date(new Date().getTime() + 1000000) | |
791 | ||
792 | const data = { | |
793 | privacy: VideoPrivacy.PRIVATE, | |
794 | scheduleUpdate: { | |
795 | updateAt: updateAt.toISOString(), | |
796 | privacy: VideoPrivacy.PUBLIC | |
797 | } | |
798 | } | |
799 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) | |
800 | ||
801 | await wait(6000) | |
802 | await checkVideoIsPublished(baseParams, name, uuid, 'absence') | |
803 | }) | |
804 | }) | |
805 | ||
806 | describe('My video is imported', function () { | |
807 | let baseParams: CheckerBaseParams | |
808 | ||
809 | before(() => { | |
810 | baseParams = { | |
811 | server: servers[0], | |
812 | emails, | |
813 | socketNotifications: adminNotifications, | |
814 | token: servers[0].accessToken | |
815 | } | |
816 | }) | |
817 | ||
818 | it('Should send a notification when the video import failed', async function () { | |
819 | this.timeout(70000) | |
820 | ||
821 | const name = 'video import ' + uuidv4() | |
822 | ||
823 | const attributes = { | |
824 | name, | |
825 | channelId, | |
826 | privacy: VideoPrivacy.PRIVATE, | |
827 | targetUrl: getBadVideoUrl() | |
828 | } | |
829 | const res = await importVideo(servers[0].url, servers[0].accessToken, attributes) | |
830 | const uuid = res.body.video.uuid | |
831 | ||
832 | await waitJobs(servers) | |
833 | await checkMyVideoImportIsFinished(baseParams, name, uuid, getBadVideoUrl(), false, 'presence') | |
834 | }) | |
835 | ||
836 | it('Should send a notification when the video import succeeded', async function () { | |
837 | this.timeout(70000) | |
838 | ||
839 | const name = 'video import ' + uuidv4() | |
840 | ||
841 | const attributes = { | |
842 | name, | |
843 | channelId, | |
844 | privacy: VideoPrivacy.PRIVATE, | |
845 | targetUrl: getYoutubeVideoUrl() | |
846 | } | |
847 | const res = await importVideo(servers[0].url, servers[0].accessToken, attributes) | |
848 | const uuid = res.body.video.uuid | |
849 | ||
850 | await waitJobs(servers) | |
851 | await checkMyVideoImportIsFinished(baseParams, name, uuid, getYoutubeVideoUrl(), true, 'presence') | |
852 | }) | |
853 | }) | |
854 | ||
855 | describe('New registration', function () { | |
856 | let baseParams: CheckerBaseParams | |
857 | ||
858 | before(() => { | |
859 | baseParams = { | |
860 | server: servers[0], | |
861 | emails, | |
862 | socketNotifications: adminNotifications, | |
863 | token: servers[0].accessToken | |
864 | } | |
865 | }) | |
866 | ||
867 | it('Should send a notification only to moderators when a user registers on the instance', async function () { | |
868 | this.timeout(10000) | |
869 | ||
870 | await registerUser(servers[0].url, 'user_45', 'password') | |
871 | ||
872 | await waitJobs(servers) | |
873 | ||
874 | await checkUserRegistered(baseParams, 'user_45', 'presence') | |
875 | ||
876 | const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } } | |
877 | await checkUserRegistered(immutableAssign(baseParams, userOverride), 'user_45', 'absence') | |
878 | }) | |
879 | }) | |
880 | ||
881 | describe('New instance follows', function () { | |
882 | const instanceIndexServer = new MockInstancesIndex() | |
883 | const config = { | |
884 | followings: { | |
885 | instance: { | |
886 | autoFollowIndex: { | |
887 | indexUrl: 'http://localhost:42100', | |
888 | enabled: true | |
889 | } | |
890 | } | |
891 | } | |
892 | } | |
893 | let baseParams: CheckerBaseParams | |
894 | ||
895 | before(async () => { | |
896 | baseParams = { | |
897 | server: servers[0], | |
898 | emails, | |
899 | socketNotifications: adminNotifications, | |
900 | token: servers[0].accessToken | |
901 | } | |
902 | ||
903 | await instanceIndexServer.initialize() | |
904 | instanceIndexServer.addInstance(servers[1].host) | |
905 | }) | |
906 | ||
907 | it('Should send a notification only to admin when there is a new instance follower', async function () { | |
908 | this.timeout(20000) | |
909 | ||
910 | await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken) | |
911 | ||
912 | await waitJobs(servers) | |
913 | ||
914 | await checkNewInstanceFollower(baseParams, 'localhost:' + servers[2].port, 'presence') | |
915 | ||
916 | const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } } | |
917 | await checkNewInstanceFollower(immutableAssign(baseParams, userOverride), 'localhost:' + servers[2].port, 'absence') | |
918 | }) | |
919 | ||
920 | it('Should send a notification on auto follow back', async function () { | |
921 | this.timeout(40000) | |
922 | ||
923 | await unfollow(servers[2].url, servers[2].accessToken, servers[0]) | |
924 | await waitJobs(servers) | |
925 | ||
926 | const config = { | |
927 | followings: { | |
928 | instance: { | |
929 | autoFollowBack: { enabled: true } | |
930 | } | |
931 | } | |
932 | } | |
933 | await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config) | |
934 | ||
935 | await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken) | |
936 | ||
937 | await waitJobs(servers) | |
938 | ||
939 | const followerHost = servers[0].host | |
940 | const followingHost = servers[2].host | |
941 | await checkAutoInstanceFollowing(baseParams, followerHost, followingHost, 'presence') | |
942 | ||
943 | const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } } | |
944 | await checkAutoInstanceFollowing(immutableAssign(baseParams, userOverride), followerHost, followingHost, 'absence') | |
945 | ||
946 | config.followings.instance.autoFollowBack.enabled = false | |
947 | await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config) | |
948 | await unfollow(servers[0].url, servers[0].accessToken, servers[2]) | |
949 | await unfollow(servers[2].url, servers[2].accessToken, servers[0]) | |
950 | }) | |
951 | ||
952 | it('Should send a notification on auto instances index follow', async function () { | |
953 | this.timeout(30000) | |
954 | await unfollow(servers[0].url, servers[0].accessToken, servers[1]) | |
955 | ||
956 | await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config) | |
957 | ||
958 | await wait(5000) | |
959 | await waitJobs(servers) | |
960 | ||
961 | const followerHost = servers[0].host | |
962 | const followingHost = servers[1].host | |
963 | await checkAutoInstanceFollowing(baseParams, followerHost, followingHost, 'presence') | |
964 | ||
965 | config.followings.instance.autoFollowIndex.enabled = false | |
966 | await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config) | |
967 | await unfollow(servers[0].url, servers[0].accessToken, servers[1]) | |
968 | }) | |
969 | }) | |
970 | ||
971 | describe('New actor follow', function () { | |
972 | let baseParams: CheckerBaseParams | |
973 | const myChannelName = 'super channel name' | |
974 | const myUserName = 'super user name' | |
975 | ||
976 | before(async () => { | |
977 | baseParams = { | |
978 | server: servers[0], | |
979 | emails, | |
980 | socketNotifications: userNotifications, | |
981 | token: userAccessToken | |
982 | } | |
983 | ||
984 | await updateMyUser({ | |
985 | url: servers[0].url, | |
986 | accessToken: servers[0].accessToken, | |
987 | displayName: 'super root name' | |
988 | }) | |
989 | ||
990 | await updateMyUser({ | |
991 | url: servers[0].url, | |
992 | accessToken: userAccessToken, | |
993 | displayName: myUserName | |
994 | }) | |
995 | ||
996 | await updateMyUser({ | |
997 | url: servers[1].url, | |
998 | accessToken: servers[1].accessToken, | |
999 | displayName: 'super root 2 name' | |
1000 | }) | |
1001 | ||
1002 | await updateVideoChannel(servers[0].url, userAccessToken, 'user_1_channel', { displayName: myChannelName }) | |
1003 | }) | |
1004 | ||
1005 | it('Should notify when a local channel is following one of our channel', async function () { | |
1006 | this.timeout(10000) | |
1007 | ||
1008 | await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port) | |
1009 | await waitJobs(servers) | |
1010 | ||
1011 | await checkNewActorFollow(baseParams, 'channel', 'root', 'super root name', myChannelName, 'presence') | |
1012 | ||
1013 | await removeUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port) | |
1014 | }) | |
1015 | ||
1016 | it('Should notify when a remote channel is following one of our channel', async function () { | |
1017 | this.timeout(10000) | |
1018 | ||
1019 | await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port) | |
1020 | await waitJobs(servers) | |
1021 | ||
1022 | await checkNewActorFollow(baseParams, 'channel', 'root', 'super root 2 name', myChannelName, 'presence') | |
1023 | ||
1024 | await removeUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port) | |
1025 | }) | |
1026 | ||
1027 | // PeerTube does not support accout -> account follows | |
1028 | // it('Should notify when a local account is following one of our channel', async function () { | |
1029 | // this.timeout(10000) | |
1030 | // | |
1031 | // await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1@localhost:' + servers[0].port) | |
1032 | // | |
1033 | // await waitJobs(servers) | |
1034 | // | |
1035 | // await checkNewActorFollow(baseParams, 'account', 'root', 'super root name', myUserName, 'presence') | |
1036 | // }) | |
1037 | ||
1038 | // it('Should notify when a remote account is following one of our channel', async function () { | |
1039 | // this.timeout(10000) | |
1040 | // | |
1041 | // await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1@localhost:' + servers[0].port) | |
1042 | // | |
1043 | // await waitJobs(servers) | |
1044 | // | |
1045 | // await checkNewActorFollow(baseParams, 'account', 'root', 'super root 2 name', myUserName, 'presence') | |
1046 | // }) | |
1047 | }) | |
1048 | ||
1049 | describe('Video-related notifications when video auto-blacklist is enabled', function () { | |
1050 | let userBaseParams: CheckerBaseParams | |
1051 | let adminBaseParamsServer1: CheckerBaseParams | |
1052 | let adminBaseParamsServer2: CheckerBaseParams | |
1053 | let videoUUID: string | |
1054 | let videoName: string | |
1055 | let currentCustomConfig: CustomConfig | |
1056 | ||
1057 | before(async () => { | |
1058 | ||
1059 | adminBaseParamsServer1 = { | |
1060 | server: servers[0], | |
1061 | emails, | |
1062 | socketNotifications: adminNotifications, | |
1063 | token: servers[0].accessToken | |
1064 | } | |
1065 | ||
1066 | adminBaseParamsServer2 = { | |
1067 | server: servers[1], | |
1068 | emails, | |
1069 | socketNotifications: adminNotificationsServer2, | |
1070 | token: servers[1].accessToken | |
1071 | } | |
1072 | ||
1073 | userBaseParams = { | |
1074 | server: servers[0], | |
1075 | emails, | |
1076 | socketNotifications: userNotifications, | |
1077 | token: userAccessToken | |
1078 | } | |
1079 | ||
1080 | const resCustomConfig = await getCustomConfig(servers[0].url, servers[0].accessToken) | |
1081 | currentCustomConfig = resCustomConfig.body | |
1082 | const autoBlacklistTestsCustomConfig = immutableAssign(currentCustomConfig, { | |
1083 | autoBlacklist: { | |
1084 | videos: { | |
1085 | ofUsers: { | |
1086 | enabled: true | |
1087 | } | |
1088 | } | |
1089 | } | |
1090 | }) | |
1091 | // enable transcoding otherwise own publish notification after transcoding not expected | |
1092 | autoBlacklistTestsCustomConfig.transcoding.enabled = true | |
1093 | await updateCustomConfig(servers[0].url, servers[0].accessToken, autoBlacklistTestsCustomConfig) | |
1094 | ||
1095 | await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port) | |
1096 | await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port) | |
1097 | ||
1098 | }) | |
1099 | ||
1100 | it('Should send notification to moderators on new video with auto-blacklist', async function () { | |
1101 | this.timeout(20000) | |
1102 | ||
1103 | videoName = 'video with auto-blacklist ' + uuidv4() | |
1104 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: videoName }) | |
1105 | videoUUID = resVideo.body.video.uuid | |
1106 | ||
1107 | await waitJobs(servers) | |
1108 | await checkVideoAutoBlacklistForModerators(adminBaseParamsServer1, videoUUID, videoName, 'presence') | |
1109 | }) | |
1110 | ||
1111 | it('Should not send video publish notification if auto-blacklisted', async function () { | |
1112 | await checkVideoIsPublished(userBaseParams, videoName, videoUUID, 'absence') | |
1113 | }) | |
1114 | ||
1115 | it('Should not send a local user subscription notification if auto-blacklisted', async function () { | |
1116 | await checkNewVideoFromSubscription(adminBaseParamsServer1, videoName, videoUUID, 'absence') | |
1117 | }) | |
1118 | ||
1119 | it('Should not send a remote user subscription notification if auto-blacklisted', async function () { | |
1120 | await checkNewVideoFromSubscription(adminBaseParamsServer2, videoName, videoUUID, 'absence') | |
1121 | }) | |
1122 | ||
1123 | it('Should send video published and unblacklist after video unblacklisted', async function () { | |
1124 | this.timeout(20000) | |
1125 | ||
1126 | await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoUUID) | |
1127 | ||
1128 | await waitJobs(servers) | |
1129 | ||
1130 | // FIXME: Can't test as two notifications sent to same user and util only checks last one | |
1131 | // One notification might be better anyways | |
1132 | // await checkNewBlacklistOnMyVideo(userBaseParams, videoUUID, videoName, 'unblacklist') | |
1133 | // await checkVideoIsPublished(userBaseParams, videoName, videoUUID, 'presence') | |
1134 | }) | |
1135 | ||
1136 | it('Should send a local user subscription notification after removed from blacklist', async function () { | |
1137 | await checkNewVideoFromSubscription(adminBaseParamsServer1, videoName, videoUUID, 'presence') | |
1138 | }) | |
1139 | ||
1140 | it('Should send a remote user subscription notification after removed from blacklist', async function () { | |
1141 | await checkNewVideoFromSubscription(adminBaseParamsServer2, videoName, videoUUID, 'presence') | |
1142 | }) | |
1143 | ||
1144 | it('Should send unblacklist but not published/subscription notes after unblacklisted if scheduled update pending', async function () { | |
1145 | this.timeout(20000) | |
1146 | ||
1147 | const updateAt = new Date(new Date().getTime() + 1000000) | |
1148 | ||
1149 | const name = 'video with auto-blacklist and future schedule ' + uuidv4() | |
1150 | ||
1151 | const data = { | |
1152 | name, | |
1153 | privacy: VideoPrivacy.PRIVATE, | |
1154 | scheduleUpdate: { | |
1155 | updateAt: updateAt.toISOString(), | |
1156 | privacy: VideoPrivacy.PUBLIC | |
1157 | } | |
1158 | } | |
1159 | ||
1160 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, data) | |
1161 | const uuid = resVideo.body.video.uuid | |
1162 | ||
1163 | await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, uuid) | |
1164 | ||
1165 | await waitJobs(servers) | |
1166 | await checkNewBlacklistOnMyVideo(userBaseParams, uuid, name, 'unblacklist') | |
1167 | ||
1168 | // FIXME: Can't test absence as two notifications sent to same user and util only checks last one | |
1169 | // One notification might be better anyways | |
1170 | // await checkVideoIsPublished(userBaseParams, name, uuid, 'absence') | |
1171 | ||
1172 | await checkNewVideoFromSubscription(adminBaseParamsServer1, name, uuid, 'absence') | |
1173 | await checkNewVideoFromSubscription(adminBaseParamsServer2, name, uuid, 'absence') | |
1174 | }) | |
1175 | ||
1176 | it('Should not send publish/subscription notifications after scheduled update if video still auto-blacklisted', async function () { | |
1177 | this.timeout(20000) | |
1178 | ||
1179 | // In 2 seconds | |
1180 | const updateAt = new Date(new Date().getTime() + 2000) | |
1181 | ||
1182 | const name = 'video with schedule done and still auto-blacklisted ' + uuidv4() | |
1183 | ||
1184 | const data = { | |
1185 | name, | |
1186 | privacy: VideoPrivacy.PRIVATE, | |
1187 | scheduleUpdate: { | |
1188 | updateAt: updateAt.toISOString(), | |
1189 | privacy: VideoPrivacy.PUBLIC | |
1190 | } | |
1191 | } | |
1192 | ||
1193 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, data) | |
1194 | const uuid = resVideo.body.video.uuid | |
1195 | ||
1196 | await wait(6000) | |
1197 | await checkVideoIsPublished(userBaseParams, name, uuid, 'absence') | |
1198 | await checkNewVideoFromSubscription(adminBaseParamsServer1, name, uuid, 'absence') | |
1199 | await checkNewVideoFromSubscription(adminBaseParamsServer2, name, uuid, 'absence') | |
1200 | }) | |
1201 | ||
1202 | it('Should not send a notification to moderators on new video without auto-blacklist', async function () { | |
1203 | this.timeout(20000) | |
1204 | ||
1205 | const name = 'video without auto-blacklist ' + uuidv4() | |
1206 | ||
1207 | // admin with blacklist right will not be auto-blacklisted | |
1208 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name }) | |
1209 | const uuid = resVideo.body.video.uuid | |
1210 | ||
1211 | await waitJobs(servers) | |
1212 | await checkVideoAutoBlacklistForModerators(adminBaseParamsServer1, uuid, name, 'absence') | |
1213 | }) | |
1214 | ||
1215 | after(async () => { | |
1216 | await updateCustomConfig(servers[0].url, servers[0].accessToken, currentCustomConfig) | |
1217 | ||
1218 | await removeUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port) | |
1219 | await removeUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port) | |
1220 | }) | |
1221 | }) | |
1222 | ||
1223 | describe('Mark as read', function () { | |
1224 | it('Should mark as read some notifications', async function () { | |
1225 | const res = await getUserNotifications(servers[0].url, userAccessToken, 2, 3) | |
1226 | const ids = res.body.data.map(n => n.id) | |
1227 | ||
1228 | await markAsReadNotifications(servers[0].url, userAccessToken, ids) | |
1229 | }) | |
1230 | ||
1231 | it('Should have the notifications marked as read', async function () { | |
1232 | const res = await getUserNotifications(servers[0].url, userAccessToken, 0, 10) | |
1233 | ||
1234 | const notifications = res.body.data as UserNotification[] | |
1235 | expect(notifications[0].read).to.be.false | |
1236 | expect(notifications[1].read).to.be.false | |
1237 | expect(notifications[2].read).to.be.true | |
1238 | expect(notifications[3].read).to.be.true | |
1239 | expect(notifications[4].read).to.be.true | |
1240 | expect(notifications[5].read).to.be.false | |
1241 | }) | |
1242 | ||
1243 | it('Should only list read notifications', async function () { | |
1244 | const res = await getUserNotifications(servers[0].url, userAccessToken, 0, 10, false) | |
1245 | ||
1246 | const notifications = res.body.data as UserNotification[] | |
1247 | for (const notification of notifications) { | |
1248 | expect(notification.read).to.be.true | |
1249 | } | |
1250 | }) | |
1251 | ||
1252 | it('Should only list unread notifications', async function () { | |
1253 | const res = await getUserNotifications(servers[0].url, userAccessToken, 0, 10, true) | |
1254 | ||
1255 | const notifications = res.body.data as UserNotification[] | |
1256 | for (const notification of notifications) { | |
1257 | expect(notification.read).to.be.false | |
1258 | } | |
1259 | }) | |
1260 | ||
1261 | it('Should mark as read all notifications', async function () { | |
1262 | await markAsReadAllNotifications(servers[0].url, userAccessToken) | |
1263 | ||
1264 | const res = await getUserNotifications(servers[0].url, userAccessToken, 0, 10, true) | |
1265 | ||
1266 | expect(res.body.total).to.equal(0) | |
1267 | expect(res.body.data).to.have.lengthOf(0) | |
1268 | }) | |
1269 | }) | |
1270 | ||
1271 | describe('Notification settings', function () { | |
1272 | let baseParams: CheckerBaseParams | |
1273 | ||
1274 | before(() => { | |
1275 | baseParams = { | |
1276 | server: servers[0], | |
1277 | emails, | |
1278 | socketNotifications: userNotifications, | |
1279 | token: userAccessToken | |
1280 | } | |
1281 | }) | |
1282 | ||
1283 | it('Should not have notifications', async function () { | |
1284 | this.timeout(20000) | |
1285 | ||
1286 | await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, { | |
1287 | newVideoFromSubscription: UserNotificationSettingValue.NONE | |
1288 | })) | |
1289 | ||
1290 | { | |
1291 | const res = await getMyUserInformation(servers[0].url, userAccessToken) | |
1292 | const info = res.body as User | |
1293 | expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.NONE) | |
1294 | } | |
1295 | ||
1296 | const { name, uuid } = await uploadVideoByLocalAccount(servers) | |
1297 | ||
1298 | const check = { web: true, mail: true } | |
1299 | await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence') | |
1300 | }) | |
1301 | ||
1302 | it('Should only have web notifications', async function () { | |
1303 | this.timeout(20000) | |
1304 | ||
1305 | await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, { | |
1306 | newVideoFromSubscription: UserNotificationSettingValue.WEB | |
1307 | })) | |
1308 | ||
1309 | { | |
1310 | const res = await getMyUserInformation(servers[0].url, userAccessToken) | |
1311 | const info = res.body as User | |
1312 | expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB) | |
1313 | } | |
1314 | ||
1315 | const { name, uuid } = await uploadVideoByLocalAccount(servers) | |
1316 | ||
1317 | { | |
1318 | const check = { mail: true, web: false } | |
1319 | await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence') | |
1320 | } | |
1321 | ||
1322 | { | |
1323 | const check = { mail: false, web: true } | |
1324 | await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence') | |
1325 | } | |
1326 | }) | |
1327 | ||
1328 | it('Should only have mail notifications', async function () { | |
1329 | this.timeout(20000) | |
1330 | ||
1331 | await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, { | |
1332 | newVideoFromSubscription: UserNotificationSettingValue.EMAIL | |
1333 | })) | |
1334 | ||
1335 | { | |
1336 | const res = await getMyUserInformation(servers[0].url, userAccessToken) | |
1337 | const info = res.body as User | |
1338 | expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.EMAIL) | |
1339 | } | |
1340 | ||
1341 | const { name, uuid } = await uploadVideoByLocalAccount(servers) | |
1342 | ||
1343 | { | |
1344 | const check = { mail: false, web: true } | |
1345 | await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence') | |
1346 | } | |
1347 | ||
1348 | { | |
1349 | const check = { mail: true, web: false } | |
1350 | await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence') | |
1351 | } | |
1352 | }) | |
1353 | ||
1354 | it('Should have email and web notifications', async function () { | |
1355 | this.timeout(20000) | |
1356 | ||
1357 | await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, { | |
1358 | newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL | |
1359 | })) | |
1360 | ||
1361 | { | |
1362 | const res = await getMyUserInformation(servers[0].url, userAccessToken) | |
1363 | const info = res.body as User | |
1364 | expect(info.notificationSettings.newVideoFromSubscription).to.equal( | |
1365 | UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL | |
1366 | ) | |
1367 | } | |
1368 | ||
1369 | const { name, uuid } = await uploadVideoByLocalAccount(servers) | |
1370 | ||
1371 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') | |
1372 | }) | |
1373 | }) | |
1374 | ||
1375 | after(async function () { | |
1376 | MockSmtpServer.Instance.kill() | |
1377 | ||
1378 | await cleanupTests(servers) | |
1379 | }) | |
1380 | }) |