4 files changed, 715 insertions, 912 deletions

diff --git a/server/tests/api/moderation/abuses.ts b/server/tests/api/moderation/abuses.ts
index fb765e7e3..8d6360eb3 100644
--- a/server/tests/api/moderation/abuses.ts
+++ b/server/tests/api/moderation/abuses.ts
@@ -3,70 +3,37 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  AbuseFilter,
-  AbuseMessage,
-  AbusePredefinedReasonsString,
-  AbuseState,
-  Account,
-  AdminAbuse,
-  UserAbuse,
-  VideoComment
-} from '@shared/models'
-import {
-  addAbuseMessage,
-  addVideoCommentThread,
+  AbusesCommand,
   cleanupTests,
-  createUser,
-  deleteAbuse,
-  deleteAbuseMessage,
-  deleteVideoComment,
-  flushAndRunMultipleServers,
-  generateUserAccessToken,
-  getAccount,
-  getAdminAbusesList,
-  getUserAbusesList,
-  getVideoCommentThreads,
-  getVideoIdFromUUID,
-  getVideosList,
-  immutableAssign,
-  listAbuseMessages,
-  removeUser,
-  removeVideo,
-  reportAbuse,
-  ServerInfo,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateAbuse,
-  uploadVideo,
-  uploadVideoAndGetId,
-  userLogin
-} from '../../../../shared/extra-utils/index'
-import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  addAccountToServerBlocklist,
-  addServerToServerBlocklist,
-  removeAccountFromServerBlocklist,
-  removeServerFromServerBlocklist
-} from '../../../../shared/extra-utils/users/blocklist'
+  waitJobs
+} from '@shared/extra-utils'
+import { AbuseMessage, AbusePredefinedReasonsString, AbuseState, AdminAbuse, UserAbuse } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test abuses', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let abuseServer1: AdminAbuse
   let abuseServer2: AdminAbuse
+  let commands: AbusesCommand[]
 
   before(async function () {
     this.timeout(50000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
 
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
+
+    commands = servers.map(s => s.abuses)
   })
 
   describe('Video abuses', function () {
@@ -75,179 +42,189 @@ describe('Test abuses', function () {
       this.timeout(50000)
 
       // Upload some videos on each servers
-      const video1Attributes = {
-        name: 'my super name for server 1',
-        description: 'my super description for server 1'
+      {
+        const attributes = {
+          name: 'my super name for server 1',
+          description: 'my super description for server 1'
+        }
+        await servers[0].videos.upload({ attributes })
       }
-      await uploadVideo(servers[0].url, servers[0].accessToken, video1Attributes)
 
-      const video2Attributes = {
-        name: 'my super name for server 2',
-        description: 'my super description for server 2'
+      {
+        const attributes = {
+          name: 'my super name for server 2',
+          description: 'my super description for server 2'
+        }
+        await servers[1].videos.upload({ attributes })
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, video2Attributes)
 
       // Wait videos propagation, server 2 has transcoding enabled
       await waitJobs(servers)
 
-      const res = await getVideosList(servers[0].url)
-      const videos = res.body.data
+      const { data } = await servers[0].videos.list()
+      expect(data.length).to.equal(2)
 
-      expect(videos.length).to.equal(2)
-
-      servers[0].video = videos.find(video => video.name === 'my super name for server 1')
-      servers[1].video = videos.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 () {
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
+      const body = await commands[0].getAdminList()
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data.length).to.equal(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data.length).to.equal(0)
     })
 
     it('Should report abuse on a local video', async function () {
       this.timeout(15000)
 
       const reason = 'my super bad reason'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, 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)
     })
 
     it('Should have 1 video abuses on server 1 and 0 on server 2', async function () {
-      const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
+      {
+        const body = await commands[0].getAdminList()
 
-      expect(res1.body.total).to.equal(1)
-      expect(res1.body.data).to.be.an('array')
-      expect(res1.body.data.length).to.equal(1)
+        expect(body.total).to.equal(1)
+        expect(body.data).to.be.an('array')
+        expect(body.data.length).to.equal(1)
 
-      const abuse: AdminAbuse = res1.body.data[0]
-      expect(abuse.reason).to.equal('my super bad reason')
+        const abuse = body.data[0]
+        expect(abuse.reason).to.equal('my super bad reason')
 
-      expect(abuse.reporterAccount.name).to.equal('root')
-      expect(abuse.reporterAccount.host).to.equal(servers[0].host)
+        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.channel).to.exist
+        expect(abuse.video.id).to.equal(servers[0].store.video.id)
+        expect(abuse.video.channel).to.exist
 
-      expect(abuse.comment).to.be.null
+        expect(abuse.comment).to.be.null
 
-      expect(abuse.flaggedAccount.name).to.equal('root')
-      expect(abuse.flaggedAccount.host).to.equal(servers[0].host)
+        expect(abuse.flaggedAccount.name).to.equal('root')
+        expect(abuse.flaggedAccount.host).to.equal(servers[0].host)
 
-      expect(abuse.video.countReports).to.equal(1)
-      expect(abuse.video.nthReport).to.equal(1)
+        expect(abuse.video.countReports).to.equal(1)
+        expect(abuse.video.nthReport).to.equal(1)
 
-      expect(abuse.countReportsForReporter).to.equal(1)
-      expect(abuse.countReportsForReportee).to.equal(1)
+        expect(abuse.countReportsForReporter).to.equal(1)
+        expect(abuse.countReportsForReportee).to.equal(1)
+      }
 
-      const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken })
-      expect(res2.body.total).to.equal(0)
-      expect(res2.body.data).to.be.an('array')
-      expect(res2.body.data.length).to.equal(0)
+      {
+        const body = await commands[1].getAdminList()
+        expect(body.total).to.equal(0)
+        expect(body.data).to.be.an('array')
+        expect(body.data.length).to.equal(0)
+      }
     })
 
     it('Should report abuse on a remote video', async function () {
       this.timeout(10000)
 
       const reason = 'my super bad reason 2'
-      const videoId = await getVideoIdFromUUID(servers[0].url, servers[1].video.uuid)
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId, reason })
+      const videoId = await servers[0].videos.getId({ uuid: servers[1].store.video.uuid })
+      await commands[0].report({ videoId, reason })
 
       // We wait requests propagation
       await waitJobs(servers)
     })
 
     it('Should have 2 video abuses on server 1 and 1 on server 2', async function () {
-      const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
+      {
+        const body = await commands[0].getAdminList()
 
-      expect(res1.body.total).to.equal(2)
-      expect(res1.body.data.length).to.equal(2)
+        expect(body.total).to.equal(2)
+        expect(body.data.length).to.equal(2)
 
-      const abuse1: AdminAbuse = res1.body.data[0]
-      expect(abuse1.reason).to.equal('my super bad reason')
-      expect(abuse1.reporterAccount.name).to.equal('root')
-      expect(abuse1.reporterAccount.host).to.equal(servers[0].host)
+        const abuse1 = body.data[0]
+        expect(abuse1.reason).to.equal('my super bad reason')
+        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.countReports).to.equal(1)
-      expect(abuse1.video.nthReport).to.equal(1)
+        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)
 
-      expect(abuse1.comment).to.be.null
+        expect(abuse1.comment).to.be.null
 
-      expect(abuse1.flaggedAccount.name).to.equal('root')
-      expect(abuse1.flaggedAccount.host).to.equal(servers[0].host)
+        expect(abuse1.flaggedAccount.name).to.equal('root')
+        expect(abuse1.flaggedAccount.host).to.equal(servers[0].host)
 
-      expect(abuse1.state.id).to.equal(AbuseState.PENDING)
-      expect(abuse1.state.label).to.equal('Pending')
-      expect(abuse1.moderationComment).to.be.null
+        expect(abuse1.state.id).to.equal(AbuseState.PENDING)
+        expect(abuse1.state.label).to.equal('Pending')
+        expect(abuse1.moderationComment).to.be.null
 
-      const abuse2: AdminAbuse = res1.body.data[1]
-      expect(abuse2.reason).to.equal('my super bad reason 2')
+        const abuse2 = body.data[1]
+        expect(abuse2.reason).to.equal('my super bad reason 2')
 
-      expect(abuse2.reporterAccount.name).to.equal('root')
-      expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
+        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
+        expect(abuse2.comment).to.be.null
 
-      expect(abuse2.flaggedAccount.name).to.equal('root')
-      expect(abuse2.flaggedAccount.host).to.equal(servers[1].host)
+        expect(abuse2.flaggedAccount.name).to.equal('root')
+        expect(abuse2.flaggedAccount.host).to.equal(servers[1].host)
 
-      expect(abuse2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuse2.state.label).to.equal('Pending')
-      expect(abuse2.moderationComment).to.be.null
+        expect(abuse2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuse2.state.label).to.equal('Pending')
+        expect(abuse2.moderationComment).to.be.null
+      }
 
-      const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken })
-      expect(res2.body.total).to.equal(1)
-      expect(res2.body.data.length).to.equal(1)
+      {
+        const body = await commands[1].getAdminList()
+        expect(body.total).to.equal(1)
+        expect(body.data.length).to.equal(1)
 
-      abuseServer2 = res2.body.data[0]
-      expect(abuseServer2.reason).to.equal('my super bad reason 2')
-      expect(abuseServer2.reporterAccount.name).to.equal('root')
-      expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
+        abuseServer2 = body.data[0]
+        expect(abuseServer2.reason).to.equal('my super bad reason 2')
+        expect(abuseServer2.reporterAccount.name).to.equal('root')
+        expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuse2.flaggedAccount.name).to.equal('root')
-      expect(abuse2.flaggedAccount.host).to.equal(servers[1].host)
+        expect(abuseServer2.flaggedAccount.name).to.equal('root')
+        expect(abuseServer2.flaggedAccount.host).to.equal(servers[1].host)
 
-      expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuseServer2.state.label).to.equal('Pending')
-      expect(abuseServer2.moderationComment).to.be.null
+        expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuseServer2.state.label).to.equal('Pending')
+        expect(abuseServer2.moderationComment).to.be.null
+      }
     })
 
     it('Should hide video abuses from blocked accounts', async function () {
       this.timeout(10000)
 
       {
-        const videoId = await getVideoIdFromUUID(servers[1].url, servers[0].video.uuid)
-        await reportAbuse({ url: servers[1].url, token: servers[1].accessToken, videoId, reason: 'will mute this' })
+        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)
 
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(3)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(3)
       }
 
       const accountToBlock = 'root@' + servers[1].host
 
       {
-        await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, accountToBlock)
+        await servers[0].blocklist.addToServerBlocklist({ account: accountToBlock })
 
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(2)
 
-        const abuse = res.body.data.find(a => a.reason === 'will mute this')
+        const abuse = body.data.find(a => a.reason === 'will mute this')
         expect(abuse).to.be.undefined
       }
 
       {
-        await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, accountToBlock)
+        await servers[0].blocklist.removeFromServerBlocklist({ account: accountToBlock })
 
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(3)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(3)
       }
     })
 
@@ -255,35 +232,35 @@ describe('Test abuses', function () {
       const serverToBlock = servers[1].host
 
       {
-        await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, servers[1].host)
+        await servers[0].blocklist.addToServerBlocklist({ server: serverToBlock })
 
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(2)
 
-        const abuse = res.body.data.find(a => a.reason === 'will mute this')
+        const abuse = body.data.find(a => a.reason === 'will mute this')
         expect(abuse).to.be.undefined
       }
 
       {
-        await removeServerFromServerBlocklist(servers[0].url, servers[0].accessToken, serverToBlock)
+        await servers[0].blocklist.removeFromServerBlocklist({ server: serverToBlock })
 
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(3)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(3)
       }
     })
 
     it('Should keep the video abuse when deleting the video', async function () {
       this.timeout(10000)
 
-      await removeVideo(servers[1].url, servers[1].accessToken, abuseServer2.video.uuid)
+      await servers[1].videos.remove({ id: abuseServer2.video.uuid })
 
       await waitJobs(servers)
 
-      const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken })
-      expect(res.body.total).to.equal(2, "wrong number of videos returned")
-      expect(res.body.data).to.have.lengthOf(2, "wrong number of videos returned")
+      const body = await commands[1].getAdminList()
+      expect(body.total).to.equal(2, "wrong number of videos returned")
+      expect(body.data).to.have.lengthOf(2, "wrong number of videos returned")
 
