21 files changed, 1772 insertions, 2364 deletions

diff --git a/server/tests/api/videos/audio-only.ts b/server/tests/api/videos/audio-only.ts
index 7ddbd5cd9..15c3ae6d6 100644
--- a/server/tests/api/videos/audio-only.ts
+++ b/server/tests/api/videos/audio-only.ts
@@ -4,23 +4,12 @@ import 'mocha'
 import * as chai from 'chai'
 import { join } from 'path'
 import { getAudioStream, getVideoStreamSize } from '@server/helpers/ffprobe-utils'
-import {
-  buildServerDirectory,
-  cleanupTests,
-  doubleFollow,
-  flushAndRunMultipleServers,
-  getVideo,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo,
-  waitJobs
-} from '../../../../shared/extra-utils'
-import { VideoDetails } from '../../../../shared/models/videos'
+import { cleanupTests, createMultipleServers, doubleFollow, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test audio only video transcoding', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoUUID: string
 
   before(async function () {
@@ -47,7 +36,7 @@ describe('Test audio only video transcoding', function () {
         }
       }
     }
-    servers = await flushAndRunMultipleServers(2, configOverride)
+    servers = await createMultipleServers(2, configOverride)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -59,15 +48,13 @@ describe('Test audio only video transcoding', function () {
   it('Should upload a video and transcode it', async function () {
     this.timeout(120000)
 
-    const resUpload = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'audio only' })
-    videoUUID = resUpload.body.video.uuid
+    const { uuid } = await servers[0].videos.upload({ attributes: { name: 'audio only' } })
+    videoUUID = uuid
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = res.body
-
+      const video = await server.videos.get({ id: videoUUID })
       expect(video.streamingPlaylists).to.have.lengthOf(1)
 
       for (const files of [ video.files, video.streamingPlaylists[0].files ]) {
@@ -81,8 +68,8 @@ describe('Test audio only video transcoding', function () {
 
   it('0p transcoded video should not have video', async function () {
     const paths = [
-      buildServerDirectory(servers[0], join('videos', videoUUID + '-0.mp4')),
-      buildServerDirectory(servers[0], join('streaming-playlists', 'hls', videoUUID, videoUUID + '-0-fragmented.mp4'))
+      servers[0].servers.buildDirectory(join('videos', videoUUID + '-0.mp4')),
+      servers[0].servers.buildDirectory(join('streaming-playlists', 'hls', videoUUID, videoUUID + '-0-fragmented.mp4'))
     ]
 
     for (const path of paths) {
diff --git a/server/tests/api/videos/multiple-servers.ts b/server/tests/api/videos/multiple-servers.ts
index a8c8a889b..d916abb09 100644
--- a/server/tests/api/videos/multiple-servers.ts
+++ b/server/tests/api/videos/multiple-servers.ts
@@ -3,49 +3,28 @@
 import 'mocha'
 import * as chai from 'chai'
 import * as request from 'supertest'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoChannel,
   buildAbsoluteFixturePath,
   checkTmpIsEmpty,
   checkVideoFilesWereRemoved,
   cleanupTests,
   completeVideoCheck,
-  createUser,
+  createMultipleServers,
   dateIsValid,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getLocalVideos,
-  getVideo,
-  getVideoChannelsList,
-  getVideosList,
-  rateVideo,
-  removeVideo,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   testImage,
-  updateVideo,
-  uploadVideo,
-  userLogin,
-  viewVideo,
   wait,
+  waitJobs,
   webtorrentAdd
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  addVideoCommentReply,
-  addVideoCommentThread,
-  deleteVideoComment,
-  findCommentId,
-  getVideoCommentThreads,
-  getVideoThreadComments
-} from '../../../../shared/extra-utils/videos/video-comments'
-import { VideoComment, VideoCommentThreadTree, VideoPrivacy } from '../../../../shared/models/videos'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoCommentThreadTree, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test multiple servers', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   const toRemove = []
   let videoUUID = ''
   let videoChannelId: number
@@ -53,7 +32,7 @@ describe('Test multiple servers', function () {
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -64,9 +43,9 @@ describe('Test multiple servers', function () {
         displayName: 'my channel',
         description: 'super channel'
       }
-      await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
-      const channelRes = await getVideoChannelsList(servers[0].url, 0, 1)
-      videoChannelId = channelRes.body.data[0].id
+      await servers[0].channels.create({ attributes: videoChannel })
+      const { data } = await servers[0].channels.list({ start: 0, count: 1 })
+      videoChannelId = data[0].id
     }
 
     // Server 1 and server 2 follow each other
@@ -79,10 +58,9 @@ describe('Test multiple servers', function () {
 
   it('Should not have videos for all servers', async function () {
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      const videos = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos.length).to.equal(0)
+      const { data } = await server.videos.list()
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(0)
     }
   })
 
@@ -90,7 +68,7 @@ describe('Test multiple servers', function () {
     it('Should upload the video on server 1 and propagate on each server', async function () {
       this.timeout(25000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name for server 1',
         category: 5,
         licence: 4,
@@ -103,7 +81,7 @@ describe('Test multiple servers', function () {
         channelId: videoChannelId,
         fixture: 'video_short1.webm'
       }
-      await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+      await servers[0].videos.upload({ attributes })
 
       await waitJobs(servers)
 
@@ -146,14 +124,13 @@ describe('Test multiple servers', function () {
           ]
         }
 
-        const res = await getVideosList(server.url)
-        const videos = res.body.data
-        expect(videos).to.be.an('array')
-        expect(videos.length).to.equal(1)
-        const video = videos[0]
+        const { data } = await server.videos.list()
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(1)
+        const video = data[0]
 
-        await completeVideoCheck(server.url, video, checkAttributes)
-        publishedAt = video.publishedAt
+        await completeVideoCheck(server, video, checkAttributes)
+        publishedAt = video.publishedAt as string
       }
     })
 
@@ -164,10 +141,10 @@ describe('Test multiple servers', function () {
         username: 'user1',
         password: 'super_password'
       }
-      await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
-      const userAccessToken = await userLogin(servers[1], user)
+      await servers[1].users.create({ username: user.username, password: user.password })
+      const userAccessToken = await servers[1].login.getAccessToken(user)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name for server 2',
         category: 4,
         licence: 3,
@@ -180,7 +157,7 @@ describe('Test multiple servers', function () {
         thumbnailfile: 'thumbnail.jpg',
         previewfile: 'preview.jpg'
       }
-      await uploadVideo(servers[1].url, userAccessToken, videoAttributes, HttpStatusCode.OK_200, 'resumable')
+      await servers[1].videos.upload({ token: userAccessToken, attributes, mode: 'resumable' })
 
       // Transcoding
       await waitJobs(servers)
@@ -235,65 +212,67 @@ describe('Test multiple servers', function () {
           previewfile: 'preview'
         }
 
-        const res = await getVideosList(server.url)
-        const videos = res.body.data
-        expect(videos).to.be.an('array')
-        expect(videos.length).to.equal(2)
-        const video = videos[1]
+        const { data } = await server.videos.list()
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(2)
+        const video = data[1]
 
-        await completeVideoCheck(server.url, video, checkAttributes)
+        await completeVideoCheck(server, video, checkAttributes)
       }
     })
 
     it('Should upload two videos on server 3 and propagate on each server', async function () {
       this.timeout(45000)
 
-      const videoAttributes1 = {
-        name: 'my super name for server 3',
-        category: 6,
-        licence: 5,
-        language: 'de',
-        nsfw: true,
-        description: 'my super description for server 3',
-        support: 'my super support text for server 3',
-        tags: [ 'tag1p3' ],
-        fixture: 'video_short3.webm'
+      {
+        const attributes = {
+          name: 'my super name for server 3',
+          category: 6,
+          licence: 5,
+          language: 'de',
+          nsfw: true,
+          description: 'my super description for server 3',
+          support: 'my super support text for server 3',
+          tags: [ 'tag1p3' ],
+          fixture: 'video_short3.webm'
+        }
+        await servers[2].videos.upload({ attributes })
       }
-      await uploadVideo(servers[2].url, servers[2].accessToken, videoAttributes1)
-
-      const videoAttributes2 = {
-        name: 'my super name for server 3-2',
-        category: 7,
-        licence: 6,
-        language: 'ko',
-        nsfw: false,
-        description: 'my super description for server 3-2',
-        support: 'my super support text for server 3-2',
-        tags: [ 'tag2p3', 'tag3p3', 'tag4p3' ],
-        fixture: 'video_short.webm'
+
+      {
+        const attributes = {
+          name: 'my super name for server 3-2',
+          category: 7,
+          licence: 6,
+          language: 'ko',
+          nsfw: false,
+          description: 'my super description for server 3-2',
+          support: 'my super support text for server 3-2',
+          tags: [ 'tag2p3', 'tag3p3', 'tag4p3' ],
+          fixture: 'video_short.webm'
+        }
+        await servers[2].videos.upload({ attributes })
       }
-      await uploadVideo(servers[2].url, servers[2].accessToken, videoAttributes2)
 
       await waitJobs(servers)
 
       // All servers should have this video
       for (const server of servers) {
         const isLocal = server.url === 'http://localhost:' + servers[2].port
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const videos = res.body.data
-        expect(videos).to.be.an('array')
-        expect(videos.length).to.equal(4)
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(4)
 
         // We not sure about the order of the two last uploads
         let video1 = null
         let video2 = null
-        if (videos[2].name === 'my super name for server 3') {
-          video1 = videos[2]
-          video2 = videos[3]
+        if (data[2].name === 'my super name for server 3') {
+          video1 = data[2]
+          video2 = data[3]
         } else {
-          video1 = videos[3]
-          video2 = videos[2]
+          video1 = data[3]
+          video2 = data[2]
         }
 
         const checkAttributesVideo1 = {
@@ -328,7 +307,7 @@ describe('Test multiple servers', function () {
             }
           ]
         }
-        await completeVideoCheck(server.url, video1, checkAttributesVideo1)
+        await completeVideoCheck(server, video1, checkAttributesVideo1)
 
         const checkAttributesVideo2 = {
           name: 'my super name for server 3-2',
@@ -362,38 +341,38 @@ describe('Test multiple servers', function () {
             }
           ]
         }
-        await completeVideoCheck(server.url, video2, checkAttributesVideo2)
+        await completeVideoCheck(server, video2, checkAttributesVideo2)
       }
     })
   })
 
   describe('It should list local videos', function () {
     it('Should list only local videos on server 1', async function () {
-      const { body } = await getLocalVideos(servers[0].url)
+      const { data, total } = await servers[0].videos.list({ filter: 'local' })
 
-      expect(body.total).to.equal(1)
-      expect(body.data).to.be.an('array')
-      expect(body.data.length).to.equal(1)
-      expect(body.data[0].name).to.equal('my super name for server 1')
+      expect(total).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(1)
+      expect(data[0].name).to.equal('my super name for server 1')
     })
 
     it('Should list only local videos on server 2', async function () {
-      const { body } = await getLocalVideos(servers[1].url)
+      const { data, total } = await servers[1].videos.list({ filter: 'local' })
 
-      expect(body.total).to.equal(1)
-      expect(body.data).to.be.an('array')
-      expect(body.data.length).to.equal(1)
-      expect(body.data[0].name).to.equal('my super name for server 2')
+      expect(total).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(1)
+      expect(data[0].name).to.equal('my super name for server 2')
     })
 
     it('Should list only local videos on server 3', async function () {
-      const { body } = await getLocalVideos(servers[2].url)
+      const { data, total } = await servers[2].videos.list({ filter: 'local' })
 
-      expect(body.total).to.equal(2)
-      expect(body.data).to.be.an('array')
-      expect(body.data.length).to.equal(2)
-      expect(body.data[0].name).to.equal('my super name for server 3')
-      expect(body.data[1].name).to.equal('my super name for server 3-2')
+      expect(total).to.equal(2)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(2)
+      expect(data[0].name).to.equal('my super name for server 3')
+      expect(data[1].name).to.equal('my super name for server 3-2')
     })
   })
 
@@ -401,15 +380,13 @@ describe('Test multiple servers', function () {
     it('Should add the file 1 by asking server 3', async function () {
       this.timeout(10000)
 
-      const res = await getVideosList(servers[2].url)
-
-      const video = res.body.data[0]
-      toRemove.push(res.body.data[2])
-      toRemove.push(res.body.data[3])
+      const { data } = await servers[2].videos.list()
 
-      const res2 = await getVideo(servers[2].url, video.id)
-      const videoDetails = res2.body
+      const video = data[0]
+      toRemove.push(data[2])
+      toRemove.push(data[3])
 
+      const videoDetails = await servers[2].videos.get({ id: video.id })
       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
       expect(torrent.files).to.be.an('array')
       expect(torrent.files.length).to.equal(1)
@@ -419,11 +396,10 @@ describe('Test multiple servers', function () {
     it('Should add the file 2 by asking server 1', async function () {
       this.timeout(10000)
 
-      const res = await getVideosList(servers[0].url)
+      const { data } = await servers[0].videos.list()
 
-      const video = res.body.data[1]
-      const res2 = await getVideo(servers[0].url, video.id)
-      const videoDetails = res2.body
+      const video = data[1]
+      const videoDetails = await servers[0].videos.get({ id: video.id })
 
       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
       expect(torrent.files).to.be.an('array')
@@ -434,11 +410,10 @@ describe('Test multiple servers', function () {
     it('Should add the file 3 by asking server 2', async function () {
       this.timeout(10000)
 
-      const res = await getVideosList(servers[1].url)
+      const { data } = await servers[1].videos.list()
 
-      const video = res.body.data[2]
-      const res2 = await getVideo(servers[1].url, video.id)
-      const videoDetails = res2.body
+      const video = data[2]
+      const videoDetails = await servers[1].videos.get({ id: video.id })
 
       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
       expect(torrent.files).to.be.an('array')
@@ -449,11 +424,10 @@ describe('Test multiple servers', function () {
     it('Should add the file 3-2 by asking server 1', async function () {
       this.timeout(10000)
 
-      const res = await getVideosList(servers[0].url)
+      const { data } = await servers[0].videos.list()
 
-      const video = res.body.data[3]
-      const res2 = await getVideo(servers[0].url, video.id)
-      const videoDetails = res2.body
+      const video = data[3]
+      const videoDetails = await servers[0].videos.get({ id: video.id })
 
       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
       expect(torrent.files).to.be.an('array')
@@ -464,11 +438,10 @@ describe('Test multiple servers', function () {
     it('Should add the file 2 in 360p by asking server 1', async function () {
       this.timeout(10000)
 
-      const res = await getVideosList(servers[0].url)
+      const { data } = await servers[0].videos.list()
 
-      const video = res.body.data.find(v => v.name === 'my super name for server 2')
-      const res2 = await getVideo(servers[0].url, video.id)
-      const videoDetails = res2.body
+      const video = data.find(v => v.name === 'my super name for server 2')
+      const videoDetails = await servers[0].videos.get({ id: video.id })
 
       const file = videoDetails.files.find(f => f.resolution.id === 360)
       expect(file).not.to.be.undefined
@@ -487,30 +460,36 @@ describe('Test multiple servers', function () {
     let remoteVideosServer3 = []
 
     before(async function () {
-      const res1 = await getVideosList(servers[0].url)
-      remoteVideosServer1 = res1.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
+      {
+        const { data } = await servers[0].videos.list()
+        remoteVideosServer1 = data.filter(video => video.isLocal === false).map(video => video.uuid)
+      }
 
-      const res2 = await getVideosList(servers[1].url)
-      remoteVideosServer2 = res2.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
+      {
+        const { data } = await servers[1].videos.list()
+        remoteVideosServer2 = data.filter(video => video.isLocal === false).map(video => video.uuid)
+      }
 
-      const res3 = await getVideosList(servers[2].url)
-      localVideosServer3 = res3.body.data.filter(video => video.isLocal === true).map(video => video.uuid)
-      remoteVideosServer3 = res3.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
+      {
+        const { data } = await servers[2].videos.list()
+        localVideosServer3 = data.filter(video => video.isLocal === true).map(video => video.uuid)
+        remoteVideosServer3 = data.filter(video => video.isLocal === false).map(video => video.uuid)
+      }
     })
 
     it('Should view multiple videos on owned servers', async function () {
       this.timeout(30000)
 
-      await viewVideo(servers[2].url, localVideosServer3[0])
+      await servers[2].videos.view({ id: localVideosServer3[0] })
       await wait(1000)
 
-      await viewVideo(servers[2].url, localVideosServer3[0])
-      await viewVideo(servers[2].url, localVideosServer3[1])
+      await servers[2].videos.view({ id: localVideosServer3[0] })
+      await servers[2].videos.view({ id: localVideosServer3[1] })
 
       await wait(1000)
 
-      await viewVideo(servers[2].url, localVideosServer3[0])
-      await viewVideo(servers[2].url, localVideosServer3[0])
+      await servers[2].videos.view({ id: localVideosServer3[0] })
+      await servers[2].videos.view({ id: localVideosServer3[0] })
 
       await waitJobs(servers)
 
@@ -520,11 +499,10 @@ describe('Test multiple servers', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const videos = res.body.data
-        const video0 = videos.find(v => v.uuid === localVideosServer3[0])
-        const video1 = videos.find(v => v.uuid === localVideosServer3[1])
+        const video0 = data.find(v => v.uuid === localVideosServer3[0])
+        const video1 = data.find(v => v.uuid === localVideosServer3[1])
 
         expect(video0.views).to.equal(3)
         expect(video1.views).to.equal(1)
@@ -535,16 +513,16 @@ describe('Test multiple servers', function () {
       this.timeout(45000)
 
       const tasks: Promise<any>[] = []
-      tasks.push(viewVideo(servers[0].url, remoteVideosServer1[0]))
-      tasks.push(viewVideo(servers[1].url, remoteVideosServer2[0]))
-      tasks.push(viewVideo(servers[1].url, remoteVideosServer2[0]))
-      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[0]))
-      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[1]))
-      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[1]))
-      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[1]))
-      tasks.push(viewVideo(servers[2].url, localVideosServer3[1]))
-      tasks.push(viewVideo(servers[2].url, localVideosServer3[1]))
-      tasks.push(viewVideo(servers[2].url, localVideosServer3[1]))
+      tasks.push(servers[0].videos.view({ id: remoteVideosServer1[0] }))
+      tasks.push(servers[1].videos.view({ id: remoteVideosServer2[0] }))
+      tasks.push(servers[1].videos.view({ id: remoteVideosServer2[0] }))
+      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[0] }))
+      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
+      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
+      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
+      tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
+      tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
+      tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
 
       await Promise.all(tasks)
 
@@ -558,18 +536,16 @@ describe('Test multiple servers', function () {
       let baseVideos = null
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-
-        const videos = res.body.data
+        const { data } = await server.videos.list()
 
         // Initialize base videos for future comparisons
         if (baseVideos === null) {
-          baseVideos = videos
+          baseVideos = data
           continue
         }
 
         for (const baseVideo of baseVideos) {
-          const sameVideo = videos.find(video => video.name === baseVideo.name)
+          const sameVideo = data.find(video => video.name === baseVideo.name)
           expect(baseVideo.views).to.equal(sameVideo.views)
         }
       }
@@ -578,35 +554,34 @@ describe('Test multiple servers', function () {
     it('Should like and dislikes videos on different services', async function () {
       this.timeout(50000)
 
-      await rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'like')
+      await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'like' })
       await wait(500)
-      await rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'dislike')
+      await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'dislike' })
       await wait(500)
-      await rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'like')
-      await rateVideo(servers[2].url, servers[2].accessToken, localVideosServer3[1], 'like')
+      await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'like' })
+      await servers[2].videos.rate({ id: localVideosServer3[1], rating: 'like' })
       await wait(500)
-      await rateVideo(servers[2].url, servers[2].accessToken, localVideosServer3[1], 'dislike')
-      await rateVideo(servers[2].url, servers[2].accessToken, remoteVideosServer3[1], 'dislike')
+      await servers[2].videos.rate({ id: localVideosServer3[1], rating: 'dislike' })
+      await servers[2].videos.rate({ id: remoteVideosServer3[1], rating: 'dislike' })
       await wait(500)
-      await rateVideo(servers[2].url, servers[2].accessToken, remoteVideosServer3[0], 'like')
+      await servers[2].videos.rate({ id: remoteVideosServer3[0], rating: 'like' })
 
       await waitJobs(servers)
       await wait(5000)
+      await waitJobs(servers)
 
       let baseVideos = null
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-
-        const videos = res.body.data
+        const { data } = await server.videos.list()
 
         // Initialize base videos for future comparisons
         if (baseVideos === null) {
-          baseVideos = videos
+          baseVideos = data
           continue
         }
 
         for (const baseVideo of baseVideos) {
-          const sameVideo = videos.find(video => video.name === baseVideo.name)
+          const sameVideo = data.find(video => video.name === baseVideo.name)
           expect(baseVideo.likes).to.equal(sameVideo.likes)
           expect(baseVideo.dislikes).to.equal(sameVideo.dislikes)
         }
@@ -632,7 +607,7 @@ describe('Test multiple servers', function () {
         previewfile: 'preview.jpg'
       }
 
-      await updateVideo(servers[2].url, servers[2].accessToken, toRemove[0].id, attributes)
+      await servers[2].videos.update({ id: toRemove[0].id, attributes })
 
       await waitJobs(servers)
     })
@@ -641,10 +616,9 @@ describe('Test multiple servers', function () {
       this.timeout(10000)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const videos = res.body.data
-        const videoUpdated = videos.find(video => video.name === 'my super video updated')
+        const videoUpdated = data.find(video => video.name === 'my super video updated')
         expect(!!videoUpdated).to.be.true
 
         const isLocal = server.url === 'http://localhost:' + servers[2].port
@@ -683,49 +657,46 @@ describe('Test multiple servers', function () {
           thumbnailfile: 'thumbnail',
           previewfile: 'preview'
         }
-        await completeVideoCheck(server.url, videoUpdated, checkAttributes)
+        await completeVideoCheck(server, videoUpdated, checkAttributes)
       }
     })
 
     it('Should remove the videos 3 and 3-2 by asking server 3', async function () {
       this.timeout(10000)
 
-      await removeVideo(servers[2].url, servers[2].accessToken, toRemove[0].id)
-      await removeVideo(servers[2].url, servers[2].accessToken, toRemove[1].id)
+      await servers[2].videos.remove({ id: toRemove[0].id })
+      await servers[2].videos.remove({ id: toRemove[1].id })
 
       await waitJobs(servers)
     })
 
     it('Should not have files of videos 3 and 3-2 on each server', async function () {
       for (const server of servers) {
-        await checkVideoFilesWereRemoved(toRemove[0].uuid, server.internalServerNumber)
-        await checkVideoFilesWereRemoved(toRemove[1].uuid, server.internalServerNumber)
+        await checkVideoFilesWereRemoved(toRemove[0].uuid, server)
+        await checkVideoFilesWereRemoved(toRemove[1].uuid, server)
       }
     })
 
     it('Should have videos 1 and 3 on each server', async function () {
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-
-        const videos = res.body.data
-        expect(videos).to.be.an('array')
-        expect(videos.length).to.equal(2)
-        expect(videos[0].name).not.to.equal(videos[1].name)
-        expect(videos[0].name).not.to.equal(toRemove[0].name)
-        expect(videos[1].name).not.to.equal(toRemove[0].name)
-        expect(videos[0].name).not.to.equal(toRemove[1].name)
-        expect(videos[1].name).not.to.equal(toRemove[1].name)
-
-        videoUUID = videos.find(video => video.name === 'my super name for server 1').uuid
+        const { data } = await server.videos.list()
+
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(2)
+        expect(data[0].name).not.to.equal(data[1].name)
+        expect(data[0].name).not.to.equal(toRemove[0].name)
+        expect(data[1].name).not.to.equal(toRemove[0].name)
+        expect(data[0].name).not.to.equal(toRemove[1].name)
+        expect(data[1].name).not.to.equal(toRemove[1].name)
+
+        videoUUID = data.find(video => video.name === 'my super name for server 1').uuid
       }
     })
 
     it('Should get the same video by UUID on each server', async function () {
       let baseVideo = null
       for (const server of servers) {
-        const res = await getVideo(server.url, videoUUID)
-
-        const video = res.body
+        const video = await server.videos.get({ id: videoUUID })
 
         if (baseVideo === null) {
           baseVideo = video
@@ -748,8 +719,7 @@ describe('Test multiple servers', function () {
 
     it('Should get the preview from each server', async function () {
       for (const server of servers) {
-        const res = await getVideo(server.url, videoUUID)
-        const video = res.body
+        const video = await server.videos.get({ id: videoUUID })
 
         await testImage(server.url, 'video_short1-preview.webm', video.previewPath)
       }
@@ -764,36 +734,36 @@ describe('Test multiple servers', function () {
 
       {
         const text = 'my super first comment'
-        await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, text)
+        await servers[0].comments.createThread({ videoId: videoUUID, text })
       }
 
       {
         const text = 'my super second comment'
-        await addVideoCommentThread(servers[2].url, servers[2].accessToken, videoUUID, text)
+        await servers[2].comments.createThread({ videoId: videoUUID, text })
       }
 
       await waitJobs(servers)
 
       {
-        const threadId = await findCommentId(servers[1].url, videoUUID, 'my super first comment')
+        const threadId = await servers[1].comments.findCommentId({ videoId: videoUUID, text: 'my super first comment' })
 
         const text = 'my super answer to thread 1'
-        await addVideoCommentReply(servers[1].url, servers[1].accessToken, videoUUID, threadId, text)
+        await servers[1].comments.addReply({ videoId: videoUUID, toCommentId: threadId, text })
       }
 
       await waitJobs(servers)
 
       {
-        const threadId = await findCommentId(servers[2].url, videoUUID, 'my super first comment')
+        const threadId = await servers[2].comments.findCommentId({ videoId: videoUUID, text: 'my super first comment' })
 
-        const res2 = await getVideoThreadComments(servers[2].url, videoUUID, threadId)
-        const childCommentId = res2.body.children[0].comment.id
+        const body = await servers[2].comments.getThread({ videoId: videoUUID, threadId })
+        const childCommentId = body.children[0].comment.id
 
         const text3 = 'my second answer to thread 1'
-        await addVideoCommentReply(servers[2].url, servers[2].accessToken, videoUUID, threadId, text3)
+        await servers[2].comments.addReply({ videoId: videoUUID, toCommentId: threadId, text: text3 })
 
         const text2 = 'my super answer to answer of thread 1'
-        await addVideoCommentReply(servers[2].url, servers[2].accessToken, videoUUID, childCommentId, text2)
+        await servers[2].comments.addReply({ videoId: videoUUID, toCommentId: childCommentId, text: text2 })
       }
 
       await waitJobs(servers)
@@ -801,14 +771,14 @@ describe('Test multiple servers', function () {
 
     it('Should have these threads', async function () {
       for (const server of servers) {
-        const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+        const body = await server.comments.listThreads({ videoId: videoUUID })
 
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data).to.have.lengthOf(2)
+        expect(body.total).to.equal(2)
+        expect(body.data).to.be.an('array')
+        expect(body.data).to.have.lengthOf(2)
 
         {
-          const comment: VideoComment = res.body.data.find(c => c.text === 'my super first comment')
+          const comment = body.data.find(c => c.text === 'my super first comment')
           expect(comment).to.not.be.undefined
           expect(comment.inReplyToCommentId).to.be.null
           expect(comment.account.name).to.equal('root')
@@ -819,7 +789,7 @@ describe('Test multiple servers', function () {
         }
 
         {
-          const comment: VideoComment = res.body.data.find(c => c.text === 'my super second comment')
+          const comment = body.data.find(c => c.text === 'my super second comment')
           expect(comment).to.not.be.undefined
           expect(comment.inReplyToCommentId).to.be.null
           expect(comment.account.name).to.equal('root')
@@ -833,12 +803,11 @@ describe('Test multiple servers', function () {
 
     it('Should have these comments', async function () {
       for (const server of servers) {
-        const res1 = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
-        const threadId = res1.body.data.find(c => c.text === 'my super first comment').id
+        const body = await server.comments.listThreads({ videoId: videoUUID })
+        const threadId = body.data.find(c => c.text === 'my super first comment').id
 
-        const res2 = await getVideoThreadComments(server.url, videoUUID, threadId)
+        const tree = await server.comments.getThread({ videoId: videoUUID, threadId })
 
-        const tree: VideoCommentThreadTree = res2.body
         expect(tree.comment.text).equal('my super first comment')
         expect(tree.comment.account.name).equal('root')
         expect(tree.comment.account.host).equal('localhost:' + servers[0].port)
@@ -867,19 +836,17 @@ describe('Test multiple servers', function () {
     it('Should delete a reply', async function () {
       this.timeout(10000)
 
-      await deleteVideoComment(servers[2].url, servers[2].accessToken, videoUUID, childOfFirstChild.comment.id)
+      await servers[2].comments.delete({ videoId: videoUUID, commentId: childOfFirstChild.comment.id })
 
       await waitJobs(servers)
     })
 
     it('Should have this comment marked as deleted', async function () {
       for (const server of servers) {
-        const res1 = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
-        const threadId = res1.body.data.find(c => c.text === 'my super first comment').id
-
-        const res2 = await getVideoThreadComments(server.url, videoUUID, threadId)
+        const { data } = await server.comments.listThreads({ videoId: videoUUID })
+        const threadId = data.find(c => c.text === 'my super first comment').id
 
-        const tree: VideoCommentThreadTree = res2.body
+        const tree = await server.comments.getThread({ videoId: videoUUID, threadId })
         expect(tree.comment.text).equal('my super first comment')
 
         const firstChild = tree.children[0]
@@ -900,23 +867,23 @@ describe('Test multiple servers', function () {
     it('Should delete the thread comments', async function () {
       this.timeout(10000)
 
-      const res = await getVideoCommentThreads(servers[0].url, videoUUID, 0, 5)
-      const threadId = res.body.data.find(c => c.text === 'my super first comment').id
-      await deleteVideoComment(servers[0].url, servers[0].accessToken, videoUUID, threadId)
+      const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
+      const commentId = data.find(c => c.text === 'my super first comment').id
+      await servers[0].comments.delete({ videoId: videoUUID, commentId })
 
       await waitJobs(servers)
     })
 
     it('Should have the threads marked as deleted on other servers too', async function () {
       for (const server of servers) {
-        const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+        const body = await server.comments.listThreads({ videoId: videoUUID })
 
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data).to.have.lengthOf(2)
+        expect(body.total).to.equal(2)
+        expect(body.data).to.be.an('array')
+        expect(body.data).to.have.lengthOf(2)
 
         {
-          const comment: VideoComment = res.body.data[0]
+          const comment = body.data[0]
           expect(comment).to.not.be.undefined
           expect(comment.inReplyToCommentId).to.be.null
           expect(comment.account.name).to.equal('root')
@@ -927,7 +894,7 @@ describe('Test multiple servers', function () {
         }
 
         {
-          const deletedComment: VideoComment = res.body.data[1]
+          const deletedComment = body.data[1]
           expect(deletedComment).to.not.be.undefined
           expect(deletedComment.isDeleted).to.be.true
           expect(deletedComment.deletedAt).to.not.be.null
@@ -945,22 +912,22 @@ describe('Test multiple servers', function () {
     it('Should delete a remote thread by the origin server', async function () {
       this.timeout(5000)
 
-      const res = await getVideoCommentThreads(servers[0].url, videoUUID, 0, 5)
-      const threadId = res.body.data.find(c => c.text === 'my super second comment').id
-      await deleteVideoComment(servers[0].url, servers[0].accessToken, videoUUID, threadId)
+      const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
+      const commentId = data.find(c => c.text === 'my super second comment').id
+      await servers[0].comments.delete({ videoId: videoUUID, commentId })
 
       await waitJobs(servers)
     })
 
     it('Should have the threads marked as deleted on other servers too', async function () {
       for (const server of servers) {
-        const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+        const body = await server.comments.listThreads({ videoId: videoUUID })
 
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.have.lengthOf(2)
+        expect(body.total).to.equal(2)
+        expect(body.data).to.have.lengthOf(2)
 
         {
-          const comment: VideoComment = res.body.data[0]
+          const comment = body.data[0]
           expect(comment.text).to.equal('')
           expect(comment.isDeleted).to.be.true
           expect(comment.createdAt).to.not.be.null
@@ -970,7 +937,7 @@ describe('Test multiple servers', function () {
         }
 
         {
-          const comment: VideoComment = res.body.data[1]
+          const comment = body.data[1]
           expect(comment.text).to.equal('')
           expect(comment.isDeleted).to.be.true
           expect(comment.createdAt).to.not.be.null
@@ -989,17 +956,17 @@ describe('Test multiple servers', function () {
         downloadEnabled: false
       }
 
-      await updateVideo(servers[0].url, servers[0].accessToken, videoUUID, attributes)
+      await servers[0].videos.update({ id: videoUUID, attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideo(server.url, videoUUID)
-        expect(res.body.commentsEnabled).to.be.false
-        expect(res.body.downloadEnabled).to.be.false
+        const video = await server.videos.get({ id: videoUUID })
+        expect(video.commentsEnabled).to.be.false
+        expect(video.downloadEnabled).to.be.false
 
         const text = 'my super forbidden comment'
-        await addVideoCommentThread(server.url, server.accessToken, videoUUID, text, HttpStatusCode.CONFLICT_409)
+        await server.comments.createThread({ videoId: videoUUID, text, expectedStatus: HttpStatusCode.CONFLICT_409 })
       }
     })
   })
@@ -1024,8 +991,8 @@ describe('Test multiple servers', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        const video = res.body.data.find(v => v.name === 'minimum parameters')
+        const { data } = await server.videos.list()
+        const video = data.find(v => v.name === 'minimum parameters')
 
         const isLocal = server.url === 'http://localhost:' + servers[1].port
         const checkAttributes = {
@@ -1072,7 +1039,7 @@ describe('Test multiple servers', function () {
             }
           ]
         }
-        await completeVideoCheck(server.url, video, checkAttributes)
+        await completeVideoCheck(server, video, checkAttributes)
       }
     })
   })
diff --git a/server/tests/api/videos/resumable-upload.ts b/server/tests/api/videos/resumable-upload.ts
index 4fc3317df..13e47c85e 100644
--- a/server/tests/api/videos/resumable-upload.ts
+++ b/server/tests/api/videos/resumable-upload.ts
@@ -4,22 +4,15 @@ import 'mocha'
 import * as chai from 'chai'
 import { pathExists, readdir, stat } from 'fs-extra'
 import { join } from 'path'
-import { HttpStatusCode } from '@shared/core-utils'
 import {
   buildAbsoluteFixturePath,
-  buildServerDirectory,
   cleanupTests,
-  flushAndRunServer,
-  getMyUserInformation,
-  prepareResumableUpload,
-  sendDebugCommand,
-  sendResumableChunks,
-  ServerInfo,
+  createSingleServer,
+  PeerTubeServer,
   setAccessTokensToServers,
-  setDefaultVideoChannel,
-  updateUser
+  setDefaultVideoChannel
 } from '@shared/extra-utils'
-import { MyUser, VideoPrivacy } from '@shared/models'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
@@ -27,7 +20,7 @@ const expect = chai.expect
 
 describe('Test resumable upload', function () {
   const defaultFixture = 'video_short.mp4'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let rootId: number
 
   async function buildSize (fixture: string, size?: number) {
@@ -42,14 +35,14 @@ describe('Test resumable upload', function () {
 
     const attributes = {
       name: 'video',
-      channelId: server.videoChannel.id,
+      channelId: server.store.channel.id,
       privacy: VideoPrivacy.PUBLIC,
       fixture: defaultFixture
     }
 
     const mimetype = 'video/mp4'
 
-    const res = await prepareResumableUpload({ url: server.url, token: server.accessToken, attributes, size, mimetype })
+    const res = await server.videos.prepareResumableUpload({ attributes, size, mimetype })
 
     return res.header['location'].split('?')[1]
   }
@@ -67,15 +60,13 @@ describe('Test resumable upload', function () {
     const size = await buildSize(defaultFixture, options.size)
     const absoluteFilePath = buildAbsoluteFixturePath(defaultFixture)
 
-    return sendResumableChunks({
-      url: server.url,
-      token: server.accessToken,
+    return server.videos.sendResumableChunks({
       pathUploadId,
       videoFilePath: absoluteFilePath,
       size,
       contentLength,
       contentRangeBuilder,
-      specialStatus: expectedStatus
+      expectedStatus
     })
   }
 
@@ -83,7 +74,7 @@ describe('Test resumable upload', function () {
     const uploadId = uploadIdArg.replace(/^upload_id=/, '')
 
     const subPath = join('tmp', 'resumable-uploads', uploadId)
-    const filePath = buildServerDirectory(server, subPath)
+    const filePath = server.servers.buildDirectory(subPath)
     const exists = await pathExists(filePath)
 
     if (expectedSize === null) {
@@ -98,7 +89,7 @@ describe('Test resumable upload', function () {
 
   async function countResumableUploads () {
     const subPath = join('tmp', 'resumable-uploads')
-    const filePath = buildServerDirectory(server, subPath)
+    const filePath = server.servers.buildDirectory(subPath)
 
     const files = await readdir(filePath)
     return files.length
@@ -107,19 +98,14 @@ describe('Test resumable upload', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
     await setDefaultVideoChannel([ server ])
 
-    const res = await getMyUserInformation(server.url, server.accessToken)
-    rootId = (res.body as MyUser).id
+    const body = await server.users.getMyInfo()
+    rootId = body.id
 
-    await updateUser({
-      url: server.url,
-      userId: rootId,
-      accessToken: server.accessToken,
-      videoQuota: 10_000_000
-    })
+    await server.users.update({ userId: rootId, videoQuota: 10_000_000 })
   })
 
   describe('Directory cleaning', function () {
@@ -138,13 +124,13 @@ describe('Test resumable upload', function () {
     })
 
     it('Should not delete recent uploads', async function () {
-      await sendDebugCommand(server.url, server.accessToken, { command: 'remove-dandling-resumable-uploads' })
+      await server.debug.sendCommand({ body: { command: 'remove-dandling-resumable-uploads' } })
 
       expect(await countResumableUploads()).to.equal(2)
     })
 
     it('Should delete old uploads', async function () {
-      await sendDebugCommand(server.url, server.accessToken, { command: 'remove-dandling-resumable-uploads' })
+      await server.debug.sendCommand({ body: { command: 'remove-dandling-resumable-uploads' } })
 
       expect(await countResumableUploads()).to.equal(0)
     })
diff --git a/server/tests/api/videos/single-server.ts b/server/tests/api/videos/single-server.ts
index 1058a1e9c..c0535be09 100644
--- a/server/tests/api/videos/single-server.ts
+++ b/server/tests/api/videos/single-server.ts
@@ -2,43 +2,26 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { keyBy } from 'lodash'
-
 import {
   checkVideoFilesWereRemoved,
   cleanupTests,
   completeVideoCheck,
-  flushAndRunServer,
-  getVideo,
-  getVideoCategories,
-  getVideoLanguages,
-  getVideoLicences,
-  getVideoPrivacies,
-  getVideosList,
-  getVideosListPagination,
-  getVideosListSort,
-  getVideosWithFilters,
-  rateVideo,
-  removeVideo,
-  ServerInfo,
+  createSingleServer,
+  PeerTubeServer,
   setAccessTokensToServers,
   testImage,
-  updateVideo,
-  uploadVideo,
-  viewVideo,
   wait
-} from '../../../../shared/extra-utils'
-import { VideoPrivacy } from '../../../../shared/models/videos'
-import { HttpStatusCode } from '@shared/core-utils'
+} from '@shared/extra-utils'
+import { Video, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test a single server', function () {
 
   function runSuite (mode: 'legacy' | 'resumable') {
-    let server: ServerInfo = null
-    let videoId = -1
-    let videoId2 = -1
+    let server: PeerTubeServer = null
+    let videoId: number | string
+    let videoId2: string
     let videoUUID = ''
     let videosListBase: any[] = null
 
@@ -111,134 +94,122 @@ describe('Test a single server', function () {
     before(async function () {
       this.timeout(30000)
 
-      server = await flushAndRunServer(1)
+      server = await createSingleServer(1)
 
       await setAccessTokensToServers([ server ])
     })
 
     it('Should list video categories', async function () {
-      const res = await getVideoCategories(server.url)
-
-      const categories = res.body
+      const categories = await server.videos.getCategories()
       expect(Object.keys(categories)).to.have.length.above(10)
 
       expect(categories[11]).to.equal('News & Politics')
     })
 
     it('Should list video licences', async function () {
-      const res = await getVideoLicences(server.url)
-
-      const licences = res.body
+      const licences = await server.videos.getLicences()
       expect(Object.keys(licences)).to.have.length.above(5)
 
       expect(licences[3]).to.equal('Attribution - No Derivatives')
     })
 
     it('Should list video languages', async function () {
-      const res = await getVideoLanguages(server.url)
-
-      const languages = res.body
+      const languages = await server.videos.getLanguages()
       expect(Object.keys(languages)).to.have.length.above(5)
 
       expect(languages['ru']).to.equal('Russian')
     })
 
     it('Should list video privacies', async function () {
-      const res = await getVideoPrivacies(server.url)
-
-      const privacies = res.body
+      const privacies = await server.videos.getPrivacies()
       expect(Object.keys(privacies)).to.have.length.at.least(3)
 
       expect(privacies[3]).to.equal('Private')
     })
 
     it('Should not have videos', async function () {
-      const res = await getVideosList(server.url)
+      const { data, total } = await server.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)
     })
 
     it('Should upload the video', async function () {
       this.timeout(10000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name',
         category: 2,
         nsfw: true,
         licence: 6,
         tags: [ 'tag1', 'tag2', 'tag3' ]
       }
-      const res = await uploadVideo(server.url, server.accessToken, videoAttributes, HttpStatusCode.OK_200, mode)
-      expect(res.body.video).to.not.be.undefined
-      expect(res.body.video.id).to.equal(1)
-      expect(res.body.video.uuid).to.have.length.above(5)
+      const video = await server.videos.upload({ attributes, mode })
+      expect(video).to.not.be.undefined
+      expect(video.id).to.equal(1)
+      expect(video.uuid).to.have.length.above(5)
 
-      videoId = res.body.video.id
-      videoUUID = res.body.video.uuid
+      videoId = video.id
+      videoUUID = video.uuid
     })
 
     it('Should get and seed the uploaded video', async function () {
       this.timeout(5000)
 
-      const res = await getVideosList(server.url)
+      const { data, total } = await server.videos.list()
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data.length).to.equal(1)
+      expect(total).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(1)
 
-      const video = res.body.data[0]
-      await completeVideoCheck(server.url, video, getCheckAttributes())
+      const video = data[0]
+      await completeVideoCheck(server, video, getCheckAttributes())
     })
 
     it('Should get the video by UUID', async function () {
       this.timeout(5000)
 
-      const res = await getVideo(server.url, videoUUID)
-
-      const video = res.body
-      await completeVideoCheck(server.url, video, getCheckAttributes())
+      const video = await server.videos.get({ id: videoUUID })
+      await completeVideoCheck(server, video, getCheckAttributes())
     })
 
     it('Should have the views updated', async function () {
       this.timeout(20000)
 
-      await viewVideo(server.url, videoId)
-      await viewVideo(server.url, videoId)
-      await viewVideo(server.url, videoId)
+      await server.videos.view({ id: videoId })
+      await server.videos.view({ id: videoId })
+      await server.videos.view({ id: videoId })
 
       await wait(1500)
 
-      await viewVideo(server.url, videoId)
-      await viewVideo(server.url, videoId)
+      await server.videos.view({ id: videoId })
+      await server.videos.view({ id: videoId })
 
       await wait(1500)
 
-      await viewVideo(server.url, videoId)
-      await viewVideo(server.url, videoId)
+      await server.videos.view({ id: videoId })
+      await server.videos.view({ id: videoId })
 
       // Wait the repeatable job
       await wait(8000)
 
-      const res = await getVideo(server.url, videoId)
-
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
       expect(video.views).to.equal(3)
     })
 
     it('Should remove the video', async function () {
-      await removeVideo(server.url, server.accessToken, videoId)
+      await server.videos.remove({ id: videoId })
 
-      await checkVideoFilesWereRemoved(videoUUID, 1)
+      await checkVideoFilesWereRemoved(videoUUID, server)
     })
 
     it('Should not have videos', async function () {
-      const res = await getVideosList(server.url)
+      const { total, data } = await server.videos.list()
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(total).to.equal(0)
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(0)
     })
 
     it('Should upload 6 videos', async function () {
@@ -250,7 +221,7 @@ describe('Test a single server', function () {
       ])
 
       for (const video of videos) {
-        const videoAttributes = {
+        const attributes = {
           name: video + ' name',
           description: video + ' description',
           category: 2,
@@ -261,19 +232,20 @@ describe('Test a single server', function () {
           fixture: video
         }
 
-        await uploadVideo(server.url, server.accessToken, videoAttributes, HttpStatusCode.OK_200, mode)
+        await server.videos.upload({ attributes, mode })
       }
     })
 
     it('Should have the correct durations', async function () {
-      const res = await getVideosList(server.url)
+      const { total, data } = await server.videos.list()
+
+      expect(total).to.equal(6)
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(6)
 
-      expect(res.body.total).to.equal(6)
-      const videos = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos).to.have.lengthOf(6)
+      const videosByName: { [ name: string ]: Video } = {}
+      data.forEach(v => { videosByName[v.name] = v })
 
-      const videosByName = keyBy<{ duration: number }>(videos, 'name')
       expect(videosByName['video_short.mp4 name'].duration).to.equal(5)
       expect(videosByName['video_short.ogv name'].duration).to.equal(5)
       expect(videosByName['video_short.webm name'].duration).to.equal(5)
@@ -283,96 +255,87 @@ describe('Test a single server', function () {
     })
 
     it('Should have the correct thumbnails', async function () {
-      const res = await getVideosList(server.url)
+      const { data } = await server.videos.list()
 
-      const videos = res.body.data
       // For the next test
-      videosListBase = videos
+      videosListBase = data
 
-      for (const video of videos) {
+      for (const video of data) {
         const videoName = video.name.replace(' name', '')
         await testImage(server.url, videoName, video.thumbnailPath)
       }
     })
 
     it('Should list only the two first videos', async function () {
-      const res = await getVideosListPagination(server.url, 0, 2, 'name')
+      const { total, data } = await server.videos.list({ start: 0, count: 2, sort: 'name' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(2)
-      expect(videos[0].name).to.equal(videosListBase[0].name)
-      expect(videos[1].name).to.equal(videosListBase[1].name)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(2)
+      expect(data[0].name).to.equal(videosListBase[0].name)
+      expect(data[1].name).to.equal(videosListBase[1].name)
     })
 
     it('Should list only the next three videos', async function () {
-      const res = await getVideosListPagination(server.url, 2, 3, 'name')
+      const { total, data } = await server.videos.list({ start: 2, count: 3, sort: 'name' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(3)
-      expect(videos[0].name).to.equal(videosListBase[2].name)
-      expect(videos[1].name).to.equal(videosListBase[3].name)
-      expect(videos[2].name).to.equal(videosListBase[4].name)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(3)
+      expect(data[0].name).to.equal(videosListBase[2].name)
+      expect(data[1].name).to.equal(videosListBase[3].name)
+      expect(data[2].name).to.equal(videosListBase[4].name)
     })
 
     it('Should list the last video', async function () {
-      const res = await getVideosListPagination(server.url, 5, 6, 'name')
+      const { total, data } = await server.videos.list({ start: 5, count: 6, sort: 'name' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(1)
-      expect(videos[0].name).to.equal(videosListBase[5].name)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(1)
+      expect(data[0].name).to.equal(videosListBase[5].name)
     })
 
     it('Should not have the total field', async function () {
-      const res = await getVideosListPagination(server.url, 5, 6, 'name', true)
+      const { total, data } = await server.videos.list({ start: 5, count: 6, sort: 'name', skipCount: true })
 
-      const videos = res.body.data
-      expect(res.body.total).to.not.exist
-      expect(videos.length).to.equal(1)
-      expect(videos[0].name).to.equal(videosListBase[5].name)
+      expect(total).to.not.exist
+      expect(data.length).to.equal(1)
+      expect(data[0].name).to.equal(videosListBase[5].name)
     })
 
     it('Should list and sort by name in descending order', async function () {
-      const res = await getVideosListSort(server.url, '-name')
+      const { total, data } = await server.videos.list({ sort: '-name' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(6)
-      expect(videos[0].name).to.equal('video_short.webm name')
-      expect(videos[1].name).to.equal('video_short.ogv name')
-      expect(videos[2].name).to.equal('video_short.mp4 name')
-      expect(videos[3].name).to.equal('video_short3.webm name')
-      expect(videos[4].name).to.equal('video_short2.webm name')
-      expect(videos[5].name).to.equal('video_short1.webm name')
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(6)
+      expect(data[0].name).to.equal('video_short.webm name')
+      expect(data[1].name).to.equal('video_short.ogv name')
+      expect(data[2].name).to.equal('video_short.mp4 name')
+      expect(data[3].name).to.equal('video_short3.webm name')
+      expect(data[4].name).to.equal('video_short2.webm name')
+      expect(data[5].name).to.equal('video_short1.webm name')
 
-      videoId = videos[3].uuid
-      videoId2 = videos[5].uuid
+      videoId = data[3].uuid
+      videoId2 = data[5].uuid
     })
 
     it('Should list and sort by trending in descending order', async function () {
-      const res = await getVideosListPagination(server.url, 0, 2, '-trending')
+      const { total, data } = await server.videos.list({ start: 0, count: 2, sort: '-trending' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(2)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(2)
     })
 
     it('Should list and sort by hotness in descending order', async function () {
-      const res = await getVideosListPagination(server.url, 0, 2, '-hot')
+      const { total, data } = await server.videos.list({ start: 0, count: 2, sort: '-hot' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(2)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(2)
     })
 
     it('Should list and sort by best in descending order', async function () {
-      const res = await getVideosListPagination(server.url, 0, 2, '-best')
+      const { total, data } = await server.videos.list({ start: 0, count: 2, sort: '-best' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(2)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(2)
     })
 
     it('Should update a video', async function () {
@@ -387,67 +350,66 @@ describe('Test a single server', function () {
         downloadEnabled: false,
         tags: [ 'tagup1', 'tagup2' ]
       }
-      await updateVideo(server.url, server.accessToken, videoId, attributes)
+      await server.videos.update({ id: videoId, attributes })
     })
 
     it('Should filter by tags and category', async function () {
-      const res1 = await getVideosWithFilters(server.url, { tagsAllOf: [ 'tagup1', 'tagup2' ], categoryOneOf: [ 4 ] })
-      expect(res1.body.total).to.equal(1)
-      expect(res1.body.data[0].name).to.equal('my super video updated')
+      {
+        const { data, total } = await server.videos.list({ tagsAllOf: [ 'tagup1', 'tagup2' ], categoryOneOf: [ 4 ] })
+        expect(total).to.equal(1)
+        expect(data[0].name).to.equal('my super video updated')
+      }
 
-      const res2 = await getVideosWithFilters(server.url, { tagsAllOf: [ 'tagup1', 'tagup2' ], categoryOneOf: [ 3 ] })
-      expect(res2.body.total).to.equal(0)
+      {
+        const { total } = await server.videos.list({ tagsAllOf: [ 'tagup1', 'tagup2' ], categoryOneOf: [ 3 ] })
+        expect(total).to.equal(0)
+      }
     })
 
     it('Should have the video updated', async function () {
       this.timeout(60000)
 
-      const res = await getVideo(server.url, videoId)
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
 
-      await completeVideoCheck(server.url, video, updateCheckAttributes())
+      await completeVideoCheck(server, video, updateCheckAttributes())
     })
 
     it('Should update only the tags of a video', async function () {
       const attributes = {
         tags: [ 'supertag', 'tag1', 'tag2' ]
       }
-      await updateVideo(server.url, server.accessToken, videoId, attributes)
+      await server.videos.update({ id: videoId, attributes })
 
-      const res = await getVideo(server.url, videoId)
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
 
-      await completeVideoCheck(server.url, video, Object.assign(updateCheckAttributes(), attributes))
+      await completeVideoCheck(server, video, Object.assign(updateCheckAttributes(), attributes))
     })
 
     it('Should update only the description of a video', async function () {
       const attributes = {
         description: 'hello everybody'
       }
-      await updateVideo(server.url, server.accessToken, videoId, attributes)
+      await server.videos.update({ id: videoId, attributes })
 
-      const res = await getVideo(server.url, videoId)
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
 
       const expectedAttributes = Object.assign(updateCheckAttributes(), { tags: [ 'supertag', 'tag1', 'tag2' ] }, attributes)
-      await completeVideoCheck(server.url, video, expectedAttributes)
+      await completeVideoCheck(server, video, expectedAttributes)
     })
 
     it('Should like a video', async function () {
-      await rateVideo(server.url, server.accessToken, videoId, 'like')
+      await server.videos.rate({ id: videoId, rating: 'like' })
 
-      const res = await getVideo(server.url, videoId)
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
 
       expect(video.likes).to.equal(1)
       expect(video.dislikes).to.equal(0)
     })
 
     it('Should dislike the same video', async function () {
-      await rateVideo(server.url, server.accessToken, videoId, 'dislike')
+      await server.videos.rate({ id: videoId, rating: 'dislike' })
 
-      const res = await getVideo(server.url, videoId)
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
 
       expect(video.likes).to.equal(0)
       expect(video.dislikes).to.equal(1)
@@ -457,10 +419,10 @@ describe('Test a single server', function () {
       {
         const now = new Date()
         const attributes = { originallyPublishedAt: now.toISOString() }
-        await updateVideo(server.url, server.accessToken, videoId, attributes)
+        await server.videos.update({ id: videoId, attributes })
 
-        const res = await getVideosListSort(server.url, '-originallyPublishedAt')
-        const names = res.body.data.map(v => v.name)
+        const { data } = await server.videos.list({ sort: '-originallyPublishedAt' })
+        const names = data.map(v => v.name)
 
         expect(names[0]).to.equal('my super video updated')
         expect(names[1]).to.equal('video_short2.webm name')
@@ -473,10 +435,10 @@ describe('Test a single server', function () {
       {
         const now = new Date()
         const attributes = { originallyPublishedAt: now.toISOString() }
-        await updateVideo(server.url, server.accessToken, videoId2, attributes)
+        await server.videos.update({ id: videoId2, attributes })
 
-        const res = await getVideosListSort(server.url, '-originallyPublishedAt')
-        const names = res.body.data.map(v => v.name)
+        const { data } = await server.videos.list({ sort: '-originallyPublishedAt' })
+        const names = data.map(v => v.name)
 
         expect(names[0]).to.equal('video_short1.webm name')
         expect(names[1]).to.equal('my super video updated')
diff --git a/server/tests/api/videos/video-captions.ts b/server/tests/api/videos/video-captions.ts
index 14ecedfa6..4c8e28adf 100644
--- a/server/tests/api/videos/video-captions.ts
+++ b/server/tests/api/videos/video-captions.ts
@@ -1,72 +1,61 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
   checkVideoFilesWereRemoved,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  removeVideo,
-  uploadVideo,
-  wait
-} from '../../../../shared/extra-utils'
-import { ServerInfo, setAccessTokensToServers } from '../../../../shared/extra-utils/index'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  createVideoCaption,
-  deleteVideoCaption,
-  listVideoCaptions,
-  testCaptionFile
-} from '../../../../shared/extra-utils/videos/video-captions'
-import { VideoCaption } from '../../../../shared/models/videos/caption/video-caption.model'
+  PeerTubeServer,
+  setAccessTokensToServers,
+  testCaptionFile,
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test video captions', function () {
   const uuidRegex = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
 
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let videoUUID: string
 
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
     await doubleFollow(servers[0], servers[1])
 
     await waitJobs(servers)
 
-    const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'my video name' })
-    videoUUID = res.body.video.uuid
+    const { uuid } = await servers[0].videos.upload({ attributes: { name: 'my video name' } })
+    videoUUID = uuid
 
     await waitJobs(servers)
   })
 
   it('Should list the captions and return an empty list', async function () {
     for (const server of servers) {
-      const res = await listVideoCaptions(server.url, videoUUID)
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
+      const body = await server.captions.list({ videoId: videoUUID })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
     }
   })
 
   it('Should create two new captions', async function () {
     this.timeout(30000)
 
-    await createVideoCaption({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].captions.add({
       language: 'ar',
       videoId: videoUUID,
       fixture: 'subtitle-good1.vtt'
     })
 
-    await createVideoCaption({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].captions.add({
       language: 'zh',
       videoId: videoUUID,
       fixture: 'subtitle-good2.vtt',
@@ -78,17 +67,17 @@ describe('Test video captions', function () {
 
   it('Should list these uploaded captions', async function () {
     for (const server of servers) {
-      const res = await listVideoCaptions(server.url, videoUUID)
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      const body = await server.captions.list({ videoId: videoUUID })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      const caption1: VideoCaption = res.body.data[0]
+      const caption1 = body.data[0]
       expect(caption1.language.id).to.equal('ar')
       expect(caption1.language.label).to.equal('Arabic')
       expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/' + uuidRegex + '-ar.vtt$'))
       await testCaptionFile(server.url, caption1.captionPath, 'Subtitle good 1.')
 
-      const caption2: VideoCaption = res.body.data[1]
+      const caption2 = body.data[1]
       expect(caption2.language.id).to.equal('zh')
       expect(caption2.language.label).to.equal('Chinese')
       expect(caption2.captionPath).to.match(new RegExp('^/lazy-static/video-captions/' + uuidRegex + '-zh.vtt$'))
@@ -99,9 +88,7 @@ describe('Test video captions', function () {
   it('Should replace an existing caption', async function () {
     this.timeout(30000)
 
-    await createVideoCaption({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].captions.add({
       language: 'ar',
       videoId: videoUUID,
       fixture: 'subtitle-good2.vtt'
@@ -112,11 +99,11 @@ describe('Test video captions', function () {
 
   it('Should have this caption updated', async function () {
     for (const server of servers) {
-      const res = await listVideoCaptions(server.url, videoUUID)
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      const body = await server.captions.list({ videoId: videoUUID })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      const caption1: VideoCaption = res.body.data[0]
+      const caption1 = body.data[0]
       expect(caption1.language.id).to.equal('ar')
       expect(caption1.language.label).to.equal('Arabic')
       expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/' + uuidRegex + '-ar.vtt$'))
@@ -127,9 +114,7 @@ describe('Test video captions', function () {
   it('Should replace an existing caption with a srt file and convert it', async function () {
     this.timeout(30000)
 
-    await createVideoCaption({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].captions.add({
       language: 'ar',
       videoId: videoUUID,
       fixture: 'subtitle-good.srt'
@@ -143,11 +128,11 @@ describe('Test video captions', function () {
 
   it('Should have this caption updated and converted', async function () {
     for (const server of servers) {
-      const res = await listVideoCaptions(server.url, videoUUID)
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      const body = await server.captions.list({ videoId: videoUUID })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      const caption1: VideoCaption = res.body.data[0]
+      const caption1 = body.data[0]
       expect(caption1.language.id).to.equal('ar')
       expect(caption1.language.label).to.equal('Arabic')
       expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/' + uuidRegex + '-ar.vtt$'))
@@ -172,18 +157,18 @@ describe('Test video captions', function () {
   it('Should remove one caption', async function () {
     this.timeout(30000)
 
-    await deleteVideoCaption(servers[0].url, servers[0].accessToken, videoUUID, 'ar')
+    await servers[0].captions.delete({ videoId: videoUUID, language: 'ar' })
 
     await waitJobs(servers)
   })
 
   it('Should only list the caption that was not deleted', async function () {
     for (const server of servers) {
-      const res = await listVideoCaptions(server.url, videoUUID)
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      const body = await server.captions.list({ videoId: videoUUID })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
 
-      const caption: VideoCaption = res.body.data[0]
+      const caption = body.data[0]
 
       expect(caption.language.id).to.equal('zh')
       expect(caption.language.label).to.equal('Chinese')
@@ -193,9 +178,9 @@ describe('Test video captions', function () {
   })
 
   it('Should remove the video, and thus all video captions', async function () {
-    await removeVideo(servers[0].url, servers[0].accessToken, videoUUID)
+    await servers[0].videos.remove({ id: videoUUID })
 
-    await checkVideoFilesWereRemoved(videoUUID, 1)
+    await checkVideoFilesWereRemoved(videoUUID, servers[0])
   })
 
   after(async function () {
diff --git a/server/tests/api/videos/video-change-ownership.ts b/server/tests/api/videos/video-change-ownership.ts
index a3384851b..6ae6d3004 100644
--- a/server/tests/api/videos/video-change-ownership.ts
+++ b/server/tests/api/videos/video-change-ownership.ts
@@ -2,234 +2,212 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  acceptChangeOwnership,
-  changeVideoOwnership,
+  ChangeOwnershipCommand,
   cleanupTests,
-  createLive,
-  createUser,
+  createMultipleServers,
+  createSingleServer,
   doubleFollow,
-  flushAndRunMultipleServers,
-  flushAndRunServer,
-  getMyUserInformation,
-  getVideo,
-  getVideoChangeOwnershipList,
-  getVideosList,
-  refuseChangeOwnership,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
-  updateCustomSubConfig,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { User } from '../../../../shared/models/users'
-import { VideoDetails, VideoPrivacy } from '../../../../shared/models/videos'
+  waitJobs
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test video change ownership - nominal', function () {
-  let servers: ServerInfo[] = []
-  const firstUser = {
-    username: 'first',
-    password: 'My great password'
-  }
-  const secondUser = {
-    username: 'second',
-    password: 'My other password'
-  }
-
-  let firstUserAccessToken = ''
+  let servers: PeerTubeServer[] = []
+
+  const firstUser = 'first'
+  const secondUser = 'second'
+
+  let firstUserToken = ''
   let firstUserChannelId: number
 
-  let secondUserAccessToken = ''
+  let secondUserToken = ''
   let secondUserChannelId: number
 
-  let lastRequestChangeOwnershipId = ''
+  let lastRequestId: number
 
   let liveId: number
 
+  let command: ChangeOwnershipCommand
+
   before(async function () {
     this.timeout(50000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      transcoding: {
-        enabled: false
-      },
-      live: {
-        enabled: true
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        transcoding: {
+          enabled: false
+        },
+        live: {
+          enabled: true
+        }
       }
     })
 
-    const videoQuota = 42000000
-    await createUser({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      username: firstUser.username,
-      password: firstUser.password,
-      videoQuota: videoQuota
-    })
-    await createUser({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      username: secondUser.username,
-      password: secondUser.password,
-      videoQuota: videoQuota
-    })
-
-    firstUserAccessToken = await userLogin(servers[0], firstUser)
-    secondUserAccessToken = await userLogin(servers[0], secondUser)
+    firstUserToken = await servers[0].users.generateUserAndToken(firstUser)
+    secondUserToken = await servers[0].users.generateUserAndToken(secondUser)
 
     {
-      const res = await getMyUserInformation(servers[0].url, firstUserAccessToken)
-      const firstUserInformation: User = res.body
-      firstUserChannelId = firstUserInformation.videoChannels[0].id
+      const { videoChannels } = await servers[0].users.getMyInfo({ token: firstUserToken })
+      firstUserChannelId = videoChannels[0].id
     }
 
     {
-      const res = await getMyUserInformation(servers[0].url, secondUserAccessToken)
-      const secondUserInformation: User = res.body
-      secondUserChannelId = secondUserInformation.videoChannels[0].id
+      const { videoChannels } = await servers[0].users.getMyInfo({ token: secondUserToken })
+      secondUserChannelId = videoChannels[0].id
     }
 
     {
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name',
         description: 'my super description'
       }
-      const res = await uploadVideo(servers[0].url, firstUserAccessToken, videoAttributes)
+      const { id } = await servers[0].videos.upload({ token: firstUserToken, attributes })
 
-      const resVideo = await getVideo(servers[0].url, res.body.video.id)
-      servers[0].video = resVideo.body
+      servers[0].store.video = await servers[0].videos.get({ id })
     }
 
     {
       const attributes = { name: 'live', channelId: firstUserChannelId, privacy: VideoPrivacy.PUBLIC }
-      const res = await createLive(servers[0].url, firstUserAccessToken, attributes)
+      const video = await servers[0].live.create({ token: firstUserToken, fields: attributes })
 
-      liveId = res.body.video.id
+      liveId = video.id
     }
 
+    command = servers[0].changeOwnership
+
     await doubleFollow(servers[0], servers[1])
   })
 
   it('Should not have video change ownership', async function () {
-    const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken)
+    {
+      const body = await command.list({ token: firstUserToken })
 
-    expect(resFirstUser.body.total).to.equal(0)
-    expect(resFirstUser.body.data).to.be.an('array')
-    expect(resFirstUser.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)
+    }
 
-    const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
+    {
+      const body = await command.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(0)
-    expect(resSecondUser.body.data).to.be.an('array')
-    expect(resSecondUser.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 send a request to change ownership of a video', async function () {
     this.timeout(15000)
 
-    await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username)
+    await command.create({ token: firstUserToken, videoId: servers[0].store.video.id, username: secondUser })
   })
 
   it('Should only return a request to change ownership for the second user', async function () {
-    const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken)
+    {
+      const body = await command.list({ token: firstUserToken })
 
-    expect(resFirstUser.body.total).to.equal(0)
-    expect(resFirstUser.body.data).to.be.an('array')
-    expect(resFirstUser.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)
+    }
 
-    const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
+    {
+      const body = await command.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(1)
-    expect(resSecondUser.body.data).to.be.an('array')
-    expect(resSecondUser.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)
 
-    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
+      lastRequestId = body.data[0].id
+    }
   })
 
   it('Should accept the same change ownership request without crashing', async function () {
     this.timeout(10000)
 
-    await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username)
+    await command.create({ token: firstUserToken, videoId: servers[0].store.video.id, username: secondUser })
   })
 
   it('Should not create multiple change ownership requests while one is waiting', async function () {
     this.timeout(10000)
 
-    const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
+    const body = await command.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(1)
-    expect(resSecondUser.body.data).to.be.an('array')
-    expect(resSecondUser.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)
   })
 
   it('Should not be possible to refuse the change of ownership from first user', async function () {
     this.timeout(10000)
 
-    await refuseChangeOwnership(servers[0].url, firstUserAccessToken, lastRequestChangeOwnershipId, HttpStatusCode.FORBIDDEN_403)
+    await command.refuse({ token: firstUserToken, ownershipId: lastRequestId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should be possible to refuse the change of ownership from second user', async function () {
     this.timeout(10000)
 
-    await refuseChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId)
+    await command.refuse({ token: secondUserToken, ownershipId: lastRequestId })
   })
 
   it('Should send a new request to change ownership of a video', async function () {
     this.timeout(15000)
 
-    await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username)
+    await command.create({ token: firstUserToken, videoId: servers[0].store.video.id, username: secondUser })
   })
 
   it('Should return two requests to change ownership for the second user', async function () {
-    const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken)
+    {
+      const body = await command.list({ token: firstUserToken })
 
-    expect(resFirstUser.body.total).to.equal(0)
-    expect(resFirstUser.body.data).to.be.an('array')
-    expect(resFirstUser.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)
+    }
 
-    const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
+    {
+      const body = await command.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(2)
-    expect(resSecondUser.body.data).to.be.an('array')
-    expect(resSecondUser.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)
 
-    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
+      lastRequestId = body.data[0].id
+    }
   })
 
   it('Should not be possible to accept the change of ownership from first user', async function () {
     this.timeout(10000)
 
-    await acceptChangeOwnership(
-      servers[0].url,
-      firstUserAccessToken,
-      lastRequestChangeOwnershipId,
-      secondUserChannelId,
-      HttpStatusCode.FORBIDDEN_403
-    )
+    await command.accept({
+      token: firstUserToken,
+      ownershipId: lastRequestId,
+      channelId: secondUserChannelId,
+      expectedStatus: HttpStatusCode.FORBIDDEN_403
+    })
   })
 
   it('Should be possible to accept the change of ownership from second user', async function () {
     this.timeout(10000)
 
-    await acceptChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId, secondUserChannelId)
+    await command.accept({ token: secondUserToken, ownershipId: lastRequestId, channelId: secondUserChannelId })
 
     await waitJobs(servers)
   })
 
   it('Should have the channel of the video updated', async function () {
     for (const server of servers) {
-      const res = await getVideo(server.url, servers[0].video.uuid)
-
-      const video: VideoDetails = res.body
+      const video = await server.videos.get({ id: servers[0].store.video.uuid })
 
       expect(video.name).to.equal('my super name')
       expect(video.channel.displayName).to.equal('Main second channel')
@@ -240,27 +218,25 @@ describe('Test video change ownership - nominal', function () {
   it('Should send a request to change ownership of a live', async function () {
     this.timeout(15000)
 
-    await changeVideoOwnership(servers[0].url, firstUserAccessToken, liveId, secondUser.username)
+    await command.create({ token: firstUserToken, videoId: liveId, username: secondUser })
 
-    const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
+    const body = await command.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(3)
-    expect(resSecondUser.body.data.length).to.equal(3)
+    expect(body.total).to.equal(3)
+    expect(body.data.length).to.equal(3)
 
-    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
+    lastRequestId = body.data[0].id
   })
 
   it('Should accept a live ownership change', async function () {
     this.timeout(20000)
 
-    await acceptChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId, secondUserChannelId)
+    await command.accept({ token: secondUserToken, ownershipId: lastRequestId, channelId: secondUserChannelId })
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, servers[0].video.uuid)
-
-      const video: VideoDetails = res.body
+      const video = await server.videos.get({ id: servers[0].store.video.uuid })
 
       expect(video.name).to.equal('my super name')
       expect(video.channel.displayName).to.equal('Main second channel')
@@ -274,99 +250,79 @@ describe('Test video change ownership - nominal', function () {
 })
 
 describe('Test video change ownership - quota too small', function () {
-  let server: ServerInfo
-  const firstUser = {
-    username: 'first',
-    password: 'My great password'
-  }
-  const secondUser = {
-    username: 'second',
-    password: 'My other password'
-  }
-  let firstUserAccessToken = ''
-  let secondUserAccessToken = ''
-  let lastRequestChangeOwnershipId = ''
+  let server: PeerTubeServer
+  const firstUser = 'first'
+  const secondUser = 'second'
+
+  let firstUserToken = ''
+  let secondUserToken = ''
+  let lastRequestId: number
 
   before(async function () {
     this.timeout(50000)
 
     // Run one server
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
-    const videoQuota = 42000000
-    const limitedVideoQuota = 10
-    await createUser({
-      url: server.url,
-      accessToken: server.accessToken,
-      username: firstUser.username,
-      password: firstUser.password,
-      videoQuota: videoQuota
-    })
-    await createUser({
-      url: server.url,
-      accessToken: server.accessToken,
-      username: secondUser.username,
-      password: secondUser.password,
-      videoQuota: limitedVideoQuota
-    })
+    await server.users.create({ username: secondUser, videoQuota: 10 })
 
-    firstUserAccessToken = await userLogin(server, firstUser)
-    secondUserAccessToken = await userLogin(server, secondUser)
+    firstUserToken = await server.users.generateUserAndToken(firstUser)
+    secondUserToken = await server.login.getAccessToken(secondUser)
 
     // Upload some videos on the server
-    const video1Attributes = {
+    const attributes = {
       name: 'my super name',
       description: 'my super description'
     }
-    await uploadVideo(server.url, firstUserAccessToken, video1Attributes)
+    await server.videos.upload({ token: firstUserToken, attributes })
 
     await waitJobs(server)
 
-    const res = await getVideosList(server.url)
-    const videos = res.body.data
-
-    expect(videos.length).to.equal(1)
+    const { data } = await server.videos.list()
+    expect(data.length).to.equal(1)
 
-    server.video = videos.find(video => video.name === 'my super name')
+    server.store.video = data.find(video => video.name === 'my super name')
   })
 
   it('Should send a request to change ownership of a video', async function () {
     this.timeout(15000)
 
-    await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
+    await server.changeOwnership.create({ token: firstUserToken, videoId: server.store.video.id, username: secondUser })
   })
 
   it('Should only return a request to change ownership for the second user', async function () {
-    const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)
+    {
+      const body = await server.changeOwnership.list({ token: firstUserToken })
 
-    expect(resFirstUser.body.total).to.equal(0)
-    expect(resFirstUser.body.data).to.be.an('array')
-    expect(resFirstUser.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)
+    }
 
-    const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)
+    {
+      const body = await server.changeOwnership.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(1)
-    expect(resSecondUser.body.data).to.be.an('array')
-    expect(resSecondUser.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)
 
-    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
+      lastRequestId = body.data[0].id
+    }
   })
 
   it('Should not be possible to accept the change of ownership from second user because of exceeded quota', async function () {
     this.timeout(10000)
 
-    const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserAccessToken)
-    const secondUserInformation: User = secondUserInformationResponse.body
-    const channelId = secondUserInformation.videoChannels[0].id
+    const { videoChannels } = await server.users.getMyInfo({ token: secondUserToken })
+    const channelId = videoChannels[0].id
 
-    await acceptChangeOwnership(
-      server.url,
-      secondUserAccessToken,
-      lastRequestChangeOwnershipId,
+    await server.changeOwnership.accept({
+      token: secondUserToken,
+      ownershipId: lastRequestId,
       channelId,
-      HttpStatusCode.PAYLOAD_TOO_LARGE_413
-    )
+      expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413
+    })
   })
 
   after(async function () {
diff --git a/server/tests/api/videos/video-channels.ts b/server/tests/api/videos/video-channels.ts
index 865098777..c25754eb6 100644
--- a/server/tests/api/videos/video-channels.ts
+++ b/server/tests/api/videos/video-channels.ts
@@ -6,48 +6,28 @@ import { basename } from 'path'
 import { ACTOR_IMAGES_SIZE } from '@server/initializers/constants'
 import {
   cleanupTests,
-  createUser,
-  deleteVideoChannelImage,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getActorImage,
-  getVideo,
-  getVideoChannel,
-  getVideoChannelVideos,
+  PeerTubeServer,
+  setAccessTokensToServers,
   setDefaultVideoChannel,
   testFileExistsOrNot,
   testImage,
-  updateVideo,
-  updateVideoChannelImage,
-  uploadVideo,
-  userLogin,
-  wait
-} from '../../../../shared/extra-utils'
-import {
-  addVideoChannel,
-  deleteVideoChannel,
-  getAccountVideoChannelsList,
-  getMyUserInformation,
-  getVideoChannelsList,
-  ServerInfo,
-  setAccessTokensToServers,
-  updateVideoChannel,
-  viewVideo
-} from '../../../../shared/extra-utils/index'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { User, Video, VideoChannel, VideoDetails } from '../../../../shared/index'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { User, VideoChannel } from '@shared/models'
 
 const expect = chai.expect
 
-async function findChannel (server: ServerInfo, channelId: number) {
-  const res = await getVideoChannelsList(server.url, 0, 5, '-name')
-  const videoChannel = res.body.data.find(c => c.id === channelId)
+async function findChannel (server: PeerTubeServer, channelId: number) {
+  const body = await server.channels.list({ sort: '-name' })
 
-  return videoChannel as VideoChannel
+  return body.data.find(c => c.id === channelId)
 }
 
 describe('Test video channels', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let userInfo: User
   let secondVideoChannelId: number
   let totoChannel: number
@@ -60,7 +40,7 @@ describe('Test video channels', function () {
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
@@ -69,11 +49,11 @@ describe('Test video channels', function () {
   })
 
   it('Should have one video channel (created with root)', async () => {
-    const res = await getVideoChannelsList(servers[0].url, 0, 2)
+    const body = await servers[0].channels.list({ start: 0, count: 2 })
 
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
   })
 
   it('Should create another video channel', async function () {
@@ -86,23 +66,22 @@ describe('Test video channels', function () {
         description: 'super video channel description',
         support: 'super video channel support text'
       }
-      const res = await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
-      secondVideoChannelId = res.body.videoChannel.id
+      const created = await servers[0].channels.create({ attributes: videoChannel })
+      secondVideoChannelId = created.id
     }
 
     // The channel is 1 is propagated to servers 2
     {
-      const videoAttributesArg = { name: 'my video name', channelId: secondVideoChannelId, support: 'video support field' }
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributesArg)
-      videoUUID = res.body.video.uuid
+      const attributes = { name: 'my video name', channelId: secondVideoChannelId, support: 'video support field' }
+      const { uuid } = await servers[0].videos.upload({ attributes })
+      videoUUID = uuid
     }
 
     await waitJobs(servers)
   })
 
   it('Should have two video channels when getting my information', async () => {
-    const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
-    userInfo = res.body
+    userInfo = await servers[0].users.getMyInfo()
 
     expect(userInfo.videoChannels).to.be.an('array')
     expect(userInfo.videoChannels).to.have.lengthOf(2)
@@ -120,16 +99,14 @@ describe('Test video channels', function () {
   })
 
   it('Should have two video channels when getting account channels on server 1', async function () {
-    const res = await getAccountVideoChannelsList({
-      url: servers[0].url,
-      accountName
-    })
+    const body = await servers[0].channels.listByAccount({ accountName })
+    expect(body.total).to.equal(2)
+
+    const videoChannels = body.data
 
-    expect(res.body.total).to.equal(2)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(2)
+    expect(videoChannels).to.be.an('array')
+    expect(videoChannels).to.have.lengthOf(2)
 
-    const videoChannels = res.body.data
     expect(videoChannels[0].name).to.equal('root_channel')
     expect(videoChannels[0].displayName).to.equal('Main root channel')
 
@@ -141,79 +118,69 @@ describe('Test video channels', function () {
 
   it('Should paginate and sort account channels', async function () {
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
+      const body = await servers[0].channels.listByAccount({
         accountName,
         start: 0,
         count: 1,
         sort: 'createdAt'
       })
 
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(1)
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(1)
 
-      const videoChannel: VideoChannel = res.body.data[0]
+      const videoChannel: VideoChannel = body.data[0]
       expect(videoChannel.name).to.equal('root_channel')
     }
 
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
+      const body = await servers[0].channels.listByAccount({
         accountName,
         start: 0,
         count: 1,
         sort: '-createdAt'
       })
 
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(1)
-
-      const videoChannel: VideoChannel = res.body.data[0]
-      expect(videoChannel.name).to.equal('second_video_channel')
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('second_video_channel')
     }
 
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
+      const body = await servers[0].channels.listByAccount({
         accountName,
         start: 1,
         count: 1,
         sort: '-createdAt'
       })
 
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(1)
-
-      const videoChannel: VideoChannel = res.body.data[0]
-      expect(videoChannel.name).to.equal('root_channel')
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('root_channel')
     }
   })
 
   it('Should have one video channel when getting account channels on server 2', async function () {
-    const res = await getAccountVideoChannelsList({
-      url: servers[1].url,
-      accountName
-    })
+    const body = await servers[1].channels.listByAccount({ accountName })
 
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
 
-    const videoChannels = res.body.data
-    expect(videoChannels[0].name).to.equal('second_video_channel')
-    expect(videoChannels[0].displayName).to.equal('second video channel')
-    expect(videoChannels[0].description).to.equal('super video channel description')
-    expect(videoChannels[0].support).to.equal('super video channel support text')
+    const videoChannel = body.data[0]
+    expect(videoChannel.name).to.equal('second_video_channel')
+    expect(videoChannel.displayName).to.equal('second video channel')
+    expect(videoChannel.description).to.equal('super video channel description')
+    expect(videoChannel.support).to.equal('super video channel support text')
   })
 
   it('Should list video channels', async function () {
-    const res = await getVideoChannelsList(servers[0].url, 1, 1, '-name')
+    const body = await servers[0].channels.list({ start: 1, count: 1, sort: '-name' })
 
-    expect(res.body.total).to.equal(2)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
-    expect(res.body.data[0].name).to.equal('root_channel')
-    expect(res.body.data[0].displayName).to.equal('Main root channel')
+    expect(body.total).to.equal(2)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].name).to.equal('root_channel')
+    expect(body.data[0].displayName).to.equal('Main root channel')
   })
 
   it('Should update video channel', async function () {
@@ -225,30 +192,29 @@ describe('Test video channels', function () {
       support: 'support updated'
     }
 
-    await updateVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel', videoChannelAttributes)
+    await servers[0].channels.update({ channelName: 'second_video_channel', attributes: videoChannelAttributes })
 
     await waitJobs(servers)
   })
 
   it('Should have video channel updated', async function () {
     for (const server of servers) {
-      const res = await getVideoChannelsList(server.url, 0, 1, '-name')
-
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].name).to.equal('second_video_channel')
-      expect(res.body.data[0].displayName).to.equal('video channel updated')
-      expect(res.body.data[0].description).to.equal('video channel description updated')
-      expect(res.body.data[0].support).to.equal('support updated')
+      const body = await server.channels.list({ start: 0, count: 1, sort: '-name' })
+
+      expect(body.total).to.equal(2)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+
+      expect(body.data[0].name).to.equal('second_video_channel')
+      expect(body.data[0].displayName).to.equal('video channel updated')
+      expect(body.data[0].description).to.equal('video channel description updated')
+      expect(body.data[0].support).to.equal('support updated')
     }
   })
 
   it('Should not have updated the video support field', async function () {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = res.body
-
+      const video = await server.videos.get({ id: videoUUID })
       expect(video.support).to.equal('video support field')
     }
   })
@@ -261,14 +227,12 @@ describe('Test video channels', function () {
       bulkVideosSupportUpdate: true
     }
 
-    await updateVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel', videoChannelAttributes)
+    await servers[0].channels.update({ channelName: 'second_video_channel', attributes: videoChannelAttributes })
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = res.body
-
+      const video = await server.videos.get({ id: videoUUID })
       expect(video.support).to.equal(videoChannelAttributes.support)
     }
   })
@@ -278,10 +242,8 @@ describe('Test video channels', function () {
 
     const fixture = 'avatar.png'
 
-    await updateVideoChannelImage({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      videoChannelName: 'second_video_channel',
+    await servers[0].channels.updateImage({
+      channelName: 'second_video_channel',
       fixture,
       type: 'avatar'
     })
@@ -295,7 +257,7 @@ describe('Test video channels', function () {
       await testImage(server.url, 'avatar-resized', avatarPaths[server.port], '.png')
       await testFileExistsOrNot(server, 'avatars', basename(avatarPaths[server.port]), true)
 
-      const row = await getActorImage(server.internalServerNumber, basename(avatarPaths[server.port]))
+      const row = await server.sql.getActorImage(basename(avatarPaths[server.port]))
       expect(row.height).to.equal(ACTOR_IMAGES_SIZE.AVATARS.height)
       expect(row.width).to.equal(ACTOR_IMAGES_SIZE.AVATARS.width)
     }
@@ -306,10 +268,8 @@ describe('Test video channels', function () {
 
     const fixture = 'banner.jpg'
 
-    await updateVideoChannelImage({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      videoChannelName: 'second_video_channel',
+    await servers[0].channels.updateImage({
+      channelName: 'second_video_channel',
       fixture,
       type: 'banner'
     })
@@ -317,14 +277,13 @@ describe('Test video channels', function () {
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideoChannel(server.url, 'second_video_channel@' + servers[0].host)
-      const videoChannel = res.body
+      const videoChannel = await server.channels.get({ channelName: 'second_video_channel@' + servers[0].host })
 
       bannerPaths[server.port] = videoChannel.banner.path
       await testImage(server.url, 'banner-resized', bannerPaths[server.port])
       await testFileExistsOrNot(server, 'avatars', basename(bannerPaths[server.port]), true)
 
-      const row = await getActorImage(server.internalServerNumber, basename(bannerPaths[server.port]))
+      const row = await server.sql.getActorImage(basename(bannerPaths[server.port]))
       expect(row.height).to.equal(ACTOR_IMAGES_SIZE.BANNERS.height)
       expect(row.width).to.equal(ACTOR_IMAGES_SIZE.BANNERS.width)
     }
@@ -333,12 +292,7 @@ describe('Test video channels', function () {
   it('Should delete the video channel avatar', async function () {
     this.timeout(15000)
 
-    await deleteVideoChannelImage({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      videoChannelName: 'second_video_channel',
-      type: 'avatar'
-    })
+    await servers[0].channels.deleteImage({ channelName: 'second_video_channel', type: 'avatar' })
 
     await waitJobs(servers)
 
@@ -353,12 +307,7 @@ describe('Test video channels', function () {
   it('Should delete the video channel banner', async function () {
     this.timeout(15000)
 
-    await deleteVideoChannelImage({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      videoChannelName: 'second_video_channel',
-      type: 'banner'
-    })
+    await servers[0].channels.deleteImage({ channelName: 'second_video_channel', type: 'banner' })
 
     await waitJobs(servers)
 
@@ -375,18 +324,19 @@ describe('Test video channels', function () {
 
     for (const server of servers) {
       const channelURI = 'second_video_channel@localhost:' + servers[0].port
-      const res1 = await getVideoChannelVideos(server.url, server.accessToken, channelURI, 0, 5)
-      expect(res1.body.total).to.equal(1)
-      expect(res1.body.data).to.be.an('array')
-      expect(res1.body.data).to.have.lengthOf(1)
-      expect(res1.body.data[0].name).to.equal('my video name')
+      const { total, data } = await server.videos.listByChannel({ handle: channelURI })
+
+      expect(total).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].name).to.equal('my video name')
     }
   })
 
   it('Should change the video channel of a video', async function () {
     this.timeout(10000)
 
-    await updateVideo(servers[0].url, servers[0].accessToken, videoUUID, { channelId: servers[0].videoChannel.id })
+    await servers[0].videos.update({ id: videoUUID, attributes: { channelId: servers[0].store.channel.id } })
 
     await waitJobs(servers)
   })
@@ -395,47 +345,50 @@ describe('Test video channels', function () {
     this.timeout(10000)
 
     for (const server of servers) {
-      const secondChannelURI = 'second_video_channel@localhost:' + servers[0].port
-      const res1 = await getVideoChannelVideos(server.url, server.accessToken, secondChannelURI, 0, 5)
-      expect(res1.body.total).to.equal(0)
-
-      const channelURI = 'root_channel@localhost:' + servers[0].port
-      const res2 = await getVideoChannelVideos(server.url, server.accessToken, channelURI, 0, 5)
-      expect(res2.body.total).to.equal(1)
-
-      const videos: Video[] = res2.body.data
-      expect(videos).to.be.an('array')
-      expect(videos).to.have.lengthOf(1)
-      expect(videos[0].name).to.equal('my video name')
+      {
+        const secondChannelURI = 'second_video_channel@localhost:' + servers[0].port
+        const { total } = await server.videos.listByChannel({ handle: secondChannelURI })
+        expect(total).to.equal(0)
+      }
+
+      {
+        const channelURI = 'root_channel@localhost:' + servers[0].port
+        const { total, data } = await server.videos.listByChannel({ handle: channelURI })
+        expect(total).to.equal(1)
+
+        expect(data).to.be.an('array')
+        expect(data).to.have.lengthOf(1)
+        expect(data[0].name).to.equal('my video name')
+      }
     }
   })
 
   it('Should delete video channel', async function () {
-    await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel')
+    await servers[0].channels.delete({ channelName: 'second_video_channel' })
   })
 
   it('Should have video channel deleted', async function () {
-    const res = await getVideoChannelsList(servers[0].url, 0, 10)
+    const body = await servers[0].channels.list({ start: 0, count: 10 })
 
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
-    expect(res.body.data[0].displayName).to.equal('Main root channel')
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].displayName).to.equal('Main root channel')
   })
 
   it('Should create the main channel with an uuid if there is a conflict', async function () {
     {
       const videoChannel = { name: 'toto_channel', displayName: 'My toto channel' }
-      const res = await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
-      totoChannel = res.body.videoChannel.id
+      const created = await servers[0].channels.create({ attributes: videoChannel })
+      totoChannel = created.id
     }
 
     {
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: 'toto', password: 'password' })
-      const accessToken = await userLogin(servers[0], { username: 'toto', password: 'password' })
+      await servers[0].users.create({ username: 'toto', password: 'password' })
+      const accessToken = await servers[0].login.getAccessToken({ username: 'toto', password: 'password' })
 
-      const res = await getMyUserInformation(servers[0].url, accessToken)
-      const videoChannel = res.body.videoChannels[0]
+      const { videoChannels } = await servers[0].users.getMyInfo({ token: accessToken })
+      const videoChannel = videoChannels[0]
       expect(videoChannel.name).to.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/)
     }
   })
@@ -444,15 +397,9 @@ describe('Test video channels', function () {
     this.timeout(10000)
 
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
-        accountName,
-        withStats: true
-      })
-
-      const channels: VideoChannel[] = res.body.data
+      const { data } = await servers[0].channels.listByAccount({ accountName, withStats: true })
 
-      for (const channel of channels) {
+      for (const channel of data) {
         expect(channel).to.haveOwnProperty('viewsPerDay')
         expect(channel.viewsPerDay).to.have.length(30 + 1) // daysPrior + today
 
@@ -464,33 +411,24 @@ describe('Test video channels', function () {
     }
 
     {
-      // video has been posted on channel servers[0].videoChannel.id since last update
-      await viewVideo(servers[0].url, videoUUID, 204, '0.0.0.1,127.0.0.1')
-      await viewVideo(servers[0].url, videoUUID, 204, '0.0.0.2,127.0.0.1')
+      // video has been posted on channel servers[0].store.videoChannel.id since last update
+      await servers[0].videos.view({ id: videoUUID, xForwardedFor: '0.0.0.1,127.0.0.1' })
+      await servers[0].videos.view({ id: videoUUID, xForwardedFor: '0.0.0.2,127.0.0.1' })
 
       // Wait the repeatable job
       await wait(8000)
 
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
-        accountName,
-        withStats: true
-      })
-      const channelWithView = res.body.data.find((channel: VideoChannel) => channel.id === servers[0].videoChannel.id)
+      const { data } = await servers[0].channels.listByAccount({ accountName, withStats: true })
+      const channelWithView = data.find(channel => channel.id === servers[0].store.channel.id)
       expect(channelWithView.viewsPerDay.slice(-1)[0].views).to.equal(2)
     }
   })
 
   it('Should report correct videos count', async function () {
-    const res = await getAccountVideoChannelsList({
-      url: servers[0].url,
-      accountName,
-      withStats: true
-    })
-    const channels: VideoChannel[] = res.body.data
+    const { data } = await servers[0].channels.listByAccount({ accountName, withStats: true })
 
-    const totoChannel = channels.find(c => c.name === 'toto_channel')
-    const rootChannel = channels.find(c => c.name === 'root_channel')
+    const totoChannel = data.find(c => c.name === 'toto_channel')
+    const rootChannel = data.find(c => c.name === 'root_channel')
 
     expect(rootChannel.videosCount).to.equal(1)
     expect(totoChannel.videosCount).to.equal(0)
@@ -498,26 +436,18 @@ describe('Test video channels', function () {
 
   it('Should search among account video channels', async function () {
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
-        accountName,
-        search: 'root'
-      })
-      expect(res.body.total).to.equal(1)
+      const body = await servers[0].channels.listByAccount({ accountName, search: 'root' })
+      expect(body.total).to.equal(1)
 
-      const channels = res.body.data
+      const channels = body.data
       expect(channels).to.have.lengthOf(1)
     }
 
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
-        accountName,
-        search: 'does not exist'
-      })
-      expect(res.body.total).to.equal(0)
+      const body = await servers[0].channels.listByAccount({ accountName, search: 'does not exist' })
+      expect(body.total).to.equal(0)
 
-      const channels = res.body.data
+      const channels = body.data
       expect(channels).to.have.lengthOf(0)
     }
   })
@@ -525,34 +455,24 @@ describe('Test video channels', function () {
   it('Should list channels by updatedAt desc if a video has been uploaded', async function () {
     this.timeout(30000)
 
-    await uploadVideo(servers[0].url, servers[0].accessToken, { channelId: totoChannel })
+    await servers[0].videos.upload({ attributes: { channelId: totoChannel } })
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getAccountVideoChannelsList({
-        url: server.url,
-        accountName,
-        sort: '-updatedAt'
-      })
+      const { data } = await server.channels.listByAccount({ accountName, sort: '-updatedAt' })
 
-      const channels: VideoChannel[] = res.body.data
-      expect(channels[0].name).to.equal('toto_channel')
-      expect(channels[1].name).to.equal('root_channel')
+      expect(data[0].name).to.equal('toto_channel')
+      expect(data[1].name).to.equal('root_channel')
     }
 
-    await uploadVideo(servers[0].url, servers[0].accessToken, { channelId: servers[0].videoChannel.id })
+    await servers[0].videos.upload({ attributes: { channelId: servers[0].store.channel.id } })
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getAccountVideoChannelsList({
-        url: server.url,
-        accountName,
-        sort: '-updatedAt'
-      })
+      const { data } = await server.channels.listByAccount({ accountName, sort: '-updatedAt' })
 
-      const channels: VideoChannel[] = res.body.data
-      expect(channels[0].name).to.equal('root_channel')
-      expect(channels[1].name).to.equal('toto_channel')
+      expect(data[0].name).to.equal('root_channel')
+      expect(data[1].name).to.equal('toto_channel')
     }
   })
 
diff --git a/server/tests/api/videos/video-comments.ts b/server/tests/api/videos/video-comments.ts
index b6b002307..61ee54540 100644
--- a/server/tests/api/videos/video-comments.ts
+++ b/server/tests/api/videos/video-comments.ts
@@ -2,80 +2,62 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { VideoComment, VideoCommentAdmin, VideoCommentThreadTree } from '@shared/models'
-import { cleanupTests, testImage } from '../../../../shared/extra-utils'
 import {
-  createUser,
+  cleanupTests,
+  CommentsCommand,
+  createSingleServer,
   dateIsValid,
-  flushAndRunServer,
-  getAccessToken,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateMyAvatar,
-  uploadVideo
-} from '../../../../shared/extra-utils/index'
-import {
-  addVideoCommentReply,
-  addVideoCommentThread,
-  deleteVideoComment,
-  getAdminVideoComments,
-  getVideoCommentThreads,
-  getVideoThreadComments
-} from '../../../../shared/extra-utils/videos/video-comments'
+  testImage
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test video comments', function () {
-  let server: ServerInfo
-  let videoId
-  let videoUUID
-  let threadId
+  let server: PeerTubeServer
+  let videoId: number
+  let videoUUID: string
+  let threadId: number
   let replyToDeleteId: number
 
   let userAccessTokenServer1: string
 
+  let command: CommentsCommand
+
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
-    const res = await uploadVideo(server.url, server.accessToken, {})
-    videoUUID = res.body.video.uuid
-    videoId = res.body.video.id
+    const { id, uuid } = await server.videos.upload()
+    videoUUID = uuid
+    videoId = id
 
-    await updateMyAvatar({
-      url: server.url,
-      accessToken: server.accessToken,
-      fixture: 'avatar.png'
-    })
+    await server.users.updateMyAvatar({ fixture: 'avatar.png' })
 
-    await createUser({
-      url: server.url,
-      accessToken: server.accessToken,
-      username: 'user1',
-      password: 'password'
-    })
-    userAccessTokenServer1 = await getAccessToken(server.url, 'user1', 'password')
+    userAccessTokenServer1 = await server.users.generateUserAndToken('user1')
+
+    command = server.comments
   })
 
   describe('User comments', function () {
 
     it('Should not have threads on this video', async function () {
-      const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+      const body = await command.listThreads({ videoId: videoUUID })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.totalNotDeletedComments).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.totalNotDeletedComments).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     })
 
     it('Should create a thread in this video', async function () {
       const text = 'my super first comment'
 
-      const res = await addVideoCommentThread(server.url, server.accessToken, videoUUID, text)
-      const comment = res.body.comment
+      const comment = await command.createThread({ videoId: videoUUID, text })
 
       expect(comment.inReplyToCommentId).to.be.null
       expect(comment.text).equal('my super first comment')
@@ -91,14 +73,14 @@ describe('Test video comments', function () {
     })
 
     it('Should list threads of this video', async function () {
-      const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+      const body = await command.listThreads({ videoId: videoUUID })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.totalNotDeletedComments).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
+      expect(body.total).to.equal(1)
+      expect(body.totalNotDeletedComments).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
 
-      const comment: VideoComment = res.body.data[0]
+      const comment = body.data[0]
       expect(comment.inReplyToCommentId).to.be.null
       expect(comment.text).equal('my super first comment')
       expect(comment.videoId).to.equal(videoId)
@@ -117,9 +99,9 @@ describe('Test video comments', function () {
     })
 
     it('Should get all the thread created', async function () {
-      const res = await getVideoThreadComments(server.url, videoUUID, threadId)
+      const body = await command.getThread({ videoId: videoUUID, threadId })
 
-      const rootComment = res.body.comment
+      const rootComment = body.comment
       expect(rootComment.inReplyToCommentId).to.be.null
       expect(rootComment.text).equal('my super first comment')
       expect(rootComment.videoId).to.equal(videoId)
@@ -129,20 +111,19 @@ describe('Test video comments', function () {
 
     it('Should create multiple replies in this thread', async function () {
       const text1 = 'my super answer to thread 1'
-      const childCommentRes = await addVideoCommentReply(server.url, server.accessToken, videoId, threadId, text1)
-      const childCommentId = childCommentRes.body.comment.id
+      const created = await command.addReply({ videoId, toCommentId: threadId, text: text1 })
+      const childCommentId = created.id
 
       const text2 = 'my super answer to answer of thread 1'
-      await addVideoCommentReply(server.url, server.accessToken, videoId, childCommentId, text2)
+      await command.addReply({ videoId, toCommentId: childCommentId, text: text2 })
 
       const text3 = 'my second answer to thread 1'
-      await addVideoCommentReply(server.url, server.accessToken, videoId, threadId, text3)
+      await command.addReply({ videoId, toCommentId: threadId, text: text3 })
     })
 
     it('Should get correctly the replies', async function () {
-      const res = await getVideoThreadComments(server.url, videoUUID, threadId)
+      const tree = await command.getThread({ videoId: videoUUID, threadId })
 
-      const tree: VideoCommentThreadTree = res.body
       expect(tree.comment.text).equal('my super first comment')
       expect(tree.children).to.have.lengthOf(2)
 
@@ -163,42 +144,41 @@ describe('Test video comments', function () {
 
     it('Should create other threads', async function () {
       const text1 = 'super thread 2'
-      await addVideoCommentThread(server.url, server.accessToken, videoUUID, text1)
+      await command.createThread({ videoId: videoUUID, text: text1 })
 
       const text2 = 'super thread 3'
-      await addVideoCommentThread(server.url, server.accessToken, videoUUID, text2)
+      await command.createThread({ videoId: videoUUID, text: text2 })
     })
 
     it('Should list the threads', async function () {
-      const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
-
-      expect(res.body.total).to.equal(3)
-      expect(res.body.totalNotDeletedComments).to.equal(6)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(3)
-
-      expect(res.body.data[0].text).to.equal('my super first comment')
-      expect(res.body.data[0].totalReplies).to.equal(3)
-      expect(res.body.data[1].text).to.equal('super thread 2')
-      expect(res.body.data[1].totalReplies).to.equal(0)
-      expect(res.body.data[2].text).to.equal('super thread 3')
-      expect(res.body.data[2].totalReplies).to.equal(0)
+      const body = await command.listThreads({ videoId: videoUUID, sort: 'createdAt' })
+
+      expect(body.total).to.equal(3)
+      expect(body.totalNotDeletedComments).to.equal(6)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(3)
+
+      expect(body.data[0].text).to.equal('my super first comment')
+      expect(body.data[0].totalReplies).to.equal(3)
+      expect(body.data[1].text).to.equal('super thread 2')
+      expect(body.data[1].totalReplies).to.equal(0)
+      expect(body.data[2].text).to.equal('super thread 3')
+      expect(body.data[2].totalReplies).to.equal(0)
     })
 
     it('Should delete a reply', async function () {
-      await deleteVideoComment(server.url, server.accessToken, videoId, replyToDeleteId)
+      await command.delete({ videoId, commentId: replyToDeleteId })
 
       {
-        const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
+        const body = await command.listThreads({ videoId: videoUUID, sort: 'createdAt' })
 
-        expect(res.body.total).to.equal(3)
-        expect(res.body.totalNotDeletedComments).to.equal(5)
+        expect(body.total).to.equal(3)
+        expect(body.totalNotDeletedComments).to.equal(5)
       }
 
       {
-        const res = await getVideoThreadComments(server.url, videoUUID, threadId)
+        const tree = await command.getThread({ videoId: videoUUID, threadId })
 
-        const tree: VideoCommentThreadTree = res.body
         expect(tree.comment.text).equal('my super first comment')
         expect(tree.children).to.have.lengthOf(2)
 
@@ -220,99 +200,88 @@ describe('Test video comments', function () {
     })
 
     it('Should delete a complete thread', async function () {
-      await deleteVideoComment(server.url, server.accessToken, videoId, threadId)
-
-      const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
-      expect(res.body.total).to.equal(3)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(3)
-
-      expect(res.body.data[0].text).to.equal('')
-      expect(res.body.data[0].isDeleted).to.be.true
-      expect(res.body.data[0].deletedAt).to.not.be.null
-      expect(res.body.data[0].account).to.be.null
-      expect(res.body.data[0].totalReplies).to.equal(2)
-      expect(res.body.data[1].text).to.equal('super thread 2')
-      expect(res.body.data[1].totalReplies).to.equal(0)
-      expect(res.body.data[2].text).to.equal('super thread 3')
-      expect(res.body.data[2].totalReplies).to.equal(0)
+      await command.delete({ videoId, commentId: threadId })
+
+      const body = await command.listThreads({ videoId: videoUUID, sort: 'createdAt' })
+      expect(body.total).to.equal(3)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(3)
+
+      expect(body.data[0].text).to.equal('')
+      expect(body.data[0].isDeleted).to.be.true
+      expect(body.data[0].deletedAt).to.not.be.null
+      expect(body.data[0].account).to.be.null
+      expect(body.data[0].totalReplies).to.equal(2)
+      expect(body.data[1].text).to.equal('super thread 2')
+      expect(body.data[1].totalReplies).to.equal(0)
+      expect(body.data[2].text).to.equal('super thread 3')
+      expect(body.data[2].totalReplies).to.equal(0)
     })
 
     it('Should count replies from the video author correctly', async function () {
-      const text = 'my super first comment'
-      await addVideoCommentThread(server.url, server.accessToken, videoUUID, text)
-      let res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
-      const comment: VideoComment = res.body.data[0]
-      const threadId2 = comment.threadId
+      await command.createThread({ videoId: videoUUID, text: 'my super first comment' })
+
+      const { data } = await command.listThreads({ videoId: videoUUID })
+      const threadId2 = data[0].threadId
 
       const text2 = 'a first answer to thread 4 by a third party'
-      await addVideoCommentReply(server.url, userAccessTokenServer1, videoId, threadId2, text2)
+      await command.addReply({ token: userAccessTokenServer1, videoId, toCommentId: threadId2, text: text2 })
 
       const text3 = 'my second answer to thread 4'
-      await addVideoCommentReply(server.url, server.accessToken, videoId, threadId2, text3)
+      await command.addReply({ videoId, toCommentId: threadId2, text: text3 })
 
-      res = await getVideoThreadComments(server.url, videoUUID, threadId2)
-      const tree: VideoCommentThreadTree = res.body
+      const tree = await command.getThread({ videoId: videoUUID, threadId: threadId2 })
       expect(tree.comment.totalReplies).to.equal(tree.comment.totalRepliesFromVideoAuthor + 1)
     })
   })
 
   describe('All instance comments', function () {
-    async function getComments (options: any = {}) {
-      const res = await getAdminVideoComments(Object.assign({
-        url: server.url,
-        token: server.accessToken,
-        start: 0,
-        count: 10
-      }, options))
-
-      return { comments: res.body.data as VideoCommentAdmin[], total: res.body.total as number }
-    }
 
     it('Should list instance comments as admin', async function () {
-      const { comments } = await getComments({ start: 0, count: 1 })
+      const { data } = await command.listForAdmin({ start: 0, count: 1 })
 
-      expect(comments[0].text).to.equal('my second answer to thread 4')
+      expect(data[0].text).to.equal('my second answer to thread 4')
     })
 
     it('Should filter instance comments by isLocal', async function () {
-      const { total, comments } = await getComments({ isLocal: false })
+      const { total, data } = await command.listForAdmin({ isLocal: false })
 
-      expect(comments).to.have.lengthOf(0)
+      expect(data).to.have.lengthOf(0)
       expect(total).to.equal(0)
     })
 
     it('Should search instance comments by account', async function () {
-      const { total, comments } = await getComments({ searchAccount: 'user' })
+      const { total, data } = await command.listForAdmin({ searchAccount: 'user' })
 
-      expect(comments).to.have.lengthOf(1)
+      expect(data).to.have.lengthOf(1)
       expect(total).to.equal(1)
 
-      expect(comments[0].text).to.equal('a first answer to thread 4 by a third party')
+      expect(data[0].text).to.equal('a first answer to thread 4 by a third party')
     })
 
     it('Should search instance comments by video', async function () {
       {
-        const { total, comments } = await getComments({ searchVideo: 'video' })
+        const { total, data } = await command.listForAdmin({ searchVideo: 'video' })
 
-        expect(comments).to.have.lengthOf(7)
+        expect(data).to.have.lengthOf(7)
         expect(total).to.equal(7)
       }
 
       {
-        const { total, comments } = await getComments({ searchVideo: 'hello' })
+        const { total, data } = await command.listForAdmin({ searchVideo: 'hello' })
 
-        expect(comments).to.have.lengthOf(0)
+        expect(data).to.have.lengthOf(0)
         expect(total).to.equal(0)
       }
     })
 
     it('Should search instance comments', async function () {
-      const { total, comments } = await getComments({ search: 'super thread 3' })
+      const { total, data } = await command.listForAdmin({ search: 'super thread 3' })
 
-      expect(comments).to.have.lengthOf(1)
       expect(total).to.equal(1)
-      expect(comments[0].text).to.equal('super thread 3')
+
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].text).to.equal('super thread 3')
     })
   })
 
diff --git a/server/tests/api/videos/video-description.ts b/server/tests/api/videos/video-description.ts
index b8e98e45f..d22b4ed96 100644
--- a/server/tests/api/videos/video-description.ts
+++ b/server/tests/api/videos/video-description.ts
@@ -1,25 +1,13 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import {
-  cleanupTests,
-  flushAndRunMultipleServers,
-  getVideo,
-  getVideoDescription,
-  getVideosList,
-  ServerInfo,
-  setAccessTokensToServers,
-  updateVideo,
-  uploadVideo
-} from '../../../../shared/extra-utils/index'
-import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import * as chai from 'chai'
+import { cleanupTests, createMultipleServers, doubleFollow, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test video description', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoUUID = ''
   let videoId: number
   const longDescription = 'my super description for server 1'.repeat(50)
@@ -28,7 +16,7 @@ describe('Test video description', function () {
     this.timeout(40000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -43,20 +31,19 @@ describe('Test video description', function () {
     const attributes = {
       description: longDescription
     }
-    await uploadVideo(servers[0].url, servers[0].accessToken, attributes)
+    await servers[0].videos.upload({ attributes })
 
     await waitJobs(servers)
 
-    const res = await getVideosList(servers[0].url)
+    const { data } = await servers[0].videos.list()
 
-    videoId = res.body.data[0].id
-    videoUUID = res.body.data[0].uuid
+    videoId = data[0].id
+    videoUUID = data[0].uuid
   })
 
   it('Should have a truncated description on each server', async function () {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video = res.body
+      const video = await server.videos.get({ id: videoUUID })
 
       // 30 characters * 6 -> 240 characters
       const truncatedDescription = 'my super description for server 1'.repeat(7) +
@@ -68,11 +55,10 @@ describe('Test video description', function () {
 
   it('Should fetch long description on each server', async function () {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video = res.body
+      const video = await server.videos.get({ id: videoUUID })
 
-      const res2 = await getVideoDescription(server.url, video.descriptionPath)
-      expect(res2.body.description).to.equal(longDescription)
+      const { description } = await server.videos.getDescription({ descriptionPath: video.descriptionPath })
+      expect(description).to.equal(longDescription)
     }
   })
 
@@ -82,20 +68,19 @@ describe('Test video description', function () {
     const attributes = {
       description: 'short description'
     }
-    await updateVideo(servers[0].url, servers[0].accessToken, videoId, attributes)
+    await servers[0].videos.update({ id: videoId, attributes })
 
     await waitJobs(servers)
   })
 
   it('Should have a small description on each server', async function () {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video = res.body
+      const video = await server.videos.get({ id: videoUUID })
 
       expect(video.description).to.equal('short description')
 
-      const res2 = await getVideoDescription(server.url, video.descriptionPath)
-      expect(res2.body.description).to.equal('short description')
+      const { description } = await server.videos.getDescription({ descriptionPath: video.descriptionPath })
+      expect(description).to.equal('short description')
     }
   })
 
diff --git a/server/tests/api/videos/video-hls.ts b/server/tests/api/videos/video-hls.ts
index 03ac3f321..7845f7334 100644
--- a/server/tests/api/videos/video-hls.ts
+++ b/server/tests/api/videos/video-hls.ts
@@ -9,31 +9,22 @@ import {
   checkSegmentHash,
   checkTmpIsEmpty,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getPlaylist,
-  getVideo,
   makeRawRequest,
-  removeVideo,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateCustomSubConfig,
-  updateVideo,
-  uploadVideo,
   waitJobs,
   webtorrentAdd
-} from '../../../../shared/extra-utils'
-import { VideoDetails } from '../../../../shared/models/videos'
-import { VideoStreamingPlaylistType } from '../../../../shared/models/videos/video-streaming-playlist.type'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoStreamingPlaylistType } from '@shared/models'
 import { DEFAULT_AUDIO_RESOLUTION } from '../../../initializers/constants'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 const expect = chai.expect
 
-async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOnly: boolean, resolutions = [ 240, 360, 480, 720 ]) {
+async function checkHlsPlaylist (servers: PeerTubeServer[], videoUUID: string, hlsOnly: boolean, resolutions = [ 240, 360, 480, 720 ]) {
   for (const server of servers) {
-    const resVideoDetails = await getVideo(server.url, videoUUID)
-    const videoDetails: VideoDetails = resVideoDetails.body
+    const videoDetails = await server.videos.get({ id: videoUUID })
     const baseUrl = `http://${videoDetails.account.host}`
 
     expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
@@ -68,10 +59,9 @@ async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOn
     }
 
     {
-      await checkResolutionsInMasterPlaylist(hlsPlaylist.playlistUrl, resolutions)
+      await checkResolutionsInMasterPlaylist({ server, playlistUrl: hlsPlaylist.playlistUrl, resolutions })
 
-      const res = await getPlaylist(hlsPlaylist.playlistUrl)
-      const masterPlaylist = res.text
+      const masterPlaylist = await server.streamingPlaylists.get({ url: hlsPlaylist.playlistUrl })
 
       for (const resolution of resolutions) {
         expect(masterPlaylist).to.contain(`${resolution}.m3u8`)
@@ -81,9 +71,10 @@ async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOn
 
     {
       for (const resolution of resolutions) {
-        const res = await getPlaylist(`${baseUrl}/static/streaming-playlists/hls/${videoUUID}/${resolution}.m3u8`)
+        const subPlaylist = await server.streamingPlaylists.get({
+          url: `${baseUrl}/static/streaming-playlists/hls/${videoUUID}/${resolution}.m3u8`
+        })
 
-        const subPlaylist = res.text
         expect(subPlaylist).to.contain(`${videoUUID}-${resolution}-fragmented.mp4`)
       }
     }
@@ -92,23 +83,31 @@ async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOn
       const baseUrlAndPath = baseUrl + '/static/streaming-playlists/hls'
 
       for (const resolution of resolutions) {
-        await checkSegmentHash(baseUrlAndPath, baseUrlAndPath, videoUUID, resolution, hlsPlaylist)
+        await checkSegmentHash({
+          server,
+          baseUrlPlaylist: baseUrlAndPath,
+          baseUrlSegment: baseUrlAndPath,
+          videoUUID,
+          resolution,
+          hlsPlaylist
+        })
       }
     }
   }
 }
 
 describe('Test HLS videos', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoUUID = ''
   let videoAudioUUID = ''
 
   function runTestSuite (hlsOnly: boolean) {
+
     it('Should upload a video and transcode it to HLS', async function () {
       this.timeout(120000)
 
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video 1', fixture: 'video_short.webm' })
-      videoUUID = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video 1', fixture: 'video_short.webm' } })
+      videoUUID = uuid
 
       await waitJobs(servers)
 
@@ -118,8 +117,8 @@ describe('Test HLS videos', function () {
     it('Should upload an audio file and transcode it to HLS', async function () {
       this.timeout(120000)
 
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video audio', fixture: 'sample.ogg' })
-      videoAudioUUID = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video audio', fixture: 'sample.ogg' } })
+      videoAudioUUID = uuid
 
       await waitJobs(servers)
 
@@ -129,7 +128,7 @@ describe('Test HLS videos', function () {
     it('Should update the video', async function () {
       this.timeout(10000)
 
-      await updateVideo(servers[0].url, servers[0].accessToken, videoUUID, { name: 'video 1 updated' })
+      await servers[0].videos.update({ id: videoUUID, attributes: { name: 'video 1 updated' } })
 
       await waitJobs(servers)
 
@@ -139,14 +138,14 @@ describe('Test HLS videos', function () {
     it('Should delete videos', async function () {
       this.timeout(10000)
 
-      await removeVideo(servers[0].url, servers[0].accessToken, videoUUID)
-      await removeVideo(servers[0].url, servers[0].accessToken, videoAudioUUID)
+      await servers[0].videos.remove({ id: videoUUID })
+      await servers[0].videos.remove({ id: videoAudioUUID })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        await getVideo(server.url, videoUUID, HttpStatusCode.NOT_FOUND_404)
-        await getVideo(server.url, videoAudioUUID, HttpStatusCode.NOT_FOUND_404)
+        await server.videos.get({ id: videoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+        await server.videos.get({ id: videoAudioUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
     })
 
@@ -176,7 +175,7 @@ describe('Test HLS videos', function () {
         }
       }
     }
-    servers = await flushAndRunMultipleServers(2, configOverride)
+    servers = await createMultipleServers(2, configOverride)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -192,24 +191,26 @@ describe('Test HLS videos', function () {
   describe('With only HLS enabled', function () {
 
     before(async function () {
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-        transcoding: {
-          enabled: true,
-          allowAudioFiles: true,
-          resolutions: {
-            '240p': true,
-            '360p': true,
-            '480p': true,
-            '720p': true,
-            '1080p': true,
-            '1440p': true,
-            '2160p': true
-          },
-          hls: {
-            enabled: true
-          },
-          webtorrent: {
-            enabled: false
+      await servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          transcoding: {
+            enabled: true,
+            allowAudioFiles: true,
+            resolutions: {
+              '240p': true,
+              '360p': true,
+              '480p': true,
+              '720p': true,
+              '1080p': true,
+              '1440p': true,
+              '2160p': true
+            },
+            hls: {
+              enabled: true
+            },
+            webtorrent: {
+              enabled: false
+            }
           }
         }
       })
diff --git a/server/tests/api/videos/video-imports.ts b/server/tests/api/videos/video-imports.ts
index 80834ca86..2eac130d2 100644
--- a/server/tests/api/videos/video-imports.ts
+++ b/server/tests/api/videos/video-imports.ts
@@ -3,43 +3,30 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
+  areHttpImportTestsDisabled,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getMyUserInformation,
-  getMyVideos,
-  getVideo,
-  getVideosList,
-  immutableAssign,
-  listVideoCaptions,
-  ServerInfo,
+  FIXTURE_URLS,
+  PeerTubeServer,
   setAccessTokensToServers,
   testCaptionFile,
-  updateCustomSubConfig
-} from '../../../../shared/extra-utils'
-import { areHttpImportTestsDisabled, testImage } from '../../../../shared/extra-utils/miscs/miscs'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  getMagnetURI,
-  getMyVideoImports,
-  getYoutubeHDRVideoUrl,
-  getYoutubeVideoUrl,
-  importVideo
-} from '../../../../shared/extra-utils/videos/video-imports'
-import { VideoCaption, VideoDetails, VideoImport, VideoPrivacy, VideoResolution } from '../../../../shared/models/videos'
+  testImage,
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoPrivacy, VideoResolution } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test video imports', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let channelIdServer1: number
   let channelIdServer2: number
 
   if (areHttpImportTestsDisabled()) return
 
-  async function checkVideosServer1 (url: string, idHttp: string, idMagnet: string, idTorrent: string) {
-    const resHttp = await getVideo(url, idHttp)
-    const videoHttp: VideoDetails = resHttp.body
+  async function checkVideosServer1 (server: PeerTubeServer, idHttp: string, idMagnet: string, idTorrent: string) {
+    const videoHttp = await server.videos.get({ id: idHttp })
 
     expect(videoHttp.name).to.equal('small video - youtube')
     // FIXME: youtube-dl seems broken
@@ -56,10 +43,8 @@ describe('Test video imports', function () {
     expect(originallyPublishedAt.getMonth()).to.equal(0)
     expect(originallyPublishedAt.getFullYear()).to.equal(2019)
 
-    const resMagnet = await getVideo(url, idMagnet)
-    const videoMagnet: VideoDetails = resMagnet.body
-    const resTorrent = await getVideo(url, idTorrent)
-    const videoTorrent: VideoDetails = resTorrent.body
+    const videoMagnet = await server.videos.get({ id: idMagnet })
+    const videoTorrent = await server.videos.get({ id: idTorrent })
 
     for (const video of [ videoMagnet, videoTorrent ]) {
       expect(video.category.label).to.equal('Misc')
@@ -74,13 +59,12 @@ describe('Test video imports', function () {
     expect(videoTorrent.name).to.contain('你好 世界 720p.mp4')
     expect(videoMagnet.name).to.contain('super peertube2 video')
 
-    const resCaptions = await listVideoCaptions(url, idHttp)
-    expect(resCaptions.body.total).to.equal(2)
+    const bodyCaptions = await server.captions.list({ videoId: idHttp })
+    expect(bodyCaptions.total).to.equal(2)
   }
 
-  async function checkVideoServer2 (url: string, id: number | string) {
-    const res = await getVideo(url, id)
-    const video: VideoDetails = res.body
+  async function checkVideoServer2 (server: PeerTubeServer, id: number | string) {
+    const video = await server.videos.get({ id })
 
     expect(video.name).to.equal('my super name')
     expect(video.category.label).to.equal('Entertainment')
@@ -92,26 +76,26 @@ describe('Test video imports', function () {
 
     expect(video.files).to.have.lengthOf(1)
 
-    const resCaptions = await listVideoCaptions(url, id)
-    expect(resCaptions.body.total).to.equal(2)
+    const bodyCaptions = await server.captions.list({ videoId: id })
+    expect(bodyCaptions.total).to.equal(2)
   }
 
   before(async function () {
     this.timeout(30_000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
     {
-      const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
-      channelIdServer1 = res.body.videoChannels[0].id
+      const { videoChannels } = await servers[0].users.getMyInfo()
+      channelIdServer1 = videoChannels[0].id
     }
 
     {
-      const res = await getMyUserInformation(servers[1].url, servers[1].accessToken)
-      channelIdServer2 = res.body.videoChannels[0].id
+      const { videoChannels } = await servers[1].users.getMyInfo()
+      channelIdServer2 = videoChannels[0].id
     }
 
     await doubleFollow(servers[0], servers[1])
@@ -126,18 +110,18 @@ describe('Test video imports', function () {
     }
 
     {
-      const attributes = immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() })
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      expect(res.body.video.name).to.equal('small video - youtube')
+      const attributes = { ...baseAttributes, targetUrl: FIXTURE_URLS.youtube }
+      const { video } = await servers[0].imports.importVideo({ attributes })
+      expect(video.name).to.equal('small video - youtube')
 
-      expect(res.body.video.thumbnailPath).to.match(new RegExp(`^/static/thumbnails/.+.jpg$`))
-      expect(res.body.video.previewPath).to.match(new RegExp(`^/lazy-static/previews/.+.jpg$`))
+      expect(video.thumbnailPath).to.match(new RegExp(`^/static/thumbnails/.+.jpg$`))
+      expect(video.previewPath).to.match(new RegExp(`^/lazy-static/previews/.+.jpg$`))
 
-      await testImage(servers[0].url, 'video_import_thumbnail', res.body.video.thumbnailPath)
-      await testImage(servers[0].url, 'video_import_preview', res.body.video.previewPath)
+      await testImage(servers[0].url, 'video_import_thumbnail', video.thumbnailPath)
+      await testImage(servers[0].url, 'video_import_preview', video.previewPath)
 
-      const resCaptions = await listVideoCaptions(servers[0].url, res.body.video.id)
-      const videoCaptions: VideoCaption[] = resCaptions.body.data
+      const bodyCaptions = await servers[0].captions.list({ videoId: video.id })
+      const videoCaptions = bodyCaptions.data
       expect(videoCaptions).to.have.lengthOf(2)
 
       const enCaption = videoCaptions.find(caption => caption.language.id === 'en')
@@ -176,52 +160,52 @@ Ajouter un sous-titre est vraiment facile`)
     }
 
     {
-      const attributes = immutableAssign(baseAttributes, {
-        magnetUri: getMagnetURI(),
+      const attributes = {
+        ...baseAttributes,
+        magnetUri: FIXTURE_URLS.magnet,
         description: 'this is a super torrent description',
         tags: [ 'tag_torrent1', 'tag_torrent2' ]
-      })
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      expect(res.body.video.name).to.equal('super peertube2 video')
+      }
+      const { video } = await servers[0].imports.importVideo({ attributes })
+      expect(video.name).to.equal('super peertube2 video')
     }
 
     {
-      const attributes = immutableAssign(baseAttributes, {
+      const attributes = {
+        ...baseAttributes,
         torrentfile: 'video-720p.torrent' as any,
         description: 'this is a super torrent description',
         tags: [ 'tag_torrent1', 'tag_torrent2' ]
-      })
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      expect(res.body.video.name).to.equal('你好 世界 720p.mp4')
+      }
+      const { video } = await servers[0].imports.importVideo({ attributes })
+      expect(video.name).to.equal('你好 世界 720p.mp4')
     }
   })
 
   it('Should list the videos to import in my videos on server 1', async function () {
-    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5, 'createdAt')
+    const { total, data } = await servers[0].videos.listMyVideos({ sort: 'createdAt' })
 
-    expect(res.body.total).to.equal(3)
+    expect(total).to.equal(3)
 
-    const videos = res.body.data
-    expect(videos).to.have.lengthOf(3)
-    expect(videos[0].name).to.equal('small video - youtube')
-    expect(videos[1].name).to.equal('super peertube2 video')
-    expect(videos[2].name).to.equal('你好 世界 720p.mp4')
+    expect(data).to.have.lengthOf(3)
+    expect(data[0].name).to.equal('small video - youtube')
+    expect(data[1].name).to.equal('super peertube2 video')
+    expect(data[2].name).to.equal('你好 世界 720p.mp4')
   })
 
   it('Should list the videos to import in my imports on server 1', async function () {
-    const res = await getMyVideoImports(servers[0].url, servers[0].accessToken, '-createdAt')
+    const { total, data: videoImports } = await servers[0].imports.getMyVideoImports({ sort: '-createdAt' })
+    expect(total).to.equal(3)
 
-    expect(res.body.total).to.equal(3)
-    const videoImports: VideoImport[] = res.body.data
     expect(videoImports).to.have.lengthOf(3)
 
-    expect(videoImports[2].targetUrl).to.equal(getYoutubeVideoUrl())
+    expect(videoImports[2].targetUrl).to.equal(FIXTURE_URLS.youtube)
     expect(videoImports[2].magnetUri).to.be.null
     expect(videoImports[2].torrentName).to.be.null
     expect(videoImports[2].video.name).to.equal('small video - youtube')
 
     expect(videoImports[1].targetUrl).to.be.null
-    expect(videoImports[1].magnetUri).to.equal(getMagnetURI())
+    expect(videoImports[1].magnetUri).to.equal(FIXTURE_URLS.magnet)
     expect(videoImports[1].torrentName).to.be.null
     expect(videoImports[1].video.name).to.equal('super peertube2 video')
 
@@ -237,12 +221,12 @@ Ajouter un sous-titre est vraiment facile`)
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      expect(res.body.total).to.equal(3)
-      expect(res.body.data).to.have.lengthOf(3)
+      const { total, data } = await server.videos.list()
+      expect(total).to.equal(3)
+      expect(data).to.have.lengthOf(3)
 
-      const [ videoHttp, videoMagnet, videoTorrent ] = res.body.data
-      await checkVideosServer1(server.url, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
+      const [ videoHttp, videoMagnet, videoTorrent ] = data
+      await checkVideosServer1(server, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
     }
   })
 
@@ -250,7 +234,7 @@ Ajouter un sous-titre est vraiment facile`)
     this.timeout(60_000)
 
     const attributes = {
-      targetUrl: getYoutubeVideoUrl(),
+      targetUrl: FIXTURE_URLS.youtube,
       channelId: channelIdServer2,
       privacy: VideoPrivacy.PUBLIC,
       category: 10,
@@ -260,8 +244,8 @@ Ajouter un sous-titre est vraiment facile`)
       description: 'my super description',
       tags: [ 'supertag1', 'supertag2' ]
     }
-    const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
-    expect(res.body.video.name).to.equal('my super name')
+    const { video } = await servers[1].imports.importVideo({ attributes })
+    expect(video.name).to.equal('my super name')
   })
 
   it('Should have the videos listed on the two instances', async function () {
@@ -270,14 +254,14 @@ Ajouter un sous-titre est vraiment facile`)
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      expect(res.body.total).to.equal(4)
-      expect(res.body.data).to.have.lengthOf(4)
+      const { total, data } = await server.videos.list()
+      expect(total).to.equal(4)
+      expect(data).to.have.lengthOf(4)
 
-      await checkVideoServer2(server.url, res.body.data[0].uuid)
+      await checkVideoServer2(server, data[0].uuid)
 
-      const [ , videoHttp, videoMagnet, videoTorrent ] = res.body.data
-      await checkVideosServer1(server.url, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
+      const [ , videoHttp, videoMagnet, videoTorrent ] = data
+      await checkVideosServer1(server, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
     }
   })
 
@@ -286,18 +270,17 @@ Ajouter un sous-titre est vraiment facile`)
 
     const attributes = {
       name: 'transcoded video',
-      magnetUri: getMagnetURI(),
+      magnetUri: FIXTURE_URLS.magnet,
       channelId: channelIdServer2,
       privacy: VideoPrivacy.PUBLIC
     }
-    const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
-    const videoUUID = res.body.video.uuid
+    const { video } = await servers[1].imports.importVideo({ attributes })
+    const videoUUID = video.uuid
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = res.body
+      const video = await server.videos.get({ id: videoUUID })
 
       expect(video.name).to.equal('transcoded video')
       expect(video.files).to.have.lengthOf(4)
@@ -333,22 +316,21 @@ Ajouter un sous-titre est vraiment facile`)
         }
       }
     }
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
+    await servers[0].config.updateCustomSubConfig({ newConfig: config })
 
     const attributes = {
       name: 'hdr video',
-      targetUrl: getYoutubeHDRVideoUrl(),
+      targetUrl: FIXTURE_URLS.youtubeHDR,
       channelId: channelIdServer1,
       privacy: VideoPrivacy.PUBLIC
     }
-    const res1 = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-    const videoUUID = res1.body.video.uuid
+    const { video: videoImported } = await servers[0].imports.importVideo({ attributes })
+    const videoUUID = videoImported.uuid
 
     await waitJobs(servers)
 
     // test resolution
-    const res2 = await getVideo(servers[0].url, videoUUID)
-    const video: VideoDetails = res2.body
+    const video = await servers[0].videos.get({ id: videoUUID })
     expect(video.name).to.equal('hdr video')
     const maxResolution = Math.max.apply(Math, video.files.map(function (o) { return o.resolution.id }))
     expect(maxResolution, 'expected max resolution not met').to.equals(VideoResolution.H_1080P)
diff --git a/server/tests/api/videos/video-nsfw.ts b/server/tests/api/videos/video-nsfw.ts
index b16b484b9..b5d183d62 100644
--- a/server/tests/api/videos/video-nsfw.ts
+++ b/server/tests/api/videos/video-nsfw.ts
@@ -1,117 +1,96 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import { cleanupTests, getVideosList, ServerInfo, setAccessTokensToServers, uploadVideo } from '../../../../shared/extra-utils/index'
-import { userLogin } from '../../../../shared/extra-utils/users/login'
-import { createUser } from '../../../../shared/extra-utils/users/users'
-import { getMyVideos } from '../../../../shared/extra-utils/videos/videos'
-import {
-  flushAndRunServer,
-  getAccountVideos,
-  getConfig,
-  getCustomConfig,
-  getMyUserInformation,
-  getVideoChannelVideos,
-  getVideosListWithToken,
-  searchVideo,
-  searchVideoWithToken,
-  updateCustomConfig,
-  updateMyUser
-} from '../../../../shared/extra-utils'
-import { ServerConfig, VideosOverview } from '../../../../shared/models'
-import { CustomConfig } from '../../../../shared/models/server/custom-config.model'
-import { User } from '../../../../shared/models/users'
-import { getVideosOverview, getVideosOverviewWithToken } from '@shared/extra-utils/overviews/overviews'
+import * as chai from 'chai'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
+import { BooleanBothQuery, CustomConfig, ResultList, Video, VideosOverview } from '@shared/models'
 
 const expect = chai.expect
 
-function createOverviewRes (res: any) {
-  const overview = res.body as VideosOverview
-
+function createOverviewRes (overview: VideosOverview) {
   const videos = overview.categories[0].videos
-  return { body: { data: videos, total: videos.length } }
+  return { data: videos, total: videos.length }
 }
 
 describe('Test video NSFW policy', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken: string
   let customConfig: CustomConfig
 
-  function getVideosFunctions (token?: string, query = {}) {
-    return getMyUserInformation(server.url, server.accessToken)
-      .then(res => {
-        const user: User = res.body
-        const videoChannelName = user.videoChannels[0].name
-        const accountName = user.account.name + '@' + user.account.host
-        const hasQuery = Object.keys(query).length !== 0
-        let promises: Promise<any>[]
-
-        if (token) {
-          promises = [
-            getVideosListWithToken(server.url, token, query),
-            searchVideoWithToken(server.url, 'n', token, query),
-            getAccountVideos(server.url, token, accountName, 0, 5, undefined, query),
-            getVideoChannelVideos(server.url, token, videoChannelName, 0, 5, undefined, query)
-          ]
-
-          // Overviews do not support video filters
-          if (!hasQuery) {
-            promises.push(getVideosOverviewWithToken(server.url, 1, token).then(res => createOverviewRes(res)))
-          }
-
-          return Promise.all(promises)
-        }
-
-        promises = [
-          getVideosList(server.url),
-          searchVideo(server.url, 'n'),
-          getAccountVideos(server.url, undefined, accountName, 0, 5),
-          getVideoChannelVideos(server.url, undefined, videoChannelName, 0, 5)
-        ]
-
-        // Overviews do not support video filters
-        if (!hasQuery) {
-          promises.push(getVideosOverview(server.url, 1).then(res => createOverviewRes(res)))
-        }
-
-        return Promise.all(promises)
-      })
+  async function getVideosFunctions (token?: string, query: { nsfw?: BooleanBothQuery } = {}) {
+    const user = await server.users.getMyInfo()
+
+    const channelName = user.videoChannels[0].name
+    const accountName = user.account.name + '@' + user.account.host
+
+    const hasQuery = Object.keys(query).length !== 0
+    let promises: Promise<ResultList<Video>>[]
+
+    if (token) {
+      promises = [
+        server.search.advancedVideoSearch({ token, search: { search: 'n', sort: '-publishedAt', ...query } }),
+        server.videos.listWithToken({ token, ...query }),
+        server.videos.listByAccount({ token, handle: accountName, ...query }),
+        server.videos.listByChannel({ token, handle: channelName, ...query })
+      ]
+
+      // Overviews do not support video filters
+      if (!hasQuery) {
+        const p = server.overviews.getVideos({ page: 1, token })
+                                         .then(res => createOverviewRes(res))
+        promises.push(p)
+      }
+
+      return Promise.all(promises)
+    }
+
+    promises = [
+      server.search.searchVideos({ search: 'n', sort: '-publishedAt' }),
+      server.videos.list(),
+      server.videos.listByAccount({ token: null, handle: accountName }),
+      server.videos.listByChannel({ token: null, handle: channelName })
+    ]
+
+    // Overviews do not support video filters
+    if (!hasQuery) {
+      const p = server.overviews.getVideos({ page: 1 })
+                                       .then(res => createOverviewRes(res))
+      promises.push(p)
+    }
+
+    return Promise.all(promises)
   }
 
   before(async function () {
     this.timeout(50000)
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     // Get the access tokens
     await setAccessTokensToServers([ server ])
 
     {
       const attributes = { name: 'nsfw', nsfw: true, category: 1 }
-      await uploadVideo(server.url, server.accessToken, attributes)
+      await server.videos.upload({ attributes })
     }
 
     {
       const attributes = { name: 'normal', nsfw: false, category: 1 }
-      await uploadVideo(server.url, server.accessToken, attributes)
+      await server.videos.upload({ attributes })
     }
 
-    {
-      const res = await getCustomConfig(server.url, server.accessToken)
-      customConfig = res.body
-    }
+    customConfig = await server.config.getCustomConfig()
   })
 
   describe('Instance default NSFW policy', function () {
+
     it('Should display NSFW videos with display default NSFW policy', async function () {
-      const resConfig = await getConfig(server.url)
-      const serverConfig: ServerConfig = resConfig.body
+      const serverConfig = await server.config.getConfig()
       expect(serverConfig.instance.defaultNSFWPolicy).to.equal('display')
 
-      for (const res of await getVideosFunctions()) {
-        expect(res.body.total).to.equal(2)
+      for (const body of await getVideosFunctions()) {
+        expect(body.total).to.equal(2)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(2)
         expect(videos[0].name).to.equal('normal')
         expect(videos[1].name).to.equal('nsfw')
@@ -120,16 +99,15 @@ describe('Test video NSFW policy', function () {
 
     it('Should not display NSFW videos with do_not_list default NSFW policy', async function () {
       customConfig.instance.defaultNSFWPolicy = 'do_not_list'
-      await updateCustomConfig(server.url, server.accessToken, customConfig)
+      await server.config.updateCustomConfig({ newCustomConfig: customConfig })
 
-      const resConfig = await getConfig(server.url)
-      const serverConfig: ServerConfig = resConfig.body
+      const serverConfig = await server.config.getConfig()
       expect(serverConfig.instance.defaultNSFWPolicy).to.equal('do_not_list')
 
-      for (const res of await getVideosFunctions()) {
-        expect(res.body.total).to.equal(1)
+      for (const body of await getVideosFunctions()) {
+        expect(body.total).to.equal(1)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(1)
         expect(videos[0].name).to.equal('normal')
       }
@@ -137,16 +115,15 @@ describe('Test video NSFW policy', function () {
 
     it('Should display NSFW videos with blur default NSFW policy', async function () {
       customConfig.instance.defaultNSFWPolicy = 'blur'
-      await updateCustomConfig(server.url, server.accessToken, customConfig)
+      await server.config.updateCustomConfig({ newCustomConfig: customConfig })
 
-      const resConfig = await getConfig(server.url)
-      const serverConfig: ServerConfig = resConfig.body
+      const serverConfig = await server.config.getConfig()
       expect(serverConfig.instance.defaultNSFWPolicy).to.equal('blur')
 
-      for (const res of await getVideosFunctions()) {
-        expect(res.body.total).to.equal(2)
+      for (const body of await getVideosFunctions()) {
+        expect(body.total).to.equal(2)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(2)
         expect(videos[0].name).to.equal('normal')
         expect(videos[1].name).to.equal('nsfw')
@@ -159,24 +136,22 @@ describe('Test video NSFW policy', function () {
     it('Should create a user having the default nsfw policy', async function () {
       const username = 'user1'
       const password = 'my super password'
-      await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
-
-      userAccessToken = await userLogin(server, { username, password })
+      await server.users.create({ username: username, password: password })
 
-      const res = await getMyUserInformation(server.url, userAccessToken)
-      const user = res.body
+      userAccessToken = await server.login.getAccessToken({ username, password })
 
+      const user = await server.users.getMyInfo({ token: userAccessToken })
       expect(user.nsfwPolicy).to.equal('blur')
     })
 
     it('Should display NSFW videos with blur user NSFW policy', async function () {
       customConfig.instance.defaultNSFWPolicy = 'do_not_list'
-      await updateCustomConfig(server.url, server.accessToken, customConfig)
+      await server.config.updateCustomConfig({ newCustomConfig: customConfig })
 
-      for (const res of await getVideosFunctions(userAccessToken)) {
-        expect(res.body.total).to.equal(2)
+      for (const body of await getVideosFunctions(userAccessToken)) {
+        expect(body.total).to.equal(2)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(2)
         expect(videos[0].name).to.equal('normal')
         expect(videos[1].name).to.equal('nsfw')
@@ -184,16 +159,12 @@ describe('Test video NSFW policy', function () {
     })
 
     it('Should display NSFW videos with display user NSFW policy', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: server.accessToken,
-        nsfwPolicy: 'display'
-      })
+      await server.users.updateMe({ nsfwPolicy: 'display' })
 
-      for (const res of await getVideosFunctions(server.accessToken)) {
-        expect(res.body.total).to.equal(2)
+      for (const body of await getVideosFunctions(server.accessToken)) {
+        expect(body.total).to.equal(2)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(2)
         expect(videos[0].name).to.equal('normal')
         expect(videos[1].name).to.equal('nsfw')
@@ -201,56 +172,51 @@ describe('Test video NSFW policy', function () {
     })
 
     it('Should not display NSFW videos with do_not_list user NSFW policy', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: server.accessToken,
-        nsfwPolicy: 'do_not_list'
-      })
+      await server.users.updateMe({ nsfwPolicy: 'do_not_list' })
 
-      for (const res of await getVideosFunctions(server.accessToken)) {
-        expect(res.body.total).to.equal(1)
+      for (const body of await getVideosFunctions(server.accessToken)) {
+        expect(body.total).to.equal(1)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(1)
         expect(videos[0].name).to.equal('normal')
       }
     })
 
     it('Should be able to see my NSFW videos even with do_not_list user NSFW policy', async function () {
-      const res = await getMyVideos(server.url, server.accessToken, 0, 5)
-      expect(res.body.total).to.equal(2)
+      const { total, data } = await server.videos.listMyVideos()
+      expect(total).to.equal(2)
 
-      const videos = res.body.data
-      expect(videos).to.have.lengthOf(2)
-      expect(videos[0].name).to.equal('normal')
-      expect(videos[1].name).to.equal('nsfw')
+      expect(data).to.have.lengthOf(2)
+      expect(data[0].name).to.equal('normal')
+      expect(data[1].name).to.equal('nsfw')
     })
 
     it('Should display NSFW videos when the nsfw param === true', async function () {
-      for (const res of await getVideosFunctions(server.accessToken, { nsfw: true })) {
-        expect(res.body.total).to.equal(1)
+      for (const body of await getVideosFunctions(server.accessToken, { nsfw: 'true' })) {
+        expect(body.total).to.equal(1)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(1)
         expect(videos[0].name).to.equal('nsfw')
       }
     })
 
     it('Should hide NSFW videos when the nsfw param === true', async function () {
-      for (const res of await getVideosFunctions(server.accessToken, { nsfw: false })) {
-        expect(res.body.total).to.equal(1)
+      for (const body of await getVideosFunctions(server.accessToken, { nsfw: 'false' })) {
+        expect(body.total).to.equal(1)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(1)
         expect(videos[0].name).to.equal('normal')
       }
     })
 
     it('Should display both videos when the nsfw param === both', async function () {
-      for (const res of await getVideosFunctions(server.accessToken, { nsfw: 'both' })) {
-        expect(res.body.total).to.equal(2)
+      for (const body of await getVideosFunctions(server.accessToken, { nsfw: 'both' })) {
+        expect(body.total).to.equal(2)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(2)
         expect(videos[0].name).to.equal('normal')
         expect(videos[1].name).to.equal('nsfw')
diff --git a/server/tests/api/videos/video-playlist-thumbnails.ts b/server/tests/api/videos/video-playlist-thumbnails.ts
index a93a0b7de..f0b2ca169 100644
--- a/server/tests/api/videos/video-playlist-thumbnails.ts
+++ b/server/tests/api/videos/video-playlist-thumbnails.ts
@@ -1,21 +1,15 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
-  addVideoInPlaylist,
   cleanupTests,
-  createVideoPlaylist,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getVideoPlaylistsList,
-  removeVideoFromPlaylist,
-  reorderVideosPlaylist,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   testImage,
-  uploadVideoAndGetId,
   waitJobs
 } from '../../../../shared/extra-utils'
 import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
@@ -23,10 +17,10 @@ import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/
 const expect = chai.expect
 
 describe('Playlist thumbnail', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
 
-  let playlistWithoutThumbnail: number
-  let playlistWithThumbnail: number
+  let playlistWithoutThumbnailId: number
+  let playlistWithThumbnailId: number
 
   let withThumbnailE1: number
   let withThumbnailE2: number
@@ -36,22 +30,22 @@ describe('Playlist thumbnail', function () {
   let video1: number
   let video2: number
 
-  async function getPlaylistWithoutThumbnail (server: ServerInfo) {
-    const res = await getVideoPlaylistsList(server.url, 0, 10)
+  async function getPlaylistWithoutThumbnail (server: PeerTubeServer) {
+    const body = await server.playlists.list({ start: 0, count: 10 })
 
-    return res.body.data.find(p => p.displayName === 'playlist without thumbnail')
+    return body.data.find(p => p.displayName === 'playlist without thumbnail')
   }
 
-  async function getPlaylistWithThumbnail (server: ServerInfo) {
-    const res = await getVideoPlaylistsList(server.url, 0, 10)
+  async function getPlaylistWithThumbnail (server: PeerTubeServer) {
+    const body = await server.playlists.list({ start: 0, count: 10 })
 
-    return res.body.data.find(p => p.displayName === 'playlist with thumbnail')
+    return body.data.find(p => p.displayName === 'playlist with thumbnail')
   }
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2, { transcoding: { enabled: false } })
+    servers = await createMultipleServers(2, { transcoding: { enabled: false } })
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -60,8 +54,8 @@ describe('Playlist thumbnail', function () {
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
 
-    video1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 1' })).id
-    video2 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 2' })).id
+    video1 = (await servers[0].videos.quickUpload({ name: 'video 1' })).id
+    video2 = (await servers[0].videos.quickUpload({ name: 'video 2' })).id
 
     await waitJobs(servers)
   })
@@ -69,24 +63,20 @@ describe('Playlist thumbnail', function () {
   it('Should automatically update the thumbnail when adding an element', async function () {
     this.timeout(30000)
 
-    const res = await createVideoPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistAttrs: {
+    const created = await servers[1].playlists.create({
+      attributes: {
         displayName: 'playlist without thumbnail',
         privacy: VideoPlaylistPrivacy.PUBLIC,
-        videoChannelId: servers[1].videoChannel.id
+        videoChannelId: servers[1].store.channel.id
       }
     })
-    playlistWithoutThumbnail = res.body.videoPlaylist.id
+    playlistWithoutThumbnailId = created.id
 
-    const res2 = await addVideoInPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithoutThumbnail,
-      elementAttrs: { videoId: video1 }
+    const added = await servers[1].playlists.addElement({
+      playlistId: playlistWithoutThumbnailId,
+      attributes: { videoId: video1 }
     })
-    withoutThumbnailE1 = res2.body.videoPlaylistElement.id
+    withoutThumbnailE1 = added.id
 
     await waitJobs(servers)
 
@@ -99,25 +89,21 @@ describe('Playlist thumbnail', function () {
   it('Should not update the thumbnail if we explicitly uploaded a thumbnail', async function () {
     this.timeout(30000)
 
-    const res = await createVideoPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistAttrs: {
+    const created = await servers[1].playlists.create({
+      attributes: {
         displayName: 'playlist with thumbnail',
         privacy: VideoPlaylistPrivacy.PUBLIC,
-        videoChannelId: servers[1].videoChannel.id,
+        videoChannelId: servers[1].store.channel.id,
         thumbnailfile: 'thumbnail.jpg'
       }
     })
-    playlistWithThumbnail = res.body.videoPlaylist.id
+    playlistWithThumbnailId = created.id
 
-    const res2 = await addVideoInPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithThumbnail,
-      elementAttrs: { videoId: video1 }
+    const added = await servers[1].playlists.addElement({
+      playlistId: playlistWithThumbnailId,
+      attributes: { videoId: video1 }
     })
-    withThumbnailE1 = res2.body.videoPlaylistElement.id
+    withThumbnailE1 = added.id
 
     await waitJobs(servers)
 
@@ -130,19 +116,15 @@ describe('Playlist thumbnail', function () {
   it('Should automatically update the thumbnail when moving the first element', async function () {
     this.timeout(30000)
 
-    const res = await addVideoInPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithoutThumbnail,
-      elementAttrs: { videoId: video2 }
+    const added = await servers[1].playlists.addElement({
+      playlistId: playlistWithoutThumbnailId,
+      attributes: { videoId: video2 }
     })
-    withoutThumbnailE2 = res.body.videoPlaylistElement.id
+    withoutThumbnailE2 = added.id
 
-    await reorderVideosPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithoutThumbnail,
-      elementAttrs: {
+    await servers[1].playlists.reorderElements({
+      playlistId: playlistWithoutThumbnailId,
+      attributes: {
         startPosition: 1,
         insertAfterPosition: 2
       }
@@ -159,19 +141,15 @@ describe('Playlist thumbnail', function () {
   it('Should not update the thumbnail when moving the first element if we explicitly uploaded a thumbnail', async function () {
     this.timeout(30000)
 
-    const res = await addVideoInPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithThumbnail,
-      elementAttrs: { videoId: video2 }
+    const added = await servers[1].playlists.addElement({
+      playlistId: playlistWithThumbnailId,
+      attributes: { videoId: video2 }
     })
-    withThumbnailE2 = res.body.videoPlaylistElement.id
+    withThumbnailE2 = added.id
 
-    await reorderVideosPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithThumbnail,
-      elementAttrs: {
+    await servers[1].playlists.reorderElements({
+      playlistId: playlistWithThumbnailId,
+      attributes: {
         startPosition: 1,
         insertAfterPosition: 2
       }
@@ -188,11 +166,9 @@ describe('Playlist thumbnail', function () {
   it('Should automatically update the thumbnail when deleting the first element', async function () {
     this.timeout(30000)
 
-    await removeVideoFromPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithoutThumbnail,
-      playlistElementId: withoutThumbnailE1
+    await servers[1].playlists.removeElement({
+      playlistId: playlistWithoutThumbnailId,
+      elementId: withoutThumbnailE1
     })
 
     await waitJobs(servers)
@@ -206,11 +182,9 @@ describe('Playlist thumbnail', function () {
   it('Should not update the thumbnail when deleting the first element if we explicitly uploaded a thumbnail', async function () {
     this.timeout(30000)
 
-    await removeVideoFromPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithThumbnail,
-      playlistElementId: withThumbnailE1
+    await servers[1].playlists.removeElement({
+      playlistId: playlistWithThumbnailId,
+      elementId: withThumbnailE1
     })
 
     await waitJobs(servers)
@@ -224,11 +198,9 @@ describe('Playlist thumbnail', function () {
   it('Should the thumbnail when we delete the last element', async function () {
     this.timeout(30000)
 
-    await removeVideoFromPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithoutThumbnail,
-      playlistElementId: withoutThumbnailE2
+    await servers[1].playlists.removeElement({
+      playlistId: playlistWithoutThumbnailId,
+      elementId: withoutThumbnailE2
     })
 
     await waitJobs(servers)
@@ -242,11 +214,9 @@ describe('Playlist thumbnail', function () {
   it('Should not update the thumbnail when we delete the last element if we explicitly uploaded a thumbnail', async function () {
     this.timeout(30000)
 
-    await removeVideoFromPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithThumbnail,
-      playlistElementId: withThumbnailE2
+    await servers[1].playlists.removeElement({
+      playlistId: playlistWithThumbnailId,
+      elementId: withThumbnailE2
     })
 
     await waitJobs(servers)
diff --git a/server/tests/api/videos/video-playlists.ts b/server/tests/api/videos/video-playlists.ts
index da8de054b..f42aee2ff 100644
--- a/server/tests/api/videos/video-playlists.ts
+++ b/server/tests/api/videos/video-playlists.ts
@@ -2,71 +2,33 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoChannel,
-  addVideoInPlaylist,
-  addVideoToBlacklist,
   checkPlaylistFilesWereRemoved,
   cleanupTests,
-  createUser,
-  createVideoPlaylist,
-  deleteVideoChannel,
-  deleteVideoPlaylist,
+  createMultipleServers,
   doubleFollow,
-  doVideosExistInMyPlaylist,
-  flushAndRunMultipleServers,
-  generateUserAccessToken,
-  getAccessToken,
-  getAccountPlaylistsList,
-  getAccountPlaylistsListWithToken,
-  getMyUserInformation,
-  getPlaylistVideos,
-  getVideoChannelPlaylistsList,
-  getVideoPlaylist,
-  getVideoPlaylistPrivacies,
-  getVideoPlaylistsList,
-  getVideoPlaylistWithToken,
-  removeUser,
-  removeVideoFromBlacklist,
-  removeVideoFromPlaylist,
-  reorderVideosPlaylist,
-  ServerInfo,
+  PeerTubeServer,
+  PlaylistsCommand,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   testImage,
-  unfollow,
-  updateVideo,
-  updateVideoPlaylist,
-  updateVideoPlaylistElement,
-  uploadVideo,
-  uploadVideoAndGetId,
-  userLogin,
   wait,
   waitJobs
-} from '../../../../shared/extra-utils'
+} from '@shared/extra-utils'
 import {
-  addAccountToAccountBlocklist,
-  addAccountToServerBlocklist,
-  addServerToAccountBlocklist,
-  addServerToServerBlocklist,
-  removeAccountFromAccountBlocklist,
-  removeAccountFromServerBlocklist,
-  removeServerFromAccountBlocklist,
-  removeServerFromServerBlocklist
-} from '../../../../shared/extra-utils/users/blocklist'
-import { User } from '../../../../shared/models/users'
-import { VideoPlaylistCreateResult, VideoPrivacy } from '../../../../shared/models/videos'
-import { VideoExistInPlaylist } from '../../../../shared/models/videos/playlist/video-exist-in-playlist.model'
-import { VideoPlaylistElement, VideoPlaylistElementType } from '../../../../shared/models/videos/playlist/video-playlist-element.model'
-import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
-import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
-import { VideoPlaylist } from '../../../../shared/models/videos/playlist/video-playlist.model'
+  HttpStatusCode,
+  VideoPlaylist,
+  VideoPlaylistCreateResult,
+  VideoPlaylistElementType,
+  VideoPlaylistPrivacy,
+  VideoPlaylistType,
+  VideoPrivacy
+} from '@shared/models'
 
 const expect = chai.expect
 
 async function checkPlaylistElementType (
-  servers: ServerInfo[],
+  servers: PeerTubeServer[],
   playlistId: string,
   type: VideoPlaylistElementType,
   position: number,
@@ -74,10 +36,10 @@ async function checkPlaylistElementType (
   total: number
 ) {
   for (const server of servers) {
-    const res = await getPlaylistVideos(server.url, server.accessToken, playlistId, 0, 10)
-    expect(res.body.total).to.equal(total)
+    const body = await server.playlists.listVideos({ token: server.accessToken, playlistId, start: 0, count: 10 })
+    expect(body.total).to.equal(total)
 
-    const videoElement: VideoPlaylistElement = res.body.data.find((e: VideoPlaylistElement) => e.position === position)
+    const videoElement = body.data.find(e => e.position === position)
     expect(videoElement.type).to.equal(type, 'On server ' + server.url)
 
     if (type === VideoPlaylistElementType.REGULAR) {
@@ -90,11 +52,11 @@ async function checkPlaylistElementType (
 }
 
 describe('Test video playlists', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
 
   let playlistServer2Id1: number
   let playlistServer2Id2: number
-  let playlistServer2UUID2: number
+  let playlistServer2UUID2: string
 
   let playlistServer1Id: number
   let playlistServer1UUID: string
@@ -106,12 +68,14 @@ describe('Test video playlists', function () {
 
   let nsfwVideoServer1: number
 
-  let userAccessTokenServer1: string
+  let userTokenServer1: string
+
+  let commands: PlaylistsCommand[]
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(3, { transcoding: { enabled: false } })
+    servers = await createMultipleServers(3, { transcoding: { enabled: false } })
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -122,86 +86,78 @@ describe('Test video playlists', function () {
     // Server 1 and server 3 follow each other
     await doubleFollow(servers[0], servers[2])
 
+    commands = servers.map(s => s.playlists)
+
     {
-      servers[0].videos = []
-      servers[1].videos = []
-      servers[2].videos = []
+      servers[0].store.videos = []
+      servers[1].store.videos = []
+      servers[2].store.videos = []
 
       for (const server of servers) {
         for (let i = 0; i < 7; i++) {
           const name = `video ${i} server ${server.serverNumber}`
-          const resVideo = await uploadVideo(server.url, server.accessToken, { name, nsfw: false })
+          const video = await server.videos.upload({ attributes: { name, nsfw: false } })
 
-          server.videos.push(resVideo.body.video)
+          server.store.videos.push(video)
         }
       }
     }
 
-    nsfwVideoServer1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'NSFW video', nsfw: true })).id
+    nsfwVideoServer1 = (await servers[0].videos.quickUpload({ name: 'NSFW video', nsfw: true })).id
 
-    {
-      await createUser({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        username: 'user1',
-        password: 'password'
-      })
-      userAccessTokenServer1 = await getAccessToken(servers[0].url, 'user1', 'password')
-    }
+    userTokenServer1 = await servers[0].users.generateUserAndToken('user1')
 
     await waitJobs(servers)
   })
 
   describe('Get default playlists', function () {
+
     it('Should list video playlist privacies', async function () {
-      const res = await getVideoPlaylistPrivacies(servers[0].url)
+      const privacies = await commands[0].getPrivacies()
 
-      const privacies = res.body
       expect(Object.keys(privacies)).to.have.length.at.least(3)
-
       expect(privacies[3]).to.equal('Private')
     })
 
     it('Should list watch later playlist', async function () {
-      const url = servers[0].url
-      const accessToken = servers[0].accessToken
+      const token = servers[0].accessToken
 
       {
-        const res = await getAccountPlaylistsListWithToken(url, accessToken, 'root', 0, 5, VideoPlaylistType.WATCH_LATER)
+        const body = await commands[0].listByAccount({ token, handle: 'root', playlistType: VideoPlaylistType.WATCH_LATER })
 
-        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 playlist: VideoPlaylist = res.body.data[0]
+        const playlist = body.data[0]
         expect(playlist.displayName).to.equal('Watch later')
         expect(playlist.type.id).to.equal(VideoPlaylistType.WATCH_LATER)
         expect(playlist.type.label).to.equal('Watch later')
       }
 
       {
-        const res = await getAccountPlaylistsListWithToken(url, accessToken, 'root', 0, 5, VideoPlaylistType.REGULAR)
+        const body = await commands[0].listByAccount({ token, handle: 'root', playlistType: VideoPlaylistType.REGULAR })
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        expect(body.total).to.equal(0)
+        expect(body.data).to.have.lengthOf(0)
       }
 
       {
-        const res = await getAccountPlaylistsList(url, 'root', 0, 5)
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        const body = await commands[0].listByAccount({ handle: 'root' })
+        expect(body.total).to.equal(0)
+        expect(body.data).to.have.lengthOf(0)
       }
     })
 
     it('Should get private playlist for a classic user', async function () {
-      const token = await generateUserAccessToken(servers[0], 'toto')
+      const token = await servers[0].users.generateUserAndToken('toto')
 
-      const res = await getAccountPlaylistsListWithToken(servers[0].url, token, 'toto', 0, 5)
+      const body = await commands[0].listByAccount({ token, handle: 'toto' })
 
-      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 playlistId = res.body.data[0].id
-      await getPlaylistVideos(servers[0].url, token, playlistId, 0, 5)
+      const playlistId = body.data[0].id
+      await commands[0].listVideos({ token, playlistId })
     })
   })
 
@@ -210,15 +166,13 @@ describe('Test video playlists', function () {
     it('Should create a playlist on server 1 and have the playlist on server 2 and 3', async function () {
       this.timeout(30000)
 
-      await createVideoPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistAttrs: {
+      await commands[0].create({
+        attributes: {
           displayName: 'my super playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
           description: 'my super description',
           thumbnailfile: 'thumbnail.jpg',
-          videoChannelId: servers[0].videoChannel.id
+          videoChannelId: servers[0].store.channel.id
         }
       })
 
@@ -227,14 +181,13 @@ describe('Test video playlists', function () {
       await wait(3000)
 
       for (const server of servers) {
-        const res = await getVideoPlaylistsList(server.url, 0, 5)
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        const body = await server.playlists.list({ start: 0, count: 5 })
+        expect(body.total).to.equal(1)
+        expect(body.data).to.have.lengthOf(1)
 
-        const playlistFromList = res.body.data[0] as VideoPlaylist
+        const playlistFromList = body.data[0]
 
-        const res2 = await getVideoPlaylist(server.url, playlistFromList.uuid)
-        const playlistFromGet = res2.body as VideoPlaylist
+        const playlistFromGet = await server.playlists.get({ playlistId: playlistFromList.uuid })
 
         for (const playlist of [ playlistFromGet, playlistFromList ]) {
           expect(playlist.id).to.be.a('number')
@@ -264,46 +217,38 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        const res = await createVideoPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
-          playlistAttrs: {
+        const playlist = await servers[1].playlists.create({
+          attributes: {
             displayName: 'playlist 2',
             privacy: VideoPlaylistPrivacy.PUBLIC,
-            videoChannelId: servers[1].videoChannel.id
+            videoChannelId: servers[1].store.channel.id
           }
         })
-        playlistServer2Id1 = res.body.videoPlaylist.id
+        playlistServer2Id1 = playlist.id
       }
 
       {
-        const res = await createVideoPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
-          playlistAttrs: {
+        const playlist = await servers[1].playlists.create({
+          attributes: {
             displayName: 'playlist 3',
             privacy: VideoPlaylistPrivacy.PUBLIC,
             thumbnailfile: 'thumbnail.jpg',
-            videoChannelId: servers[1].videoChannel.id
+            videoChannelId: servers[1].store.channel.id
           }
         })
 
-        playlistServer2Id2 = res.body.videoPlaylist.id
-        playlistServer2UUID2 = res.body.videoPlaylist.uuid
+        playlistServer2Id2 = playlist.id
+        playlistServer2UUID2 = playlist.uuid
       }
 
       for (const id of [ playlistServer2Id1, playlistServer2Id2 ]) {
-        await addVideoInPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
+        await servers[1].playlists.addElement({
           playlistId: id,
-          elementAttrs: { videoId: servers[1].videos[0].id, startTimestamp: 1, stopTimestamp: 2 }
+          attributes: { videoId: servers[1].store.videos[0].id, startTimestamp: 1, stopTimestamp: 2 }
         })
-        await addVideoInPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
+        await servers[1].playlists.addElement({
           playlistId: id,
-          elementAttrs: { videoId: servers[1].videos[1].id }
+          attributes: { videoId: servers[1].store.videos[1].id }
         })
       }
 
@@ -311,20 +256,20 @@ describe('Test video playlists', function () {
       await wait(3000)
 
       for (const server of [ servers[0], servers[1] ]) {
-        const res = await getVideoPlaylistsList(server.url, 0, 5)
+        const body = await server.playlists.list({ start: 0, count: 5 })
 
-        const playlist2 = res.body.data.find(p => p.displayName === 'playlist 2')
+        const playlist2 = body.data.find(p => p.displayName === 'playlist 2')
         expect(playlist2).to.not.be.undefined
         await testImage(server.url, 'thumbnail-playlist', playlist2.thumbnailPath)
 
-        const playlist3 = res.body.data.find(p => p.displayName === 'playlist 3')
+        const playlist3 = body.data.find(p => p.displayName === 'playlist 3')
         expect(playlist3).to.not.be.undefined
         await testImage(server.url, 'thumbnail', playlist3.thumbnailPath)
       }
 
-      const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
-      expect(res.body.data.find(p => p.displayName === 'playlist 2')).to.be.undefined
-      expect(res.body.data.find(p => p.displayName === 'playlist 3')).to.be.undefined
+      const body = await servers[2].playlists.list({ start: 0, count: 5 })
+      expect(body.data.find(p => p.displayName === 'playlist 2')).to.be.undefined
+      expect(body.data.find(p => p.displayName === 'playlist 3')).to.be.undefined
     })
 
     it('Should have the playlist on server 3 after a new follow', async function () {
@@ -333,13 +278,13 @@ describe('Test video playlists', function () {
       // Server 2 and server 3 follow each other
       await doubleFollow(servers[1], servers[2])
 
-      const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
+      const body = await servers[2].playlists.list({ start: 0, count: 5 })
 
-      const playlist2 = res.body.data.find(p => p.displayName === 'playlist 2')
+      const playlist2 = body.data.find(p => p.displayName === 'playlist 2')
       expect(playlist2).to.not.be.undefined
       await testImage(servers[2].url, 'thumbnail-playlist', playlist2.thumbnailPath)
 
-      expect(res.body.data.find(p => p.displayName === 'playlist 3')).to.not.be.undefined
+      expect(body.data.find(p => p.displayName === 'playlist 3')).to.not.be.undefined
     })
   })
 
@@ -349,22 +294,20 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        const res = await getVideoPlaylistsList(servers[2].url, 1, 2, 'createdAt')
-
-        expect(res.body.total).to.equal(3)
+        const body = await servers[2].playlists.list({ start: 1, count: 2, sort: 'createdAt' })
+        expect(body.total).to.equal(3)
 
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(2)
         expect(data[0].displayName).to.equal('playlist 2')
         expect(data[1].displayName).to.equal('playlist 3')
       }
 
       {
-        const res = await getVideoPlaylistsList(servers[2].url, 1, 2, '-createdAt')
+        const body = await servers[2].playlists.list({ start: 1, count: 2, sort: '-createdAt' })
+        expect(body.total).to.equal(3)
 
-        expect(res.body.total).to.equal(3)
-
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(2)
         expect(data[0].displayName).to.equal('playlist 2')
         expect(data[1].displayName).to.equal('my super playlist')
@@ -375,11 +318,10 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        const res = await getVideoChannelPlaylistsList(servers[0].url, 'root_channel', 0, 2, '-createdAt')
-
-        expect(res.body.total).to.equal(1)
+        const body = await commands[0].listByChannel({ handle: 'root_channel', start: 0, count: 2, sort: '-createdAt' })
+        expect(body.total).to.equal(1)
 
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(1)
         expect(data[0].displayName).to.equal('my super playlist')
       }
@@ -389,41 +331,37 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        const res = await getAccountPlaylistsList(servers[1].url, 'root', 1, 2, '-createdAt')
+        const body = await servers[1].playlists.listByAccount({ handle: 'root', start: 1, count: 2, sort: '-createdAt' })
+        expect(body.total).to.equal(2)
 
-        expect(res.body.total).to.equal(2)
-
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(1)
         expect(data[0].displayName).to.equal('playlist 2')
       }
 
       {
-        const res = await getAccountPlaylistsList(servers[1].url, 'root', 1, 2, 'createdAt')
-
-        expect(res.body.total).to.equal(2)
+        const body = await servers[1].playlists.listByAccount({ handle: 'root', start: 1, count: 2, sort: 'createdAt' })
+        expect(body.total).to.equal(2)
 
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(1)
         expect(data[0].displayName).to.equal('playlist 3')
       }
 
       {
-        const res = await getAccountPlaylistsList(servers[1].url, 'root', 0, 10, 'createdAt', '3')
+        const body = await servers[1].playlists.listByAccount({ handle: 'root', sort: 'createdAt', search: '3' })
+        expect(body.total).to.equal(1)
 
-        expect(res.body.total).to.equal(1)
-
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(1)
         expect(data[0].displayName).to.equal('playlist 3')
       }
 
       {
-        const res = await getAccountPlaylistsList(servers[1].url, 'root', 0, 10, 'createdAt', '4')
-
-        expect(res.body.total).to.equal(0)
+        const body = await servers[1].playlists.listByAccount({ handle: 'root', sort: 'createdAt', search: '4' })
+        expect(body.total).to.equal(0)
 
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(0)
       }
     })
@@ -437,28 +375,22 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        const res = await createVideoPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
-          playlistAttrs: {
+        unlistedPlaylist = await servers[1].playlists.create({
+          attributes: {
             displayName: 'playlist unlisted',
             privacy: VideoPlaylistPrivacy.UNLISTED,
-            videoChannelId: servers[1].videoChannel.id
+            videoChannelId: servers[1].store.channel.id
           }
         })
-        unlistedPlaylist = res.body.videoPlaylist
       }
 
       {
-        const res = await createVideoPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
-          playlistAttrs: {
+        privatePlaylist = await servers[1].playlists.create({
+          attributes: {
             displayName: 'playlist private',
             privacy: VideoPlaylistPrivacy.PRIVATE
           }
         })
-        privatePlaylist = res.body.videoPlaylist
       }
 
       await waitJobs(servers)
@@ -468,15 +400,15 @@ describe('Test video playlists', function () {
     it('Should not list unlisted or private playlists', async function () {
       for (const server of servers) {
         const results = [
-          await getAccountPlaylistsList(server.url, 'root@localhost:' + servers[1].port, 0, 5, '-createdAt'),
-          await getVideoPlaylistsList(server.url, 0, 2, '-createdAt')
+          await server.playlists.listByAccount({ handle: 'root@localhost:' + servers[1].port, sort: '-createdAt' }),
+          await server.playlists.list({ start: 0, count: 2, sort: '-createdAt' })
         ]
 
-        expect(results[0].body.total).to.equal(2)
-        expect(results[1].body.total).to.equal(3)
+        expect(results[0].total).to.equal(2)
+        expect(results[1].total).to.equal(3)
 
-        for (const res of results) {
-          const data: VideoPlaylist[] = res.body.data
+        for (const body of results) {
+          const data = body.data
           expect(data).to.have.lengthOf(2)
           expect(data[0].displayName).to.equal('playlist 3')
           expect(data[1].displayName).to.equal('playlist 2')
@@ -485,23 +417,23 @@ describe('Test video playlists', function () {
     })
 
     it('Should not get unlisted playlist using only the id', async function () {
-      await getVideoPlaylist(servers[1].url, unlistedPlaylist.id, 404)
+      await servers[1].playlists.get({ playlistId: unlistedPlaylist.id, expectedStatus: 404 })
     })
 
     it('Should get unlisted plyaylist using uuid or shortUUID', async function () {
-      await getVideoPlaylist(servers[1].url, unlistedPlaylist.uuid)
-      await getVideoPlaylist(servers[1].url, unlistedPlaylist.shortUUID)
+      await servers[1].playlists.get({ playlistId: unlistedPlaylist.uuid })
+      await servers[1].playlists.get({ playlistId: unlistedPlaylist.shortUUID })
     })
 
     it('Should not get private playlist without token', async function () {
       for (const id of [ privatePlaylist.id, privatePlaylist.uuid, privatePlaylist.shortUUID ]) {
-        await getVideoPlaylist(servers[1].url, id, 401)
+        await servers[1].playlists.get({ playlistId: id, expectedStatus: 401 })
       }
     })
 
     it('Should get private playlist with a token', async function () {
       for (const id of [ privatePlaylist.id, privatePlaylist.uuid, privatePlaylist.shortUUID ]) {
-        await getVideoPlaylistWithToken(servers[1].url, servers[1].accessToken, id)
+        await servers[1].playlists.get({ token: servers[1].accessToken, playlistId: id })
       }
     })
   })
@@ -511,15 +443,13 @@ describe('Test video playlists', function () {
     it('Should update a playlist', async function () {
       this.timeout(30000)
 
-      await updateVideoPlaylist({
-        url: servers[1].url,
-        token: servers[1].accessToken,
-        playlistAttrs: {
+      await servers[1].playlists.update({
+        attributes: {
           displayName: 'playlist 3 updated',
           description: 'description updated',
           privacy: VideoPlaylistPrivacy.UNLISTED,
           thumbnailfile: 'thumbnail.jpg',
-          videoChannelId: servers[1].videoChannel.id
+          videoChannelId: servers[1].store.channel.id
         },
         playlistId: playlistServer2Id2
       })
@@ -527,8 +457,7 @@ describe('Test video playlists', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideoPlaylist(server.url, playlistServer2UUID2)
-        const playlist: VideoPlaylist = res.body
+        const playlist = await server.playlists.get({ playlistId: playlistServer2UUID2 })
 
         expect(playlist.displayName).to.equal('playlist 3 updated')
         expect(playlist.description).to.equal('description updated')
@@ -554,39 +483,37 @@ describe('Test video playlists', function () {
     it('Should create a playlist containing different startTimestamp/endTimestamp videos', async function () {
       this.timeout(30000)
 
-      const addVideo = (elementAttrs: any) => {
-        return addVideoInPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistId: playlistServer1Id, elementAttrs })
+      const addVideo = (attributes: any) => {
+        return commands[0].addElement({ playlistId: playlistServer1Id, attributes })
       }
 
-      const res = await createVideoPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistAttrs: {
+      const playlist = await commands[0].create({
+        attributes: {
           displayName: 'playlist 4',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: servers[0].videoChannel.id
+          videoChannelId: servers[0].store.channel.id
         }
       })
 
-      playlistServer1Id = res.body.videoPlaylist.id
-      playlistServer1UUID = res.body.videoPlaylist.uuid
+      playlistServer1Id = playlist.id
+      playlistServer1UUID = playlist.uuid
 
-      await addVideo({ videoId: servers[0].videos[0].uuid, startTimestamp: 15, stopTimestamp: 28 })
-      await addVideo({ videoId: servers[2].videos[1].uuid, startTimestamp: 35 })
-      await addVideo({ videoId: servers[2].videos[2].uuid })
+      await addVideo({ videoId: servers[0].store.videos[0].uuid, startTimestamp: 15, stopTimestamp: 28 })
+      await addVideo({ videoId: servers[2].store.videos[1].uuid, startTimestamp: 35 })
+      await addVideo({ videoId: servers[2].store.videos[2].uuid })
       {
-        const res = await addVideo({ videoId: servers[0].videos[3].uuid, stopTimestamp: 35 })
-        playlistElementServer1Video4 = res.body.videoPlaylistElement.id
+        const element = await addVideo({ videoId: servers[0].store.videos[3].uuid, stopTimestamp: 35 })
+        playlistElementServer1Video4 = element.id
       }
 
       {
-        const res = await addVideo({ videoId: servers[0].videos[4].uuid, startTimestamp: 45, stopTimestamp: 60 })
-        playlistElementServer1Video5 = res.body.videoPlaylistElement.id
+        const element = await addVideo({ videoId: servers[0].store.videos[4].uuid, startTimestamp: 45, stopTimestamp: 60 })
+        playlistElementServer1Video5 = element.id
       }
 
       {
-        const res = await addVideo({ videoId: nsfwVideoServer1, startTimestamp: 5 })
-        playlistElementNSFW = res.body.videoPlaylistElement.id
+        const element = await addVideo({ videoId: nsfwVideoServer1, startTimestamp: 5 })
+        playlistElementNSFW = element.id
 
         await addVideo({ videoId: nsfwVideoServer1, startTimestamp: 4 })
         await addVideo({ videoId: nsfwVideoServer1 })
@@ -599,64 +526,68 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       for (const server of servers) {
-        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
-
-        expect(res.body.total).to.equal(8)
-
-        const videoElements: VideoPlaylistElement[] = res.body.data
-        expect(videoElements).to.have.lengthOf(8)
-
-        expect(videoElements[0].video.name).to.equal('video 0 server 1')
-        expect(videoElements[0].position).to.equal(1)
-        expect(videoElements[0].startTimestamp).to.equal(15)
-        expect(videoElements[0].stopTimestamp).to.equal(28)
-
-        expect(videoElements[1].video.name).to.equal('video 1 server 3')
-        expect(videoElements[1].position).to.equal(2)
-        expect(videoElements[1].startTimestamp).to.equal(35)
-        expect(videoElements[1].stopTimestamp).to.be.null
-
-        expect(videoElements[2].video.name).to.equal('video 2 server 3')
-        expect(videoElements[2].position).to.equal(3)
-        expect(videoElements[2].startTimestamp).to.be.null
-        expect(videoElements[2].stopTimestamp).to.be.null
-
-        expect(videoElements[3].video.name).to.equal('video 3 server 1')
-        expect(videoElements[3].position).to.equal(4)
-        expect(videoElements[3].startTimestamp).to.be.null
-        expect(videoElements[3].stopTimestamp).to.equal(35)
-
-        expect(videoElements[4].video.name).to.equal('video 4 server 1')
-        expect(videoElements[4].position).to.equal(5)
-        expect(videoElements[4].startTimestamp).to.equal(45)
-        expect(videoElements[4].stopTimestamp).to.equal(60)
-
-        expect(videoElements[5].video.name).to.equal('NSFW video')
-        expect(videoElements[5].position).to.equal(6)
-        expect(videoElements[5].startTimestamp).to.equal(5)
-        expect(videoElements[5].stopTimestamp).to.be.null
-
-        expect(videoElements[6].video.name).to.equal('NSFW video')
-        expect(videoElements[6].position).to.equal(7)
-        expect(videoElements[6].startTimestamp).to.equal(4)
-        expect(videoElements[6].stopTimestamp).to.be.null
-
-        expect(videoElements[7].video.name).to.equal('NSFW video')
-        expect(videoElements[7].position).to.equal(8)
-        expect(videoElements[7].startTimestamp).to.be.null
-        expect(videoElements[7].stopTimestamp).to.be.null
-
-        const res3 = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 2)
-        expect(res3.body.data).to.have.lengthOf(2)
+        {
+          const body = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
+
+          expect(body.total).to.equal(8)
+
+          const videoElements = body.data
+          expect(videoElements).to.have.lengthOf(8)
+
+          expect(videoElements[0].video.name).to.equal('video 0 server 1')
+          expect(videoElements[0].position).to.equal(1)
+          expect(videoElements[0].startTimestamp).to.equal(15)
+          expect(videoElements[0].stopTimestamp).to.equal(28)
+
+          expect(videoElements[1].video.name).to.equal('video 1 server 3')
+          expect(videoElements[1].position).to.equal(2)
+          expect(videoElements[1].startTimestamp).to.equal(35)
+          expect(videoElements[1].stopTimestamp).to.be.null
+
+          expect(videoElements[2].video.name).to.equal('video 2 server 3')
+          expect(videoElements[2].position).to.equal(3)
+          expect(videoElements[2].startTimestamp).to.be.null
+          expect(videoElements[2].stopTimestamp).to.be.null
+
+          expect(videoElements[3].video.name).to.equal('video 3 server 1')
+          expect(videoElements[3].position).to.equal(4)
+          expect(videoElements[3].startTimestamp).to.be.null
+          expect(videoElements[3].stopTimestamp).to.equal(35)
+
+          expect(videoElements[4].video.name).to.equal('video 4 server 1')
+          expect(videoElements[4].position).to.equal(5)
+          expect(videoElements[4].startTimestamp).to.equal(45)
+          expect(videoElements[4].stopTimestamp).to.equal(60)
+
+          expect(videoElements[5].video.name).to.equal('NSFW video')
+          expect(videoElements[5].position).to.equal(6)
+          expect(videoElements[5].startTimestamp).to.equal(5)
+          expect(videoElements[5].stopTimestamp).to.be.null
+
+          expect(videoElements[6].video.name).to.equal('NSFW video')
+          expect(videoElements[6].position).to.equal(7)
+          expect(videoElements[6].startTimestamp).to.equal(4)
+          expect(videoElements[6].stopTimestamp).to.be.null
+
+          expect(videoElements[7].video.name).to.equal('NSFW video')
+          expect(videoElements[7].position).to.equal(8)
+          expect(videoElements[7].startTimestamp).to.be.null
+          expect(videoElements[7].stopTimestamp).to.be.null
+        }
+
+        {
+          const body = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 2 })
+          expect(body.data).to.have.lengthOf(2)
+        }
       }
     })
   })
 
   describe('Element type', function () {
-    let groupUser1: ServerInfo[]
-    let groupWithoutToken1: ServerInfo[]
-    let group1: ServerInfo[]
-    let group2: ServerInfo[]
+    let groupUser1: PeerTubeServer[]
+    let groupWithoutToken1: PeerTubeServer[]
+    let group1: PeerTubeServer[]
+    let group2: PeerTubeServer[]
 
     let video1: string
     let video2: string
@@ -665,31 +596,30 @@ describe('Test video playlists', function () {
     before(async function () {
       this.timeout(60000)
 
-      groupUser1 = [ Object.assign({}, servers[0], { accessToken: userAccessTokenServer1 }) ]
+      groupUser1 = [ Object.assign({}, servers[0], { accessToken: userTokenServer1 }) ]
       groupWithoutToken1 = [ Object.assign({}, servers[0], { accessToken: undefined }) ]
       group1 = [ servers[0] ]
       group2 = [ servers[1], servers[2] ]
 
-      const res = await createVideoPlaylist({
-        url: servers[0].url,
-        token: userAccessTokenServer1,
-        playlistAttrs: {
+      const playlist = await commands[0].create({
+        token: userTokenServer1,
+        attributes: {
           displayName: 'playlist 56',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: servers[0].videoChannel.id
+          videoChannelId: servers[0].store.channel.id
         }
       })
 
-      const playlistServer1Id2 = res.body.videoPlaylist.id
-      playlistServer1UUID2 = res.body.videoPlaylist.uuid
+      const playlistServer1Id2 = playlist.id
+      playlistServer1UUID2 = playlist.uuid
 
-      const addVideo = (elementAttrs: any) => {
-        return addVideoInPlaylist({ url: servers[0].url, token: userAccessTokenServer1, playlistId: playlistServer1Id2, elementAttrs })
+      const addVideo = (attributes: any) => {
+        return commands[0].addElement({ token: userTokenServer1, playlistId: playlistServer1Id2, attributes })
       }
 
-      video1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 89', token: userAccessTokenServer1 })).uuid
-      video2 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video 90' })).uuid
-      video3 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 91', nsfw: true })).uuid
+      video1 = (await servers[0].videos.quickUpload({ name: 'video 89', token: userTokenServer1 })).uuid
+      video2 = (await servers[1].videos.quickUpload({ name: 'video 90' })).uuid
+      video3 = (await servers[0].videos.quickUpload({ name: 'video 91', nsfw: true })).uuid
 
       await waitJobs(servers)
 
@@ -707,7 +637,7 @@ describe('Test video playlists', function () {
       const position = 1
 
       {
-        await updateVideo(servers[0].url, servers[0].accessToken, video1, { privacy: VideoPrivacy.PRIVATE })
+        await servers[0].videos.update({ id: video1, attributes: { privacy: VideoPrivacy.PRIVATE } })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
@@ -717,7 +647,7 @@ describe('Test video playlists', function () {
       }
 
       {
-        await updateVideo(servers[0].url, servers[0].accessToken, video1, { privacy: VideoPrivacy.PUBLIC })
+        await servers[0].videos.update({ id: video1, attributes: { privacy: VideoPrivacy.PUBLIC } })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
@@ -735,7 +665,7 @@ describe('Test video playlists', function () {
       const position = 1
 
       {
-        await addVideoToBlacklist(servers[0].url, servers[0].accessToken, video1, 'reason', true)
+        await servers[0].blacklist.add({ videoId: video1, reason: 'reason', unfederate: true })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
@@ -745,7 +675,7 @@ describe('Test video playlists', function () {
       }
 
       {
-        await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, video1)
+        await servers[0].blacklist.remove({ videoId: video1 })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
@@ -759,56 +689,58 @@ describe('Test video playlists', function () {
     it('Should update the element type if the account or server of the video is blocked', async function () {
       this.timeout(90000)
 
+      const command = servers[0].blocklist
+
       const name = 'video 90'
       const position = 2
 
       {
-        await addAccountToAccountBlocklist(servers[0].url, userAccessTokenServer1, 'root@localhost:' + servers[1].port)
+        await command.addToMyBlocklist({ token: userTokenServer1, account: 'root@localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 
-        await removeAccountFromAccountBlocklist(servers[0].url, userAccessTokenServer1, 'root@localhost:' + servers[1].port)
+        await command.removeFromMyBlocklist({ token: userTokenServer1, account: 'root@localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
       }
 
       {
-        await addServerToAccountBlocklist(servers[0].url, userAccessTokenServer1, 'localhost:' + servers[1].port)
+        await command.addToMyBlocklist({ token: userTokenServer1, server: 'localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 
-        await removeServerFromAccountBlocklist(servers[0].url, userAccessTokenServer1, 'localhost:' + servers[1].port)
+        await command.removeFromMyBlocklist({ token: userTokenServer1, server: 'localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
       }
 
       {
-        await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, 'root@localhost:' + servers[1].port)
+        await command.addToServerBlocklist({ account: 'root@localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 
-        await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, 'root@localhost:' + servers[1].port)
+        await command.removeFromServerBlocklist({ account: 'root@localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
       }
 
       {
-        await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.addToServerBlocklist({ server: 'localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 
-        await removeServerFromServerBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.removeFromServerBlocklist({ server: 'localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
@@ -816,10 +748,10 @@ describe('Test video playlists', function () {
     })
 
     it('Should hide the video if it is NSFW', async function () {
-      const res = await getPlaylistVideos(servers[0].url, userAccessTokenServer1, playlistServer1UUID2, 0, 10, { nsfw: false })
-      expect(res.body.total).to.equal(3)
+      const body = await commands[0].listVideos({ token: userTokenServer1, playlistId: playlistServer1UUID2, query: { nsfw: 'false' } })
+      expect(body.total).to.equal(3)
 
-      const elements: VideoPlaylistElement[] = res.body.data
+      const elements = body.data
       const element = elements.find(e => e.position === 3)
 
       expect(element).to.exist
@@ -835,11 +767,9 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        await reorderVideosPlaylist({
-          url: servers[0].url,
-          token: servers[0].accessToken,
+        await commands[0].reorderElements({
           playlistId: playlistServer1Id,
-          elementAttrs: {
+          attributes: {
             startPosition: 2,
             insertAfterPosition: 3
           }
@@ -848,8 +778,8 @@ describe('Test video playlists', function () {
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
-          const names = (res.body.data as VideoPlaylistElement[]).map(v => v.video.name)
+          const body = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
+          const names = body.data.map(v => v.video.name)
 
           expect(names).to.deep.equal([
             'video 0 server 1',
@@ -865,11 +795,9 @@ describe('Test video playlists', function () {
       }
 
       {
-        await reorderVideosPlaylist({
-          url: servers[0].url,
-          token: servers[0].accessToken,
+        await commands[0].reorderElements({
           playlistId: playlistServer1Id,
-          elementAttrs: {
+          attributes: {
             startPosition: 1,
             reorderLength: 3,
             insertAfterPosition: 4
@@ -879,8 +807,8 @@ describe('Test video playlists', function () {
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
-          const names = (res.body.data as VideoPlaylistElement[]).map(v => v.video.name)
+          const body = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
+          const names = body.data.map(v => v.video.name)
 
           expect(names).to.deep.equal([
             'video 3 server 1',
@@ -896,11 +824,9 @@ describe('Test video playlists', function () {
       }
 
       {
-        await reorderVideosPlaylist({
-          url: servers[0].url,
-          token: servers[0].accessToken,
+        await commands[0].reorderElements({
           playlistId: playlistServer1Id,
-          elementAttrs: {
+          attributes: {
             startPosition: 6,
             insertAfterPosition: 3
           }
@@ -909,8 +835,7 @@ describe('Test video playlists', function () {
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
-          const elements: VideoPlaylistElement[] = res.body.data
+          const { data: elements } = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
           const names = elements.map(v => v.video.name)
 
           expect(names).to.deep.equal([
@@ -934,22 +859,18 @@ describe('Test video playlists', function () {
     it('Should update startTimestamp/endTimestamp of some elements', async function () {
       this.timeout(30000)
 
-      await updateVideoPlaylistElement({
-        url: servers[0].url,
-        token: servers[0].accessToken,
+      await commands[0].updateElement({
         playlistId: playlistServer1Id,
-        playlistElementId: playlistElementServer1Video4,
-        elementAttrs: {
+        elementId: playlistElementServer1Video4,
+        attributes: {
           startTimestamp: 1
         }
       })
 
-      await updateVideoPlaylistElement({
-        url: servers[0].url,
-        token: servers[0].accessToken,
+      await commands[0].updateElement({
         playlistId: playlistServer1Id,
-        playlistElementId: playlistElementServer1Video5,
-        elementAttrs: {
+        elementId: playlistElementServer1Video5,
+        attributes: {
           stopTimestamp: null
         }
       })
@@ -957,8 +878,7 @@ describe('Test video playlists', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
-        const elements: VideoPlaylistElement[] = res.body.data
+        const { data: elements } = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
 
         expect(elements[0].video.name).to.equal('video 3 server 1')
         expect(elements[0].position).to.equal(1)
@@ -974,17 +894,16 @@ describe('Test video playlists', function () {
 
     it('Should check videos existence in my playlist', async function () {
       const videoIds = [
-        servers[0].videos[0].id,
+        servers[0].store.videos[0].id,
         42000,
-        servers[0].videos[3].id,
+        servers[0].store.videos[3].id,
         43000,
-        servers[0].videos[4].id
+        servers[0].store.videos[4].id
       ]
-      const res = await doVideosExistInMyPlaylist(servers[0].url, servers[0].accessToken, videoIds)
-      const obj = res.body as VideoExistInPlaylist
+      const obj = await commands[0].videosExist({ videoIds })
 
       {
-        const elem = obj[servers[0].videos[0].id]
+        const elem = obj[servers[0].store.videos[0].id]
         expect(elem).to.have.lengthOf(1)
         expect(elem[0].playlistElementId).to.exist
         expect(elem[0].playlistId).to.equal(playlistServer1Id)
@@ -993,7 +912,7 @@ describe('Test video playlists', function () {
       }
 
       {
-        const elem = obj[servers[0].videos[3].id]
+        const elem = obj[servers[0].store.videos[3].id]
         expect(elem).to.have.lengthOf(1)
         expect(elem[0].playlistElementId).to.equal(playlistElementServer1Video4)
         expect(elem[0].playlistId).to.equal(playlistServer1Id)
@@ -1002,7 +921,7 @@ describe('Test video playlists', function () {
       }
 
       {
-        const elem = obj[servers[0].videos[4].id]
+        const elem = obj[servers[0].store.videos[4].id]
         expect(elem).to.have.lengthOf(1)
         expect(elem[0].playlistId).to.equal(playlistServer1Id)
         expect(elem[0].startTimestamp).to.equal(45)
@@ -1015,42 +934,29 @@ describe('Test video playlists', function () {
 
     it('Should automatically update updatedAt field of playlists', async function () {
       const server = servers[1]
-      const videoId = servers[1].videos[5].id
+      const videoId = servers[1].store.videos[5].id
 
       async function getPlaylistNames () {
-        const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root', 0, 5, undefined, '-updatedAt')
+        const { data } = await server.playlists.listByAccount({ token: server.accessToken, handle: 'root', sort: '-updatedAt' })
 
-        return (res.body.data as VideoPlaylist[]).map(p => p.displayName)
+        return data.map(p => p.displayName)
       }
 
-      const elementAttrs = { videoId }
-      const res1 = await addVideoInPlaylist({ url: server.url, token: server.accessToken, playlistId: playlistServer2Id1, elementAttrs })
-      const res2 = await addVideoInPlaylist({ url: server.url, token: server.accessToken, playlistId: playlistServer2Id2, elementAttrs })
-
-      const element1 = res1.body.videoPlaylistElement.id
-      const element2 = res2.body.videoPlaylistElement.id
+      const attributes = { videoId }
+      const element1 = await server.playlists.addElement({ playlistId: playlistServer2Id1, attributes })
+      const element2 = await server.playlists.addElement({ playlistId: playlistServer2Id2, attributes })
 
       const names1 = await getPlaylistNames()
       expect(names1[0]).to.equal('playlist 3 updated')
       expect(names1[1]).to.equal('playlist 2')
 
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlistServer2Id1,
-        playlistElementId: element1
-      })
+      await server.playlists.removeElement({ playlistId: playlistServer2Id1, elementId: element1.id })
 
       const names2 = await getPlaylistNames()
       expect(names2[0]).to.equal('playlist 2')
       expect(names2[1]).to.equal('playlist 3 updated')
 
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlistServer2Id2,
-        playlistElementId: element2
-      })
+      await server.playlists.removeElement({ playlistId: playlistServer2Id2, elementId: element2.id })
 
       const names3 = await getPlaylistNames()
       expect(names3[0]).to.equal('playlist 3 updated')
@@ -1060,28 +966,16 @@ describe('Test video playlists', function () {
     it('Should delete some elements', async function () {
       this.timeout(30000)
 
-      await removeVideoFromPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistId: playlistServer1Id,
-        playlistElementId: playlistElementServer1Video4
-      })
-
-      await removeVideoFromPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistId: playlistServer1Id,
-        playlistElementId: playlistElementNSFW
-      })
+      await commands[0].removeElement({ playlistId: playlistServer1Id, elementId: playlistElementServer1Video4 })
+      await commands[0].removeElement({ playlistId: playlistServer1Id, elementId: playlistElementNSFW })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+        const body = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
+        expect(body.total).to.equal(6)
 
-        expect(res.body.total).to.equal(6)
-
-        const elements: VideoPlaylistElement[] = res.body.data
+        const elements = body.data
         expect(elements).to.have.lengthOf(6)
 
         expect(elements[0].video.name).to.equal('video 0 server 1')
@@ -1107,34 +1001,31 @@ describe('Test video playlists', function () {
     it('Should be able to create a public playlist, and set it to private', async function () {
       this.timeout(30000)
 
-      const res = await createVideoPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistAttrs: {
+      const videoPlaylistIds = await commands[0].create({
+        attributes: {
           displayName: 'my super public playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: servers[0].videoChannel.id
+          videoChannelId: servers[0].store.channel.id
         }
       })
-      const videoPlaylistIds = res.body.videoPlaylist
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        await getVideoPlaylist(server.url, videoPlaylistIds.uuid, HttpStatusCode.OK_200)
+        await server.playlists.get({ playlistId: videoPlaylistIds.uuid, expectedStatus: HttpStatusCode.OK_200 })
       }
 
-      const playlistAttrs = { privacy: VideoPlaylistPrivacy.PRIVATE }
-      await updateVideoPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistId: videoPlaylistIds.id, playlistAttrs })
+      const attributes = { privacy: VideoPlaylistPrivacy.PRIVATE }
+      await commands[0].update({ playlistId: videoPlaylistIds.id, attributes })
 
       await waitJobs(servers)
 
       for (const server of [ servers[1], servers[2] ]) {
-        await getVideoPlaylist(server.url, videoPlaylistIds.uuid, HttpStatusCode.NOT_FOUND_404)
+        await server.playlists.get({ playlistId: videoPlaylistIds.uuid, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
-      await getVideoPlaylist(servers[0].url, videoPlaylistIds.uuid, HttpStatusCode.UNAUTHORIZED_401)
 
-      await getVideoPlaylistWithToken(servers[0].url, servers[0].accessToken, videoPlaylistIds.uuid, HttpStatusCode.OK_200)
+      await commands[0].get({ playlistId: videoPlaylistIds.uuid, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+      await commands[0].get({ token: servers[0].accessToken, playlistId: videoPlaylistIds.uuid, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -1143,12 +1034,12 @@ describe('Test video playlists', function () {
     it('Should delete the playlist on server 1 and delete on server 2 and 3', async function () {
       this.timeout(30000)
 
-      await deleteVideoPlaylist(servers[0].url, servers[0].accessToken, playlistServer1Id)
+      await commands[0].delete({ playlistId: playlistServer1Id })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        await getVideoPlaylist(server.url, playlistServer1UUID, HttpStatusCode.NOT_FOUND_404)
+        await server.playlists.get({ playlistId: playlistServer1UUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
     })
 
@@ -1163,75 +1054,61 @@ describe('Test video playlists', function () {
     it('Should unfollow servers 1 and 2 and hide their playlists', async function () {
       this.timeout(30000)
 
-      const finder = data => data.find(p => p.displayName === 'my super playlist')
+      const finder = (data: VideoPlaylist[]) => data.find(p => p.displayName === 'my super playlist')
 
       {
-        const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
-        expect(res.body.total).to.equal(3)
-        expect(finder(res.body.data)).to.not.be.undefined
+        const body = await servers[2].playlists.list({ start: 0, count: 5 })
+        expect(body.total).to.equal(3)
+
+        expect(finder(body.data)).to.not.be.undefined
       }
 
-      await unfollow(servers[2].url, servers[2].accessToken, servers[0])
+      await servers[2].follows.unfollow({ target: servers[0] })
 
       {
-        const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
-        expect(res.body.total).to.equal(1)
+        const body = await servers[2].playlists.list({ start: 0, count: 5 })
+        expect(body.total).to.equal(1)
 
-        expect(finder(res.body.data)).to.be.undefined
+        expect(finder(body.data)).to.be.undefined
       }
     })
 
     it('Should delete a channel and put the associated playlist in private mode', async function () {
       this.timeout(30000)
 
-      const res = await addVideoChannel(servers[0].url, servers[0].accessToken, { name: 'super_channel', displayName: 'super channel' })
-      const videoChannelId = res.body.videoChannel.id
+      const channel = await servers[0].channels.create({ attributes: { name: 'super_channel', displayName: 'super channel' } })
 
-      const res2 = await createVideoPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistAttrs: {
+      const playlistCreated = await commands[0].create({
+        attributes: {
           displayName: 'channel playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId
+          videoChannelId: channel.id
         }
       })
-      const videoPlaylistUUID = res2.body.videoPlaylist.uuid
 
       await waitJobs(servers)
 
-      await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'super_channel')
+      await servers[0].channels.delete({ channelName: 'super_channel' })
 
       await waitJobs(servers)
 
-      const res3 = await getVideoPlaylistWithToken(servers[0].url, servers[0].accessToken, videoPlaylistUUID)
-      expect(res3.body.displayName).to.equal('channel playlist')
-      expect(res3.body.privacy.id).to.equal(VideoPlaylistPrivacy.PRIVATE)
+      const body = await commands[0].get({ token: servers[0].accessToken, playlistId: playlistCreated.uuid })
+      expect(body.displayName).to.equal('channel playlist')
+      expect(body.privacy.id).to.equal(VideoPlaylistPrivacy.PRIVATE)
 
-      await getVideoPlaylist(servers[1].url, videoPlaylistUUID, HttpStatusCode.NOT_FOUND_404)
+      await servers[1].playlists.get({ playlistId: playlistCreated.uuid, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should delete an account and delete its playlists', async function () {
       this.timeout(30000)
 
-      const user = { username: 'user_1', password: 'password' }
-      const res = await createUser({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        username: user.username,
-        password: user.password
-      })
-
-      const userId = res.body.user.id
-      const userAccessToken = await userLogin(servers[0], user)
+      const { userId, token } = await servers[0].users.generate('user_1')
 
-      const resChannel = await getMyUserInformation(servers[0].url, userAccessToken)
-      const userChannel = (resChannel.body as User).videoChannels[0]
+      const { videoChannels } = await servers[0].users.getMyInfo({ token })
+      const userChannel = videoChannels[0]
 
-      await createVideoPlaylist({
-        url: servers[0].url,
-        token: userAccessToken,
-        playlistAttrs: {
+      await commands[0].create({
+        attributes: {
           displayName: 'playlist to be deleted',
           privacy: VideoPlaylistPrivacy.PUBLIC,
           videoChannelId: userChannel.id
@@ -1240,22 +1117,24 @@ describe('Test video playlists', function () {
 
       await waitJobs(servers)
 
-      const finder = data => data.find(p => p.displayName === 'playlist to be deleted')
+      const finder = (data: VideoPlaylist[]) => data.find(p => p.displayName === 'playlist to be deleted')
 
       {
         for (const server of [ servers[0], servers[1] ]) {
-          const res = await getVideoPlaylistsList(server.url, 0, 15)
-          expect(finder(res.body.data)).to.not.be.undefined
+          const body = await server.playlists.list({ start: 0, count: 15 })
+
+          expect(finder(body.data)).to.not.be.undefined
         }
       }
 
-      await removeUser(servers[0].url, userId, servers[0].accessToken)
+      await servers[0].users.remove({ userId })
       await waitJobs(servers)
 
       {
         for (const server of [ servers[0], servers[1] ]) {
-          const res = await getVideoPlaylistsList(server.url, 0, 15)
-          expect(finder(res.body.data)).to.be.undefined
+          const body = await server.playlists.list({ start: 0, count: 15 })
+
+          expect(finder(body.data)).to.be.undefined
         }
       }
     })
diff --git a/server/tests/api/videos/video-privacy.ts b/server/tests/api/videos/video-privacy.ts
index 950aeb7cf..b51b3bcdd 100644
--- a/server/tests/api/videos/video-privacy.ts
+++ b/server/tests/api/videos/video-privacy.ts
@@ -2,28 +2,13 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
-import { Video, VideoCreateResult } from '@shared/models'
-import {
-  cleanupTests,
-  flushAndRunServer,
-  getVideosList,
-  getVideosListWithToken,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo
-} from '../../../../shared/extra-utils/index'
-import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { userLogin } from '../../../../shared/extra-utils/users/login'
-import { createUser } from '../../../../shared/extra-utils/users/users'
-import { getMyVideos, getVideo, getVideoWithToken, updateVideo } from '../../../../shared/extra-utils/videos/videos'
-import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
+import { cleanupTests, createSingleServer, doubleFollow, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { HttpStatusCode, VideoCreateResult, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test video privacy', function () {
-  const servers: ServerInfo[] = []
+  const servers: PeerTubeServer[] = []
   let anotherUserToken: string
 
   let privateVideoId: number
@@ -49,8 +34,8 @@ describe('Test video privacy', function () {
     this.timeout(50000)
 
     // Run servers
-    servers.push(await flushAndRunServer(1, dontFederateUnlistedConfig))
-    servers.push(await flushAndRunServer(2))
+    servers.push(await createSingleServer(1, dontFederateUnlistedConfig))
+    servers.push(await createSingleServer(2))
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -66,55 +51,53 @@ describe('Test video privacy', function () {
 
       for (const privacy of [ VideoPrivacy.PRIVATE, VideoPrivacy.INTERNAL ]) {
         const attributes = { privacy }
-        await uploadVideo(servers[0].url, servers[0].accessToken, attributes)
+        await servers[0].videos.upload({ attributes })
       }
 
       await waitJobs(servers)
     })
 
     it('Should not have these private and internal videos 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(0)
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(total).to.equal(0)
+      expect(data).to.have.lengthOf(0)
     })
 
     it('Should not list the private and internal videos for an unauthenticated user 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.have.lengthOf(0)
+      expect(total).to.equal(0)
+      expect(data).to.have.lengthOf(0)
     })
 
     it('Should not list the private video and list the internal video for an authenticated user on server 1', async function () {
-      const res = await getVideosListWithToken(servers[0].url, servers[0].accessToken)
+      const { total, data } = await servers[0].videos.listWithToken()
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
 
-      expect(res.body.data[0].privacy.id).to.equal(VideoPrivacy.INTERNAL)
+      expect(data[0].privacy.id).to.equal(VideoPrivacy.INTERNAL)
     })
 
     it('Should list my (private and internal) videos', async function () {
-      const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 10)
+      const { total, data } = await servers[0].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)
 
-      const videos: Video[] = res.body.data
-
-      const privateVideo = videos.find(v => v.privacy.id === VideoPrivacy.PRIVATE)
+      const privateVideo = data.find(v => v.privacy.id === VideoPrivacy.PRIVATE)
       privateVideoId = privateVideo.id
       privateVideoUUID = privateVideo.uuid
 
-      const internalVideo = videos.find(v => v.privacy.id === VideoPrivacy.INTERNAL)
+      const internalVideo = data.find(v => v.privacy.id === VideoPrivacy.INTERNAL)
       internalVideoId = internalVideo.id
       internalVideoUUID = internalVideo.uuid
     })
 
     it('Should not be able to watch the private/internal video with non authenticated user', async function () {
-      await getVideo(servers[0].url, privateVideoUUID, HttpStatusCode.UNAUTHORIZED_401)
-      await getVideo(servers[0].url, internalVideoUUID, HttpStatusCode.UNAUTHORIZED_401)
+      await servers[0].videos.get({ id: privateVideoUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+      await servers[0].videos.get({ id: internalVideoUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should not be able to watch the private video with another user', async function () {
@@ -124,18 +107,23 @@ describe('Test video privacy', function () {
         username: 'hello',
         password: 'super 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 })
+
+      anotherUserToken = await servers[0].login.getAccessToken(user)
 
-      anotherUserToken = await userLogin(servers[0], user)
-      await getVideoWithToken(servers[0].url, anotherUserToken, privateVideoUUID, HttpStatusCode.FORBIDDEN_403)
+      await servers[0].videos.getWithToken({
+        token: anotherUserToken,
+        id: privateVideoUUID,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
     })
 
     it('Should be able to watch the internal video with another user', async function () {
-      await getVideoWithToken(servers[0].url, anotherUserToken, internalVideoUUID, HttpStatusCode.OK_200)
+      await servers[0].videos.getWithToken({ token: anotherUserToken, id: internalVideoUUID })
     })
 
     it('Should be able to watch the private video with the correct user', async function () {
-      await getVideoWithToken(servers[0].url, servers[0].accessToken, privateVideoUUID, HttpStatusCode.OK_200)
+      await servers[0].videos.getWithToken({ id: privateVideoUUID })
     })
   })
 
@@ -148,7 +136,7 @@ describe('Test video privacy', function () {
         name: 'unlisted video',
         privacy: VideoPrivacy.UNLISTED
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, attributes)
+      await servers[1].videos.upload({ attributes })
 
       // Server 2 has transcoding enabled
       await waitJobs(servers)
@@ -156,32 +144,32 @@ describe('Test video privacy', function () {
 
     it('Should not have this unlisted video listed on server 1 and 2', async function () {
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { total, data } = await server.videos.list()
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
       }
     })
 
     it('Should list my (unlisted) videos', async function () {
-      const res = await getMyVideos(servers[1].url, servers[1].accessToken, 0, 1)
+      const { total, data } = await servers[1].videos.listMyVideos()
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
 
-      unlistedVideo = res.body.data[0]
+      unlistedVideo = data[0]
     })
 
     it('Should not be able to get this unlisted video using its id', async function () {
-      await getVideo(servers[1].url, unlistedVideo.id, 404)
+      await servers[1].videos.get({ id: unlistedVideo.id, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should be able to get this unlisted video using its uuid/shortUUID', async function () {
       for (const server of servers) {
         for (const id of [ unlistedVideo.uuid, unlistedVideo.shortUUID ]) {
-          const res = await getVideo(server.url, id)
+          const video = await server.videos.get({ id })
 
-          expect(res.body.name).to.equal('unlisted video')
+          expect(video.name).to.equal('unlisted video')
         }
       }
     })
@@ -193,28 +181,28 @@ describe('Test video privacy', function () {
         name: 'unlisted video',
         privacy: VideoPrivacy.UNLISTED
       }
-      await uploadVideo(servers[0].url, servers[0].accessToken, attributes)
+      await servers[0].videos.upload({ attributes })
 
       await waitJobs(servers)
     })
 
     it('Should list my new unlisted video', async function () {
-      const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 3)
+      const { total, data } = await servers[0].videos.listMyVideos()
 
-      expect(res.body.total).to.equal(3)
-      expect(res.body.data).to.have.lengthOf(3)
+      expect(total).to.equal(3)
+      expect(data).to.have.lengthOf(3)
 
-      nonFederatedUnlistedVideoUUID = res.body.data[0].uuid
+      nonFederatedUnlistedVideoUUID = data[0].uuid
     })
 
     it('Should be able to get non-federated unlisted video from origin', async function () {
-      const res = await getVideo(servers[0].url, nonFederatedUnlistedVideoUUID)
+      const video = await servers[0].videos.get({ id: nonFederatedUnlistedVideoUUID })
 
-      expect(res.body.name).to.equal('unlisted video')
+      expect(video.name).to.equal('unlisted video')
     })
 
     it('Should not be able to get non-federated unlisted video from federated server', async function () {
-      await getVideo(servers[1].url, nonFederatedUnlistedVideoUUID, HttpStatusCode.NOT_FOUND_404)
+      await servers[1].videos.get({ id: nonFederatedUnlistedVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
   })
 
@@ -226,20 +214,20 @@ describe('Test video privacy', function () {
       now = Date.now()
 
       {
-        const attribute = {
+        const attributes = {
           name: 'private video becomes public',
           privacy: VideoPrivacy.PUBLIC
         }
 
-        await updateVideo(servers[0].url, servers[0].accessToken, privateVideoId, attribute)
+        await servers[0].videos.update({ id: privateVideoId, attributes })
       }
 
       {
-        const attribute = {
+        const attributes = {
           name: 'internal video becomes public',
           privacy: VideoPrivacy.PUBLIC
         }
-        await updateVideo(servers[0].url, servers[0].accessToken, internalVideoId, attribute)
+        await servers[0].videos.update({ id: internalVideoId, attributes })
       }
 
       await waitJobs(servers)
@@ -247,13 +235,12 @@ describe('Test video privacy', function () {
 
     it('Should have this new public video listed on server 1 and 2', async function () {
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.have.lengthOf(2)
+        const { total, data } = await server.videos.list()
+        expect(total).to.equal(2)
+        expect(data).to.have.lengthOf(2)
 
-        const videos: Video[] = res.body.data
-        const privateVideo = videos.find(v => v.name === 'private video becomes public')
-        const internalVideo = videos.find(v => v.name === 'internal video becomes public')
+        const privateVideo = data.find(v => v.name === 'private video becomes public')
+        const internalVideo = data.find(v => v.name === 'internal video becomes public')
 
         expect(privateVideo).to.not.be.undefined
         expect(internalVideo).to.not.be.undefined
@@ -270,27 +257,25 @@ describe('Test video privacy', function () {
     it('Should set these videos as private and internal', async function () {
       this.timeout(10000)
 
-      await updateVideo(servers[0].url, servers[0].accessToken, internalVideoId, { privacy: VideoPrivacy.PRIVATE })
-      await updateVideo(servers[0].url, servers[0].accessToken, privateVideoId, { privacy: VideoPrivacy.INTERNAL })
+      await servers[0].videos.update({ id: internalVideoId, attributes: { privacy: VideoPrivacy.PRIVATE } })
+      await servers[0].videos.update({ id: privateVideoId, attributes: { privacy: VideoPrivacy.INTERNAL } })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { total, data } = await server.videos.list()
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
       }
 
       {
-        const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5)
-        const videos = res.body.data
-
-        expect(res.body.total).to.equal(3)
-        expect(videos).to.have.lengthOf(3)
+        const { total, data } = await servers[0].videos.listMyVideos()
+        expect(total).to.equal(3)
+        expect(data).to.have.lengthOf(3)
 
-        const privateVideo = videos.find(v => v.name === 'private video becomes public')
-        const internalVideo = videos.find(v => v.name === 'internal video becomes public')
+        const privateVideo = data.find(v => v.name === 'private video becomes public')
+        const internalVideo = data.find(v => v.name === 'internal video becomes public')
 
         expect(privateVideo).to.not.be.undefined
         expect(internalVideo).to.not.be.undefined
diff --git a/server/tests/api/videos/video-schedule-update.ts b/server/tests/api/videos/video-schedule-update.ts
index 204f43611..3f7738784 100644
--- a/server/tests/api/videos/video-schedule-update.ts
+++ b/server/tests/api/videos/video-schedule-update.ts
@@ -1,22 +1,17 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import { VideoPrivacy } from '../../../../shared/models/videos'
+import * as chai from 'chai'
 import {
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getMyVideos,
-  getVideosList,
-  getVideoWithToken,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateVideo,
-  uploadVideo,
-  wait
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
@@ -28,14 +23,14 @@ function in10Seconds () {
 }
 
 describe('Test video update scheduler', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let video2UUID: string
 
   before(async function () {
     this.timeout(30000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
@@ -45,35 +40,34 @@ describe('Test video update scheduler', function () {
   it('Should upload a video and schedule an update in 10 seconds', async function () {
     this.timeout(10000)
 
-    const videoAttributes = {
+    const attributes = {
       name: 'video 1',
       privacy: VideoPrivacy.PRIVATE,
       scheduleUpdate: {
         updateAt: in10Seconds().toISOString(),
-        privacy: VideoPrivacy.PUBLIC
+        privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
       }
     }
 
-    await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+    await servers[0].videos.upload({ attributes })
 
     await waitJobs(servers)
   })
 
   it('Should not list the video (in privacy mode)', async function () {
     for (const server of servers) {
-      const res = await getVideosList(server.url)
+      const { total } = await server.videos.list()
 
-      expect(res.body.total).to.equal(0)
+      expect(total).to.equal(0)
     }
   })
 
   it('Should have my scheduled video in my account videos', async function () {
-    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5)
-    expect(res.body.total).to.equal(1)
+    const { total, data } = await servers[0].videos.listMyVideos()
+    expect(total).to.equal(1)
 
-    const videoFromList = res.body.data[0]
-    const res2 = await getVideoWithToken(servers[0].url, servers[0].accessToken, videoFromList.uuid)
-    const videoFromGet = res2.body
+    const videoFromList = data[0]
+    const videoFromGet = await servers[0].videos.getWithToken({ id: videoFromList.uuid })
 
     for (const video of [ videoFromList, videoFromGet ]) {
       expect(video.name).to.equal('video 1')
@@ -90,23 +84,23 @@ describe('Test video update scheduler', function () {
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
+      const { total, data } = await server.videos.list()
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data[0].name).to.equal('video 1')
+      expect(total).to.equal(1)
+      expect(data[0].name).to.equal('video 1')
     }
   })
 
   it('Should upload a video without scheduling an update', async function () {
     this.timeout(10000)
 
-    const videoAttributes = {
+    const attributes = {
       name: 'video 2',
       privacy: VideoPrivacy.PRIVATE
     }
 
-    const res = await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
-    video2UUID = res.body.video.uuid
+    const { uuid } = await servers[0].videos.upload({ attributes })
+    video2UUID = uuid
 
     await waitJobs(servers)
   })
@@ -114,31 +108,31 @@ describe('Test video update scheduler', function () {
   it('Should update a video by scheduling an update', async function () {
     this.timeout(10000)
 
-    const videoAttributes = {
+    const attributes = {
       name: 'video 2 updated',
       scheduleUpdate: {
         updateAt: in10Seconds().toISOString(),
-        privacy: VideoPrivacy.PUBLIC
+        privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
       }
     }
 
-    await updateVideo(servers[0].url, servers[0].accessToken, video2UUID, videoAttributes)
+    await servers[0].videos.update({ id: video2UUID, attributes })
     await waitJobs(servers)
   })
 
   it('Should not display the updated video', async function () {
     for (const server of servers) {
-      const res = await getVideosList(server.url)
+      const { total } = await server.videos.list()
 
-      expect(res.body.total).to.equal(1)
+      expect(total).to.equal(1)
     }
   })
 
   it('Should have my scheduled updated video in my account videos', async function () {
-    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5)
-    expect(res.body.total).to.equal(2)
+    const { total, data } = await servers[0].videos.listMyVideos()
+    expect(total).to.equal(2)
 
-    const video = res.body.data.find(v => v.uuid === video2UUID)
+    const video = data.find(v => v.uuid === video2UUID)
     expect(video).not.to.be.undefined
 
     expect(video.name).to.equal('video 2 updated')
@@ -155,11 +149,10 @@ describe('Test video update scheduler', function () {
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-
-      expect(res.body.total).to.equal(2)
+      const { total, data } = await server.videos.list()
+      expect(total).to.equal(2)
 
-      const video = res.body.data.find(v => v.uuid === video2UUID)
+      const video = data.find(v => v.uuid === video2UUID)
       expect(video).not.to.be.undefined
       expect(video.name).to.equal('video 2 updated')
     }
diff --git a/server/tests/api/videos/video-transcoder.ts b/server/tests/api/videos/video-transcoder.ts
index ea5ffd239..e4892bb24 100644
--- a/server/tests/api/videos/video-transcoder.ts
+++ b/server/tests/api/videos/video-transcoder.ts
@@ -2,36 +2,23 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { FfprobeData } from 'fluent-ffmpeg'
 import { omit } from 'lodash'
 import { join } from 'path'
-import { Job } from '@shared/models'
-import { VIDEO_TRANSCODING_FPS } from '../../../../server/initializers/constants'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   buildAbsoluteFixturePath,
-  buildServerDirectory,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
   generateHighBitrateVideo,
   generateVideoWithFramerate,
-  getJobsListPaginationAndSort,
-  getMyVideos,
-  getServerFileSize,
-  getVideo,
-  getVideoFileMetadataUrl,
-  getVideosList,
   makeGetRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateCustomSubConfig,
-  uploadVideo,
-  uploadVideoAndGetId,
   waitJobs,
   webtorrentAdd
-} from '../../../../shared/extra-utils'
-import { getMaxBitrate, VideoDetails, VideoResolution, VideoState } from '../../../../shared/models/videos'
+} from '@shared/extra-utils'
+import { getMaxBitrate, HttpStatusCode, VideoResolution, VideoState } from '@shared/models'
+import { VIDEO_TRANSCODING_FPS } from '../../../../server/initializers/constants'
 import {
   canDoQuickTranscode,
   getAudioStream,
@@ -43,37 +30,39 @@ import {
 
 const expect = chai.expect
 
-function updateConfigForTranscoding (server: ServerInfo) {
-  return updateCustomSubConfig(server.url, server.accessToken, {
-    transcoding: {
-      enabled: true,
-      allowAdditionalExtensions: true,
-      allowAudioFiles: true,
-      hls: { enabled: true },
-      webtorrent: { enabled: true },
-      resolutions: {
-        '0p': false,
-        '240p': true,
-        '360p': true,
-        '480p': true,
-        '720p': true,
-        '1080p': true,
-        '1440p': true,
-        '2160p': true
+function updateConfigForTranscoding (server: PeerTubeServer) {
+  return server.config.updateCustomSubConfig({
+    newConfig: {
+      transcoding: {
+        enabled: true,
+        allowAdditionalExtensions: true,
+        allowAudioFiles: true,
+        hls: { enabled: true },
+        webtorrent: { enabled: true },
+        resolutions: {
+          '0p': false,
+          '240p': true,
+          '360p': true,
+          '480p': true,
+          '720p': true,
+          '1080p': true,
+          '1440p': true,
+          '2160p': true
+        }
       }
     }
   })
 }
 
 describe('Test video transcoding', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let video4k: string
 
   before(async function () {
     this.timeout(30_000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
@@ -87,21 +76,20 @@ describe('Test video transcoding', function () {
     it('Should not transcode video on server 1', async function () {
       this.timeout(60_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name for server 1',
         description: 'my super description for server 1',
         fixture: 'video_short.webm'
       }
-      await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+      await servers[0].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        const video = res.body.data[0]
+        const { data } = await server.videos.list()
+        const video = data[0]
 
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails = res2.body
+        const videoDetails = await server.videos.get({ id: video.id })
         expect(videoDetails.files).to.have.lengthOf(1)
 
         const magnetUri = videoDetails.files[0].magnetUri
@@ -117,21 +105,20 @@ describe('Test video transcoding', function () {
     it('Should transcode video on server 2', async function () {
       this.timeout(120_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name for server 2',
         description: 'my super description for server 2',
         fixture: 'video_short.webm'
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails = res2.body
+        const video = data.find(v => v.name === attributes.name)
+        const videoDetails = await server.videos.get({ id: video.id })
 
         expect(videoDetails.files).to.have.lengthOf(4)
 
@@ -150,47 +137,50 @@ describe('Test video transcoding', function () {
 
       {
         // Upload the video, but wait transcoding
-        const videoAttributes = {
+        const attributes = {
           name: 'waiting video',
           fixture: 'video_short1.webm',
           waitTranscoding: true
         }
-        const resVideo = await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
-        const videoId = resVideo.body.video.uuid
+        const { uuid } = await servers[1].videos.upload({ attributes })
+        const videoId = uuid
 
         // Should be in transcode state
-        const { body } = await getVideo(servers[1].url, videoId)
+        const body = await servers[1].videos.get({ id: videoId })
         expect(body.name).to.equal('waiting video')
         expect(body.state.id).to.equal(VideoState.TO_TRANSCODE)
         expect(body.state.label).to.equal('To transcode')
         expect(body.waitTranscoding).to.be.true
 
-        // Should have my video
-        const resMyVideos = await getMyVideos(servers[1].url, servers[1].accessToken, 0, 10)
-        const videoToFindInMine = resMyVideos.body.data.find(v => v.name === videoAttributes.name)
-        expect(videoToFindInMine).not.to.be.undefined
-        expect(videoToFindInMine.state.id).to.equal(VideoState.TO_TRANSCODE)
-        expect(videoToFindInMine.state.label).to.equal('To transcode')
-        expect(videoToFindInMine.waitTranscoding).to.be.true
+        {
+          // Should have my video
+          const { data } = await servers[1].videos.listMyVideos()
+          const videoToFindInMine = data.find(v => v.name === attributes.name)
+          expect(videoToFindInMine).not.to.be.undefined
+          expect(videoToFindInMine.state.id).to.equal(VideoState.TO_TRANSCODE)
+          expect(videoToFindInMine.state.label).to.equal('To transcode')
+          expect(videoToFindInMine.waitTranscoding).to.be.true
+        }
 
-        // Should not list this video
-        const resVideos = await getVideosList(servers[1].url)
-        const videoToFindInList = resVideos.body.data.find(v => v.name === videoAttributes.name)
-        expect(videoToFindInList).to.be.undefined
+        {
+          // Should not list this video
+          const { data } = await servers[1].videos.list()
+          const videoToFindInList = data.find(v => v.name === attributes.name)
+          expect(videoToFindInList).to.be.undefined
+        }
 
         // Server 1 should not have the video yet
-        await getVideo(servers[0].url, videoId, HttpStatusCode.NOT_FOUND_404)
+        await servers[0].videos.get({ id: videoId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        const videoToFind = res.body.data.find(v => v.name === 'waiting video')
+        const { data } = await server.videos.list()
+        const videoToFind = data.find(v => v.name === 'waiting video')
         expect(videoToFind).not.to.be.undefined
 
-        const res2 = await getVideo(server.url, videoToFind.id)
-        const videoDetails: VideoDetails = res2.body
+        const videoDetails = await server.videos.get({ id: videoToFind.id })
 
         expect(videoDetails.state.id).to.equal(VideoState.PUBLISHED)
         expect(videoDetails.state.label).to.equal('Published')
@@ -211,22 +201,20 @@ describe('Test video transcoding', function () {
       }
 
       for (const fixture of [ 'video_short.mkv', 'video_short.avi' ]) {
-        const videoAttributes = {
+        const attributes = {
           name: fixture,
           fixture
         }
 
-        await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+        await servers[1].videos.upload({ attributes })
 
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getVideosList(server.url)
-
-          const video = res.body.data.find(v => v.name === videoAttributes.name)
-          const res2 = await getVideo(server.url, video.id)
-          const videoDetails = res2.body
+          const { data } = await server.videos.list()
 
+          const video = data.find(v => v.name === attributes.name)
+          const videoDetails = await server.videos.get({ id: video.id })
           expect(videoDetails.files).to.have.lengthOf(4)
 
           const magnetUri = videoDetails.files[0].magnetUri
@@ -238,22 +226,20 @@ describe('Test video transcoding', function () {
     it('Should transcode a 4k video', async function () {
       this.timeout(200_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: '4k video',
         fixture: 'video_short_4k.mp4'
       }
 
-      const resUpload = await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
-      video4k = resUpload.body.video.uuid
+      const { uuid } = await servers[1].videos.upload({ attributes })
+      video4k = uuid
 
       await waitJobs(servers)
 
       const resolutions = [ 240, 360, 480, 720, 1080, 1440, 2160 ]
 
       for (const server of servers) {
-        const res = await getVideo(server.url, video4k)
-        const videoDetails: VideoDetails = res.body
-
+        const videoDetails = await server.videos.get({ id: video4k })
         expect(videoDetails.files).to.have.lengthOf(resolutions.length)
 
         for (const r of resolutions) {
@@ -269,24 +255,23 @@ describe('Test video transcoding', function () {
     it('Should transcode high bit rate mp3 to proper bit rate', async function () {
       this.timeout(60_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'mp3_256k',
         fixture: 'video_short_mp3_256k.mp4'
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails: VideoDetails = res2.body
+        const video = data.find(v => v.name === attributes.name)
+        const videoDetails = await server.videos.get({ id: video.id })
 
         expect(videoDetails.files).to.have.lengthOf(4)
 
-        const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-240.mp4'))
+        const path = servers[1].servers.buildDirectory(join('videos', video.uuid + '-240.mp4'))
         const probe = await getAudioStream(path)
 
         if (probe.audioStream) {
@@ -301,23 +286,22 @@ describe('Test video transcoding', function () {
     it('Should transcode video with no audio and have no audio itself', async function () {
       this.timeout(60_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'no_audio',
         fixture: 'video_short_no_audio.mp4'
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails: VideoDetails = res2.body
+        const video = data.find(v => v.name === attributes.name)
+        const videoDetails = await server.videos.get({ id: video.id })
 
         expect(videoDetails.files).to.have.lengthOf(4)
-        const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-240.mp4'))
+        const path = servers[1].servers.buildDirectory(join('videos', video.uuid + '-240.mp4'))
         const probe = await getAudioStream(path)
         expect(probe).to.not.have.property('audioStream')
       }
@@ -326,26 +310,25 @@ describe('Test video transcoding', function () {
     it('Should leave the audio untouched, but properly transcode the video', async function () {
       this.timeout(60_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'untouched_audio',
         fixture: 'video_short.mp4'
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails: VideoDetails = res2.body
+        const video = data.find(v => v.name === attributes.name)
+        const videoDetails = await server.videos.get({ id: video.id })
 
         expect(videoDetails.files).to.have.lengthOf(4)
 
-        const fixturePath = buildAbsoluteFixturePath(videoAttributes.fixture)
+        const fixturePath = buildAbsoluteFixturePath(attributes.fixture)
         const fixtureVideoProbe = await getAudioStream(fixturePath)
-        const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-240.mp4'))
+        const path = servers[1].servers.buildDirectory(join('videos', video.uuid + '-240.mp4'))
 
         const videoProbe = await getAudioStream(path)
 
@@ -364,19 +347,21 @@ describe('Test video transcoding', function () {
     function runSuite (mode: 'legacy' | 'resumable') {
 
       before(async function () {
-        await updateCustomSubConfig(servers[1].url, servers[1].accessToken, {
-          transcoding: {
-            hls: { enabled: true },
-            webtorrent: { enabled: true },
-            resolutions: {
-              '0p': false,
-              '240p': false,
-              '360p': false,
-              '480p': false,
-              '720p': false,
-              '1080p': false,
-              '1440p': false,
-              '2160p': false
+        await servers[1].config.updateCustomSubConfig({
+          newConfig: {
+            transcoding: {
+              hls: { enabled: true },
+              webtorrent: { enabled: true },
+              resolutions: {
+                '0p': false,
+                '240p': false,
+                '360p': false,
+                '480p': false,
+                '720p': false,
+                '1080p': false,
+                '1440p': false,
+                '2160p': false
+              }
             }
           }
         })
@@ -385,22 +370,21 @@ describe('Test video transcoding', function () {
       it('Should merge an audio file with the preview file', async function () {
         this.timeout(60_000)
 
-        const videoAttributesArg = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
-        await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributesArg, HttpStatusCode.OK_200, mode)
+        const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
+        await servers[1].videos.upload({ attributes, mode })
 
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getVideosList(server.url)
+          const { data } = await server.videos.list()
 
-          const video = res.body.data.find(v => v.name === 'audio_with_preview')
-          const res2 = await getVideo(server.url, video.id)
-          const videoDetails: VideoDetails = res2.body
+          const video = data.find(v => v.name === 'audio_with_preview')
+          const videoDetails = await server.videos.get({ id: video.id })
 
           expect(videoDetails.files).to.have.lengthOf(1)
 
-          await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, statusCodeExpected: HttpStatusCode.OK_200 })
-          await makeGetRequest({ url: server.url, path: videoDetails.previewPath, statusCodeExpected: HttpStatusCode.OK_200 })
+          await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+          await makeGetRequest({ url: server.url, path: videoDetails.previewPath, expectedStatus: HttpStatusCode.OK_200 })
 
           const magnetUri = videoDetails.files[0].magnetUri
           expect(magnetUri).to.contain('.mp4')
@@ -410,22 +394,21 @@ describe('Test video transcoding', function () {
       it('Should upload an audio file and choose a default background image', async function () {
         this.timeout(60_000)
 
-        const videoAttributesArg = { name: 'audio_without_preview', fixture: 'sample.ogg' }
-        await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributesArg, HttpStatusCode.OK_200, mode)
+        const attributes = { name: 'audio_without_preview', fixture: 'sample.ogg' }
+        await servers[1].videos.upload({ attributes, mode })
 
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getVideosList(server.url)
+          const { data } = await server.videos.list()
 
-          const video = res.body.data.find(v => v.name === 'audio_without_preview')
-          const res2 = await getVideo(server.url, video.id)
-          const videoDetails = res2.body
+          const video = data.find(v => v.name === 'audio_without_preview')
+          const videoDetails = await server.videos.get({ id: video.id })
 
           expect(videoDetails.files).to.have.lengthOf(1)
 
-          await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, statusCodeExpected: HttpStatusCode.OK_200 })
-          await makeGetRequest({ url: server.url, path: videoDetails.previewPath, statusCodeExpected: HttpStatusCode.OK_200 })
+          await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+          await makeGetRequest({ url: server.url, path: videoDetails.previewPath, expectedStatus: HttpStatusCode.OK_200 })
 
           const magnetUri = videoDetails.files[0].magnetUri
           expect(magnetUri).to.contain('.mp4')
@@ -435,26 +418,27 @@ describe('Test video transcoding', function () {
       it('Should upload an audio file and create an audio version only', async function () {
         this.timeout(60_000)
 
-        await updateCustomSubConfig(servers[1].url, servers[1].accessToken, {
-          transcoding: {
-            hls: { enabled: true },
-            webtorrent: { enabled: true },
-            resolutions: {
-              '0p': true,
-              '240p': false,
-              '360p': false
+        await servers[1].config.updateCustomSubConfig({
+          newConfig: {
+            transcoding: {
+              hls: { enabled: true },
+              webtorrent: { enabled: true },
+              resolutions: {
+                '0p': true,
+                '240p': false,
+                '360p': false
+              }
             }
           }
         })
 
-        const videoAttributesArg = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
-        const resVideo = await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributesArg, HttpStatusCode.OK_200, mode)
+        const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
+        const { id } = await servers[1].videos.upload({ attributes, mode })
 
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res2 = await getVideo(server.url, resVideo.body.video.id)
-          const videoDetails: VideoDetails = res2.body
+          const videoDetails = await server.videos.get({ id })
 
           for (const files of [ videoDetails.files, videoDetails.streamingPlaylists[0].files ]) {
             expect(files).to.have.lengthOf(2)
@@ -480,21 +464,20 @@ describe('Test video transcoding', function () {
     it('Should transcode a 60 FPS video', async function () {
       this.timeout(60_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super 30fps name for server 2',
         description: 'my super 30fps description for server 2',
         fixture: '60fps_720p_small.mp4'
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails: VideoDetails = res2.body
+        const video = data.find(v => v.name === attributes.name)
+        const videoDetails = await server.videos.get({ id: video.id })
 
         expect(videoDetails.files).to.have.lengthOf(4)
         expect(videoDetails.files[0].fps).to.be.above(58).and.below(62)
@@ -503,13 +486,13 @@ describe('Test video transcoding', function () {
         expect(videoDetails.files[3].fps).to.be.below(31)
 
         for (const resolution of [ '240', '360', '480' ]) {
-          const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-' + resolution + '.mp4'))
+          const path = servers[1].servers.buildDirectory(join('videos', video.uuid + '-' + resolution + '.mp4'))
           const fps = await getVideoFileFPS(path)
 
           expect(fps).to.be.below(31)
         }
 
-        const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-720.mp4'))
+        const path = servers[1].servers.buildDirectory(join('videos', video.uuid + '-720.mp4'))
         const fps = await getVideoFileFPS(path)
 
         expect(fps).to.be.above(58).and.below(62)
@@ -528,29 +511,29 @@ describe('Test video transcoding', function () {
         expect(fps).to.be.equal(59)
       }
 
-      const videoAttributes = {
+      const attributes = {
         name: '59fps video',
         description: '59fps video',
         fixture: tempFixturePath
       }
 
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
+        const video = data.find(v => v.name === attributes.name)
 
         {
-          const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-240.mp4'))
+          const path = servers[1].servers.buildDirectory(join('videos', video.uuid + '-240.mp4'))
           const fps = await getVideoFileFPS(path)
           expect(fps).to.be.equal(25)
         }
 
         {
-          const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-720.mp4'))
+          const path = servers[1].servers.buildDirectory(join('videos', video.uuid + '-720.mp4'))
           const fps = await getVideoFileFPS(path)
           expect(fps).to.be.equal(59)
         }
@@ -571,23 +554,23 @@ describe('Test video transcoding', function () {
         expect(bitrate).to.be.above(getMaxBitrate(VideoResolution.H_1080P, 25, VIDEO_TRANSCODING_FPS))
       }
 
-      const videoAttributes = {
+      const attributes = {
         name: 'high bitrate video',
         description: 'high bitrate video',
         fixture: tempFixturePath
       }
 
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
+        const video = data.find(v => v.name === attributes.name)
 
         for (const resolution of [ '240', '360', '480', '720', '1080' ]) {
-          const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-' + resolution + '.mp4'))
+          const path = servers[1].servers.buildDirectory(join('videos', video.uuid + '-' + resolution + '.mp4'))
 
           const bitrate = await getVideoFileBitrate(path)
           const fps = await getVideoFileFPS(path)
@@ -602,7 +585,7 @@ describe('Test video transcoding', function () {
     it('Should not transcode to an higher bitrate than the original file', async function () {
       this.timeout(160_000)
 
-      const config = {
+      const newConfig = {
         transcoding: {
           enabled: true,
           resolutions: {
@@ -618,22 +601,21 @@ describe('Test video transcoding', function () {
           hls: { enabled: true }
         }
       }
-      await updateCustomSubConfig(servers[1].url, servers[1].accessToken, config)
+      await servers[1].config.updateCustomSubConfig({ newConfig })
 
-      const videoAttributes = {
+      const attributes = {
         name: 'low bitrate',
         fixture: 'low-bitrate.mp4'
       }
 
-      const resUpload = await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
-      const videoUUID = resUpload.body.video.uuid
+      const { uuid } = await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       const resolutions = [ 240, 360, 480, 720, 1080 ]
       for (const r of resolutions) {
-        const path = `videos/${videoUUID}-${r}.mp4`
-        const size = await getServerFileSize(servers[1], path)
+        const path = `videos/${uuid}-${r}.mp4`
+        const size = await servers[1].servers.getServerFileSize(path)
         expect(size, `${path} not below ${60_000}`).to.be.below(60_000)
       }
     })
@@ -644,11 +626,11 @@ describe('Test video transcoding', function () {
     it('Should provide valid ffprobe data', async function () {
       this.timeout(160_000)
 
-      const videoUUID = (await uploadVideoAndGetId({ server: servers[1], videoName: 'ffprobe data' })).uuid
+      const videoUUID = (await servers[1].videos.quickUpload({ name: 'ffprobe data' })).uuid
       await waitJobs(servers)
 
       {
-        const path = buildServerDirectory(servers[1], join('videos', videoUUID + '-240.mp4'))
+        const path = servers[1].servers.buildDirectory(join('videos', videoUUID + '-240.mp4'))
         const metadata = await getMetadataFromFile(path)
 
         // expected format properties
@@ -678,8 +660,7 @@ describe('Test video transcoding', function () {
       }
 
       for (const server of servers) {
-        const res2 = await getVideo(server.url, videoUUID)
-        const videoDetails: VideoDetails = res2.body
+        const videoDetails = await server.videos.get({ id: videoUUID })
 
         const videoFiles = videoDetails.files
                                       .concat(videoDetails.streamingPlaylists[0].files)
@@ -691,8 +672,7 @@ describe('Test video transcoding', function () {
           expect(file.metadataUrl).to.contain(servers[1].url)
           expect(file.metadataUrl).to.contain(videoUUID)
 
-          const res3 = await getVideoFileMetadataUrl(file.metadataUrl)
-          const metadata: FfprobeData = res3.body
+          const metadata = await server.videos.getFileMetadata({ url: file.metadataUrl })
           expect(metadata).to.have.nested.property('format.size')
         }
       }
@@ -709,17 +689,14 @@ describe('Test video transcoding', function () {
   describe('Transcoding job queue', function () {
 
     it('Should have the appropriate priorities for transcoding jobs', async function () {
-      const res = await getJobsListPaginationAndSort({
-        url: servers[1].url,
-        accessToken: servers[1].accessToken,
+      const body = await servers[1].jobs.getJobsList({
         start: 0,
         count: 100,
         sort: '-createdAt',
         jobType: 'video-transcoding'
       })
 
-      const jobs = res.body.data as Job[]
-
+      const jobs = body.data
       const transcodingJobs = jobs.filter(j => j.data.videoUUID === video4k)
 
       expect(transcodingJobs).to.have.lengthOf(14)
diff --git a/server/tests/api/videos/videos-filter.ts b/server/tests/api/videos/videos-filter.ts
index 7428b82c5..2306807bf 100644
--- a/server/tests/api/videos/videos-filter.ts
+++ b/server/tests/api/videos/videos-filter.ts
@@ -1,25 +1,18 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import { expect } from 'chai'
 import {
   cleanupTests,
-  createUser,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
   makeGetRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { Video, VideoPrivacy } from '../../../../shared/models/videos'
-import { UserRole } from '../../../../shared/models/users'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-
-const expect = chai.expect
-
-async function getVideosNames (server: ServerInfo, token: string, filter: string, statusCodeExpected = HttpStatusCode.OK_200) {
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode, UserRole, Video, VideoPrivacy } from '@shared/models'
+
+async function getVideosNames (server: PeerTubeServer, token: string, filter: string, expectedStatus = HttpStatusCode.OK_200) {
   const paths = [
     '/api/v1/video-channels/root_channel/videos',
     '/api/v1/accounts/root/videos',
@@ -38,7 +31,7 @@ async function getVideosNames (server: ServerInfo, token: string, filter: string
         sort: 'createdAt',
         filter
       },
-      statusCodeExpected
+      expectedStatus
     })
 
     videosResults.push(res.body.data.map(v => v.name))
@@ -48,42 +41,32 @@ async function getVideosNames (server: ServerInfo, token: string, filter: string
 }
 
 describe('Test videos filter', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(160000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
     for (const server of servers) {
       const moderator = { username: 'moderator', password: 'my super password' }
-      await createUser(
-        {
-          url: server.url,
-          accessToken: server.accessToken,
-          username: moderator.username,
-          password: moderator.password,
-          videoQuota: undefined,
-          videoQuotaDaily: undefined,
-          role: UserRole.MODERATOR
-        }
-      )
-      server['moderatorAccessToken'] = await userLogin(server, moderator)
+      await server.users.create({ username: moderator.username, password: moderator.password, role: UserRole.MODERATOR })
+      server['moderatorAccessToken'] = await server.login.getAccessToken(moderator)
 
-      await uploadVideo(server.url, server.accessToken, { name: 'public ' + server.serverNumber })
+      await server.videos.upload({ attributes: { name: 'public ' + server.serverNumber } })
 
       {
         const attributes = { name: 'unlisted ' + server.serverNumber, privacy: VideoPrivacy.UNLISTED }
-        await uploadVideo(server.url, server.accessToken, attributes)
+        await server.videos.upload({ attributes })
       }
 
       {
         const attributes = { name: 'private ' + server.serverNumber, privacy: VideoPrivacy.PRIVATE }
-        await uploadVideo(server.url, server.accessToken, attributes)
+        await server.videos.upload({ attributes })
       }
     }
 
diff --git a/server/tests/api/videos/videos-history.ts b/server/tests/api/videos/videos-history.ts
index b25cff879..e4bc0bb3a 100644
--- a/server/tests/api/videos/videos-history.ts
+++ b/server/tests/api/videos/videos-history.ts
@@ -1,74 +1,66 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
   cleanupTests,
-  createUser,
-  flushAndRunServer,
-  getVideosListWithToken,
-  getVideoWithToken,
+  createSingleServer,
+  HistoryCommand,
   killallServers,
-  reRunServer,
-  searchVideoWithToken,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateMyUser,
-  uploadVideo,
-  userLogin,
   wait
-} from '../../../../shared/extra-utils'
-import { Video, VideoDetails } from '../../../../shared/models/videos'
-import { listMyVideosHistory, removeMyVideosHistory, userWatchVideo } from '../../../../shared/extra-utils/videos/video-history'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+} from '@shared/extra-utils'
+import { HttpStatusCode, Video } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test videos history', function () {
-  let server: ServerInfo = null
+  let server: PeerTubeServer = null
   let video1UUID: string
   let video2UUID: string
   let video3UUID: string
   let video3WatchedDate: Date
   let userAccessToken: string
+  let command: HistoryCommand
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
+    command = server.history
+
     {
-      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 1' })
-      video1UUID = res.body.video.uuid
+      const { uuid } = await server.videos.upload({ attributes: { name: 'video 1' } })
+      video1UUID = uuid
     }
 
     {
-      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
-      video2UUID = res.body.video.uuid
+      const { uuid } = await server.videos.upload({ attributes: { name: 'video 2' } })
+      video2UUID = uuid
     }
 
     {
-      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 3' })
-      video3UUID = res.body.video.uuid
+      const { uuid } = await server.videos.upload({ attributes: { name: 'video 3' } })
+      video3UUID = uuid
     }
 
     const user = {
       username: 'user_1',
       password: 'super password'
     }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(server, user)
+    await server.users.create({ username: user.username, password: user.password })
+    userAccessToken = await server.login.getAccessToken(user)
   })
 
   it('Should get videos, without watching history', async function () {
-    const res = await getVideosListWithToken(server.url, server.accessToken)
-    const videos: Video[] = res.body.data
+    const { data } = await server.videos.listWithToken()
 
-    for (const video of videos) {
-      const resDetail = await getVideoWithToken(server.url, server.accessToken, video.id)
-      const videoDetails: VideoDetails = resDetail.body
+    for (const video of data) {
+      const videoDetails = await server.videos.getWithToken({ id: video.id })
 
       expect(video.userHistory).to.be.undefined
       expect(videoDetails.userHistory).to.be.undefined
@@ -76,21 +68,21 @@ describe('Test videos history', function () {
   })
 
   it('Should watch the first and second video', async function () {
-    await userWatchVideo(server.url, server.accessToken, video2UUID, 8)
-    await userWatchVideo(server.url, server.accessToken, video1UUID, 3)
+    await command.wathVideo({ videoId: video2UUID, currentTime: 8 })
+    await command.wathVideo({ videoId: video1UUID, currentTime: 3 })
   })
 
   it('Should return the correct history when listing, searching and getting videos', async function () {
     const videosOfVideos: Video[][] = []
 
     {
-      const res = await getVideosListWithToken(server.url, server.accessToken)
-      videosOfVideos.push(res.body.data)
+      const { data } = await server.videos.listWithToken()
+      videosOfVideos.push(data)
     }
 
     {
-      const res = await searchVideoWithToken(server.url, 'video', server.accessToken)
-      videosOfVideos.push(res.body.data)
+      const body = await server.search.searchVideos({ token: server.accessToken, search: 'video' })
+      videosOfVideos.push(body.data)
     }
 
     for (const videos of videosOfVideos) {
@@ -108,24 +100,21 @@ describe('Test videos history', function () {
     }
 
     {
-      const resDetail = await getVideoWithToken(server.url, server.accessToken, video1UUID)
-      const videoDetails: VideoDetails = resDetail.body
+      const videoDetails = await server.videos.getWithToken({ id: video1UUID })
 
       expect(videoDetails.userHistory).to.not.be.undefined
       expect(videoDetails.userHistory.currentTime).to.equal(3)
     }
 
     {
-      const resDetail = await getVideoWithToken(server.url, server.accessToken, video2UUID)
-      const videoDetails: VideoDetails = resDetail.body
+      const videoDetails = await server.videos.getWithToken({ id: video2UUID })
 
       expect(videoDetails.userHistory).to.not.be.undefined
       expect(videoDetails.userHistory.currentTime).to.equal(8)
     }
 
     {
-      const resDetail = await getVideoWithToken(server.url, server.accessToken, video3UUID)
-      const videoDetails: VideoDetails = resDetail.body
+      const videoDetails = await server.videos.getWithToken({ id: video3UUID })
 
       expect(videoDetails.userHistory).to.be.undefined
     }
@@ -133,71 +122,64 @@ describe('Test videos history', function () {
 
   it('Should have these videos when listing my history', async function () {
     video3WatchedDate = new Date()
-    await userWatchVideo(server.url, server.accessToken, video3UUID, 2)
+    await command.wathVideo({ videoId: video3UUID, currentTime: 2 })
 
-    const res = await listMyVideosHistory(server.url, server.accessToken)
+    const body = await command.list()
 
-    expect(res.body.total).to.equal(3)
+    expect(body.total).to.equal(3)
 
-    const videos: Video[] = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('video 3')
     expect(videos[1].name).to.equal('video 1')
     expect(videos[2].name).to.equal('video 2')
   })
 
   it('Should not have videos history on another user', async function () {
-    const res = await listMyVideosHistory(server.url, userAccessToken)
+    const body = await command.list({ token: userAccessToken })
 
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   it('Should be able to search through videos in my history', async function () {
-    const res = await listMyVideosHistory(server.url, server.accessToken, '2')
-
-    expect(res.body.total).to.equal(1)
+    const body = await command.list({ search: '2' })
+    expect(body.total).to.equal(1)
 
-    const videos: Video[] = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('video 2')
   })
 
   it('Should clear my history', async function () {
-    await removeMyVideosHistory(server.url, server.accessToken, video3WatchedDate.toISOString())
+    await command.remove({ beforeDate: video3WatchedDate.toISOString() })
   })
 
   it('Should have my history cleared', async function () {
-    const res = await listMyVideosHistory(server.url, server.accessToken)
+    const body = await command.list()
+    expect(body.total).to.equal(1)
 
-    expect(res.body.total).to.equal(1)
-
-    const videos: Video[] = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('video 3')
   })
 
   it('Should disable videos history', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: server.accessToken,
+    await server.users.updateMe({
       videosHistoryEnabled: false
     })
 
-    await userWatchVideo(server.url, server.accessToken, video2UUID, 8, HttpStatusCode.CONFLICT_409)
+    await command.wathVideo({ videoId: video2UUID, currentTime: 8, expectedStatus: HttpStatusCode.CONFLICT_409 })
   })
 
   it('Should re-enable videos history', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: server.accessToken,
+    await server.users.updateMe({
       videosHistoryEnabled: true
     })
 
-    await userWatchVideo(server.url, server.accessToken, video1UUID, 8)
-
-    const res = await listMyVideosHistory(server.url, server.accessToken)
+    await command.wathVideo({ videoId: video1UUID, currentTime: 8 })
 
-    expect(res.body.total).to.equal(2)
+    const body = await command.list()
+    expect(body.total).to.equal(2)
 
-    const videos: Video[] = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('video 1')
     expect(videos[1].name).to.equal('video 3')
   })
@@ -205,30 +187,29 @@ describe('Test videos history', function () {
   it('Should not clean old history', async function () {
     this.timeout(50000)
 
-    killallServers([ server ])
+    await killallServers([ server ])
 
-    await reRunServer(server, { history: { videos: { max_age: '10 days' } } })
+    await server.run({ history: { videos: { max_age: '10 days' } } })
 
     await wait(6000)
 
     // Should still have history
 
-    const res = await listMyVideosHistory(server.url, server.accessToken)
-
-    expect(res.body.total).to.equal(2)
+    const body = await command.list()
+    expect(body.total).to.equal(2)
   })
 
   it('Should clean old history', async function () {
     this.timeout(50000)
 
-    killallServers([ server ])
+    await killallServers([ server ])
 
-    await reRunServer(server, { history: { videos: { max_age: '5 seconds' } } })
+    await server.run({ history: { videos: { max_age: '5 seconds' } } })
 
     await wait(6000)
 
-    const res = await listMyVideosHistory(server.url, server.accessToken)
-    expect(res.body.total).to.equal(0)
+    const body = await command.list()
+    expect(body.total).to.equal(0)
   })
 
   after(async function () {
diff --git a/server/tests/api/videos/videos-overview.ts b/server/tests/api/videos/videos-overview.ts
index c266a1dc5..70aa66549 100644
--- a/server/tests/api/videos/videos-overview.ts
+++ b/server/tests/api/videos/videos-overview.ts
@@ -2,29 +2,15 @@
 
 import 'mocha'
 import * as chai from 'chai'
-
-import {
-  cleanupTests,
-  flushAndRunServer,
-  generateUserAccessToken,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo,
-  wait
-} from '../../../../shared/extra-utils'
-import { getVideosOverview, getVideosOverviewWithToken } from '../../../../shared/extra-utils/overviews/overviews'
-import { VideosOverview } from '../../../../shared/models/overviews'
-import { addAccountToAccountBlocklist } from '@shared/extra-utils/users/blocklist'
-import { Response } from 'superagent'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers, wait } from '@shared/extra-utils'
+import { VideosOverview } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test a videos overview', function () {
-  let server: ServerInfo = null
-
-  function testOverviewCount (res: Response, expected: number) {
-    const overview: VideosOverview = res.body
+  let server: PeerTubeServer = null
 
+  function testOverviewCount (overview: VideosOverview, expected: number) {
     expect(overview.tags).to.have.lengthOf(expected)
     expect(overview.categories).to.have.lengthOf(expected)
     expect(overview.channels).to.have.lengthOf(expected)
@@ -33,15 +19,15 @@ describe('Test a videos overview', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
   })
 
   it('Should send empty overview', async function () {
-    const res = await getVideosOverview(server.url, 1)
+    const body = await server.overviews.getVideos({ page: 1 })
 
-    testOverviewCount(res, 0)
+    testOverviewCount(body, 0)
   })
 
   it('Should upload 5 videos in a specific category, tag and channel but not include them in overview', async function () {
@@ -49,40 +35,45 @@ describe('Test a videos overview', function () {
 
     await wait(3000)
 
-    await uploadVideo(server.url, server.accessToken, {
-      name: 'video 0',
-      category: 3,
-      tags: [ 'coucou1', 'coucou2' ]
+    await server.videos.upload({
+      attributes: {
+        name: 'video 0',
+        category: 3,
+        tags: [ 'coucou1', 'coucou2' ]
+      }
     })
 
-    const res = await getVideosOverview(server.url, 1)
+    const body = await server.overviews.getVideos({ page: 1 })
 
-    testOverviewCount(res, 0)
+    testOverviewCount(body, 0)
   })
 
   it('Should upload another video and include all videos in the overview', async function () {
     this.timeout(30000)
 
-    for (let i = 1; i < 6; i++) {
-      await uploadVideo(server.url, server.accessToken, {
-        name: 'video ' + i,
-        category: 3,
-        tags: [ 'coucou1', 'coucou2' ]
-      })
+    {
+      for (let i = 1; i < 6; i++) {
+        await server.videos.upload({
+          attributes: {
+            name: 'video ' + i,
+            category: 3,
+            tags: [ 'coucou1', 'coucou2' ]
+          }
+        })
+      }
+
+      await wait(3000)
     }
 
-    await wait(3000)
-
     {
-      const res = await getVideosOverview(server.url, 1)
+      const body = await server.overviews.getVideos({ page: 1 })
 
-      testOverviewCount(res, 1)
+      testOverviewCount(body, 1)
     }
 
     {
-      const res = await getVideosOverview(server.url, 2)
+      const overview = await server.overviews.getVideos({ page: 2 })
 
-      const overview: VideosOverview = res.body
       expect(overview.tags).to.have.lengthOf(1)
       expect(overview.categories).to.have.lengthOf(0)
       expect(overview.channels).to.have.lengthOf(0)
@@ -90,20 +81,10 @@ describe('Test a videos overview', function () {
   })
 
   it('Should have the correct overview', async function () {
-    const res1 = await getVideosOverview(server.url, 1)
-    const res2 = await getVideosOverview(server.url, 2)
-
-    const overview1: VideosOverview = res1.body
-    const overview2: VideosOverview = res2.body
-
-    const tmp = [
-      overview1.tags,
-      overview1.categories,
-      overview1.channels,
-      overview2.tags
-    ]
+    const overview1 = await server.overviews.getVideos({ page: 1 })
+    const overview2 = await server.overviews.getVideos({ page: 2 })
 
-    for (const arr of tmp) {
+    for (const arr of [ overview1.tags, overview1.categories, overview1.channels, overview2.tags ]) {
       expect(arr).to.have.lengthOf(1)
 
       const obj = arr[0]
@@ -127,20 +108,20 @@ describe('Test a videos overview', function () {
   })
 
   it('Should hide muted accounts', async function () {
-    const token = await generateUserAccessToken(server, 'choco')
+    const token = await server.users.generateUserAndToken('choco')
 
-    await addAccountToAccountBlocklist(server.url, token, 'root@' + server.host)
+    await server.blocklist.addToMyBlocklist({ token, account: 'root@' + server.host })
 
     {
-      const res = await getVideosOverview(server.url, 1)
+      const body = await server.overviews.getVideos({ page: 1 })
 
-      testOverviewCount(res, 1)
+      testOverviewCount(body, 1)
     }
 
     {
-      const res = await getVideosOverviewWithToken(server.url, 1, token)
+      const body = await server.overviews.getVideos({ page: 1, token })
 
-      testOverviewCount(res, 0)
+      testOverviewCount(body, 0)
     }
   })
 
diff --git a/server/tests/api/videos/videos-views-cleaner.ts b/server/tests/api/videos/videos-views-cleaner.ts
index b89f33217..82268b1be 100644
--- a/server/tests/api/videos/videos-views-cleaner.ts
+++ b/server/tests/api/videos/videos-views-cleaner.ts
@@ -1,19 +1,14 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
   cleanupTests,
-  closeAllSequelize,
-  countVideoViewsOf,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
   killallServers,
-  reRunServer,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  uploadVideoAndGetId,
-  viewVideo,
   wait,
   waitJobs
 } from '../../../../shared/extra-utils'
@@ -21,7 +16,7 @@ import {
 const expect = chai.expect
 
 describe('Test video views cleaner', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
 
   let videoIdServer1: string
   let videoIdServer2: string
@@ -29,20 +24,20 @@ describe('Test video views cleaner', function () {
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     await doubleFollow(servers[0], servers[1])
 
-    videoIdServer1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video server 1' })).uuid
-    videoIdServer2 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video server 2' })).uuid
+    videoIdServer1 = (await servers[0].videos.quickUpload({ name: 'video server 1' })).uuid
+    videoIdServer2 = (await servers[1].videos.quickUpload({ name: 'video server 2' })).uuid
 
     await waitJobs(servers)
 
-    await viewVideo(servers[0].url, videoIdServer1)
-    await viewVideo(servers[1].url, videoIdServer1)
-    await viewVideo(servers[0].url, videoIdServer2)
-    await viewVideo(servers[1].url, videoIdServer2)
+    await servers[0].videos.view({ id: videoIdServer1 })
+    await servers[1].videos.view({ id: videoIdServer1 })
+    await servers[0].videos.view({ id: videoIdServer2 })
+    await servers[1].videos.view({ id: videoIdServer2 })
 
     await waitJobs(servers)
   })
@@ -50,9 +45,9 @@ describe('Test video views cleaner', function () {
   it('Should not clean old video views', async function () {
     this.timeout(50000)
 
-    killallServers([ servers[0] ])
+    await killallServers([ servers[0] ])
 
-    await reRunServer(servers[0], { views: { videos: { remote: { max_age: '10 days' } } } })
+    await servers[0].run({ views: { videos: { remote: { max_age: '10 days' } } } })
 
     await wait(6000)
 
@@ -60,14 +55,14 @@ describe('Test video views cleaner', function () {
 
     {
       for (const server of servers) {
-        const total = await countVideoViewsOf(server.internalServerNumber, videoIdServer1)
+        const total = await server.sql.countVideoViewsOf(videoIdServer1)
         expect(total).to.equal(2, 'Server ' + server.serverNumber + ' does not have the correct amount of views')
       }
     }
 
     {
       for (const server of servers) {
-        const total = await countVideoViewsOf(server.internalServerNumber, videoIdServer2)
+        const total = await server.sql.countVideoViewsOf(videoIdServer2)
         expect(total).to.equal(2, 'Server ' + server.serverNumber + ' does not have the correct amount of views')
       }
     }
@@ -76,9 +71,9 @@ describe('Test video views cleaner', function () {
   it('Should clean old video views', async function () {
     this.timeout(50000)
 
-    killallServers([ servers[0] ])
+    await killallServers([ servers[0] ])
 
-    await reRunServer(servers[0], { views: { videos: { remote: { max_age: '5 seconds' } } } })
+    await servers[0].run({ views: { videos: { remote: { max_age: '5 seconds' } } } })
 
     await wait(6000)
 
@@ -86,23 +81,21 @@ describe('Test video views cleaner', function () {
 
     {
       for (const server of servers) {
-        const total = await countVideoViewsOf(server.internalServerNumber, videoIdServer1)
+        const total = await server.sql.countVideoViewsOf(videoIdServer1)
         expect(total).to.equal(2)
       }
     }
 
     {
-      const totalServer1 = await countVideoViewsOf(servers[0].internalServerNumber, videoIdServer2)
+      const totalServer1 = await servers[0].sql.countVideoViewsOf(videoIdServer2)
       expect(totalServer1).to.equal(0)
 
-      const totalServer2 = await countVideoViewsOf(servers[1].internalServerNumber, videoIdServer2)
+      const totalServer2 = await servers[1].sql.countVideoViewsOf(videoIdServer2)
       expect(totalServer2).to.equal(2)
     }
   })
 
   after(async function () {
-    await closeAllSequelize(servers)
-
     await cleanupTests(servers)
   })
 })