1 files changed, 63 insertions, 67 deletions

diff --git a/server/tests/api/notifications/notifications-api.ts b/server/tests/api/notifications/notifications-api.ts
index b81995449..fa4b53db6 100644
--- a/server/tests/api/notifications/notifications-api.ts
+++ b/server/tests/api/notifications/notifications-api.ts
@@ -2,28 +2,24 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { addUserSubscription } from '@shared/extra-utils/users/user-subscriptions'
-import { cleanupTests, getMyUserInformation, immutableAssign, uploadRandomVideo, waitJobs } from '../../../../shared/extra-utils'
-import { ServerInfo } from '../../../../shared/extra-utils/index'
-import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
 import {
   CheckerBaseParams,
   checkNewVideoFromSubscription,
+  cleanupTests,
   getAllNotificationsSettings,
-  getUserNotifications,
-  markAsReadAllNotifications,
-  markAsReadNotifications,
+  MockSmtpServer,
+  PeerTubeServer,
   prepareNotificationsTest,
-  updateMyNotificationSettings
-} from '../../../../shared/extra-utils/users/user-notifications'
-import { User, UserNotification, UserNotificationSettingValue } from '../../../../shared/models/users'
+  waitJobs
+} from '@shared/extra-utils'
+import { UserNotification, UserNotificationSettingValue } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test notifications API', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userNotifications: UserNotification[] = []
-  let userAccessToken: string
+  let userToken: string
   let emails: object[] = []
 
   before(async function () {
@@ -31,14 +27,14 @@ describe('Test notifications API', function () {
 
     const res = await prepareNotificationsTest(1)
     emails = res.emails
-    userAccessToken = res.userAccessToken
+    userToken = res.userAccessToken
     userNotifications = res.userNotifications
     server = res.servers[0]
 
-    await addUserSubscription(server.url, userAccessToken, 'root_channel@localhost:' + server.port)
+    await server.subscriptions.add({ token: userToken, targetUri: 'root_channel@localhost:' + server.port })
 
     for (let i = 0; i < 10; i++) {
-      await uploadRandomVideo(server, false)
+      await server.videos.randomUpload({ wait: false })
     }
 
     await waitJobs([ server ])
@@ -47,49 +43,46 @@ describe('Test notifications API', function () {
   describe('Mark as read', function () {
 
     it('Should mark as read some notifications', async function () {
-      const res = await getUserNotifications(server.url, userAccessToken, 2, 3)
-      const ids = res.body.data.map(n => n.id)
+      const { data } = await server.notifications.list({ token: userToken, start: 2, count: 3 })
+      const ids = data.map(n => n.id)
 
-      await markAsReadNotifications(server.url, userAccessToken, ids)
+      await server.notifications.markAsRead({ token: userToken, ids })
     })
 
     it('Should have the notifications marked as read', async function () {
-      const res = await getUserNotifications(server.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
+      const { data } = await server.notifications.list({ token: userToken, start: 0, count: 10 })
+
+      expect(data[0].read).to.be.false
+      expect(data[1].read).to.be.false
+      expect(data[2].read).to.be.true
+      expect(data[3].read).to.be.true
+      expect(data[4].read).to.be.true
+      expect(data[5].read).to.be.false
     })
 
     it('Should only list read notifications', async function () {
-      const res = await getUserNotifications(server.url, userAccessToken, 0, 10, false)
+      const { data } = await server.notifications.list({ token: userToken, start: 0, count: 10, unread: false })
 
-      const notifications = res.body.data as UserNotification[]
-      for (const notification of notifications) {
+      for (const notification of data) {
         expect(notification.read).to.be.true
       }
     })
 
     it('Should only list unread notifications', async function () {
-      const res = await getUserNotifications(server.url, userAccessToken, 0, 10, true)
+      const { data } = await server.notifications.list({ token: userToken, start: 0, count: 10, unread: true })
 
-      const notifications = res.body.data as UserNotification[]
-      for (const notification of notifications) {
+      for (const notification of data) {
         expect(notification.read).to.be.false
       }
     })
 
     it('Should mark as read all notifications', async function () {
-      await markAsReadAllNotifications(server.url, userAccessToken)
+      await server.notifications.markAsReadAll({ token: userToken })
 
-      const res = await getUserNotifications(server.url, userAccessToken, 0, 10, true)
+      const body = await server.notifications.list({ token: userToken, start: 0, count: 10, unread: true })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
     })
   })
 
@@ -101,97 +94,100 @@ describe('Test notifications API', function () {
         server: server,
         emails,
         socketNotifications: userNotifications,
-        token: userAccessToken
+        token: userToken
       }
     })
 
     it('Should not have notifications', async function () {
       this.timeout(20000)
 
-      await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
-        newVideoFromSubscription: UserNotificationSettingValue.NONE
-      }))
+      await server.notifications.updateMySettings({
+        token: userToken,
+        settings: { ...getAllNotificationsSettings(), newVideoFromSubscription: UserNotificationSettingValue.NONE }
+      })
 
       {
-        const res = await getMyUserInformation(server.url, userAccessToken)
-        const info = res.body as User
+        const info = await server.users.getMyInfo({ token: userToken })
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.NONE)
       }
 
-      const { name, uuid } = await uploadRandomVideo(server)
+      const { name, uuid } = await server.videos.randomUpload()
 
       const check = { web: true, mail: true }
-      await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
+      await checkNewVideoFromSubscription({ ...baseParams, check }, name, uuid, 'absence')
     })
 
     it('Should only have web notifications', async function () {
       this.timeout(20000)
 
-      await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
-        newVideoFromSubscription: UserNotificationSettingValue.WEB
-      }))
+      await server.notifications.updateMySettings({
+        token: userToken,
+        settings: { ...getAllNotificationsSettings(), newVideoFromSubscription: UserNotificationSettingValue.WEB }
+      })
 
       {
-        const res = await getMyUserInformation(server.url, userAccessToken)
-        const info = res.body as User
+        const info = await server.users.getMyInfo({ token: userToken })
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB)
       }
 
-      const { name, uuid } = await uploadRandomVideo(server)
+      const { name, uuid } = await server.videos.randomUpload()
 
       {
         const check = { mail: true, web: false }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
+        await checkNewVideoFromSubscription({ ...baseParams, check }, name, uuid, 'absence')
       }
 
       {
         const check = { mail: false, web: true }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
+        await checkNewVideoFromSubscription({ ...baseParams, check }, name, uuid, 'presence')
       }
     })
 
     it('Should only have mail notifications', async function () {
       this.timeout(20000)
 
-      await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
-        newVideoFromSubscription: UserNotificationSettingValue.EMAIL
-      }))
+      await server.notifications.updateMySettings({
+        token: userToken,
+        settings: { ...getAllNotificationsSettings(), newVideoFromSubscription: UserNotificationSettingValue.EMAIL }
+      })
 
       {
-        const res = await getMyUserInformation(server.url, userAccessToken)
-        const info = res.body as User
+        const info = await server.users.getMyInfo({ token: userToken })
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.EMAIL)
       }
 
-      const { name, uuid } = await uploadRandomVideo(server)
+      const { name, uuid } = await server.videos.randomUpload()
 
       {
         const check = { mail: false, web: true }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
+        await checkNewVideoFromSubscription({ ...baseParams, check }, name, uuid, 'absence')
       }
 
       {
         const check = { mail: true, web: false }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
+        await checkNewVideoFromSubscription({ ...baseParams, check }, name, uuid, 'presence')
       }
     })
 
     it('Should have email and web notifications', async function () {
       this.timeout(20000)
 
-      await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
-        newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
-      }))
+      await server.notifications.updateMySettings({
+        token: userToken,
+        settings: {
+          ...getAllNotificationsSettings(),
+          newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
+        }
+      })
 
       {
-        const res = await getMyUserInformation(server.url, userAccessToken)
-        const info = res.body as User
+        const info = await server.users.getMyInfo({ token: userToken })
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(
           UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
         )
       }
 
-      const { name, uuid } = await uploadRandomVideo(server)
+      const { name, uuid } = await server.videos.randomUpload()
 
       await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
     })