-      const abuse: AdminAbuse = res.body.data[0]
+      const abuse = body.data[0]
       expect(abuse.id).to.equal(abuseServer2.id, "wrong origin server id for first video")
       expect(abuse.video.id).to.equal(abuseServer2.video.id, "wrong video id")
       expect(abuse.video.channel).to.exist
@@ -295,39 +272,36 @@ describe('Test abuses', function () {
 
       // register a second user to have two reporters/reportees
       const user = { username: 'user2', password: 'password' }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, ...user })
-      const userAccessToken = await userLogin(servers[0], user)
+      await servers[0].users.create({ ...user })
+      const userAccessToken = await servers[0].login.getAccessToken(user)
 
       // upload a third video via this user
-      const video3Attributes = {
+      const attributes = {
         name: 'my second super name for server 1',
         description: 'my second super description for server 1'
       }
-      await uploadVideo(servers[0].url, userAccessToken, video3Attributes)
-
-      const res1 = await getVideosList(servers[0].url)
-      const videos = res1.body.data
-      const video3 = videos.find(video => video.name === 'my second super name for server 1')
+      const { id } = await servers[0].videos.upload({ token: userAccessToken, attributes })
+      const video3Id = id
 
       // resume with the test
       const reason3 = 'my super bad reason 3'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId: video3.id, reason: reason3 })
+      await commands[0].report({ videoId: video3Id, reason: reason3 })
 
       const reason4 = 'my super bad reason 4'
-      await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: servers[0].video.id, reason: reason4 })
+      await commands[0].report({ token: userAccessToken, videoId: servers[0].store.video.id, reason: reason4 })
 
       {
-        const res2 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        const abuses = res2.body.data as AdminAbuse[]
+        const body = await commands[0].getAdminList()
+        const abuses = body.data
 
-        const abuseVideo3 = res2.body.data.find(a => a.video.id === video3.id)
+        const abuseVideo3 = body.data.find(a => a.video.id === video3Id)
         expect(abuseVideo3).to.not.be.undefined
         expect(abuseVideo3.video.countReports).to.equal(1, "wrong reports count for video 3")
         expect(abuseVideo3.video.nthReport).to.equal(1, "wrong report position in report list for video 3")
         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")
       }
     })
@@ -337,20 +311,18 @@ describe('Test abuses', function () {
 
       const reason5 = 'my super bad reason 5'
       const predefinedReasons5: AbusePredefinedReasonsString[] = [ 'violentOrRepulsive', 'captions' ]
-      const createdAbuse = (await reportAbuse({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        videoId: servers[0].video.id,
+      const createRes = await commands[0].report({
+        videoId: servers[0].store.video.id,
         reason: reason5,
         predefinedReasons: predefinedReasons5,
         startAt: 1,
         endAt: 5
-      })).body.abuse
+      })
 
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
+      const body = await commands[0].getAdminList()
 
       {
-        const abuse = (res.body.data as AdminAbuse[]).find(a => a.id === createdAbuse.id)
+        const abuse = body.data.find(a => a.id === createRes.abuse.id)
         expect(abuse.reason).to.equals(reason5)
         expect(abuse.predefinedReasons).to.deep.equals(predefinedReasons5, "predefined reasons do not match the one reported")
         expect(abuse.video.startAt).to.equal(1, "starting timestamp doesn't match the one reported")
@@ -361,37 +333,30 @@ describe('Test abuses', function () {
     it('Should delete the video abuse', async function () {
       this.timeout(10000)
 
-      await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id)
+      await commands[1].delete({ abuseId: abuseServer2.id })
 
       await waitJobs(servers)
 
       {
-        const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken })
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data.length).to.equal(1)
-        expect(res.body.data[0].id).to.not.equal(abuseServer2.id)
+        const body = await commands[1].getAdminList()
+        expect(body.total).to.equal(1)
+        expect(body.data.length).to.equal(1)
+        expect(body.data[0].id).to.not.equal(abuseServer2.id)
       }
 
       {
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(6)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(6)
       }
     })
 
     it('Should list and filter video abuses', async function () {
       this.timeout(10000)
 
-      async function list (query: Omit<Parameters<typeof getAdminAbusesList>[0], 'url' | 'token'>) {
-        const options = {
-          url: servers[0].url,
-          token: servers[0].accessToken
-        }
-
-        Object.assign(options, query)
+      async function list (query: Parameters<AbusesCommand['getAdminList']>[0]) {
+        const body = await commands[0].getAdminList(query)
 
-        const res = await getAdminAbusesList(options)
-
-        return res.body.data as AdminAbuse[]
+        return body.data
       }
 
       expect(await list({ id: 56 })).to.have.lengthOf(0)
@@ -424,24 +389,24 @@ describe('Test abuses', function () {
 
   describe('Comment abuses', function () {
 
-    async function getComment (url: string, videoIdArg: number | string) {
+    async function getComment (server: PeerTubeServer, videoIdArg: number | string) {
       const videoId = typeof videoIdArg === 'string'
-        ? await getVideoIdFromUUID(url, videoIdArg)
+        ? await server.videos.getId({ uuid: videoIdArg })
         : videoIdArg
 
-      const res = await getVideoCommentThreads(url, videoId, 0, 5)
+      const { data } = await server.comments.listThreads({ videoId })
 
-      return res.body.data[0] as VideoComment
+      return data[0]
     }
 
     before(async function () {
       this.timeout(50000)
 
-      servers[0].video = await uploadVideoAndGetId({ server: servers[0], videoName: 'server 1' })
-      servers[1].video = await uploadVideoAndGetId({ server: servers[1], videoName: 'server 2' })
+      servers[0].store.video = await servers[0].videos.quickUpload({ name: 'server 1' })
+      servers[1].store.video = await servers[1].videos.quickUpload({ name: 'server 2' })
 
-      await addVideoCommentThread(servers[0].url, servers[0].accessToken, servers[0].video.id, 'comment server 1')
-      await addVideoCommentThread(servers[1].url, servers[1].accessToken, servers[1].video.id, '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)
     })
@@ -449,23 +414,23 @@ describe('Test abuses', function () {
     it('Should report abuse on a comment', async function () {
       this.timeout(15000)
 
-      const comment = await getComment(servers[0].url, servers[0].video.id)
+      const comment = await getComment(servers[0], servers[0].store.video.id)
 
       const reason = 'it is a bad comment'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, commentId: comment.id, reason })
+      await commands[0].report({ commentId: comment.id, reason })
 
       await waitJobs(servers)
     })
 
     it('Should have 1 comment abuse on server 1 and 0 on server 2', async function () {
       {
-        const comment = await getComment(servers[0].url, servers[0].video.id)
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' })
+        const comment = await getComment(servers[0], servers[0].store.video.id)
+        const body = await commands[0].getAdminList({ filter: 'comment' })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(body.total).to.equal(1)
+        expect(body.data).to.have.lengthOf(1)
 
-        const abuse: AdminAbuse = res.body.data[0]
+        const abuse = body.data[0]
         expect(abuse.reason).to.equal('it is a bad comment')
 
         expect(abuse.reporterAccount.name).to.equal('root')
@@ -477,98 +442,102 @@ 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)
       }
 
       {
-        const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data.length).to.equal(0)
+        const body = await commands[1].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(0)
+        expect(body.data.length).to.equal(0)
       }
     })
 
     it('Should report abuse on a remote comment', async function () {
       this.timeout(10000)
 
-      const comment = await getComment(servers[0].url, servers[1].video.uuid)
+      const comment = await getComment(servers[0], servers[1].store.video.uuid)
 
       const reason = 'it is a really bad comment'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, commentId: comment.id, reason })
+      await commands[0].report({ commentId: comment.id, reason })
 
       await waitJobs(servers)
     })
 
     it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () {
-      const commentServer2 = await getComment(servers[0].url, servers[1].video.id)
+      const commentServer2 = await getComment(servers[0], servers[1].store.video.id)
 
-      const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' })
-      expect(res1.body.total).to.equal(2)
-      expect(res1.body.data.length).to.equal(2)
+      {
+        const body = await commands[0].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(2)
+        expect(body.data.length).to.equal(2)
 
-      const abuse: AdminAbuse = res1.body.data[0]
-      expect(abuse.reason).to.equal('it is a bad comment')
-      expect(abuse.countReportsForReporter).to.equal(6)
-      expect(abuse.countReportsForReportee).to.equal(5)
+        const abuse = body.data[0]
+        expect(abuse.reason).to.equal('it is a bad comment')
+        expect(abuse.countReportsForReporter).to.equal(6)
+        expect(abuse.countReportsForReportee).to.equal(5)
 
-      const abuse2: AdminAbuse = res1.body.data[1]
+        const abuse2 = body.data[1]
 
-      expect(abuse2.reason).to.equal('it is a really bad comment')
+        expect(abuse2.reason).to.equal('it is a really bad comment')
 
-      expect(abuse2.reporterAccount.name).to.equal('root')
-      expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
+        expect(abuse2.reporterAccount.name).to.equal('root')
+        expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuse2.video).to.be.null
+        expect(abuse2.video).to.be.null
 
-      expect(abuse2.comment.deleted).to.be.false
-      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.deleted).to.be.false
+        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].store.video.uuid)
 
-      expect(abuse2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuse2.state.label).to.equal('Pending')
+        expect(abuse2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuse2.state.label).to.equal('Pending')
 
-      expect(abuse2.moderationComment).to.be.null
+        expect(abuse2.moderationComment).to.be.null
 
-      expect(abuse2.countReportsForReporter).to.equal(6)
-      expect(abuse2.countReportsForReportee).to.equal(2)
+        expect(abuse2.countReportsForReporter).to.equal(6)
+        expect(abuse2.countReportsForReportee).to.equal(2)
+      }
 
-      const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' })
-      expect(res2.body.total).to.equal(1)
-      expect(res2.body.data.length).to.equal(1)
+      {
+        const body = await commands[1].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(1)
+        expect(body.data.length).to.equal(1)
 
-      abuseServer2 = res2.body.data[0]
-      expect(abuseServer2.reason).to.equal('it is a really bad comment')
-      expect(abuseServer2.reporterAccount.name).to.equal('root')
-      expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
+        abuseServer2 = body.data[0]
+        expect(abuseServer2.reason).to.equal('it is a really bad comment')
+        expect(abuseServer2.reporterAccount.name).to.equal('root')
+        expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuseServer2.state.label).to.equal('Pending')
+        expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuseServer2.state.label).to.equal('Pending')
 
-      expect(abuseServer2.moderationComment).to.be.null
+        expect(abuseServer2.moderationComment).to.be.null
 
-      expect(abuseServer2.countReportsForReporter).to.equal(1)
-      expect(abuseServer2.countReportsForReportee).to.equal(1)
+        expect(abuseServer2.countReportsForReporter).to.equal(1)
+        expect(abuseServer2.countReportsForReportee).to.equal(1)
+      }
     })
 
     it('Should keep the comment abuse when deleting the comment', async function () {
       this.timeout(10000)
 
-      const commentServer2 = await getComment(servers[0].url, servers[1].video.id)
+      const commentServer2 = await getComment(servers[0], servers[1].store.video.id)
 
-      await deleteVideoComment(servers[0].url, servers[0].accessToken, servers[1].video.uuid, commentServer2.id)
+      await servers[0].comments.delete({ videoId: servers[1].store.video.uuid, commentId: commentServer2.id })
 
       await waitJobs(servers)
 
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' })
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      const body = await commands[0].getAdminList({ filter: 'comment' })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      const abuse = (res.body.data as AdminAbuse[]).find(a => a.comment?.id === commentServer2.id)
+      const abuse = body.data.find(a => a.comment?.id === commentServer2.id)
       expect(abuse).to.not.be.undefined
 
       expect(abuse.comment.text).to.be.empty
@@ -579,72 +548,60 @@ describe('Test abuses', function () {
     it('Should delete the comment abuse', async function () {
       this.timeout(10000)
 
-      await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id)
+      await commands[1].delete({ abuseId: abuseServer2.id })
 
       await waitJobs(servers)
 
       {
-        const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data.length).to.equal(0)
+        const body = await commands[1].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(0)
+        expect(body.data.length).to.equal(0)
       }
 
       {
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(2)
       }
     })
 
     it('Should list and filter video abuses', async function () {
       {
-        const res = await getAdminAbusesList({
-          url: servers[0].url,
-          token: servers[0].accessToken,
-          filter: 'comment',
-          searchReportee: 'foo'
-        })
-        expect(res.body.total).to.equal(0)
+        const body = await commands[0].getAdminList({ filter: 'comment', searchReportee: 'foo' })
+        expect(body.total).to.equal(0)
       }
 
       {
-        const res = await getAdminAbusesList({
-          url: servers[0].url,
-          token: servers[0].accessToken,
-          filter: 'comment',
-          searchReportee: 'ot'
-        })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getAdminList({ filter: 'comment', searchReportee: 'ot' })
+        expect(body.total).to.equal(2)
       }
 
       {
-        const baseParams = { url: servers[0].url, token: servers[0].accessToken, filter: 'comment' as AbuseFilter, start: 1, count: 1 }
-
-        const res1 = await getAdminAbusesList(immutableAssign(baseParams, { sort: 'createdAt' }))
-        expect(res1.body.data).to.have.lengthOf(1)
-        expect(res1.body.data[0].comment.text).to.be.empty
+        const body = await commands[0].getAdminList({ filter: 'comment', start: 1, count: 1, sort: 'createdAt' })
+        expect(body.data).to.have.lengthOf(1)
+        expect(body.data[0].comment.text).to.be.empty
+      }
 
-        const res2 = await getAdminAbusesList(immutableAssign(baseParams, { sort: '-createdAt' }))
-        expect(res2.body.data).to.have.lengthOf(1)
-        expect(res2.body.data[0].comment.text).to.equal('comment server 1')
+      {
+        const body = await commands[0].getAdminList({ filter: 'comment', start: 1, count: 1, sort: '-createdAt' })
+        expect(body.data).to.have.lengthOf(1)
+        expect(body.data[0].comment.text).to.equal('comment server 1')
       }
     })
   })
 
   describe('Account abuses', function () {
 
-    async function getAccountFromServer (url: string, name: string, server: ServerInfo) {
-      const res = await getAccount(url, name + '@' + server.host)
-
-      return res.body as Account
+    function getAccountFromServer (server: PeerTubeServer, targetName: string, targetServer: PeerTubeServer) {
+      return server.accounts.get({ accountName: targetName + '@' + targetServer.host })
     }
 
     before(async function () {
       this.timeout(50000)
 
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: 'user_1', password: 'donald' })
+      await servers[0].users.create({ username: 'user_1', password: 'donald' })
 
-      const token = await generateUserAccessToken(servers[1], 'user_2')
-      await uploadVideo(servers[1].url, token, { 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)
     })
@@ -652,22 +609,22 @@ describe('Test abuses', function () {
     it('Should report abuse on an account', async function () {
       this.timeout(15000)
 
-      const account = await getAccountFromServer(servers[0].url, 'user_1', servers[0])
+      const account = await getAccountFromServer(servers[0], 'user_1', servers[0])
 
       const reason = 'it is a bad account'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, accountId: account.id, reason })
+      await commands[0].report({ accountId: account.id, reason })
 
       await waitJobs(servers)
     })
 
     it('Should have 1 account abuse on server 1 and 0 on server 2', async function () {
       {
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' })
+        const body = await commands[0].getAdminList({ filter: 'account' })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(body.total).to.equal(1)
+        expect(body.data).to.have.lengthOf(1)
 
-        const abuse: AdminAbuse = res.body.data[0]
+        const abuse = body.data[0]
         expect(abuse.reason).to.equal('it is a bad account')
 
         expect(abuse.reporterAccount.name).to.equal('root')
@@ -681,96 +638,100 @@ describe('Test abuses', function () {
       }
 
       {
-        const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data.length).to.equal(0)
+        const body = await commands[1].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(0)
+        expect(body.data.length).to.equal(0)
       }
     })
 
     it('Should report abuse on a remote account', async function () {
       this.timeout(10000)
 
-      const account = await getAccountFromServer(servers[0].url, 'user_2', servers[1])
+      const account = await getAccountFromServer(servers[0], 'user_2', servers[1])
 
       const reason = 'it is a really bad account'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, accountId: account.id, reason })
+      await commands[0].report({ accountId: account.id, reason })
 
       await waitJobs(servers)
     })
 
     it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () {
-      const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' })
-      expect(res1.body.total).to.equal(2)
-      expect(res1.body.data.length).to.equal(2)
+      {
+        const body = await commands[0].getAdminList({ filter: 'account' })
+        expect(body.total).to.equal(2)
+        expect(body.data.length).to.equal(2)
 
-      const abuse: AdminAbuse = res1.body.data[0]
-      expect(abuse.reason).to.equal('it is a bad account')
+        const abuse: AdminAbuse = body.data[0]
+        expect(abuse.reason).to.equal('it is a bad account')
 
-      const abuse2: AdminAbuse = res1.body.data[1]
-      expect(abuse2.reason).to.equal('it is a really bad account')
+        const abuse2: AdminAbuse = body.data[1]
+        expect(abuse2.reason).to.equal('it is a really bad account')
 
-      expect(abuse2.reporterAccount.name).to.equal('root')
-      expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
+        expect(abuse2.reporterAccount.name).to.equal('root')
+        expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuse2.video).to.be.null
-      expect(abuse2.comment).to.be.null
+        expect(abuse2.video).to.be.null
+        expect(abuse2.comment).to.be.null
 
-      expect(abuse2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuse2.state.label).to.equal('Pending')
+        expect(abuse2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuse2.state.label).to.equal('Pending')
 
-      expect(abuse2.moderationComment).to.be.null
+        expect(abuse2.moderationComment).to.be.null
+      }
 
-      const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'account' })
-      expect(res2.body.total).to.equal(1)
-      expect(res2.body.data.length).to.equal(1)
+      {
+        const body = await commands[1].getAdminList({ filter: 'account' })
+        expect(body.total).to.equal(1)
+        expect(body.data.length).to.equal(1)
 
-      abuseServer2 = res2.body.data[0]
+        abuseServer2 = body.data[0]
 
-      expect(abuseServer2.reason).to.equal('it is a really bad account')
+        expect(abuseServer2.reason).to.equal('it is a really bad account')
 
-      expect(abuseServer2.reporterAccount.name).to.equal('root')
-      expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
+        expect(abuseServer2.reporterAccount.name).to.equal('root')
+        expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuseServer2.state.label).to.equal('Pending')
+        expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuseServer2.state.label).to.equal('Pending')
 
