server/tests/api/notifications/user-notifications.ts

   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 })