Add import finished and video published notifs

1 files changed, 276 insertions, 125 deletions

diff --git a/server/tests/api/users/user-notifications.ts b/server/tests/api/users/user-notifications.ts
index 09c0479fd..e4966dbf5 100644
--- a/server/tests/api/users/user-notifications.ts
+++ b/server/tests/api/users/user-notifications.ts
@@ -29,33 +29,46 @@ import {
   getLastNotification,
   getUserNotifications,
   markAsReadNotifications,
-  updateMyNotificationSettings
+  updateMyNotificationSettings,
+  checkVideoIsPublished, checkMyVideoImportIsFinished
 } from '../../../../shared/utils/users/user-notifications'
-import { User, UserNotification, UserNotificationSettingValue } from '../../../../shared/models/users'
+import {
+  User,
+  UserNotification,
+  UserNotificationSetting,
+  UserNotificationSettingValue,
+  UserNotificationType
+} from '../../../../shared/models/users'
 import { MockSmtpServer } from '../../../../shared/utils/miscs/email'
 import { addUserSubscription } from '../../../../shared/utils/users/user-subscriptions'
 import { VideoPrivacy } from '../../../../shared/models/videos'
-import { getYoutubeVideoUrl, importVideo } from '../../../../shared/utils/videos/video-imports'
+import { getYoutubeVideoUrl, importVideo, getBadVideoUrl } from '../../../../shared/utils/videos/video-imports'
 import { addVideoCommentReply, addVideoCommentThread } from '../../../../shared/utils/videos/video-comments'
+import * as uuidv4 from 'uuid/v4'
+import { addAccountToAccountBlocklist, removeAccountFromAccountBlocklist } from '../../../../shared/utils/users/blocklist'
 
 const expect = chai.expect
 
