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

   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,
  13   registerUser,
  14   removeVideoFromBlacklist,
  15   reportVideoAbuse,
  16   updateMyUser,
  17   updateVideo,
  18   updateVideoChannel,
  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 {
  27   checkCommentMention,
  28   CheckerBaseParams,
  29   checkMyVideoImportIsFinished,
  30   checkNewActorFollow,
  31   checkNewBlacklistOnMyVideo,
  32   checkNewCommentOnMyVideo,
  33   checkNewVideoAbuseForModerators,
  34   checkNewVideoFromSubscription,
  35   checkUserRegistered,
  36   checkVideoIsPublished,
  37   getLastNotification,
  38   getUserNotifications,
  39   markAsReadNotifications,
  40   updateMyNotificationSettings,
  41   markAsReadAllNotifications
  42 } from '../../../../shared/utils/users/user-notifications'
  43 import {
  44   User,
  45   UserNotification,
  46   UserNotificationSetting,
  47   UserNotificationSettingValue,
  48   UserNotificationType
  49 } from '../../../../shared/models/users'
  50 import { MockSmtpServer } from '../../../../shared/utils/miscs/email'
  51 import { addUserSubscription, removeUserSubscription } from '../../../../shared/utils/users/user-subscriptions'
  52 import { VideoPrivacy } from '../../../../shared/models/videos'
  53 import { getBadVideoUrl, getYoutubeVideoUrl, importVideo } from '../../../../shared/utils/videos/video-imports'
  54 import { addVideoCommentReply, addVideoCommentThread } from '../../../../shared/utils/videos/video-comments'
  55 import * as uuidv4 from 'uuid/v4'
  56 import { addAccountToAccountBlocklist, removeAccountFromAccountBlocklist } from '../../../../shared/utils/users/blocklist'
  57
  58 const expect = chai.expect
  59
  60 async function uploadVideoByRemoteAccount (servers: ServerInfo[], additionalParams: any = {}) {
  61   const name = 'remote video ' + uuidv4()
  62
  63   const data = Object.assign({ name }, additionalParams)
  64   const res = await uploadVideo(servers[ 1 ].url, servers[ 1 ].accessToken, data)
  65
  66   await waitJobs(servers)
  67
  68   return { uuid: res.body.video.uuid, name }
  69 }
  70
  71 async function uploadVideoByLocalAccount (servers: ServerInfo[], additionalParams: any = {}) {
  72   const name = 'local video ' + uuidv4()
  73
  74   const data = Object.assign({ name }, additionalParams)
  75   const res = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, data)
  76
  77   await waitJobs(servers)
  78
  79   return { uuid: res.body.video.uuid, name }
  80 }
  81
  82 describe('Test users notifications', function () {
  83   let servers: ServerInfo[] = []
  84   let userAccessToken: string
  85   let userNotifications: UserNotification[] = []
  86   let adminNotifications: UserNotification[] = []
  87   let adminNotificationsServer2: UserNotification[] = []
  88   const emails: object[] = []
  89   let channelId: number
  90
  91   const allNotificationSettings: UserNotificationSetting = {
  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
 101   }
 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
 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)
 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     }
 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     }
 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 () {
 168       this.timeout(10000)
 169
 170       await uploadVideoByLocalAccount(servers)
 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 () {
 180       this.timeout(15000)
 181
 182       await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:9001')
 183       await waitJobs(servers)
 184
 185       const { name, uuid } = await uploadVideoByLocalAccount(servers)
 186       await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
 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')
 193       await waitJobs(servers)
 194
 195       const { name, uuid } = await uploadVideoByRemoteAccount(servers)
 196       await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
 197     })
 198
 199     it('Should send a new video notification on a scheduled publication', async function () {
 200       this.timeout(20000)
 201
 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       }
 212       const { name, uuid } = await uploadVideoByLocalAccount(servers, data)
 213
 214       await wait(6000)
 215       await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
 216     })
 217
 218     it('Should send a new video notification on a remote scheduled publication', async function () {
 219       this.timeout(50000)
 220
 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       }
 231       const { name, uuid } = await uploadVideoByRemoteAccount(servers, data)
 232       await waitJobs(servers)
 233
 234       await wait(6000)
 235       await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
 236     })
 237
 238     it('Should not send a notification before the video is published', async function () {
 239       this.timeout(20000)
 240
 241       let updateAt = new Date(new Date().getTime() + 1000000)
 242
 243       const data = {
 244         privacy: VideoPrivacy.PRIVATE,
 245         scheduleUpdate: {
 246           updateAt: updateAt.toISOString(),
 247           privacy: VideoPrivacy.PUBLIC
 248         }
 249       }
 250       const { name, uuid } = await uploadVideoByLocalAccount(servers, data)
 251
 252       await wait(6000)
 253       await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
 254     })
 255
 256     it('Should send a new video notification when a video becomes public', async function () {
 257       this.timeout(10000)
 258
 259       const data = { privacy: VideoPrivacy.PRIVATE }
 260       const { name, uuid } = await uploadVideoByLocalAccount(servers, data)
 261
 262       await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
 263
 264       await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.PUBLIC })
 265
 266       await wait(500)
 267       await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
 268     })
 269
 270     it('Should send a new video notification when a remote video becomes public', async function () {
 271       this.timeout(20000)
 272
 273       const data = { privacy: VideoPrivacy.PRIVATE }
 274       const { name, uuid } = await uploadVideoByRemoteAccount(servers, data)
 275
 276       await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
 277
 278       await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.PUBLIC })
 279
 280       await waitJobs(servers)
 281       await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
 282     })
 283
 284     it('Should not send a new video notification when a video becomes unlisted', async function () {
 285       this.timeout(20000)
 286
 287       const data = { privacy: VideoPrivacy.PRIVATE }
 288       const { name, uuid } = await uploadVideoByLocalAccount(servers, data)
 289
 290       await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED })
 291
 292       await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
 293     })
 294
 295     it('Should not send a new video notification when a remote video becomes unlisted', async function () {
 296       this.timeout(20000)
 297
 298       const data = { privacy: VideoPrivacy.PRIVATE }
 299       const { name, uuid } = await uploadVideoByRemoteAccount(servers, data)
 300
 301       await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED })
 302
 303       await waitJobs(servers)
 304       await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
 305     })
 306
 307     it('Should send a new video notification after a video import', async function () {
 308       this.timeout(30000)
 309
 310       const name = 'video import ' + uuidv4()
 311
 312       const attributes = {
 313         name,
 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
 323       await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
 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
 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
 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
 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
 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
 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
 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
 581       const name = 'video for abuse ' + uuidv4()
 582       const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
 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)
 588       await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence')
 589     })
 590
 591     it('Should send a notification to moderators on remote video abuse', async function () {
 592       this.timeout(10000)
 593
 594       const name = 'video for abuse ' + uuidv4()
 595       const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
 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)
 603       await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence')
 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
 622       const name = 'video for abuse ' + uuidv4()
 623       const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
 624       const uuid = resVideo.body.video.uuid
 625
 626       await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid)
 627
 628       await waitJobs(servers)
 629       await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'blacklist')
 630     })
 631
 632     it('Should send a notification to video owner on unblacklist', async function () {
 633       this.timeout(10000)
 634
 635       const name = 'video for abuse ' + uuidv4()
 636       const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
 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)
 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 () {
 663       this.timeout(10000)
 664
 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     })
 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     })
 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')
 804     })
 805   })
 806
 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 () {
 820       this.timeout(10000)
 821
 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 () {
 868       this.timeout(10000)
 869
 870       await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:9001')
 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 () {
 879       this.timeout(10000)
 880
 881       await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:9001')
 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 () {
 890       this.timeout(10000)
 891
 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 () {
 900       this.timeout(10000)
 901
 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
 910   describe('Mark as read', function () {
 911     it('Should mark as read some notifications', async function () {
 912       const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 2, 3)
 913       const ids = res.body.data.map(n => n.id)
 914
 915       await markAsReadNotifications(servers[ 0 ].url, userAccessToken, ids)
 916     })
 917
 918     it('Should have the notifications marked as read', async function () {
 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)
 932
 933       const notifications = res.body.data as UserNotification[]
 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       }
 946     })
 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     })
 956   })
 957
 958   describe('Notification settings', function () {
 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 () {
 971       this.timeout(10000)
 972
 973       await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
 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
 983       const { name, uuid } = await uploadVideoByLocalAccount(servers)
 984
 985       const check = { web: true, mail: true }
 986       await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
 987     })
 988
 989     it('Should only have web notifications', async function () {
 990       this.timeout(10000)
 991
 992       await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
 993         newVideoFromSubscription: UserNotificationSettingValue.WEB
 994       }))
 995
 996       {
 997         const res = await getMyUserInformation(servers[0].url, userAccessToken)
 998         const info = res.body as User
 999         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB)
