Shorter server command names

4 files changed, 138 insertions, 138 deletions

diff --git a/server/tests/api/moderation/abuses.ts b/server/tests/api/moderation/abuses.ts
index 7574b8f4a..97a0d95c4 100644
--- a/server/tests/api/moderation/abuses.ts
+++ b/server/tests/api/moderation/abuses.ts
@@ -33,7 +33,7 @@ describe('Test abuses', function () {
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
 
-    commands = servers.map(s => s.abusesCommand)
+    commands = servers.map(s => s.abuses)
   })
 
   describe('Video abuses', function () {
@@ -47,7 +47,7 @@ describe('Test abuses', function () {
           name: 'my super name for server 1',
           description: 'my super description for server 1'
         }
-        await servers[0].videosCommand.upload({ attributes })
+        await servers[0].videos.upload({ attributes })
       }
 
       {
@@ -55,17 +55,17 @@ describe('Test abuses', function () {
           name: 'my super name for server 2',
           description: 'my super description for server 2'
         }
-        await servers[1].videosCommand.upload({ attributes })
+        await servers[1].videos.upload({ attributes })
       }
 
       // Wait videos propagation, server 2 has transcoding enabled
       await waitJobs(servers)
 
-      const { data } = await servers[0].videosCommand.list()
+      const { data } = await servers[0].videos.list()
       expect(data.length).to.equal(2)
 
-      servers[0].video = data.find(video => video.name === 'my super name for server 1')
-      servers[1].video = data.find(video => video.name === 'my super name for server 2')
+      servers[0].store.video = data.find(video => video.name === 'my super name for server 1')
+      servers[1].store.video =  data.find(video => video.name === 'my super name for server 2')
     })
 
     it('Should not have abuses', async function () {
@@ -80,7 +80,7 @@ describe('Test abuses', function () {
       this.timeout(15000)
 
       const reason = 'my super bad reason'
-      await commands[0].report({ videoId: servers[0].video.id, reason })
+      await commands[0].report({ videoId: servers[0].store.video.id, reason })
 
       // We wait requests propagation, even if the server 1 is not supposed to make a request to server 2
       await waitJobs(servers)
@@ -100,7 +100,7 @@ describe('Test abuses', function () {
         expect(abuse.reporterAccount.name).to.equal('root')
         expect(abuse.reporterAccount.host).to.equal(servers[0].host)
 
-        expect(abuse.video.id).to.equal(servers[0].video.id)
+        expect(abuse.video.id).to.equal(servers[0].store.video.id)
         expect(abuse.video.channel).to.exist
 
         expect(abuse.comment).to.be.null
@@ -127,7 +127,7 @@ describe('Test abuses', function () {
       this.timeout(10000)
 
       const reason = 'my super bad reason 2'
-      const videoId = await servers[0].videosCommand.getId({ uuid: servers[1].video.uuid })
+      const videoId = await servers[0].videos.getId({ uuid: servers[1].store.video.uuid })
       await commands[0].report({ videoId, reason })
 
       // We wait requests propagation
@@ -146,7 +146,7 @@ describe('Test abuses', function () {
         expect(abuse1.reporterAccount.name).to.equal('root')
         expect(abuse1.reporterAccount.host).to.equal(servers[0].host)
 
-        expect(abuse1.video.id).to.equal(servers[0].video.id)
+        expect(abuse1.video.id).to.equal(servers[0].store.video.id)
         expect(abuse1.video.countReports).to.equal(1)
         expect(abuse1.video.nthReport).to.equal(1)
 
@@ -165,7 +165,7 @@ describe('Test abuses', function () {
         expect(abuse2.reporterAccount.name).to.equal('root')
         expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
 
-        expect(abuse2.video.id).to.equal(servers[1].video.id)
+        expect(abuse2.video.id).to.equal(servers[1].store.video.id)
 
         expect(abuse2.comment).to.be.null
 
@@ -200,7 +200,7 @@ describe('Test abuses', function () {
       this.timeout(10000)
 
       {
-        const videoId = await servers[1].videosCommand.getId({ uuid: servers[0].video.uuid })
+        const videoId = await servers[1].videos.getId({ uuid: servers[0].store.video.uuid })
         await commands[1].report({ videoId, reason: 'will mute this' })
         await waitJobs(servers)
 
@@ -211,7 +211,7 @@ describe('Test abuses', function () {
       const accountToBlock = 'root@' + servers[1].host
 
       {
-        await servers[0].blocklistCommand.addToServerBlocklist({ account: accountToBlock })
+        await servers[0].blocklist.addToServerBlocklist({ account: accountToBlock })
 
         const body = await commands[0].getAdminList()
         expect(body.total).to.equal(2)
@@ -221,7 +221,7 @@ describe('Test abuses', function () {
       }
 
       {
-        await servers[0].blocklistCommand.removeFromServerBlocklist({ account: accountToBlock })
+        await servers[0].blocklist.removeFromServerBlocklist({ account: accountToBlock })
 
         const body = await commands[0].getAdminList()
         expect(body.total).to.equal(3)
@@ -232,7 +232,7 @@ describe('Test abuses', function () {
       const serverToBlock = servers[1].host
 
       {
-        await servers[0].blocklistCommand.addToServerBlocklist({ server: serverToBlock })
+        await servers[0].blocklist.addToServerBlocklist({ server: serverToBlock })
 
         const body = await commands[0].getAdminList()
         expect(body.total).to.equal(2)
@@ -242,7 +242,7 @@ describe('Test abuses', function () {
       }
 
       {
-        await servers[0].blocklistCommand.removeFromServerBlocklist({ server: serverToBlock })
+        await servers[0].blocklist.removeFromServerBlocklist({ server: serverToBlock })
 
         const body = await commands[0].getAdminList()
         expect(body.total).to.equal(3)
@@ -252,7 +252,7 @@ describe('Test abuses', function () {
     it('Should keep the video abuse when deleting the video', async function () {
       this.timeout(10000)
 
-      await servers[1].videosCommand.remove({ id: abuseServer2.video.uuid })
+      await servers[1].videos.remove({ id: abuseServer2.video.uuid })
 
       await waitJobs(servers)
 
@@ -272,15 +272,15 @@ describe('Test abuses', function () {
 
       // register a second user to have two reporters/reportees
       const user = { username: 'user2', password: 'password' }
-      await servers[0].usersCommand.create({ ...user })
-      const userAccessToken = await servers[0].loginCommand.getAccessToken(user)
+      await servers[0].users.create({ ...user })
+      const userAccessToken = await servers[0].login.getAccessToken(user)
 
       // upload a third video via this user
       const attributes = {
         name: 'my second super name for server 1',
         description: 'my second super description for server 1'
       }
-      const { id } = await servers[0].videosCommand.upload({ token: userAccessToken, attributes })
+      const { id } = await servers[0].videos.upload({ token: userAccessToken, attributes })
       const video3Id = id
 
       // resume with the test
@@ -288,7 +288,7 @@ describe('Test abuses', function () {
       await commands[0].report({ videoId: video3Id, reason: reason3 })
 
       const reason4 = 'my super bad reason 4'
-      await commands[0].report({ token: userAccessToken, videoId: servers[0].video.id, reason: reason4 })
+      await commands[0].report({ token: userAccessToken, videoId: servers[0].store.video.id, reason: reason4 })
 
       {
         const body = await commands[0].getAdminList()
@@ -301,7 +301,7 @@ describe('Test abuses', function () {
         expect(abuseVideo3.countReportsForReportee).to.equal(1, "wrong reports count for reporter on video 3 abuse")
         expect(abuseVideo3.countReportsForReporter).to.equal(3, "wrong reports count for reportee on video 3 abuse")
 
-        const abuseServer1 = abuses.find(a => a.video.id === servers[0].video.id)
+        const abuseServer1 = abuses.find(a => a.video.id === servers[0].store.video.id)
         expect(abuseServer1.countReportsForReportee).to.equal(3, "wrong reports count for reporter on video 1 abuse")
       }
     })
@@ -312,7 +312,7 @@ describe('Test abuses', function () {
       const reason5 = 'my super bad reason 5'
       const predefinedReasons5: AbusePredefinedReasonsString[] = [ 'violentOrRepulsive', 'captions' ]
       const createRes = await commands[0].report({
-        videoId: servers[0].video.id,
+        videoId: servers[0].store.video.id,
         reason: reason5,
         predefinedReasons: predefinedReasons5,
         startAt: 1,
@@ -391,10 +391,10 @@ describe('Test abuses', function () {
 
     async function getComment (server: ServerInfo, videoIdArg: number | string) {
       const videoId = typeof videoIdArg === 'string'
-        ? await server.videosCommand.getId({ uuid: videoIdArg })
+        ? await server.videos.getId({ uuid: videoIdArg })
         : videoIdArg
 
-      const { data } = await server.commentsCommand.listThreads({ videoId })
+      const { data } = await server.comments.listThreads({ videoId })
 
       return data[0]
     }
@@ -402,11 +402,11 @@ describe('Test abuses', function () {
     before(async function () {
       this.timeout(50000)
 
-      servers[0].video = await await servers[0].videosCommand.quickUpload({ name: 'server 1' })
-      servers[1].video = await await servers[1].videosCommand.quickUpload({ name: 'server 2' })
+      servers[0].store.video = await await servers[0].videos.quickUpload({ name: 'server 1' })
+      servers[1].store.video =  await await servers[1].videos.quickUpload({ name: 'server 2' })
 
-      await servers[0].commentsCommand.createThread({ videoId: servers[0].video.id, text: 'comment server 1' })
-      await servers[1].commentsCommand.createThread({ videoId: servers[1].video.id, text: 'comment server 2' })
+      await servers[0].comments.createThread({ videoId: servers[0].store.video.id, text: 'comment server 1' })
+      await servers[1].comments.createThread({ videoId: servers[1].store.video.id, text: 'comment server 2' })
 
       await waitJobs(servers)
     })
@@ -414,7 +414,7 @@ describe('Test abuses', function () {
     it('Should report abuse on a comment', async function () {
       this.timeout(15000)
 
-      const comment = await getComment(servers[0], servers[0].video.id)
+      const comment = await getComment(servers[0], servers[0].store.video.id)
 
       const reason = 'it is a bad comment'
       await commands[0].report({ commentId: comment.id, reason })
@@ -424,7 +424,7 @@ describe('Test abuses', function () {
 
     it('Should have 1 comment abuse on server 1 and 0 on server 2', async function () {
       {
-        const comment = await getComment(servers[0], servers[0].video.id)
+        const comment = await getComment(servers[0], servers[0].store.video.id)
         const body = await commands[0].getAdminList({ filter: 'comment' })
 
         expect(body.total).to.equal(1)
@@ -442,8 +442,8 @@ describe('Test abuses', function () {
         expect(abuse.comment.id).to.equal(comment.id)
         expect(abuse.comment.text).to.equal(comment.text)
         expect(abuse.comment.video.name).to.equal('server 1')
-        expect(abuse.comment.video.id).to.equal(servers[0].video.id)
-        expect(abuse.comment.video.uuid).to.equal(servers[0].video.uuid)
+        expect(abuse.comment.video.id).to.equal(servers[0].store.video.id)
+        expect(abuse.comment.video.uuid).to.equal(servers[0].store.video.uuid)
 
         expect(abuse.countReportsForReporter).to.equal(5)
         expect(abuse.countReportsForReportee).to.equal(5)
@@ -459,7 +459,7 @@ describe('Test abuses', function () {
     it('Should report abuse on a remote comment', async function () {
       this.timeout(10000)
 
-      const comment = await getComment(servers[0], servers[1].video.uuid)
+      const comment = await getComment(servers[0], servers[1].store.video.uuid)
 
       const reason = 'it is a really bad comment'
       await commands[0].report({ commentId: comment.id, reason })
@@ -468,7 +468,7 @@ describe('Test abuses', function () {
     })
 
     it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () {
-      const commentServer2 = await getComment(servers[0], servers[1].video.id)
+      const commentServer2 = await getComment(servers[0], servers[1].store.video.id)
 
       {
         const body = await commands[0].getAdminList({ filter: 'comment' })
@@ -493,7 +493,7 @@ describe('Test abuses', function () {
         expect(abuse2.comment.id).to.equal(commentServer2.id)
         expect(abuse2.comment.text).to.equal(commentServer2.text)
         expect(abuse2.comment.video.name).to.equal('server 2')
-        expect(abuse2.comment.video.uuid).to.equal(servers[1].video.uuid)
+        expect(abuse2.comment.video.uuid).to.equal(servers[1].store.video.uuid)
 
         expect(abuse2.state.id).to.equal(AbuseState.PENDING)
         expect(abuse2.state.label).to.equal('Pending')
@@ -527,9 +527,9 @@ describe('Test abuses', function () {
     it('Should keep the comment abuse when deleting the comment', async function () {
       this.timeout(10000)
 
-      const commentServer2 = await getComment(servers[0], servers[1].video.id)
+      const commentServer2 = await getComment(servers[0], servers[1].store.video.id)
 
-      await servers[0].commentsCommand.delete({ videoId: servers[1].video.uuid, commentId: commentServer2.id })
+      await servers[0].comments.delete({ videoId: servers[1].store.video.uuid, commentId: commentServer2.id })
 
       await waitJobs(servers)
 
@@ -592,16 +592,16 @@ describe('Test abuses', function () {
   describe('Account abuses', function () {
 
     function getAccountFromServer (server: ServerInfo, targetName: string, targetServer: ServerInfo) {
-      return server.accountsCommand.get({ accountName: targetName + '@' + targetServer.host })
+      return server.accounts.get({ accountName: targetName + '@' + targetServer.host })
     }
 
     before(async function () {
       this.timeout(50000)
 
-      await servers[0].usersCommand.create({ username: 'user_1', password: 'donald' })
+      await servers[0].users.create({ username: 'user_1', password: 'donald' })
 
-      const token = await servers[1].usersCommand.generateUserAndToken('user_2')
-      await servers[1].videosCommand.upload({ token, attributes: { name: 'super video' } })
+      const token = await servers[1].users.generateUserAndToken('user_2')
+      await servers[1].videos.upload({ token, attributes: { name: 'super video' } })
 
       await waitJobs(servers)
     })
@@ -702,7 +702,7 @@ describe('Test abuses', function () {
       this.timeout(10000)
 
       const account = await getAccountFromServer(servers[1], 'user_2', servers[1])
-      await servers[1].usersCommand.remove({ userId: account.userId })
+      await servers[1].users.remove({ userId: account.userId })
 
       await waitJobs(servers)
 
@@ -759,11 +759,11 @@ describe('Test abuses', function () {
     let userAccessToken: string
 
     before(async function () {
-      userAccessToken = await servers[0].usersCommand.generateUserAndToken('user_42')
+      userAccessToken = await servers[0].users.generateUserAndToken('user_42')
 
-      await commands[0].report({ token: userAccessToken, videoId: servers[0].video.id, reason: 'user reason 1' })
+      await commands[0].report({ token: userAccessToken, videoId: servers[0].store.video.id, reason: 'user reason 1' })
 
-      const videoId = await servers[0].videosCommand.getId({ uuid: servers[1].video.uuid })
+      const videoId = await servers[0].videos.getId({ uuid: servers[1].store.video.uuid })
       await commands[0].report({ token: userAccessToken, videoId, reason: 'user reason 2' })
     })
 
@@ -830,9 +830,9 @@ describe('Test abuses', function () {
     let abuseMessageModerationId: number
 
     before(async function () {
-      userToken = await servers[0].usersCommand.generateUserAndToken('user_43')
+      userToken = await servers[0].users.generateUserAndToken('user_43')
 
-      const body = await commands[0].report({ token: userToken, videoId: servers[0].video.id, reason: 'user 43 reason 1' })
+      const body = await commands[0].report({ token: userToken, videoId: servers[0].store.video.id, reason: 'user 43 reason 1' })
       abuseId = body.abuse.id
     })
 
diff --git a/server/tests/api/moderation/blocklist-notification.ts b/server/tests/api/moderation/blocklist-notification.ts
index 92a0ec681..6b56fdd65 100644
--- a/server/tests/api/moderation/blocklist-notification.ts
+++ b/server/tests/api/moderation/blocklist-notification.ts
@@ -8,7 +8,7 @@ import { UserNotificationType } from '@shared/models'
 const expect = chai.expect
 
 async function checkNotifications (server: ServerInfo, token: string, expected: UserNotificationType[]) {
-  const { data } = await server.notificationsCommand.list({ token, start: 0, count: 10, unread: true })
+  const { data } = await server.notifications.list({ token, start: 0, count: 10, unread: true })
   expect(data).to.have.lengthOf(expected.length)
 
   for (const type of expected) {
@@ -26,24 +26,24 @@ describe('Test blocklist', function () {
 
   async function resetState () {
     try {
-      await servers[1].subscriptionsCommand.remove({ token: remoteUserToken, uri: 'user1_channel@' + servers[0].host })
-      await servers[1].subscriptionsCommand.remove({ token: remoteUserToken, uri: 'user2_channel@' + servers[0].host })
+      await servers[1].subscriptions.remove({ token: remoteUserToken, uri: 'user1_channel@' + servers[0].host })
+      await servers[1].subscriptions.remove({ token: remoteUserToken, uri: 'user2_channel@' + servers[0].host })
     } catch {}
 
     await waitJobs(servers)
 
-    await servers[0].notificationsCommand.markAsReadAll({ token: userToken1 })
-    await servers[0].notificationsCommand.markAsReadAll({ token: userToken2 })
+    await servers[0].notifications.markAsReadAll({ token: userToken1 })
+    await servers[0].notifications.markAsReadAll({ token: userToken2 })
 
     {
-      const { uuid } = await servers[0].videosCommand.upload({ token: userToken1, attributes: { name: 'video' } })
+      const { uuid } = await servers[0].videos.upload({ token: userToken1, attributes: { name: 'video' } })
       videoUUID = uuid
 
       await waitJobs(servers)
     }
 
     {
-      await servers[1].commentsCommand.createThread({
+      await servers[1].comments.createThread({
         token: remoteUserToken,
         videoId: videoUUID,
         text: '@user2@' + servers[0].host + ' hello'
@@ -52,8 +52,8 @@ describe('Test blocklist', function () {
 
     {
 
-      await servers[1].subscriptionsCommand.add({ token: remoteUserToken, targetUri: 'user1_channel@' + servers[0].host })
-      await servers[1].subscriptionsCommand.add({ token: remoteUserToken, targetUri: 'user2_channel@' + servers[0].host })
+      await servers[1].subscriptions.add({ token: remoteUserToken, targetUri: 'user1_channel@' + servers[0].host })
+      await servers[1].subscriptions.add({ token: remoteUserToken, targetUri: 'user2_channel@' + servers[0].host })
     }
 
     await waitJobs(servers)
@@ -67,29 +67,29 @@ describe('Test blocklist', function () {
 
     {
       const user = { username: 'user1', password: 'password' }
-      await servers[0].usersCommand.create({
+      await servers[0].users.create({
         username: user.username,
         password: user.password,
         videoQuota: -1,
         videoQuotaDaily: -1
       })
 
-      userToken1 = await servers[0].loginCommand.getAccessToken(user)
-      await servers[0].videosCommand.upload({ token: userToken1, attributes: { name: 'video user 1' } })
+      userToken1 = await servers[0].login.getAccessToken(user)
+      await servers[0].videos.upload({ token: userToken1, attributes: { name: 'video user 1' } })
     }
 
     {
       const user = { username: 'user2', password: 'password' }
-      await servers[0].usersCommand.create({ username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      userToken2 = await servers[0].loginCommand.getAccessToken(user)
+      userToken2 = await servers[0].login.getAccessToken(user)
     }
 
     {
       const user = { username: 'user3', password: 'password' }
-      await servers[1].usersCommand.create({ username: user.username, password: user.password })
+      await servers[1].users.create({ username: user.username, password: user.password })
 
-      remoteUserToken = await servers[1].loginCommand.getAccessToken(user)
+      remoteUserToken = await servers[1].login.getAccessToken(user)
     }
 
     await doubleFollow(servers[0], servers[1])
@@ -111,7 +111,7 @@ describe('Test blocklist', function () {
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await servers[0].blocklistCommand.addToMyBlocklist({ token: userToken1, account: 'user3@' + servers[1].host })
+      await servers[0].blocklist.addToMyBlocklist({ token: userToken1, account: 'user3@' + servers[1].host })
       await waitJobs(servers)
     })
 
@@ -124,7 +124,7 @@ describe('Test blocklist', function () {
 
       await checkNotifications(servers[0], userToken2, notifs)
 
-      await servers[0].blocklistCommand.removeFromMyBlocklist({ token: userToken1, account: 'user3@' + servers[1].host })
+      await servers[0].blocklist.removeFromMyBlocklist({ token: userToken1, account: 'user3@' + servers[1].host })
     })
   })
 
@@ -144,7 +144,7 @@ describe('Test blocklist', function () {
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await servers[0].blocklistCommand.addToMyBlocklist({ token: userToken1, server: servers[1].host })
+      await servers[0].blocklist.addToMyBlocklist({ token: userToken1, server: servers[1].host })
       await waitJobs(servers)
     })
 
@@ -157,7 +157,7 @@ describe('Test blocklist', function () {
 
       await checkNotifications(servers[0], userToken2, notifs)
 
-      await servers[0].blocklistCommand.removeFromMyBlocklist({ token: userToken1, server: servers[1].host })
+      await servers[0].blocklist.removeFromMyBlocklist({ token: userToken1, server: servers[1].host })
     })
   })
 
@@ -184,7 +184,7 @@ describe('Test blocklist', function () {
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await servers[0].blocklistCommand.addToServerBlocklist({ account: 'user3@' + servers[1].host })
+      await servers[0].blocklist.addToServerBlocklist({ account: 'user3@' + servers[1].host })
       await waitJobs(servers)
     })
 
@@ -192,7 +192,7 @@ describe('Test blocklist', function () {
       await checkNotifications(servers[0], userToken1, [])
       await checkNotifications(servers[0], userToken2, [])
 
-      await servers[0].blocklistCommand.removeFromServerBlocklist({ account: 'user3@' + servers[1].host })
+      await servers[0].blocklist.removeFromServerBlocklist({ account: 'user3@' + servers[1].host })
     })
   })
 
@@ -219,7 +219,7 @@ describe('Test blocklist', function () {
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await servers[0].blocklistCommand.addToServerBlocklist({ server: servers[1].host })
+      await servers[0].blocklist.addToServerBlocklist({ server: servers[1].host })
       await waitJobs(servers)
     })
 
diff --git a/server/tests/api/moderation/blocklist.ts b/server/tests/api/moderation/blocklist.ts
index 3c3b2d6fd..9a4a3b3b9 100644
--- a/server/tests/api/moderation/blocklist.ts
+++ b/server/tests/api/moderation/blocklist.ts
@@ -18,24 +18,24 @@ const expect = chai.expect
 
 async function checkAllVideos (server: ServerInfo, token: string) {
   {
-    const { data } = await server.videosCommand.listWithToken({ token })
+    const { data } = await server.videos.listWithToken({ token })
     expect(data).to.have.lengthOf(5)
   }
 
   {
-    const { data } = await server.videosCommand.list()
+    const { data } = await server.videos.list()
     expect(data).to.have.lengthOf(5)
   }
 }
 
 async function checkAllComments (server: ServerInfo, token: string, videoUUID: string) {
-  const { data } = await server.commentsCommand.listThreads({ videoId: videoUUID, start: 0, count: 25, sort: '-createdAt', token })
+  const { data } = await server.comments.listThreads({ videoId: videoUUID, start: 0, count: 25, sort: '-createdAt', token })
 
   const threads = data.filter(t => t.isDeleted === false)
   expect(threads).to.have.lengthOf(2)
 
   for (const thread of threads) {
-    const tree = await server.commentsCommand.getThread({ videoId: videoUUID, threadId: thread.id, token })
+    const tree = await server.comments.getThread({ videoId: videoUUID, threadId: thread.id, token })
     expect(tree.children).to.have.lengthOf(1)
   }
 }
@@ -45,13 +45,13 @@ async function checkCommentNotification (
   comment: { server: ServerInfo, token: string, videoUUID: string, text: string },
   check: 'presence' | 'absence'
 ) {
-  const command = comment.server.commentsCommand
+  const command = comment.server.comments
 
   const { threadId, createdAt } = await command.createThread({ token: comment.token, videoId: comment.videoUUID, text: comment.text })
 
   await waitJobs([ mainServer, comment.server ])
 
-  const { data } = await mainServer.notificationsCommand.list({ start: 0, count: 30 })
+  const { data } = await mainServer.notifications.list({ start: 0, count: 30 })
   const commentNotifications = data.filter(n => n.comment && n.comment.video.uuid === comment.videoUUID && n.createdAt >= createdAt)
 
   if (check === 'presence') expect(commentNotifications).to.have.lengthOf(1)
@@ -80,44 +80,44 @@ describe('Test blocklist', function () {
     servers = await flushAndRunMultipleServers(3)
     await setAccessTokensToServers(servers)
 
-    command = servers[0].blocklistCommand
-    commentsCommand = servers.map(s => s.commentsCommand)
+    command = servers[0].blocklist
+    commentsCommand = servers.map(s => s.comments)
 
     {
       const user = { username: 'user1', password: 'password' }
-      await servers[0].usersCommand.create({ username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      userToken1 = await servers[0].loginCommand.getAccessToken(user)
-      await servers[0].videosCommand.upload({ token: userToken1, attributes: { name: 'video user 1' } })
+      userToken1 = await servers[0].login.getAccessToken(user)
+      await servers[0].videos.upload({ token: userToken1, attributes: { name: 'video user 1' } })
     }
 
     {
       const user = { username: 'moderator', password: 'password' }
-      await servers[0].usersCommand.create({ username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      userModeratorToken = await servers[0].loginCommand.getAccessToken(user)
+      userModeratorToken = await servers[0].login.getAccessToken(user)
     }
 
     {
       const user = { username: 'user2', password: 'password' }
-      await servers[1].usersCommand.create({ username: user.username, password: user.password })
+      await servers[1].users.create({ username: user.username, password: user.password })
 
-      userToken2 = await servers[1].loginCommand.getAccessToken(user)
-      await servers[1].videosCommand.upload({ token: userToken2, attributes: { name: 'video user 2' } })
+      userToken2 = await servers[1].login.getAccessToken(user)
+      await servers[1].videos.upload({ token: userToken2, attributes: { name: 'video user 2' } })
     }
 
     {
-      const { uuid } = await servers[0].videosCommand.upload({ attributes: { name: 'video server 1' } })
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video server 1' } })
       videoUUID1 = uuid
     }
 
     {
-      const { uuid } = await servers[1].videosCommand.upload({ attributes: { name: 'video server 2' } })
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video server 2' } })
       videoUUID2 = uuid
     }
 
     {
-      const { uuid } = await servers[0].videosCommand.upload({ attributes: { name: 'video 2 server 1' } })
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video 2 server 1' } })
       videoUUID3 = uuid
     }
 
@@ -159,7 +159,7 @@ describe('Test blocklist', function () {
       })
 
       it('Should hide its videos', async function () {
-        const { data } = await servers[0].videosCommand.listWithToken()
+        const { data } = await servers[0].videos.listWithToken()
 
         expect(data).to.have.lengthOf(4)
 
@@ -172,7 +172,7 @@ describe('Test blocklist', function () {
       })
 
       it('Should hide its videos', async function () {
-        const { data } = await servers[0].videosCommand.listWithToken()
+        const { data } = await servers[0].videos.listWithToken()
 
         expect(data).to.have.lengthOf(3)
 
@@ -289,12 +289,12 @@ describe('Test blocklist', function () {
 
         // Server 1 and 3 should only have uploader comments
         for (const server of [ servers[0], servers[2] ]) {
-          const { data } = await server.commentsCommand.listThreads({ videoId: videoUUID3, count: 25, sort: '-createdAt' })
+          const { data } = await server.comments.listThreads({ videoId: videoUUID3, count: 25, sort: '-createdAt' })
 
           expect(data).to.have.lengthOf(1)
           expect(data[0].text).to.equal('uploader')
 
-          const tree = await server.commentsCommand.getThread({ videoId: videoUUID3, threadId: data[0].id })
+          const tree = await server.comments.getThread({ videoId: videoUUID3, threadId: data[0].id })
 
           if (server.serverNumber === 1) expect(tree.children).to.have.lengthOf(0)
           else expect(tree.children).to.have.lengthOf(1)
@@ -306,7 +306,7 @@ describe('Test blocklist', function () {
       })
 
       it('Should display its videos', async function () {
-        const { data } = await servers[0].videosCommand.listWithToken()
+        const { data } = await servers[0].videos.listWithToken()
         expect(data).to.have.lengthOf(4)
 
         const v = data.find(v => v.name === 'video user 2')
@@ -315,7 +315,7 @@ describe('Test blocklist', function () {
 
       it('Should display its comments on my video', async function () {
         for (const server of servers) {
-          const { data } = await server.commentsCommand.listThreads({ videoId: videoUUID3, count: 25, sort: '-createdAt' })
+          const { data } = await server.comments.listThreads({ videoId: videoUUID3, count: 25, sort: '-createdAt' })
 
           // Server 3 should not have 2 comment threads, because server 1 did not forward the server 2 comment
           if (server.serverNumber === 3) {
@@ -327,7 +327,7 @@ describe('Test blocklist', function () {
           expect(data[0].text).to.equal('uploader')
           expect(data[1].text).to.equal('comment user 2')
 
-          const tree = await server.commentsCommand.getThread({ videoId: videoUUID3, threadId: data[0].id })
+          const tree = await server.comments.getThread({ videoId: videoUUID3, threadId: data[0].id })
           expect(tree.children).to.have.lengthOf(1)
           expect(tree.children[0].comment.text).to.equal('reply by user 2')
           expect(tree.children[0].children).to.have.lengthOf(1)
@@ -378,7 +378,7 @@ describe('Test blocklist', function () {
       })
 
       it('Should hide its videos', async function () {
-        const { data } = await servers[0].videosCommand.listWithToken()
+        const { data } = await servers[0].videos.listWithToken()
 
         expect(data).to.have.lengthOf(3)
 
@@ -488,7 +488,7 @@ describe('Test blocklist', function () {
 
       it('Should hide its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const { data } = await servers[0].videosCommand.listWithToken({ token })
+          const { data } = await servers[0].videos.listWithToken({ token })
 
           expect(data).to.have.lengthOf(4)
 
@@ -503,7 +503,7 @@ describe('Test blocklist', function () {
 
       it('Should hide its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const { data } = await servers[0].videosCommand.listWithToken({ token })
+          const { data } = await servers[0].videos.listWithToken({ token })
 
           expect(data).to.have.lengthOf(3)
 
@@ -581,7 +581,7 @@ describe('Test blocklist', function () {
 
       it('Should display its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const { data } = await servers[0].videosCommand.listWithToken({ token })
+          const { data } = await servers[0].videos.listWithToken({ token })
           expect(data).to.have.lengthOf(4)
 
           const v = data.find(v => v.name === 'video user 2')
@@ -639,8 +639,8 @@ describe('Test blocklist', function () {
       it('Should hide its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
           const requests = [
-            servers[0].videosCommand.list(),
-            servers[0].videosCommand.listWithToken({ token })
+            servers[0].videos.list(),
+            servers[0].videos.listWithToken({ token })
           ]
 
           for (const req of requests) {
@@ -688,13 +688,13 @@ describe('Test blocklist', function () {
 
         {
           const now = new Date()
-          await servers[1].followsCommand.unfollow({ target: servers[0] })
+          await servers[1].follows.unfollow({ target: servers[0] })
           await waitJobs(servers)
-          await servers[1].followsCommand.follow({ targets: [ servers[0].host ] })
+          await servers[1].follows.follow({ targets: [ servers[0].host ] })
 
           await waitJobs(servers)
 
-          const { data } = await servers[0].notificationsCommand.list({ start: 0, count: 30 })
+          const { data } = await servers[0].notifications.list({ start: 0, count: 30 })
           const commentNotifications = data.filter(n => {
             return n.type === UserNotificationType.NEW_INSTANCE_FOLLOWER && n.createdAt >= now.toISOString()
           })
@@ -749,13 +749,13 @@ describe('Test blocklist', function () {
 
         {
           const now = new Date()
-          await servers[1].followsCommand.unfollow({ target: servers[0] })
+          await servers[1].follows.unfollow({ target: servers[0] })
           await waitJobs(servers)
-          await servers[1].followsCommand.follow({ targets: [ servers[0].host ] })
+          await servers[1].follows.follow({ targets: [ servers[0].host ] })
 
           await waitJobs(servers)
 
-          const { data } = await servers[0].notificationsCommand.list({ start: 0, count: 30 })
+          const { data } = await servers[0].notifications.list({ start: 0, count: 30 })
           const commentNotifications = data.filter(n => {
             return n.type === UserNotificationType.NEW_INSTANCE_FOLLOWER && n.createdAt >= now.toISOString()
           })
diff --git a/server/tests/api/moderation/video-blacklist.ts b/server/tests/api/moderation/video-blacklist.ts
index 2f2e678e7..d23d23bcb 100644
--- a/server/tests/api/moderation/video-blacklist.ts
+++ b/server/tests/api/moderation/video-blacklist.ts
@@ -25,10 +25,10 @@ describe('Test video blacklist', function () {
   let command: BlacklistCommand
 
   async function blacklistVideosOnServer (server: ServerInfo) {
-    const { data } = await server.videosCommand.list()
+    const { data } = await server.videos.list()
 
     for (const video of data) {
-      await server.blacklistCommand.add({ videoId: video.id, reason: 'super reason' })
+      await server.blacklist.add({ videoId: video.id, reason: 'super reason' })
     }
   }
 
@@ -45,13 +45,13 @@ describe('Test video blacklist', function () {
     await doubleFollow(servers[0], servers[1])
 
     // Upload 2 videos on server 2
-    await servers[1].videosCommand.upload({ attributes: { name: 'My 1st video', description: 'A video on server 2' } })
-    await servers[1].videosCommand.upload({ attributes: { name: 'My 2nd video', description: 'A video on server 2' } })
+    await servers[1].videos.upload({ attributes: { name: 'My 1st video', description: 'A video on server 2' } })
+    await servers[1].videos.upload({ attributes: { name: 'My 2nd video', description: 'A video on server 2' } })
 
     // Wait videos propagation, server 2 has transcoding enabled
     await waitJobs(servers)
 
-    command = servers[0].blacklistCommand
+    command = servers[0].blacklist
 
     // Blacklist the two videos on server 1
     await blacklistVideosOnServer(servers[0])
@@ -61,7 +61,7 @@ describe('Test video blacklist', function () {
 
     it('Should not have the video blacklisted in videos list/search on server 1', async function () {
       {
-        const { total, data } = await servers[0].videosCommand.list()
+        const { total, data } = await servers[0].videos.list()
 
         expect(total).to.equal(0)
         expect(data).to.be.an('array')
@@ -69,7 +69,7 @@ describe('Test video blacklist', function () {
       }
 
       {
-        const body = await servers[0].searchCommand.searchVideos({ search: 'video' })
+        const body = await servers[0].search.searchVideos({ search: 'video' })
 
         expect(body.total).to.equal(0)
         expect(body.data).to.be.an('array')
@@ -79,7 +79,7 @@ describe('Test video blacklist', function () {
 
     it('Should have the blacklisted video in videos list/search on server 2', async function () {
       {
-        const { total, data } = await servers[1].videosCommand.list()
+        const { total, data } = await servers[1].videos.list()
 
         expect(total).to.equal(2)
         expect(data).to.be.an('array')
@@ -87,7 +87,7 @@ describe('Test video blacklist', function () {
       }
 
       {
-        const body = await servers[1].searchCommand.searchVideos({ search: 'video' })
+        const body = await servers[1].search.searchVideos({ search: 'video' })
 
         expect(body.total).to.equal(2)
         expect(body.data).to.be.an('array')
@@ -181,7 +181,7 @@ describe('Test video blacklist', function () {
     it('Should display blacklisted videos', async function () {
       await blacklistVideosOnServer(servers[1])
 
-      const { total, data } = await servers[1].videosCommand.listMyVideos()
+      const { total, data } = await servers[1].videos.listMyVideos()
 
       expect(total).to.equal(2)
       expect(data).to.have.lengthOf(2)
@@ -198,7 +198,7 @@ describe('Test video blacklist', function () {
     let blacklist = []
 
     it('Should not have any video in videos list on server 1', async function () {
-      const { total, data } = await servers[0].videosCommand.list()
+      const { total, data } = await servers[0].videos.list()
       expect(total).to.equal(0)
       expect(data).to.be.an('array')
       expect(data.length).to.equal(0)
@@ -215,7 +215,7 @@ describe('Test video blacklist', function () {
     })
 
     it('Should have the ex-blacklisted video in videos list on server 1', async function () {
-      const { total, data } = await servers[0].videosCommand.list()
+      const { total, data } = await servers[0].videos.list()
       expect(total).to.equal(1)
 
       expect(data).to.be.an('array')
@@ -244,11 +244,11 @@ describe('Test video blacklist', function () {
       this.timeout(10000)
 
       {
-        const { uuid } = await servers[0].videosCommand.upload({ attributes: { name: 'Video 3' } })
+        const { uuid } = await servers[0].videos.upload({ attributes: { name: 'Video 3' } })
         video3UUID = uuid
       }
       {
-        const { uuid } = await servers[0].videosCommand.upload({ attributes: { name: 'Video 4' } })
+        const { uuid } = await servers[0].videos.upload({ attributes: { name: 'Video 4' } })
         video4UUID = uuid
       }
 
@@ -263,12 +263,12 @@ describe('Test video blacklist', function () {
       await waitJobs(servers)
 
       {
-        const { data } = await servers[0].videosCommand.list()
+        const { data } = await servers[0].videos.list()
         expect(data.find(v => v.uuid === video3UUID)).to.be.undefined
       }
 
       {
-        const { data } = await servers[1].videosCommand.list()
+        const { data } = await servers[1].videos.list()
         expect(data.find(v => v.uuid === video3UUID)).to.not.be.undefined
       }
     })
@@ -281,7 +281,7 @@ describe('Test video blacklist', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const { data } = await server.videosCommand.list()
+        const { data } = await server.videos.list()
         expect(data.find(v => v.uuid === video4UUID)).to.be.undefined
       }
     })
@@ -289,12 +289,12 @@ describe('Test video blacklist', function () {
     it('Should have the video unfederated even after an Update AP message', async function () {
       this.timeout(10000)
 
-      await servers[0].videosCommand.update({ id: video4UUID, attributes: { description: 'super description' } })
+      await servers[0].videos.update({ id: video4UUID, attributes: { description: 'super description' } })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const { data } = await server.videosCommand.list()
+        const { data } = await server.videos.list()
         expect(data.find(v => v.uuid === video4UUID)).to.be.undefined
       }
     })
@@ -318,7 +318,7 @@ describe('Test video blacklist', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const { data } = await server.videosCommand.list()
+        const { data } = await server.videos.list()
         expect(data.find(v => v.uuid === video4UUID)).to.not.be.undefined
       }
     })
@@ -348,36 +348,36 @@ describe('Test video blacklist', function () {
 
       {
         const user = { username: 'user_without_flag', password: 'password' }
-        await servers[0].usersCommand.create({
+        await servers[0].users.create({
           username: user.username,
           adminFlags: UserAdminFlag.NONE,
           password: user.password,
           role: UserRole.USER
         })
 
-        userWithoutFlag = await servers[0].loginCommand.getAccessToken(user)
+        userWithoutFlag = await servers[0].login.getAccessToken(user)
 
-        const { videoChannels } = await servers[0].usersCommand.getMyInfo({ token: userWithoutFlag })
+        const { videoChannels } = await servers[0].users.getMyInfo({ token: userWithoutFlag })
         channelOfUserWithoutFlag = videoChannels[0].id
       }
 
       {
         const user = { username: 'user_with_flag', password: 'password' }
-        await servers[0].usersCommand.create({
+        await servers[0].users.create({
           username: user.username,
           adminFlags: UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST,
           password: user.password,
           role: UserRole.USER
         })
 
-        userWithFlag = await servers[0].loginCommand.getAccessToken(user)
+        userWithFlag = await servers[0].login.getAccessToken(user)
       }
 
       await waitJobs(servers)
     })
 
     it('Should auto blacklist a video on upload', async function () {
-      await servers[0].videosCommand.upload({ token: userWithoutFlag, attributes: { name: 'blacklisted' } })
+      await servers[0].videos.upload({ token: userWithoutFlag, attributes: { name: 'blacklisted' } })
 
       const body = await command.list({ type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
       expect(body.total).to.equal(1)
@@ -392,7 +392,7 @@ describe('Test video blacklist', function () {
         name: 'URL import',
         channelId: channelOfUserWithoutFlag
       }
-      await servers[0].importsCommand.importVideo({ token: userWithoutFlag, attributes })
+      await servers[0].imports.importVideo({ token: userWithoutFlag, attributes })
 
       const body = await command.list({ sort: 'createdAt', type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
       expect(body.total).to.equal(2)
@@ -405,7 +405,7 @@ describe('Test video blacklist', function () {
         name: 'Torrent import',
         channelId: channelOfUserWithoutFlag
       }
-      await servers[0].importsCommand.importVideo({ token: userWithoutFlag, attributes })
+      await servers[0].imports.importVideo({ token: userWithoutFlag, attributes })
 
       const body = await command.list({ sort: 'createdAt', type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
       expect(body.total).to.equal(3)
@@ -413,7 +413,7 @@ describe('Test video blacklist', function () {
     })
 
     it('Should not auto blacklist a video on upload if the user has the bypass blacklist flag', async function () {
-      await servers[0].videosCommand.upload({ token: userWithFlag, attributes: { name: 'not blacklisted' } })
+      await servers[0].videos.upload({ token: userWithFlag, attributes: { name: 'not blacklisted' } })
 
       const body = await command.list({ type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
       expect(body.total).to.equal(3)