-async function uploadVideoByRemoteAccount (servers: ServerInfo[], videoNameId: number, additionalParams: any = {}) {
-  const data = Object.assign({ name: 'remote video ' + videoNameId }, additionalParams)
+async function uploadVideoByRemoteAccount (servers: ServerInfo[], additionalParams: any = {}) {
+  const name = 'remote video ' + uuidv4()
+
+  const data = Object.assign({ name }, additionalParams)
   const res = await uploadVideo(servers[ 1 ].url, servers[ 1 ].accessToken, data)
 
   await waitJobs(servers)
 
-  return res.body.video.uuid
+  return { uuid: res.body.video.uuid, name }
 }
 
-async function uploadVideoByLocalAccount (servers: ServerInfo[], videoNameId: number, additionalParams: any = {}) {
-  const data = Object.assign({ name: 'local video ' + videoNameId }, additionalParams)
+async function uploadVideoByLocalAccount (servers: ServerInfo[], additionalParams: any = {}) {
+  const name = 'local video ' + uuidv4()
+
+  const data = Object.assign({ name }, additionalParams)
   const res = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, data)
 
   await waitJobs(servers)
 
-  return res.body.video.uuid
+  return { uuid: res.body.video.uuid, name }
 }
 
 describe('Test users notifications', function () {
@@ -63,7 +76,18 @@ describe('Test users notifications', function () {
   let userAccessToken: string
   let userNotifications: UserNotification[] = []
   let adminNotifications: UserNotification[] = []
+  let adminNotificationsServer2: UserNotification[] = []
   const emails: object[] = []
+  let channelId: number
+
+  const allNotificationSettings: UserNotificationSetting = {
+    myVideoPublished: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
+    myVideoImportFinished: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
+    newCommentOnMyVideo: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
+    newVideoFromSubscription: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
+    videoAbuseAsModerator: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
+    blacklistOnMyVideo: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL
+  }
 
   before(async function () {
     this.timeout(120000)
@@ -94,12 +118,9 @@ describe('Test users notifications', function () {
     await createUser(servers[0].url, servers[0].accessToken, user.username, user.password, 10 * 1000 * 1000)
     userAccessToken = await userLogin(servers[0], user)
 
-    await updateMyNotificationSettings(servers[0].url, userAccessToken, {
-      newCommentOnMyVideo: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
-      newVideoFromSubscription: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
-      blacklistOnMyVideo: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
-      videoAbuseAsModerator: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL
-    })
+    await updateMyNotificationSettings(servers[0].url, userAccessToken, allNotificationSettings)
+    await updateMyNotificationSettings(servers[0].url, servers[0].accessToken, allNotificationSettings)
+    await updateMyNotificationSettings(servers[1].url, servers[1].accessToken, allNotificationSettings)
 
     {
       const socket = getUserNotificationSocket(servers[ 0 ].url, userAccessToken)
@@ -109,6 +130,15 @@ describe('Test users notifications', function () {
       const socket = getUserNotificationSocket(servers[ 0 ].url, servers[0].accessToken)
       socket.on('new-notification', n => adminNotifications.push(n))
     }
+    {
+      const socket = getUserNotificationSocket(servers[ 1 ].url, servers[1].accessToken)
+      socket.on('new-notification', n => adminNotificationsServer2.push(n))
+    }
+
+    {
+      const resChannel = await getMyUserInformation(servers[0].url, servers[0].accessToken)
+      channelId = resChannel.body.videoChannels[0].id
+    }
   })
 
   describe('New video from my subscription notification', function () {
@@ -124,7 +154,7 @@ describe('Test users notifications', function () {
     })
 
     it('Should not send notifications if the user does not follow the video publisher', async function () {
-      await uploadVideoByLocalAccount(servers, 1)
+      await uploadVideoByLocalAccount(servers)
 
       const notification = await getLastNotification(servers[ 0 ].url, userAccessToken)
       expect(notification).to.be.undefined
@@ -136,11 +166,8 @@ describe('Test users notifications', function () {
     it('Should send a new video notification if the user follows the local video publisher', async function () {
       await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:9001')
 
-      const videoNameId = 10
-      const videoName = 'local video ' + videoNameId
-
-      const uuid = await uploadVideoByLocalAccount(servers, videoNameId)
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'presence')
+      const { name, uuid } = await uploadVideoByLocalAccount(servers)
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
     })
 
     it('Should send a new video notification from a remote account', async function () {
@@ -148,21 +175,13 @@ describe('Test users notifications', function () {
 
       await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:9002')
 
-      const videoNameId = 20
-      const videoName = 'remote video ' + videoNameId
-
-      const uuid = await uploadVideoByRemoteAccount(servers, videoNameId)
-      await waitJobs(servers)
-
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'presence')
+      const { name, uuid } = await uploadVideoByRemoteAccount(servers)
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
     })
 
     it('Should send a new video notification on a scheduled publication', async function () {
       this.timeout(20000)
 
-      const videoNameId = 30
-      const videoName = 'local video ' + videoNameId
-
       // In 2 seconds
       let updateAt = new Date(new Date().getTime() + 2000)
 
@@ -173,18 +192,15 @@ describe('Test users notifications', function () {
           privacy: VideoPrivacy.PUBLIC
         }
       }
-      const uuid = await uploadVideoByLocalAccount(servers, videoNameId, data)
+      const { name, uuid } = await uploadVideoByLocalAccount(servers, data)
 
       await wait(6000)
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'presence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
     })
 
     it('Should send a new video notification on a remote scheduled publication', async function () {
       this.timeout(20000)
 
-      const videoNameId = 40
-      const videoName = 'remote video ' + videoNameId
-
       // In 2 seconds
       let updateAt = new Date(new Date().getTime() + 2000)
 
@@ -195,19 +211,16 @@ describe('Test users notifications', function () {
           privacy: VideoPrivacy.PUBLIC
         }
       }
-      const uuid = await uploadVideoByRemoteAccount(servers, videoNameId, data)
+      const { name, uuid } = await uploadVideoByRemoteAccount(servers, data)
       await waitJobs(servers)
 
       await wait(6000)
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'presence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
     })
 
     it('Should not send a notification before the video is published', async function () {
       this.timeout(20000)
 
-      const videoNameId = 50
-      const videoName = 'local video ' + videoNameId
-
       let updateAt = new Date(new Date().getTime() + 100000)
 
       const data = {
@@ -217,86 +230,70 @@ describe('Test users notifications', function () {
           privacy: VideoPrivacy.PUBLIC
         }
       }
-      const uuid = await uploadVideoByLocalAccount(servers, videoNameId, data)
+      const { name, uuid } = await uploadVideoByLocalAccount(servers, data)
 
       await wait(6000)
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'absence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
     })
 
     it('Should send a new video notification when a video becomes public', async function () {
       this.timeout(10000)
 
-      const videoNameId = 60
-      const videoName = 'local video ' + videoNameId
-
       const data = { privacy: VideoPrivacy.PRIVATE }
-      const uuid = await uploadVideoByLocalAccount(servers, videoNameId, data)
+      const { name, uuid } = await uploadVideoByLocalAccount(servers, data)
 
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'absence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
 
       await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.PUBLIC })
 
       await wait(500)
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'presence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
     })
 
     it('Should send a new video notification when a remote video becomes public', async function () {
       this.timeout(20000)
 
-      const videoNameId = 70
-      const videoName = 'remote video ' + videoNameId
-
       const data = { privacy: VideoPrivacy.PRIVATE }
-      const uuid = await uploadVideoByRemoteAccount(servers, videoNameId, data)
-      await waitJobs(servers)
+      const { name, uuid } = await uploadVideoByRemoteAccount(servers, data)
 
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'absence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
 
       await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.PUBLIC })
 
       await waitJobs(servers)
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'presence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
     })
 
     it('Should not send a new video notification when a video becomes unlisted', async function () {
       this.timeout(20000)
 
-      const videoNameId = 80
-      const videoName = 'local video ' + videoNameId
-
       const data = { privacy: VideoPrivacy.PRIVATE }
-      const uuid = await uploadVideoByLocalAccount(servers, videoNameId, data)
+      const { name, uuid } = await uploadVideoByLocalAccount(servers, data)
 
       await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED })
 
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'absence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
     })
 
     it('Should not send a new video notification when a remote video becomes unlisted', async function () {
       this.timeout(20000)
 
-      const videoNameId = 90
-      const videoName = 'remote video ' + videoNameId
-
       const data = { privacy: VideoPrivacy.PRIVATE }
-      const uuid = await uploadVideoByRemoteAccount(servers, videoNameId, data)
-      await waitJobs(servers)
+      const { name, uuid } = await uploadVideoByRemoteAccount(servers, data)
 
       await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED })
 
       await waitJobs(servers)
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'absence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
     })
 
     it('Should send a new video notification after a video import', async function () {
       this.timeout(30000)
 
-      const resChannel = await getMyUserInformation(servers[0].url, servers[0].accessToken)
-      const channelId = resChannel.body.videoChannels[0].id
-      const videoName = 'local video 100'
+      const name = 'video import ' + uuidv4()
 
       const attributes = {
-        name: videoName,
+        name,
         channelId,
         privacy: VideoPrivacy.PUBLIC,
         targetUrl: getYoutubeVideoUrl()
@@ -306,7 +303,7 @@ describe('Test users notifications', function () {
 
       await waitJobs(servers)
 
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'presence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
     })
   })
 
@@ -348,6 +345,23 @@ describe('Test users notifications', function () {
       await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
     })
 
+    it('Should not send a new comment notification if the account is muted', async function () {
+      this.timeout(10000)
+
+      await addAccountToAccountBlocklist(servers[ 0 ].url, userAccessToken, 'root')
+
+      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
+      const uuid = resVideo.body.video.uuid
+
+      const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
+      const commentId = resComment.body.comment.id
+
+      await wait(500)
+      await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
+
+      await removeAccountFromAccountBlocklist(servers[ 0 ].url, userAccessToken, 'root')
+    })
+
     it('Should send a new comment notification after a local comment on my video', async function () {
       this.timeout(10000)
 
@@ -425,23 +439,21 @@ describe('Test users notifications', function () {
     it('Should send a notification to moderators on local video abuse', async function () {
       this.timeout(10000)
 
-      const videoName = 'local video 110'
-
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: videoName })
+      const name = 'video for abuse ' + uuidv4()
+      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
       const uuid = resVideo.body.video.uuid
 
       await reportVideoAbuse(servers[0].url, servers[0].accessToken, uuid, 'super reason')
 
       await waitJobs(servers)
-      await checkNewVideoAbuseForModerators(baseParams, uuid, videoName, 'presence')
+      await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence')
     })
 
     it('Should send a notification to moderators on remote video abuse', async function () {
       this.timeout(10000)
 
-      const videoName = 'remote video 120'
-
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: videoName })
+      const name = 'video for abuse ' + uuidv4()
+      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
       const uuid = resVideo.body.video.uuid
 
       await waitJobs(servers)
@@ -449,7 +461,7 @@ describe('Test users notifications', function () {
       await reportVideoAbuse(servers[1].url, servers[1].accessToken, uuid, 'super reason')
 
       await waitJobs(servers)
-      await checkNewVideoAbuseForModerators(baseParams, uuid, videoName, 'presence')
+      await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence')
     })
   })
 
@@ -468,23 +480,21 @@ describe('Test users notifications', function () {
     it('Should send a notification to video owner on blacklist', async function () {
       this.timeout(10000)
 
-      const videoName = 'local video 130'
-
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: videoName })
+      const name = 'video for abuse ' + uuidv4()
+      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
       const uuid = resVideo.body.video.uuid
 
       await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid)
 
       await waitJobs(servers)
-      await checkNewBlacklistOnMyVideo(baseParams, uuid, videoName, 'blacklist')
+      await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'blacklist')
     })
 
     it('Should send a notification to video owner on unblacklist', async function () {
       this.timeout(10000)
 
-      const videoName = 'local video 130'
-
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: videoName })
+      const name = 'video for abuse ' + uuidv4()
+      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
       const uuid = resVideo.body.video.uuid
 
       await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid)
@@ -494,38 +504,187 @@ describe('Test users notifications', function () {
       await waitJobs(servers)
 
       await wait(500)
-      await checkNewBlacklistOnMyVideo(baseParams, uuid, videoName, 'unblacklist')
+      await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'unblacklist')
+    })
+  })
+
+  describe('My video is published', function () {
+    let baseParams: CheckerBaseParams
+
+    before(() => {
+      baseParams = {
+        server: servers[1],
+        emails,
+        socketNotifications: adminNotificationsServer2,
+        token: servers[1].accessToken
+      }
+    })
+
+    it('Should not send a notification if transcoding is not enabled', async function () {
+      const { name, uuid } = await uploadVideoByLocalAccount(servers)
+      await waitJobs(servers)
+
+      await checkVideoIsPublished(baseParams, name, uuid, 'absence')
+    })
+
+    it('Should not send a notification if the wait transcoding is false', async function () {
+      this.timeout(50000)
+
+      await uploadVideoByRemoteAccount(servers, { waitTranscoding: false })
+      await waitJobs(servers)
+
+      const notification = await getLastNotification(servers[ 0 ].url, userAccessToken)
+      if (notification) {
+        expect(notification.type).to.not.equal(UserNotificationType.MY_VIDEO_PUBLISHED)
+      }
+    })
+
+    it('Should send a notification even if the video is not transcoded in other resolutions', async function () {
+      this.timeout(50000)
+
+      const { name, uuid } = await uploadVideoByRemoteAccount(servers, { waitTranscoding: true, fixture: 'video_short_240p.mp4' })
+      await waitJobs(servers)
+
+      await checkVideoIsPublished(baseParams, name, uuid, 'presence')
+    })
+
+    it('Should send a notification with a transcoded video', async function () {
+      this.timeout(50000)
+
+      const { name, uuid } = await uploadVideoByRemoteAccount(servers, { waitTranscoding: true })
+      await waitJobs(servers)
+
+      await checkVideoIsPublished(baseParams, name, uuid, 'presence')
+    })
+
+    it('Should send a notification when an imported video is transcoded', async function () {
+      this.timeout(50000)
+
+      const name = 'video import ' + uuidv4()
+
+      const attributes = {
+        name,
+        channelId,
+        privacy: VideoPrivacy.PUBLIC,
+        targetUrl: getYoutubeVideoUrl(),
+        waitTranscoding: true
+      }
+      const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
+      const uuid = res.body.video.uuid
+
+      await waitJobs(servers)
+      await checkVideoIsPublished(baseParams, name, uuid, 'presence')
+    })
+
+    it('Should send a notification when the scheduled update has been proceeded', async function () {
+      this.timeout(70000)
+
+      // In 2 seconds
+      let updateAt = new Date(new Date().getTime() + 2000)
+
+      const data = {
+        privacy: VideoPrivacy.PRIVATE,
+        scheduleUpdate: {
+          updateAt: updateAt.toISOString(),
+          privacy: VideoPrivacy.PUBLIC
+        }
+      }
+      const { name, uuid } = await uploadVideoByRemoteAccount(servers, data)
+
+      await wait(6000)
+      await checkVideoIsPublished(baseParams, name, uuid, 'presence')
+    })
+  })
+
+  describe('My video is imported', function () {
+    let baseParams: CheckerBaseParams
+
+    before(() => {
+      baseParams = {
+        server: servers[0],
+        emails,
+        socketNotifications: adminNotifications,
+        token: servers[0].accessToken
+      }
+    })
+
+    it('Should send a notification when the video import failed', async function () {
+      this.timeout(70000)
+
+      const name = 'video import ' + uuidv4()
+
+      const attributes = {
+        name,
+        channelId,
+        privacy: VideoPrivacy.PRIVATE,
+        targetUrl: getBadVideoUrl()
+      }
+      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
+      const uuid = res.body.video.uuid
+
+      await waitJobs(servers)
+      await checkMyVideoImportIsFinished(baseParams, name, uuid, getBadVideoUrl(), false, 'presence')
+    })
+
+    it('Should send a notification when the video import succeeded', async function () {
+      this.timeout(70000)
+
+      const name = 'video import ' + uuidv4()
+
+      const attributes = {
+        name,
+        channelId,
+        privacy: VideoPrivacy.PRIVATE,
+        targetUrl: getYoutubeVideoUrl()
+      }
+      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
+      const uuid = res.body.video.uuid
+
+      await waitJobs(servers)
+      await checkMyVideoImportIsFinished(baseParams, name, uuid, getYoutubeVideoUrl(), true, 'presence')
     })
   })
 
   describe('Mark as read', function () {
     it('Should mark as read some notifications', async function () {
-      const res = await getUserNotifications(servers[0].url, userAccessToken, 2, 3)
+      const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 2, 3)
       const ids = res.body.data.map(n => n.id)
 
-      await markAsReadNotifications(servers[0].url, userAccessToken, ids)
+      await markAsReadNotifications(servers[ 0 ].url, userAccessToken, ids)
     })
 
     it('Should have the notifications marked as read', async function () {
-      const res = await getUserNotifications(servers[0].url, userAccessToken, 0, 10)
+      const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 0, 10)
+
+      const notifications = res.body.data as UserNotification[]
+      expect(notifications[ 0 ].read).to.be.false
+      expect(notifications[ 1 ].read).to.be.false
+      expect(notifications[ 2 ].read).to.be.true
+      expect(notifications[ 3 ].read).to.be.true
+      expect(notifications[ 4 ].read).to.be.true
+      expect(notifications[ 5 ].read).to.be.false
+    })
+
+    it('Should only list read notifications', async function () {
+      const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 0, 10, false)
 
       const notifications = res.body.data as UserNotification[]
-      expect(notifications[0].read).to.be.false
-      expect(notifications[1].read).to.be.false
-      expect(notifications[2].read).to.be.true
-      expect(notifications[3].read).to.be.true
-      expect(notifications[4].read).to.be.true
-      expect(notifications[5].read).to.be.false
+      for (const notification of notifications) {
+        expect(notification.read).to.be.true
+      }
+    })
+
+    it('Should only list unread notifications', async function () {
+      const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 0, 10, true)
+
+      const notifications = res.body.data as UserNotification[]
+      for (const notification of notifications) {
+        expect(notification.read).to.be.false
+      }
     })
   })
 
   describe('Notification settings', function () {
-    const baseUpdateNotificationParams = {
-      newCommentOnMyVideo: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
-      newVideoFromSubscription: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
-      videoAbuseAsModerator: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL,
-      blacklistOnMyVideo: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL
-    }
     let baseParams: CheckerBaseParams
 
     before(() => {
@@ -538,7 +697,7 @@ describe('Test users notifications', function () {
     })
 
     it('Should not have notifications', async function () {
-      await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(baseUpdateNotificationParams, {
+      await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
         newVideoFromSubscription: UserNotificationSettingValue.NONE
       }))
 
@@ -548,16 +707,14 @@ describe('Test users notifications', function () {
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.NONE)
       }
 
-      const videoNameId = 42
-      const videoName = 'local video ' + videoNameId
-      const uuid = await uploadVideoByLocalAccount(servers, videoNameId)
+      const { name, uuid } = await uploadVideoByLocalAccount(servers)
 
       const check = { web: true, mail: true }
-      await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), videoName, uuid, 'absence')
+      await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
     })
 
     it('Should only have web notifications', async function () {
-      await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(baseUpdateNotificationParams, {
+      await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
         newVideoFromSubscription: UserNotificationSettingValue.WEB_NOTIFICATION
       }))
 
@@ -567,23 +724,21 @@ describe('Test users notifications', function () {
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB_NOTIFICATION)
       }
 
-      const videoNameId = 52
-      const videoName = 'local video ' + videoNameId
-      const uuid = await uploadVideoByLocalAccount(servers, videoNameId)
+      const { name, uuid } = await uploadVideoByLocalAccount(servers)
 
       {
         const check = { mail: true, web: false }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), videoName, uuid, 'absence')
+        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
       }
 
       {
         const check = { mail: false, web: true }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), videoName, uuid, 'presence')