-      expect(abuseServer2.moderationComment).to.be.null
+        expect(abuseServer2.moderationComment).to.be.null
+      }
     })
 
     it('Should keep the account abuse when deleting the account', async function () {
       this.timeout(10000)
 
-      const account = await getAccountFromServer(servers[1].url, 'user_2', servers[1])
-      await removeUser(servers[1].url, account.userId, servers[1].accessToken)
+      const account = await getAccountFromServer(servers[1], 'user_2', servers[1])
+      await servers[1].users.remove({ userId: account.userId })
 
       await waitJobs(servers)
 
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' })
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      const body = await commands[0].getAdminList({ filter: 'account' })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      const abuse = (res.body.data as AdminAbuse[]).find(a => a.reason === 'it is a really bad account')
+      const abuse = body.data.find(a => a.reason === 'it is a really bad account')
       expect(abuse).to.not.be.undefined
     })
 
     it('Should delete the account abuse', async function () {
       this.timeout(10000)
 
-      await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id)
+      await commands[1].delete({ abuseId: abuseServer2.id })
 
       await waitJobs(servers)
 
       {
-        const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'account' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data.length).to.equal(0)
+        const body = await commands[1].getAdminList({ filter: 'account' })
+        expect(body.total).to.equal(0)
+        expect(body.data.length).to.equal(0)
       }
 
       {
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getAdminList({ filter: 'account' })
+        expect(body.total).to.equal(2)
 
-        abuseServer1 = res.body.data[0]
+        abuseServer1 = body.data[0]
       }
     })
   })
@@ -778,20 +739,18 @@ describe('Test abuses', function () {
   describe('Common actions on abuses', function () {
 
     it('Should update the state of an abuse', async function () {
-      const body = { state: AbuseState.REJECTED }
-      await updateAbuse(servers[0].url, servers[0].accessToken, abuseServer1.id, body)
+      await commands[0].update({ abuseId: abuseServer1.id, body: { state: AbuseState.REJECTED } })
 
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, id: abuseServer1.id })
-      expect(res.body.data[0].state.id).to.equal(AbuseState.REJECTED)
+      const body = await commands[0].getAdminList({ id: abuseServer1.id })
+      expect(body.data[0].state.id).to.equal(AbuseState.REJECTED)
     })
 
     it('Should add a moderation comment', async function () {
-      const body = { state: AbuseState.ACCEPTED, moderationComment: 'It is valid' }
-      await updateAbuse(servers[0].url, servers[0].accessToken, abuseServer1.id, body)
+      await commands[0].update({ abuseId: abuseServer1.id, body: { state: AbuseState.ACCEPTED, moderationComment: 'Valid' } })
 
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, id: abuseServer1.id })
-      expect(res.body.data[0].state.id).to.equal(AbuseState.ACCEPTED)
-      expect(res.body.data[0].moderationComment).to.equal('It is valid')
+      const body = await commands[0].getAdminList({ id: abuseServer1.id })
+      expect(body.data[0].state.id).to.equal(AbuseState.ACCEPTED)
+      expect(body.data[0].moderationComment).to.equal('Valid')
     })
   })
 
@@ -800,20 +759,20 @@ describe('Test abuses', function () {
     let userAccessToken: string
 
     before(async function () {
-      userAccessToken = await generateUserAccessToken(servers[0], 'user_42')
+      userAccessToken = await servers[0].users.generateUserAndToken('user_42')
 
-      await reportAbuse({ url: servers[0].url, 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 getVideoIdFromUUID(servers[0].url, servers[1].video.uuid)
-      await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId, reason: 'user reason 2' })
+      const videoId = await servers[0].videos.getId({ uuid: servers[1].store.video.uuid })
+      await commands[0].report({ token: userAccessToken, videoId, reason: 'user reason 2' })
     })
 
     it('Should correctly list my abuses', async function () {
       {
-        const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 0, count: 5, sort: 'createdAt' })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getUserList({ token: userAccessToken, start: 0, count: 5, sort: 'createdAt' })
+        expect(body.total).to.equal(2)
 
-        const abuses: UserAbuse[] = res.body.data
+        const abuses = body.data
         expect(abuses[0].reason).to.equal('user reason 1')
         expect(abuses[1].reason).to.equal('user reason 2')
 
@@ -821,95 +780,77 @@ describe('Test abuses', function () {
       }
 
       {
-        const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 1, count: 1, sort: 'createdAt' })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getUserList({ token: userAccessToken, start: 1, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(2)
 
-        const abuses: UserAbuse[] = res.body.data
+        const abuses: UserAbuse[] = body.data
         expect(abuses[0].reason).to.equal('user reason 2')
       }
 
       {
-        const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 1, count: 1, sort: '-createdAt' })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getUserList({ token: userAccessToken, start: 1, count: 1, sort: '-createdAt' })
+        expect(body.total).to.equal(2)
 
-        const abuses: UserAbuse[] = res.body.data
+        const abuses: UserAbuse[] = body.data
         expect(abuses[0].reason).to.equal('user reason 1')
       }
     })
 
     it('Should correctly filter my abuses by id', async function () {
-      const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, id: abuseId1 })
+      const body = await commands[0].getUserList({ token: userAccessToken, id: abuseId1 })
+      expect(body.total).to.equal(1)
 
