shared/notifications.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import { expect } from 'chai'
   4 import { inspect } from 'util'
   5 import {
   6   AbuseState,
   7   PluginType,
   8   UserNotification,
   9   UserNotificationSetting,
  10   UserNotificationSettingValue,
  11   UserNotificationType
  12 } from '@shared/models'
  13 import {
  14   createMultipleServers,
  15   doubleFollow,
  16   PeerTubeServer,
  17   setAccessTokensToServers,
  18   setDefaultAccountAvatar,
  19   setDefaultChannelAvatar,
  20   setDefaultVideoChannel
  21 } from '@shared/server-commands'
  22 import { MockSmtpServer } from './mock-servers'
  23
  24 type CheckerBaseParams = {
  25   server: PeerTubeServer
  26   emails: any[]
  27   socketNotifications: UserNotification[]
  28   token: string
  29   check?: { web: boolean, mail: boolean }
  30 }
  31
  32 type CheckerType = 'presence' | 'absence'
  33
  34 function getAllNotificationsSettings (): UserNotificationSetting {
  35   return {
  36     newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  37     newCommentOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  38     abuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  39     videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  40     blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  41     myVideoImportFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  42     myVideoPublished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  43     commentMention: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  44     newFollow: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  45     newUserRegistration: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  46     newInstanceFollower: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  47     abuseNewMessage: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  48     abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  49     autoInstanceFollowing: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  50     newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  51     myVideoStudioEditionFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
  52     newPluginVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
  53   }
  54 }
  55
  56 async function checkNewVideoFromSubscription (options: CheckerBaseParams & {
  57   videoName: string
  58   shortUUID: string
  59   checkType: CheckerType
  60 }) {
  61   const { videoName, shortUUID } = options
  62   const notificationType = UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION
  63
  64   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
  65     if (checkType === 'presence') {
  66       expect(notification).to.not.be.undefined
  67       expect(notification.type).to.equal(notificationType)
  68
  69       checkVideo(notification.video, videoName, shortUUID)
  70       checkActor(notification.video.channel)
  71     } else {
  72       expect(notification).to.satisfy((n: UserNotification) => {
  73         return n === undefined || n.type !== UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION || n.video.name !== videoName
  74       })
  75     }
  76   }
  77
  78   function emailNotificationFinder (email: object) {
  79     const text = email['text']
  80     return text.indexOf(shortUUID) !== -1 && text.indexOf('Your subscription') !== -1
  81   }
  82
  83   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
  84 }
  85
  86 async function checkVideoIsPublished (options: CheckerBaseParams & {
  87   videoName: string
  88   shortUUID: string
  89   checkType: CheckerType
  90 }) {
  91   const { videoName, shortUUID } = options
  92   const notificationType = UserNotificationType.MY_VIDEO_PUBLISHED
  93
  94   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
  95     if (checkType === 'presence') {
  96       expect(notification).to.not.be.undefined
  97       expect(notification.type).to.equal(notificationType)
  98
  99       checkVideo(notification.video, videoName, shortUUID)
 100       checkActor(notification.video.channel)
 101     } else {
 102       expect(notification.video).to.satisfy(v => v === undefined || v.name !== videoName)
 103     }
 104   }
 105
 106   function emailNotificationFinder (email: object) {
 107     const text: string = email['text']
 108     return text.includes(shortUUID) && text.includes('Your video')
 109   }
 110
 111   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 112 }
 113
 114 async function checkVideoStudioEditionIsFinished (options: CheckerBaseParams & {
 115   videoName: string
 116   shortUUID: string
 117   checkType: CheckerType
 118 }) {
 119   const { videoName, shortUUID } = options
 120   const notificationType = UserNotificationType.MY_VIDEO_STUDIO_EDITION_FINISHED
 121
 122   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 123     if (checkType === 'presence') {
 124       expect(notification).to.not.be.undefined
 125       expect(notification.type).to.equal(notificationType)
 126
 127       checkVideo(notification.video, videoName, shortUUID)
 128       checkActor(notification.video.channel)
 129     } else {
 130       expect(notification.video).to.satisfy(v => v === undefined || v.name !== videoName)
 131     }
 132   }
 133
 134   function emailNotificationFinder (email: object) {
 135     const text: string = email['text']
 136     return text.includes(shortUUID) && text.includes('Edition of your video')
 137   }
 138
 139   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 140 }
 141
 142 async function checkMyVideoImportIsFinished (options: CheckerBaseParams & {
 143   videoName: string
 144   shortUUID: string
 145   url: string
 146   success: boolean
 147   checkType: CheckerType
 148 }) {
 149   const { videoName, shortUUID, url, success } = options
 150
 151   const notificationType = success ? UserNotificationType.MY_VIDEO_IMPORT_SUCCESS : UserNotificationType.MY_VIDEO_IMPORT_ERROR
 152
 153   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 154     if (checkType === 'presence') {
 155       expect(notification).to.not.be.undefined
 156       expect(notification.type).to.equal(notificationType)
 157
 158       expect(notification.videoImport.targetUrl).to.equal(url)
 159
 160       if (success) checkVideo(notification.videoImport.video, videoName, shortUUID)
 161     } else {
 162       expect(notification.videoImport).to.satisfy(i => i === undefined || i.targetUrl !== url)
 163     }
 164   }
 165
 166   function emailNotificationFinder (email: object) {
 167     const text: string = email['text']
 168     const toFind = success ? ' finished' : ' error'
 169
 170     return text.includes(url) && text.includes(toFind)
 171   }
 172
 173   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 174 }
 175
 176 async function checkUserRegistered (options: CheckerBaseParams & {
 177   username: string
 178   checkType: CheckerType
 179 }) {
 180   const { username } = options
 181   const notificationType = UserNotificationType.NEW_USER_REGISTRATION
 182
 183   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 184     if (checkType === 'presence') {
 185       expect(notification).to.not.be.undefined
 186       expect(notification.type).to.equal(notificationType)
 187
 188       checkActor(notification.account)
 189       expect(notification.account.name).to.equal(username)
 190     } else {
 191       expect(notification).to.satisfy(n => n.type !== notificationType || n.account.name !== username)
 192     }
 193   }
 194
 195   function emailNotificationFinder (email: object) {
 196     const text: string = email['text']
 197
 198     return text.includes(' registered.') && text.includes(username)
 199   }
 200
 201   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 202 }
 203
 204 async function checkNewActorFollow (options: CheckerBaseParams & {
 205   followType: 'channel' | 'account'
 206   followerName: string
 207   followerDisplayName: string
 208   followingDisplayName: string
 209   checkType: CheckerType
 210 }) {
 211   const { followType, followerName, followerDisplayName, followingDisplayName } = options
 212   const notificationType = UserNotificationType.NEW_FOLLOW
 213
 214   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 215     if (checkType === 'presence') {
 216       expect(notification).to.not.be.undefined
 217       expect(notification.type).to.equal(notificationType)
 218
 219       checkActor(notification.actorFollow.follower)
 220       expect(notification.actorFollow.follower.displayName).to.equal(followerDisplayName)
 221       expect(notification.actorFollow.follower.name).to.equal(followerName)
 222       expect(notification.actorFollow.follower.host).to.not.be.undefined
 223
 224       const following = notification.actorFollow.following
 225       expect(following.displayName).to.equal(followingDisplayName)
 226       expect(following.type).to.equal(followType)
 227     } else {
 228       expect(notification).to.satisfy(n => {
 229         return n.type !== notificationType ||
 230           (n.actorFollow.follower.name !== followerName && n.actorFollow.following !== followingDisplayName)
 231       })
 232     }
 233   }
 234
 235   function emailNotificationFinder (email: object) {
 236     const text: string = email['text']
 237
 238     return text.includes(followType) && text.includes(followingDisplayName) && text.includes(followerDisplayName)
 239   }
 240
 241   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 242 }
 243
 244 async function checkNewInstanceFollower (options: CheckerBaseParams & {
 245   followerHost: string
 246   checkType: CheckerType
 247 }) {
 248   const { followerHost } = options
 249   const notificationType = UserNotificationType.NEW_INSTANCE_FOLLOWER
 250
 251   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 252     if (checkType === 'presence') {
 253       expect(notification).to.not.be.undefined
 254       expect(notification.type).to.equal(notificationType)
 255
 256       checkActor(notification.actorFollow.follower)
 257       expect(notification.actorFollow.follower.name).to.equal('peertube')
 258       expect(notification.actorFollow.follower.host).to.equal(followerHost)
 259
 260       expect(notification.actorFollow.following.name).to.equal('peertube')
 261     } else {
 262       expect(notification).to.satisfy(n => {
 263         return n.type !== notificationType || n.actorFollow.follower.host !== followerHost
 264       })
 265     }
 266   }
 267
 268   function emailNotificationFinder (email: object) {
 269     const text: string = email['text']
 270
 271     return text.includes('instance has a new follower') && text.includes(followerHost)
 272   }
 273
 274   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 275 }
 276
 277 async function checkAutoInstanceFollowing (options: CheckerBaseParams & {
 278   followerHost: string
 279   followingHost: string
 280   checkType: CheckerType
 281 }) {
 282   const { followerHost, followingHost } = options
 283   const notificationType = UserNotificationType.AUTO_INSTANCE_FOLLOWING
 284
 285   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 286     if (checkType === 'presence') {
 287       expect(notification).to.not.be.undefined
 288       expect(notification.type).to.equal(notificationType)
 289
 290       const following = notification.actorFollow.following
 291       checkActor(following)
 292       expect(following.name).to.equal('peertube')
 293       expect(following.host).to.equal(followingHost)
 294
 295       expect(notification.actorFollow.follower.name).to.equal('peertube')
 296       expect(notification.actorFollow.follower.host).to.equal(followerHost)
 297     } else {
 298       expect(notification).to.satisfy(n => {
 299         return n.type !== notificationType || n.actorFollow.following.host !== followingHost
 300       })
 301     }
 302   }
 303
 304   function emailNotificationFinder (email: object) {
 305     const text: string = email['text']
 306
 307     return text.includes(' automatically followed a new instance') && text.includes(followingHost)
 308   }
 309
 310   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 311 }
 312
 313 async function checkCommentMention (options: CheckerBaseParams & {
 314   shortUUID: string
 315   commentId: number
 316   threadId: number
 317   byAccountDisplayName: string
 318   checkType: CheckerType
 319 }) {
 320   const { shortUUID, commentId, threadId, byAccountDisplayName } = options
 321   const notificationType = UserNotificationType.COMMENT_MENTION
 322
 323   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 324     if (checkType === 'presence') {
 325       expect(notification).to.not.be.undefined
 326       expect(notification.type).to.equal(notificationType)
 327
 328       checkComment(notification.comment, commentId, threadId)
 329       checkActor(notification.comment.account)
 330       expect(notification.comment.account.displayName).to.equal(byAccountDisplayName)
 331
 332       checkVideo(notification.comment.video, undefined, shortUUID)
 333     } else {
 334       expect(notification).to.satisfy(n => n.type !== notificationType || n.comment.id !== commentId)
 335     }
 336   }
 337
 338   function emailNotificationFinder (email: object) {
 339     const text: string = email['text']
 340
 341     return text.includes(' mentioned ') && text.includes(shortUUID) && text.includes(byAccountDisplayName)
 342   }
 343
 344   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 345 }
 346
 347 let lastEmailCount = 0
 348
 349 async function checkNewCommentOnMyVideo (options: CheckerBaseParams & {
 350   shortUUID: string
 351   commentId: number
 352   threadId: number
 353   checkType: CheckerType
 354 }) {
 355   const { server, shortUUID, commentId, threadId, checkType, emails } = options
 356   const notificationType = UserNotificationType.NEW_COMMENT_ON_MY_VIDEO
 357
 358   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 359     if (checkType === 'presence') {
 360       expect(notification).to.not.be.undefined
 361       expect(notification.type).to.equal(notificationType)
 362
 363       checkComment(notification.comment, commentId, threadId)
 364       checkActor(notification.comment.account)
 365       checkVideo(notification.comment.video, undefined, shortUUID)
 366     } else {
 367       expect(notification).to.satisfy((n: UserNotification) => {
 368         return n === undefined || n.comment === undefined || n.comment.id !== commentId
 369       })
 370     }
 371   }
 372
 373   const commentUrl = `http://localhost:${server.port}/w/${shortUUID};threadId=${threadId}`
 374
 375   function emailNotificationFinder (email: object) {
 376     return email['text'].indexOf(commentUrl) !== -1
 377   }
 378
 379   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 380
 381   if (checkType === 'presence') {
 382     // We cannot detect email duplicates, so check we received another email
 383     expect(emails).to.have.length.above(lastEmailCount)
 384     lastEmailCount = emails.length
 385   }
 386 }
 387
 388 async function checkNewVideoAbuseForModerators (options: CheckerBaseParams & {
 389   shortUUID: string
 390   videoName: string
 391   checkType: CheckerType
 392 }) {
 393   const { shortUUID, videoName } = options
 394   const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
 395
 396   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 397     if (checkType === 'presence') {
 398       expect(notification).to.not.be.undefined
 399       expect(notification.type).to.equal(notificationType)
 400
 401       expect(notification.abuse.id).to.be.a('number')
 402       checkVideo(notification.abuse.video, videoName, shortUUID)
 403     } else {
 404       expect(notification).to.satisfy((n: UserNotification) => {
 405         return n === undefined || n.abuse === undefined || n.abuse.video.shortUUID !== shortUUID
 406       })
 407     }
 408   }
 409
 410   function emailNotificationFinder (email: object) {
 411     const text = email['text']
 412     return text.indexOf(shortUUID) !== -1 && text.indexOf('abuse') !== -1
 413   }
 414
 415   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 416 }
 417
 418 async function checkNewAbuseMessage (options: CheckerBaseParams & {
 419   abuseId: number
 420   message: string
 421   toEmail: string
 422   checkType: CheckerType
 423 }) {
 424   const { abuseId, message, toEmail } = options
 425   const notificationType = UserNotificationType.ABUSE_NEW_MESSAGE
 426
 427   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 428     if (checkType === 'presence') {
 429       expect(notification).to.not.be.undefined
 430       expect(notification.type).to.equal(notificationType)
 431
 432       expect(notification.abuse.id).to.equal(abuseId)
 433     } else {
 434       expect(notification).to.satisfy((n: UserNotification) => {
 435         return n === undefined || n.type !== notificationType || n.abuse === undefined || n.abuse.id !== abuseId
 436       })
 437     }
 438   }
 439
 440   function emailNotificationFinder (email: object) {
 441     const text = email['text']
 442     const to = email['to'].filter(t => t.address === toEmail)
 443
 444     return text.indexOf(message) !== -1 && to.length !== 0
 445   }
 446
 447   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 448 }
 449
 450 async function checkAbuseStateChange (options: CheckerBaseParams & {
 451   abuseId: number
 452   state: AbuseState
 453   checkType: CheckerType
 454 }) {
 455   const { abuseId, state } = options
 456   const notificationType = UserNotificationType.ABUSE_STATE_CHANGE
 457
 458   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 459     if (checkType === 'presence') {
 460       expect(notification).to.not.be.undefined
 461       expect(notification.type).to.equal(notificationType)
 462
 463       expect(notification.abuse.id).to.equal(abuseId)
 464       expect(notification.abuse.state).to.equal(state)
 465     } else {
 466       expect(notification).to.satisfy((n: UserNotification) => {
 467         return n === undefined || n.abuse === undefined || n.abuse.id !== abuseId
 468       })
 469     }
 470   }
 471
 472   function emailNotificationFinder (email: object) {
 473     const text = email['text']
 474
 475     const contains = state === AbuseState.ACCEPTED
 476       ? ' accepted'
 477       : ' rejected'
 478
 479     return text.indexOf(contains) !== -1
 480   }
 481
 482   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 483 }
 484
 485 async function checkNewCommentAbuseForModerators (options: CheckerBaseParams & {
 486   shortUUID: string
 487   videoName: string
 488   checkType: CheckerType
 489 }) {
 490   const { shortUUID, videoName } = options
 491   const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
 492
 493   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 494     if (checkType === 'presence') {
 495       expect(notification).to.not.be.undefined
 496       expect(notification.type).to.equal(notificationType)
 497
 498       expect(notification.abuse.id).to.be.a('number')
 499       checkVideo(notification.abuse.comment.video, videoName, shortUUID)
 500     } else {
 501       expect(notification).to.satisfy((n: UserNotification) => {
 502         return n === undefined || n.abuse === undefined || n.abuse.comment.video.shortUUID !== shortUUID
 503       })
 504     }
 505   }
 506
 507   function emailNotificationFinder (email: object) {
 508     const text = email['text']
 509     return text.indexOf(shortUUID) !== -1 && text.indexOf('abuse') !== -1
 510   }
 511
 512   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 513 }
 514
 515 async function checkNewAccountAbuseForModerators (options: CheckerBaseParams & {
 516   displayName: string
 517   checkType: CheckerType
 518 }) {
 519   const { displayName } = options
 520   const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
 521
 522   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 523     if (checkType === 'presence') {
 524       expect(notification).to.not.be.undefined
 525       expect(notification.type).to.equal(notificationType)
 526
 527       expect(notification.abuse.id).to.be.a('number')
 528       expect(notification.abuse.account.displayName).to.equal(displayName)
 529     } else {
 530       expect(notification).to.satisfy((n: UserNotification) => {
 531         return n === undefined || n.abuse === undefined || n.abuse.account.displayName !== displayName
 532       })
 533     }
 534   }
 535
 536   function emailNotificationFinder (email: object) {
 537     const text = email['text']
 538     return text.indexOf(displayName) !== -1 && text.indexOf('abuse') !== -1
 539   }
 540
 541   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 542 }
 543
 544 async function checkVideoAutoBlacklistForModerators (options: CheckerBaseParams & {
 545   shortUUID: string
 546   videoName: string
 547   checkType: CheckerType
 548 }) {
 549   const { shortUUID, videoName } = options
 550   const notificationType = UserNotificationType.VIDEO_AUTO_BLACKLIST_FOR_MODERATORS
 551
 552   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 553     if (checkType === 'presence') {
 554       expect(notification).to.not.be.undefined
 555       expect(notification.type).to.equal(notificationType)
 556
 557       expect(notification.videoBlacklist.video.id).to.be.a('number')
 558       checkVideo(notification.videoBlacklist.video, videoName, shortUUID)
 559     } else {
 560       expect(notification).to.satisfy((n: UserNotification) => {
 561         return n === undefined || n.video === undefined || n.video.shortUUID !== shortUUID
 562       })
 563     }
 564   }
 565
 566   function emailNotificationFinder (email: object) {
 567     const text = email['text']
 568     return text.indexOf(shortUUID) !== -1 && email['text'].indexOf('video-auto-blacklist/list') !== -1
 569   }
 570
 571   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 572 }
 573
 574 async function checkNewBlacklistOnMyVideo (options: CheckerBaseParams & {
 575   shortUUID: string
 576   videoName: string
 577   blacklistType: 'blacklist' | 'unblacklist'
 578 }) {
 579   const { videoName, shortUUID, blacklistType } = options
 580   const notificationType = blacklistType === 'blacklist'
 581     ? UserNotificationType.BLACKLIST_ON_MY_VIDEO
 582     : UserNotificationType.UNBLACKLIST_ON_MY_VIDEO
 583
 584   function notificationChecker (notification: UserNotification) {
 585     expect(notification).to.not.be.undefined
 586     expect(notification.type).to.equal(notificationType)
 587
 588     const video = blacklistType === 'blacklist' ? notification.videoBlacklist.video : notification.video
 589
 590     checkVideo(video, videoName, shortUUID)
 591   }
 592
 593   function emailNotificationFinder (email: object) {
 594     const text = email['text']
 595     const blacklistText = blacklistType === 'blacklist'
 596       ? 'blacklisted'
 597       : 'unblacklisted'
 598
 599     return text.includes(shortUUID) && text.includes(blacklistText)
 600   }
 601
 602   await checkNotification({ ...options, notificationChecker, emailNotificationFinder, checkType: 'presence' })
 603 }
 604
 605 async function checkNewPeerTubeVersion (options: CheckerBaseParams & {
 606   latestVersion: string
 607   checkType: CheckerType
 608 }) {
 609   const { latestVersion } = options
 610   const notificationType = UserNotificationType.NEW_PEERTUBE_VERSION
 611
 612   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 613     if (checkType === 'presence') {
 614       expect(notification).to.not.be.undefined
 615       expect(notification.type).to.equal(notificationType)
 616
 617       expect(notification.peertube).to.exist
 618       expect(notification.peertube.latestVersion).to.equal(latestVersion)
 619     } else {
 620       expect(notification).to.satisfy((n: UserNotification) => {
 621         return n === undefined || n.peertube === undefined || n.peertube.latestVersion !== latestVersion
 622       })
 623     }
 624   }
 625
 626   function emailNotificationFinder (email: object) {
 627     const text = email['text']
 628
 629     return text.includes(latestVersion)
 630   }
 631
 632   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 633 }
 634
 635 async function checkNewPluginVersion (options: CheckerBaseParams & {
 636   pluginType: PluginType
 637   pluginName: string
 638   checkType: CheckerType
 639 }) {
 640   const { pluginName, pluginType } = options
 641   const notificationType = UserNotificationType.NEW_PLUGIN_VERSION
 642
 643   function notificationChecker (notification: UserNotification, checkType: CheckerType) {
 644     if (checkType === 'presence') {
 645       expect(notification).to.not.be.undefined
 646       expect(notification.type).to.equal(notificationType)
 647
 648       expect(notification.plugin.name).to.equal(pluginName)
 649       expect(notification.plugin.type).to.equal(pluginType)
 650     } else {
 651       expect(notification).to.satisfy((n: UserNotification) => {
 652         return n === undefined || n.plugin === undefined || n.plugin.name !== pluginName
 653       })
 654     }
 655   }
 656
 657   function emailNotificationFinder (email: object) {
 658     const text = email['text']
 659
 660     return text.includes(pluginName)
 661   }
 662
 663   await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
 664 }
 665
 666 async function prepareNotificationsTest (serversCount = 3, overrideConfigArg: any = {}) {
 667   const userNotifications: UserNotification[] = []
 668   const adminNotifications: UserNotification[] = []
 669   const adminNotificationsServer2: UserNotification[] = []
 670   const emails: object[] = []
 671
 672   const port = await MockSmtpServer.Instance.collectEmails(emails)
 673
 674   const overrideConfig = {
 675     smtp: {
 676       hostname: 'localhost',
 677       port
 678     },
 679     signup: {
 680       limit: 20
 681     }
 682   }
 683   const servers = await createMultipleServers(serversCount, Object.assign(overrideConfig, overrideConfigArg))
 684
 685   await setAccessTokensToServers(servers)
 686   await setDefaultVideoChannel(servers)
 687   await setDefaultChannelAvatar(servers)
 688   await setDefaultAccountAvatar(servers)
 689
 690   if (servers[1]) {
 691     await servers[1].config.enableStudio()
 692     await servers[1].config.enableLive({ allowReplay: true, transcoding: false })
 693   }
 694
 695   if (serversCount > 1) {
 696     await doubleFollow(servers[0], servers[1])
 697   }
 698
 699   const user = { username: 'user_1', password: 'super password' }
 700   await servers[0].users.create({ ...user, videoQuota: 10 * 1000 * 1000 })
 701   const userAccessToken = await servers[0].login.getAccessToken(user)
 702
 703   await servers[0].notifications.updateMySettings({ token: userAccessToken, settings: getAllNotificationsSettings() })
 704   await servers[0].notifications.updateMySettings({ settings: getAllNotificationsSettings() })
 705
 706   if (serversCount > 1) {
 707     await servers[1].notifications.updateMySettings({ settings: getAllNotificationsSettings() })
 708   }
 709
 710   {
 711     const socket = servers[0].socketIO.getUserNotificationSocket({ token: userAccessToken })
 712     socket.on('new-notification', n => userNotifications.push(n))
 713   }
 714   {
 715     const socket = servers[0].socketIO.getUserNotificationSocket()
 716     socket.on('new-notification', n => adminNotifications.push(n))
 717   }
 718
 719   if (serversCount > 1) {
 720     const socket = servers[1].socketIO.getUserNotificationSocket()
 721     socket.on('new-notification', n => adminNotificationsServer2.push(n))
 722   }
 723
 724   const { videoChannels } = await servers[0].users.getMyInfo()
 725   const channelId = videoChannels[0].id
 726
 727   return {
 728     userNotifications,
 729     adminNotifications,
 730     adminNotificationsServer2,
 731     userAccessToken,
 732     emails,
 733     servers,
 734     channelId
 735   }
 736 }
 737
 738 // ---------------------------------------------------------------------------
 739
 740 export {
 741   getAllNotificationsSettings,
 742
 743   CheckerBaseParams,
 744   CheckerType,
 745   checkMyVideoImportIsFinished,
 746   checkUserRegistered,
 747   checkAutoInstanceFollowing,
 748   checkVideoIsPublished,
 749   checkNewVideoFromSubscription,
 750   checkNewActorFollow,
 751   checkNewCommentOnMyVideo,
 752   checkNewBlacklistOnMyVideo,
 753   checkCommentMention,
 754   checkNewVideoAbuseForModerators,
 755   checkVideoAutoBlacklistForModerators,
 756   checkNewAbuseMessage,
 757   checkAbuseStateChange,
 758   checkNewInstanceFollower,
 759   prepareNotificationsTest,
 760   checkNewCommentAbuseForModerators,
 761   checkNewAccountAbuseForModerators,
 762   checkNewPeerTubeVersion,
 763   checkNewPluginVersion,
 764   checkVideoStudioEditionIsFinished
 765 }
 766
 767 // ---------------------------------------------------------------------------
 768
 769 async function checkNotification (options: CheckerBaseParams & {
 770   notificationChecker: (notification: UserNotification, checkType: CheckerType) => void
 771   emailNotificationFinder: (email: object) => boolean
 772   checkType: CheckerType
 773 }) {
 774   const { server, token, checkType, notificationChecker, emailNotificationFinder, socketNotifications, emails } = options
 775
 776   const check = options.check || { web: true, mail: true }
 777
 778   if (check.web) {
 779     const notification = await server.notifications.getLatest({ token: token })
 780
 781     if (notification || checkType !== 'absence') {
 782       notificationChecker(notification, checkType)
 783     }
 784
 785     const socketNotification = socketNotifications.find(n => {
 786       try {
 787         notificationChecker(n, 'presence')
 788         return true
 789       } catch {
 790         return false
 791       }
 792     })
 793
 794     if (checkType === 'presence') {
 795       const obj = inspect(socketNotifications, { depth: 5 })
 796       expect(socketNotification, 'The socket notification is absent when it should be present. ' + obj).to.not.be.undefined
 797     } else {
 798       const obj = inspect(socketNotification, { depth: 5 })
 799       expect(socketNotification, 'The socket notification is present when it should not be present. ' + obj).to.be.undefined
 800     }
 801   }
 802
 803   if (check.mail) {
 804     // Last email
 805     const email = emails
 806                       .slice()
 807                       .reverse()
 808                       .find(e => emailNotificationFinder(e))
 809
 810     if (checkType === 'presence') {
 811       const texts = emails.map(e => e.text)
 812       expect(email, 'The email is absent when is should be present. ' + inspect(texts)).to.not.be.undefined
 813     } else {
 814       expect(email, 'The email is present when is should not be present. ' + inspect(email)).to.be.undefined
 815     }
 816   }
 817 }
 818
 819 function checkVideo (video: any, videoName?: string, shortUUID?: string) {
 820   if (videoName) {
 821     expect(video.name).to.be.a('string')
 822     expect(video.name).to.not.be.empty
 823     expect(video.name).to.equal(videoName)
 824   }
 825
 826   if (shortUUID) {
 827     expect(video.shortUUID).to.be.a('string')
 828     expect(video.shortUUID).to.not.be.empty
 829     expect(video.shortUUID).to.equal(shortUUID)
 830   }
 831
 832   expect(video.id).to.be.a('number')
 833 }
 834
 835 function checkActor (actor: any) {
 836   expect(actor.displayName).to.be.a('string')
 837   expect(actor.displayName).to.not.be.empty
 838   expect(actor.host).to.not.be.undefined
 839 }
 840
 841 function checkComment (comment: any, commentId: number, threadId: number) {
 842   expect(comment.id).to.equal(commentId)
 843   expect(comment.threadId).to.equal(threadId)
 844 }