+        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
       }
     })
 
     it('Should only have mail notifications', async function () {
-      await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(baseUpdateNotificationParams, {
+      await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
         newVideoFromSubscription: UserNotificationSettingValue.EMAIL
       }))
 
@@ -593,23 +748,21 @@ describe('Test users notifications', function () {
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.EMAIL)
       }
 
-      const videoNameId = 62
-      const videoName = 'local video ' + videoNameId
-      const uuid = await uploadVideoByLocalAccount(servers, videoNameId)
+      const { name, uuid } = await uploadVideoByLocalAccount(servers)
 
       {
         const check = { mail: false, web: true }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), videoName, uuid, 'absence')
+        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
       }
 
       {
         const check = { mail: true, web: false }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), videoName, uuid, 'presence')
+        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
       }
     })
 
     it('Should have email and web notifications', async function () {
-      await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(baseUpdateNotificationParams, {
+      await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
         newVideoFromSubscription: UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL
       }))
 
@@ -619,11 +772,9 @@ describe('Test users notifications', function () {
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB_NOTIFICATION_AND_EMAIL)
       }
 
-      const videoNameId = 72
-      const videoName = 'local video ' + videoNameId
-      const uuid = await uploadVideoByLocalAccount(servers, videoNameId)
+      const { name, uuid } = await uploadVideoByLocalAccount(servers)
 
-      await checkNewVideoFromSubscription(baseParams, videoName, uuid, 'presence')
+      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
     })
   })