-      expect(res.body.total).to.equal(1)
-
-      const abuses: UserAbuse[] = res.body.data
+      const abuses: UserAbuse[] = body.data
       expect(abuses[0].reason).to.equal('user reason 1')
     })
 
     it('Should correctly filter my abuses by search', async function () {
-      const res = await getUserAbusesList({
-        url: servers[0].url,
-        token: userAccessToken,
-        search: 'server 2'
-      })
-
-      expect(res.body.total).to.equal(1)
+      const body = await commands[0].getUserList({ token: userAccessToken, search: 'server 2' })
+      expect(body.total).to.equal(1)
 
-      const abuses: UserAbuse[] = res.body.data
+      const abuses: UserAbuse[] = body.data
       expect(abuses[0].reason).to.equal('user reason 2')
     })
 
     it('Should correctly filter my abuses by state', async function () {
-      const body = { state: AbuseState.REJECTED }
-      await updateAbuse(servers[0].url, servers[0].accessToken, abuseId1, body)
+      await commands[0].update({ abuseId: abuseId1, body: { state: AbuseState.REJECTED } })
 
-      const res = await getUserAbusesList({
-        url: servers[0].url,
-        token: userAccessToken,
-        state: AbuseState.REJECTED
-      })
-
-      expect(res.body.total).to.equal(1)
+      const body = await commands[0].getUserList({ token: userAccessToken, state: AbuseState.REJECTED })
+      expect(body.total).to.equal(1)
 
-      const abuses: UserAbuse[] = res.body.data
+      const abuses: UserAbuse[] = body.data
       expect(abuses[0].reason).to.equal('user reason 1')
     })
   })
 
   describe('Abuse messages', async function () {
     let abuseId: number
-    let userAccessToken: string
+    let userToken: string
     let abuseMessageUserId: number
     let abuseMessageModerationId: number
 
     before(async function () {
-      userAccessToken = await generateUserAccessToken(servers[0], 'user_43')
+      userToken = await servers[0].users.generateUserAndToken('user_43')
 
-      const res = await reportAbuse({
-        url: servers[0].url,
-        token: userAccessToken,
-        videoId: servers[0].video.id,
-        reason: 'user 43 reason 1'
-      })
-
-      abuseId = res.body.abuse.id
+      const body = await commands[0].report({ token: userToken, videoId: servers[0].store.video.id, reason: 'user 43 reason 1' })
+      abuseId = body.abuse.id
     })
 
     it('Should create some messages on the abuse', async function () {
-      await addAbuseMessage(servers[0].url, userAccessToken, abuseId, 'message 1')
-      await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, 'message 2')
-      await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, 'message 3')
-      await addAbuseMessage(servers[0].url, userAccessToken, abuseId, 'message 4')
+      await commands[0].addMessage({ token: userToken, abuseId, message: 'message 1' })
+      await commands[0].addMessage({ abuseId, message: 'message 2' })
+      await commands[0].addMessage({ abuseId, message: 'message 3' })
+      await commands[0].addMessage({ token: userToken, abuseId, message: 'message 4' })
     })
 
     it('Should have the correct messages count when listing abuses', async function () {
       const results = await Promise.all([
-        getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, start: 0, count: 50 }),
-        getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 0, count: 50 })
+        commands[0].getAdminList({ start: 0, count: 50 }),
+        commands[0].getUserList({ token: userToken, start: 0, count: 50 })
       ])
 
