]>
Commit | Line | Data |
---|---|---|
cef534ed C |
1 | /* tslint:disable:no-unused-expression */ |
2 | ||
3 | import * as chai from 'chai' | |
4 | import 'mocha' | |
5 | import { | |
6 | addVideoToBlacklist, | |
7 | createUser, | |
8 | doubleFollow, | |
9 | flushAndRunMultipleServers, | |
10 | flushTests, | |
11 | getMyUserInformation, | |
12 | immutableAssign, | |
f7cc67b4 | 13 | registerUser, |
cef534ed C |
14 | removeVideoFromBlacklist, |
15 | reportVideoAbuse, | |
f7cc67b4 | 16 | updateMyUser, |
cef534ed | 17 | updateVideo, |
f7cc67b4 | 18 | updateVideoChannel, |
cef534ed C |
19 | userLogin, |
20 | wait | |
21 | } from '../../../../shared/utils' | |
22 | import { killallServers, ServerInfo, uploadVideo } from '../../../../shared/utils/index' | |
23 | import { setAccessTokensToServers } from '../../../../shared/utils/users/login' | |
24 | import { waitJobs } from '../../../../shared/utils/server/jobs' | |
25 | import { getUserNotificationSocket } from '../../../../shared/utils/socket/socket-io' | |
26 | import { | |
f7cc67b4 | 27 | checkCommentMention, |
cef534ed | 28 | CheckerBaseParams, |
f7cc67b4 C |
29 | checkMyVideoImportIsFinished, |
30 | checkNewActorFollow, | |
cef534ed C |
31 | checkNewBlacklistOnMyVideo, |
32 | checkNewCommentOnMyVideo, | |
33 | checkNewVideoAbuseForModerators, | |
34 | checkNewVideoFromSubscription, | |
f7cc67b4 C |
35 | checkUserRegistered, |
36 | checkVideoIsPublished, | |
cef534ed C |
37 | getLastNotification, |
38 | getUserNotifications, | |
39 | markAsReadNotifications, | |
2f1548fd C |
40 | updateMyNotificationSettings, |
41 | markAsReadAllNotifications | |
cef534ed | 42 | } from '../../../../shared/utils/users/user-notifications' |
dc133480 C |
43 | import { |
44 | User, | |
45 | UserNotification, | |
46 | UserNotificationSetting, | |
47 | UserNotificationSettingValue, | |
48 | UserNotificationType | |
49 | } from '../../../../shared/models/users' | |
cef534ed | 50 | import { MockSmtpServer } from '../../../../shared/utils/miscs/email' |
f7cc67b4 | 51 | import { addUserSubscription, removeUserSubscription } from '../../../../shared/utils/users/user-subscriptions' |
cef534ed | 52 | import { VideoPrivacy } from '../../../../shared/models/videos' |
f7cc67b4 | 53 | import { getBadVideoUrl, getYoutubeVideoUrl, importVideo } from '../../../../shared/utils/videos/video-imports' |
cef534ed | 54 | import { addVideoCommentReply, addVideoCommentThread } from '../../../../shared/utils/videos/video-comments' |
dc133480 C |
55 | import * as uuidv4 from 'uuid/v4' |
56 | import { addAccountToAccountBlocklist, removeAccountFromAccountBlocklist } from '../../../../shared/utils/users/blocklist' | |
cef534ed C |
57 | |
58 | const expect = chai.expect | |
59 | ||
dc133480 C |
60 | async function uploadVideoByRemoteAccount (servers: ServerInfo[], additionalParams: any = {}) { |
61 | const name = 'remote video ' + uuidv4() | |
62 | ||
63 | const data = Object.assign({ name }, additionalParams) | |
cef534ed C |
64 | const res = await uploadVideo(servers[ 1 ].url, servers[ 1 ].accessToken, data) |
65 | ||
66 | await waitJobs(servers) | |
67 | ||
dc133480 | 68 | return { uuid: res.body.video.uuid, name } |
cef534ed C |
69 | } |
70 | ||
dc133480 C |
71 | async function uploadVideoByLocalAccount (servers: ServerInfo[], additionalParams: any = {}) { |
72 | const name = 'local video ' + uuidv4() | |
73 | ||
74 | const data = Object.assign({ name }, additionalParams) | |
cef534ed C |
75 | const res = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, data) |
76 | ||
77 | await waitJobs(servers) | |
78 | ||
dc133480 | 79 | return { uuid: res.body.video.uuid, name } |
cef534ed C |
80 | } |
81 | ||
6c32d302 | 82 | describe('Test users notifications', function () { |
cef534ed C |
83 | let servers: ServerInfo[] = [] |
84 | let userAccessToken: string | |
85 | let userNotifications: UserNotification[] = [] | |
86 | let adminNotifications: UserNotification[] = [] | |
dc133480 | 87 | let adminNotificationsServer2: UserNotification[] = [] |
cef534ed | 88 | const emails: object[] = [] |
dc133480 C |
89 | let channelId: number |
90 | ||
91 | const allNotificationSettings: UserNotificationSetting = { | |
2f1548fd C |
92 | newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, |
93 | newCommentOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
94 | videoAbuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
95 | blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
96 | myVideoImportFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
97 | myVideoPublished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
98 | commentMention: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
99 | newFollow: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, | |
100 | newUserRegistration: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL | |
dc133480 | 101 | } |
cef534ed C |
102 | |
103 | before(async function () { | |
104 | this.timeout(120000) | |
105 | ||
106 | await MockSmtpServer.Instance.collectEmails(emails) | |
107 | ||
108 | await flushTests() | |
109 | ||
110 | const overrideConfig = { | |
111 | smtp: { | |
112 | hostname: 'localhost' | |
113 | } | |
114 | } | |
115 | servers = await flushAndRunMultipleServers(2, overrideConfig) | |
116 | ||
117 | // Get the access tokens | |
118 | await setAccessTokensToServers(servers) | |
119 | ||
120 | // Server 1 and server 2 follow each other | |
121 | await doubleFollow(servers[0], servers[1]) | |
122 | ||
123 | await waitJobs(servers) | |
124 | ||
125 | const user = { | |
126 | username: 'user_1', | |
127 | password: 'super password' | |
128 | } | |
129 | await createUser(servers[0].url, servers[0].accessToken, user.username, user.password, 10 * 1000 * 1000) | |
130 | userAccessToken = await userLogin(servers[0], user) | |
131 | ||
dc133480 C |
132 | await updateMyNotificationSettings(servers[0].url, userAccessToken, allNotificationSettings) |
133 | await updateMyNotificationSettings(servers[0].url, servers[0].accessToken, allNotificationSettings) | |
134 | await updateMyNotificationSettings(servers[1].url, servers[1].accessToken, allNotificationSettings) | |
cef534ed C |
135 | |
136 | { | |
137 | const socket = getUserNotificationSocket(servers[ 0 ].url, userAccessToken) | |
138 | socket.on('new-notification', n => userNotifications.push(n)) | |
139 | } | |
140 | { | |
141 | const socket = getUserNotificationSocket(servers[ 0 ].url, servers[0].accessToken) | |
142 | socket.on('new-notification', n => adminNotifications.push(n)) | |
143 | } | |
dc133480 C |
144 | { |
145 | const socket = getUserNotificationSocket(servers[ 1 ].url, servers[1].accessToken) | |
146 | socket.on('new-notification', n => adminNotificationsServer2.push(n)) | |
147 | } | |
148 | ||
149 | { | |
150 | const resChannel = await getMyUserInformation(servers[0].url, servers[0].accessToken) | |
151 | channelId = resChannel.body.videoChannels[0].id | |
152 | } | |
cef534ed C |
153 | }) |
154 | ||
155 | describe('New video from my subscription notification', function () { | |
156 | let baseParams: CheckerBaseParams | |
157 | ||
158 | before(() => { | |
159 | baseParams = { | |
160 | server: servers[0], | |
161 | emails, | |
162 | socketNotifications: userNotifications, | |
163 | token: userAccessToken | |
164 | } | |
165 | }) | |
166 | ||
167 | it('Should not send notifications if the user does not follow the video publisher', async function () { | |
f7effe8d JM |
168 | this.timeout(10000) |
169 | ||
dc133480 | 170 | await uploadVideoByLocalAccount(servers) |
cef534ed C |
171 | |
172 | const notification = await getLastNotification(servers[ 0 ].url, userAccessToken) | |
173 | expect(notification).to.be.undefined | |
174 | ||
175 | expect(emails).to.have.lengthOf(0) | |
176 | expect(userNotifications).to.have.lengthOf(0) | |
177 | }) | |
178 | ||
179 | it('Should send a new video notification if the user follows the local video publisher', async function () { | |
89ada4e2 | 180 | this.timeout(15000) |
2f1548fd | 181 | |
cef534ed | 182 | await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:9001') |
2f1548fd | 183 | await waitJobs(servers) |
cef534ed | 184 | |
dc133480 C |
185 | const { name, uuid } = await uploadVideoByLocalAccount(servers) |
186 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') | |
cef534ed C |
187 | }) |
188 | ||
189 | it('Should send a new video notification from a remote account', async function () { | |
190 | this.timeout(50000) // Server 2 has transcoding enabled | |
191 | ||
192 | await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:9002') | |
2f1548fd | 193 | await waitJobs(servers) |
cef534ed | 194 | |
dc133480 C |
195 | const { name, uuid } = await uploadVideoByRemoteAccount(servers) |
196 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') | |
cef534ed C |
197 | }) |
198 | ||
199 | it('Should send a new video notification on a scheduled publication', async function () { | |
200 | this.timeout(20000) | |
201 | ||
cef534ed C |
202 | // In 2 seconds |
203 | let updateAt = new Date(new Date().getTime() + 2000) | |
204 | ||
205 | const data = { | |
206 | privacy: VideoPrivacy.PRIVATE, | |
207 | scheduleUpdate: { | |
208 | updateAt: updateAt.toISOString(), | |
209 | privacy: VideoPrivacy.PUBLIC | |
210 | } | |
211 | } | |
dc133480 | 212 | const { name, uuid } = await uploadVideoByLocalAccount(servers, data) |
cef534ed C |
213 | |
214 | await wait(6000) | |
dc133480 | 215 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') |
cef534ed C |
216 | }) |
217 | ||
218 | it('Should send a new video notification on a remote scheduled publication', async function () { | |
9a18a625 | 219 | this.timeout(50000) |
cef534ed | 220 | |
cef534ed C |
221 | // In 2 seconds |
222 | let updateAt = new Date(new Date().getTime() + 2000) | |
223 | ||
224 | const data = { | |
225 | privacy: VideoPrivacy.PRIVATE, | |
226 | scheduleUpdate: { | |
227 | updateAt: updateAt.toISOString(), | |
228 | privacy: VideoPrivacy.PUBLIC | |
229 | } | |
230 | } | |
dc133480 | 231 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) |
e8d246d5 | 232 | await waitJobs(servers) |
cef534ed C |
233 | |
234 | await wait(6000) | |
dc133480 | 235 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') |
cef534ed C |
236 | }) |
237 | ||
238 | it('Should not send a notification before the video is published', async function () { | |
239 | this.timeout(20000) | |
240 | ||
9a18a625 | 241 | let updateAt = new Date(new Date().getTime() + 1000000) |
cef534ed C |
242 | |
243 | const data = { | |
244 | privacy: VideoPrivacy.PRIVATE, | |
245 | scheduleUpdate: { | |
246 | updateAt: updateAt.toISOString(), | |
247 | privacy: VideoPrivacy.PUBLIC | |
248 | } | |
249 | } | |
dc133480 | 250 | const { name, uuid } = await uploadVideoByLocalAccount(servers, data) |
cef534ed C |
251 | |
252 | await wait(6000) | |
dc133480 | 253 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') |
cef534ed C |
254 | }) |
255 | ||
256 | it('Should send a new video notification when a video becomes public', async function () { | |
257 | this.timeout(10000) | |
258 | ||
cef534ed | 259 | const data = { privacy: VideoPrivacy.PRIVATE } |
dc133480 | 260 | const { name, uuid } = await uploadVideoByLocalAccount(servers, data) |
cef534ed | 261 | |
dc133480 | 262 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') |
cef534ed C |
263 | |
264 | await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.PUBLIC }) | |
265 | ||
266 | await wait(500) | |
dc133480 | 267 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') |
cef534ed C |
268 | }) |
269 | ||
270 | it('Should send a new video notification when a remote video becomes public', async function () { | |
271 | this.timeout(20000) | |
272 | ||
cef534ed | 273 | const data = { privacy: VideoPrivacy.PRIVATE } |
dc133480 | 274 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) |
cef534ed | 275 | |
dc133480 | 276 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') |
cef534ed C |
277 | |
278 | await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.PUBLIC }) | |
279 | ||
280 | await waitJobs(servers) | |
dc133480 | 281 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') |
cef534ed C |
282 | }) |
283 | ||
284 | it('Should not send a new video notification when a video becomes unlisted', async function () { | |
285 | this.timeout(20000) | |
286 | ||
cef534ed | 287 | const data = { privacy: VideoPrivacy.PRIVATE } |
dc133480 | 288 | const { name, uuid } = await uploadVideoByLocalAccount(servers, data) |
cef534ed C |
289 | |
290 | await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED }) | |
291 | ||
dc133480 | 292 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') |
cef534ed C |
293 | }) |
294 | ||
295 | it('Should not send a new video notification when a remote video becomes unlisted', async function () { | |
296 | this.timeout(20000) | |
297 | ||
cef534ed | 298 | const data = { privacy: VideoPrivacy.PRIVATE } |
dc133480 | 299 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) |
cef534ed C |
300 | |
301 | await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED }) | |
302 | ||
303 | await waitJobs(servers) | |
dc133480 | 304 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') |
cef534ed C |
305 | }) |
306 | ||
307 | it('Should send a new video notification after a video import', async function () { | |
308 | this.timeout(30000) | |
309 | ||
dc133480 | 310 | const name = 'video import ' + uuidv4() |
cef534ed C |
311 | |
312 | const attributes = { | |
dc133480 | 313 | name, |
cef534ed C |
314 | channelId, |
315 | privacy: VideoPrivacy.PUBLIC, | |
316 | targetUrl: getYoutubeVideoUrl() | |
317 | } | |
318 | const res = await importVideo(servers[0].url, servers[0].accessToken, attributes) | |
319 | const uuid = res.body.video.uuid | |
320 | ||
321 | await waitJobs(servers) | |
322 | ||
dc133480 | 323 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') |
cef534ed C |
324 | }) |
325 | }) | |
326 | ||
327 | describe('Comment on my video notifications', function () { | |
328 | let baseParams: CheckerBaseParams | |
329 | ||
330 | before(() => { | |
331 | baseParams = { | |
332 | server: servers[0], | |
333 | emails, | |
334 | socketNotifications: userNotifications, | |
335 | token: userAccessToken | |
336 | } | |
337 | }) | |
338 | ||
339 | it('Should not send a new comment notification after a comment on another video', async function () { | |
340 | this.timeout(10000) | |
341 | ||
342 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
343 | const uuid = resVideo.body.video.uuid | |
344 | ||
345 | const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment') | |
346 | const commentId = resComment.body.comment.id | |
347 | ||
348 | await wait(500) | |
349 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence') | |
350 | }) | |
351 | ||
352 | it('Should not send a new comment notification if I comment my own video', async function () { | |
353 | this.timeout(10000) | |
354 | ||
355 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
356 | const uuid = resVideo.body.video.uuid | |
357 | ||
358 | const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, 'comment') | |
359 | const commentId = resComment.body.comment.id | |
360 | ||
361 | await wait(500) | |
362 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence') | |
363 | }) | |
364 | ||
dc133480 C |
365 | it('Should not send a new comment notification if the account is muted', async function () { |
366 | this.timeout(10000) | |
367 | ||
368 | await addAccountToAccountBlocklist(servers[ 0 ].url, userAccessToken, 'root') | |
369 | ||
370 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
371 | const uuid = resVideo.body.video.uuid | |
372 | ||
373 | const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment') | |
374 | const commentId = resComment.body.comment.id | |
375 | ||
376 | await wait(500) | |
377 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence') | |
378 | ||
379 | await removeAccountFromAccountBlocklist(servers[ 0 ].url, userAccessToken, 'root') | |
380 | }) | |
381 | ||
cef534ed C |
382 | it('Should send a new comment notification after a local comment on my video', async function () { |
383 | this.timeout(10000) | |
384 | ||
385 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
386 | const uuid = resVideo.body.video.uuid | |
387 | ||
388 | const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment') | |
389 | const commentId = resComment.body.comment.id | |
390 | ||
391 | await wait(500) | |
392 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence') | |
393 | }) | |
394 | ||
395 | it('Should send a new comment notification after a remote comment on my video', async function () { | |
396 | this.timeout(10000) | |
397 | ||
398 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
399 | const uuid = resVideo.body.video.uuid | |
400 | ||
401 | await waitJobs(servers) | |
402 | ||
403 | const resComment = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment') | |
404 | const commentId = resComment.body.comment.id | |
405 | ||
406 | await waitJobs(servers) | |
407 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence') | |
408 | }) | |
409 | ||
410 | it('Should send a new comment notification after a local reply on my video', async function () { | |
411 | this.timeout(10000) | |
412 | ||
413 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
414 | const uuid = resVideo.body.video.uuid | |
415 | ||
416 | const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment') | |
417 | const threadId = resThread.body.comment.id | |
418 | ||
419 | const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'reply') | |
420 | const commentId = resComment.body.comment.id | |
421 | ||
422 | await wait(500) | |
423 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence') | |
424 | }) | |
425 | ||
426 | it('Should send a new comment notification after a remote reply on my video', async function () { | |
427 | this.timeout(10000) | |
428 | ||
429 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
430 | const uuid = resVideo.body.video.uuid | |
431 | await waitJobs(servers) | |
432 | ||
433 | const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment') | |
434 | const threadId = resThread.body.comment.id | |
435 | ||
436 | const resComment = await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, threadId, 'reply') | |
437 | const commentId = resComment.body.comment.id | |
438 | ||
439 | await waitJobs(servers) | |
440 | await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence') | |
441 | }) | |
442 | }) | |
443 | ||
f7cc67b4 C |
444 | describe('Mention notifications', function () { |
445 | let baseParams: CheckerBaseParams | |
446 | ||
447 | before(async () => { | |
448 | baseParams = { | |
449 | server: servers[0], | |
450 | emails, | |
451 | socketNotifications: userNotifications, | |
452 | token: userAccessToken | |
453 | } | |
454 | ||
455 | await updateMyUser({ | |
456 | url: servers[0].url, | |
457 | accessToken: servers[0].accessToken, | |
458 | displayName: 'super root name' | |
459 | }) | |
460 | ||
461 | await updateMyUser({ | |
462 | url: servers[1].url, | |
463 | accessToken: servers[1].accessToken, | |
464 | displayName: 'super root 2 name' | |
465 | }) | |
466 | }) | |
467 | ||
468 | it('Should not send a new mention comment notification if I mention the video owner', async function () { | |
469 | this.timeout(10000) | |
470 | ||
471 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' }) | |
472 | const uuid = resVideo.body.video.uuid | |
473 | ||
474 | const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello') | |
475 | const commentId = resComment.body.comment.id | |
476 | ||
477 | await wait(500) | |
478 | await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence') | |
479 | }) | |
480 | ||
481 | it('Should not send a new mention comment notification if I mention myself', async function () { | |
482 | this.timeout(10000) | |
483 | ||
484 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
485 | const uuid = resVideo.body.video.uuid | |
486 | ||
487 | const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, '@user_1 hello') | |
488 | const commentId = resComment.body.comment.id | |
489 | ||
490 | await wait(500) | |
491 | await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence') | |
492 | }) | |
493 | ||
494 | it('Should not send a new mention notification if the account is muted', async function () { | |
495 | this.timeout(10000) | |
496 | ||
497 | await addAccountToAccountBlocklist(servers[ 0 ].url, userAccessToken, 'root') | |
498 | ||
499 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
500 | const uuid = resVideo.body.video.uuid | |
501 | ||
502 | const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello') | |
503 | const commentId = resComment.body.comment.id | |
504 | ||
505 | await wait(500) | |
506 | await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence') | |
507 | ||
508 | await removeAccountFromAccountBlocklist(servers[ 0 ].url, userAccessToken, 'root') | |
509 | }) | |
510 | ||
1f6d57e3 C |
511 | it('Should not send a new mention notification if the remote account mention a local account', async function () { |
512 | this.timeout(20000) | |
513 | ||
514 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
515 | const uuid = resVideo.body.video.uuid | |
516 | ||
517 | await waitJobs(servers) | |
518 | const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, '@user_1 hello') | |
519 | const threadId = resThread.body.comment.id | |
520 | ||
521 | await waitJobs(servers) | |
522 | await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root 2 name', 'absence') | |
523 | }) | |
524 | ||
f7cc67b4 C |
525 | it('Should send a new mention notification after local comments', async function () { |
526 | this.timeout(10000) | |
527 | ||
528 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
529 | const uuid = resVideo.body.video.uuid | |
530 | ||
531 | const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello 1') | |
532 | const threadId = resThread.body.comment.id | |
533 | ||
534 | await wait(500) | |
535 | await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root name', 'presence') | |
536 | ||
537 | const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'hello 2 @user_1') | |
538 | const commentId = resComment.body.comment.id | |
539 | ||
540 | await wait(500) | |
541 | await checkCommentMention(baseParams, uuid, commentId, threadId, 'super root name', 'presence') | |
542 | }) | |
543 | ||
544 | it('Should send a new mention notification after remote comments', async function () { | |
545 | this.timeout(20000) | |
546 | ||
547 | const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' }) | |
548 | const uuid = resVideo.body.video.uuid | |
549 | ||
550 | await waitJobs(servers) | |
551 | const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'hello @user_1@localhost:9001 1') | |
552 | const threadId = resThread.body.comment.id | |
553 | ||
554 | await waitJobs(servers) | |
555 | await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root 2 name', 'presence') | |
556 | ||
557 | const text = '@user_1@localhost:9001 hello 2 @root@localhost:9001' | |
558 | const resComment = await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, threadId, text) | |
559 | const commentId = resComment.body.comment.id | |
560 | ||
561 | await waitJobs(servers) | |
562 | await checkCommentMention(baseParams, uuid, commentId, threadId, 'super root 2 name', 'presence') | |
563 | }) | |
564 | }) | |
565 | ||
cef534ed C |
566 | describe('Video abuse for moderators notification' , function () { |
567 | let baseParams: CheckerBaseParams | |
568 | ||
569 | before(() => { | |
570 | baseParams = { | |
571 | server: servers[0], | |
572 | emails, | |
573 | socketNotifications: adminNotifications, | |
574 | token: servers[0].accessToken | |
575 | } | |
576 | }) | |
577 | ||
578 | it('Should send a notification to moderators on local video abuse', async function () { | |
579 | this.timeout(10000) | |
580 | ||
dc133480 C |
581 | const name = 'video for abuse ' + uuidv4() |
582 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name }) | |
cef534ed C |
583 | const uuid = resVideo.body.video.uuid |
584 | ||
585 | await reportVideoAbuse(servers[0].url, servers[0].accessToken, uuid, 'super reason') | |
586 | ||
587 | await waitJobs(servers) | |
dc133480 | 588 | await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence') |
cef534ed C |
589 | }) |
590 | ||
591 | it('Should send a notification to moderators on remote video abuse', async function () { | |
592 | this.timeout(10000) | |
593 | ||
dc133480 C |
594 | const name = 'video for abuse ' + uuidv4() |
595 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name }) | |
cef534ed C |
596 | const uuid = resVideo.body.video.uuid |
597 | ||
598 | await waitJobs(servers) | |
599 | ||
600 | await reportVideoAbuse(servers[1].url, servers[1].accessToken, uuid, 'super reason') | |
601 | ||
602 | await waitJobs(servers) | |
dc133480 | 603 | await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence') |
cef534ed C |
604 | }) |
605 | }) | |
606 | ||
607 | describe('Video blacklist on my video', function () { | |
608 | let baseParams: CheckerBaseParams | |
609 | ||
610 | before(() => { | |
611 | baseParams = { | |
612 | server: servers[0], | |
613 | emails, | |
614 | socketNotifications: userNotifications, | |
615 | token: userAccessToken | |
616 | } | |
617 | }) | |
618 | ||
619 | it('Should send a notification to video owner on blacklist', async function () { | |
620 | this.timeout(10000) | |
621 | ||
dc133480 C |
622 | const name = 'video for abuse ' + uuidv4() |
623 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name }) | |
cef534ed C |
624 | const uuid = resVideo.body.video.uuid |
625 | ||
626 | await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid) | |
627 | ||
628 | await waitJobs(servers) | |
dc133480 | 629 | await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'blacklist') |
cef534ed C |
630 | }) |
631 | ||
632 | it('Should send a notification to video owner on unblacklist', async function () { | |
633 | this.timeout(10000) | |
634 | ||
dc133480 C |
635 | const name = 'video for abuse ' + uuidv4() |
636 | const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name }) | |
cef534ed C |
637 | const uuid = resVideo.body.video.uuid |
638 | ||
639 | await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid) | |
640 | ||
641 | await waitJobs(servers) | |
642 | await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, uuid) | |
643 | await waitJobs(servers) | |
644 | ||
645 | await wait(500) | |
dc133480 C |
646 | await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'unblacklist') |
647 | }) | |
648 | }) | |
649 | ||
650 | describe('My video is published', function () { | |
651 | let baseParams: CheckerBaseParams | |
652 | ||
653 | before(() => { | |
654 | baseParams = { | |
655 | server: servers[1], | |
656 | emails, | |
657 | socketNotifications: adminNotificationsServer2, | |
658 | token: servers[1].accessToken | |
659 | } | |
660 | }) | |
661 | ||
662 | it('Should not send a notification if transcoding is not enabled', async function () { | |
f7effe8d JM |
663 | this.timeout(10000) |
664 | ||
dc133480 C |
665 | const { name, uuid } = await uploadVideoByLocalAccount(servers) |
666 | await waitJobs(servers) | |
667 | ||
668 | await checkVideoIsPublished(baseParams, name, uuid, 'absence') | |
669 | }) | |
670 | ||
671 | it('Should not send a notification if the wait transcoding is false', async function () { | |
672 | this.timeout(50000) | |
673 | ||
674 | await uploadVideoByRemoteAccount(servers, { waitTranscoding: false }) | |
675 | await waitJobs(servers) | |
676 | ||
677 | const notification = await getLastNotification(servers[ 0 ].url, userAccessToken) | |
678 | if (notification) { | |
679 | expect(notification.type).to.not.equal(UserNotificationType.MY_VIDEO_PUBLISHED) | |
680 | } | |
681 | }) | |
682 | ||
683 | it('Should send a notification even if the video is not transcoded in other resolutions', async function () { | |
684 | this.timeout(50000) | |
685 | ||
686 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, { waitTranscoding: true, fixture: 'video_short_240p.mp4' }) | |
687 | await waitJobs(servers) | |
688 | ||
689 | await checkVideoIsPublished(baseParams, name, uuid, 'presence') | |
690 | }) | |
691 | ||
692 | it('Should send a notification with a transcoded video', async function () { | |
693 | this.timeout(50000) | |
694 | ||
695 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, { waitTranscoding: true }) | |
696 | await waitJobs(servers) | |
697 | ||
698 | await checkVideoIsPublished(baseParams, name, uuid, 'presence') | |
699 | }) | |
700 | ||
701 | it('Should send a notification when an imported video is transcoded', async function () { | |
702 | this.timeout(50000) | |
703 | ||
704 | const name = 'video import ' + uuidv4() | |
705 | ||
706 | const attributes = { | |
707 | name, | |
708 | channelId, | |
709 | privacy: VideoPrivacy.PUBLIC, | |
710 | targetUrl: getYoutubeVideoUrl(), | |
711 | waitTranscoding: true | |
712 | } | |
713 | const res = await importVideo(servers[1].url, servers[1].accessToken, attributes) | |
714 | const uuid = res.body.video.uuid | |
715 | ||
716 | await waitJobs(servers) | |
717 | await checkVideoIsPublished(baseParams, name, uuid, 'presence') | |
718 | }) | |
719 | ||
720 | it('Should send a notification when the scheduled update has been proceeded', async function () { | |
721 | this.timeout(70000) | |
722 | ||
723 | // In 2 seconds | |
724 | let updateAt = new Date(new Date().getTime() + 2000) | |
725 | ||
726 | const data = { | |
727 | privacy: VideoPrivacy.PRIVATE, | |
728 | scheduleUpdate: { | |
729 | updateAt: updateAt.toISOString(), | |
730 | privacy: VideoPrivacy.PUBLIC | |
731 | } | |
732 | } | |
733 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) | |
734 | ||
735 | await wait(6000) | |
736 | await checkVideoIsPublished(baseParams, name, uuid, 'presence') | |
737 | }) | |
f7effe8d JM |
738 | |
739 | it('Should not send a notification before the video is published', async function () { | |
740 | this.timeout(20000) | |
741 | ||
742 | let updateAt = new Date(new Date().getTime() + 100000) | |
743 | ||
744 | const data = { | |
745 | privacy: VideoPrivacy.PRIVATE, | |
746 | scheduleUpdate: { | |
747 | updateAt: updateAt.toISOString(), | |
748 | privacy: VideoPrivacy.PUBLIC | |
749 | } | |
750 | } | |
751 | const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) | |
752 | ||
753 | await wait(6000) | |
754 | await checkVideoIsPublished(baseParams, name, uuid, 'absence') | |
755 | }) | |
dc133480 C |
756 | }) |
757 | ||
758 | describe('My video is imported', function () { | |
759 | let baseParams: CheckerBaseParams | |
760 | ||
761 | before(() => { | |
762 | baseParams = { | |
763 | server: servers[0], | |
764 | emails, | |
765 | socketNotifications: adminNotifications, | |
766 | token: servers[0].accessToken | |
767 | } | |
768 | }) | |
769 | ||
770 | it('Should send a notification when the video import failed', async function () { | |
771 | this.timeout(70000) | |
772 | ||
773 | const name = 'video import ' + uuidv4() | |
774 | ||
775 | const attributes = { | |
776 | name, | |
777 | channelId, | |
778 | privacy: VideoPrivacy.PRIVATE, | |
779 | targetUrl: getBadVideoUrl() | |
780 | } | |
781 | const res = await importVideo(servers[0].url, servers[0].accessToken, attributes) | |
782 | const uuid = res.body.video.uuid | |
783 | ||
784 | await waitJobs(servers) | |
785 | await checkMyVideoImportIsFinished(baseParams, name, uuid, getBadVideoUrl(), false, 'presence') | |
786 | }) | |
787 | ||
788 | it('Should send a notification when the video import succeeded', async function () { | |
789 | this.timeout(70000) | |
790 | ||
791 | const name = 'video import ' + uuidv4() | |
792 | ||
793 | const attributes = { | |
794 | name, | |
795 | channelId, | |
796 | privacy: VideoPrivacy.PRIVATE, | |
797 | targetUrl: getYoutubeVideoUrl() | |
798 | } | |
799 | const res = await importVideo(servers[0].url, servers[0].accessToken, attributes) | |
800 | const uuid = res.body.video.uuid | |
801 | ||
802 | await waitJobs(servers) | |
803 | await checkMyVideoImportIsFinished(baseParams, name, uuid, getYoutubeVideoUrl(), true, 'presence') | |
cef534ed C |
804 | }) |
805 | }) | |
806 | ||
f7cc67b4 C |
807 | describe('New registration', function () { |
808 | let baseParams: CheckerBaseParams | |
809 | ||
810 | before(() => { | |
811 | baseParams = { | |
812 | server: servers[0], | |
813 | emails, | |
814 | socketNotifications: adminNotifications, | |
815 | token: servers[0].accessToken | |
816 | } | |
817 | }) | |
818 | ||
819 | it('Should send a notification only to moderators when a user registers on the instance', async function () { | |
f7effe8d JM |
820 | this.timeout(10000) |
821 | ||
f7cc67b4 C |
822 | await registerUser(servers[0].url, 'user_45', 'password') |
823 | ||
824 | await waitJobs(servers) | |
825 | ||
826 | await checkUserRegistered(baseParams, 'user_45', 'presence') | |
827 | ||
828 | const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } } | |
829 | await checkUserRegistered(immutableAssign(baseParams, userOverride), 'user_45', 'absence') | |
830 | }) | |
831 | }) | |
832 | ||
833 | describe('New actor follow', function () { | |
834 | let baseParams: CheckerBaseParams | |
835 | let myChannelName = 'super channel name' | |
836 | let myUserName = 'super user name' | |
837 | ||
838 | before(async () => { | |
839 | baseParams = { | |
840 | server: servers[0], | |
841 | emails, | |
842 | socketNotifications: userNotifications, | |
843 | token: userAccessToken | |
844 | } | |
845 | ||
846 | await updateMyUser({ | |
847 | url: servers[0].url, | |
848 | accessToken: servers[0].accessToken, | |
849 | displayName: 'super root name' | |
850 | }) | |
851 | ||
852 | await updateMyUser({ | |
853 | url: servers[0].url, | |
854 | accessToken: userAccessToken, | |
855 | displayName: myUserName | |
856 | }) | |
857 | ||
858 | await updateMyUser({ | |
859 | url: servers[1].url, | |
860 | accessToken: servers[1].accessToken, | |
861 | displayName: 'super root 2 name' | |
862 | }) | |
863 | ||
864 | await updateVideoChannel(servers[0].url, userAccessToken, 'user_1_channel', { displayName: myChannelName }) | |
865 | }) | |
866 | ||
867 | it('Should notify when a local channel is following one of our channel', async function () { | |
2f1548fd | 868 | this.timeout(10000) |
f7cc67b4 | 869 | |
2f1548fd | 870 | await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:9001') |
f7cc67b4 C |
871 | await waitJobs(servers) |
872 | ||
873 | await checkNewActorFollow(baseParams, 'channel', 'root', 'super root name', myChannelName, 'presence') | |
874 | ||
875 | await removeUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:9001') | |
876 | }) | |
877 | ||
878 | it('Should notify when a remote channel is following one of our channel', async function () { | |
2f1548fd | 879 | this.timeout(10000) |
f7cc67b4 | 880 | |
2f1548fd | 881 | await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:9001') |
f7cc67b4 C |
882 | await waitJobs(servers) |
883 | ||
884 | await checkNewActorFollow(baseParams, 'channel', 'root', 'super root 2 name', myChannelName, 'presence') | |
885 | ||
886 | await removeUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:9001') | |
887 | }) | |
888 | ||
889 | it('Should notify when a local account is following one of our channel', async function () { | |
f7effe8d JM |
890 | this.timeout(10000) |
891 | ||
f7cc67b4 C |
892 | await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1@localhost:9001') |
893 | ||
894 | await waitJobs(servers) | |
895 | ||
896 | await checkNewActorFollow(baseParams, 'account', 'root', 'super root name', myUserName, 'presence') | |
897 | }) | |
898 | ||
899 | it('Should notify when a remote account is following one of our channel', async function () { | |
f7effe8d JM |
900 | this.timeout(10000) |
901 | ||
f7cc67b4 C |
902 | await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1@localhost:9001') |
903 | ||
904 | await waitJobs(servers) | |
905 | ||
906 | await checkNewActorFollow(baseParams, 'account', 'root', 'super root 2 name', myUserName, 'presence') | |
907 | }) | |
908 | }) | |
909 | ||
cef534ed C |
910 | describe('Mark as read', function () { |
911 | it('Should mark as read some notifications', async function () { | |
dc133480 | 912 | const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 2, 3) |
cef534ed C |
913 | const ids = res.body.data.map(n => n.id) |
914 | ||
dc133480 | 915 | await markAsReadNotifications(servers[ 0 ].url, userAccessToken, ids) |
cef534ed C |
916 | }) |
917 | ||
918 | it('Should have the notifications marked as read', async function () { | |
dc133480 C |
919 | const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 0, 10) |
920 | ||
921 | const notifications = res.body.data as UserNotification[] | |
922 | expect(notifications[ 0 ].read).to.be.false | |
923 | expect(notifications[ 1 ].read).to.be.false | |
924 | expect(notifications[ 2 ].read).to.be.true | |
925 | expect(notifications[ 3 ].read).to.be.true | |
926 | expect(notifications[ 4 ].read).to.be.true | |
927 | expect(notifications[ 5 ].read).to.be.false | |
928 | }) | |
929 | ||
930 | it('Should only list read notifications', async function () { | |
931 | const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 0, 10, false) | |
cef534ed C |
932 | |
933 | const notifications = res.body.data as UserNotification[] | |
dc133480 C |
934 | for (const notification of notifications) { |
935 | expect(notification.read).to.be.true | |
936 | } | |
937 | }) | |
938 | ||
939 | it('Should only list unread notifications', async function () { | |
940 | const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 0, 10, true) | |
941 | ||
942 | const notifications = res.body.data as UserNotification[] | |
943 | for (const notification of notifications) { | |
944 | expect(notification.read).to.be.false | |
945 | } | |
cef534ed | 946 | }) |
2f1548fd C |
947 | |
948 | it('Should mark as read all notifications', async function () { | |
949 | await markAsReadAllNotifications(servers[ 0 ].url, userAccessToken) | |
950 | ||
951 | const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 0, 10, true) | |
952 | ||
953 | expect(res.body.total).to.equal(0) | |
954 | expect(res.body.data).to.have.lengthOf(0) | |
955 | }) | |
cef534ed C |
956 | }) |
957 | ||
958 | describe('Notification settings', function () { | |
cef534ed C |
959 | let baseParams: CheckerBaseParams |
960 | ||
961 | before(() => { | |
962 | baseParams = { | |
963 | server: servers[0], | |
964 | emails, | |
965 | socketNotifications: userNotifications, | |
966 | token: userAccessToken | |
967 | } | |
968 | }) | |
969 | ||
970 | it('Should not have notifications', async function () { | |
f7effe8d JM |
971 | this.timeout(10000) |
972 | ||
dc133480 | 973 | await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, { |
cef534ed C |
974 | newVideoFromSubscription: UserNotificationSettingValue.NONE |
975 | })) | |
976 | ||
977 | { | |
978 | const res = await getMyUserInformation(servers[0].url, userAccessToken) | |
979 | const info = res.body as User | |
980 | expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.NONE) | |
981 | } | |
982 | ||
dc133480 | 983 | const { name, uuid } = await uploadVideoByLocalAccount(servers) |
cef534ed C |
984 | |
985 | const check = { web: true, mail: true } | |
dc133480 | 986 | await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence') |
cef534ed C |
987 | }) |
988 | ||
989 | it('Should only have web notifications', async function () { | |
f7effe8d JM |
990 | this.timeout(10000) |
991 | ||
dc133480 | 992 | await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, { |
2f1548fd | 993 | newVideoFromSubscription: UserNotificationSettingValue.WEB |
cef534ed C |
994 | })) |
995 | ||
996 | { | |
997 | const res = await getMyUserInformation(servers[0].url, userAccessToken) | |
998 | const info = res.body as User | |
2f1548fd | 999 | expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB) |
cef534ed C |
1000 | } |
1001 | ||
dc133480 | 1002 | const { name, uuid } = await uploadVideoByLocalAccount(servers) |
cef534ed C |
1003 | |
1004 | { | |
1005 | const check = { mail: true, web: false } | |
dc133480 | 1006 | await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence') |
cef534ed C |
1007 | } |
1008 | ||
1009 | { | |
1010 | const check = { mail: false, web: true } | |
dc133480 | 1011 | await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence') |
cef534ed C |
1012 | } |
1013 | }) | |
1014 | ||
1015 | it('Should only have mail notifications', async function () { | |
f7effe8d JM |
1016 | this.timeout(10000) |
1017 | ||
dc133480 | 1018 | await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, { |
cef534ed C |
1019 | newVideoFromSubscription: UserNotificationSettingValue.EMAIL |
1020 | })) | |
1021 | ||
1022 | { | |
1023 | const res = await getMyUserInformation(servers[0].url, userAccessToken) | |
1024 | const info = res.body as User | |
1025 | expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.EMAIL) | |
1026 | } | |
1027 | ||
dc133480 | 1028 | const { name, uuid } = await uploadVideoByLocalAccount(servers) |
cef534ed C |
1029 | |
1030 | { | |
1031 | const check = { mail: false, web: true } | |
dc133480 | 1032 | await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence') |
cef534ed C |
1033 | } |
1034 | ||
1035 | { | |
1036 | const check = { mail: true, web: false } | |
dc133480 | 1037 | await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence') |
cef534ed C |
1038 | } |
1039 | }) | |
1040 | ||
1041 | it('Should have email and web notifications', async function () { | |
f7effe8d JM |
1042 | this.timeout(10000) |
1043 | ||
dc133480 | 1044 | await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, { |
2f1548fd | 1045 | newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL |
cef534ed C |
1046 | })) |
1047 | ||
1048 | { | |
1049 | const res = await getMyUserInformation(servers[0].url, userAccessToken) | |
1050 | const info = res.body as User | |
2f1548fd C |
1051 | expect(info.notificationSettings.newVideoFromSubscription).to.equal( |
1052 | UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL | |
1053 | ) | |
cef534ed C |
1054 | } |
1055 | ||
dc133480 | 1056 | const { name, uuid } = await uploadVideoByLocalAccount(servers) |
cef534ed | 1057 | |
dc133480 | 1058 | await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') |
cef534ed C |
1059 | }) |
1060 | }) | |
1061 | ||
1062 | after(async function () { | |
89ada4e2 C |
1063 | MockSmtpServer.Instance.kill() |
1064 | ||
cef534ed C |
1065 | killallServers(servers) |
1066 | }) | |
1067 | }) |