1000       }
1001
1002       const { name, uuid } = await uploadVideoByLocalAccount(servers)
1003
1004       {
1005         const check = { mail: true, web: false }
1006         await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
1007       }
1008
1009       {
1010         const check = { mail: false, web: true }
1011         await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
1012       }
1013     })
1014
1015     it('Should only have mail notifications', async function () {
1016       this.timeout(10000)
1017
1018       await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
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
1028       const { name, uuid } = await uploadVideoByLocalAccount(servers)
1029
1030       {
1031         const check = { mail: false, web: true }
1032         await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
1033       }
1034
1035       {
1036         const check = { mail: true, web: false }
1037         await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
1038       }
1039     })
1040
1041     it('Should have email and web notifications', async function () {
1042       this.timeout(10000)
1043
1044       await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
1045         newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
1046       }))
1047
1048       {
1049         const res = await getMyUserInformation(servers[0].url, userAccessToken)
1050         const info = res.body as User
1051         expect(info.notificationSettings.newVideoFromSubscription).to.equal(
1052           UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
1053         )
1054       }
1055
1056       const { name, uuid } = await uploadVideoByLocalAccount(servers)
1057
1058       await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
1059     })
1060   })
1061
1062   after(async function () {
1063     MockSmtpServer.Instance.kill()
1064
1065     killallServers(servers)
1066   })
1067 })