-      for (const res of results) {
-        const abuses: AdminAbuse[] = res.body.data
+      for (const body of results) {
+        const abuses = body.data
         const abuse = abuses.find(a => a.id === abuseId)
         expect(abuse.countMessages).to.equal(4)
       }
@@ -917,14 +858,14 @@ describe('Test abuses', function () {
 
     it('Should correctly list messages of this abuse', async function () {
       const results = await Promise.all([
-        listAbuseMessages(servers[0].url, servers[0].accessToken, abuseId),
-        listAbuseMessages(servers[0].url, userAccessToken, abuseId)
+        commands[0].listMessages({ abuseId }),
+        commands[0].listMessages({ token: userToken, abuseId })
       ])
 
-      for (const res of results) {
-        expect(res.body.total).to.equal(4)
+      for (const body of results) {
+        expect(body.total).to.equal(4)
 
-        const abuseMessages: AbuseMessage[] = res.body.data
+        const abuseMessages: AbuseMessage[] = body.data
 
         expect(abuseMessages[0].message).to.equal('message 1')
         expect(abuseMessages[0].byModerator).to.be.false
@@ -948,19 +889,18 @@ describe('Test abuses', function () {
     })
 
     it('Should delete messages', async function () {
-      await deleteAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, abuseMessageModerationId)
-      await deleteAbuseMessage(servers[0].url, userAccessToken, abuseId, abuseMessageUserId)
+      await commands[0].deleteMessage({ abuseId, messageId: abuseMessageModerationId })
+      await commands[0].deleteMessage({ token: userToken, abuseId, messageId: abuseMessageUserId })
 
       const results = await Promise.all([
-        listAbuseMessages(servers[0].url, servers[0].accessToken, abuseId),
-        listAbuseMessages(servers[0].url, userAccessToken, abuseId)
+        commands[0].listMessages({ abuseId }),
+        commands[0].listMessages({ token: userToken, abuseId })
       ])
 
-      for (const res of results) {
-        expect(res.body.total).to.equal(2)
-
-        const abuseMessages: AbuseMessage[] = res.body.data
+      for (const body of results) {
+        expect(body.total).to.equal(2)
 
+        const abuseMessages: AbuseMessage[] = body.data
         expect(abuseMessages[0].message).to.equal('message 2')
         expect(abuseMessages[1].message).to.equal('message 4')
       }
diff --git a/server/tests/api/moderation/blocklist-notification.ts b/server/tests/api/moderation/blocklist-notification.ts
index 4fb3c95f2..75b15c298 100644
--- a/server/tests/api/moderation/blocklist-notification.ts
+++ b/server/tests/api/moderation/blocklist-notification.ts
@@ -2,47 +2,22 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { getUserNotifications, markAsReadAllNotifications } from '@shared/extra-utils/users/user-notifications'
-import { addUserSubscription, removeUserSubscription } from '@shared/extra-utils/users/user-subscriptions'
-import { UserNotification, UserNotificationType } from '@shared/models'
-import {
-  cleanupTests,
-  createUser,
-  doubleFollow,
-  flushAndRunMultipleServers,
-  ServerInfo,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils/index'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  addAccountToAccountBlocklist,
-  addAccountToServerBlocklist,
-  addServerToAccountBlocklist,
-  addServerToServerBlocklist,
-  removeAccountFromAccountBlocklist,
-  removeAccountFromServerBlocklist,
-  removeServerFromAccountBlocklist
-} from '../../../../shared/extra-utils/users/blocklist'
-import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
-import { addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments'
+import { cleanupTests, createMultipleServers, doubleFollow, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { UserNotificationType } from '@shared/models'
 
 const expect = chai.expect
 
-async function checkNotifications (url: string, token: string, expected: UserNotificationType[]) {
-  const res = await getUserNotifications(url, token, 0, 10, true)
-
-  const notifications: UserNotification[] = res.body.data
-
-  expect(notifications).to.have.lengthOf(expected.length)
+async function checkNotifications (server: PeerTubeServer, token: string, expected: UserNotificationType[]) {
+  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) {
-    expect(notifications.find(n => n.type === type)).to.exist
+    expect(data.find(n => n.type === type)).to.exist
   }
 }
 
 describe('Test blocklist', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let videoUUID: string
 
   let userToken1: string
@@ -51,30 +26,34 @@ describe('Test blocklist', function () {
 
   async function resetState () {
     try {
-      await removeUserSubscription(servers[1].url, remoteUserToken, 'user1_channel@' + servers[0].host)
-      await removeUserSubscription(servers[1].url, remoteUserToken, '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 markAsReadAllNotifications(servers[0].url, userToken1)
-    await markAsReadAllNotifications(servers[0].url, userToken2)
+    await servers[0].notifications.markAsReadAll({ token: userToken1 })
+    await servers[0].notifications.markAsReadAll({ token: userToken2 })
 
     {
-      const res = await uploadVideo(servers[0].url, userToken1, { name: 'video' })
-      videoUUID = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ token: userToken1, attributes: { name: 'video' } })
+      videoUUID = uuid
 
       await waitJobs(servers)
     }
 
     {
-      await addVideoCommentThread(servers[1].url, remoteUserToken, videoUUID, '@user2@' + servers[0].host + ' hello')
+      await servers[1].comments.createThread({
+        token: remoteUserToken,
+        videoId: videoUUID,
+        text: '@user2@' + servers[0].host + ' hello'
+      })
     }
 
     {
 
-      await addUserSubscription(servers[1].url, remoteUserToken, 'user1_channel@' + servers[0].host)
-      await addUserSubscription(servers[1].url, remoteUserToken, '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)
@@ -83,36 +62,34 @@ describe('Test blocklist', function () {
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     {
       const user = { username: 'user1', password: 'password' }
-      await createUser({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
+      await servers[0].users.create({
         username: user.username,
         password: user.password,
         videoQuota: -1,
         videoQuotaDaily: -1
       })
 
-      userToken1 = await userLogin(servers[0], user)
-      await uploadVideo(servers[0].url, userToken1, { 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 createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      userToken2 = await userLogin(servers[0], user)
+      userToken2 = await servers[0].login.getAccessToken(user)
     }
 
     {
       const user = { username: 'user3', password: 'password' }
-      await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
+      await servers[1].users.create({ username: user.username, password: user.password })
 
-      remoteUserToken = await userLogin(servers[1], user)
+      remoteUserToken = await servers[1].login.getAccessToken(user)
     }
 
     await doubleFollow(servers[0], servers[1])
@@ -128,26 +105,26 @@ describe('Test blocklist', function () {
 
     it('Should have appropriate notifications', async function () {
       const notifs = [ UserNotificationType.NEW_COMMENT_ON_MY_VIDEO, UserNotificationType.NEW_FOLLOW ]
-      await checkNotifications(servers[0].url, userToken1, notifs)
+      await checkNotifications(servers[0], userToken1, notifs)
     })
 
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await addAccountToAccountBlocklist(servers[0].url, userToken1, 'user3@' + servers[1].host)
+      await servers[0].blocklist.addToMyBlocklist({ token: userToken1, account: 'user3@' + servers[1].host })
       await waitJobs(servers)
     })
 
     it('Should not have notifications from this account', async function () {
-      await checkNotifications(servers[0].url, userToken1, [])
+      await checkNotifications(servers[0], userToken1, [])
     })
 
     it('Should have notifications of this account on user 2', async function () {
       const notifs = [ UserNotificationType.COMMENT_MENTION, UserNotificationType.NEW_FOLLOW ]
 
-      await checkNotifications(servers[0].url, userToken2, notifs)
+      await checkNotifications(servers[0], userToken2, notifs)
 
-      await removeAccountFromAccountBlocklist(servers[0].url, userToken1, 'user3@' + servers[1].host)
+      await servers[0].blocklist.removeFromMyBlocklist({ token: userToken1, account: 'user3@' + servers[1].host })
     })
   })
 
@@ -161,26 +138,26 @@ describe('Test blocklist', function () {
 
     it('Should have appropriate notifications', async function () {
       const notifs = [ UserNotificationType.NEW_COMMENT_ON_MY_VIDEO, UserNotificationType.NEW_FOLLOW ]
-      await checkNotifications(servers[0].url, userToken1, notifs)
+      await checkNotifications(servers[0], userToken1, notifs)
     })
 
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await addServerToAccountBlocklist(servers[0].url, userToken1, servers[1].host)
+      await servers[0].blocklist.addToMyBlocklist({ token: userToken1, server: servers[1].host })
       await waitJobs(servers)
     })
 
     it('Should not have notifications from this account', async function () {
-      await checkNotifications(servers[0].url, userToken1, [])
+      await checkNotifications(servers[0], userToken1, [])
     })
 
     it('Should have notifications of this account on user 2', async function () {
       const notifs = [ UserNotificationType.COMMENT_MENTION, UserNotificationType.NEW_FOLLOW ]
 
-      await checkNotifications(servers[0].url, userToken2, notifs)
+      await checkNotifications(servers[0], userToken2, notifs)
 
-      await removeServerFromAccountBlocklist(servers[0].url, userToken1, servers[1].host)
+      await servers[0].blocklist.removeFromMyBlocklist({ token: userToken1, server: servers[1].host })
     })
   })
 
@@ -195,27 +172,27 @@ describe('Test blocklist', function () {
     it('Should have appropriate notifications', async function () {
       {
         const notifs = [ UserNotificationType.NEW_COMMENT_ON_MY_VIDEO, UserNotificationType.NEW_FOLLOW ]
-        await checkNotifications(servers[0].url, userToken1, notifs)
+        await checkNotifications(servers[0], userToken1, notifs)
       }
 
       {
         const notifs = [ UserNotificationType.COMMENT_MENTION, UserNotificationType.NEW_FOLLOW ]
-        await checkNotifications(servers[0].url, userToken2, notifs)
+        await checkNotifications(servers[0], userToken2, notifs)
       }
     })
 
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, 'user3@' + servers[1].host)
+      await servers[0].blocklist.addToServerBlocklist({ account: 'user3@' + servers[1].host })
       await waitJobs(servers)
     })
 
     it('Should not have notifications from this account', async function () {
-      await checkNotifications(servers[0].url, userToken1, [])
-      await checkNotifications(servers[0].url, userToken2, [])
+      await checkNotifications(servers[0], userToken1, [])
+      await checkNotifications(servers[0], userToken2, [])
 
-      await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, 'user3@' + servers[1].host)
+      await servers[0].blocklist.removeFromServerBlocklist({ account: 'user3@' + servers[1].host })
     })
   })
 
@@ -230,25 +207,25 @@ describe('Test blocklist', function () {
     it('Should have appropriate notifications', async function () {
       {
         const notifs = [ UserNotificationType.NEW_COMMENT_ON_MY_VIDEO, UserNotificationType.NEW_FOLLOW ]
-        await checkNotifications(servers[0].url, userToken1, notifs)
+        await checkNotifications(servers[0], userToken1, notifs)
       }
 
       {
         const notifs = [ UserNotificationType.COMMENT_MENTION, UserNotificationType.NEW_FOLLOW ]
-        await checkNotifications(servers[0].url, userToken2, notifs)
+        await checkNotifications(servers[0], userToken2, notifs)
       }
     })
 
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, servers[1].host)
+      await servers[0].blocklist.addToServerBlocklist({ server: servers[1].host })
       await waitJobs(servers)
     })
 
     it('Should not have notifications from this account', async function () {
-      await checkNotifications(servers[0].url, userToken1, [])
-      await checkNotifications(servers[0].url, userToken2, [])
+      await checkNotifications(servers[0], userToken1, [])
+      await checkNotifications(servers[0], userToken2, [])
     })
   })
 
diff --git a/server/tests/api/moderation/blocklist.ts b/server/tests/api/moderation/blocklist.ts
index 793abbcb4..089af8b15 100644
--- a/server/tests/api/moderation/blocklist.ts
+++ b/server/tests/api/moderation/blocklist.ts
@@ -3,106 +3,67 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  addAccountToAccountBlocklist,
-  addAccountToServerBlocklist,
-  addServerToAccountBlocklist,
-  addServerToServerBlocklist,
-  addVideoCommentReply,
-  addVideoCommentThread,
+  BlocklistCommand,
   cleanupTests,
-  createUser,
-  deleteVideoComment,
+  CommentsCommand,
+  createMultipleServers,
   doubleFollow,
-  findCommentId,
-  flushAndRunMultipleServers,
-  follow,
-  getAccountBlocklistByAccount,
-  getAccountBlocklistByServer,
-  getServerBlocklistByAccount,
-  getServerBlocklistByServer,
-  getUserNotifications,
-  getVideoCommentThreads,
-  getVideosList,
-  getVideosListWithToken,
-  getVideoThreadComments,
-  removeAccountFromAccountBlocklist,
-  removeAccountFromServerBlocklist,
-  removeServerFromAccountBlocklist,
-  removeServerFromServerBlocklist,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  unfollow,
-  uploadVideo,
-  userLogin,
   waitJobs
 } from '@shared/extra-utils'
-import {
-  AccountBlock,
-  ServerBlock,
-  UserNotification,
-  UserNotificationType,
-  Video,
-  VideoComment,
-  VideoCommentThreadTree
-} from '@shared/models'
+import { UserNotificationType } from '@shared/models'
 
 const expect = chai.expect
 
-async function checkAllVideos (url: string, token: string) {
+async function checkAllVideos (server: PeerTubeServer, token: string) {
   {
-    const res = await getVideosListWithToken(url, token)
-
-    expect(res.body.data).to.have.lengthOf(5)
+    const { data } = await server.videos.listWithToken({ token })
+    expect(data).to.have.lengthOf(5)
   }
 
   {
-    const res = await getVideosList(url)
-
-    expect(res.body.data).to.have.lengthOf(5)
+    const { data } = await server.videos.list()
+    expect(data).to.have.lengthOf(5)
   }
 }
 
-async function checkAllComments (url: string, token: string, videoUUID: string) {
-  const resThreads = await getVideoCommentThreads(url, videoUUID, 0, 25, '-createdAt', token)
+async function checkAllComments (server: PeerTubeServer, token: string, videoUUID: string) {
+  const { data } = await server.comments.listThreads({ videoId: videoUUID, start: 0, count: 25, sort: '-createdAt', token })
 
-  const allThreads: VideoComment[] = resThreads.body.data
-  const threads = allThreads.filter(t => t.isDeleted === false)
+  const threads = data.filter(t => t.isDeleted === false)
   expect(threads).to.have.lengthOf(2)
 
   for (const thread of threads) {
-    const res = await getVideoThreadComments(url, videoUUID, thread.id, token)
-
-    const tree: VideoCommentThreadTree = res.body
+    const tree = await server.comments.getThread({ videoId: videoUUID, threadId: thread.id, token })
     expect(tree.children).to.have.lengthOf(1)
   }
 }
 
 async function checkCommentNotification (
-  mainServer: ServerInfo,
-  comment: { server: ServerInfo, token: string, videoUUID: string, text: string },
+  mainServer: PeerTubeServer,
+  comment: { server: PeerTubeServer, token: string, videoUUID: string, text: string },
   check: 'presence' | 'absence'
 ) {
-  const resComment = await addVideoCommentThread(comment.server.url, comment.token, comment.videoUUID, comment.text)
-  const created = resComment.body.comment as VideoComment
-  const threadId = created.id
-  const createdAt = created.createdAt
+  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 res = await getUserNotifications(mainServer.url, mainServer.accessToken, 0, 30)
-  const commentNotifications = (res.body.data as UserNotification[])
-                                  .filter(n => n.comment && n.comment.video.uuid === comment.videoUUID && n.createdAt >= createdAt)
+  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)
   else expect(commentNotifications).to.have.lengthOf(0)
 
-  await deleteVideoComment(comment.server.url, comment.token, comment.videoUUID, threadId)
+  await command.delete({ token: comment.token, videoId: comment.videoUUID, commentId: threadId })
 
   await waitJobs([ mainServer, comment.server ])
 }
 
 describe('Test blocklist', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let videoUUID1: string
   let videoUUID2: string
   let videoUUID3: string
@@ -110,62 +71,73 @@ describe('Test blocklist', function () {
   let userModeratorToken: string
   let userToken2: string
 
+  let command: BlocklistCommand
+  let commentsCommand: CommentsCommand[]
+
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
     await setAccessTokensToServers(servers)
 
+    command = servers[0].blocklist
+    commentsCommand = servers.map(s => s.comments)
+
     {
       const user = { username: 'user1', password: 'password' }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      userToken1 = await userLogin(servers[0], user)
-      await uploadVideo(servers[0].url, userToken1, { 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 createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      userModeratorToken = await userLogin(servers[0], user)
+      userModeratorToken = await servers[0].login.getAccessToken(user)
     }
 
     {
       const user = { username: 'user2', password: 'password' }
-      await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
+      await servers[1].users.create({ username: user.username, password: user.password })
 
-      userToken2 = await userLogin(servers[1], user)
-      await uploadVideo(servers[1].url, userToken2, { name: 'video user 2' })
+      userToken2 = await servers[1].login.getAccessToken(user)
+      await servers[1].videos.upload({ token: userToken2, attributes: { name: 'video user 2' } })
     }
 
     {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video server 1' })
-      videoUUID1 = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video server 1' } })
+      videoUUID1 = uuid
     }
 
     {
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video server 2' })
-      videoUUID2 = res.body.video.uuid
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video server 2' } })
+      videoUUID2 = uuid
     }
 
     {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video 2 server 1' })
-      videoUUID3 = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video 2 server 1' } })
+      videoUUID3 = uuid
     }
 
     await doubleFollow(servers[0], servers[1])
     await doubleFollow(servers[0], servers[2])
 
     {
-      const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID1, 'comment root 1')
-      const resReply = await addVideoCommentReply(servers[0].url, userToken1, videoUUID1, resComment.body.comment.id, 'comment user 1')
-      await addVideoCommentReply(servers[0].url, servers[0].accessToken, videoUUID1, resReply.body.comment.id, 'comment root 1')
+      const created = await commentsCommand[0].createThread({ videoId: videoUUID1, text: 'comment root 1' })
+      const reply = await commentsCommand[0].addReply({
+        token: userToken1,
+        videoId: videoUUID1,
+        toCommentId: created.id,
+        text: 'comment user 1'
+      })
+      await commentsCommand[0].addReply({ videoId: videoUUID1, toCommentId: reply.id, text: 'comment root 1' })
     }
 
     {
-      const resComment = await addVideoCommentThread(servers[0].url, userToken1, videoUUID1, 'comment user 1')
-      await addVideoCommentReply(servers[0].url, servers[0].accessToken, videoUUID1, resComment.body.comment.id, 'comment root 1')
+      const created = await commentsCommand[0].createThread({ token: userToken1, videoId: videoUUID1, text: 'comment user 1' })
+      await commentsCommand[0].addReply({ videoId: videoUUID1, toCommentId: created.id, text: 'comment root 1' })
     }
 
     await waitJobs(servers)
@@ -175,55 +147,60 @@ describe('Test blocklist', function () {
 
     describe('When managing account blocklist', function () {
       it('Should list all videos', function () {
-        return checkAllVideos(servers[0].url, servers[0].accessToken)
+        return checkAllVideos(servers[0], servers[0].accessToken)
       })
 
       it('Should list the comments', function () {
-        return checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        return checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
       })
 
       it('Should block a remote account', async function () {
-        await addAccountToAccountBlocklist(servers[0].url, servers[0].accessToken, 'user2@localhost:' + servers[1].port)
+        await command.addToMyBlocklist({ account: 'user2@localhost:' + servers[1].port })
       })
 
       it('Should hide its videos', async function () {
-        const res = await getVideosListWithToken(servers[0].url, servers[0].accessToken)
+        const { data } = await servers[0].videos.listWithToken()
 
-        const videos: Video[] = res.body.data
-        expect(videos).to.have.lengthOf(4)
+        expect(data).to.have.lengthOf(4)
 
-        const v = videos.find(v => v.name === 'video user 2')
+        const v = data.find(v => v.name === 'video user 2')
         expect(v).to.be.undefined
       })
 
       it('Should block a local account', async function () {
-        await addAccountToAccountBlocklist(servers[0].url, servers[0].accessToken, 'user1')
+        await command.addToMyBlocklist({ account: 'user1' })
       })
 
       it('Should hide its videos', async function () {
-        const res = await getVideosListWithToken(servers[0].url, servers[0].accessToken)
+        const { data } = await servers[0].videos.listWithToken()
 
-        const videos: Video[] = res.body.data
-        expect(videos).to.have.lengthOf(3)
+        expect(data).to.have.lengthOf(3)
 
-        const v = videos.find(v => v.name === 'video user 1')
+        const v = data.find(v => v.name === 'video user 1')
         expect(v).to.be.undefined
       })
 
       it('Should hide its comments', async function () {
-        const resThreads = await getVideoCommentThreads(servers[0].url, videoUUID1, 0, 25, '-createdAt', servers[0].accessToken)
-
-        const threads: VideoComment[] = resThreads.body.data
-        expect(threads).to.have.lengthOf(1)
-        expect(threads[0].totalReplies).to.equal(1)
-
-        const t = threads.find(t => t.text === 'comment user 1')
+        const { data } = await commentsCommand[0].listThreads({
+          token: servers[0].accessToken,
+          videoId: videoUUID1,
+          start: 0,
+          count: 25,
+          sort: '-createdAt'
+        })
+
+        expect(data).to.have.lengthOf(1)
+        expect(data[0].totalReplies).to.equal(1)
+
+        const t = data.find(t => t.text === 'comment user 1')
         expect(t).to.be.undefined
 
-        for (const thread of threads) {
-          const res = await getVideoThreadComments(servers[0].url, videoUUID1, thread.id, servers[0].accessToken)
-
-          const tree: VideoCommentThreadTree = res.body
+        for (const thread of data) {
+          const tree = await commentsCommand[0].getThread({
+            videoId: videoUUID1,
+            threadId: thread.id,
+            token: servers[0].accessToken
+          })
           expect(tree.children).to.have.lengthOf(0)
         }
       })
@@ -248,17 +225,15 @@ describe('Test blocklist', function () {
       })
 
       it('Should list all the videos with another user', async function () {
-        return checkAllVideos(servers[0].url, userToken1)
+        return checkAllVideos(servers[0], userToken1)
       })
 
       it('Should list blocked accounts', async function () {
         {
-          const res = await getAccountBlocklistByAccount(servers[0].url, servers[0].accessToken, 0, 1, 'createdAt')
-          const blocks: AccountBlock[] = res.body.data
+          const body = await command.listMyAccountBlocklist({ start: 0, count: 1, sort: 'createdAt' })
+          expect(body.total).to.equal(2)
 
-          expect(res.body.total).to.equal(2)
-
-          const block = blocks[0]
+          const block = body.data[0]
           expect(block.byAccount.displayName).to.equal('root')
           expect(block.byAccount.name).to.equal('root')
           expect(block.blockedAccount.displayName).to.equal('user2')
@@ -267,12 +242,10 @@ describe('Test blocklist', function () {
         }
 
         {
-          const res = await getAccountBlocklistByAccount(servers[0].url, servers[0].accessToken, 1, 2, 'createdAt')
-          const blocks: AccountBlock[] = res.body.data
-
-          expect(res.body.total).to.equal(2)
+          const body = await command.listMyAccountBlocklist({ start: 1, count: 2, sort: 'createdAt' })
+          expect(body.total).to.equal(2)
 
-          const block = blocks[0]
+          const block = body.data[0]
           expect(block.byAccount.displayName).to.equal('root')
           expect(block.byAccount.name).to.equal('root')
           expect(block.blockedAccount.displayName).to.equal('user1')
@@ -285,32 +258,29 @@ describe('Test blocklist', function () {
         this.timeout(60000)
 
         {
-          await addVideoCommentThread(servers[1].url, userToken2, videoUUID3, 'comment user 2')
+          await commentsCommand[1].createThread({ token: userToken2, videoId: videoUUID3, text: 'comment user 2' })
           await waitJobs(servers)
 
-          await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID3, 'uploader')
+          await commentsCommand[0].createThread({ token: servers[0].accessToken, videoId: videoUUID3, text: 'uploader' })
           await waitJobs(servers)
 
-          const commentId = await findCommentId(servers[1].url, videoUUID3, 'uploader')
+          const commentId = await commentsCommand[1].findCommentId({ videoId: videoUUID3, text: 'uploader' })
           const message = 'reply by user 2'
-          const resReply = await addVideoCommentReply(servers[1].url, userToken2, videoUUID3, commentId, message)
-          await addVideoCommentReply(servers[1].url, servers[1].accessToken, videoUUID3, resReply.body.comment.id, 'another reply')
+          const reply = await commentsCommand[1].addReply({ token: userToken2, videoId: videoUUID3, toCommentId: commentId, text: message })
+          await commentsCommand[1].addReply({ videoId: videoUUID3, toCommentId: reply.id, text: 'another reply' })
 
           await waitJobs(servers)
         }
 
         // Server 2 has all the comments
         {
-          const resThreads = await getVideoCommentThreads(servers[1].url, videoUUID3, 0, 25, '-createdAt')
-          const threads: VideoComment[] = resThreads.body.data
-
-          expect(threads).to.have.lengthOf(2)
-          expect(threads[0].text).to.equal('uploader')
-          expect(threads[1].text).to.equal('comment user 2')
+          const { data } = await commentsCommand[1].listThreads({ videoId: videoUUID3, count: 25, sort: '-createdAt' })
 
-          const resReplies = await getVideoThreadComments(servers[1].url, videoUUID3, threads[0].id)
+          expect(data).to.have.lengthOf(2)
+          expect(data[0].text).to.equal('uploader')
+          expect(data[1].text).to.equal('comment user 2')
 
-          const tree: VideoCommentThreadTree = resReplies.body
+          const tree = await commentsCommand[1].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)
@@ -319,55 +289,45 @@ describe('Test blocklist', function () {
 
         // Server 1 and 3 should only have uploader comments
         for (const server of [ servers[0], servers[2] ]) {
-          const resThreads = await getVideoCommentThreads(server.url, videoUUID3, 0, 25, '-createdAt')
-          const threads: VideoComment[] = resThreads.body.data
+          const { data } = await server.comments.listThreads({ videoId: videoUUID3, count: 25, sort: '-createdAt' })
 
-          expect(threads).to.have.lengthOf(1)
-          expect(threads[0].text).to.equal('uploader')
+          expect(data).to.have.lengthOf(1)
+          expect(data[0].text).to.equal('uploader')
 
-          const resReplies = await getVideoThreadComments(server.url, videoUUID3, threads[0].id)
+          const tree = await server.comments.getThread({ videoId: videoUUID3, threadId: data[0].id })
 
-          const tree: VideoCommentThreadTree = resReplies.body
-          if (server.serverNumber === 1) {
-            expect(tree.children).to.have.lengthOf(0)
-          } else {
-            expect(tree.children).to.have.lengthOf(1)
-          }
+          if (server.serverNumber === 1) expect(tree.children).to.have.lengthOf(0)
+          else expect(tree.children).to.have.lengthOf(1)
         }
       })
 
       it('Should unblock the remote account', async function () {
-        await removeAccountFromAccountBlocklist(servers[0].url, servers[0].accessToken, 'user2@localhost:' + servers[1].port)
+        await command.removeFromMyBlocklist({ account: 'user2@localhost:' + servers[1].port })
       })
 
       it('Should display its videos', async function () {
-        const res = await getVideosListWithToken(servers[0].url, servers[0].accessToken)
-
-        const videos: Video[] = res.body.data
-        expect(videos).to.have.lengthOf(4)
+        const { data } = await servers[0].videos.listWithToken()
+        expect(data).to.have.lengthOf(4)
 
-        const v = videos.find(v => v.name === 'video user 2')
+        const v = data.find(v => v.name === 'video user 2')
         expect(v).not.to.be.undefined
       })
 
       it('Should display its comments on my video', async function () {
         for (const server of servers) {
-          const resThreads = await getVideoCommentThreads(server.url, videoUUID3, 0, 25, '-createdAt')
-          const threads: VideoComment[] = resThreads.body.data
+          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) {
-            expect(threads).to.have.lengthOf(1)
+            expect(data).to.have.lengthOf(1)
             continue
           }
 
-          expect(threads).to.have.lengthOf(2)
-          expect(threads[0].text).to.equal('uploader')
-          expect(threads[1].text).to.equal('comment user 2')
+          expect(data).to.have.lengthOf(2)
+          expect(data[0].text).to.equal('uploader')
+          expect(data[1].text).to.equal('comment user 2')
 
-          const resReplies = await getVideoThreadComments(server.url, videoUUID3, threads[0].id)
-
-          const tree: VideoCommentThreadTree = resReplies.body
+          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)
@@ -376,11 +336,11 @@ describe('Test blocklist', function () {
       })
 
       it('Should unblock the local account', async function () {
-        await removeAccountFromAccountBlocklist(servers[0].url, servers[0].accessToken, 'user1')
+        await command.removeFromMyBlocklist({ account: 'user1' })
       })
 
       it('Should display its comments', function () {
-        return checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        return checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
       })
 
       it('Should have a notification from a non blocked account', async function () {
@@ -404,46 +364,45 @@ describe('Test blocklist', function () {
     })
 
     describe('When managing server blocklist', function () {
+
       it('Should list all videos', function () {
-        return checkAllVideos(servers[0].url, servers[0].accessToken)
+        return checkAllVideos(servers[0], servers[0].accessToken)
       })
 
       it('Should list the comments', function () {
-        return checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        return checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
       })
 
       it('Should block a remote server', async function () {
-        await addServerToAccountBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.addToMyBlocklist({ server: 'localhost:' + servers[1].port })
       })
 
       it('Should hide its videos', async function () {
-        const res = await getVideosListWithToken(servers[0].url, servers[0].accessToken)
+        const { data } = await servers[0].videos.listWithToken()
 
-        const videos: Video[] = res.body.data
-        expect(videos).to.have.lengthOf(3)
+        expect(data).to.have.lengthOf(3)
 
-        const v1 = videos.find(v => v.name === 'video user 2')
-        const v2 = videos.find(v => v.name === 'video server 2')
+        const v1 = data.find(v => v.name === 'video user 2')
+        const v2 = data.find(v => v.name === 'video server 2')
 
         expect(v1).to.be.undefined
         expect(v2).to.be.undefined
       })
 
       it('Should list all the videos with another user', async function () {
-        return checkAllVideos(servers[0].url, userToken1)
+        return checkAllVideos(servers[0], userToken1)
       })
 
       it('Should hide its comments', async function () {
         this.timeout(10000)
 
-        const resThreads = await addVideoCommentThread(servers[1].url, userToken2, videoUUID1, 'hidden comment 2')
-        const threadId = resThreads.body.comment.id
+        const { id } = await commentsCommand[1].createThread({ token: userToken2, videoId: videoUUID1, text: 'hidden comment 2' })
 
         await waitJobs(servers)
 
-        await checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        await checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
 
-        await deleteVideoComment(servers[1].url, userToken2, videoUUID1, threadId)
+        await commentsCommand[1].delete({ token: userToken2, videoId: videoUUID1, commentId: id })
       })
 
       it('Should not have notifications from blocked server', async function () {
@@ -466,27 +425,25 @@ describe('Test blocklist', function () {
       })
 
       it('Should list blocked servers', async function () {
-        const res = await getServerBlocklistByAccount(servers[0].url, servers[0].accessToken, 0, 1, 'createdAt')
-        const blocks: ServerBlock[] = res.body.data
-
-        expect(res.body.total).to.equal(1)
+        const body = await command.listMyServerBlocklist({ start: 0, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(1)
 
-        const block = blocks[0]
+        const block = body.data[0]
         expect(block.byAccount.displayName).to.equal('root')
         expect(block.byAccount.name).to.equal('root')
         expect(block.blockedServer.host).to.equal('localhost:' + servers[1].port)
       })
 
       it('Should unblock the remote server', async function () {
-        await removeServerFromAccountBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.removeFromMyBlocklist({ server: 'localhost:' + servers[1].port })
       })
 
       it('Should display its videos', function () {
-        return checkAllVideos(servers[0].url, servers[0].accessToken)
+        return checkAllVideos(servers[0], servers[0].accessToken)
       })
 
       it('Should display its comments', function () {
-        return checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        return checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
       })
 
       it('Should have notification from unblocked server', async function () {
@@ -515,54 +472,50 @@ describe('Test blocklist', function () {
     describe('When managing account blocklist', function () {
       it('Should list all videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllVideos(servers[0].url, token)
+          await checkAllVideos(servers[0], token)
         }
       })
 
       it('Should list the comments', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllComments(servers[0].url, token, videoUUID1)
+          await checkAllComments(servers[0], token, videoUUID1)
         }
       })
 
       it('Should block a remote account', async function () {
-        await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, 'user2@localhost:' + servers[1].port)
+        await command.addToServerBlocklist({ account: 'user2@localhost:' + servers[1].port })
       })
 
       it('Should hide its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const res = await getVideosListWithToken(servers[0].url, token)
+          const { data } = await servers[0].videos.listWithToken({ token })
 
-          const videos: Video[] = res.body.data
-          expect(videos).to.have.lengthOf(4)
+          expect(data).to.have.lengthOf(4)
 
-          const v = videos.find(v => v.name === 'video user 2')
+          const v = data.find(v => v.name === 'video user 2')
           expect(v).to.be.undefined
         }
       })
 
       it('Should block a local account', async function () {
-        await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, 'user1')
+        await command.addToServerBlocklist({ account: 'user1' })
       })
 
       it('Should hide its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const res = await getVideosListWithToken(servers[0].url, token)
+          const { data } = await servers[0].videos.listWithToken({ token })
 
-          const videos: Video[] = res.body.data
-          expect(videos).to.have.lengthOf(3)
+          expect(data).to.have.lengthOf(3)
 
-          const v = videos.find(v => v.name === 'video user 1')
+          const v = data.find(v => v.name === 'video user 1')
           expect(v).to.be.undefined
         }
       })
 
       it('Should hide its comments', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const resThreads = await getVideoCommentThreads(servers[0].url, videoUUID1, 0, 20, '-createdAt', token)
-
-          let threads: VideoComment[] = resThreads.body.data
-          threads = threads.filter(t => t.isDeleted === false)
+          const { data } = await commentsCommand[0].listThreads({ videoId: videoUUID1, count: 20, sort: '-createdAt', token })
+          const threads = data.filter(t => t.isDeleted === false)
 
           expect(threads).to.have.lengthOf(1)
           expect(threads[0].totalReplies).to.equal(1)
@@ -571,9 +524,7 @@ describe('Test blocklist', function () {
           expect(t).to.be.undefined
 
           for (const thread of threads) {
-            const res = await getVideoThreadComments(servers[0].url, videoUUID1, thread.id, token)
-
-            const tree: VideoCommentThreadTree = res.body
+            const tree = await commentsCommand[0].getThread({ videoId: videoUUID1, threadId: thread.id, token })
             expect(tree.children).to.have.lengthOf(0)
           }
         }
@@ -600,12 +551,10 @@ describe('Test blocklist', function () {
 
       it('Should list blocked accounts', async function () {
         {
-          const res = await getAccountBlocklistByServer(servers[0].url, servers[0].accessToken, 0, 1, 'createdAt')
-          const blocks: AccountBlock[] = res.body.data
-
-          expect(res.body.total).to.equal(2)
+          const body = await command.listServerAccountBlocklist({ start: 0, count: 1, sort: 'createdAt' })
+          expect(body.total).to.equal(2)
 
-          const block = blocks[0]
+          const block = body.data[0]
           expect(block.byAccount.displayName).to.equal('peertube')
           expect(block.byAccount.name).to.equal('peertube')
           expect(block.blockedAccount.displayName).to.equal('user2')
@@ -614,12 +563,10 @@ describe('Test blocklist', function () {
         }
 
         {
-          const res = await getAccountBlocklistByServer(servers[0].url, servers[0].accessToken, 1, 2, 'createdAt')
-          const blocks: AccountBlock[] = res.body.data
+          const body = await command.listServerAccountBlocklist({ start: 1, count: 2, sort: 'createdAt' })
+          expect(body.total).to.equal(2)
 
-          expect(res.body.total).to.equal(2)
-
-          const block = blocks[0]
+          const block = body.data[0]
           expect(block.byAccount.displayName).to.equal('peertube')
           expect(block.byAccount.name).to.equal('peertube')
           expect(block.blockedAccount.displayName).to.equal('user1')
@@ -629,28 +576,26 @@ describe('Test blocklist', function () {
       })
 
       it('Should unblock the remote account', async function () {
-        await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, 'user2@localhost:' + servers[1].port)
+        await command.removeFromServerBlocklist({ account: 'user2@localhost:' + servers[1].port })
       })
 
       it('Should display its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const res = await getVideosListWithToken(servers[0].url, token)
-
-          const videos: Video[] = res.body.data
-          expect(videos).to.have.lengthOf(4)
+          const { data } = await servers[0].videos.listWithToken({ token })
+          expect(data).to.have.lengthOf(4)
 
-          const v = videos.find(v => v.name === 'video user 2')
+          const v = data.find(v => v.name === 'video user 2')
           expect(v).not.to.be.undefined
         }
       })
 
       it('Should unblock the local account', async function () {
-        await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, 'user1')
+        await command.removeFromServerBlocklist({ account: 'user1' })
       })
 
       it('Should display its comments', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllComments(servers[0].url, token, videoUUID1)
+          await checkAllComments(servers[0], token, videoUUID1)
         }
       })
 
@@ -677,31 +622,33 @@ describe('Test blocklist', function () {
     describe('When managing server blocklist', function () {
       it('Should list all videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllVideos(servers[0].url, token)
+          await checkAllVideos(servers[0], token)
         }
       })
 
       it('Should list the comments', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllComments(servers[0].url, token, videoUUID1)
+          await checkAllComments(servers[0], token, videoUUID1)
         }
       })
 
       it('Should block a remote server', async function () {
-        await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.addToServerBlocklist({ server: 'localhost:' + servers[1].port })
       })
 
       it('Should hide its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const res1 = await getVideosList(servers[0].url)
-          const res2 = await getVideosListWithToken(servers[0].url, token)
+          const requests = [
+            servers[0].videos.list(),
+            servers[0].videos.listWithToken({ token })
+          ]
 
-          for (const res of [ res1, res2 ]) {
-            const videos: Video[] = res.body.data
-            expect(videos).to.have.lengthOf(3)
+          for (const req of requests) {
+            const { data } = await req
+            expect(data).to.have.lengthOf(3)
 
-            const v1 = videos.find(v => v.name === 'video user 2')
-            const v2 = videos.find(v => v.name === 'video server 2')
+            const v1 = data.find(v => v.name === 'video user 2')
+            const v2 = data.find(v => v.name === 'video server 2')
 
             expect(v1).to.be.undefined
             expect(v2).to.be.undefined
@@ -712,14 +659,13 @@ describe('Test blocklist', function () {
       it('Should hide its comments', async function () {
         this.timeout(10000)
 
-        const resThreads = await addVideoCommentThread(servers[1].url, userToken2, videoUUID1, 'hidden comment 2')
-        const threadId = resThreads.body.comment.id
+        const { id } = await commentsCommand[1].createThread({ token: userToken2, videoId: videoUUID1, text: 'hidden comment 2' })
 
         await waitJobs(servers)
 
-        await checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        await checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
 
-        await deleteVideoComment(servers[1].url, userToken2, videoUUID1, threadId)
+        await commentsCommand[1].delete({ token: userToken2, videoId: videoUUID1, commentId: id })
       })
 
       it('Should not have notification from blocked instances by instance', async function () {
@@ -742,48 +688,44 @@ describe('Test blocklist', function () {
 
         {
           const now = new Date()
-          await unfollow(servers[1].url, servers[1].accessToken, servers[0])
+          await servers[1].follows.unfollow({ target: servers[0] })
           await waitJobs(servers)
-          await follow(servers[1].url, [ servers[0].host ], servers[1].accessToken)
+          await servers[1].follows.follow({ hosts: [ servers[0].host ] })
 
           await waitJobs(servers)
 
-          const res = await getUserNotifications(servers[0].url, servers[0].accessToken, 0, 30)
-          const commentNotifications = (res.body.data as UserNotification[])
-                                          .filter(n => {
-                                            return n.type === UserNotificationType.NEW_INSTANCE_FOLLOWER &&
-                                            n.createdAt >= now.toISOString()
-                                          })
+          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()
+          })
 
           expect(commentNotifications).to.have.lengthOf(0)
         }
       })
 
       it('Should list blocked servers', async function () {
-        const res = await getServerBlocklistByServer(servers[0].url, servers[0].accessToken, 0, 1, 'createdAt')
-        const blocks: ServerBlock[] = res.body.data
-
-        expect(res.body.total).to.equal(1)
+        const body = await command.listServerServerBlocklist({ start: 0, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(1)
 
-        const block = blocks[0]
+        const block = body.data[0]
         expect(block.byAccount.displayName).to.equal('peertube')
         expect(block.byAccount.name).to.equal('peertube')
         expect(block.blockedServer.host).to.equal('localhost:' + servers[1].port)
       })
 
       it('Should unblock the remote server', async function () {
-        await removeServerFromServerBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.removeFromServerBlocklist({ server: 'localhost:' + servers[1].port })
       })
 
       it('Should list all videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllVideos(servers[0].url, token)
+          await checkAllVideos(servers[0], token)
         }
       })
 
       it('Should list the comments', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllComments(servers[0].url, token, videoUUID1)
+          await checkAllComments(servers[0], token, videoUUID1)
         }
       })
 
@@ -807,18 +749,16 @@ describe('Test blocklist', function () {
 
         {
           const now = new Date()
-          await unfollow(servers[1].url, servers[1].accessToken, servers[0])
+          await servers[1].follows.unfollow({ target: servers[0] })
           await waitJobs(servers)
-          await follow(servers[1].url, [ servers[0].host ], servers[1].accessToken)
+          await servers[1].follows.follow({ hosts: [ servers[0].host ] })
 
           await waitJobs(servers)
 
-          const res = await getUserNotifications(servers[0].url, servers[0].accessToken, 0, 30)
-          const commentNotifications = (res.body.data as UserNotification[])
-                                          .filter(n => {
-                                            return n.type === UserNotificationType.NEW_INSTANCE_FOLLOWER &&
-                                            n.createdAt >= now.toISOString()
-                                          })
+          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()
+          })
 
           expect(commentNotifications).to.have.lengthOf(1)
         }
diff --git a/server/tests/api/moderation/video-blacklist.ts b/server/tests/api/moderation/video-blacklist.ts
index 52cac20d9..d5838191a 100644
--- a/server/tests/api/moderation/video-blacklist.ts
+++ b/server/tests/api/moderation/video-blacklist.ts
@@ -4,44 +4,30 @@ import 'mocha'
 import * as chai from 'chai'
 import { orderBy } from 'lodash'
 import {
-  addVideoToBlacklist,
+  BlacklistCommand,
   cleanupTests,
-  createUser,
-  flushAndRunMultipleServers,
-  getBlacklistedVideosList,
-  getMyUserInformation,
-  getMyVideos,
-  getVideosList,
+  createMultipleServers,
+  doubleFollow,
+  FIXTURE_URLS,
   killallServers,
-  removeVideoFromBlacklist,
-  reRunServer,
-  searchVideo,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateVideo,
-  updateVideoBlacklist,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils/index'
-import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { getGoodVideoUrl, getMagnetURI, importVideo } from '../../../../shared/extra-utils/videos/video-imports'
-import { User, UserRole } from '../../../../shared/models/users'
-import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
-import { VideoBlacklist, VideoBlacklistType } from '../../../../shared/models/videos'
+  waitJobs
+} from '@shared/extra-utils'
+import { UserAdminFlag, UserRole, VideoBlacklist, VideoBlacklistType } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test video blacklist', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoId: number
+  let command: BlacklistCommand
 
-  async function blacklistVideosOnServer (server: ServerInfo) {
-    const res = await getVideosList(server.url)
+  async function blacklistVideosOnServer (server: PeerTubeServer) {
+    const { data } = await server.videos.list()
 
-    const videos = res.body.data
-    for (const video of videos) {
-      await addVideoToBlacklist(server.url, server.accessToken, video.id, 'super reason')
+    for (const video of data) {
+      await server.blacklist.add({ videoId: video.id, reason: 'super reason' })
     }
   }
 
@@ -49,7 +35,7 @@ describe('Test video blacklist', function () {
     this.timeout(50000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -58,12 +44,14 @@ describe('Test video blacklist', function () {
     await doubleFollow(servers[0], servers[1])
 
     // Upload 2 videos on server 2
-    await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'My 1st video', description: 'A video on server 2' })
-    await uploadVideo(servers[1].url, servers[1].accessToken, { 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].blacklist
+
     // Blacklist the two videos on server 1
     await blacklistVideosOnServer(servers[0])
   })
@@ -72,48 +60,47 @@ describe('Test video blacklist', function () {
 
     it('Should not have the video blacklisted in videos list/search on server 1', async function () {
       {
-        const res = await getVideosList(servers[0].url)
+        const { total, data } = await servers[0].videos.list()
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data.length).to.equal(0)
+        expect(total).to.equal(0)
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(0)
       }
 
       {
-        const res = await searchVideo(servers[0].url, 'name')
+        const body = await servers[0].search.searchVideos({ search: 'video' })
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data.length).to.equal(0)
+        expect(body.total).to.equal(0)
+        expect(body.data).to.be.an('array')
+        expect(body.data.length).to.equal(0)
       }
     })
 
     it('Should have the blacklisted video in videos list/search on server 2', async function () {
       {
-        const res = await getVideosList(servers[1].url)
+        const { total, data } = await servers[1].videos.list()
 
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data.length).to.equal(2)
+        expect(total).to.equal(2)
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(2)
       }
 
       {
-        const res = await searchVideo(servers[1].url, 'video')
+        const body = await servers[1].search.searchVideos({ search: 'video' })
 
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data.length).to.equal(2)
+        expect(body.total).to.equal(2)
+        expect(body.data).to.be.an('array')
+        expect(body.data.length).to.equal(2)
       }
     })
   })
 
   describe('When listing manually blacklisted videos', function () {
     it('Should display all the blacklisted videos', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken })
-
-      expect(res.body.total).to.equal(2)
+      const body = await command.list()
+      expect(body.total).to.equal(2)
 
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(2)
 
@@ -124,79 +111,66 @@ describe('Test video blacklist', function () {
     })
 
     it('Should display all the blacklisted videos when applying manual type filter', async function () {
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        type: VideoBlacklistType.MANUAL
-      })
+      const body = await command.list({ type: VideoBlacklistType.MANUAL })
+      expect(body.total).to.equal(2)
 
-      expect(res.body.total).to.equal(2)
-
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(2)
     })
 
     it('Should display nothing when applying automatic type filter', async function () {
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
-      })
-
-      expect(res.body.total).to.equal(0)
+      const body = await command.list({ type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
+      expect(body.total).to.equal(0)
 
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(0)
     })
 
     it('Should get the correct sort when sorting by descending id', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: '-id' })
-      expect(res.body.total).to.equal(2)
+      const body = await command.list({ sort: '-id' })
+      expect(body.total).to.equal(2)
 
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(2)
 
-      const result = orderBy(res.body.data, [ 'id' ], [ 'desc' ])
-
+      const result = orderBy(body.data, [ 'id' ], [ 'desc' ])
       expect(blacklistedVideos).to.deep.equal(result)
     })
 
     it('Should get the correct sort when sorting by descending video name', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: '-name' })
-      expect(res.body.total).to.equal(2)
+      const body = await command.list({ sort: '-name' })
+      expect(body.total).to.equal(2)
 
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(2)
 
-      const result = orderBy(res.body.data, [ 'name' ], [ 'desc' ])
-
+      const result = orderBy(body.data, [ 'name' ], [ 'desc' ])
       expect(blacklistedVideos).to.deep.equal(result)
     })
 
     it('Should get the correct sort when sorting by ascending creation date', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: 'createdAt' })
-      expect(res.body.total).to.equal(2)
+      const body = await command.list({ sort: 'createdAt' })
+      expect(body.total).to.equal(2)
 
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(2)
 
-      const result = orderBy(res.body.data, [ 'createdAt' ])
-
+      const result = orderBy(body.data, [ 'createdAt' ])
       expect(blacklistedVideos).to.deep.equal(result)
     })
   })
 
   describe('When updating blacklisted videos', function () {
     it('Should change the reason', async function () {
-      await updateVideoBlacklist(servers[0].url, servers[0].accessToken, videoId, 'my super reason updated')
+      await command.update({ videoId, reason: 'my super reason updated' })
 
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: '-name' })
-      const video = res.body.data.find(b => b.video.id === videoId)
+      const body = await command.list({ sort: '-name' })
+      const video = body.data.find(b => b.video.id === videoId)
 
       expect(video.reason).to.equal('my super reason updated')
     })
@@ -206,12 +180,12 @@ describe('Test video blacklist', function () {
     it('Should display blacklisted videos', async function () {
       await blacklistVideosOnServer(servers[1])
 
-      const res = await getMyVideos(servers[1].url, servers[1].accessToken, 0, 5)
+      const { total, data } = await servers[1].videos.listMyVideos()
 
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      expect(total).to.equal(2)
+      expect(data).to.have.lengthOf(2)
 
-      for (const video of res.body.data) {
+      for (const video of data) {
         expect(video.blacklisted).to.be.true
         expect(video.blacklistedReason).to.equal('super reason')
       }
@@ -223,39 +197,38 @@ describe('Test video blacklist', function () {
     let blacklist = []
 
     it('Should not have any video in videos list on server 1', async function () {
-      const res = await getVideosList(servers[0].url)
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data.length).to.equal(0)
+      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)
     })
 
     it('Should remove a video from the blacklist on server 1', async function () {
       // Get one video in the blacklist
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: '-name' })
-      videoToRemove = res.body.data[0]
-      blacklist = res.body.data.slice(1)
+      const body = await command.list({ sort: '-name' })
+      videoToRemove = body.data[0]
+      blacklist = body.data.slice(1)
 
       // Remove it
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoToRemove.video.id)
+      await command.remove({ videoId: videoToRemove.video.id })
     })
 
     it('Should have the ex-blacklisted video in videos list on server 1', async function () {
-      const res = await getVideosList(servers[0].url)
-      expect(res.body.total).to.equal(1)
+      const { total, data } = await servers[0].videos.list()
+      expect(total).to.equal(1)
 
-      const videos = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos.length).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(1)
 
-      expect(videos[0].name).to.equal(videoToRemove.video.name)
-      expect(videos[0].id).to.equal(videoToRemove.video.id)
+      expect(data[0].name).to.equal(videoToRemove.video.name)
+      expect(data[0].id).to.equal(videoToRemove.video.id)
     })
 
     it('Should not have the ex-blacklisted video in videos blacklist list on server 1', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: '-name' })
-      expect(res.body.total).to.equal(1)
+      const body = await command.list({ sort: '-name' })
+      expect(body.total).to.equal(1)
 
-      const videos = res.body.data
+      const videos = body.data
       expect(videos).to.be.an('array')
       expect(videos.length).to.equal(1)
       expect(videos).to.deep.equal(blacklist)
@@ -270,12 +243,12 @@ describe('Test video blacklist', function () {
       this.timeout(10000)
 
       {
-        const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'Video 3' })
-        video3UUID = res.body.video.uuid
+        const { uuid } = await servers[0].videos.upload({ attributes: { name: 'Video 3' } })
+        video3UUID = uuid
       }
       {
-        const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'Video 4' })
-        video4UUID = res.body.video.uuid
+        const { uuid } = await servers[0].videos.upload({ attributes: { name: 'Video 4' } })
+        video4UUID = uuid
       }
 
       await waitJobs(servers)
@@ -284,51 +257,51 @@ describe('Test video blacklist', function () {
     it('Should blacklist video 3 and keep it federated', async function () {
       this.timeout(10000)
 
-      await addVideoToBlacklist(servers[0].url, servers[0].accessToken, video3UUID, 'super reason', false)
+      await command.add({ videoId: video3UUID, reason: 'super reason', unfederate: false })
 
       await waitJobs(servers)
 
       {
-        const res = await getVideosList(servers[0].url)
-        expect(res.body.data.find(v => v.uuid === video3UUID)).to.be.undefined
+        const { data } = await servers[0].videos.list()
+        expect(data.find(v => v.uuid === video3UUID)).to.be.undefined
       }
 
       {
-        const res = await getVideosList(servers[1].url)
-        expect(res.body.data.find(v => v.uuid === video3UUID)).to.not.be.undefined
+        const { data } = await servers[1].videos.list()
+        expect(data.find(v => v.uuid === video3UUID)).to.not.be.undefined
       }
     })
 
     it('Should unfederate the video', async function () {
       this.timeout(10000)
 
-      await addVideoToBlacklist(servers[0].url, servers[0].accessToken, video4UUID, 'super reason', true)
+      await command.add({ videoId: video4UUID, reason: 'super reason', unfederate: true })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        expect(res.body.data.find(v => v.uuid === video4UUID)).to.be.undefined
+        const { data } = await server.videos.list()
+        expect(data.find(v => v.uuid === video4UUID)).to.be.undefined
       }
     })
 
     it('Should have the video unfederated even after an Update AP message', async function () {
       this.timeout(10000)
 
-      await updateVideo(servers[0].url, servers[0].accessToken, video4UUID, { description: 'super description' })
+      await servers[0].videos.update({ id: video4UUID, attributes: { description: 'super description' } })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        expect(res.body.data.find(v => v.uuid === video4UUID)).to.be.undefined
+        const { data } = await server.videos.list()
+        expect(data.find(v => v.uuid === video4UUID)).to.be.undefined
       }
     })
 
     it('Should have the correct video blacklist unfederate attribute', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: 'createdAt' })
+      const body = await command.list({ sort: 'createdAt' })
 
-      const blacklistedVideos: VideoBlacklist[] = res.body.data
+      const blacklistedVideos = body.data
       const video3Blacklisted = blacklistedVideos.find(b => b.video.uuid === video3UUID)
       const video4Blacklisted = blacklistedVideos.find(b => b.video.uuid === video4UUID)
 
@@ -339,13 +312,13 @@ describe('Test video blacklist', function () {
     it('Should remove the video from blacklist and refederate the video', async function () {
       this.timeout(10000)
 
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, video4UUID)
+      await command.remove({ videoId: video4UUID })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        expect(res.body.data.find(v => v.uuid === video4UUID)).to.not.be.undefined
+        const { data } = await server.videos.list()
+        expect(data.find(v => v.uuid === video4UUID)).to.not.be.undefined
       }
     })
 
@@ -359,7 +332,7 @@ describe('Test video blacklist', function () {
     before(async function () {
       this.timeout(20000)
 
-      killallServers([ servers[0] ])
+      await killallServers([ servers[0] ])
 
       const config = {
         auto_blacklist: {
@@ -370,106 +343,79 @@ describe('Test video blacklist', function () {
           }
         }
       }
-      await reRunServer(servers[0], config)
+      await servers[0].run(config)
 
       {
         const user = { username: 'user_without_flag', password: 'password' }
-        await createUser({
-          url: servers[0].url,
-          accessToken: servers[0].accessToken,
+        await servers[0].users.create({
           username: user.username,
           adminFlags: UserAdminFlag.NONE,
           password: user.password,
           role: UserRole.USER
         })
 
-        userWithoutFlag = await userLogin(servers[0], user)
+        userWithoutFlag = await servers[0].login.getAccessToken(user)
 
-        const res = await getMyUserInformation(servers[0].url, userWithoutFlag)
-        const body: User = res.body
-        channelOfUserWithoutFlag = body.videoChannels[0].id
+        const { videoChannels } = await servers[0].users.getMyInfo({ token: userWithoutFlag })
+        channelOfUserWithoutFlag = videoChannels[0].id
       }
 
       {
         const user = { username: 'user_with_flag', password: 'password' }
-        await createUser({
-          url: servers[0].url,
-          accessToken: servers[0].accessToken,
+        await servers[0].users.create({
           username: user.username,
           adminFlags: UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST,
           password: user.password,
           role: UserRole.USER
         })
 
-        userWithFlag = await userLogin(servers[0], user)
+        userWithFlag = await servers[0].login.getAccessToken(user)
       }
 
       await waitJobs(servers)
     })
 
     it('Should auto blacklist a video on upload', async function () {
-      await uploadVideo(servers[0].url, userWithoutFlag, { name: 'blacklisted' })
-
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
-      })
+      await servers[0].videos.upload({ token: userWithoutFlag, attributes: { name: 'blacklisted' } })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data[0].video.name).to.equal('blacklisted')
+      const body = await command.list({ type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].video.name).to.equal('blacklisted')
     })
 
     it('Should auto blacklist a video on URL import', async function () {
       this.timeout(15000)
 
       const attributes = {
-        targetUrl: getGoodVideoUrl(),
+        targetUrl: FIXTURE_URLS.goodVideo,
         name: 'URL import',
         channelId: channelOfUserWithoutFlag
       }
-      await importVideo(servers[0].url, userWithoutFlag, attributes)
+      await servers[0].imports.importVideo({ token: userWithoutFlag, attributes })
 
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        sort: 'createdAt',
-        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
-      })
-
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data[1].video.name).to.equal('URL import')
+      const body = await command.list({ sort: 'createdAt', type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
+      expect(body.total).to.equal(2)
+      expect(body.data[1].video.name).to.equal('URL import')
     })
 
     it('Should auto blacklist a video on torrent import', async function () {
       const attributes = {
-        magnetUri: getMagnetURI(),
+        magnetUri: FIXTURE_URLS.magnet,
         name: 'Torrent import',
         channelId: channelOfUserWithoutFlag
       }
-      await importVideo(servers[0].url, userWithoutFlag, attributes)
-
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        sort: 'createdAt',
-        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
-      })
+      await servers[0].imports.importVideo({ token: userWithoutFlag, attributes })
 
-      expect(res.body.total).to.equal(3)
-      expect(res.body.data[2].video.name).to.equal('Torrent import')
+      const body = await command.list({ sort: 'createdAt', type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
+      expect(body.total).to.equal(3)
+      expect(body.data[2].video.name).to.equal('Torrent import')
     })
 
     it('Should not auto blacklist a video on upload if the user has the bypass blacklist flag', async function () {
-      await uploadVideo(servers[0].url, userWithFlag, { name: 'not blacklisted' })
-
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
-      })
+      await servers[0].videos.upload({ token: userWithFlag, attributes: { name: 'not blacklisted' } })
 
-      expect(res.body.total).to.equal(3)
+      const body = await command.list({ type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
+      expect(body.total).to.equal(3)
     })
   })