Merge branch 'next' into develop

135 files changed, 5682 insertions, 5503 deletions

diff --git a/shared/core-utils/miscs/index.ts b/shared/core-utils/miscs/index.ts
index 251df1de2..afd147f24 100644
--- a/shared/core-utils/miscs/index.ts
+++ b/shared/core-utils/miscs/index.ts
@@ -1,5 +1,3 @@
 export * from './date'
 export * from './miscs'
 export * from './types'
-export * from './http-error-codes'
-export * from './http-methods'
diff --git a/shared/extra-utils/bulk/bulk-command.ts b/shared/extra-utils/bulk/bulk-command.ts
new file mode 100644
index 000000000..b5c5673ce
--- /dev/null
+++ b/shared/extra-utils/bulk/bulk-command.ts
@@ -0,0 +1,20 @@
+import { BulkRemoveCommentsOfBody, HttpStatusCode } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class BulkCommand extends AbstractCommand {
+
+  removeCommentsOf (options: OverrideCommandOptions & {
+    attributes: BulkRemoveCommentsOfBody
+  }) {
+    const { attributes } = options
+
+    return this.postBodyRequest({
+      ...options,
+
+      path: '/api/v1/bulk/remove-comments-of',
+      fields: attributes,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/bulk/bulk.ts b/shared/extra-utils/bulk/bulk.ts
deleted file mode 100644
index b6f437b8b..000000000
--- a/shared/extra-utils/bulk/bulk.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { BulkRemoveCommentsOfBody } from "@shared/models/bulk/bulk-remove-comments-of-body.model"
-import { makePostBodyRequest } from "../requests/requests"
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function bulkRemoveCommentsOf (options: {
-  url: string
-  token: string
-  attributes: BulkRemoveCommentsOfBody
-  expectedStatus?: number
-}) {
-  const { url, token, attributes, expectedStatus } = options
-  const path = '/api/v1/bulk/remove-comments-of'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    fields: attributes,
-    statusCodeExpected: expectedStatus || HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-export {
-  bulkRemoveCommentsOf
-}
diff --git a/shared/extra-utils/bulk/index.ts b/shared/extra-utils/bulk/index.ts
new file mode 100644
index 000000000..391597243
--- /dev/null
+++ b/shared/extra-utils/bulk/index.ts
@@ -0,0 +1 @@
+export * from './bulk-command'
diff --git a/shared/extra-utils/cli/cli-command.ts b/shared/extra-utils/cli/cli-command.ts
new file mode 100644
index 000000000..bc1dddc68
--- /dev/null
+++ b/shared/extra-utils/cli/cli-command.ts
@@ -0,0 +1,23 @@
+import { exec } from 'child_process'
+import { AbstractCommand } from '../shared'
+
+export class CLICommand extends AbstractCommand {
+
+  static exec (command: string) {
+    return new Promise<string>((res, rej) => {
+      exec(command, (err, stdout, _stderr) => {
+        if (err) return rej(err)
+
+        return res(stdout)
+      })
+    })
+  }
+
+  getEnv () {
+    return `NODE_ENV=test NODE_APP_INSTANCE=${this.server.internalServerNumber}`
+  }
+
+  async execWithEnv (command: string) {
+    return CLICommand.exec(`${this.getEnv()} ${command}`)
+  }
+}
diff --git a/shared/extra-utils/cli/cli.ts b/shared/extra-utils/cli/cli.ts
deleted file mode 100644
index c62e170bb..000000000
--- a/shared/extra-utils/cli/cli.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { exec } from 'child_process'
-
-import { ServerInfo } from '../server/servers'
-
-function getEnvCli (server?: ServerInfo) {
-  return `NODE_ENV=test NODE_APP_INSTANCE=${server.internalServerNumber}`
-}
-
-async function execCLI (command: string) {
-  return new Promise<string>((res, rej) => {
-    exec(command, (err, stdout, stderr) => {
-      if (err) return rej(err)
-
-      return res(stdout)
-    })
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  execCLI,
-  getEnvCli
-}
diff --git a/shared/extra-utils/cli/index.ts b/shared/extra-utils/cli/index.ts
new file mode 100644
index 000000000..91b5abfbe
--- /dev/null
+++ b/shared/extra-utils/cli/index.ts
@@ -0,0 +1 @@
+export * from './cli-command'
diff --git a/shared/extra-utils/custom-pages/custom-pages-command.ts b/shared/extra-utils/custom-pages/custom-pages-command.ts
new file mode 100644
index 000000000..cd869a8de
--- /dev/null
+++ b/shared/extra-utils/custom-pages/custom-pages-command.ts
@@ -0,0 +1,33 @@
+import { CustomPage, HttpStatusCode } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class CustomPagesCommand extends AbstractCommand {
+
+  getInstanceHomepage (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/custom-pages/homepage/instance'
+
+    return this.getRequestBody<CustomPage>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  updateInstanceHomepage (options: OverrideCommandOptions & {
+    content: string
+  }) {
+    const { content } = options
+    const path = '/api/v1/custom-pages/homepage/instance'
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: { content },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/custom-pages/custom-pages.ts b/shared/extra-utils/custom-pages/custom-pages.ts
deleted file mode 100644
index bf2d16c70..000000000
--- a/shared/extra-utils/custom-pages/custom-pages.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { makeGetRequest, makePutBodyRequest } from '../requests/requests'
-
-function getInstanceHomepage (url: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/custom-pages/homepage/instance'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected
-  })
-}
-
-function updateInstanceHomepage (url: string, token: string, content: string) {
-  const path = '/api/v1/custom-pages/homepage/instance'
-
-  return makePutBodyRequest({
-    url,
-    path,
-    token,
-    fields: { content },
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getInstanceHomepage,
-  updateInstanceHomepage
-}
diff --git a/shared/extra-utils/custom-pages/index.ts b/shared/extra-utils/custom-pages/index.ts
new file mode 100644
index 000000000..58aed04f2
--- /dev/null
+++ b/shared/extra-utils/custom-pages/index.ts
@@ -0,0 +1 @@
+export * from './custom-pages-command'
diff --git a/shared/extra-utils/feeds/feeds-command.ts b/shared/extra-utils/feeds/feeds-command.ts
new file mode 100644
index 000000000..3c95f9536
--- /dev/null
+++ b/shared/extra-utils/feeds/feeds-command.ts
@@ -0,0 +1,44 @@
+
+import { HttpStatusCode } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+type FeedType = 'videos' | 'video-comments' | 'subscriptions'
+
+export class FeedCommand extends AbstractCommand {
+
+  getXML (options: OverrideCommandOptions & {
+    feed: FeedType
+    format?: string
+  }) {
+    const { feed, format } = options
+    const path = '/feeds/' + feed + '.xml'
+
+    return this.getRequestText({
+      ...options,
+
+      path,
+      query: format ? { format } : undefined,
+      accept: 'application/xml',
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getJSON (options: OverrideCommandOptions & {
+    feed: FeedType
+    query?: { [ id: string ]: any }
+  }) {
+    const { feed, query } = options
+    const path = '/feeds/' + feed + '.json'
+
+    return this.getRequestText({
+      ...options,
+
+      path,
+      query,
+      accept: 'application/json',
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/feeds/feeds.ts b/shared/extra-utils/feeds/feeds.ts
deleted file mode 100644
index ce0a98c6d..000000000
--- a/shared/extra-utils/feeds/feeds.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import * as request from 'supertest'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-type FeedType = 'videos' | 'video-comments' | 'subscriptions'
-
-function getXMLfeed (url: string, feed: FeedType, format?: string) {
-  const path = '/feeds/' + feed + '.xml'
-
-  return request(url)
-          .get(path)
-          .query((format) ? { format: format } : {})
-          .set('Accept', 'application/xml')
-          .expect(HttpStatusCode.OK_200)
-          .expect('Content-Type', /xml/)
-}
-
-function getJSONfeed (url: string, feed: FeedType, query: any = {}, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/feeds/' + feed + '.json'
-
-  return request(url)
-          .get(path)
-          .query(query)
-          .set('Accept', 'application/json')
-          .expect(statusCodeExpected)
-          .expect('Content-Type', /json/)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getXMLfeed,
-  getJSONfeed
-}
diff --git a/shared/extra-utils/feeds/index.ts b/shared/extra-utils/feeds/index.ts
new file mode 100644
index 000000000..662a22b6f
--- /dev/null
+++ b/shared/extra-utils/feeds/index.ts
@@ -0,0 +1 @@
+export * from './feeds-command'
diff --git a/shared/extra-utils/index.ts b/shared/extra-utils/index.ts
index 87ee8abba..4b3636d06 100644
--- a/shared/extra-utils/index.ts
+++ b/shared/extra-utils/index.ts
@@ -1,51 +1,15 @@
-export * from './bulk/bulk'
-
-export * from './cli/cli'
-
-export * from './custom-pages/custom-pages'
-
-export * from './feeds/feeds'
-
-export * from './mock-servers/mock-instances-index'
-
-export * from './miscs/email'
-export * from './miscs/sql'
-export * from './miscs/miscs'
-export * from './miscs/stubs'
-
-export * from './moderation/abuses'
-export * from './plugins/mock-blocklist'
-
-export * from './requests/check-api-params'
-export * from './requests/requests'
-
-export * from './search/video-channels'
-export * from './search/video-playlists'
-export * from './search/videos'
-
-export * from './server/activitypub'
-export * from './server/clients'
-export * from './server/config'
-export * from './server/debug'
-export * from './server/follows'
-export * from './server/jobs'
-export * from './server/plugins'
-export * from './server/servers'
-
-export * from './users/accounts'
-export * from './users/blocklist'
-export * from './users/login'
-export * from './users/user-notifications'
-export * from './users/user-subscriptions'
-export * from './users/users'
-
-export * from './videos/live'
-export * from './videos/services'
-export * from './videos/video-blacklist'
-export * from './videos/video-captions'
-export * from './videos/video-change-ownership'
-export * from './videos/video-channels'
-export * from './videos/video-comments'
-export * from './videos/video-playlists'
-export * from './videos/video-streaming-playlists'
-export * from './videos/videos'
+export * from './bulk'
+export * from './cli'
+export * from './custom-pages'
+export * from './feeds'
+export * from './logs'
+export * from './miscs'
+export * from './mock-servers'
+export * from './moderation'
+export * from './overviews'
+export * from './requests'
+export * from './search'
+export * from './server'
+export * from './socket'
+export * from './users'
+export * from './videos'
diff --git a/shared/extra-utils/logs/index.ts b/shared/extra-utils/logs/index.ts
new file mode 100644
index 000000000..69452d7f0
--- /dev/null
+++ b/shared/extra-utils/logs/index.ts
@@ -0,0 +1 @@
+export * from './logs-command'
diff --git a/shared/extra-utils/logs/logs-command.ts b/shared/extra-utils/logs/logs-command.ts
new file mode 100644
index 000000000..5912e814f
--- /dev/null
+++ b/shared/extra-utils/logs/logs-command.ts
@@ -0,0 +1,43 @@
+import { HttpStatusCode } from '@shared/models'
+import { LogLevel } from '../../models/server/log-level.type'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class LogsCommand extends AbstractCommand {
+
+  getLogs (options: OverrideCommandOptions & {
+    startDate: Date
+    endDate?: Date
+    level?: LogLevel
+  }) {
+    const { startDate, endDate, level } = options
+    const path = '/api/v1/server/logs'
+
+    return this.getRequestBody({
+      ...options,
+
+      path,
+      query: { startDate, endDate, level },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getAuditLogs (options: OverrideCommandOptions & {
+    startDate: Date
+    endDate?: Date
+  }) {
+    const { startDate, endDate } = options
+
+    const path = '/api/v1/server/audit-logs'
+
+    return this.getRequestBody({
+      ...options,
+
+      path,
+      query: { startDate, endDate },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+}
diff --git a/shared/extra-utils/logs/logs.ts b/shared/extra-utils/logs/logs.ts
deleted file mode 100644
index 8d741276c..000000000
--- a/shared/extra-utils/logs/logs.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { makeGetRequest } from '../requests/requests'
-import { LogLevel } from '../../models/server/log-level.type'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getLogs (url: string, accessToken: string, startDate: Date, endDate?: Date, level?: LogLevel) {
-  const path = '/api/v1/server/logs'
-
-  return makeGetRequest({
-    url,
-    path,
-    token: accessToken,
-    query: { startDate, endDate, level },
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getAuditLogs (url: string, accessToken: string, startDate: Date, endDate?: Date) {
-  const path = '/api/v1/server/audit-logs'
-
-  return makeGetRequest({
-    url,
-    path,
-    token: accessToken,
-    query: { startDate, endDate },
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-export {
-  getLogs,
-  getAuditLogs
-}
diff --git a/shared/extra-utils/miscs/checks.ts b/shared/extra-utils/miscs/checks.ts
new file mode 100644
index 000000000..7fc92f804
--- /dev/null
+++ b/shared/extra-utils/miscs/checks.ts
@@ -0,0 +1,46 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/no-floating-promises */
+
+import { expect } from 'chai'
+import { pathExists, readFile } from 'fs-extra'
+import { join } from 'path'
+import { root } from '@server/helpers/core-utils'
+import { HttpStatusCode } from '@shared/models'
+import { makeGetRequest } from '../requests'
+import { PeerTubeServer } from '../server'
+
+// Default interval -> 5 minutes
+function dateIsValid (dateString: string, interval = 300000) {
+  const dateToCheck = new Date(dateString)
+  const now = new Date()
+
+  return Math.abs(now.getTime() - dateToCheck.getTime()) <= interval
+}
+
+async function testImage (url: string, imageName: string, imagePath: string, extension = '.jpg') {
+  const res = await makeGetRequest({
+    url,
+    path: imagePath,
+    expectedStatus: HttpStatusCode.OK_200
+  })
+
+  const body = res.body
+
+  const data = await readFile(join(root(), 'server', 'tests', 'fixtures', imageName + extension))
+  const minLength = body.length - ((30 * body.length) / 100)
+  const maxLength = body.length + ((30 * body.length) / 100)
+
+  expect(data.length).to.be.above(minLength, 'the generated image is way smaller than the recorded fixture')
+  expect(data.length).to.be.below(maxLength, 'the generated image is way larger than the recorded fixture')
+}
+
+async function testFileExistsOrNot (server: PeerTubeServer, directory: string, filePath: string, exist: boolean) {
+  const base = server.servers.buildDirectory(directory)
+
+  expect(await pathExists(join(base, filePath))).to.equal(exist)
+}
+
+export {
+  dateIsValid,
+  testImage,
+  testFileExistsOrNot
+}
diff --git a/shared/extra-utils/miscs/generate.ts b/shared/extra-utils/miscs/generate.ts
new file mode 100644
index 000000000..8d6435481
--- /dev/null
+++ b/shared/extra-utils/miscs/generate.ts
@@ -0,0 +1,61 @@
+import * as ffmpeg from 'fluent-ffmpeg'
+import { ensureDir, pathExists } from 'fs-extra'
+import { dirname } from 'path'
+import { buildAbsoluteFixturePath } from './tests'
+
+async function generateHighBitrateVideo () {
+  const tempFixturePath = buildAbsoluteFixturePath('video_high_bitrate_1080p.mp4', true)
+
+  await ensureDir(dirname(tempFixturePath))
+
+  const exists = await pathExists(tempFixturePath)
+  if (!exists) {
+    console.log('Generating high bitrate video.')
+
+    // Generate a random, high bitrate video on the fly, so we don't have to include
+    // a large file in the repo. The video needs to have a certain minimum length so
+    // that FFmpeg properly applies bitrate limits.
+    // https://stackoverflow.com/a/15795112
+    return new Promise<string>((res, rej) => {
+      ffmpeg()
+        .outputOptions([ '-f rawvideo', '-video_size 1920x1080', '-i /dev/urandom' ])
+        .outputOptions([ '-ac 2', '-f s16le', '-i /dev/urandom', '-t 10' ])
+        .outputOptions([ '-maxrate 10M', '-bufsize 10M' ])
+        .output(tempFixturePath)
+        .on('error', rej)
+        .on('end', () => res(tempFixturePath))
+        .run()
+    })
+  }
+
+  return tempFixturePath
+}
+
+async function generateVideoWithFramerate (fps = 60) {
+  const tempFixturePath = buildAbsoluteFixturePath(`video_${fps}fps.mp4`, true)
+
+  await ensureDir(dirname(tempFixturePath))
+
+  const exists = await pathExists(tempFixturePath)
+  if (!exists) {
+    console.log('Generating video with framerate %d.', fps)
+
+    return new Promise<string>((res, rej) => {
+      ffmpeg()
+        .outputOptions([ '-f rawvideo', '-video_size 1280x720', '-i /dev/urandom' ])
+        .outputOptions([ '-ac 2', '-f s16le', '-i /dev/urandom', '-t 10' ])
+        .outputOptions([ `-r ${fps}` ])
+        .output(tempFixturePath)
+        .on('error', rej)
+        .on('end', () => res(tempFixturePath))
+        .run()
+    })
+  }
+
+  return tempFixturePath
+}
+
+export {
+  generateHighBitrateVideo,
+  generateVideoWithFramerate
+}
diff --git a/shared/extra-utils/miscs/index.ts b/shared/extra-utils/miscs/index.ts
new file mode 100644
index 000000000..4474661de
--- /dev/null
+++ b/shared/extra-utils/miscs/index.ts
@@ -0,0 +1,5 @@
+export * from './checks'
+export * from './generate'
+export * from './sql-command'
+export * from './tests'
+export * from './webtorrent'
diff --git a/shared/extra-utils/miscs/miscs.ts b/shared/extra-utils/miscs/miscs.ts
deleted file mode 100644
index 462b914d4..000000000
--- a/shared/extra-utils/miscs/miscs.ts
+++ /dev/null
@@ -1,170 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-
-import * as chai from 'chai'
-import * as ffmpeg from 'fluent-ffmpeg'
-import { ensureDir, pathExists, readFile, stat } from 'fs-extra'
-import { basename, dirname, isAbsolute, join, resolve } from 'path'
-import * as request from 'supertest'
-import * as WebTorrent from 'webtorrent'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-const expect = chai.expect
-let webtorrent: WebTorrent.Instance
-
-function immutableAssign<T, U> (target: T, source: U) {
-  return Object.assign<{}, T, U>({}, target, source)
-}
-
-// Default interval -> 5 minutes
-function dateIsValid (dateString: string, interval = 300000) {
-  const dateToCheck = new Date(dateString)
-  const now = new Date()
-
-  return Math.abs(now.getTime() - dateToCheck.getTime()) <= interval
-}
-
-function wait (milliseconds: number) {
-  return new Promise(resolve => setTimeout(resolve, milliseconds))
-}
-
-function webtorrentAdd (torrent: string, refreshWebTorrent = false) {
-  const WebTorrent = require('webtorrent')
-
-  if (!webtorrent) webtorrent = new WebTorrent()
-  if (refreshWebTorrent === true) webtorrent = new WebTorrent()
-
-  return new Promise<WebTorrent.Torrent>(res => webtorrent.add(torrent, res))
-}
-
-function root () {
-  // We are in /miscs
-  let root = join(__dirname, '..', '..', '..')
-
-  if (basename(root) === 'dist') root = resolve(root, '..')
-
-  return root
-}
-
-function buildServerDirectory (server: { internalServerNumber: number }, directory: string) {
-  return join(root(), 'test' + server.internalServerNumber, directory)
-}
-
-async function testImage (url: string, imageName: string, imagePath: string, extension = '.jpg') {
-  const res = await request(url)
-    .get(imagePath)
-    .expect(HttpStatusCode.OK_200)
-
-  const body = res.body
-
-  const data = await readFile(join(root(), 'server', 'tests', 'fixtures', imageName + extension))
-  const minLength = body.length - ((30 * body.length) / 100)
-  const maxLength = body.length + ((30 * body.length) / 100)
-
-  expect(data.length).to.be.above(minLength, 'the generated image is way smaller than the recorded fixture')
-  expect(data.length).to.be.below(maxLength, 'the generated image is way larger than the recorded fixture')
-}
-
-async function testFileExistsOrNot (server: { internalServerNumber: number }, directory: string, filePath: string, exist: boolean) {
-  const base = buildServerDirectory(server, directory)
-
-  expect(await pathExists(join(base, filePath))).to.equal(exist)
-}
-
-function isGithubCI () {
-  return !!process.env.GITHUB_WORKSPACE
-}
-
-function buildAbsoluteFixturePath (path: string, customCIPath = false) {
-  if (isAbsolute(path)) return path
-
-  if (customCIPath && process.env.GITHUB_WORKSPACE) {
-    return join(process.env.GITHUB_WORKSPACE, 'fixtures', path)
-  }
-
-  return join(root(), 'server', 'tests', 'fixtures', path)
-}
-
-function areHttpImportTestsDisabled () {
-  const disabled = process.env.DISABLE_HTTP_IMPORT_TESTS === 'true'
-
-  if (disabled) console.log('Import tests are disabled')
-
-  return disabled
-}
-
-async function generateHighBitrateVideo () {
-  const tempFixturePath = buildAbsoluteFixturePath('video_high_bitrate_1080p.mp4', true)
-
-  await ensureDir(dirname(tempFixturePath))
-
-  const exists = await pathExists(tempFixturePath)
-  if (!exists) {
-    console.log('Generating high bitrate video.')
-
-    // Generate a random, high bitrate video on the fly, so we don't have to include
-    // a large file in the repo. The video needs to have a certain minimum length so
-    // that FFmpeg properly applies bitrate limits.
-    // https://stackoverflow.com/a/15795112
-    return new Promise<string>((res, rej) => {
-      ffmpeg()
-        .outputOptions([ '-f rawvideo', '-video_size 1920x1080', '-i /dev/urandom' ])
-        .outputOptions([ '-ac 2', '-f s16le', '-i /dev/urandom', '-t 10' ])
-        .outputOptions([ '-maxrate 10M', '-bufsize 10M' ])
-        .output(tempFixturePath)
-        .on('error', rej)
-        .on('end', () => res(tempFixturePath))
-        .run()
-    })
-  }
-
-  return tempFixturePath
-}
-
-async function generateVideoWithFramerate (fps = 60) {
-  const tempFixturePath = buildAbsoluteFixturePath(`video_${fps}fps.mp4`, true)
-
-  await ensureDir(dirname(tempFixturePath))
-
-  const exists = await pathExists(tempFixturePath)
-  if (!exists) {
-    console.log('Generating video with framerate %d.', fps)
-
-    return new Promise<string>((res, rej) => {
-      ffmpeg()
-        .outputOptions([ '-f rawvideo', '-video_size 1280x720', '-i /dev/urandom' ])
-        .outputOptions([ '-ac 2', '-f s16le', '-i /dev/urandom', '-t 10' ])
-        .outputOptions([ `-r ${fps}` ])
-        .output(tempFixturePath)
-        .on('error', rej)
-        .on('end', () => res(tempFixturePath))
-        .run()
-    })
-  }
-
-  return tempFixturePath
-}
-
-async function getFileSize (path: string) {
-  const stats = await stat(path)
-
-  return stats.size
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  dateIsValid,
-  wait,
-  areHttpImportTestsDisabled,
-  buildServerDirectory,
-  webtorrentAdd,
-  getFileSize,
-  immutableAssign,
-  testImage,
-  isGithubCI,
-  buildAbsoluteFixturePath,
-  testFileExistsOrNot,
-  root,
-  generateHighBitrateVideo,
-  generateVideoWithFramerate
-}
diff --git a/shared/extra-utils/miscs/sql-command.ts b/shared/extra-utils/miscs/sql-command.ts
new file mode 100644
index 000000000..80c8cd271
--- /dev/null
+++ b/shared/extra-utils/miscs/sql-command.ts
@@ -0,0 +1,142 @@
+import { QueryTypes, Sequelize } from 'sequelize'
+import { AbstractCommand } from '../shared/abstract-command'
+
+export class SQLCommand extends AbstractCommand {
+  private sequelize: Sequelize
+
+  deleteAll (table: string) {
+    const seq = this.getSequelize()
+
+    const options = { type: QueryTypes.DELETE }
+
+    return seq.query(`DELETE FROM "${table}"`, options)
+  }
+
+  async getCount (table: string) {
+    const seq = this.getSequelize()
+
+    const options = { type: QueryTypes.SELECT as QueryTypes.SELECT }
+
+    const [ { total } ] = await seq.query<{ total: string }>(`SELECT COUNT(*) as total FROM "${table}"`, options)
+    if (total === null) return 0
+
+    return parseInt(total, 10)
+  }
+
+  setActorField (to: string, field: string, value: string) {
+    const seq = this.getSequelize()
+
+    const options = { type: QueryTypes.UPDATE }
+
+    return seq.query(`UPDATE actor SET "${field}" = '${value}' WHERE url = '${to}'`, options)
+  }
+
+  setVideoField (uuid: string, field: string, value: string) {
+    const seq = this.getSequelize()
+
+    const options = { type: QueryTypes.UPDATE }
+
+    return seq.query(`UPDATE video SET "${field}" = '${value}' WHERE uuid = '${uuid}'`, options)
+  }
+
+  setPlaylistField (uuid: string, field: string, value: string) {
+    const seq = this.getSequelize()
+
+    const options = { type: QueryTypes.UPDATE }
+
+    return seq.query(`UPDATE "videoPlaylist" SET "${field}" = '${value}' WHERE uuid = '${uuid}'`, options)
+  }
+
+  async countVideoViewsOf (uuid: string) {
+    const seq = this.getSequelize()
+
+    // tslint:disable
+    const query = 'SELECT SUM("videoView"."views") AS "total" FROM "videoView" ' +
+      `INNER JOIN "video" ON "video"."id" = "videoView"."videoId" WHERE "video"."uuid" = '${uuid}'`
+
+    const options = { type: QueryTypes.SELECT as QueryTypes.SELECT }
+    const [ { total } ] = await seq.query<{ total: number }>(query, options)
+
+    if (!total) return 0
+
+    return parseInt(total + '', 10)
+  }
+
+  getActorImage (filename: string) {
+    return this.selectQuery(`SELECT * FROM "actorImage" WHERE filename = '${filename}'`)
+      .then(rows => rows[0])
+  }
+
+  selectQuery (query: string) {
+    const seq = this.getSequelize()
+    const options = { type: QueryTypes.SELECT as QueryTypes.SELECT }
+
+    return seq.query<any>(query, options)
+  }
+
+  updateQuery (query: string) {
+    const seq = this.getSequelize()
+    const options = { type: QueryTypes.UPDATE as QueryTypes.UPDATE }
+
+    return seq.query(query, options)
+  }
+
+  setPluginField (pluginName: string, field: string, value: string) {
+    const seq = this.getSequelize()
+
+    const options = { type: QueryTypes.UPDATE }
+
+    return seq.query(`UPDATE "plugin" SET "${field}" = '${value}' WHERE "name" = '${pluginName}'`, options)
+  }
+
+  setPluginVersion (pluginName: string, newVersion: string) {
+    return this.setPluginField(pluginName, 'version', newVersion)
+  }
+
+  setPluginLatestVersion (pluginName: string, newVersion: string) {
+    return this.setPluginField(pluginName, 'latestVersion', newVersion)
+  }
+
+  setActorFollowScores (newScore: number) {
+    const seq = this.getSequelize()
+
+    const options = { type: QueryTypes.UPDATE }
+
+    return seq.query(`UPDATE "actorFollow" SET "score" = ${newScore}`, options)
+  }
+
+  setTokenField (accessToken: string, field: string, value: string) {
+    const seq = this.getSequelize()
+
+    const options = { type: QueryTypes.UPDATE }
+
+    return seq.query(`UPDATE "oAuthToken" SET "${field}" = '${value}' WHERE "accessToken" = '${accessToken}'`, options)
+  }
+
+  async cleanup () {
+    if (!this.sequelize) return
+
+    await this.sequelize.close()
+    this.sequelize = undefined
+  }
+
+  private getSequelize () {
+    if (this.sequelize) return this.sequelize
+
+    const dbname = 'peertube_test' + this.server.internalServerNumber
+    const username = 'peertube'
+    const password = 'peertube'
+    const host = 'localhost'
+    const port = 5432
+
+    this.sequelize = new Sequelize(dbname, username, password, {
+      dialect: 'postgres',
+      host,
+      port,
+      logging: false
+    })
+
+    return this.sequelize
+  }
+
+}
diff --git a/shared/extra-utils/miscs/sql.ts b/shared/extra-utils/miscs/sql.ts
deleted file mode 100644
index 65a0aa5fe..000000000
--- a/shared/extra-utils/miscs/sql.ts
+++ /dev/null
@@ -1,161 +0,0 @@
-import { QueryTypes, Sequelize } from 'sequelize'
-import { ServerInfo } from '../server/servers'
-
-const sequelizes: { [ id: number ]: Sequelize } = {}
-
-function getSequelize (internalServerNumber: number) {
-  if (sequelizes[internalServerNumber]) return sequelizes[internalServerNumber]
-
-  const dbname = 'peertube_test' + internalServerNumber
-  const username = 'peertube'
-  const password = 'peertube'
-  const host = 'localhost'
-  const port = 5432
-
-  const seq = new Sequelize(dbname, username, password, {
-    dialect: 'postgres',
-    host,
-    port,
-    logging: false
-  })
-
-  sequelizes[internalServerNumber] = seq
-
-  return seq
-}
-
-function deleteAll (internalServerNumber: number, table: string) {
-  const seq = getSequelize(internalServerNumber)
-
-  const options = { type: QueryTypes.DELETE }
-
-  return seq.query(`DELETE FROM "${table}"`, options)
-}
-
-async function getCount (internalServerNumber: number, table: string) {
-  const seq = getSequelize(internalServerNumber)
-
-  const options = { type: QueryTypes.SELECT as QueryTypes.SELECT }
-
-  const [ { total } ] = await seq.query<{ total: string }>(`SELECT COUNT(*) as total FROM "${table}"`, options)
-  if (total === null) return 0
-
-  return parseInt(total, 10)
-}
-
-function setActorField (internalServerNumber: number, to: string, field: string, value: string) {
-  const seq = getSequelize(internalServerNumber)
-
-  const options = { type: QueryTypes.UPDATE }
-
-  return seq.query(`UPDATE actor SET "${field}" = '${value}' WHERE url = '${to}'`, options)
-}
-
-function setVideoField (internalServerNumber: number, uuid: string, field: string, value: string) {
-  const seq = getSequelize(internalServerNumber)
-
-  const options = { type: QueryTypes.UPDATE }
-
-  return seq.query(`UPDATE video SET "${field}" = '${value}' WHERE uuid = '${uuid}'`, options)
-}
-
-function setPlaylistField (internalServerNumber: number, uuid: string, field: string, value: string) {
-  const seq = getSequelize(internalServerNumber)
-
-  const options = { type: QueryTypes.UPDATE }
-
-  return seq.query(`UPDATE "videoPlaylist" SET "${field}" = '${value}' WHERE uuid = '${uuid}'`, options)
-}
-
-async function countVideoViewsOf (internalServerNumber: number, uuid: string) {
-  const seq = getSequelize(internalServerNumber)
-
-  // tslint:disable
-  const query = 'SELECT SUM("videoView"."views") AS "total" FROM "videoView" ' +
-    `INNER JOIN "video" ON "video"."id" = "videoView"."videoId" WHERE "video"."uuid" = '${uuid}'`
-
-  const options = { type: QueryTypes.SELECT as QueryTypes.SELECT }
-  const [ { total } ] = await seq.query<{ total: number }>(query, options)
-
-  if (!total) return 0
-
-  return parseInt(total + '', 10)
-}
-
-function getActorImage (internalServerNumber: number, filename: string) {
-  return selectQuery(internalServerNumber, `SELECT * FROM "actorImage" WHERE filename = '${filename}'`)
-    .then(rows => rows[0])
-}
-
-function selectQuery (internalServerNumber: number, query: string) {
-  const seq = getSequelize(internalServerNumber)
-  const options = { type: QueryTypes.SELECT as QueryTypes.SELECT }
-
-  return seq.query<any>(query, options)
-}
-
-function updateQuery (internalServerNumber: number, query: string) {
-  const seq = getSequelize(internalServerNumber)
-  const options = { type: QueryTypes.UPDATE as QueryTypes.UPDATE }
-
-  return seq.query(query, options)
-}
-
-async function closeAllSequelize (servers: ServerInfo[]) {
-  for (const server of servers) {
-    if (sequelizes[server.internalServerNumber]) {
-      await sequelizes[server.internalServerNumber].close()
-      // eslint-disable-next-line
-      delete sequelizes[server.internalServerNumber]
-    }
-  }
-}
-
-function setPluginField (internalServerNumber: number, pluginName: string, field: string, value: string) {
-  const seq = getSequelize(internalServerNumber)
-
-  const options = { type: QueryTypes.UPDATE }
-
-  return seq.query(`UPDATE "plugin" SET "${field}" = '${value}' WHERE "name" = '${pluginName}'`, options)
-}
-
-function setPluginVersion (internalServerNumber: number, pluginName: string, newVersion: string) {
-  return setPluginField(internalServerNumber, pluginName, 'version', newVersion)
-}
-
-function setPluginLatestVersion (internalServerNumber: number, pluginName: string, newVersion: string) {
-  return setPluginField(internalServerNumber, pluginName, 'latestVersion', newVersion)
-}
-
-function setActorFollowScores (internalServerNumber: number, newScore: number) {
-  const seq = getSequelize(internalServerNumber)
-
-  const options = { type: QueryTypes.UPDATE }
-
-  return seq.query(`UPDATE "actorFollow" SET "score" = ${newScore}`, options)
-}
-
-function setTokenField (internalServerNumber: number, accessToken: string, field: string, value: string) {
-  const seq = getSequelize(internalServerNumber)
-
-  const options = { type: QueryTypes.UPDATE }
-
-  return seq.query(`UPDATE "oAuthToken" SET "${field}" = '${value}' WHERE "accessToken" = '${accessToken}'`, options)
-}
-
-export {
-  setVideoField,
-  setPlaylistField,
-  setActorField,
-  countVideoViewsOf,
-  setPluginVersion,
-  setPluginLatestVersion,
-  selectQuery,
-  getActorImage,
-  deleteAll,
-  setTokenField,
-  updateQuery,
-  setActorFollowScores,
-  closeAllSequelize,
-  getCount
-}
diff --git a/shared/extra-utils/miscs/stubs.ts b/shared/extra-utils/miscs/stubs.ts
deleted file mode 100644
index d1eb0e3b2..000000000
--- a/shared/extra-utils/miscs/stubs.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-function buildRequestStub (): any {
-  return { }
-}
-
-function buildResponseStub (): any {
-  return {
-    locals: {}
-  }
-}
-
-export {
-  buildResponseStub,
-  buildRequestStub
-}
diff --git a/shared/extra-utils/miscs/tests.ts b/shared/extra-utils/miscs/tests.ts
new file mode 100644
index 000000000..3dfb2487e
--- /dev/null
+++ b/shared/extra-utils/miscs/tests.ts
@@ -0,0 +1,94 @@
+import { stat } from 'fs-extra'
+import { basename, isAbsolute, join, resolve } from 'path'
+
+const FIXTURE_URLS = {
+  youtube: 'https://www.youtube.com/watch?v=msX3jv1XdvM',
+
+  /**
+   * The video is used to check format-selection correctness wrt. HDR,
+   * which brings its own set of oddities outside of a MediaSource.
+   * FIXME: refactor once HDR is supported at playback
+   *
+   * The video needs to have the following format_ids:
+   * (which you can check by using `youtube-dl <url> -F`):
+   * - 303 (1080p webm vp9)
+   * - 299 (1080p mp4 avc1)
+   * - 335 (1080p webm vp9.2 HDR)
+   *
+   * 15 jan. 2021: TEST VIDEO NOT CURRENTLY PROVIDING
+   * - 400 (1080p mp4 av01)
+   * - 315 (2160p webm vp9 HDR)
+   * - 337 (2160p webm vp9.2 HDR)
+   * - 401 (2160p mp4 av01 HDR)
+   */
+  youtubeHDR: 'https://www.youtube.com/watch?v=qR5vOXbZsI4',
+
+  // eslint-disable-next-line max-len
+  magnet: 'magnet:?xs=https%3A%2F%2Fpeertube2.cpy.re%2Fstatic%2Ftorrents%2Fb209ca00-c8bb-4b2b-b421-1ede169f3dbc-720.torrent&xt=urn:btih:0f498834733e8057ed5c6f2ee2b4efd8d84a76ee&dn=super+peertube2+video&tr=wss%3A%2F%2Fpeertube2.cpy.re%3A443%2Ftracker%2Fsocket&tr=https%3A%2F%2Fpeertube2.cpy.re%2Ftracker%2Fannounce&ws=https%3A%2F%2Fpeertube2.cpy.re%2Fstatic%2Fwebseed%2Fb209ca00-c8bb-4b2b-b421-1ede169f3dbc-720.mp4',
+
+  badVideo: 'https://download.cpy.re/peertube/bad_video.mp4',
+  goodVideo: 'https://download.cpy.re/peertube/good_video.mp4',
+  video4K: 'https://download.cpy.re/peertube/4k_file.txt'
+}
+
+function parallelTests () {
+  return process.env.MOCHA_PARALLEL === 'true'
+}
+
+function isGithubCI () {
+  return !!process.env.GITHUB_WORKSPACE
+}
+
+function areHttpImportTestsDisabled () {
+  const disabled = process.env.DISABLE_HTTP_IMPORT_TESTS === 'true'
+
+  if (disabled) console.log('Import tests are disabled')
+
+  return disabled
+}
+
+function buildAbsoluteFixturePath (path: string, customCIPath = false) {
+  if (isAbsolute(path)) return path
+
+  if (customCIPath && process.env.GITHUB_WORKSPACE) {
+    return join(process.env.GITHUB_WORKSPACE, 'fixtures', path)
+  }
+
+  return join(root(), 'server', 'tests', 'fixtures', path)
+}
+
+function root () {
+  // We are in /miscs
+  let root = join(__dirname, '..', '..', '..')
+
+  if (basename(root) === 'dist') root = resolve(root, '..')
+
+  return root
+}
+
+function wait (milliseconds: number) {
+  return new Promise(resolve => setTimeout(resolve, milliseconds))
+}
+
+async function getFileSize (path: string) {
+  const stats = await stat(path)
+
+  return stats.size
+}
+
+function buildRequestStub (): any {
+  return { }
+}
+
+export {
+  FIXTURE_URLS,
+
+  parallelTests,
+  isGithubCI,
+  areHttpImportTestsDisabled,
+  buildAbsoluteFixturePath,
+  getFileSize,
+  buildRequestStub,
+  wait,
+  root
+}
diff --git a/shared/extra-utils/miscs/webtorrent.ts b/shared/extra-utils/miscs/webtorrent.ts
new file mode 100644
index 000000000..815ea3d56
--- /dev/null
+++ b/shared/extra-utils/miscs/webtorrent.ts
@@ -0,0 +1,30 @@
+import { readFile } from 'fs-extra'
+import * as parseTorrent from 'parse-torrent'
+import { join } from 'path'
+import * as WebTorrent from 'webtorrent'
+import { PeerTubeServer } from '../server'
+
+let webtorrent: WebTorrent.Instance
+
+function webtorrentAdd (torrent: string, refreshWebTorrent = false) {
+  const WebTorrent = require('webtorrent')
+
+  if (!webtorrent) webtorrent = new WebTorrent()
+  if (refreshWebTorrent === true) webtorrent = new WebTorrent()
+
+  return new Promise<WebTorrent.Torrent>(res => webtorrent.add(torrent, res))
+}
+
+async function parseTorrentVideo (server: PeerTubeServer, videoUUID: string, resolution: number) {
+  const torrentName = videoUUID + '-' + resolution + '.torrent'
+  const torrentPath = server.servers.buildDirectory(join('torrents', torrentName))
+
+  const data = await readFile(torrentPath)
+
+  return parseTorrent(data)
+}
+
+export {
+  webtorrentAdd,
+  parseTorrentVideo
+}
diff --git a/shared/extra-utils/mock-servers/index.ts b/shared/extra-utils/mock-servers/index.ts
new file mode 100644
index 000000000..0ec07f685
--- /dev/null
+++ b/shared/extra-utils/mock-servers/index.ts
@@ -0,0 +1,4 @@
+export * from './mock-email'
+export * from './mock-instances-index'
+export * from './mock-joinpeertube-versions'
+export * from './mock-plugin-blocklist'
diff --git a/shared/extra-utils/miscs/email.ts b/shared/extra-utils/mock-servers/mock-email.ts
index 9fc9a5ad0..ffd62e325 100644
--- a/shared/extra-utils/miscs/email.ts
+++ b/shared/extra-utils/mock-servers/mock-email.ts
@@ -1,6 +1,6 @@
 import { ChildProcess } from 'child_process'
-import { randomInt } from '../../core-utils/miscs/miscs'
-import { parallelTests } from '../server/servers'
+import { randomInt } from '@shared/core-utils'
+import { parallelTests } from '../miscs'
 
 const MailDev = require('maildev')
 
diff --git a/shared/extra-utils/mock-servers/joinpeertube-versions.ts b/shared/extra-utils/mock-servers/mock-joinpeertube-versions.ts
index 5ea432ecf..5ea432ecf 100644
--- a/shared/extra-utils/mock-servers/joinpeertube-versions.ts
+++ b/shared/extra-utils/mock-servers/mock-joinpeertube-versions.ts
diff --git a/shared/extra-utils/plugins/mock-blocklist.ts b/shared/extra-utils/mock-servers/mock-plugin-blocklist.ts
index d18f8224f..d18f8224f 100644
--- a/shared/extra-utils/plugins/mock-blocklist.ts
+++ b/shared/extra-utils/mock-servers/mock-plugin-blocklist.ts
diff --git a/shared/extra-utils/moderation/abuses-command.ts b/shared/extra-utils/moderation/abuses-command.ts
new file mode 100644
index 000000000..7b3abb056
--- /dev/null
+++ b/shared/extra-utils/moderation/abuses-command.ts
@@ -0,0 +1,228 @@
+import { pick } from 'lodash'
+import {
+  AbuseFilter,
+  AbuseMessage,
+  AbusePredefinedReasonsString,
+  AbuseState,
+  AbuseUpdate,
+  AbuseVideoIs,
+  AdminAbuse,
+  HttpStatusCode,
+  ResultList,
+  UserAbuse
+} from '@shared/models'
+import { unwrapBody } from '../requests/requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class AbusesCommand extends AbstractCommand {
+
+  report (options: OverrideCommandOptions & {
+    reason: string
+
+    accountId?: number
+    videoId?: number
+    commentId?: number
+
+    predefinedReasons?: AbusePredefinedReasonsString[]
+
+    startAt?: number
+    endAt?: number
+  }) {
+    const path = '/api/v1/abuses'
+
+    const video = options.videoId
+      ? {
+        id: options.videoId,
+        startAt: options.startAt,
+        endAt: options.endAt
+      }
+      : undefined
+
+    const comment = options.commentId
+      ? { id: options.commentId }
+      : undefined
+
+    const account = options.accountId
+      ? { id: options.accountId }
+      : undefined
+
+    const body = {
+      account,
+      video,
+      comment,
+
+      reason: options.reason,
+      predefinedReasons: options.predefinedReasons
+    }
+
+    return unwrapBody<{ abuse: { id: number } }>(this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: body,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+  }
+
+  getAdminList (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+
+    id?: number
+    predefinedReason?: AbusePredefinedReasonsString
+    search?: string
+    filter?: AbuseFilter
+    state?: AbuseState
+    videoIs?: AbuseVideoIs
+    searchReporter?: string
+    searchReportee?: string
+    searchVideo?: string
+    searchVideoChannel?: string
+  } = {}) {
+    const toPick = [
+      'count',
+      'filter',
+      'id',
+      'predefinedReason',
+      'search',
+      'searchReportee',
+      'searchReporter',
+      'searchVideo',
+      'searchVideoChannel',
+      'sort',
+      'start',
+      'state',
+      'videoIs'
+    ]
+
+    const path = '/api/v1/abuses'
+
+    const defaultQuery = { sort: 'createdAt' }
+    const query = { ...defaultQuery, ...pick(options, toPick) }
+
+    return this.getRequestBody<ResultList<AdminAbuse>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getUserList (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+
+    id?: number
+    search?: string
+    state?: AbuseState
+  }) {
+    const toPick = [
+      'id',
+      'search',
+      'state',
+      'start',
+      'count',
+      'sort'
+    ]
+
+    const path = '/api/v1/users/me/abuses'
+
+    const defaultQuery = { sort: 'createdAt' }
+    const query = { ...defaultQuery, ...pick(options, toPick) }
+
+    return this.getRequestBody<ResultList<UserAbuse>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  update (options: OverrideCommandOptions & {
+    abuseId: number
+    body: AbuseUpdate
+  }) {
+    const { abuseId, body } = options
+    const path = '/api/v1/abuses/' + abuseId
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: body,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  delete (options: OverrideCommandOptions & {
+    abuseId: number
+  }) {
+    const { abuseId } = options
+    const path = '/api/v1/abuses/' + abuseId
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  listMessages (options: OverrideCommandOptions & {
+    abuseId: number
+  }) {
+    const { abuseId } = options
+    const path = '/api/v1/abuses/' + abuseId + '/messages'
+
+    return this.getRequestBody<ResultList<AbuseMessage>>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  deleteMessage (options: OverrideCommandOptions & {
+    abuseId: number
+    messageId: number
+  }) {
+    const { abuseId, messageId } = options
+    const path = '/api/v1/abuses/' + abuseId + '/messages/' + messageId
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  addMessage (options: OverrideCommandOptions & {
+    abuseId: number
+    message: string
+  }) {
+    const { abuseId, message } = options
+    const path = '/api/v1/abuses/' + abuseId + '/messages'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { message },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+}
diff --git a/shared/extra-utils/moderation/abuses.ts b/shared/extra-utils/moderation/abuses.ts
deleted file mode 100644
index c0fda722f..000000000
--- a/shared/extra-utils/moderation/abuses.ts
+++ /dev/null
@@ -1,244 +0,0 @@
-import { AbuseFilter, AbusePredefinedReasonsString, AbuseState, AbuseUpdate, AbuseVideoIs } from '@shared/models'
-import { makeDeleteRequest, makeGetRequest, makePostBodyRequest, makePutBodyRequest } from '../requests/requests'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function reportAbuse (options: {
-  url: string
-  token: string
-
-  reason: string
-
-  accountId?: number
-  videoId?: number
-  commentId?: number
-
-  predefinedReasons?: AbusePredefinedReasonsString[]
-
-  startAt?: number
-  endAt?: number
-
-  statusCodeExpected?: number
-}) {
-  const path = '/api/v1/abuses'
-
-  const video = options.videoId
-    ? {
-      id: options.videoId,
-      startAt: options.startAt,
-      endAt: options.endAt
-    }
-    : undefined
-
-  const comment = options.commentId
-    ? { id: options.commentId }
-    : undefined
-
-  const account = options.accountId
-    ? { id: options.accountId }
-    : undefined
-
-  const body = {
-    account,
-    video,
-    comment,
-
-    reason: options.reason,
-    predefinedReasons: options.predefinedReasons
-  }
-
-  return makePostBodyRequest({
-    url: options.url,
-    path,
-    token: options.token,
-
-    fields: body,
-    statusCodeExpected: options.statusCodeExpected || HttpStatusCode.OK_200
-  })
-}
-
-function getAdminAbusesList (options: {
-  url: string
-  token: string
-
-  start?: number
-  count?: number
-  sort?: string
-
-  id?: number
-  predefinedReason?: AbusePredefinedReasonsString
-  search?: string
-  filter?: AbuseFilter
-  state?: AbuseState
-  videoIs?: AbuseVideoIs
-  searchReporter?: string
-  searchReportee?: string
-  searchVideo?: string
-  searchVideoChannel?: string
-}) {
-  const {
-    url,
-    token,
-    start,
-    count,
-    sort,
-    id,
-    predefinedReason,
-    search,
-    filter,
-    state,
-    videoIs,
-    searchReporter,
-    searchReportee,
-    searchVideo,
-    searchVideoChannel
-  } = options
-  const path = '/api/v1/abuses'
-
-  const query = {
-    id,
-    predefinedReason,
-    search,
-    state,
-    filter,
-    videoIs,
-    start,
-    count,
-    sort: sort || 'createdAt',
-    searchReporter,
-    searchReportee,
-    searchVideo,
-    searchVideoChannel
-  }
-
-  return makeGetRequest({
-    url,
-    path,
-    token,
-    query,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getUserAbusesList (options: {
-  url: string
-  token: string
-
-  start?: number
-  count?: number
-  sort?: string
-
-  id?: number
-  search?: string
-  state?: AbuseState
-}) {
-  const {
-    url,
-    token,
-    start,
-    count,
-    sort,
-    id,
-    search,
-    state
-  } = options
-  const path = '/api/v1/users/me/abuses'
-
-  const query = {
-    id,
-    search,
-    state,
-    start,
-    count,
-    sort: sort || 'createdAt'
-  }
-
-  return makeGetRequest({
-    url,
-    path,
-    token,
-    query,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function updateAbuse (
-  url: string,
-  token: string,
-  abuseId: number,
-  body: AbuseUpdate,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/abuses/' + abuseId
-
-  return makePutBodyRequest({
-    url,
-    token,
-    path,
-    fields: body,
-    statusCodeExpected
-  })
-}
-
-function deleteAbuse (url: string, token: string, abuseId: number, statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/abuses/' + abuseId
-
-  return makeDeleteRequest({
-    url,
-    token,
-    path,
-    statusCodeExpected
-  })
-}
-
-function listAbuseMessages (url: string, token: string, abuseId: number, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/abuses/' + abuseId + '/messages'
-
-  return makeGetRequest({
-    url,
-    token,
-    path,
-    statusCodeExpected
-  })
-}
-
-function deleteAbuseMessage (
-  url: string,
-  token: string,
-  abuseId: number,
-  messageId: number,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/abuses/' + abuseId + '/messages/' + messageId
-
-  return makeDeleteRequest({
-    url,
-    token,
-    path,
-    statusCodeExpected
-  })
-}
-
-function addAbuseMessage (url: string, token: string, abuseId: number, message: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/abuses/' + abuseId + '/messages'
-
-  return makePostBodyRequest({
-    url,
-    token,
-    path,
-    fields: { message },
-    statusCodeExpected
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  reportAbuse,
-  getAdminAbusesList,
-  updateAbuse,
-  deleteAbuse,
-  getUserAbusesList,
-  listAbuseMessages,
-  deleteAbuseMessage,
-  addAbuseMessage
-}
diff --git a/shared/extra-utils/moderation/index.ts b/shared/extra-utils/moderation/index.ts
new file mode 100644
index 000000000..b37643956
--- /dev/null
+++ b/shared/extra-utils/moderation/index.ts
@@ -0,0 +1 @@
+export * from './abuses-command'
diff --git a/shared/extra-utils/overviews/index.ts b/shared/extra-utils/overviews/index.ts
new file mode 100644
index 000000000..e19551907
--- /dev/null
+++ b/shared/extra-utils/overviews/index.ts
@@ -0,0 +1 @@
+export * from './overviews-command'
diff --git a/shared/extra-utils/overviews/overviews-command.ts b/shared/extra-utils/overviews/overviews-command.ts
new file mode 100644
index 000000000..06b4892d2
--- /dev/null
+++ b/shared/extra-utils/overviews/overviews-command.ts
@@ -0,0 +1,23 @@
+import { HttpStatusCode, VideosOverview } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class OverviewsCommand extends AbstractCommand {
+
+  getVideos (options: OverrideCommandOptions & {
+    page: number
+  }) {
+    const { page } = options
+    const path = '/api/v1/overviews/videos'
+
+    const query = { page }
+
+    return this.getRequestBody<VideosOverview>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/overviews/overviews.ts b/shared/extra-utils/overviews/overviews.ts
deleted file mode 100644
index 5e1a13e5e..000000000
--- a/shared/extra-utils/overviews/overviews.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { makeGetRequest } from '../requests/requests'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getVideosOverview (url: string, page: number, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/overviews/videos'
-
-  const query = { page }
-
-  return makeGetRequest({
-    url,
-    path,
-    query,
-    statusCodeExpected
-  })
-}
-
-function getVideosOverviewWithToken (url: string, page: number, token: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/overviews/videos'
-
-  const query = { page }
-
-  return makeGetRequest({
-    url,
-    path,
-    query,
-    token,
-    statusCodeExpected
-  })
-}
-
-export {
-  getVideosOverview,
-  getVideosOverviewWithToken
-}
diff --git a/shared/extra-utils/requests/activitypub.ts b/shared/extra-utils/requests/activitypub.ts
index ecd8ce823..4ae878384 100644
--- a/shared/extra-utils/requests/activitypub.ts
+++ b/shared/extra-utils/requests/activitypub.ts
@@ -1,7 +1,7 @@
+import { activityPubContextify } from '../../../server/helpers/activitypub'
 import { doRequest } from '../../../server/helpers/requests'
 import { HTTP_SIGNATURE } from '../../../server/initializers/constants'
 import { buildGlobalHeaders } from '../../../server/lib/job-queue/handlers/utils/activitypub-http-utils'
-import { activityPubContextify } from '../../../server/helpers/activitypub'
 
 function makePOSTAPRequest (url: string, body: any, httpSignature: any, headers: any) {
   const options = {
diff --git a/shared/extra-utils/requests/check-api-params.ts b/shared/extra-utils/requests/check-api-params.ts
index 7f5ff775c..26ba1e913 100644
--- a/shared/extra-utils/requests/check-api-params.ts
+++ b/shared/extra-utils/requests/check-api-params.ts
@@ -1,14 +1,13 @@
+import { HttpStatusCode } from '@shared/models'
 import { makeGetRequest } from './requests'
-import { immutableAssign } from '../miscs/miscs'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 
 function checkBadStartPagination (url: string, path: string, token?: string, query = {}) {
   return makeGetRequest({
     url,
     path,
     token,
-    query: immutableAssign(query, { start: 'hello' }),
-    statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+    query: { ...query, start: 'hello' },
+    expectedStatus: HttpStatusCode.BAD_REQUEST_400
   })
 }
 
@@ -17,16 +16,16 @@ async function checkBadCountPagination (url: string, path: string, token?: strin
     url,
     path,
     token,
-    query: immutableAssign(query, { count: 'hello' }),
-    statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+    query: { ...query, count: 'hello' },
+    expectedStatus: HttpStatusCode.BAD_REQUEST_400
   })
 
   await makeGetRequest({
     url,
     path,
     token,
-    query: immutableAssign(query, { count: 2000 }),
-    statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+    query: { ...query, count: 2000 },
+    expectedStatus: HttpStatusCode.BAD_REQUEST_400
   })
 }
 
@@ -35,8 +34,8 @@ function checkBadSortPagination (url: string, path: string, token?: string, quer
     url,
     path,
     token,
-    query: immutableAssign(query, { sort: 'hello' }),
-    statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+    query: { ...query, sort: 'hello' },
+    expectedStatus: HttpStatusCode.BAD_REQUEST_400
   })
 }
 
diff --git a/shared/extra-utils/requests/index.ts b/shared/extra-utils/requests/index.ts
new file mode 100644
index 000000000..501163f92
--- /dev/null
+++ b/shared/extra-utils/requests/index.ts
@@ -0,0 +1,3 @@
+// Don't include activitypub that import stuff from server
+export * from './check-api-params'
+export * from './requests'
diff --git a/shared/extra-utils/requests/requests.ts b/shared/extra-utils/requests/requests.ts
index 38e24d897..70f790222 100644
--- a/shared/extra-utils/requests/requests.ts
+++ b/shared/extra-utils/requests/requests.ts
@@ -1,103 +1,82 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/no-floating-promises */
+/* eslint-disable @typescript-eslint/no-floating-promises */
 
+import { decode } from 'querystring'
 import * as request from 'supertest'
-import { buildAbsoluteFixturePath, root } from '../miscs/miscs'
-import { isAbsolute, join } from 'path'
 import { URL } from 'url'
-import { decode } from 'querystring'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '@shared/models'
+import { buildAbsoluteFixturePath } from '../miscs/tests'
 
-function get4KFileUrl () {
-  return 'https://download.cpy.re/peertube/4k_file.txt'
+export type CommonRequestParams = {
+  url: string
+  path?: string
+  contentType?: string
+  range?: string
+  redirects?: number
+  accept?: string
+  host?: string
+  token?: string
+  headers?: { [ name: string ]: string }
+  type?: string
+  xForwardedFor?: string
+  expectedStatus?: HttpStatusCode
 }
 
-function makeRawRequest (url: string, statusCodeExpected?: HttpStatusCode, range?: string) {
+function makeRawRequest (url: string, expectedStatus?: HttpStatusCode, range?: string) {
   const { host, protocol, pathname } = new URL(url)
 
-  return makeGetRequest({ url: `${protocol}//${host}`, path: pathname, statusCodeExpected, range })
+  return makeGetRequest({ url: `${protocol}//${host}`, path: pathname, expectedStatus, range })
 }
 
-function makeGetRequest (options: {
-  url: string
-  path?: string
+function makeGetRequest (options: CommonRequestParams & {
   query?: any
-  token?: string
-  statusCodeExpected?: HttpStatusCode
-  contentType?: string
-  range?: string
-  redirects?: number
-  accept?: string
 }) {
-  if (!options.statusCodeExpected) options.statusCodeExpected = HttpStatusCode.BAD_REQUEST_400
-  if (options.contentType === undefined) options.contentType = 'application/json'
-
   const req = request(options.url).get(options.path)
+                                  .query(options.query)
 
-  if (options.contentType) req.set('Accept', options.contentType)
-  if (options.token) req.set('Authorization', 'Bearer ' + options.token)
-  if (options.query) req.query(options.query)
-  if (options.range) req.set('Range', options.range)
-  if (options.accept) req.set('Accept', options.accept)
-  if (options.redirects) req.redirects(options.redirects)
-
-  return req.expect(options.statusCodeExpected)
+  return buildRequest(req, { contentType: 'application/json', expectedStatus: HttpStatusCode.BAD_REQUEST_400, ...options })
 }
 
-function makeDeleteRequest (options: {
-  url: string
-  path: string
-  token?: string
-  statusCodeExpected?: HttpStatusCode
-}) {
-  if (!options.statusCodeExpected) options.statusCodeExpected = HttpStatusCode.BAD_REQUEST_400
+function makeHTMLRequest (url: string, path: string) {
+  return makeGetRequest({
+    url,
+    path,
+    accept: 'text/html',
+    expectedStatus: HttpStatusCode.OK_200
+  })
+}
 
-  const req = request(options.url)
-    .delete(options.path)
-    .set('Accept', 'application/json')
+function makeActivityPubGetRequest (url: string, path: string, expectedStatus = HttpStatusCode.OK_200) {
+  return makeGetRequest({
+    url,
+    path,
+    expectedStatus: expectedStatus,
+    accept: 'application/activity+json,text/html;q=0.9,\\*/\\*;q=0.8'
+  })
+}
 
-  if (options.token) req.set('Authorization', 'Bearer ' + options.token)
+function makeDeleteRequest (options: CommonRequestParams) {
+  const req = request(options.url).delete(options.path)
 
-  return req.expect(options.statusCodeExpected)
+  return buildRequest(req, { accept: 'application/json', expectedStatus: HttpStatusCode.BAD_REQUEST_400, ...options })
 }
 
-function makeUploadRequest (options: {
-  url: string
+function makeUploadRequest (options: CommonRequestParams & {
   method?: 'POST' | 'PUT'
-  path: string
-  token?: string
+
   fields: { [ fieldName: string ]: any }
   attaches?: { [ attachName: string ]: any | any[] }
-  statusCodeExpected?: HttpStatusCode
 }) {
-  if (!options.statusCodeExpected) options.statusCodeExpected = HttpStatusCode.BAD_REQUEST_400
-
-  let req: request.Test
-  if (options.method === 'PUT') {
-    req = request(options.url).put(options.path)
-  } else {
-    req = request(options.url).post(options.path)
-  }
-
-  req.set('Accept', 'application/json')
+  let req = options.method === 'PUT'
+    ? request(options.url).put(options.path)
+    : request(options.url).post(options.path)
 
-  if (options.token) req.set('Authorization', 'Bearer ' + options.token)
+  req = buildRequest(req, { accept: 'application/json', expectedStatus: HttpStatusCode.BAD_REQUEST_400, ...options })
 
-  Object.keys(options.fields).forEach(field => {
-    const value = options.fields[field]
-
-    if (value === undefined) return
-
-    if (Array.isArray(value)) {
-      for (let i = 0; i < value.length; i++) {
-        req.field(field + '[' + i + ']', value[i])
-      }
-    } else {
-      req.field(field, value)
-    }
-  })
+  buildFields(req, options.fields)
 
   Object.keys(options.attaches || {}).forEach(attach => {
     const value = options.attaches[attach]
+
     if (Array.isArray(value)) {
       req.attach(attach, buildAbsoluteFixturePath(value[0]), value[1])
     } else {
@@ -105,27 +84,16 @@ function makeUploadRequest (options: {
     }
   })
 
-  return req.expect(options.statusCodeExpected)
+  return req
 }
 
-function makePostBodyRequest (options: {
-  url: string
-  path: string
-  token?: string
+function makePostBodyRequest (options: CommonRequestParams & {
   fields?: { [ fieldName: string ]: any }
-  statusCodeExpected?: HttpStatusCode
 }) {
-  if (!options.fields) options.fields = {}
-  if (!options.statusCodeExpected) options.statusCodeExpected = HttpStatusCode.BAD_REQUEST_400
-
-  const req = request(options.url)
-                .post(options.path)
-                .set('Accept', 'application/json')
+  const req = request(options.url).post(options.path)
+                                  .send(options.fields)
 
-  if (options.token) req.set('Authorization', 'Bearer ' + options.token)
-
-  return req.send(options.fields)
-            .expect(options.statusCodeExpected)
+  return buildRequest(req, { accept: 'application/json', expectedStatus: HttpStatusCode.BAD_REQUEST_400, ...options })
 }
 
 function makePutBodyRequest (options: {
@@ -133,59 +101,29 @@ function makePutBodyRequest (options: {
   path: string
   token?: string
   fields: { [ fieldName: string ]: any }
-  statusCodeExpected?: HttpStatusCode
+  expectedStatus?: HttpStatusCode
 }) {
-  if (!options.statusCodeExpected) options.statusCodeExpected = HttpStatusCode.BAD_REQUEST_400
-
-  const req = request(options.url)
-                .put(options.path)
-                .set('Accept', 'application/json')
+  const req = request(options.url).put(options.path)
+                                  .send(options.fields)
 
-  if (options.token) req.set('Authorization', 'Bearer ' + options.token)
-
-  return req.send(options.fields)
-            .expect(options.statusCodeExpected)
+  return buildRequest(req, { accept: 'application/json', expectedStatus: HttpStatusCode.BAD_REQUEST_400, ...options })
 }
 
-function makeHTMLRequest (url: string, path: string) {
-  return request(url)
-    .get(path)
-    .set('Accept', 'text/html')
-    .expect(HttpStatusCode.OK_200)
+function decodeQueryString (path: string) {
+  return decode(path.split('?')[1])
 }
 
-function updateImageRequest (options: {
-  url: string
-  path: string
-  accessToken: string
-  fixture: string
-  fieldname: string
-}) {
-  let filePath = ''
-  if (isAbsolute(options.fixture)) {
-    filePath = options.fixture
-  } else {
-    filePath = join(root(), 'server', 'tests', 'fixtures', options.fixture)
-  }
-
-  return makeUploadRequest({
-    url: options.url,
-    path: options.path,
-    token: options.accessToken,
-    fields: {},
-    attaches: { [options.fieldname]: filePath },
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
+function unwrapBody <T> (test: request.Test): Promise<T> {
+  return test.then(res => res.body)
 }
 
-function decodeQueryString (path: string) {
-  return decode(path.split('?')[1])
+function unwrapText (test: request.Test): Promise<string> {
+  return test.then(res => res.text)
 }
 
 // ---------------------------------------------------------------------------
 
 export {
-  get4KFileUrl,
   makeHTMLRequest,
   makeGetRequest,
   decodeQueryString,
@@ -194,5 +132,51 @@ export {
   makePutBodyRequest,
   makeDeleteRequest,
   makeRawRequest,
-  updateImageRequest
+  makeActivityPubGetRequest,
+  unwrapBody,
+  unwrapText
+}
+
+// ---------------------------------------------------------------------------
+
+function buildRequest (req: request.Test, options: CommonRequestParams) {
+  if (options.contentType) req.set('Accept', options.contentType)
+  if (options.token) req.set('Authorization', 'Bearer ' + options.token)
+  if (options.range) req.set('Range', options.range)
+  if (options.accept) req.set('Accept', options.accept)
+  if (options.host) req.set('Host', options.host)
+  if (options.redirects) req.redirects(options.redirects)
+  if (options.expectedStatus) req.expect(options.expectedStatus)
+  if (options.xForwardedFor) req.set('X-Forwarded-For', options.xForwardedFor)
+  if (options.type) req.type(options.type)
+
+  Object.keys(options.headers || {}).forEach(name => {
+    req.set(name, options.headers[name])
+  })
+
+  return req
+}
+
+function buildFields (req: request.Test, fields: { [ fieldName: string ]: any }, namespace?: string) {
+  if (!fields) return
+
+  let formKey: string
+
+  for (const key of Object.keys(fields)) {
+    if (namespace) formKey = `${namespace}[${key}]`
+    else formKey = key
+
+    if (fields[key] === undefined) continue
+
+    if (Array.isArray(fields[key]) && fields[key].length === 0) {
+      req.field(key, null)
+      continue
+    }
+
+    if (fields[key] !== null && typeof fields[key] === 'object') {
+      buildFields(req, fields[key], formKey)
+    } else {
+      req.field(formKey, fields[key])
+    }
+  }
 }
diff --git a/shared/extra-utils/search/index.ts b/shared/extra-utils/search/index.ts
new file mode 100644
index 000000000..48dbe8ae9
--- /dev/null
+++ b/shared/extra-utils/search/index.ts
@@ -0,0 +1 @@
+export * from './search-command'
diff --git a/shared/extra-utils/search/search-command.ts b/shared/extra-utils/search/search-command.ts
new file mode 100644
index 000000000..0fbbcd6ef
--- /dev/null
+++ b/shared/extra-utils/search/search-command.ts
@@ -0,0 +1,98 @@
+import {
+  HttpStatusCode,
+  ResultList,
+  Video,
+  VideoChannel,
+  VideoChannelsSearchQuery,
+  VideoPlaylist,
+  VideoPlaylistsSearchQuery,
+  VideosSearchQuery
+} from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class SearchCommand extends AbstractCommand {
+
+  searchChannels (options: OverrideCommandOptions & {
+    search: string
+  }) {
+    return this.advancedChannelSearch({
+      ...options,
+
+      search: { search: options.search }
+    })
+  }
+
+  advancedChannelSearch (options: OverrideCommandOptions & {
+    search: VideoChannelsSearchQuery
+  }) {
+    const { search } = options
+    const path = '/api/v1/search/video-channels'
+
+    return this.getRequestBody<ResultList<VideoChannel>>({
+      ...options,
+
+      path,
+      query: search,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  searchPlaylists (options: OverrideCommandOptions & {
+    search: string
+  }) {
+    return this.advancedPlaylistSearch({
+      ...options,
+
+      search: { search: options.search }
+    })
+  }
+
+  advancedPlaylistSearch (options: OverrideCommandOptions & {
+    search: VideoPlaylistsSearchQuery
+  }) {
+    const { search } = options
+    const path = '/api/v1/search/video-playlists'
+
+    return this.getRequestBody<ResultList<VideoPlaylist>>({
+      ...options,
+
+      path,
+      query: search,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  searchVideos (options: OverrideCommandOptions & {
+    search: string
+    sort?: string
+  }) {
+    const { search, sort } = options
+
+    return this.advancedVideoSearch({
+      ...options,
+
+      search: {
+        search: search,
+        sort: sort ?? '-publishedAt'
+      }
+    })
+  }
+
+  advancedVideoSearch (options: OverrideCommandOptions & {
+    search: VideosSearchQuery
+  }) {
+    const { search } = options
+    const path = '/api/v1/search/videos'
+
+    return this.getRequestBody<ResultList<Video>>({
+      ...options,
+
+      path,
+      query: search,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/search/video-channels.ts b/shared/extra-utils/search/video-channels.ts
deleted file mode 100644
index 8e0f42578..000000000
--- a/shared/extra-utils/search/video-channels.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { VideoChannelsSearchQuery } from '@shared/models'
-import { makeGetRequest } from '../requests/requests'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function searchVideoChannel (url: string, search: string, token?: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/search/video-channels'
-
-  return makeGetRequest({
-    url,
-    path,
-    query: {
-      sort: '-createdAt',
-      search
-    },
-    token,
-    statusCodeExpected
-  })
-}
-
-function advancedVideoChannelSearch (url: string, search: VideoChannelsSearchQuery) {
-  const path = '/api/v1/search/video-channels'
-
-  return makeGetRequest({
-    url,
-    path,
-    query: search,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  searchVideoChannel,
-  advancedVideoChannelSearch
-}
diff --git a/shared/extra-utils/search/video-playlists.ts b/shared/extra-utils/search/video-playlists.ts
deleted file mode 100644
index c22831df7..000000000
--- a/shared/extra-utils/search/video-playlists.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { VideoPlaylistsSearchQuery } from '@shared/models'
-import { HttpStatusCode } from '../../core-utils/miscs/http-error-codes'
-import { makeGetRequest } from '../requests/requests'
-
-function searchVideoPlaylists (url: string, search: string, token?: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/search/video-playlists'
-
-  return makeGetRequest({
-    url,
-    path,
-    query: {
-      sort: '-createdAt',
-      search
-    },
-    token,
-    statusCodeExpected
-  })
-}
-
-function advancedVideoPlaylistSearch (url: string, search: VideoPlaylistsSearchQuery) {
-  const path = '/api/v1/search/video-playlists'
-
-  return makeGetRequest({
-    url,
-    path,
-    query: search,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  searchVideoPlaylists,
-  advancedVideoPlaylistSearch
-}
diff --git a/shared/extra-utils/search/videos.ts b/shared/extra-utils/search/videos.ts
deleted file mode 100644
index db6edbd58..000000000
--- a/shared/extra-utils/search/videos.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-
-import * as request from 'supertest'
-import { VideosSearchQuery } from '../../models/search'
-import { immutableAssign } from '../miscs/miscs'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function searchVideo (url: string, search: string, sort = '-publishedAt') {
-  const path = '/api/v1/search/videos'
-
-  const query = { sort, search: search }
-  const req = request(url)
-    .get(path)
-    .query(query)
-    .set('Accept', 'application/json')
-
-  return req.expect(HttpStatusCode.OK_200)
-            .expect('Content-Type', /json/)
-}
-
-function searchVideoWithToken (url: string, search: string, token: string, query: { nsfw?: boolean } = {}) {
-  const path = '/api/v1/search/videos'
-  const req = request(url)
-    .get(path)
-    .set('Authorization', 'Bearer ' + token)
-    .query(immutableAssign(query, { sort: '-publishedAt', search }))
-    .set('Accept', 'application/json')
-
-  return req.expect(HttpStatusCode.OK_200)
-            .expect('Content-Type', /json/)
-}
-
-function searchVideoWithSort (url: string, search: string, sort: string) {
-  const path = '/api/v1/search/videos'
-
-  const query = { search, sort }
-
-  return request(url)
-    .get(path)
-    .query(query)
-    .set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function advancedVideosSearch (url: string, options: VideosSearchQuery) {
-  const path = '/api/v1/search/videos'
-
-  return request(url)
-    .get(path)
-    .query(options)
-    .set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  searchVideo,
-  advancedVideosSearch,
-  searchVideoWithToken,
-  searchVideoWithSort
-}
diff --git a/shared/extra-utils/server/activitypub.ts b/shared/extra-utils/server/activitypub.ts
deleted file mode 100644
index cf967ed7d..000000000
--- a/shared/extra-utils/server/activitypub.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import * as request from 'supertest'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function makeActivityPubGetRequest (url: string, path: string, expectedStatus = HttpStatusCode.OK_200) {
-  return request(url)
-    .get(path)
-    .set('Accept', 'application/activity+json,text/html;q=0.9,\\*/\\*;q=0.8')
-    .expect(expectedStatus)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  makeActivityPubGetRequest
-}
diff --git a/shared/extra-utils/server/clients.ts b/shared/extra-utils/server/clients.ts
deleted file mode 100644
index 894fe4911..000000000
--- a/shared/extra-utils/server/clients.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import * as request from 'supertest'
-import { URL } from 'url'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getClient (url: string) {
-  const path = '/api/v1/oauth-clients/local'
-
-  return request(url)
-          .get(path)
-          .set('Host', new URL(url).host)
-          .set('Accept', 'application/json')
-          .expect(HttpStatusCode.OK_200)
-          .expect('Content-Type', /json/)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getClient
-}
diff --git a/shared/extra-utils/server/config-command.ts b/shared/extra-utils/server/config-command.ts
new file mode 100644
index 000000000..11148aa46
--- /dev/null
+++ b/shared/extra-utils/server/config-command.ts
@@ -0,0 +1,263 @@
+import { merge } from 'lodash'
+import { DeepPartial } from '@shared/core-utils'
+import { About, HttpStatusCode, ServerConfig } from '@shared/models'
+import { CustomConfig } from '../../models/server/custom-config.model'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class ConfigCommand extends AbstractCommand {
+
+  static getCustomConfigResolutions (enabled: boolean) {
+    return {
+      '240p': enabled,
+      '360p': enabled,
+      '480p': enabled,
+      '720p': enabled,
+      '1080p': enabled,
+      '1440p': enabled,
+      '2160p': enabled
+    }
+  }
+
+  getConfig (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/config'
+
+    return this.getRequestBody<ServerConfig>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getAbout (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/config/about'
+
+    return this.getRequestBody<About>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getCustomConfig (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/config/custom'
+
+    return this.getRequestBody<CustomConfig>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  updateCustomConfig (options: OverrideCommandOptions & {
+    newCustomConfig: CustomConfig
+  }) {
+    const path = '/api/v1/config/custom'
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: options.newCustomConfig,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  deleteCustomConfig (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/config/custom'
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  updateCustomSubConfig (options: OverrideCommandOptions & {
+    newConfig: DeepPartial<CustomConfig>
+  }) {
+    const newCustomConfig: CustomConfig = {
+      instance: {
+        name: 'PeerTube updated',
+        shortDescription: 'my short description',
+        description: 'my super description',
+        terms: 'my super terms',
+        codeOfConduct: 'my super coc',
+
+        creationReason: 'my super creation reason',
+        moderationInformation: 'my super moderation information',
+        administrator: 'Kuja',
+        maintenanceLifetime: 'forever',
+        businessModel: 'my super business model',
+        hardwareInformation: '2vCore 3GB RAM',
+
+        languages: [ 'en', 'es' ],
+        categories: [ 1, 2 ],
+
+        isNSFW: true,
+        defaultNSFWPolicy: 'blur',
+
+        defaultClientRoute: '/videos/recently-added',
+
+        customizations: {
+          javascript: 'alert("coucou")',
+          css: 'body { background-color: red; }'
+        }
+      },
+      theme: {
+        default: 'default'
+      },
+      services: {
+        twitter: {
+          username: '@MySuperUsername',
+          whitelisted: true
+        }
+      },
+      cache: {
+        previews: {
+          size: 2
+        },
+        captions: {
+          size: 3
+        },
+        torrents: {
+          size: 4
+        }
+      },
+      signup: {
+        enabled: false,
+        limit: 5,
+        requiresEmailVerification: false,
+        minimumAge: 16
+      },
+      admin: {
+        email: 'superadmin1@example.com'
+      },
+      contactForm: {
+        enabled: true
+      },
+      user: {
+        videoQuota: 5242881,
+        videoQuotaDaily: 318742
+      },
+      transcoding: {
+        enabled: true,
+        allowAdditionalExtensions: true,
+        allowAudioFiles: true,
+        threads: 1,
+        concurrency: 3,
+        profile: 'default',
+        resolutions: {
+          '0p': false,
+          '240p': false,
+          '360p': true,
+          '480p': true,
+          '720p': false,
+          '1080p': false,
+          '1440p': false,
+          '2160p': false
+        },
+        webtorrent: {
+          enabled: true
+        },
+        hls: {
+          enabled: false
+        }
+      },
+      live: {
+        enabled: true,
+        allowReplay: false,
+        maxDuration: -1,
+        maxInstanceLives: -1,
+        maxUserLives: 50,
+        transcoding: {
+          enabled: true,
+          threads: 4,
+          profile: 'default',
+          resolutions: {
+            '240p': true,
+            '360p': true,
+            '480p': true,
+            '720p': true,
+            '1080p': true,
+            '1440p': true,
+            '2160p': true
+          }
+        }
+      },
+      import: {
+        videos: {
+          concurrency: 3,
+          http: {
+            enabled: false
+          },
+          torrent: {
+            enabled: false
+          }
+        }
+      },
+      trending: {
+        videos: {
+          algorithms: {
+            enabled: [ 'best', 'hot', 'most-viewed', 'most-liked' ],
+            default: 'hot'
+          }
+        }
+      },
+      autoBlacklist: {
+        videos: {
+          ofUsers: {
+            enabled: false
+          }
+        }
+      },
+      followers: {
+        instance: {
+          enabled: true,
+          manualApproval: false
+        }
+      },
+      followings: {
+        instance: {
+          autoFollowBack: {
+            enabled: false
+          },
+          autoFollowIndex: {
+            indexUrl: 'https://instances.joinpeertube.org/api/v1/instances/hosts',
+            enabled: false
+          }
+        }
+      },
+      broadcastMessage: {
+        enabled: true,
+        level: 'warning',
+        message: 'hello',
+        dismissable: true
+      },
+      search: {
+        remoteUri: {
+          users: true,
+          anonymous: true
+        },
+        searchIndex: {
+          enabled: true,
+          url: 'https://search.joinpeertube.org',
+          disableLocalSearch: true,
+          isDefaultSearch: true
+        }
+      }
+    }
+
+    merge(newCustomConfig, options.newConfig)
+
+    return this.updateCustomConfig({ ...options, newCustomConfig })
+  }
+}
diff --git a/shared/extra-utils/server/config.ts b/shared/extra-utils/server/config.ts
deleted file mode 100644
index 9fcfb31fd..000000000
--- a/shared/extra-utils/server/config.ts
+++ /dev/null
@@ -1,260 +0,0 @@
-import { makeDeleteRequest, makeGetRequest, makePutBodyRequest } from '../requests/requests'
-import { CustomConfig } from '../../models/server/custom-config.model'
-import { DeepPartial, HttpStatusCode } from '@shared/core-utils'
-import { merge } from 'lodash'
-
-function getConfig (url: string) {
-  const path = '/api/v1/config'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getAbout (url: string) {
-  const path = '/api/v1/config/about'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getCustomConfig (url: string, token: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/config/custom'
-
-  return makeGetRequest({
-    url,
-    token,
-    path,
-    statusCodeExpected
-  })
-}
-
-function updateCustomConfig (url: string, token: string, newCustomConfig: CustomConfig, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/config/custom'
-
-  return makePutBodyRequest({
-    url,
-    token,
-    path,
-    fields: newCustomConfig,
-    statusCodeExpected
-  })
-}
-
-function updateCustomSubConfig (url: string, token: string, newConfig: DeepPartial<CustomConfig>) {
-  const updateParams: CustomConfig = {
-    instance: {
-      name: 'PeerTube updated',
-      shortDescription: 'my short description',
-      description: 'my super description',
-      terms: 'my super terms',
-      codeOfConduct: 'my super coc',
-
-      creationReason: 'my super creation reason',
-      moderationInformation: 'my super moderation information',
-      administrator: 'Kuja',
-      maintenanceLifetime: 'forever',
-      businessModel: 'my super business model',
-      hardwareInformation: '2vCore 3GB RAM',
-
-      languages: [ 'en', 'es' ],
-      categories: [ 1, 2 ],
-
-      isNSFW: true,
-      defaultNSFWPolicy: 'blur',
-
-      defaultClientRoute: '/videos/recently-added',
-
-      customizations: {
-        javascript: 'alert("coucou")',
-        css: 'body { background-color: red; }'
-      }
-    },
-    theme: {
-      default: 'default'
-    },
-    services: {
-      twitter: {
-        username: '@MySuperUsername',
-        whitelisted: true
-      }
-    },
-    cache: {
-      previews: {
-        size: 2
-      },
-      captions: {
-        size: 3
-      },
-      torrents: {
-        size: 4
-      }
-    },
-    signup: {
-      enabled: false,
-      limit: 5,
-      requiresEmailVerification: false,
-      minimumAge: 16
-    },
-    admin: {
-      email: 'superadmin1@example.com'
-    },
-    contactForm: {
-      enabled: true
-    },
-    user: {
-      videoQuota: 5242881,
-      videoQuotaDaily: 318742
-    },
-    transcoding: {
-      enabled: true,
-      allowAdditionalExtensions: true,
-      allowAudioFiles: true,
-      threads: 1,
-      concurrency: 3,
-      profile: 'default',
-      resolutions: {
-        '0p': false,
-        '240p': false,
-        '360p': true,
-        '480p': true,
-        '720p': false,
-        '1080p': false,
-        '1440p': false,
-        '2160p': false
-      },
-      webtorrent: {
-        enabled: true
-      },
-      hls: {
-        enabled: false
-      }
-    },
-    live: {
-      enabled: true,
-      allowReplay: false,
-      maxDuration: -1,
-      maxInstanceLives: -1,
-      maxUserLives: 50,
-      transcoding: {
-        enabled: true,
-        threads: 4,
-        profile: 'default',
-        resolutions: {
-          '240p': true,
-          '360p': true,
-          '480p': true,
-          '720p': true,
-          '1080p': true,
-          '1440p': true,
-          '2160p': true
-        }
-      }
-    },
-    import: {
-      videos: {
-        concurrency: 3,
-        http: {
-          enabled: false
-        },
-        torrent: {
-          enabled: false
-        }
-      }
-    },
-    trending: {
-      videos: {
-        algorithms: {
-          enabled: [ 'best', 'hot', 'most-viewed', 'most-liked' ],
-          default: 'hot'
-        }
-      }
-    },
-    autoBlacklist: {
-      videos: {
-        ofUsers: {
-          enabled: false
-        }
-      }
-    },
-    followers: {
-      instance: {
-        enabled: true,
-        manualApproval: false
-      }
-    },
-    followings: {
-      instance: {
-        autoFollowBack: {
-          enabled: false
-        },
-        autoFollowIndex: {
-          indexUrl: 'https://instances.joinpeertube.org/api/v1/instances/hosts',
-          enabled: false
-        }
-      }
-    },
-    broadcastMessage: {
-      enabled: true,
-      level: 'warning',
-      message: 'hello',
-      dismissable: true
-    },
-    search: {
-      remoteUri: {
-        users: true,
-        anonymous: true
-      },
-      searchIndex: {
-        enabled: true,
-        url: 'https://search.joinpeertube.org',
-        disableLocalSearch: true,
-        isDefaultSearch: true
-      }
-    }
-  }
-
-  merge(updateParams, newConfig)
-
-  return updateCustomConfig(url, token, updateParams)
-}
-
-function getCustomConfigResolutions (enabled: boolean) {
-  return {
-    '240p': enabled,
-    '360p': enabled,
-    '480p': enabled,
-    '720p': enabled,
-    '1080p': enabled,
-    '1440p': enabled,
-    '2160p': enabled
-  }
-}
-
-function deleteCustomConfig (url: string, token: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/config/custom'
-
-  return makeDeleteRequest({
-    url,
-    token,
-    path,
-    statusCodeExpected
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getConfig,
-  getCustomConfig,
-  updateCustomConfig,
-  getAbout,
-  deleteCustomConfig,
-  updateCustomSubConfig,
-  getCustomConfigResolutions
-}
diff --git a/shared/extra-utils/server/contact-form-command.ts b/shared/extra-utils/server/contact-form-command.ts
new file mode 100644
index 000000000..0e8fd6d84
--- /dev/null
+++ b/shared/extra-utils/server/contact-form-command.ts
@@ -0,0 +1,31 @@
+import { HttpStatusCode } from '@shared/models'
+import { ContactForm } from '../../models/server'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class ContactFormCommand extends AbstractCommand {
+
+  send (options: OverrideCommandOptions & {
+    fromEmail: string
+    fromName: string
+    subject: string
+    body: string
+  }) {
+    const path = '/api/v1/server/contact'
+
+    const body: ContactForm = {
+      fromEmail: options.fromEmail,
+      fromName: options.fromName,
+      subject: options.subject,
+      body: options.body
+    }
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: body,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/server/contact-form.ts b/shared/extra-utils/server/contact-form.ts
deleted file mode 100644
index 6c9232cc6..000000000
--- a/shared/extra-utils/server/contact-form.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import * as request from 'supertest'
-import { ContactForm } from '../../models/server'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function sendContactForm (options: {
-  url: string
-  fromEmail: string
-  fromName: string
-  subject: string
-  body: string
-  expectedStatus?: number
-}) {
-  const path = '/api/v1/server/contact'
-
-  const body: ContactForm = {
-    fromEmail: options.fromEmail,
-    fromName: options.fromName,
-    subject: options.subject,
-    body: options.body
-  }
-  return request(options.url)
-    .post(path)
-    .send(body)
-    .expect(options.expectedStatus || HttpStatusCode.NO_CONTENT_204)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  sendContactForm
-}
diff --git a/shared/extra-utils/server/debug-command.ts b/shared/extra-utils/server/debug-command.ts
new file mode 100644
index 000000000..3c5a785bb
--- /dev/null
+++ b/shared/extra-utils/server/debug-command.ts
@@ -0,0 +1,33 @@
+import { Debug, HttpStatusCode, SendDebugCommand } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class DebugCommand extends AbstractCommand {
+
+  getDebug (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/server/debug'
+
+    return this.getRequestBody<Debug>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  sendCommand (options: OverrideCommandOptions & {
+    body: SendDebugCommand
+  }) {
+    const { body } = options
+    const path = '/api/v1/server/debug/run-command'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: body,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/server/debug.ts b/shared/extra-utils/server/debug.ts
deleted file mode 100644
index f196812b7..000000000
--- a/shared/extra-utils/server/debug.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { makeGetRequest, makePostBodyRequest } from '../requests/requests'
-import { HttpStatusCode } from '../../core-utils/miscs/http-error-codes'
-import { SendDebugCommand } from '@shared/models'
-
-function getDebug (url: string, token: string) {
-  const path = '/api/v1/server/debug'
-
-  return makeGetRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function sendDebugCommand (url: string, token: string, body: SendDebugCommand) {
-  const path = '/api/v1/server/debug/run-command'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    fields: body,
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getDebug,
-  sendDebugCommand
-}
diff --git a/shared/extra-utils/server/directories.ts b/shared/extra-utils/server/directories.ts
new file mode 100644
index 000000000..b6465cbf4
--- /dev/null
+++ b/shared/extra-utils/server/directories.ts
@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { pathExists, readdir } from 'fs-extra'
+import { join } from 'path'
+import { root } from '@server/helpers/core-utils'
+import { PeerTubeServer } from './server'
+
+async function checkTmpIsEmpty (server: PeerTubeServer) {
+  await checkDirectoryIsEmpty(server, 'tmp', [ 'plugins-global.css', 'hls', 'resumable-uploads' ])
+
+  if (await pathExists(join('test' + server.internalServerNumber, 'tmp', 'hls'))) {
+    await checkDirectoryIsEmpty(server, 'tmp/hls')
+  }
+}
+
+async function checkDirectoryIsEmpty (server: PeerTubeServer, directory: string, exceptions: string[] = []) {
+  const testDirectory = 'test' + server.internalServerNumber
+
+  const directoryPath = join(root(), testDirectory, directory)
+
+  const directoryExists = await pathExists(directoryPath)
+  expect(directoryExists).to.be.true
+
+  const files = await readdir(directoryPath)
+  const filtered = files.filter(f => exceptions.includes(f) === false)
+
+  expect(filtered).to.have.lengthOf(0)
+}
+
+export {
+  checkTmpIsEmpty,
+  checkDirectoryIsEmpty
+}
diff --git a/shared/extra-utils/server/follows-command.ts b/shared/extra-utils/server/follows-command.ts
new file mode 100644
index 000000000..2b889cf66
--- /dev/null
+++ b/shared/extra-utils/server/follows-command.ts
@@ -0,0 +1,141 @@
+import { pick } from 'lodash'
+import { ActivityPubActorType, ActorFollow, FollowState, HttpStatusCode, ResultList, ServerFollowCreate } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+import { PeerTubeServer } from './server'
+
+export class FollowsCommand extends AbstractCommand {
+
+  getFollowers (options: OverrideCommandOptions & {
+    start: number
+    count: number
+    sort: string
+    search?: string
+    actorType?: ActivityPubActorType
+    state?: FollowState
+  }) {
+    const path = '/api/v1/server/followers'
+
+    const toPick = [ 'start', 'count', 'sort', 'search', 'state', 'actorType' ]
+    const query = pick(options, toPick)
+
+    return this.getRequestBody<ResultList<ActorFollow>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getFollowings (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+    search?: string
+    actorType?: ActivityPubActorType
+    state?: FollowState
+  } = {}) {
+    const path = '/api/v1/server/following'
+
+    const toPick = [ 'start', 'count', 'sort', 'search', 'state', 'actorType' ]
+    const query = pick(options, toPick)
+
+    return this.getRequestBody<ResultList<ActorFollow>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  follow (options: OverrideCommandOptions & {
+    hosts?: string[]
+    handles?: string[]
+  }) {
+    const path = '/api/v1/server/following'
+
+    const fields: ServerFollowCreate = {}
+
+    if (options.hosts) {
+      fields.hosts = options.hosts.map(f => f.replace(/^http:\/\//, ''))
+    }
+
+    if (options.handles) {
+      fields.handles = options.handles
+    }
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  async unfollow (options: OverrideCommandOptions & {
+    target: PeerTubeServer | string
+  }) {
+    const { target } = options
+
+    const handle = typeof target === 'string'
+      ? target
+      : target.host
+
+    const path = '/api/v1/server/following/' + handle
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  acceptFollower (options: OverrideCommandOptions & {
+    follower: string
+  }) {
+    const path = '/api/v1/server/followers/' + options.follower + '/accept'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  rejectFollower (options: OverrideCommandOptions & {
+    follower: string
+  }) {
+    const path = '/api/v1/server/followers/' + options.follower + '/reject'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  removeFollower (options: OverrideCommandOptions & {
+    follower: PeerTubeServer
+  }) {
+    const path = '/api/v1/server/followers/peertube@' + options.follower.host
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/server/follows.ts b/shared/extra-utils/server/follows.ts
index 6aae4a31d..698238f29 100644
--- a/shared/extra-utils/server/follows.ts
+++ b/shared/extra-utils/server/follows.ts
@@ -1,126 +1,10 @@
-import * as request from 'supertest'
-import { ServerInfo } from './servers'
 import { waitJobs } from './jobs'
-import { makePostBodyRequest } from '../requests/requests'
-import { ActivityPubActorType, FollowState } from '@shared/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { PeerTubeServer } from './server'
 
-function getFollowersListPaginationAndSort (options: {
-  url: string
-  start: number
-  count: number
-  sort: string
-  search?: string
-  actorType?: ActivityPubActorType
-  state?: FollowState
-}) {
-  const { url, start, count, sort, search, state, actorType } = options
-  const path = '/api/v1/server/followers'
-
-  const query = {
-    start,
-    count,
-    sort,
-    search,
-    state,
-    actorType
-  }
-
-  return request(url)
-    .get(path)
-    .query(query)
-    .set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function acceptFollower (url: string, token: string, follower: string, statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/server/followers/' + follower + '/accept'
-
-  return makePostBodyRequest({
-    url,
-    token,
-    path,
-    statusCodeExpected
-  })
-}
-
-function rejectFollower (url: string, token: string, follower: string, statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/server/followers/' + follower + '/reject'
-
-  return makePostBodyRequest({
-    url,
-    token,
-    path,
-    statusCodeExpected
-  })
-}
-
-function getFollowingListPaginationAndSort (options: {
-  url: string
-  start: number
-  count: number
-  sort: string
-  search?: string
-  actorType?: ActivityPubActorType
-  state?: FollowState
-}) {
-  const { url, start, count, sort, search, state, actorType } = options
-  const path = '/api/v1/server/following'
-
-  const query = {
-    start,
-    count,
-    sort,
-    search,
-    state,
-    actorType
-  }
-
-  return request(url)
-    .get(path)
-    .query(query)
-    .set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function follow (follower: string, following: string[], accessToken: string, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/server/following'
-
-  const followingHosts = following.map(f => f.replace(/^http:\/\//, ''))
-  return request(follower)
-    .post(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .send({ hosts: followingHosts })
-    .expect(expectedStatus)
-}
-
-async function unfollow (url: string, accessToken: string, target: ServerInfo, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/server/following/' + target.host
-
-  return request(url)
-    .delete(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .expect(expectedStatus)
-}
-
-function removeFollower (url: string, accessToken: string, follower: ServerInfo, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/server/followers/peertube@' + follower.host
-
-  return request(url)
-    .delete(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .expect(expectedStatus)
-}
-
-async function doubleFollow (server1: ServerInfo, server2: ServerInfo) {
+async function doubleFollow (server1: PeerTubeServer, server2: PeerTubeServer) {
   await Promise.all([
-    follow(server1.url, [ server2.url ], server1.accessToken),
-    follow(server2.url, [ server1.url ], server2.accessToken)
+    server1.follows.follow({ hosts: [ server2.url ] }),
+    server2.follows.follow({ hosts: [ server1.url ] })
   ])
 
   // Wait request propagation
@@ -132,12 +16,5 @@ async function doubleFollow (server1: ServerInfo, server2: ServerInfo) {
 // ---------------------------------------------------------------------------
 
 export {
-  getFollowersListPaginationAndSort,
-  getFollowingListPaginationAndSort,
-  unfollow,
-  removeFollower,
-  follow,
-  doubleFollow,
-  acceptFollower,
-  rejectFollower
+  doubleFollow
 }
diff --git a/shared/extra-utils/server/index.ts b/shared/extra-utils/server/index.ts
new file mode 100644
index 000000000..9055dfc57
--- /dev/null
+++ b/shared/extra-utils/server/index.ts
@@ -0,0 +1,15 @@
+export * from './config-command'
+export * from './contact-form-command'
+export * from './debug-command'
+export * from './directories'
+export * from './follows-command'
+export * from './follows'
+export * from './jobs'
+export * from './jobs-command'
+export * from './plugins-command'
+export * from './plugins'
+export * from './redundancy-command'
+export * from './server'
+export * from './servers-command'
+export * from './servers'
+export * from './stats-command'
diff --git a/shared/extra-utils/server/jobs-command.ts b/shared/extra-utils/server/jobs-command.ts
new file mode 100644
index 000000000..09a299e5b
--- /dev/null
+++ b/shared/extra-utils/server/jobs-command.ts
@@ -0,0 +1,36 @@
+import { pick } from 'lodash'
+import { HttpStatusCode } from '@shared/models'
+import { Job, JobState, JobType, ResultList } from '../../models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class JobsCommand extends AbstractCommand {
+
+  getJobsList (options: OverrideCommandOptions & {
+    state?: JobState
+    jobType?: JobType
+    start?: number
+    count?: number
+    sort?: string
+  } = {}) {
+    const path = this.buildJobsUrl(options.state)
+
+    const query = pick(options, [ 'start', 'count', 'sort', 'jobType' ])
+
+    return this.getRequestBody<ResultList<Job>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  private buildJobsUrl (state?: JobState) {
+    let path = '/api/v1/jobs'
+
+    if (state) path += '/' + state
+
+    return path
+  }
+}
diff --git a/shared/extra-utils/server/jobs.ts b/shared/extra-utils/server/jobs.ts
index 763374e03..64a0353eb 100644
--- a/shared/extra-utils/server/jobs.ts
+++ b/shared/extra-utils/server/jobs.ts
@@ -1,66 +1,17 @@
-import * as request from 'supertest'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { getDebug, makeGetRequest } from '../../../shared/extra-utils'
-import { Job, JobState, JobType, ServerDebug } from '../../models'
-import { wait } from '../miscs/miscs'
-import { ServerInfo } from './servers'
 
-function buildJobsUrl (state?: JobState) {
-  let path = '/api/v1/jobs'
+import { JobState } from '../../models'
+import { wait } from '../miscs'
+import { PeerTubeServer } from './server'
 
-  if (state) path += '/' + state
-
-  return path
-}
-
-function getJobsList (url: string, accessToken: string, state?: JobState) {
-  const path = buildJobsUrl(state)
-
-  return request(url)
-    .get(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function getJobsListPaginationAndSort (options: {
-  url: string
-  accessToken: string
-  start: number
-  count: number
-  sort: string
-  state?: JobState
-  jobType?: JobType
-}) {
-  const { url, accessToken, state, start, count, sort, jobType } = options
-  const path = buildJobsUrl(state)
-
-  const query = {
-    start,
-    count,
-    sort,
-    jobType
-  }
-
-  return makeGetRequest({
-    url,
-    path,
-    token: accessToken,
-    statusCodeExpected: HttpStatusCode.OK_200,
-    query
-  })
-}
-
-async function waitJobs (serversArg: ServerInfo[] | ServerInfo) {
+async function waitJobs (serversArg: PeerTubeServer[] | PeerTubeServer) {
   const pendingJobWait = process.env.NODE_PENDING_JOB_WAIT
     ? parseInt(process.env.NODE_PENDING_JOB_WAIT, 10)
     : 250
 
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
 
-  if (Array.isArray(serversArg) === false) servers = [ serversArg as ServerInfo ]
-  else servers = serversArg as ServerInfo[]
+  if (Array.isArray(serversArg) === false) servers = [ serversArg as PeerTubeServer ]
+  else servers = serversArg as PeerTubeServer[]
 
   const states: JobState[] = [ 'waiting', 'active', 'delayed' ]
   const repeatableJobs = [ 'videos-views', 'activitypub-cleaner' ]
@@ -72,15 +23,13 @@ async function waitJobs (serversArg: ServerInfo[] | ServerInfo) {
     // Check if each server has pending request
     for (const server of servers) {
       for (const state of states) {
-        const p = getJobsListPaginationAndSort({
-          url: server.url,
-          accessToken: server.accessToken,
-          state: state,
+        const p = server.jobs.getJobsList({
+          state,
           start: 0,
           count: 10,
           sort: '-createdAt'
-        }).then(res => res.body.data)
-          .then((jobs: Job[]) => jobs.filter(j => !repeatableJobs.includes(j.type)))
+        }).then(body => body.data)
+          .then(jobs => jobs.filter(j => !repeatableJobs.includes(j.type)))
           .then(jobs => {
             if (jobs.length !== 0) {
               pendingRequests = true
@@ -90,9 +39,8 @@ async function waitJobs (serversArg: ServerInfo[] | ServerInfo) {
         tasks.push(p)
       }
 
-      const p = getDebug(server.url, server.accessToken)
-        .then(res => res.body)
-        .then((obj: ServerDebug) => {
+      const p = server.debug.getDebug()
+        .then(obj => {
           if (obj.activityPubMessagesWaiting !== 0) {
             pendingRequests = true
           }
@@ -123,7 +71,5 @@ async function waitJobs (serversArg: ServerInfo[] | ServerInfo) {
 // ---------------------------------------------------------------------------
 
 export {
-  getJobsList,
-  waitJobs,
-  getJobsListPaginationAndSort
+  waitJobs
 }
diff --git a/shared/extra-utils/server/plugins-command.ts b/shared/extra-utils/server/plugins-command.ts
new file mode 100644
index 000000000..b944475a2
--- /dev/null
+++ b/shared/extra-utils/server/plugins-command.ts
@@ -0,0 +1,256 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { readJSON, writeJSON } from 'fs-extra'
+import { join } from 'path'
+import { root } from '@server/helpers/core-utils'
+import {
+  HttpStatusCode,
+  PeerTubePlugin,
+  PeerTubePluginIndex,
+  PeertubePluginIndexList,
+  PluginPackageJson,
+  PluginTranslation,
+  PluginType,
+  PublicServerSetting,
+  RegisteredServerSettings,
+  ResultList
+} from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class PluginsCommand extends AbstractCommand {
+
+  static getPluginTestPath (suffix = '') {
+    return join(root(), 'server', 'tests', 'fixtures', 'peertube-plugin-test' + suffix)
+  }
+
+  list (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+    pluginType?: PluginType
+    uninstalled?: boolean
+  }) {
+    const { start, count, sort, pluginType, uninstalled } = options
+    const path = '/api/v1/plugins'
+
+    return this.getRequestBody<ResultList<PeerTubePlugin>>({
+      ...options,
+
+      path,
+      query: {
+        start,
+        count,
+        sort,
+        pluginType,
+        uninstalled
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listAvailable (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+    pluginType?: PluginType
+    currentPeerTubeEngine?: string
+    search?: string
+    expectedStatus?: HttpStatusCode
+  }) {
+    const { start, count, sort, pluginType, search, currentPeerTubeEngine } = options
+    const path = '/api/v1/plugins/available'
+
+    const query: PeertubePluginIndexList = {
+      start,
+      count,
+      sort,
+      pluginType,
+      currentPeerTubeEngine,
+      search
+    }
+
+    return this.getRequestBody<ResultList<PeerTubePluginIndex>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  get (options: OverrideCommandOptions & {
+    npmName: string
+  }) {
+    const path = '/api/v1/plugins/' + options.npmName
+
+    return this.getRequestBody<PeerTubePlugin>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  updateSettings (options: OverrideCommandOptions & {
+    npmName: string
+    settings: any
+  }) {
+    const { npmName, settings } = options
+    const path = '/api/v1/plugins/' + npmName + '/settings'
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: { settings },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  getRegisteredSettings (options: OverrideCommandOptions & {
+    npmName: string
+  }) {
+    const path = '/api/v1/plugins/' + options.npmName + '/registered-settings'
+
+    return this.getRequestBody<RegisteredServerSettings>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getPublicSettings (options: OverrideCommandOptions & {
+    npmName: string
+  }) {
+    const { npmName } = options
+    const path = '/api/v1/plugins/' + npmName + '/public-settings'
+
+    return this.getRequestBody<PublicServerSetting>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getTranslations (options: OverrideCommandOptions & {
+    locale: string
+  }) {
+    const { locale } = options
+    const path = '/plugins/translations/' + locale + '.json'
+
+    return this.getRequestBody<PluginTranslation>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  install (options: OverrideCommandOptions & {
+    path?: string
+    npmName?: string
+  }) {
+    const { npmName, path } = options
+    const apiPath = '/api/v1/plugins/install'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path: apiPath,
+      fields: { npmName, path },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  update (options: OverrideCommandOptions & {
+    path?: string
+    npmName?: string
+  }) {
+    const { npmName, path } = options
+    const apiPath = '/api/v1/plugins/update'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path: apiPath,
+      fields: { npmName, path },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  uninstall (options: OverrideCommandOptions & {
+    npmName: string
+  }) {
+    const { npmName } = options
+    const apiPath = '/api/v1/plugins/uninstall'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path: apiPath,
+      fields: { npmName },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  getCSS (options: OverrideCommandOptions = {}) {
+    const path = '/plugins/global.css'
+
+    return this.getRequestText({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getExternalAuth (options: OverrideCommandOptions & {
+    npmName: string
+    npmVersion: string
+    authName: string
+    query?: any
+  }) {
+    const { npmName, npmVersion, authName, query } = options
+
+    const path = '/plugins/' + npmName + '/' + npmVersion + '/auth/' + authName
+
+    return this.getRequest({
+      ...options,
+
+      path,
+      query,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200,
+      redirects: 0
+    })
+  }
+
+  updatePackageJSON (npmName: string, json: any) {
+    const path = this.getPackageJSONPath(npmName)
+
+    return writeJSON(path, json)
+  }
+
+  getPackageJSON (npmName: string): Promise<PluginPackageJson> {
+    const path = this.getPackageJSONPath(npmName)
+
+    return readJSON(path)
+  }
+
+  private getPackageJSONPath (npmName: string) {
+    return this.server.servers.buildDirectory(join('plugins', 'node_modules', npmName, 'package.json'))
+  }
+}
diff --git a/shared/extra-utils/server/plugins.ts b/shared/extra-utils/server/plugins.ts
index d53e5b382..0f5fabd5a 100644
--- a/shared/extra-utils/server/plugins.ts
+++ b/shared/extra-utils/server/plugins.ts
@@ -1,307 +1,18 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import { expect } from 'chai'
-import { readJSON, writeJSON } from 'fs-extra'
-import { join } from 'path'
-import { RegisteredServerSettings } from '@shared/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { PeertubePluginIndexList } from '../../models/plugins/plugin-index/peertube-plugin-index-list.model'
-import { PluginType } from '../../models/plugins/plugin.type'
-import { buildServerDirectory, root } from '../miscs/miscs'
-import { makeGetRequest, makePostBodyRequest, makePutBodyRequest } from '../requests/requests'
-import { ServerInfo } from './servers'
+import { PeerTubeServer } from '../server/server'
 
-function listPlugins (parameters: {
-  url: string
-  accessToken: string
-  start?: number
-  count?: number
-  sort?: string
-  pluginType?: PluginType
-  uninstalled?: boolean
-  expectedStatus?: HttpStatusCode
-}) {
-  const { url, accessToken, start, count, sort, pluginType, uninstalled, expectedStatus = HttpStatusCode.OK_200 } = parameters
-  const path = '/api/v1/plugins'
-
-  return makeGetRequest({
-    url,
-    path,
-    token: accessToken,
-    query: {
-      start,
-      count,
-      sort,
-      pluginType,
-      uninstalled
-    },
-    statusCodeExpected: expectedStatus
-  })
-}
-
-function listAvailablePlugins (parameters: {
-  url: string
-  accessToken: string
-  start?: number
-  count?: number
-  sort?: string
-  pluginType?: PluginType
-  currentPeerTubeEngine?: string
-  search?: string
-  expectedStatus?: HttpStatusCode
-}) {
-  const {
-    url,
-    accessToken,
-    start,
-    count,
-    sort,
-    pluginType,
-    search,
-    currentPeerTubeEngine,
-    expectedStatus = HttpStatusCode.OK_200
-  } = parameters
-  const path = '/api/v1/plugins/available'
-
-  const query: PeertubePluginIndexList = {
-    start,
-    count,
-    sort,
-    pluginType,
-    currentPeerTubeEngine,
-    search
-  }
-
-  return makeGetRequest({
-    url,
-    path,
-    token: accessToken,
-    query,
-    statusCodeExpected: expectedStatus
-  })
-}
-
-function getPlugin (parameters: {
-  url: string
-  accessToken: string
-  npmName: string
-  expectedStatus?: HttpStatusCode
-}) {
-  const { url, accessToken, npmName, expectedStatus = HttpStatusCode.OK_200 } = parameters
-  const path = '/api/v1/plugins/' + npmName
-
-  return makeGetRequest({
-    url,
-    path,
-    token: accessToken,
-    statusCodeExpected: expectedStatus
-  })
-}
-
-function updatePluginSettings (parameters: {
-  url: string
-  accessToken: string
-  npmName: string
-  settings: any
-  expectedStatus?: HttpStatusCode
-}) {
-  const { url, accessToken, npmName, settings, expectedStatus = HttpStatusCode.NO_CONTENT_204 } = parameters
-  const path = '/api/v1/plugins/' + npmName + '/settings'
-
-  return makePutBodyRequest({
-    url,
-    path,
-    token: accessToken,
-    fields: { settings },
-    statusCodeExpected: expectedStatus
-  })
-}
-
-function getPluginRegisteredSettings (parameters: {
-  url: string
-  accessToken: string
-  npmName: string
-  expectedStatus?: HttpStatusCode
-}) {
-  const { url, accessToken, npmName, expectedStatus = HttpStatusCode.OK_200 } = parameters
-  const path = '/api/v1/plugins/' + npmName + '/registered-settings'
-
-  return makeGetRequest({
-    url,
-    path,
-    token: accessToken,
-    statusCodeExpected: expectedStatus
-  })
-}
-
-async function testHelloWorldRegisteredSettings (server: ServerInfo) {
-  const res = await getPluginRegisteredSettings({
-    url: server.url,
-    accessToken: server.accessToken,
-    npmName: 'peertube-plugin-hello-world'
-  })
-
-  const registeredSettings = (res.body as RegisteredServerSettings).registeredSettings
+async function testHelloWorldRegisteredSettings (server: PeerTubeServer) {
+  const body = await server.plugins.getRegisteredSettings({ npmName: 'peertube-plugin-hello-world' })
 
+  const registeredSettings = body.registeredSettings
   expect(registeredSettings).to.have.length.at.least(1)
 
   const adminNameSettings = registeredSettings.find(s => s.name === 'admin-name')
   expect(adminNameSettings).to.not.be.undefined
 }
 
-function getPublicSettings (parameters: {
-  url: string
-  npmName: string
-  expectedStatus?: HttpStatusCode
-}) {
-  const { url, npmName, expectedStatus = HttpStatusCode.OK_200 } = parameters
-  const path = '/api/v1/plugins/' + npmName + '/public-settings'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: expectedStatus
-  })
-}
-
-function getPluginTranslations (parameters: {
-  url: string
-  locale: string
-  expectedStatus?: HttpStatusCode
-}) {
-  const { url, locale, expectedStatus = HttpStatusCode.OK_200 } = parameters
-  const path = '/plugins/translations/' + locale + '.json'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: expectedStatus
-  })
-}
-
-function installPlugin (parameters: {
-  url: string
-  accessToken: string
-  path?: string
-  npmName?: string
-  expectedStatus?: HttpStatusCode
-}) {
-  const { url, accessToken, npmName, path, expectedStatus = HttpStatusCode.OK_200 } = parameters
-  const apiPath = '/api/v1/plugins/install'
-
-  return makePostBodyRequest({
-    url,
-    path: apiPath,
-    token: accessToken,
-    fields: { npmName, path },
-    statusCodeExpected: expectedStatus
-  })
-}
-
-function updatePlugin (parameters: {
-  url: string
-  accessToken: string
-  path?: string
-  npmName?: string
-  expectedStatus?: HttpStatusCode
-}) {
-  const { url, accessToken, npmName, path, expectedStatus = HttpStatusCode.OK_200 } = parameters
-  const apiPath = '/api/v1/plugins/update'
-
-  return makePostBodyRequest({
-    url,
-    path: apiPath,
-    token: accessToken,
-    fields: { npmName, path },
-    statusCodeExpected: expectedStatus
-  })
-}
-
-function uninstallPlugin (parameters: {
-  url: string
-  accessToken: string
-  npmName: string
-  expectedStatus?: HttpStatusCode
-}) {
-  const { url, accessToken, npmName, expectedStatus = HttpStatusCode.NO_CONTENT_204 } = parameters
-  const apiPath = '/api/v1/plugins/uninstall'
-
-  return makePostBodyRequest({
-    url,
-    path: apiPath,
-    token: accessToken,
-    fields: { npmName },
-    statusCodeExpected: expectedStatus
-  })
-}
-
-function getPluginsCSS (url: string) {
-  const path = '/plugins/global.css'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getPackageJSONPath (server: ServerInfo, npmName: string) {
-  return buildServerDirectory(server, join('plugins', 'node_modules', npmName, 'package.json'))
-}
-
-function updatePluginPackageJSON (server: ServerInfo, npmName: string, json: any) {
-  const path = getPackageJSONPath(server, npmName)
-
-  return writeJSON(path, json)
-}
-
-function getPluginPackageJSON (server: ServerInfo, npmName: string) {
-  const path = getPackageJSONPath(server, npmName)
-
-  return readJSON(path)
-}
-
-function getPluginTestPath (suffix = '') {
-  return join(root(), 'server', 'tests', 'fixtures', 'peertube-plugin-test' + suffix)
-}
-
-function getExternalAuth (options: {
-  url: string
-  npmName: string
-  npmVersion: string
-  authName: string
-  query?: any
-  statusCodeExpected?: HttpStatusCode
-}) {
-  const { url, npmName, npmVersion, authName, statusCodeExpected, query } = options
-
-  const path = '/plugins/' + npmName + '/' + npmVersion + '/auth/' + authName
-
-  return makeGetRequest({
-    url,
-    path,
-    query,
-    statusCodeExpected: statusCodeExpected || HttpStatusCode.OK_200,
-    redirects: 0
-  })
-}
-
 export {
-  listPlugins,
-  listAvailablePlugins,
-  installPlugin,
-  getPluginTranslations,
-  getPluginsCSS,
-  updatePlugin,
-  getPlugin,
-  uninstallPlugin,
-  testHelloWorldRegisteredSettings,
-  updatePluginSettings,
-  getPluginRegisteredSettings,
-  getPackageJSONPath,
-  updatePluginPackageJSON,
-  getPluginPackageJSON,
-  getPluginTestPath,
-  getPublicSettings,
-  getExternalAuth
+  testHelloWorldRegisteredSettings
 }
diff --git a/shared/extra-utils/server/redundancy-command.ts b/shared/extra-utils/server/redundancy-command.ts
new file mode 100644
index 000000000..e7a8b3c29
--- /dev/null
+++ b/shared/extra-utils/server/redundancy-command.ts
@@ -0,0 +1,80 @@
+import { HttpStatusCode, ResultList, VideoRedundanciesTarget, VideoRedundancy } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class RedundancyCommand extends AbstractCommand {
+
+  updateRedundancy (options: OverrideCommandOptions & {
+    host: string
+    redundancyAllowed: boolean
+  }) {
+    const { host, redundancyAllowed } = options
+    const path = '/api/v1/server/redundancy/' + host
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: { redundancyAllowed },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  listVideos (options: OverrideCommandOptions & {
+    target: VideoRedundanciesTarget
+    start?: number
+    count?: number
+    sort?: string
+  }) {
+    const path = '/api/v1/server/redundancy/videos'
+
+    const { target, start, count, sort } = options
+
+    return this.getRequestBody<ResultList<VideoRedundancy>>({
+      ...options,
+
+      path,
+
+      query: {
+        start: start ?? 0,
+        count: count ?? 5,
+        sort: sort ?? 'name',
+        target
+      },
+
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  addVideo (options: OverrideCommandOptions & {
+    videoId: number
+  }) {
+    const path = '/api/v1/server/redundancy/videos'
+    const { videoId } = options
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { videoId },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  removeVideo (options: OverrideCommandOptions & {
+    redundancyId: number
+  }) {
+    const { redundancyId } = options
+    const path = '/api/v1/server/redundancy/videos/' + redundancyId
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/server/redundancy.ts b/shared/extra-utils/server/redundancy.ts
deleted file mode 100644
index b83815a37..000000000
--- a/shared/extra-utils/server/redundancy.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import { makeDeleteRequest, makeGetRequest, makePostBodyRequest, makePutBodyRequest } from '../requests/requests'
-import { VideoRedundanciesTarget } from '@shared/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function updateRedundancy (
-  url: string,
-  accessToken: string,
-  host: string,
-  redundancyAllowed: boolean,
-  expectedStatus = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/server/redundancy/' + host
-
-  return makePutBodyRequest({
-    url,
-    path,
-    token: accessToken,
-    fields: { redundancyAllowed },
-    statusCodeExpected: expectedStatus
-  })
-}
-
-function listVideoRedundancies (options: {
-  url: string
-  accessToken: string
-  target: VideoRedundanciesTarget
-  start?: number
-  count?: number
-  sort?: string
-  statusCodeExpected?: HttpStatusCode
-}) {
-  const path = '/api/v1/server/redundancy/videos'
-
-  const { url, accessToken, target, statusCodeExpected, start, count, sort } = options
-
-  return makeGetRequest({
-    url,
-    token: accessToken,
-    path,
-    query: {
-      start: start ?? 0,
-      count: count ?? 5,
-      sort: sort ?? 'name',
-      target
-    },
-    statusCodeExpected: statusCodeExpected || HttpStatusCode.OK_200
-  })
-}
-
-function addVideoRedundancy (options: {
-  url: string
-  accessToken: string
-  videoId: number
-}) {
-  const path = '/api/v1/server/redundancy/videos'
-  const { url, accessToken, videoId } = options
-
-  return makePostBodyRequest({
-    url,
-    token: accessToken,
-    path,
-    fields: { videoId },
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-function removeVideoRedundancy (options: {
-  url: string
-  accessToken: string
-  redundancyId: number
-}) {
-  const { url, accessToken, redundancyId } = options
-  const path = '/api/v1/server/redundancy/videos/' + redundancyId
-
-  return makeDeleteRequest({
-    url,
-    token: accessToken,
-    path,
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-export {
-  updateRedundancy,
-  listVideoRedundancies,
-  addVideoRedundancy,
-  removeVideoRedundancy
-}
diff --git a/shared/extra-utils/server/server.ts b/shared/extra-utils/server/server.ts
new file mode 100644
index 000000000..b33bb9d1e
--- /dev/null
+++ b/shared/extra-utils/server/server.ts
@@ -0,0 +1,378 @@
+import { ChildProcess, fork } from 'child_process'
+import { copy } from 'fs-extra'
+import { join } from 'path'
+import { root } from '@server/helpers/core-utils'
+import { randomInt } from '../../core-utils/miscs/miscs'
+import { VideoChannel } from '../../models/videos'
+import { BulkCommand } from '../bulk'
+import { CLICommand } from '../cli'
+import { CustomPagesCommand } from '../custom-pages'
+import { FeedCommand } from '../feeds'
+import { LogsCommand } from '../logs'
+import { parallelTests, SQLCommand } from '../miscs'
+import { AbusesCommand } from '../moderation'
+import { OverviewsCommand } from '../overviews'
+import { SearchCommand } from '../search'
+import { SocketIOCommand } from '../socket'
+import { AccountsCommand, BlocklistCommand, LoginCommand, NotificationsCommand, SubscriptionsCommand, UsersCommand } from '../users'
+import {
+  BlacklistCommand,
+  CaptionsCommand,
+  ChangeOwnershipCommand,
+  ChannelsCommand,
+  HistoryCommand,
+  ImportsCommand,
+  LiveCommand,
+  PlaylistsCommand,
+  ServicesCommand,
+  StreamingPlaylistsCommand,
+  VideosCommand
+} from '../videos'
+import { CommentsCommand } from '../videos/comments-command'
+import { ConfigCommand } from './config-command'
+import { ContactFormCommand } from './contact-form-command'
+import { DebugCommand } from './debug-command'
+import { FollowsCommand } from './follows-command'
+import { JobsCommand } from './jobs-command'
+import { PluginsCommand } from './plugins-command'
+import { RedundancyCommand } from './redundancy-command'
+import { ServersCommand } from './servers-command'
+import { StatsCommand } from './stats-command'
+
+export type RunServerOptions = {
+  hideLogs?: boolean
+  execArgv?: string[]
+}
+
+export class PeerTubeServer {
+  app?: ChildProcess
+
+  url: string
+  host?: string
+  hostname?: string
+  port?: number
+
+  rtmpPort?: number
+
+  parallel?: boolean
+  internalServerNumber: number
+
+  serverNumber?: number
+  customConfigFile?: string
+
+  store?: {
+    client?: {
+      id?: string
+      secret?: string
+    }
+
+    user?: {
+      username: string
+      password: string
+      email?: string
+    }
+
+    channel?: VideoChannel
+
+    video?: {
+      id: number
+      uuid: string
+      shortUUID: string
+      name?: string
+      url?: string
+
+      account?: {
+        name: string
+      }
+
+      embedPath?: string
+    }
+
+    videos?: { id: number, uuid: string }[]
+  }
+
+  accessToken?: string
+  refreshToken?: string
+
+  bulk?: BulkCommand
+  cli?: CLICommand
+  customPage?: CustomPagesCommand
+  feed?: FeedCommand
+  logs?: LogsCommand
+  abuses?: AbusesCommand
+  overviews?: OverviewsCommand
+  search?: SearchCommand
+  contactForm?: ContactFormCommand
+  debug?: DebugCommand
+  follows?: FollowsCommand
+  jobs?: JobsCommand
+  plugins?: PluginsCommand
+  redundancy?: RedundancyCommand
+  stats?: StatsCommand
+  config?: ConfigCommand
+  socketIO?: SocketIOCommand
+  accounts?: AccountsCommand
+  blocklist?: BlocklistCommand
+  subscriptions?: SubscriptionsCommand
+  live?: LiveCommand
+  services?: ServicesCommand
+  blacklist?: BlacklistCommand
+  captions?: CaptionsCommand
+  changeOwnership?: ChangeOwnershipCommand
+  playlists?: PlaylistsCommand
+  history?: HistoryCommand
+  imports?: ImportsCommand
+  streamingPlaylists?: StreamingPlaylistsCommand
+  channels?: ChannelsCommand
+  comments?: CommentsCommand
+  sql?: SQLCommand
+  notifications?: NotificationsCommand
+  servers?: ServersCommand
+  login?: LoginCommand
+  users?: UsersCommand
+  videos?: VideosCommand
+
+  constructor (options: { serverNumber: number } | { url: string }) {
+    if ((options as any).url) {
+      this.setUrl((options as any).url)
+    } else {
+      this.setServerNumber((options as any).serverNumber)
+    }
+
+    this.store = {
+      client: {
+        id: null,
+        secret: null
+      },
+      user: {
+        username: null,
+        password: null
+      }
+    }
+
+    this.assignCommands()
+  }
+
+  setServerNumber (serverNumber: number) {
+    this.serverNumber = serverNumber
+
+    this.parallel = parallelTests()
+
+    this.internalServerNumber = this.parallel ? this.randomServer() : this.serverNumber
+    this.rtmpPort = this.parallel ? this.randomRTMP() : 1936
+    this.port = 9000 + this.internalServerNumber
+
+    this.url = `http://localhost:${this.port}`
+    this.host = `localhost:${this.port}`
+    this.hostname = 'localhost'
+  }
+
+  setUrl (url: string) {
+    const parsed = new URL(url)
+
+    this.url = url
+    this.host = parsed.host
+    this.hostname = parsed.hostname
+    this.port = parseInt(parsed.port)
+  }
+
+  async flushAndRun (configOverride?: Object, args = [], options: RunServerOptions = {}) {
+    await ServersCommand.flushTests(this.internalServerNumber)
+
+    return this.run(configOverride, args, options)
+  }
+
+  async run (configOverrideArg?: any, args = [], options: RunServerOptions = {}) {
+    // These actions are async so we need to be sure that they have both been done
+    const serverRunString = {
+      'HTTP server listening': false
+    }
+    const key = 'Database peertube_test' + this.internalServerNumber + ' is ready'
+    serverRunString[key] = false
+
+    const regexps = {
+      client_id: 'Client id: (.+)',
+      client_secret: 'Client secret: (.+)',
+      user_username: 'Username: (.+)',
+      user_password: 'User password: (.+)'
+    }
+
+    await this.assignCustomConfigFile()
+
+    const configOverride = this.buildConfigOverride()
+
+    if (configOverrideArg !== undefined) {
+      Object.assign(configOverride, configOverrideArg)
+    }
+
+    // Share the environment
+    const env = Object.create(process.env)
+    env['NODE_ENV'] = 'test'
+    env['NODE_APP_INSTANCE'] = this.internalServerNumber.toString()
+    env['NODE_CONFIG'] = JSON.stringify(configOverride)
+
+    const forkOptions = {
+      silent: true,
+      env,
+      detached: true,
+      execArgv: options.execArgv || []
+    }
+
+    return new Promise<void>(res => {
+      const self = this
+
+      this.app = fork(join(root(), 'dist', 'server.js'), args, forkOptions)
+      this.app.stdout.on('data', function onStdout (data) {
+        let dontContinue = false
+
+        // Capture things if we want to
+        for (const key of Object.keys(regexps)) {
+          const regexp = regexps[key]
+          const matches = data.toString().match(regexp)
+          if (matches !== null) {
+            if (key === 'client_id') self.store.client.id = matches[1]
+            else if (key === 'client_secret') self.store.client.secret = matches[1]
+            else if (key === 'user_username') self.store.user.username = matches[1]
+            else if (key === 'user_password') self.store.user.password = matches[1]
+          }
+        }
+
+        // Check if all required sentences are here
+        for (const key of Object.keys(serverRunString)) {
+          if (data.toString().indexOf(key) !== -1) serverRunString[key] = true
+          if (serverRunString[key] === false) dontContinue = true
+        }
+
+        // If no, there is maybe one thing not already initialized (client/user credentials generation...)
+        if (dontContinue === true) return
+
+        if (options.hideLogs === false) {
+          console.log(data.toString())
+        } else {
+          self.app.stdout.removeListener('data', onStdout)
+        }
+
+        process.on('exit', () => {
+          try {
+            process.kill(self.app.pid)
+          } catch { /* empty */ }
+        })
+
+        res()
+      })
+    })
+  }
+
+  async kill () {
+    if (!this.app) return
+
+    await this.sql.cleanup()
+
+    process.kill(-this.app.pid)
+
+    this.app = null
+  }
+
+  private randomServer () {
+    const low = 10
+    const high = 10000
+
+    return randomInt(low, high)
+  }
+
+  private randomRTMP () {
+    const low = 1900
+    const high = 2100
+
+    return randomInt(low, high)
+  }
+
+  private async assignCustomConfigFile () {
+    if (this.internalServerNumber === this.serverNumber) return
+
+    const basePath = join(root(), 'config')
+
+    const tmpConfigFile = join(basePath, `test-${this.internalServerNumber}.yaml`)
+    await copy(join(basePath, `test-${this.serverNumber}.yaml`), tmpConfigFile)
+
+    this.customConfigFile = tmpConfigFile
+  }
+
+  private buildConfigOverride () {
+    if (!this.parallel) return {}
+
+    return {
+      listen: {
+        port: this.port
+      },
+      webserver: {
+        port: this.port
+      },
+      database: {
+        suffix: '_test' + this.internalServerNumber
+      },
+      storage: {
+        tmp: `test${this.internalServerNumber}/tmp/`,
+        avatars: `test${this.internalServerNumber}/avatars/`,
+        videos: `test${this.internalServerNumber}/videos/`,
+        streaming_playlists: `test${this.internalServerNumber}/streaming-playlists/`,
+        redundancy: `test${this.internalServerNumber}/redundancy/`,
+        logs: `test${this.internalServerNumber}/logs/`,
+        previews: `test${this.internalServerNumber}/previews/`,
+        thumbnails: `test${this.internalServerNumber}/thumbnails/`,
+        torrents: `test${this.internalServerNumber}/torrents/`,
+        captions: `test${this.internalServerNumber}/captions/`,
+        cache: `test${this.internalServerNumber}/cache/`,
+        plugins: `test${this.internalServerNumber}/plugins/`
+      },
+      admin: {
+        email: `admin${this.internalServerNumber}@example.com`
+      },
+      live: {
+        rtmp: {
+          port: this.rtmpPort
+        }
+      }
+    }
+  }
+
+  private assignCommands () {
+    this.bulk = new BulkCommand(this)
+    this.cli = new CLICommand(this)
+    this.customPage = new CustomPagesCommand(this)
+    this.feed = new FeedCommand(this)
+    this.logs = new LogsCommand(this)
+    this.abuses = new AbusesCommand(this)
+    this.overviews = new OverviewsCommand(this)
+    this.search = new SearchCommand(this)
+    this.contactForm = new ContactFormCommand(this)
+    this.debug = new DebugCommand(this)
+    this.follows = new FollowsCommand(this)
+    this.jobs = new JobsCommand(this)
+    this.plugins = new PluginsCommand(this)
+    this.redundancy = new RedundancyCommand(this)
+    this.stats = new StatsCommand(this)
+    this.config = new ConfigCommand(this)
+    this.socketIO = new SocketIOCommand(this)
+    this.accounts = new AccountsCommand(this)
+    this.blocklist = new BlocklistCommand(this)
+    this.subscriptions = new SubscriptionsCommand(this)
+    this.live = new LiveCommand(this)
+    this.services = new ServicesCommand(this)
+    this.blacklist = new BlacklistCommand(this)
+    this.captions = new CaptionsCommand(this)
+    this.changeOwnership = new ChangeOwnershipCommand(this)
+    this.playlists = new PlaylistsCommand(this)
+    this.history = new HistoryCommand(this)
+    this.imports = new ImportsCommand(this)
+    this.streamingPlaylists = new StreamingPlaylistsCommand(this)
+    this.channels = new ChannelsCommand(this)
+    this.comments = new CommentsCommand(this)
+    this.sql = new SQLCommand(this)
+    this.notifications = new NotificationsCommand(this)
+    this.servers = new ServersCommand(this)
+    this.login = new LoginCommand(this)
+    this.users = new UsersCommand(this)
+    this.videos = new VideosCommand(this)
+  }
+}
diff --git a/shared/extra-utils/server/servers-command.ts b/shared/extra-utils/server/servers-command.ts
new file mode 100644
index 000000000..107e2b4ad
--- /dev/null
+++ b/shared/extra-utils/server/servers-command.ts
@@ -0,0 +1,81 @@
+import { exec } from 'child_process'
+import { copy, ensureDir, readFile, remove } from 'fs-extra'
+import { join } from 'path'
+import { root } from '@server/helpers/core-utils'
+import { HttpStatusCode } from '@shared/models'
+import { getFileSize } from '@uploadx/core'
+import { isGithubCI, wait } from '../miscs'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class ServersCommand extends AbstractCommand {
+
+  static flushTests (internalServerNumber: number) {
+    return new Promise<void>((res, rej) => {
+      const suffix = ` -- ${internalServerNumber}`
+
+      return exec('npm run clean:server:test' + suffix, (err, _stdout, stderr) => {
+        if (err || stderr) return rej(err || new Error(stderr))
+
+        return res()
+      })
+    })
+  }
+
+  ping (options: OverrideCommandOptions = {}) {
+    return this.getRequestBody({
+      ...options,
+
+      path: '/api/v1/ping',
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  async cleanupTests () {
+    const p: Promise<any>[] = []
+
+    if (isGithubCI()) {
+      await ensureDir('artifacts')
+
+      const origin = this.buildDirectory('logs/peertube.log')
+      const destname = `peertube-${this.server.internalServerNumber}.log`
+      console.log('Saving logs %s.', destname)
+
+      await copy(origin, join('artifacts', destname))
+    }
+
+    if (this.server.parallel) {
+      p.push(ServersCommand.flushTests(this.server.internalServerNumber))
+    }
+
+    if (this.server.customConfigFile) {
+      p.push(remove(this.server.customConfigFile))
+    }
+
+    return p
+  }
+
+  async waitUntilLog (str: string, count = 1, strictCount = true) {
+    const logfile = this.server.servers.buildDirectory('logs/peertube.log')
+
+    while (true) {
+      const buf = await readFile(logfile)
+
+      const matches = buf.toString().match(new RegExp(str, 'g'))
+      if (matches && matches.length === count) return
+      if (matches && strictCount === false && matches.length >= count) return
+
+      await wait(1000)
+    }
+  }
+
+  buildDirectory (directory: string) {
+    return join(root(), 'test' + this.server.internalServerNumber, directory)
+  }
+
+  async getServerFileSize (subPath: string) {
+    const path = this.server.servers.buildDirectory(subPath)
+
+    return getFileSize(path)
+  }
+}
diff --git a/shared/extra-utils/server/servers.ts b/shared/extra-utils/server/servers.ts
index 28e431e94..87d7e9449 100644
--- a/shared/extra-utils/server/servers.ts
+++ b/shared/extra-utils/server/servers.ts
@@ -1,384 +1,49 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/no-floating-promises */
+import { ensureDir } from 'fs-extra'
+import { isGithubCI } from '../miscs'
+import { PeerTubeServer, RunServerOptions } from './server'
 
-import { expect } from 'chai'
-import { ChildProcess, exec, fork } from 'child_process'
-import { copy, ensureDir, pathExists, readdir, readFile, remove } from 'fs-extra'
-import { join } from 'path'
-import { randomInt } from '../../core-utils/miscs/miscs'
-import { VideoChannel } from '../../models/videos'
-import { buildServerDirectory, getFileSize, isGithubCI, root, wait } from '../miscs/miscs'
-import { makeGetRequest } from '../requests/requests'
+async function createSingleServer (serverNumber: number, configOverride?: Object, args = [], options: RunServerOptions = {}) {
+  const server = new PeerTubeServer({ serverNumber })
 
-interface ServerInfo {
-  app: ChildProcess
-
-  url: string
-  host: string
-  hostname: string
-  port: number
-
-  rtmpPort: number
-
-  parallel: boolean
-  internalServerNumber: number
-  serverNumber: number
-
-  client: {
-    id: string
-    secret: string
-  }
-
-  user: {
-    username: string
-    password: string
-    email?: string
-  }
-
-  customConfigFile?: string
-
-  accessToken?: string
-  refreshToken?: string
-  videoChannel?: VideoChannel
-
-  video?: {
-    id: number
-    uuid: string
-    shortUUID: string
-    name?: string
-    url?: string
-
-    account?: {
-      name: string
-    }
-
-    embedPath?: string
-  }
-
-  remoteVideo?: {
-    id: number
-    uuid: string
-  }
-
-  videos?: { id: number, uuid: string }[]
-}
-
-function parallelTests () {
-  return process.env.MOCHA_PARALLEL === 'true'
-}
-
-function flushAndRunMultipleServers (totalServers: number, configOverride?: Object) {
-  const apps = []
-  let i = 0
-
-  return new Promise<ServerInfo[]>(res => {
-    function anotherServerDone (serverNumber, app) {
-      apps[serverNumber - 1] = app
-      i++
-      if (i === totalServers) {
-        return res(apps)
-      }
-    }
-
-    for (let j = 1; j <= totalServers; j++) {
-      flushAndRunServer(j, configOverride).then(app => anotherServerDone(j, app))
-    }
-  })
-}
-
-function flushTests (serverNumber?: number) {
-  return new Promise<void>((res, rej) => {
-    const suffix = serverNumber ? ` -- ${serverNumber}` : ''
-
-    return exec('npm run clean:server:test' + suffix, (err, _stdout, stderr) => {
-      if (err || stderr) return rej(err || new Error(stderr))
-
-      return res()
-    })
-  })
-}
-
-function randomServer () {
-  const low = 10
-  const high = 10000
-
-  return randomInt(low, high)
-}
-
-function randomRTMP () {
-  const low = 1900
-  const high = 2100
-
-  return randomInt(low, high)
-}
-
-type RunServerOptions = {
-  hideLogs?: boolean
-  execArgv?: string[]
-}
-
-async function flushAndRunServer (serverNumber: number, configOverride?: Object, args = [], options: RunServerOptions = {}) {
-  const parallel = parallelTests()
-
-  const internalServerNumber = parallel ? randomServer() : serverNumber
-  const rtmpPort = parallel ? randomRTMP() : 1936
-  const port = 9000 + internalServerNumber
-
-  await flushTests(internalServerNumber)
-
-  const server: ServerInfo = {
-    app: null,
-    port,
-    internalServerNumber,
-    rtmpPort,
-    parallel,
-    serverNumber,
-    url: `http://localhost:${port}`,
-    host: `localhost:${port}`,
-    hostname: 'localhost',
-    client: {
-      id: null,
-      secret: null
-    },
-    user: {
-      username: null,
-      password: null
-    }
-  }
-
-  return runServer(server, configOverride, args, options)
-}
-
-async function runServer (server: ServerInfo, configOverrideArg?: any, args = [], options: RunServerOptions = {}) {
-  // These actions are async so we need to be sure that they have both been done
-  const serverRunString = {
-    'HTTP server listening': false
-  }
-  const key = 'Database peertube_test' + server.internalServerNumber + ' is ready'
-  serverRunString[key] = false
-
-  const regexps = {
-    client_id: 'Client id: (.+)',
-    client_secret: 'Client secret: (.+)',
-    user_username: 'Username: (.+)',
-    user_password: 'User password: (.+)'
-  }
-
-  if (server.internalServerNumber !== server.serverNumber) {
-    const basePath = join(root(), 'config')
-
-    const tmpConfigFile = join(basePath, `test-${server.internalServerNumber}.yaml`)
-    await copy(join(basePath, `test-${server.serverNumber}.yaml`), tmpConfigFile)
-
-    server.customConfigFile = tmpConfigFile
-  }
-
-  const configOverride: any = {}
-
-  if (server.parallel) {
-    Object.assign(configOverride, {
-      listen: {
-        port: server.port
-      },
-      webserver: {
-        port: server.port
-      },
-      database: {
-        suffix: '_test' + server.internalServerNumber
-      },
-      storage: {
-        tmp: `test${server.internalServerNumber}/tmp/`,
-        avatars: `test${server.internalServerNumber}/avatars/`,
-        videos: `test${server.internalServerNumber}/videos/`,
-        streaming_playlists: `test${server.internalServerNumber}/streaming-playlists/`,
-        redundancy: `test${server.internalServerNumber}/redundancy/`,
-        logs: `test${server.internalServerNumber}/logs/`,
-        previews: `test${server.internalServerNumber}/previews/`,
-        thumbnails: `test${server.internalServerNumber}/thumbnails/`,
-        torrents: `test${server.internalServerNumber}/torrents/`,
-        captions: `test${server.internalServerNumber}/captions/`,
-        cache: `test${server.internalServerNumber}/cache/`,
-        plugins: `test${server.internalServerNumber}/plugins/`
-      },
-      admin: {
-        email: `admin${server.internalServerNumber}@example.com`
-      },
-      live: {
-        rtmp: {
-          port: server.rtmpPort
-        }
-      }
-    })
-  }
-
-  if (configOverrideArg !== undefined) {
-    Object.assign(configOverride, configOverrideArg)
-  }
-
-  // Share the environment
-  const env = Object.create(process.env)
-  env['NODE_ENV'] = 'test'
-  env['NODE_APP_INSTANCE'] = server.internalServerNumber.toString()
-  env['NODE_CONFIG'] = JSON.stringify(configOverride)
-
-  const forkOptions = {
-    silent: true,
-    env,
-    detached: true,
-    execArgv: options.execArgv || []
-  }
-
-  return new Promise<ServerInfo>(res => {
-    server.app = fork(join(root(), 'dist', 'server.js'), args, forkOptions)
-    server.app.stdout.on('data', function onStdout (data) {
-      let dontContinue = false
-
-      // Capture things if we want to
-      for (const key of Object.keys(regexps)) {
-        const regexp = regexps[key]
-        const matches = data.toString().match(regexp)
-        if (matches !== null) {
-          if (key === 'client_id') server.client.id = matches[1]
-          else if (key === 'client_secret') server.client.secret = matches[1]
-          else if (key === 'user_username') server.user.username = matches[1]
-          else if (key === 'user_password') server.user.password = matches[1]
-        }
-      }
-
-      // Check if all required sentences are here
-      for (const key of Object.keys(serverRunString)) {
-        if (data.toString().indexOf(key) !== -1) serverRunString[key] = true
-        if (serverRunString[key] === false) dontContinue = true
-      }
-
-      // If no, there is maybe one thing not already initialized (client/user credentials generation...)
-      if (dontContinue === true) return
-
-      if (options.hideLogs === false) {
-        console.log(data.toString())
-      } else {
-        server.app.stdout.removeListener('data', onStdout)
-      }
-
-      process.on('exit', () => {
-        try {
-          process.kill(server.app.pid)
-        } catch { /* empty */ }
-      })
-
-      res(server)
-    })
-  })
-}
-
-async function reRunServer (server: ServerInfo, configOverride?: any) {
-  const newServer = await runServer(server, configOverride)
-  server.app = newServer.app
+  await server.flushAndRun(configOverride, args, options)
 
   return server
 }
 
-async function checkTmpIsEmpty (server: ServerInfo) {
-  await checkDirectoryIsEmpty(server, 'tmp', [ 'plugins-global.css', 'hls', 'resumable-uploads' ])
+function createMultipleServers (totalServers: number, configOverride?: Object) {
+  const serverPromises: Promise<PeerTubeServer>[] = []
 
-  if (await pathExists(join('test' + server.internalServerNumber, 'tmp', 'hls'))) {
-    await checkDirectoryIsEmpty(server, 'tmp/hls')
+  for (let i = 1; i <= totalServers; i++) {
+    serverPromises.push(createSingleServer(i, configOverride))
   }
-}
-
-async function checkDirectoryIsEmpty (server: ServerInfo, directory: string, exceptions: string[] = []) {
-  const testDirectory = 'test' + server.internalServerNumber
-
-  const directoryPath = join(root(), testDirectory, directory)
 
-  const directoryExists = await pathExists(directoryPath)
-  expect(directoryExists).to.be.true
-
-  const files = await readdir(directoryPath)
-  const filtered = files.filter(f => exceptions.includes(f) === false)
-
-  expect(filtered).to.have.lengthOf(0)
+  return Promise.all(serverPromises)
 }
 
-function killallServers (servers: ServerInfo[]) {
-  for (const server of servers) {
-    if (!server.app) continue
-
-    process.kill(-server.app.pid)
-    server.app = null
-  }
+async function killallServers (servers: PeerTubeServer[]) {
+  return Promise.all(servers.map(s => s.kill()))
 }
 
-async function cleanupTests (servers: ServerInfo[]) {
-  killallServers(servers)
+async function cleanupTests (servers: PeerTubeServer[]) {
+  await killallServers(servers)
 
   if (isGithubCI()) {
     await ensureDir('artifacts')
   }
 
-  const p: Promise<any>[] = []
+  let p: Promise<any>[] = []
   for (const server of servers) {
-    if (isGithubCI()) {
-      const origin = await buildServerDirectory(server, 'logs/peertube.log')
-      const destname = `peertube-${server.internalServerNumber}.log`
-      console.log('Saving logs %s.', destname)
-
-      await copy(origin, join('artifacts', destname))
-    }
-
-    if (server.parallel) {
-      p.push(flushTests(server.internalServerNumber))
-    }
-
-    if (server.customConfigFile) {
-      p.push(remove(server.customConfigFile))
-    }
+    p = p.concat(server.servers.cleanupTests())
   }
 
   return Promise.all(p)
 }
 
-async function waitUntilLog (server: ServerInfo, str: string, count = 1, strictCount = true) {
-  const logfile = buildServerDirectory(server, 'logs/peertube.log')
-
-  while (true) {
-    const buf = await readFile(logfile)
-
-    const matches = buf.toString().match(new RegExp(str, 'g'))
-    if (matches && matches.length === count) return
-    if (matches && strictCount === false && matches.length >= count) return
-
-    await wait(1000)
-  }
-}
-
-async function getServerFileSize (server: ServerInfo, subPath: string) {
-  const path = buildServerDirectory(server, subPath)
-
-  return getFileSize(path)
-}
-
-function makePingRequest (server: ServerInfo) {
-  return makeGetRequest({
-    url: server.url,
-    path: '/api/v1/ping',
-    statusCodeExpected: 200
-  })
-}
-
 // ---------------------------------------------------------------------------
 
 export {
-  checkDirectoryIsEmpty,
-  checkTmpIsEmpty,
-  getServerFileSize,
-  ServerInfo,
-  parallelTests,
+  createSingleServer,
+  createMultipleServers,
   cleanupTests,
-  flushAndRunMultipleServers,
-  flushTests,
-  makePingRequest,
-  flushAndRunServer,
-  killallServers,
-  reRunServer,
-  waitUntilLog
+  killallServers
 }
diff --git a/shared/extra-utils/server/stats-command.ts b/shared/extra-utils/server/stats-command.ts
new file mode 100644
index 000000000..64a452306
--- /dev/null
+++ b/shared/extra-utils/server/stats-command.ts
@@ -0,0 +1,25 @@
+import { HttpStatusCode, ServerStats } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class StatsCommand extends AbstractCommand {
+
+  get (options: OverrideCommandOptions & {
+    useCache?: boolean // default false
+  } = {}) {
+    const { useCache = false } = options
+    const path = '/api/v1/server/stats'
+
+    const query = {
+      t: useCache ? undefined : new Date().getTime()
+    }
+
+    return this.getRequestBody<ServerStats>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/server/stats.ts b/shared/extra-utils/server/stats.ts
deleted file mode 100644
index b9dae24e2..000000000
--- a/shared/extra-utils/server/stats.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { makeGetRequest } from '../requests/requests'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getStats (url: string, useCache = false) {
-  const path = '/api/v1/server/stats'
-
-  const query = {
-    t: useCache ? undefined : new Date().getTime()
-  }
-
-  return makeGetRequest({
-    url,
-    path,
-    query,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getStats
-}
diff --git a/shared/extra-utils/shared/abstract-command.ts b/shared/extra-utils/shared/abstract-command.ts
new file mode 100644
index 000000000..021045e49
--- /dev/null
+++ b/shared/extra-utils/shared/abstract-command.ts
@@ -0,0 +1,199 @@
+import { isAbsolute, join } from 'path'
+import { root } from '../miscs/tests'
+import {
+  makeDeleteRequest,
+  makeGetRequest,
+  makePostBodyRequest,
+  makePutBodyRequest,
+  makeUploadRequest,
+  unwrapBody,
+  unwrapText
+} from '../requests/requests'
+import { PeerTubeServer } from '../server/server'
+
+export interface OverrideCommandOptions {
+  token?: string
+  expectedStatus?: number
+}
+
+interface InternalCommonCommandOptions extends OverrideCommandOptions {
+  // Default to server.url
+  url?: string
+
+  path: string
+  // If we automatically send the server token if the token is not provided
+  implicitToken: boolean
+  defaultExpectedStatus: number
+
+  // Common optional request parameters
+  contentType?: string
+  accept?: string
+  redirects?: number
+  range?: string
+  host?: string
+  headers?: { [ name: string ]: string }
+  requestType?: string
+  xForwardedFor?: string
+}
+
+interface InternalGetCommandOptions extends InternalCommonCommandOptions {
+  query?: { [ id: string ]: any }
+}
+
+abstract class AbstractCommand {
+
+  constructor (
+    protected server: PeerTubeServer
+  ) {
+
+  }
+
+  protected getRequestBody <T> (options: InternalGetCommandOptions) {
+    return unwrapBody<T>(this.getRequest(options))
+  }
+
+  protected getRequestText (options: InternalGetCommandOptions) {
+    return unwrapText(this.getRequest(options))
+  }
+
+  protected getRawRequest (options: Omit<InternalGetCommandOptions, 'path'>) {
+    const { url, range } = options
+    const { host, protocol, pathname } = new URL(url)
+
+    return this.getRequest({
+      ...options,
+
+      token: this.buildCommonRequestToken(options),
+      defaultExpectedStatus: this.buildExpectedStatus(options),
+
+      url: `${protocol}//${host}`,
+      path: pathname,
+      range
+    })
+  }
+
+  protected getRequest (options: InternalGetCommandOptions) {
+    const { query } = options
+
+    return makeGetRequest({
+      ...this.buildCommonRequestOptions(options),
+
+      query
+    })
+  }
+
+  protected deleteRequest (options: InternalCommonCommandOptions) {
+    return makeDeleteRequest(this.buildCommonRequestOptions(options))
+  }
+
+  protected putBodyRequest (options: InternalCommonCommandOptions & {
+    fields?: { [ fieldName: string ]: any }
+  }) {
+    const { fields } = options
+
+    return makePutBodyRequest({
+      ...this.buildCommonRequestOptions(options),
+
+      fields
+    })
+  }
+
+  protected postBodyRequest (options: InternalCommonCommandOptions & {
+    fields?: { [ fieldName: string ]: any }
+  }) {
+    const { fields } = options
+
+    return makePostBodyRequest({
+      ...this.buildCommonRequestOptions(options),
+
+      fields
+    })
+  }
+
+  protected postUploadRequest (options: InternalCommonCommandOptions & {
+    fields?: { [ fieldName: string ]: any }
+    attaches?: { [ fieldName: string ]: any }
+  }) {
+    const { fields, attaches } = options
+
+    return makeUploadRequest({
+      ...this.buildCommonRequestOptions(options),
+
+      method: 'POST',
+      fields,
+      attaches
+    })
+  }
+
+  protected putUploadRequest (options: InternalCommonCommandOptions & {
+    fields?: { [ fieldName: string ]: any }
+    attaches?: { [ fieldName: string ]: any }
+  }) {
+    const { fields, attaches } = options
+
+    return makeUploadRequest({
+      ...this.buildCommonRequestOptions(options),
+
+      method: 'PUT',
+      fields,
+      attaches
+    })
+  }
+
+  protected updateImageRequest (options: InternalCommonCommandOptions & {
+    fixture: string
+    fieldname: string
+  }) {
+    const filePath = isAbsolute(options.fixture)
+      ? options.fixture
+      : join(root(), 'server', 'tests', 'fixtures', options.fixture)
+
+    return this.postUploadRequest({
+      ...options,
+
+      fields: {},
+      attaches: { [options.fieldname]: filePath }
+    })
+  }
+
+  protected buildCommonRequestOptions (options: InternalCommonCommandOptions) {
+    const { url, path, redirects, contentType, accept, range, host, headers, requestType, xForwardedFor } = options
+
+    return {
+      url: url ?? this.server.url,
+      path,
+
+      token: this.buildCommonRequestToken(options),
+      expectedStatus: this.buildExpectedStatus(options),
+
+      redirects,
+      contentType,
+      range,
+      host,
+      accept,
+      headers,
+      type: requestType,
+      xForwardedFor
+    }
+  }
+
+  protected buildCommonRequestToken (options: Pick<InternalCommonCommandOptions, 'token' | 'implicitToken'>) {
+    const { token } = options
+
+    const fallbackToken = options.implicitToken
+      ? this.server.accessToken
+      : undefined
+
+    return token !== undefined ? token : fallbackToken
+  }
+
+  protected buildExpectedStatus (options: Pick<InternalCommonCommandOptions, 'expectedStatus' | 'defaultExpectedStatus'>) {
+    const { expectedStatus, defaultExpectedStatus } = options
+
+    return expectedStatus !== undefined ? expectedStatus : defaultExpectedStatus
+  }
+}
+
+export {
+  AbstractCommand
+}
diff --git a/shared/extra-utils/shared/index.ts b/shared/extra-utils/shared/index.ts
new file mode 100644
index 000000000..e807ab4f7
--- /dev/null
+++ b/shared/extra-utils/shared/index.ts
@@ -0,0 +1 @@
+export * from './abstract-command'
diff --git a/shared/extra-utils/socket/index.ts b/shared/extra-utils/socket/index.ts
new file mode 100644
index 000000000..594329b2f
--- /dev/null
+++ b/shared/extra-utils/socket/index.ts
@@ -0,0 +1 @@
+export * from './socket-io-command'
diff --git a/shared/extra-utils/socket/socket-io-command.ts b/shared/extra-utils/socket/socket-io-command.ts
new file mode 100644
index 000000000..c277ead28
--- /dev/null
+++ b/shared/extra-utils/socket/socket-io-command.ts
@@ -0,0 +1,15 @@
+import { io } from 'socket.io-client'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class SocketIOCommand extends AbstractCommand {
+
+  getUserNotificationSocket (options: OverrideCommandOptions = {}) {
+    return io(this.server.url + '/user-notifications', {
+      query: { accessToken: options.token ?? this.server.accessToken }
+    })
+  }
+
+  getLiveNotificationSocket () {
+    return io(this.server.url + '/live-videos')
+  }
+}
diff --git a/shared/extra-utils/socket/socket-io.ts b/shared/extra-utils/socket/socket-io.ts
deleted file mode 100644
index 4ca93f453..000000000
--- a/shared/extra-utils/socket/socket-io.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import { io } from 'socket.io-client'
-
-function getUserNotificationSocket (serverUrl: string, accessToken: string) {
-  return io(serverUrl + '/user-notifications', {
-    query: { accessToken }
-  })
-}
-
-function getLiveNotificationSocket (serverUrl: string) {
-  return io(serverUrl + '/live-videos')
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getUserNotificationSocket,
-  getLiveNotificationSocket
-}
diff --git a/shared/extra-utils/users/accounts-command.ts b/shared/extra-utils/users/accounts-command.ts
new file mode 100644
index 000000000..2f586104e
--- /dev/null
+++ b/shared/extra-utils/users/accounts-command.ts
@@ -0,0 +1,56 @@
+import { HttpStatusCode, ResultList } from '@shared/models'
+import { Account } from '../../models/actors'
+import { AccountVideoRate, VideoRateType } from '../../models/videos'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class AccountsCommand extends AbstractCommand {
+
+  list (options: OverrideCommandOptions & {
+    sort?: string // default -createdAt
+  } = {}) {
+    const { sort = '-createdAt' } = options
+    const path = '/api/v1/accounts'
+
+    return this.getRequestBody<ResultList<Account>>({
+      ...options,
+
+      path,
+      query: { sort },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  get (options: OverrideCommandOptions & {
+    accountName: string
+  }) {
+    const path = '/api/v1/accounts/' + options.accountName
+
+    return this.getRequestBody<Account>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listRatings (options: OverrideCommandOptions & {
+    accountName: string
+    rating?: VideoRateType
+  }) {
+    const { rating, accountName } = options
+    const path = '/api/v1/accounts/' + accountName + '/ratings'
+
+    const query = { rating }
+
+    return this.getRequestBody<ResultList<AccountVideoRate>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/users/accounts.ts b/shared/extra-utils/users/accounts.ts
deleted file mode 100644
index 4ea7f1402..000000000
--- a/shared/extra-utils/users/accounts.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-
-import * as request from 'supertest'
-import { expect } from 'chai'
-import { existsSync, readdir } from 'fs-extra'
-import { join } from 'path'
-import { Account } from '../../models/actors'
-import { root } from '../miscs/miscs'
-import { makeGetRequest } from '../requests/requests'
-import { VideoRateType } from '../../models/videos'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getAccountsList (url: string, sort = '-createdAt', statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/accounts'
-
-  return makeGetRequest({
-    url,
-    query: { sort },
-    path,
-    statusCodeExpected
-  })
-}
-
-function getAccount (url: string, accountName: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/accounts/' + accountName
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected
-  })
-}
-
-async function expectAccountFollows (url: string, nameWithDomain: string, followersCount: number, followingCount: number) {
-  const res = await getAccountsList(url)
-  const account = res.body.data.find((a: Account) => a.name + '@' + a.host === nameWithDomain)
-
-  const message = `${nameWithDomain} on ${url}`
-  expect(account.followersCount).to.equal(followersCount, message)
-  expect(account.followingCount).to.equal(followingCount, message)
-}
-
-async function checkActorFilesWereRemoved (filename: string, serverNumber: number) {
-  const testDirectory = 'test' + serverNumber
-
-  for (const directory of [ 'avatars' ]) {
-    const directoryPath = join(root(), testDirectory, directory)
-
-    const directoryExists = existsSync(directoryPath)
-    expect(directoryExists).to.be.true
-
-    const files = await readdir(directoryPath)
-    for (const file of files) {
-      expect(file).to.not.contain(filename)
-    }
-  }
-}
-
-function getAccountRatings (
-  url: string,
-  accountName: string,
-  accessToken: string,
-  rating?: VideoRateType,
-  statusCodeExpected = HttpStatusCode.OK_200
-) {
-  const path = '/api/v1/accounts/' + accountName + '/ratings'
-
-  const query = rating ? { rating } : {}
-
-  return request(url)
-          .get(path)
-          .query(query)
-          .set('Accept', 'application/json')
-          .set('Authorization', 'Bearer ' + accessToken)
-          .expect(statusCodeExpected)
-          .expect('Content-Type', /json/)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getAccount,
-  expectAccountFollows,
-  getAccountsList,
-  checkActorFilesWereRemoved,
-  getAccountRatings
-}
diff --git a/shared/extra-utils/users/actors.ts b/shared/extra-utils/users/actors.ts
new file mode 100644
index 000000000..cfcc7d0a7
--- /dev/null
+++ b/shared/extra-utils/users/actors.ts
@@ -0,0 +1,73 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { pathExists, readdir } from 'fs-extra'
+import { join } from 'path'
+import { root } from '@server/helpers/core-utils'
+import { Account, VideoChannel } from '@shared/models'
+import { PeerTubeServer } from '../server'
+
+async function expectChannelsFollows (options: {
+  server: PeerTubeServer
+  handle: string
+  followers: number
+  following: number
+}) {
+  const { server } = options
+  const { data } = await server.channels.list()
+
+  return expectActorFollow({ ...options, data })
+}
+
+async function expectAccountFollows (options: {
+  server: PeerTubeServer
+  handle: string
+  followers: number
+  following: number
+}) {
+  const { server } = options
+  const { data } = await server.accounts.list()
+
+  return expectActorFollow({ ...options, data })
+}
+
+async function checkActorFilesWereRemoved (filename: string, serverNumber: number) {
+  const testDirectory = 'test' + serverNumber
+
+  for (const directory of [ 'avatars' ]) {
+    const directoryPath = join(root(), testDirectory, directory)
+
+    const directoryExists = await pathExists(directoryPath)
+    expect(directoryExists).to.be.true
+
+    const files = await readdir(directoryPath)
+    for (const file of files) {
+      expect(file).to.not.contain(filename)
+    }
+  }
+}
+
+export {
+  expectAccountFollows,
+  expectChannelsFollows,
+  checkActorFilesWereRemoved
+}
+
+// ---------------------------------------------------------------------------
+
+function expectActorFollow (options: {
+  server: PeerTubeServer
+  data: (Account | VideoChannel)[]
+  handle: string
+  followers: number
+  following: number
+}) {
+  const { server, data, handle, followers, following } = options
+
+  const actor = data.find(a => a.name + '@' + a.host === handle)
+  const message = `${handle} on ${server.url}`
+
+  expect(actor, message).to.exist
+  expect(actor.followersCount).to.equal(followers, message)
+  expect(actor.followingCount).to.equal(following, message)
+}
diff --git a/shared/extra-utils/users/blocklist-command.ts b/shared/extra-utils/users/blocklist-command.ts
new file mode 100644
index 000000000..14491a1ae
--- /dev/null
+++ b/shared/extra-utils/users/blocklist-command.ts
@@ -0,0 +1,139 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { AccountBlock, HttpStatusCode, ResultList, ServerBlock } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+type ListBlocklistOptions = OverrideCommandOptions & {
+  start: number
+  count: number
+  sort: string // default -createdAt
+}
+
+export class BlocklistCommand extends AbstractCommand {
+
+  listMyAccountBlocklist (options: ListBlocklistOptions) {
+    const path = '/api/v1/users/me/blocklist/accounts'
+
+    return this.listBlocklist<AccountBlock>(options, path)
+  }
+
+  listMyServerBlocklist (options: ListBlocklistOptions) {
+    const path = '/api/v1/users/me/blocklist/servers'
+
+    return this.listBlocklist<ServerBlock>(options, path)
+  }
+
+  listServerAccountBlocklist (options: ListBlocklistOptions) {
+    const path = '/api/v1/server/blocklist/accounts'
+
+    return this.listBlocklist<AccountBlock>(options, path)
+  }
+
+  listServerServerBlocklist (options: ListBlocklistOptions) {
+    const path = '/api/v1/server/blocklist/servers'
+
+    return this.listBlocklist<ServerBlock>(options, path)
+  }
+
+  // ---------------------------------------------------------------------------
+
+  addToMyBlocklist (options: OverrideCommandOptions & {
+    account?: string
+    server?: string
+  }) {
+    const { account, server } = options
+
+    const path = account
+      ? '/api/v1/users/me/blocklist/accounts'
+      : '/api/v1/users/me/blocklist/servers'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: {
+        accountName: account,
+        host: server
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  addToServerBlocklist (options: OverrideCommandOptions & {
+    account?: string
+    server?: string
+  }) {
+    const { account, server } = options
+
+    const path = account
+      ? '/api/v1/server/blocklist/accounts'
+      : '/api/v1/server/blocklist/servers'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: {
+        accountName: account,
+        host: server
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  removeFromMyBlocklist (options: OverrideCommandOptions & {
+    account?: string
+    server?: string
+  }) {
+    const { account, server } = options
+
+    const path = account
+      ? '/api/v1/users/me/blocklist/accounts/' + account
+      : '/api/v1/users/me/blocklist/servers/' + server
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  removeFromServerBlocklist (options: OverrideCommandOptions & {
+    account?: string
+    server?: string
+  }) {
+    const { account, server } = options
+
+    const path = account
+      ? '/api/v1/server/blocklist/accounts/' + account
+      : '/api/v1/server/blocklist/servers/' + server
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  private listBlocklist <T> (options: ListBlocklistOptions, path: string) {
+    const { start, count, sort = '-createdAt' } = options
+
+    return this.getRequestBody<ResultList<T>>({
+      ...options,
+
+      path,
+      query: { start, count, sort },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+}
diff --git a/shared/extra-utils/users/blocklist.ts b/shared/extra-utils/users/blocklist.ts
deleted file mode 100644
index bdf7ee58a..000000000
--- a/shared/extra-utils/users/blocklist.ts
+++ /dev/null
@@ -1,238 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-
-import { makeGetRequest, makeDeleteRequest, makePostBodyRequest } from '../requests/requests'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getAccountBlocklistByAccount (
-  url: string,
-  token: string,
-  start: number,
-  count: number,
-  sort = '-createdAt',
-  statusCodeExpected = HttpStatusCode.OK_200
-) {
-  const path = '/api/v1/users/me/blocklist/accounts'
-
-  return makeGetRequest({
-    url,
-    token,
-    query: { start, count, sort },
-    path,
-    statusCodeExpected
-  })
-}
-
-function addAccountToAccountBlocklist (
-  url: string,
-  token: string,
-  accountToBlock: string,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/users/me/blocklist/accounts'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    fields: {
-      accountName: accountToBlock
-    },
-    statusCodeExpected
-  })
-}
-
-function removeAccountFromAccountBlocklist (
-  url: string,
-  token: string,
-  accountToUnblock: string,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/users/me/blocklist/accounts/' + accountToUnblock
-
-  return makeDeleteRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-function getServerBlocklistByAccount (
-  url: string,
-  token: string,
-  start: number,
-  count: number,
-  sort = '-createdAt',
-  statusCodeExpected = HttpStatusCode.OK_200
-) {
-  const path = '/api/v1/users/me/blocklist/servers'
-
-  return makeGetRequest({
-    url,
-    token,
-    query: { start, count, sort },
-    path,
-    statusCodeExpected
-  })
-}
-
-function addServerToAccountBlocklist (
-  url: string,
-  token: string,
-  serverToBlock: string,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/users/me/blocklist/servers'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    fields: {
-      host: serverToBlock
-    },
-    statusCodeExpected
-  })
-}
-
-function removeServerFromAccountBlocklist (
-  url: string,
-  token: string,
-  serverToBlock: string,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/users/me/blocklist/servers/' + serverToBlock
-
-  return makeDeleteRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-function getAccountBlocklistByServer (
-  url: string,
-  token: string,
-  start: number,
-  count: number,
-  sort = '-createdAt',
-  statusCodeExpected = HttpStatusCode.OK_200
-) {
-  const path = '/api/v1/server/blocklist/accounts'
-
-  return makeGetRequest({
-    url,
-    token,
-    query: { start, count, sort },
-    path,
-    statusCodeExpected
-  })
-}
-
-function addAccountToServerBlocklist (
-  url: string,
-  token: string,
-  accountToBlock: string,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/server/blocklist/accounts'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    fields: {
-      accountName: accountToBlock
-    },
-    statusCodeExpected
-  })
-}
-
-function removeAccountFromServerBlocklist (
-  url: string,
-  token: string,
-  accountToUnblock: string,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/server/blocklist/accounts/' + accountToUnblock
-
-  return makeDeleteRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-function getServerBlocklistByServer (
-  url: string,
-  token: string,
-  start: number,
-  count: number,
-  sort = '-createdAt',
-  statusCodeExpected = HttpStatusCode.OK_200
-) {
-  const path = '/api/v1/server/blocklist/servers'
-
-  return makeGetRequest({
-    url,
-    token,
-    query: { start, count, sort },
-    path,
-    statusCodeExpected
-  })
-}
-
-function addServerToServerBlocklist (
-  url: string,
-  token: string,
-  serverToBlock: string,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/server/blocklist/servers'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    fields: {
-      host: serverToBlock
-    },
-    statusCodeExpected
-  })
-}
-
-function removeServerFromServerBlocklist (
-  url: string,
-  token: string,
-  serverToBlock: string,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/server/blocklist/servers/' + serverToBlock
-
-  return makeDeleteRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getAccountBlocklistByAccount,
-  addAccountToAccountBlocklist,
-  removeAccountFromAccountBlocklist,
-  getServerBlocklistByAccount,
-  addServerToAccountBlocklist,
-  removeServerFromAccountBlocklist,
-
-  getAccountBlocklistByServer,
-  addAccountToServerBlocklist,
-  removeAccountFromServerBlocklist,
-  getServerBlocklistByServer,
-  addServerToServerBlocklist,
-  removeServerFromServerBlocklist
-}
diff --git a/shared/extra-utils/users/index.ts b/shared/extra-utils/users/index.ts
new file mode 100644
index 000000000..460a06f70
--- /dev/null
+++ b/shared/extra-utils/users/index.ts
@@ -0,0 +1,9 @@
+export * from './accounts-command'
+export * from './actors'
+export * from './blocklist-command'
+export * from './login'
+export * from './login-command'
+export * from './notifications'
+export * from './notifications-command'
+export * from './subscriptions-command'
+export * from './users-command'
diff --git a/shared/extra-utils/users/login-command.ts b/shared/extra-utils/users/login-command.ts
new file mode 100644
index 000000000..143f72a59
--- /dev/null
+++ b/shared/extra-utils/users/login-command.ts
@@ -0,0 +1,132 @@
+import { HttpStatusCode, PeerTubeProblemDocument } from '@shared/models'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class LoginCommand extends AbstractCommand {
+
+  login (options: OverrideCommandOptions & {
+    client?: { id?: string, secret?: string }
+    user?: { username: string, password?: string }
+  } = {}) {
+    const { client = this.server.store.client, user = this.server.store.user } = options
+    const path = '/api/v1/users/token'
+
+    const body = {
+      client_id: client.id,
+      client_secret: client.secret,
+      username: user.username,
+      password: user.password ?? 'password',
+      response_type: 'code',
+      grant_type: 'password',
+      scope: 'upload'
+    }
+
+    return unwrapBody<{ access_token: string, refresh_token: string } & PeerTubeProblemDocument>(this.postBodyRequest({
+      ...options,
+
+      path,
+      requestType: 'form',
+      fields: body,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+  }
+
+  getAccessToken (arg1?: { username: string, password?: string }): Promise<string>
+  getAccessToken (arg1: string, password?: string): Promise<string>
+  async getAccessToken (arg1?: { username: string, password?: string } | string, password?: string) {
+    let user: { username: string, password?: string }
+
+    if (!arg1) user = this.server.store.user
+    else if (typeof arg1 === 'object') user = arg1
+    else user = { username: arg1, password }
+
+    try {
+      const body = await this.login({ user })
+
+      return body.access_token
+    } catch (err) {
+      throw new Error(`Cannot authenticate. Please check your username/password. (${err})`)
+    }
+  }
+
+  loginUsingExternalToken (options: OverrideCommandOptions & {
+    username: string
+    externalAuthToken: string
+  }) {
+    const { username, externalAuthToken } = options
+    const path = '/api/v1/users/token'
+
+    const body = {
+      client_id: this.server.store.client.id,
+      client_secret: this.server.store.client.secret,
+      username: username,
+      response_type: 'code',
+      grant_type: 'password',
+      scope: 'upload',
+      externalAuthToken
+    }
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      requestType: 'form',
+      fields: body,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  logout (options: OverrideCommandOptions & {
+    token: string
+  }) {
+    const path = '/api/v1/users/revoke-token'
+
+    return unwrapBody<{ redirectUrl: string }>(this.postBodyRequest({
+      ...options,
+
+      path,
+      requestType: 'form',
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+  }
+
+  refreshToken (options: OverrideCommandOptions & {
+    refreshToken: string
+  }) {
+    const path = '/api/v1/users/token'
+
+    const body = {
+      client_id: this.server.store.client.id,
+      client_secret: this.server.store.client.secret,
+      refresh_token: options.refreshToken,
+      response_type: 'code',
+      grant_type: 'refresh_token'
+    }
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      requestType: 'form',
+      fields: body,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getClient (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/oauth-clients/local'
+
+    return this.getRequestBody<{ client_id: string, client_secret: string }>({
+      ...options,
+
+      path,
+      host: this.server.host,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/users/login.ts b/shared/extra-utils/users/login.ts
index 39e1a2747..f1df027d3 100644
--- a/shared/extra-utils/users/login.ts
+++ b/shared/extra-utils/users/login.ts
@@ -1,133 +1,19 @@
-import * as request from 'supertest'
+import { PeerTubeServer } from '../server/server'
 
-import { ServerInfo } from '../server/servers'
-import { getClient } from '../server/clients'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-type Client = { id: string, secret: string }
-type User = { username: string, password: string }
-type Server = { url: string, client: Client, user: User }
-
-function login (url: string, client: Client, user: User, expectedStatus = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/token'
-
-  const body = {
-    client_id: client.id,
-    client_secret: client.secret,
-    username: user.username,
-    password: user.password,
-    response_type: 'code',
-    grant_type: 'password',
-    scope: 'upload'
-  }
-
-  return request(url)
-          .post(path)
-          .type('form')
-          .send(body)
-          .expect(expectedStatus)
-}
-
-function logout (url: string, token: string, expectedStatus = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/revoke-token'
-
-  return request(url)
-    .post(path)
-    .set('Authorization', 'Bearer ' + token)
-    .type('form')
-    .expect(expectedStatus)
-}
-
-async function serverLogin (server: Server) {
-  const res = await login(server.url, server.client, server.user, HttpStatusCode.OK_200)
-
-  return res.body.access_token as string
-}
-
-function refreshToken (server: ServerInfo, refreshToken: string, expectedStatus = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/token'
-
-  const body = {
-    client_id: server.client.id,
-    client_secret: server.client.secret,
-    refresh_token: refreshToken,
-    response_type: 'code',
-    grant_type: 'refresh_token'
-  }
-
-  return request(server.url)
-    .post(path)
-    .type('form')
-    .send(body)
-    .expect(expectedStatus)
-}
-
-async function userLogin (server: Server, user: User, expectedStatus = HttpStatusCode.OK_200) {
-  const res = await login(server.url, server.client, user, expectedStatus)
-
-  return res.body.access_token as string
-}
-
-async function getAccessToken (url: string, username: string, password: string) {
-  const resClient = await getClient(url)
-  const client = {
-    id: resClient.body.client_id,
-    secret: resClient.body.client_secret
-  }
-
-  const user = { username, password }
-
-  try {
-    const res = await login(url, client, user)
-    return res.body.access_token
-  } catch (err) {
-    throw new Error('Cannot authenticate. Please check your username/password.')
-  }
-}
-
-function setAccessTokensToServers (servers: ServerInfo[]) {
+function setAccessTokensToServers (servers: PeerTubeServer[]) {
   const tasks: Promise<any>[] = []
 
   for (const server of servers) {
-    const p = serverLogin(server).then(t => { server.accessToken = t })
+    const p = server.login.getAccessToken()
+                                 .then(t => { server.accessToken = t })
     tasks.push(p)
   }
 
   return Promise.all(tasks)
 }
 
-function loginUsingExternalToken (server: Server, username: string, externalAuthToken: string, expectedStatus = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/token'
-
-  const body = {
-    client_id: server.client.id,
-    client_secret: server.client.secret,
-    username: username,
-    response_type: 'code',
-    grant_type: 'password',
-    scope: 'upload',
-    externalAuthToken
-  }
-
-  return request(server.url)
-          .post(path)
-          .type('form')
-          .send(body)
-          .expect(expectedStatus)
-}
-
 // ---------------------------------------------------------------------------
 
 export {
-  login,
-  logout,
-  serverLogin,
-  refreshToken,
-  userLogin,
-  getAccessToken,
-  setAccessTokensToServers,
-  Server,
-  Client,
-  User,
-  loginUsingExternalToken
+  setAccessTokensToServers
 }
diff --git a/shared/extra-utils/users/notifications-command.ts b/shared/extra-utils/users/notifications-command.ts
new file mode 100644
index 000000000..2d79a3747
--- /dev/null
+++ b/shared/extra-utils/users/notifications-command.ts
@@ -0,0 +1,86 @@
+import { HttpStatusCode, ResultList } from '@shared/models'
+import { UserNotification, UserNotificationSetting } from '../../models/users'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class NotificationsCommand extends AbstractCommand {
+
+  updateMySettings (options: OverrideCommandOptions & {
+    settings: UserNotificationSetting
+  }) {
+    const path = '/api/v1/users/me/notification-settings'
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: options.settings,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  list (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    unread?: boolean
+    sort?: string
+  }) {
+    const { start, count, unread, sort = '-createdAt' } = options
+    const path = '/api/v1/users/me/notifications'
+
+    return this.getRequestBody<ResultList<UserNotification>>({
+      ...options,
+
+      path,
+      query: {
+        start,
+        count,
+        sort,
+        unread
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  markAsRead (options: OverrideCommandOptions & {
+    ids: number[]
+  }) {
+    const { ids } = options
+    const path = '/api/v1/users/me/notifications/read'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { ids },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  markAsReadAll (options: OverrideCommandOptions) {
+    const path = '/api/v1/users/me/notifications/read-all'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  async getLastest (options: OverrideCommandOptions = {}) {
+    const { total, data } = await this.list({
+      ...options,
+      start: 0,
+      count: 1,
+      sort: '-createdAt'
+    })
+
+    if (total === 0) return undefined
+
+    return data[0]
+  }
+}
diff --git a/shared/extra-utils/users/user-notifications.ts b/shared/extra-utils/users/notifications.ts
index 844f4442d..4c42fad3e 100644
--- a/shared/extra-utils/users/user-notifications.ts
+++ b/shared/extra-utils/users/notifications.ts
@@ -3,91 +3,36 @@
 import { expect } from 'chai'
 import { inspect } from 'util'
 import { AbuseState, PluginType } from '@shared/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 import { UserNotification, UserNotificationSetting, UserNotificationSettingValue, UserNotificationType } from '../../models/users'
-import { MockSmtpServer } from '../miscs/email'
-import { makeGetRequest, makePostBodyRequest, makePutBodyRequest } from '../requests/requests'
+import { MockSmtpServer } from '../mock-servers/mock-email'
+import { PeerTubeServer } from '../server'
 import { doubleFollow } from '../server/follows'
-import { flushAndRunMultipleServers, ServerInfo } from '../server/servers'
-import { getUserNotificationSocket } from '../socket/socket-io'
-import { setAccessTokensToServers, userLogin } from './login'
-import { createUser, getMyUserInformation } from './users'
+import { createMultipleServers } from '../server/servers'
+import { setAccessTokensToServers } from './login'
 
-function updateMyNotificationSettings (
-  url: string,
-  token: string,
-  settings: UserNotificationSetting,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/users/me/notification-settings'
-
-  return makePutBodyRequest({
-    url,
-    path,
-    token,
-    fields: settings,
-    statusCodeExpected
-  })
-}
-
-async function getUserNotifications (
-  url: string,
-  token: string,
-  start: number,
-  count: number,
-  unread?: boolean,
-  sort = '-createdAt',
-  statusCodeExpected = HttpStatusCode.OK_200
-) {
-  const path = '/api/v1/users/me/notifications'
-
-  return makeGetRequest({
-    url,
-    path,
-    token,
-    query: {
-      start,
-      count,
-      sort,
-      unread
-    },
-    statusCodeExpected
-  })
-}
-
-function markAsReadNotifications (url: string, token: string, ids: number[], statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/users/me/notifications/read'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    fields: { ids },
-    statusCodeExpected
-  })
-}
-
-function markAsReadAllNotifications (url: string, token: string, statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/users/me/notifications/read-all'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-async function getLastNotification (serverUrl: string, accessToken: string) {
-  const res = await getUserNotifications(serverUrl, accessToken, 0, 1, undefined, '-createdAt')
-
-  if (res.body.total === 0) return undefined
-
-  return res.body.data[0] as UserNotification
+function getAllNotificationsSettings (): UserNotificationSetting {
+  return {
+    newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newCommentOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    abuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    myVideoImportFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    myVideoPublished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    commentMention: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newFollow: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newUserRegistration: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newInstanceFollower: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    abuseNewMessage: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    autoInstanceFollowing: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newPluginVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
+  }
 }
 
 type CheckerBaseParams = {
-  server: ServerInfo
+  server: PeerTubeServer
   emails: any[]
   socketNotifications: UserNotification[]
   token: string
@@ -105,7 +50,7 @@ async function checkNotification (
   const check = base.check || { web: true, mail: true }
 
   if (check.web) {
-    const notification = await getLastNotification(base.server.url, base.token)
+    const notification = await base.server.notifications.getLastest({ token: base.token })
 
     if (notification || checkType !== 'absence') {
       notificationChecker(notification, checkType)
@@ -681,27 +626,6 @@ async function checkNewPluginVersion (base: CheckerBaseParams, pluginType: Plugi
   await checkNotification(base, notificationChecker, emailNotificationFinder, type)
 }
 
-function getAllNotificationsSettings (): UserNotificationSetting {
-  return {
-    newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    newCommentOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    abuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    myVideoImportFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    myVideoPublished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    commentMention: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    newFollow: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    newUserRegistration: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    newInstanceFollower: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    abuseNewMessage: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    autoInstanceFollowing: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    newPluginVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
-  }
-}
-
 async function prepareNotificationsTest (serversCount = 3, overrideConfigArg: any = {}) {
   const userNotifications: UserNotification[] = []
   const adminNotifications: UserNotification[] = []
@@ -719,7 +643,7 @@ async function prepareNotificationsTest (serversCount = 3, overrideConfigArg: an
       limit: 20
     }
   }
-  const servers = await flushAndRunMultipleServers(serversCount, Object.assign(overrideConfig, overrideConfigArg))
+  const servers = await createMultipleServers(serversCount, Object.assign(overrideConfig, overrideConfigArg))
 
   await setAccessTokensToServers(servers)
 
@@ -727,42 +651,33 @@ async function prepareNotificationsTest (serversCount = 3, overrideConfigArg: an
     await doubleFollow(servers[0], servers[1])
   }
 
-  const user = {
-    username: 'user_1',
-    password: 'super password'
-  }
-  await createUser({
-    url: servers[0].url,
-    accessToken: servers[0].accessToken,
-    username: user.username,
-    password: user.password,
-    videoQuota: 10 * 1000 * 1000
-  })
-  const userAccessToken = await userLogin(servers[0], user)
+  const user = { username: 'user_1', password: 'super password' }
+  await servers[0].users.create({ ...user, videoQuota: 10 * 1000 * 1000 })
+  const userAccessToken = await servers[0].login.getAccessToken(user)
 
-  await updateMyNotificationSettings(servers[0].url, userAccessToken, getAllNotificationsSettings())
-  await updateMyNotificationSettings(servers[0].url, servers[0].accessToken, getAllNotificationsSettings())
+  await servers[0].notifications.updateMySettings({ token: userAccessToken, settings: getAllNotificationsSettings() })
+  await servers[0].notifications.updateMySettings({ settings: getAllNotificationsSettings() })
 
   if (serversCount > 1) {
-    await updateMyNotificationSettings(servers[1].url, servers[1].accessToken, getAllNotificationsSettings())
+    await servers[1].notifications.updateMySettings({ settings: getAllNotificationsSettings() })
   }
 
   {
-    const socket = getUserNotificationSocket(servers[0].url, userAccessToken)
+    const socket = servers[0].socketIO.getUserNotificationSocket({ token: userAccessToken })
     socket.on('new-notification', n => userNotifications.push(n))
   }
   {
-    const socket = getUserNotificationSocket(servers[0].url, servers[0].accessToken)
+    const socket = servers[0].socketIO.getUserNotificationSocket()
     socket.on('new-notification', n => adminNotifications.push(n))
   }
 
   if (serversCount > 1) {
-    const socket = getUserNotificationSocket(servers[1].url, servers[1].accessToken)
+    const socket = servers[1].socketIO.getUserNotificationSocket()
     socket.on('new-notification', n => adminNotificationsServer2.push(n))
   }
 
-  const resChannel = await getMyUserInformation(servers[0].url, servers[0].accessToken)
-  const channelId = resChannel.body.videoChannels[0].id
+  const { videoChannels } = await servers[0].users.getMyInfo()
+  const channelId = videoChannels[0].id
 
   return {
     userNotifications,
@@ -778,11 +693,11 @@ async function prepareNotificationsTest (serversCount = 3, overrideConfigArg: an
 // ---------------------------------------------------------------------------
 
 export {
+  getAllNotificationsSettings,
+
   CheckerBaseParams,
   CheckerType,
-  getAllNotificationsSettings,
   checkNotification,
-  markAsReadAllNotifications,
   checkMyVideoImportIsFinished,
   checkUserRegistered,
   checkAutoInstanceFollowing,
@@ -792,14 +707,10 @@ export {
   checkNewCommentOnMyVideo,
   checkNewBlacklistOnMyVideo,
   checkCommentMention,
-  updateMyNotificationSettings,
   checkNewVideoAbuseForModerators,
   checkVideoAutoBlacklistForModerators,
   checkNewAbuseMessage,
   checkAbuseStateChange,
-  getUserNotifications,
-  markAsReadNotifications,
-  getLastNotification,
   checkNewInstanceFollower,
   prepareNotificationsTest,
   checkNewCommentAbuseForModerators,
diff --git a/shared/extra-utils/users/subscriptions-command.ts b/shared/extra-utils/users/subscriptions-command.ts
new file mode 100644
index 000000000..edc60e612
--- /dev/null
+++ b/shared/extra-utils/users/subscriptions-command.ts
@@ -0,0 +1,99 @@
+import { HttpStatusCode, ResultList, Video, VideoChannel } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class SubscriptionsCommand extends AbstractCommand {
+
+  add (options: OverrideCommandOptions & {
+    targetUri: string
+  }) {
+    const path = '/api/v1/users/me/subscriptions'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { uri: options.targetUri },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  list (options: OverrideCommandOptions & {
+    sort?: string // default -createdAt
+    search?: string
+  } = {}) {
+    const { sort = '-createdAt', search } = options
+    const path = '/api/v1/users/me/subscriptions'
+
+    return this.getRequestBody<ResultList<VideoChannel>>({
+      ...options,
+
+      path,
+      query: {
+        sort,
+        search
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listVideos (options: OverrideCommandOptions & {
+    sort?: string // default -createdAt
+  } = {}) {
+    const { sort = '-createdAt' } = options
+    const path = '/api/v1/users/me/subscriptions/videos'
+
+    return this.getRequestBody<ResultList<Video>>({
+      ...options,
+
+      path,
+      query: { sort },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  get (options: OverrideCommandOptions & {
+    uri: string
+  }) {
+    const path = '/api/v1/users/me/subscriptions/' + options.uri
+
+    return this.getRequestBody<VideoChannel>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  remove (options: OverrideCommandOptions & {
+    uri: string
+  }) {
+    const path = '/api/v1/users/me/subscriptions/' + options.uri
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  exist (options: OverrideCommandOptions & {
+    uris: string[]
+  }) {
+    const path = '/api/v1/users/me/subscriptions/exist'
+
+    return this.getRequestBody<{ [id: string ]: boolean }>({
+      ...options,
+
+      path,
+      query: { 'uris[]': options.uris },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/users/user-subscriptions.ts b/shared/extra-utils/users/user-subscriptions.ts
deleted file mode 100644
index edc7a3562..000000000
--- a/shared/extra-utils/users/user-subscriptions.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-import { makeDeleteRequest, makeGetRequest, makePostBodyRequest } from '../requests/requests'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function addUserSubscription (url: string, token: string, targetUri: string, statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/users/me/subscriptions'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected,
-    fields: { uri: targetUri }
-  })
-}
-
-function listUserSubscriptions (parameters: {
-  url: string
-  token: string
-  sort?: string
-  search?: string
-  statusCodeExpected?: number
-}) {
-  const { url, token, sort = '-createdAt', search, statusCodeExpected = HttpStatusCode.OK_200 } = parameters
-  const path = '/api/v1/users/me/subscriptions'
-
-  return makeGetRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected,
-    query: {
-      sort,
-      search
-    }
-  })
-}
-
-function listUserSubscriptionVideos (url: string, token: string, sort = '-createdAt', statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/me/subscriptions/videos'
-
-  return makeGetRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected,
-    query: { sort }
-  })
-}
-
-function getUserSubscription (url: string, token: string, uri: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/me/subscriptions/' + uri
-
-  return makeGetRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-function removeUserSubscription (url: string, token: string, uri: string, statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/users/me/subscriptions/' + uri
-
-  return makeDeleteRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-function areSubscriptionsExist (url: string, token: string, uris: string[], statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/me/subscriptions/exist'
-
-  return makeGetRequest({
-    url,
-    path,
-    query: { 'uris[]': uris },
-    token,
-    statusCodeExpected
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  areSubscriptionsExist,
-  addUserSubscription,
-  listUserSubscriptions,
-  getUserSubscription,
-  listUserSubscriptionVideos,
-  removeUserSubscription
-}
diff --git a/shared/extra-utils/users/users-command.ts b/shared/extra-utils/users/users-command.ts
new file mode 100644
index 000000000..d66ad15f2
--- /dev/null
+++ b/shared/extra-utils/users/users-command.ts
@@ -0,0 +1,414 @@
+import { omit, pick } from 'lodash'
+import {
+  HttpStatusCode,
+  MyUser,
+  ResultList,
+  User,
+  UserAdminFlag,
+  UserCreateResult,
+  UserRole,
+  UserUpdate,
+  UserUpdateMe,
+  UserVideoQuota,
+  UserVideoRate
+} from '@shared/models'
+import { ScopedToken } from '@shared/models/users/user-scoped-token'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class UsersCommand extends AbstractCommand {
+
+  askResetPassword (options: OverrideCommandOptions & {
+    email: string
+  }) {
+    const { email } = options
+    const path = '/api/v1/users/ask-reset-password'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { email },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  resetPassword (options: OverrideCommandOptions & {
+    userId: number
+    verificationString: string
+    password: string
+  }) {
+    const { userId, verificationString, password } = options
+    const path = '/api/v1/users/' + userId + '/reset-password'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { password, verificationString },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  askSendVerifyEmail (options: OverrideCommandOptions & {
+    email: string
+  }) {
+    const { email } = options
+    const path = '/api/v1/users/ask-send-verify-email'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { email },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  verifyEmail (options: OverrideCommandOptions & {
+    userId: number
+    verificationString: string
+    isPendingEmail?: boolean // default false
+  }) {
+    const { userId, verificationString, isPendingEmail = false } = options
+    const path = '/api/v1/users/' + userId + '/verify-email'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: {
+        verificationString,
+        isPendingEmail
+      },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  banUser (options: OverrideCommandOptions & {
+    userId: number
+    reason?: string
+  }) {
+    const { userId, reason } = options
+    const path = '/api/v1/users' + '/' + userId + '/block'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { reason },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  unbanUser (options: OverrideCommandOptions & {
+    userId: number
+  }) {
+    const { userId } = options
+    const path = '/api/v1/users' + '/' + userId + '/unblock'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  getMyScopedTokens (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/users/scoped-tokens'
+
+    return this.getRequestBody<ScopedToken>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  renewMyScopedTokens (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/users/scoped-tokens'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  create (options: OverrideCommandOptions & {
+    username: string
+    password?: string
+    videoQuota?: number
+    videoQuotaDaily?: number
+    role?: UserRole
+    adminFlags?: UserAdminFlag
+  }) {
+    const {
+      username,
+      adminFlags,
+      password = 'password',
+      videoQuota = 42000000,
+      videoQuotaDaily = -1,
+      role = UserRole.USER
+    } = options
+
+    const path = '/api/v1/users'
+
+    return unwrapBody<{ user: UserCreateResult }>(this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: {
+        username,
+        password,
+        role,
+        adminFlags,
+        email: username + '@example.com',
+        videoQuota,
+        videoQuotaDaily
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })).then(res => res.user)
+  }
+
+  async generate (username: string) {
+    const password = 'password'
+    const user = await this.create({ username, password })
+
+    const token = await this.server.login.getAccessToken({ username, password })
+
+    const me = await this.getMyInfo({ token })
+
+    return {
+      token,
+      userId: user.id,
+      userChannelId: me.videoChannels[0].id
+    }
+  }
+
+  async generateUserAndToken (username: string) {
+    const password = 'password'
+    await this.create({ username, password })
+
+    return this.server.login.getAccessToken({ username, password })
+  }
+
+  register (options: OverrideCommandOptions & {
+    username: string
+    password?: string
+    displayName?: string
+    channel?: {
+      name: string
+      displayName: string
+    }
+  }) {
+    const { username, password = 'password', displayName, channel } = options
+    const path = '/api/v1/users/register'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: {
+        username,
+        password,
+        email: username + '@example.com',
+        displayName,
+        channel
+      },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  getMyInfo (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/users/me'
+
+    return this.getRequestBody<MyUser>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getMyQuotaUsed (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/users/me/video-quota-used'
+
+    return this.getRequestBody<UserVideoQuota>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getMyRating (options: OverrideCommandOptions & {
+    videoId: number | string
+  }) {
+    const { videoId } = options
+    const path = '/api/v1/users/me/videos/' + videoId + '/rating'
+
+    return this.getRequestBody<UserVideoRate>({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  deleteMe (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/users/me'
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  updateMe (options: OverrideCommandOptions & UserUpdateMe) {
+    const path = '/api/v1/users/me'
+
+    const toSend: UserUpdateMe = omit(options, 'url', 'accessToken')
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: toSend,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  updateMyAvatar (options: OverrideCommandOptions & {
+    fixture: string
+  }) {
+    const { fixture } = options
+    const path = '/api/v1/users/me/avatar/pick'
+
+    return this.updateImageRequest({
+      ...options,
+
+      path,
+      fixture,
+      fieldname: 'avatarfile',
+
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  get (options: OverrideCommandOptions & {
+    userId: number
+    withStats?: boolean // default false
+  }) {
+    const { userId, withStats } = options
+    const path = '/api/v1/users/' + userId
+
+    return this.getRequestBody<User>({
+      ...options,
+
+      path,
+      query: { withStats },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  list (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+    search?: string
+    blocked?: boolean
+  } = {}) {
+    const path = '/api/v1/users'
+
+    return this.getRequestBody<ResultList<User>>({
+      ...options,
+
+      path,
+      query: pick(options, [ 'start', 'count', 'sort', 'search', 'blocked' ]),
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  remove (options: OverrideCommandOptions & {
+    userId: number
+  }) {
+    const { userId } = options
+    const path = '/api/v1/users/' + userId
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  update (options: OverrideCommandOptions & {
+    userId: number
+    email?: string
+    emailVerified?: boolean
+    videoQuota?: number
+    videoQuotaDaily?: number
+    password?: string
+    adminFlags?: UserAdminFlag
+    pluginAuth?: string
+    role?: UserRole
+  }) {
+    const path = '/api/v1/users/' + options.userId
+
+    const toSend: UserUpdate = {}
+    if (options.password !== undefined && options.password !== null) toSend.password = options.password
+    if (options.email !== undefined && options.email !== null) toSend.email = options.email
+    if (options.emailVerified !== undefined && options.emailVerified !== null) toSend.emailVerified = options.emailVerified
+    if (options.videoQuota !== undefined && options.videoQuota !== null) toSend.videoQuota = options.videoQuota
+    if (options.videoQuotaDaily !== undefined && options.videoQuotaDaily !== null) toSend.videoQuotaDaily = options.videoQuotaDaily
+    if (options.role !== undefined && options.role !== null) toSend.role = options.role
+    if (options.adminFlags !== undefined && options.adminFlags !== null) toSend.adminFlags = options.adminFlags
+    if (options.pluginAuth !== undefined) toSend.pluginAuth = options.pluginAuth
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: toSend,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/users/users.ts b/shared/extra-utils/users/users.ts
deleted file mode 100644
index 0f15962ad..000000000
--- a/shared/extra-utils/users/users.ts
+++ /dev/null
@@ -1,415 +0,0 @@
-import { omit } from 'lodash'
-import * as request from 'supertest'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { UserUpdateMe } from '../../models/users'
-import { UserAdminFlag } from '../../models/users/user-flag.model'
-import { UserRegister } from '../../models/users/user-register.model'
-import { UserRole } from '../../models/users/user-role'
-import { makeGetRequest, makePostBodyRequest, makePutBodyRequest, updateImageRequest } from '../requests/requests'
-import { ServerInfo } from '../server/servers'
-import { userLogin } from './login'
-
-function createUser (parameters: {
-  url: string
-  accessToken: string
-  username: string
-  password: string
-  videoQuota?: number
-  videoQuotaDaily?: number
-  role?: UserRole
-  adminFlags?: UserAdminFlag
-  specialStatus?: number
-}) {
-  const {
-    url,
-    accessToken,
-    username,
-    adminFlags,
-    password = 'password',
-    videoQuota = 1000000,
-    videoQuotaDaily = -1,
-    role = UserRole.USER,
-    specialStatus = HttpStatusCode.OK_200
-  } = parameters
-
-  const path = '/api/v1/users'
-  const body = {
-    username,
-    password,
-    role,
-    adminFlags,
-    email: username + '@example.com',
-    videoQuota,
-    videoQuotaDaily
-  }
-
-  return request(url)
-          .post(path)
-          .set('Accept', 'application/json')
-          .set('Authorization', 'Bearer ' + accessToken)
-          .send(body)
-          .expect(specialStatus)
-}
-
-async function generateUser (server: ServerInfo, username: string) {
-  const password = 'my super password'
-  const resCreate = await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
-
-  const token = await userLogin(server, { username, password })
-
-  const resMe = await getMyUserInformation(server.url, token)
-
-  return {
-    token,
-    userId: resCreate.body.user.id,
-    userChannelId: resMe.body.videoChannels[0].id
-  }
-}
-
-async function generateUserAccessToken (server: ServerInfo, username: string) {
-  const password = 'my super password'
-  await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
-
-  return userLogin(server, { username, password })
-}
-
-function registerUser (url: string, username: string, password: string, specialStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/users/register'
-  const body = {
-    username,
-    password,
-    email: username + '@example.com'
-  }
-
-  return request(url)
-          .post(path)
-          .set('Accept', 'application/json')
-          .send(body)
-          .expect(specialStatus)
-}
-
-function registerUserWithChannel (options: {
-  url: string
-  user: { username: string, password: string, displayName?: string }
-  channel: { name: string, displayName: string }
-}) {
-  const path = '/api/v1/users/register'
-  const body: UserRegister = {
-    username: options.user.username,
-    password: options.user.password,
-    email: options.user.username + '@example.com',
-    channel: options.channel
-  }
-
-  if (options.user.displayName) {
-    Object.assign(body, { displayName: options.user.displayName })
-  }
-
-  return makePostBodyRequest({
-    url: options.url,
-    path,
-    fields: body,
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-function getMyUserInformation (url: string, accessToken: string, specialStatus = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/me'
-
-  return request(url)
-          .get(path)
-          .set('Accept', 'application/json')
-          .set('Authorization', 'Bearer ' + accessToken)
-          .expect(specialStatus)
-          .expect('Content-Type', /json/)
-}
-
-function getUserScopedTokens (url: string, token: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/scoped-tokens'
-
-  return makeGetRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-function renewUserScopedTokens (url: string, token: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/scoped-tokens'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-function deleteMe (url: string, accessToken: string, specialStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/users/me'
-
-  return request(url)
-    .delete(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .expect(specialStatus)
-}
-
-function getMyUserVideoQuotaUsed (url: string, accessToken: string, specialStatus = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/me/video-quota-used'
-
-  return request(url)
-          .get(path)
-          .set('Accept', 'application/json')
-          .set('Authorization', 'Bearer ' + accessToken)
-          .expect(specialStatus)
-          .expect('Content-Type', /json/)
-}
-
-function getUserInformation (url: string, accessToken: string, userId: number, withStats = false) {
-  const path = '/api/v1/users/' + userId
-
-  return request(url)
-    .get(path)
-    .query({ withStats })
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function getMyUserVideoRating (url: string, accessToken: string, videoId: number | string, specialStatus = HttpStatusCode.OK_200) {
-  const path = '/api/v1/users/me/videos/' + videoId + '/rating'
-
-  return request(url)
-          .get(path)
-          .set('Accept', 'application/json')
-          .set('Authorization', 'Bearer ' + accessToken)
-          .expect(specialStatus)
-          .expect('Content-Type', /json/)
-}
-
-function getUsersList (url: string, accessToken: string) {
-  const path = '/api/v1/users'
-
-  return request(url)
-          .get(path)
-          .set('Accept', 'application/json')
-          .set('Authorization', 'Bearer ' + accessToken)
-          .expect(HttpStatusCode.OK_200)
-          .expect('Content-Type', /json/)
-}
-
-function getUsersListPaginationAndSort (
-  url: string,
-  accessToken: string,
-  start: number,
-  count: number,
-  sort: string,
-  search?: string,
-  blocked?: boolean
-) {
-  const path = '/api/v1/users'
-
-  const query = {
-    start,
-    count,
-    sort,
-    search,
-    blocked
-  }
-
-  return request(url)
-          .get(path)
-          .query(query)
-          .set('Accept', 'application/json')
-          .set('Authorization', 'Bearer ' + accessToken)
-          .expect(HttpStatusCode.OK_200)
-          .expect('Content-Type', /json/)
-}
-
-function removeUser (url: string, userId: number | string, accessToken: string, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/users'
-
-  return request(url)
-          .delete(path + '/' + userId)
-          .set('Accept', 'application/json')
-          .set('Authorization', 'Bearer ' + accessToken)
-          .expect(expectedStatus)
-}
-
-function blockUser (
-  url: string,
-  userId: number | string,
-  accessToken: string,
-  expectedStatus = HttpStatusCode.NO_CONTENT_204,
-  reason?: string
-) {
-  const path = '/api/v1/users'
-  let body: any
-  if (reason) body = { reason }
-
-  return request(url)
-    .post(path + '/' + userId + '/block')
-    .send(body)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .expect(expectedStatus)
-}
-
-function unblockUser (url: string, userId: number | string, accessToken: string, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/users'
-
-  return request(url)
-    .post(path + '/' + userId + '/unblock')
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .expect(expectedStatus)
-}
-
-function updateMyUser (options: { url: string, accessToken: string, statusCodeExpected?: HttpStatusCode } & UserUpdateMe) {
-  const path = '/api/v1/users/me'
-
-  const toSend: UserUpdateMe = omit(options, 'url', 'accessToken')
-
-  return makePutBodyRequest({
-    url: options.url,
-    path,
-    token: options.accessToken,
-    fields: toSend,
-    statusCodeExpected: options.statusCodeExpected || HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-function updateMyAvatar (options: {
-  url: string
-  accessToken: string
-  fixture: string
-}) {
-  const path = '/api/v1/users/me/avatar/pick'
-
-  return updateImageRequest({ ...options, path, fieldname: 'avatarfile' })
-}
-
-function updateUser (options: {
-  url: string
-  userId: number
-  accessToken: string
-  email?: string
-  emailVerified?: boolean
-  videoQuota?: number
-  videoQuotaDaily?: number
-  password?: string
-  adminFlags?: UserAdminFlag
-  pluginAuth?: string
-  role?: UserRole
-}) {
-  const path = '/api/v1/users/' + options.userId
-
-  const toSend = {}
-  if (options.password !== undefined && options.password !== null) toSend['password'] = options.password
-  if (options.email !== undefined && options.email !== null) toSend['email'] = options.email
-  if (options.emailVerified !== undefined && options.emailVerified !== null) toSend['emailVerified'] = options.emailVerified
-  if (options.videoQuota !== undefined && options.videoQuota !== null) toSend['videoQuota'] = options.videoQuota
-  if (options.videoQuotaDaily !== undefined && options.videoQuotaDaily !== null) toSend['videoQuotaDaily'] = options.videoQuotaDaily
-  if (options.role !== undefined && options.role !== null) toSend['role'] = options.role
-  if (options.adminFlags !== undefined && options.adminFlags !== null) toSend['adminFlags'] = options.adminFlags
-  if (options.pluginAuth !== undefined) toSend['pluginAuth'] = options.pluginAuth
-
-  return makePutBodyRequest({
-    url: options.url,
-    path,
-    token: options.accessToken,
-    fields: toSend,
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-function askResetPassword (url: string, email: string) {
-  const path = '/api/v1/users/ask-reset-password'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    fields: { email },
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-function resetPassword (
-  url: string,
-  userId: number,
-  verificationString: string,
-  password: string,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/users/' + userId + '/reset-password'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    fields: { password, verificationString },
-    statusCodeExpected
-  })
-}
-
-function askSendVerifyEmail (url: string, email: string) {
-  const path = '/api/v1/users/ask-send-verify-email'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    fields: { email },
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-function verifyEmail (
-  url: string,
-  userId: number,
-  verificationString: string,
-  isPendingEmail = false,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/users/' + userId + '/verify-email'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    fields: {
-      verificationString,
-      isPendingEmail
-    },
-    statusCodeExpected
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  createUser,
-  registerUser,
-  getMyUserInformation,
-  getMyUserVideoRating,
-  deleteMe,
-  registerUserWithChannel,
-  getMyUserVideoQuotaUsed,
-  getUsersList,
-  getUsersListPaginationAndSort,
-  removeUser,
-  updateUser,
-  updateMyUser,
-  getUserInformation,
-  blockUser,
-  unblockUser,
-  askResetPassword,
-  resetPassword,
-  renewUserScopedTokens,
-  updateMyAvatar,
-  generateUser,
-  askSendVerifyEmail,
-  generateUserAccessToken,
-  verifyEmail,
-  getUserScopedTokens
-}
diff --git a/shared/extra-utils/videos/blacklist-command.ts b/shared/extra-utils/videos/blacklist-command.ts
new file mode 100644
index 000000000..3a2ef89ba
--- /dev/null
+++ b/shared/extra-utils/videos/blacklist-command.ts
@@ -0,0 +1,76 @@
+
+import { HttpStatusCode, ResultList } from '@shared/models'
+import { VideoBlacklist, VideoBlacklistType } from '../../models/videos'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class BlacklistCommand extends AbstractCommand {
+
+  add (options: OverrideCommandOptions & {
+    videoId: number | string
+    reason?: string
+    unfederate?: boolean
+  }) {
+    const { videoId, reason, unfederate } = options
+    const path = '/api/v1/videos/' + videoId + '/blacklist'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { reason, unfederate },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  update (options: OverrideCommandOptions & {
+    videoId: number | string
+    reason?: string
+  }) {
+    const { videoId, reason } = options
+    const path = '/api/v1/videos/' + videoId + '/blacklist'
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: { reason },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  remove (options: OverrideCommandOptions & {
+    videoId: number | string
+  }) {
+    const { videoId } = options
+    const path = '/api/v1/videos/' + videoId + '/blacklist'
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  list (options: OverrideCommandOptions & {
+    sort?: string
+    type?: VideoBlacklistType
+  } = {}) {
+    const { sort, type } = options
+    const path = '/api/v1/videos/blacklist/'
+
+    const query = { sort, type }
+
+    return this.getRequestBody<ResultList<VideoBlacklist>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/videos/captions-command.ts b/shared/extra-utils/videos/captions-command.ts
new file mode 100644
index 000000000..a65ea99e3
--- /dev/null
+++ b/shared/extra-utils/videos/captions-command.ts
@@ -0,0 +1,65 @@
+import { HttpStatusCode, ResultList, VideoCaption } from '@shared/models'
+import { buildAbsoluteFixturePath } from '../miscs'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class CaptionsCommand extends AbstractCommand {
+
+  add (options: OverrideCommandOptions & {
+    videoId: string | number
+    language: string
+    fixture: string
+    mimeType?: string
+  }) {
+    const { videoId, language, fixture, mimeType } = options
+
+    const path = '/api/v1/videos/' + videoId + '/captions/' + language
+
+    const captionfile = buildAbsoluteFixturePath(fixture)
+    const captionfileAttach = mimeType
+      ? [ captionfile, { contentType: mimeType } ]
+      : captionfile
+
+    return this.putUploadRequest({
+      ...options,
+
+      path,
+      fields: {},
+      attaches: {
+        captionfile: captionfileAttach
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  list (options: OverrideCommandOptions & {
+    videoId: string | number
+  }) {
+    const { videoId } = options
+    const path = '/api/v1/videos/' + videoId + '/captions'
+
+    return this.getRequestBody<ResultList<VideoCaption>>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  delete (options: OverrideCommandOptions & {
+    videoId: string | number
+    language: string
+  }) {
+    const { videoId, language } = options
+    const path = '/api/v1/videos/' + videoId + '/captions/' + language
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/videos/captions.ts b/shared/extra-utils/videos/captions.ts
new file mode 100644
index 000000000..ff8a43366
--- /dev/null
+++ b/shared/extra-utils/videos/captions.ts
@@ -0,0 +1,17 @@
+import { expect } from 'chai'
+import * as request from 'supertest'
+import { HttpStatusCode } from '@shared/models'
+
+async function testCaptionFile (url: string, captionPath: string, containsString: string) {
+  const res = await request(url)
+    .get(captionPath)
+    .expect(HttpStatusCode.OK_200)
+
+  expect(res.text).to.contain(containsString)
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  testCaptionFile
+}
diff --git a/shared/extra-utils/videos/change-ownership-command.ts b/shared/extra-utils/videos/change-ownership-command.ts
new file mode 100644
index 000000000..ad4c726ef
--- /dev/null
+++ b/shared/extra-utils/videos/change-ownership-command.ts
@@ -0,0 +1,68 @@
+
+import { HttpStatusCode, ResultList, VideoChangeOwnership } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class ChangeOwnershipCommand extends AbstractCommand {
+
+  create (options: OverrideCommandOptions & {
+    videoId: number | string
+    username: string
+  }) {
+    const { videoId, username } = options
+    const path = '/api/v1/videos/' + videoId + '/give-ownership'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { username },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  list (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/videos/ownership'
+
+    return this.getRequestBody<ResultList<VideoChangeOwnership>>({
+      ...options,
+
+      path,
+      query: { sort: '-createdAt' },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  accept (options: OverrideCommandOptions & {
+    ownershipId: number
+    channelId: number
+  }) {
+    const { ownershipId, channelId } = options
+    const path = '/api/v1/videos/ownership/' + ownershipId + '/accept'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { channelId },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  refuse (options: OverrideCommandOptions & {
+    ownershipId: number
+  }) {
+    const { ownershipId } = options
+    const path = '/api/v1/videos/ownership/' + ownershipId + '/refuse'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/videos/channels-command.ts b/shared/extra-utils/videos/channels-command.ts
new file mode 100644
index 000000000..f8eb3f885
--- /dev/null
+++ b/shared/extra-utils/videos/channels-command.ts
@@ -0,0 +1,156 @@
+import { pick } from 'lodash'
+import { HttpStatusCode, ResultList, VideoChannel, VideoChannelCreateResult } from '@shared/models'
+import { VideoChannelCreate } from '../../models/videos/channel/video-channel-create.model'
+import { VideoChannelUpdate } from '../../models/videos/channel/video-channel-update.model'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class ChannelsCommand extends AbstractCommand {
+
+  list (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+    withStats?: boolean
+  } = {}) {
+    const path = '/api/v1/video-channels'
+
+    return this.getRequestBody<ResultList<VideoChannel>>({
+      ...options,
+
+      path,
+      query: pick(options, [ 'start', 'count', 'sort', 'withStats' ]),
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listByAccount (options: OverrideCommandOptions & {
+    accountName: string
+    start?: number
+    count?: number
+    sort?: string
+    withStats?: boolean
+    search?: string
+  }) {
+    const { accountName, sort = 'createdAt' } = options
+    const path = '/api/v1/accounts/' + accountName + '/video-channels'
+
+    return this.getRequestBody<ResultList<VideoChannel>>({
+      ...options,
+
+      path,
+      query: { sort, ...pick(options, [ 'start', 'count', 'withStats', 'search' ]) },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  async create (options: OverrideCommandOptions & {
+    attributes: VideoChannelCreate
+  }) {
+    const path = '/api/v1/video-channels/'
+
+    // Default attributes
+    const defaultAttributes = {
+      displayName: 'my super video channel',
+      description: 'my super channel description',
+      support: 'my super channel support'
+    }
+    const attributes = { ...defaultAttributes, ...options.attributes }
+
+    const body = await unwrapBody<{ videoChannel: VideoChannelCreateResult }>(this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: attributes,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+
+    return body.videoChannel
+  }
+
+  update (options: OverrideCommandOptions & {
+    channelName: string
+    attributes: VideoChannelUpdate
+  }) {
+    const { channelName, attributes } = options
+    const path = '/api/v1/video-channels/' + channelName
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: attributes,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  delete (options: OverrideCommandOptions & {
+    channelName: string
+  }) {
+    const path = '/api/v1/video-channels/' + options.channelName
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  get (options: OverrideCommandOptions & {
+    channelName: string
+  }) {
+    const path = '/api/v1/video-channels/' + options.channelName
+
+    return this.getRequestBody<VideoChannel>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  updateImage (options: OverrideCommandOptions & {
+    fixture: string
+    channelName: string | number
+    type: 'avatar' | 'banner'
+  }) {
+    const { channelName, fixture, type } = options
+
+    const path = `/api/v1/video-channels/${channelName}/${type}/pick`
+
+    return this.updateImageRequest({
+      ...options,
+
+      path,
+      fixture,
+      fieldname: type + 'file',
+
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  deleteImage (options: OverrideCommandOptions & {
+    channelName: string | number
+    type: 'avatar' | 'banner'
+  }) {
+    const { channelName, type } = options
+
+    const path = `/api/v1/video-channels/${channelName}/${type}`
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/videos/channels.ts b/shared/extra-utils/videos/channels.ts
new file mode 100644
index 000000000..756c47453
--- /dev/null
+++ b/shared/extra-utils/videos/channels.ts
@@ -0,0 +1,18 @@
+import { PeerTubeServer } from '../server/server'
+
+function setDefaultVideoChannel (servers: PeerTubeServer[]) {
+  const tasks: Promise<any>[] = []
+
+  for (const server of servers) {
+    const p = server.users.getMyInfo()
+      .then(user => { server.store.channel = user.videoChannels[0] })
+
+    tasks.push(p)
+  }
+
+  return Promise.all(tasks)
+}
+
+export {
+  setDefaultVideoChannel
+}
diff --git a/shared/extra-utils/videos/comments-command.ts b/shared/extra-utils/videos/comments-command.ts
new file mode 100644
index 000000000..f0d163a07
--- /dev/null
+++ b/shared/extra-utils/videos/comments-command.ts
@@ -0,0 +1,152 @@
+import { pick } from 'lodash'
+import { HttpStatusCode, ResultList, VideoComment, VideoCommentThreads, VideoCommentThreadTree } from '@shared/models'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class CommentsCommand extends AbstractCommand {
+
+  private lastVideoId: number | string
+  private lastThreadId: number
+  private lastReplyId: number
+
+  listForAdmin (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+    isLocal?: boolean
+    search?: string
+    searchAccount?: string
+    searchVideo?: string
+  } = {}) {
+    const { sort = '-createdAt' } = options
+    const path = '/api/v1/videos/comments'
+
+    const query = { sort, ...pick(options, [ 'start', 'count', 'isLocal', 'search', 'searchAccount', 'searchVideo' ]) }
+
+    return this.getRequestBody<ResultList<VideoComment>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listThreads (options: OverrideCommandOptions & {
+    videoId: number | string
+    start?: number
+    count?: number
+    sort?: string
+  }) {
+    const { start, count, sort, videoId } = options
+    const path = '/api/v1/videos/' + videoId + '/comment-threads'
+
+    return this.getRequestBody<VideoCommentThreads>({
+      ...options,
+
+      path,
+      query: { start, count, sort },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getThread (options: OverrideCommandOptions & {
+    videoId: number | string
+    threadId: number
+  }) {
+    const { videoId, threadId } = options
+    const path = '/api/v1/videos/' + videoId + '/comment-threads/' + threadId
+
+    return this.getRequestBody<VideoCommentThreadTree>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  async createThread (options: OverrideCommandOptions & {
+    videoId: number | string
+    text: string
+  }) {
+    const { videoId, text } = options
+    const path = '/api/v1/videos/' + videoId + '/comment-threads'
+
+    const body = await unwrapBody<{ comment: VideoComment }>(this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { text },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+
+    this.lastThreadId = body.comment?.id
+    this.lastVideoId = videoId
+
+    return body.comment
+  }
+
+  async addReply (options: OverrideCommandOptions & {
+    videoId: number | string
+    toCommentId: number
+    text: string
+  }) {
+    const { videoId, toCommentId, text } = options
+    const path = '/api/v1/videos/' + videoId + '/comments/' + toCommentId
+
+    const body = await unwrapBody<{ comment: VideoComment }>(this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { text },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+
+    this.lastReplyId = body.comment?.id
+
+    return body.comment
+  }
+
+  async addReplyToLastReply (options: OverrideCommandOptions & {
+    text: string
+  }) {
+    return this.addReply({ ...options, videoId: this.lastVideoId, toCommentId: this.lastReplyId })
+  }
+
+  async addReplyToLastThread (options: OverrideCommandOptions & {
+    text: string
+  }) {
+    return this.addReply({ ...options, videoId: this.lastVideoId, toCommentId: this.lastThreadId })
+  }
+
+  async findCommentId (options: OverrideCommandOptions & {
+    videoId: number | string
+    text: string
+  }) {
+    const { videoId, text } = options
+    const { data } = await this.listThreads({ videoId, count: 25, sort: '-createdAt' })
+
+    return data.find(c => c.text === text).id
+  }
+
+  delete (options: OverrideCommandOptions & {
+    videoId: number | string
+    commentId: number
+  }) {
+    const { videoId, commentId } = options
+    const path = '/api/v1/videos/' + videoId + '/comments/' + commentId
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/videos/history-command.ts b/shared/extra-utils/videos/history-command.ts
new file mode 100644
index 000000000..13b7150c1
--- /dev/null
+++ b/shared/extra-utils/videos/history-command.ts
@@ -0,0 +1,58 @@
+import { HttpStatusCode, ResultList, Video } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class HistoryCommand extends AbstractCommand {
+
+  wathVideo (options: OverrideCommandOptions & {
+    videoId: number | string
+    currentTime: number
+  }) {
+    const { videoId, currentTime } = options
+
+    const path = '/api/v1/videos/' + videoId + '/watching'
+    const fields = { currentTime }
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  list (options: OverrideCommandOptions & {
+    search?: string
+  } = {}) {
+    const { search } = options
+    const path = '/api/v1/users/me/history/videos'
+
+    return this.getRequestBody<ResultList<Video>>({
+      ...options,
+
+      path,
+      query: {
+        search
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  remove (options: OverrideCommandOptions & {
+    beforeDate?: string
+  } = {}) {
+    const { beforeDate } = options
+    const path = '/api/v1/users/me/history/videos/remove'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: { beforeDate },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+}
diff --git a/shared/extra-utils/videos/imports-command.ts b/shared/extra-utils/videos/imports-command.ts
new file mode 100644
index 000000000..e4944694d
--- /dev/null
+++ b/shared/extra-utils/videos/imports-command.ts
@@ -0,0 +1,47 @@
+
+import { HttpStatusCode, ResultList } from '@shared/models'
+import { VideoImport, VideoImportCreate } from '../../models/videos'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class ImportsCommand extends AbstractCommand {
+
+  importVideo (options: OverrideCommandOptions & {
+    attributes: VideoImportCreate & { torrentfile?: string }
+  }) {
+    const { attributes } = options
+    const path = '/api/v1/videos/imports'
+
+    let attaches: any = {}
+    if (attributes.torrentfile) attaches = { torrentfile: attributes.torrentfile }
+
+    return unwrapBody<VideoImport>(this.postUploadRequest({
+      ...options,
+
+      path,
+      attaches,
+      fields: options.attributes,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+  }
+
+  getMyVideoImports (options: OverrideCommandOptions & {
+    sort?: string
+  } = {}) {
+    const { sort } = options
+    const path = '/api/v1/users/me/videos/imports'
+
+    const query = {}
+    if (sort) query['sort'] = sort
+
+    return this.getRequestBody<ResultList<VideoImport>>({
+      ...options,
+
+      path,
+      query: { sort },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/videos/index.ts b/shared/extra-utils/videos/index.ts
new file mode 100644
index 000000000..26e663f46
--- /dev/null
+++ b/shared/extra-utils/videos/index.ts
@@ -0,0 +1,19 @@
+export * from './blacklist-command'
+export * from './captions-command'
+export * from './captions'
+export * from './change-ownership-command'
+export * from './channels'
+export * from './channels-command'
+export * from './comments-command'
+export * from './history-command'
+export * from './imports-command'
+export * from './live-command'
+export * from './live'
+export * from './playlists-command'
+export * from './playlists'
+export * from './services-command'
+export * from './streaming-playlists-command'
+export * from './streaming-playlists'
+export * from './comments-command'
+export * from './videos-command'
+export * from './videos'
diff --git a/shared/extra-utils/videos/live-command.ts b/shared/extra-utils/videos/live-command.ts
new file mode 100644
index 000000000..bf9486a05
--- /dev/null
+++ b/shared/extra-utils/videos/live-command.ts
@@ -0,0 +1,154 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { readdir } from 'fs-extra'
+import { omit } from 'lodash'
+import { join } from 'path'
+import { HttpStatusCode, LiveVideo, LiveVideoCreate, LiveVideoUpdate, VideoCreateResult, VideoDetails, VideoState } from '@shared/models'
+import { wait } from '../miscs'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+import { sendRTMPStream, testFfmpegStreamError } from './live'
+
+export class LiveCommand extends AbstractCommand {
+
+  get (options: OverrideCommandOptions & {
+    videoId: number | string
+  }) {
+    const path = '/api/v1/videos/live'
+
+    return this.getRequestBody<LiveVideo>({
+      ...options,
+
+      path: path + '/' + options.videoId,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  update (options: OverrideCommandOptions & {
+    videoId: number | string
+    fields: LiveVideoUpdate
+  }) {
+    const { videoId, fields } = options
+    const path = '/api/v1/videos/live'
+
+    return this.putBodyRequest({
+      ...options,
+
+      path: path + '/' + videoId,
+      fields,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  async create (options: OverrideCommandOptions & {
+    fields: LiveVideoCreate
+  }) {
+    const { fields } = options
+    const path = '/api/v1/videos/live'
+
+    const attaches: any = {}
+    if (fields.thumbnailfile) attaches.thumbnailfile = fields.thumbnailfile
+    if (fields.previewfile) attaches.previewfile = fields.previewfile
+
+    const body = await unwrapBody<{ video: VideoCreateResult }>(this.postUploadRequest({
+      ...options,
+
+      path,
+      attaches,
+      fields: omit(fields, 'thumbnailfile', 'previewfile'),
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+
+    return body.video
+  }
+
+  async sendRTMPStreamInVideo (options: OverrideCommandOptions & {
+    videoId: number | string
+    fixtureName?: string
+  }) {
+    const { videoId, fixtureName } = options
+    const videoLive = await this.get({ videoId })
+
+    return sendRTMPStream(videoLive.rtmpUrl, videoLive.streamKey, fixtureName)
+  }
+
+  async runAndTestStreamError (options: OverrideCommandOptions & {
+    videoId: number | string
+    shouldHaveError: boolean
+  }) {
+    const command = await this.sendRTMPStreamInVideo(options)
+
+    return testFfmpegStreamError(command, options.shouldHaveError)
+  }
+
+  waitUntilPublished (options: OverrideCommandOptions & {
+    videoId: number | string
+  }) {
+    const { videoId } = options
+    return this.waitUntilState({ videoId, state: VideoState.PUBLISHED })
+  }
+
+  waitUntilWaiting (options: OverrideCommandOptions & {
+    videoId: number | string
+  }) {
+    const { videoId } = options
+    return this.waitUntilState({ videoId, state: VideoState.WAITING_FOR_LIVE })
+  }
+
+  waitUntilEnded (options: OverrideCommandOptions & {
+    videoId: number | string
+  }) {
+    const { videoId } = options
+    return this.waitUntilState({ videoId, state: VideoState.LIVE_ENDED })
+  }
+
+  waitUntilSegmentGeneration (options: OverrideCommandOptions & {
+    videoUUID: string
+    resolution: number
+    segment: number
+  }) {
+    const { resolution, segment, videoUUID } = options
+    const segmentName = `${resolution}-00000${segment}.ts`
+
+    return this.server.servers.waitUntilLog(`${videoUUID}/${segmentName}`, 2, false)
+  }
+
+  async waitUntilSaved (options: OverrideCommandOptions & {
+    videoId: number | string
+  }) {
+    let video: VideoDetails
+
+    do {
+      video = await this.server.videos.getWithToken({ token: options.token, id: options.videoId })
+
+      await wait(500)
+    } while (video.isLive === true && video.state.id !== VideoState.PUBLISHED)
+  }
+
+  async countPlaylists (options: OverrideCommandOptions & {
+    videoUUID: string
+  }) {
+    const basePath = this.server.servers.buildDirectory('streaming-playlists')
+    const hlsPath = join(basePath, 'hls', options.videoUUID)
+
+    const files = await readdir(hlsPath)
+
+    return files.filter(f => f.endsWith('.m3u8')).length
+  }
+
+  private async waitUntilState (options: OverrideCommandOptions & {
+    videoId: number | string
+    state: VideoState
+  }) {
+    let video: VideoDetails
+
+    do {
+      video = await this.server.videos.getWithToken({ token: options.token, id: options.videoId })
+
+      await wait(500)
+    } while (video.state.id !== options.state)
+  }
+}
diff --git a/shared/extra-utils/videos/live.ts b/shared/extra-utils/videos/live.ts
index c0384769b..502964b1a 100644
--- a/shared/extra-utils/videos/live.ts
+++ b/shared/extra-utils/videos/live.ts
@@ -3,69 +3,9 @@
 import { expect } from 'chai'
 import * as ffmpeg from 'fluent-ffmpeg'
 import { pathExists, readdir } from 'fs-extra'
-import { omit } from 'lodash'
 import { join } from 'path'
-import { LiveVideo, LiveVideoCreate, LiveVideoUpdate, VideoDetails, VideoState } from '@shared/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { buildAbsoluteFixturePath, buildServerDirectory, wait } from '../miscs/miscs'
-import { makeGetRequest, makePutBodyRequest, makeUploadRequest } from '../requests/requests'
-import { ServerInfo, waitUntilLog } from '../server/servers'
-import { getVideoWithToken } from './videos'
-
-function getLive (url: string, token: string, videoId: number | string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/videos/live'
-
-  return makeGetRequest({
-    url,
-    token,
-    path: path + '/' + videoId,
-    statusCodeExpected
-  })
-}
-
-function updateLive (
-  url: string,
-  token: string,
-  videoId: number | string,
-  fields: LiveVideoUpdate,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/videos/live'
-
-  return makePutBodyRequest({
-    url,
-    token,
-    path: path + '/' + videoId,
-    fields,
-    statusCodeExpected
-  })
-}
-
-function createLive (url: string, token: string, fields: LiveVideoCreate, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/videos/live'
-
-  const attaches: any = {}
-  if (fields.thumbnailfile) attaches.thumbnailfile = fields.thumbnailfile
-  if (fields.previewfile) attaches.previewfile = fields.previewfile
-
-  const updatedFields = omit(fields, 'thumbnailfile', 'previewfile')
-
-  return makeUploadRequest({
-    url,
-    path,
-    token,
-    attaches,
-    fields: updatedFields,
-    statusCodeExpected
-  })
-}
-
-async function sendRTMPStreamInVideo (url: string, token: string, videoId: number | string, fixtureName?: string) {
-  const res = await getLive(url, token, videoId)
-  const videoLive = res.body as LiveVideo
-
-  return sendRTMPStream(videoLive.rtmpUrl, videoLive.streamKey, fixtureName)
-}
+import { buildAbsoluteFixturePath, wait } from '../miscs'
+import { PeerTubeServer } from '../server/server'
 
 function sendRTMPStream (rtmpBaseUrl: string, streamKey: string, fixtureName = 'video_short.mp4') {
   const fixture = buildAbsoluteFixturePath(fixtureName)
@@ -109,12 +49,6 @@ function waitFfmpegUntilError (command: ffmpeg.FfmpegCommand, successAfterMS = 1
   })
 }
 
-async function runAndTestFfmpegStreamError (url: string, token: string, videoId: number | string, shouldHaveError: boolean) {
-  const command = await sendRTMPStreamInVideo(url, token, videoId)
-
-  return testFfmpegStreamError(command, shouldHaveError)
-}
-
 async function testFfmpegStreamError (command: ffmpeg.FfmpegCommand, shouldHaveError: boolean) {
   let error: Error
 
@@ -136,53 +70,14 @@ async function stopFfmpeg (command: ffmpeg.FfmpegCommand) {
   await wait(500)
 }
 
-function waitUntilLivePublished (url: string, token: string, videoId: number | string) {
-  return waitUntilLiveState(url, token, videoId, VideoState.PUBLISHED)
-}
-
-function waitUntilLiveWaiting (url: string, token: string, videoId: number | string) {
-  return waitUntilLiveState(url, token, videoId, VideoState.WAITING_FOR_LIVE)
-}
-
-function waitUntilLiveEnded (url: string, token: string, videoId: number | string) {
-  return waitUntilLiveState(url, token, videoId, VideoState.LIVE_ENDED)
-}
-
-function waitUntilLiveSegmentGeneration (server: ServerInfo, videoUUID: string, resolutionNum: number, segmentNum: number) {
-  const segmentName = `${resolutionNum}-00000${segmentNum}.ts`
-  return waitUntilLog(server, `${videoUUID}/${segmentName}`, 2, false)
-}
-
-async function waitUntilLiveState (url: string, token: string, videoId: number | string, state: VideoState) {
-  let video: VideoDetails
-
-  do {
-    const res = await getVideoWithToken(url, token, videoId)
-    video = res.body
-
-    await wait(500)
-  } while (video.state.id !== state)
-}
-
-async function waitUntilLiveSaved (url: string, token: string, videoId: number | string) {
-  let video: VideoDetails
-
-  do {
-    const res = await getVideoWithToken(url, token, videoId)
-    video = res.body
-
-    await wait(500)
-  } while (video.isLive === true && video.state.id !== VideoState.PUBLISHED)
-}
-
-async function waitUntilLivePublishedOnAllServers (servers: ServerInfo[], videoId: string) {
+async function waitUntilLivePublishedOnAllServers (servers: PeerTubeServer[], videoId: string) {
   for (const server of servers) {
-    await waitUntilLivePublished(server.url, server.accessToken, videoId)
+    await server.live.waitUntilPublished({ videoId })
   }
 }
 
-async function checkLiveCleanup (server: ServerInfo, videoUUID: string, resolutions: number[] = []) {
-  const basePath = buildServerDirectory(server, 'streaming-playlists')
+async function checkLiveCleanup (server: PeerTubeServer, videoUUID: string, resolutions: number[] = []) {
+  const basePath = server.servers.buildDirectory('streaming-playlists')
   const hlsPath = join(basePath, 'hls', videoUUID)
 
   if (resolutions.length === 0) {
@@ -206,33 +101,11 @@ async function checkLiveCleanup (server: ServerInfo, videoUUID: string, resoluti
   expect(files).to.contain('segments-sha256.json')
 }
 
-async function getPlaylistsCount (server: ServerInfo, videoUUID: string) {
-  const basePath = buildServerDirectory(server, 'streaming-playlists')
-  const hlsPath = join(basePath, 'hls', videoUUID)
-
-  const files = await readdir(hlsPath)
-
-  return files.filter(f => f.endsWith('.m3u8')).length
-}
-
-// ---------------------------------------------------------------------------
-
 export {
-  getLive,
-  getPlaylistsCount,
-  waitUntilLiveSaved,
-  waitUntilLivePublished,
-  updateLive,
-  createLive,
-  runAndTestFfmpegStreamError,
-  checkLiveCleanup,
-  waitUntilLiveSegmentGeneration,
-  stopFfmpeg,
-  waitUntilLiveWaiting,
-  sendRTMPStreamInVideo,
-  waitUntilLiveEnded,
+  sendRTMPStream,
   waitFfmpegUntilError,
+  testFfmpegStreamError,
+  stopFfmpeg,
   waitUntilLivePublishedOnAllServers,
-  sendRTMPStream,
-  testFfmpegStreamError
+  checkLiveCleanup
 }
diff --git a/shared/extra-utils/videos/playlists-command.ts b/shared/extra-utils/videos/playlists-command.ts
new file mode 100644
index 000000000..6f329800e
--- /dev/null
+++ b/shared/extra-utils/videos/playlists-command.ts
@@ -0,0 +1,279 @@
+import { omit, pick } from 'lodash'
+import {
+  BooleanBothQuery,
+  HttpStatusCode,
+  ResultList,
+  VideoExistInPlaylist,
+  VideoPlaylist,
+  VideoPlaylistCreate,
+  VideoPlaylistCreateResult,
+  VideoPlaylistElement,
+  VideoPlaylistElementCreate,
+  VideoPlaylistElementCreateResult,
+  VideoPlaylistElementUpdate,
+  VideoPlaylistReorder,
+  VideoPlaylistType,
+  VideoPlaylistUpdate
+} from '@shared/models'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class PlaylistsCommand extends AbstractCommand {
+
+  list (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+  }) {
+    const path = '/api/v1/video-playlists'
+    const query = pick(options, [ 'start', 'count', 'sort' ])
+
+    return this.getRequestBody<ResultList<VideoPlaylist>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listByChannel (options: OverrideCommandOptions & {
+    handle: string
+    start?: number
+    count?: number
+    sort?: string
+  }) {
+    const path = '/api/v1/video-channels/' + options.handle + '/video-playlists'
+    const query = pick(options, [ 'start', 'count', 'sort' ])
+
+    return this.getRequestBody<ResultList<VideoPlaylist>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listByAccount (options: OverrideCommandOptions & {
+    handle: string
+    start?: number
+    count?: number
+    sort?: string
+    search?: string
+    playlistType?: VideoPlaylistType
+  }) {
+    const path = '/api/v1/accounts/' + options.handle + '/video-playlists'
+    const query = pick(options, [ 'start', 'count', 'sort', 'search', 'playlistType' ])
+
+    return this.getRequestBody<ResultList<VideoPlaylist>>({
+      ...options,
+
+      path,
+      query,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  get (options: OverrideCommandOptions & {
+    playlistId: number | string
+  }) {
+    const { playlistId } = options
+    const path = '/api/v1/video-playlists/' + playlistId
+
+    return this.getRequestBody<VideoPlaylist>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listVideos (options: OverrideCommandOptions & {
+    playlistId: number | string
+    start?: number
+    count?: number
+    query?: { nsfw?: BooleanBothQuery }
+  }) {
+    const path = '/api/v1/video-playlists/' + options.playlistId + '/videos'
+    const query = options.query ?? {}
+
+    return this.getRequestBody<ResultList<VideoPlaylistElement>>({
+      ...options,
+
+      path,
+      query: {
+        ...query,
+        start: options.start,
+        count: options.count
+      },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  delete (options: OverrideCommandOptions & {
+    playlistId: number | string
+  }) {
+    const path = '/api/v1/video-playlists/' + options.playlistId
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  async create (options: OverrideCommandOptions & {
+    attributes: VideoPlaylistCreate
+  }) {
+    const path = '/api/v1/video-playlists'
+
+    const fields = omit(options.attributes, 'thumbnailfile')
+
+    const attaches = options.attributes.thumbnailfile
+      ? { thumbnailfile: options.attributes.thumbnailfile }
+      : {}
+
+    const body = await unwrapBody<{ videoPlaylist: VideoPlaylistCreateResult }>(this.postUploadRequest({
+      ...options,
+
+      path,
+      fields,
+      attaches,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+
+    return body.videoPlaylist
+  }
+
+  update (options: OverrideCommandOptions & {
+    attributes: VideoPlaylistUpdate
+    playlistId: number | string
+  }) {
+    const path = '/api/v1/video-playlists/' + options.playlistId
+
+    const fields = omit(options.attributes, 'thumbnailfile')
+
+    const attaches = options.attributes.thumbnailfile
+      ? { thumbnailfile: options.attributes.thumbnailfile }
+      : {}
+
+    return this.putUploadRequest({
+      ...options,
+
+      path,
+      fields,
+      attaches,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  async addElement (options: OverrideCommandOptions & {
+    playlistId: number | string
+    attributes: VideoPlaylistElementCreate | { videoId: string }
+  }) {
+    const attributes = {
+      ...options.attributes,
+
+      videoId: await this.server.videos.getId({ ...options, uuid: options.attributes.videoId })
+    }
+
+    const path = '/api/v1/video-playlists/' + options.playlistId + '/videos'
+
+    const body = await unwrapBody<{ videoPlaylistElement: VideoPlaylistElementCreateResult }>(this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: attributes,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+
+    return body.videoPlaylistElement
+  }
+
+  updateElement (options: OverrideCommandOptions & {
+    playlistId: number | string
+    elementId: number | string
+    attributes: VideoPlaylistElementUpdate
+  }) {
+    const path = '/api/v1/video-playlists/' + options.playlistId + '/videos/' + options.elementId
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: options.attributes,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  removeElement (options: OverrideCommandOptions & {
+    playlistId: number | string
+    elementId: number
+  }) {
+    const path = '/api/v1/video-playlists/' + options.playlistId + '/videos/' + options.elementId
+
+    return this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  reorderElements (options: OverrideCommandOptions & {
+    playlistId: number | string
+    attributes: VideoPlaylistReorder
+  }) {
+    const path = '/api/v1/video-playlists/' + options.playlistId + '/videos/reorder'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      fields: options.attributes,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  getPrivacies (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/video-playlists/privacies'
+
+    return this.getRequestBody<{ [ id: number ]: string }>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  videosExist (options: OverrideCommandOptions & {
+    videoIds: number[]
+  }) {
+    const { videoIds } = options
+    const path = '/api/v1/users/me/video-playlists/videos-exist'
+
+    return this.getRequestBody<VideoExistInPlaylist>({
+      ...options,
+
+      path,
+      query: { videoIds },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/videos/playlists.ts b/shared/extra-utils/videos/playlists.ts
new file mode 100644
index 000000000..3dde52bb9
--- /dev/null
+++ b/shared/extra-utils/videos/playlists.ts
@@ -0,0 +1,25 @@
+import { expect } from 'chai'
+import { readdir } from 'fs-extra'
+import { join } from 'path'
+import { root } from '../miscs'
+
+async function checkPlaylistFilesWereRemoved (
+  playlistUUID: string,
+  internalServerNumber: number,
+  directories = [ 'thumbnails' ]
+) {
+  const testDirectory = 'test' + internalServerNumber
+
+  for (const directory of directories) {
+    const directoryPath = join(root(), testDirectory, directory)
+
+    const files = await readdir(directoryPath)
+    for (const file of files) {
+      expect(file).to.not.contain(playlistUUID)
+    }
+  }
+}
+
+export {
+  checkPlaylistFilesWereRemoved
+}
diff --git a/shared/extra-utils/videos/services-command.ts b/shared/extra-utils/videos/services-command.ts
new file mode 100644
index 000000000..06760df42
--- /dev/null
+++ b/shared/extra-utils/videos/services-command.ts
@@ -0,0 +1,29 @@
+import { HttpStatusCode } from '@shared/models'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class ServicesCommand extends AbstractCommand {
+
+  getOEmbed (options: OverrideCommandOptions & {
+    oembedUrl: string
+    format?: string
+    maxHeight?: number
+    maxWidth?: number
+  }) {
+    const path = '/services/oembed'
+    const query = {
+      url: options.oembedUrl,
+      format: options.format,
+      maxheight: options.maxHeight,
+      maxwidth: options.maxWidth
+    }
+
+    return this.getRequest({
+      ...options,
+
+      path,
+      query,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+}
diff --git a/shared/extra-utils/videos/services.ts b/shared/extra-utils/videos/services.ts
deleted file mode 100644
index e13a788bd..000000000
--- a/shared/extra-utils/videos/services.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import * as request from 'supertest'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getOEmbed (url: string, oembedUrl: string, format?: string, maxHeight?: number, maxWidth?: number) {
-  const path = '/services/oembed'
-  const query = {
-    url: oembedUrl,
-    format,
-    maxheight: maxHeight,
-    maxwidth: maxWidth
-  }
-
-  return request(url)
-          .get(path)
-          .query(query)
-          .set('Accept', 'application/json')
-          .expect(HttpStatusCode.OK_200)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getOEmbed
-}
diff --git a/shared/extra-utils/videos/streaming-playlists-command.ts b/shared/extra-utils/videos/streaming-playlists-command.ts
new file mode 100644
index 000000000..9662685da
--- /dev/null
+++ b/shared/extra-utils/videos/streaming-playlists-command.ts
@@ -0,0 +1,44 @@
+import { HttpStatusCode } from '@shared/models'
+import { unwrapBody, unwrapText } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class StreamingPlaylistsCommand extends AbstractCommand {
+
+  get (options: OverrideCommandOptions & {
+    url: string
+  }) {
+    return unwrapText(this.getRawRequest({
+      ...options,
+
+      url: options.url,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+  }
+
+  getSegment (options: OverrideCommandOptions & {
+    url: string
+    range?: string
+  }) {
+    return unwrapBody<Buffer>(this.getRawRequest({
+      ...options,
+
+      url: options.url,
+      range: options.range,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+  }
+
+  getSegmentSha256 (options: OverrideCommandOptions & {
+    url: string
+  }) {
+    return unwrapBody<{ [ id: string ]: string }>(this.getRawRequest({
+      ...options,
+
+      url: options.url,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+  }
+}
diff --git a/shared/extra-utils/videos/streaming-playlists.ts b/shared/extra-utils/videos/streaming-playlists.ts
new file mode 100644
index 000000000..1ae3fefc1
--- /dev/null
+++ b/shared/extra-utils/videos/streaming-playlists.ts
@@ -0,0 +1,75 @@
+import { expect } from 'chai'
+import { sha256 } from '@server/helpers/core-utils'
+import { HttpStatusCode, VideoStreamingPlaylist } from '@shared/models'
+import { PeerTubeServer } from '../server'
+
+async function checkSegmentHash (options: {
+  server: PeerTubeServer
+  baseUrlPlaylist: string
+  baseUrlSegment: string
+  videoUUID: string
+  resolution: number
+  hlsPlaylist: VideoStreamingPlaylist
+}) {
+  const { server, baseUrlPlaylist, baseUrlSegment, videoUUID, resolution, hlsPlaylist } = options
+  const command = server.streamingPlaylists
+
+  const playlist = await command.get({ url: `${baseUrlPlaylist}/${videoUUID}/${resolution}.m3u8` })
+
+  const videoName = `${videoUUID}-${resolution}-fragmented.mp4`
+
+  const matches = /#EXT-X-BYTERANGE:(\d+)@(\d+)/.exec(playlist)
+
+  const length = parseInt(matches[1], 10)
+  const offset = parseInt(matches[2], 10)
+  const range = `${offset}-${offset + length - 1}`
+
+  const segmentBody = await command.getSegment({
+    url: `${baseUrlSegment}/${videoUUID}/${videoName}`,
+    expectedStatus: HttpStatusCode.PARTIAL_CONTENT_206,
+    range: `bytes=${range}`
+  })
+
+  const shaBody = await command.getSegmentSha256({ url: hlsPlaylist.segmentsSha256Url })
+  expect(sha256(segmentBody)).to.equal(shaBody[videoName][range])
+}
+
+async function checkLiveSegmentHash (options: {
+  server: PeerTubeServer
+  baseUrlSegment: string
+  videoUUID: string
+  segmentName: string
+  hlsPlaylist: VideoStreamingPlaylist
+}) {
+  const { server, baseUrlSegment, videoUUID, segmentName, hlsPlaylist } = options
+  const command = server.streamingPlaylists
+
+  const segmentBody = await command.getSegment({ url: `${baseUrlSegment}/${videoUUID}/${segmentName}` })
+  const shaBody = await command.getSegmentSha256({ url: hlsPlaylist.segmentsSha256Url })
+
+  expect(sha256(segmentBody)).to.equal(shaBody[segmentName])
+}
+
+async function checkResolutionsInMasterPlaylist (options: {
+  server: PeerTubeServer
+  playlistUrl: string
+  resolutions: number[]
+}) {
+  const { server, playlistUrl, resolutions } = options
+
+  const masterPlaylist = await server.streamingPlaylists.get({ url: playlistUrl })
+
+  for (const resolution of resolutions) {
+    const reg = new RegExp(
+      '#EXT-X-STREAM-INF:BANDWIDTH=\\d+,RESOLUTION=\\d+x' + resolution + ',(FRAME-RATE=\\d+,)?CODECS="avc1.64001f,mp4a.40.2"'
+    )
+
+    expect(masterPlaylist).to.match(reg)
+  }
+}
+
+export {
+  checkSegmentHash,
+  checkLiveSegmentHash,
+  checkResolutionsInMasterPlaylist
+}
diff --git a/shared/extra-utils/videos/video-blacklist.ts b/shared/extra-utils/videos/video-blacklist.ts
deleted file mode 100644
index aa1548537..000000000
--- a/shared/extra-utils/videos/video-blacklist.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import * as request from 'supertest'
-import { VideoBlacklistType } from '../../models/videos'
-import { makeGetRequest } from '..'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function addVideoToBlacklist (
-  url: string,
-  token: string,
-  videoId: number | string,
-  reason?: string,
-  unfederate?: boolean,
-  specialStatus = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/videos/' + videoId + '/blacklist'
-
-  return request(url)
-    .post(path)
-    .send({ reason, unfederate })
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(specialStatus)
-}
-
-function updateVideoBlacklist (
-  url: string,
-  token: string,
-  videoId: number,
-  reason?: string,
-  specialStatus = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/videos/' + videoId + '/blacklist'
-
-  return request(url)
-    .put(path)
-    .send({ reason })
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(specialStatus)
-}
-
-function removeVideoFromBlacklist (url: string, token: string, videoId: number | string, specialStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/videos/' + videoId + '/blacklist'
-
-  return request(url)
-    .delete(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(specialStatus)
-}
-
-function getBlacklistedVideosList (parameters: {
-  url: string
-  token: string
-  sort?: string
-  type?: VideoBlacklistType
-  specialStatus?: HttpStatusCode
-}) {
-  const { url, token, sort, type, specialStatus = HttpStatusCode.OK_200 } = parameters
-  const path = '/api/v1/videos/blacklist/'
-
-  const query = { sort, type }
-
-  return makeGetRequest({
-    url,
-    path,
-    query,
-    token,
-    statusCodeExpected: specialStatus
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  addVideoToBlacklist,
-  removeVideoFromBlacklist,
-  getBlacklistedVideosList,
-  updateVideoBlacklist
-}
diff --git a/shared/extra-utils/videos/video-captions.ts b/shared/extra-utils/videos/video-captions.ts
deleted file mode 100644
index 62eec7b90..000000000
--- a/shared/extra-utils/videos/video-captions.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { makeDeleteRequest, makeGetRequest, makeUploadRequest } from '../requests/requests'
-import * as request from 'supertest'
-import * as chai from 'chai'
-import { buildAbsoluteFixturePath } from '../miscs/miscs'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-const expect = chai.expect
-
-function createVideoCaption (args: {
-  url: string
-  accessToken: string
-  videoId: string | number
-  language: string
-  fixture: string
-  mimeType?: string
-  statusCodeExpected?: number
-}) {
-  const path = '/api/v1/videos/' + args.videoId + '/captions/' + args.language
-
-  const captionfile = buildAbsoluteFixturePath(args.fixture)
-  const captionfileAttach = args.mimeType ? [ captionfile, { contentType: args.mimeType } ] : captionfile
-
-  return makeUploadRequest({
-    method: 'PUT',
-    url: args.url,
-    path,
-    token: args.accessToken,
-    fields: {},
-    attaches: {
-      captionfile: captionfileAttach
-    },
-    statusCodeExpected: args.statusCodeExpected || HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-function listVideoCaptions (url: string, videoId: string | number) {
-  const path = '/api/v1/videos/' + videoId + '/captions'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function deleteVideoCaption (url: string, token: string, videoId: string | number, language: string) {
-  const path = '/api/v1/videos/' + videoId + '/captions/' + language
-
-  return makeDeleteRequest({
-    url,
-    token,
-    path,
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-async function testCaptionFile (url: string, captionPath: string, containsString: string) {
-  const res = await request(url)
-    .get(captionPath)
-    .expect(HttpStatusCode.OK_200)
-
-  expect(res.text).to.contain(containsString)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  createVideoCaption,
-  listVideoCaptions,
-  testCaptionFile,
-  deleteVideoCaption
-}
diff --git a/shared/extra-utils/videos/video-change-ownership.ts b/shared/extra-utils/videos/video-change-ownership.ts
deleted file mode 100644
index ef82a7636..000000000
--- a/shared/extra-utils/videos/video-change-ownership.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import * as request from 'supertest'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function changeVideoOwnership (
-  url: string,
-  token: string,
-  videoId: number | string,
-  username,
-  expectedStatus = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/videos/' + videoId + '/give-ownership'
-
-  return request(url)
-    .post(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .send({ username })
-    .expect(expectedStatus)
-}
-
-function getVideoChangeOwnershipList (url: string, token: string) {
-  const path = '/api/v1/videos/ownership'
-
-  return request(url)
-    .get(path)
-    .query({ sort: '-createdAt' })
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function acceptChangeOwnership (
-  url: string,
-  token: string,
-  ownershipId: string,
-  channelId: number,
-  expectedStatus = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/videos/ownership/' + ownershipId + '/accept'
-
-  return request(url)
-    .post(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .send({ channelId })
-    .expect(expectedStatus)
-}
-
-function refuseChangeOwnership (
-  url: string,
-  token: string,
-  ownershipId: string,
-  expectedStatus = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/videos/ownership/' + ownershipId + '/refuse'
-
-  return request(url)
-    .post(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(expectedStatus)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  changeVideoOwnership,
-  getVideoChangeOwnershipList,
-  acceptChangeOwnership,
-  refuseChangeOwnership
-}
diff --git a/shared/extra-utils/videos/video-channels.ts b/shared/extra-utils/videos/video-channels.ts
deleted file mode 100644
index 0aab93e52..000000000
--- a/shared/extra-utils/videos/video-channels.ts
+++ /dev/null
@@ -1,192 +0,0 @@
-/* eslint-disable @typescript-eslint/no-floating-promises */
-
-import * as request from 'supertest'
-import { VideoChannelUpdate } from '../../models/videos/channel/video-channel-update.model'
-import { VideoChannelCreate } from '../../models/videos/channel/video-channel-create.model'
-import { makeDeleteRequest, makeGetRequest, updateImageRequest } from '../requests/requests'
-import { ServerInfo } from '../server/servers'
-import { MyUser, User } from '../../models/users/user.model'
-import { getMyUserInformation } from '../users/users'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getVideoChannelsList (url: string, start: number, count: number, sort?: string, withStats?: boolean) {
-  const path = '/api/v1/video-channels'
-
-  const req = request(url)
-    .get(path)
-    .query({ start: start })
-    .query({ count: count })
-
-  if (sort) req.query({ sort })
-  if (withStats) req.query({ withStats })
-
-  return req.set('Accept', 'application/json')
-            .expect(HttpStatusCode.OK_200)
-            .expect('Content-Type', /json/)
-}
-
-function getAccountVideoChannelsList (parameters: {
-  url: string
-  accountName: string
-  start?: number
-  count?: number
-  sort?: string
-  specialStatus?: HttpStatusCode
-  withStats?: boolean
-  search?: string
-}) {
-  const {
-    url,
-    accountName,
-    start,
-    count,
-    sort = 'createdAt',
-    specialStatus = HttpStatusCode.OK_200,
-    withStats = false,
-    search
-  } = parameters
-
-  const path = '/api/v1/accounts/' + accountName + '/video-channels'
-
-  return makeGetRequest({
-    url,
-    path,
-    query: {
-      start,
-      count,
-      sort,
-      withStats,
-      search
-    },
-    statusCodeExpected: specialStatus
-  })
-}
-
-function addVideoChannel (
-  url: string,
-  token: string,
-  videoChannelAttributesArg: VideoChannelCreate,
-  expectedStatus = HttpStatusCode.OK_200
-) {
-  const path = '/api/v1/video-channels/'
-
-  // Default attributes
-  let attributes = {
-    displayName: 'my super video channel',
-    description: 'my super channel description',
-    support: 'my super channel support'
-  }
-  attributes = Object.assign(attributes, videoChannelAttributesArg)
-
-  return request(url)
-    .post(path)
-    .send(attributes)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(expectedStatus)
-}
-
-function updateVideoChannel (
-  url: string,
-  token: string,
-  channelName: string,
-  attributes: VideoChannelUpdate,
-  expectedStatus = HttpStatusCode.NO_CONTENT_204
-) {
-  const body: any = {}
-  const path = '/api/v1/video-channels/' + channelName
-
-  if (attributes.displayName) body.displayName = attributes.displayName
-  if (attributes.description) body.description = attributes.description
-  if (attributes.support) body.support = attributes.support
-  if (attributes.bulkVideosSupportUpdate) body.bulkVideosSupportUpdate = attributes.bulkVideosSupportUpdate
-
-  return request(url)
-    .put(path)
-    .send(body)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(expectedStatus)
-}
-
-function deleteVideoChannel (url: string, token: string, channelName: string, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/video-channels/' + channelName
-
-  return request(url)
-    .delete(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(expectedStatus)
-}
-
-function getVideoChannel (url: string, channelName: string) {
-  const path = '/api/v1/video-channels/' + channelName
-
-  return request(url)
-    .get(path)
-    .set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function updateVideoChannelImage (options: {
-  url: string
-  accessToken: string
-  fixture: string
-  videoChannelName: string | number
-  type: 'avatar' | 'banner'
-}) {
-  const path = `/api/v1/video-channels/${options.videoChannelName}/${options.type}/pick`
-
-  return updateImageRequest({ ...options, path, fieldname: options.type + 'file' })
-}
-
-function deleteVideoChannelImage (options: {
-  url: string
-  accessToken: string
-  videoChannelName: string | number
-  type: 'avatar' | 'banner'
-}) {
-  const path = `/api/v1/video-channels/${options.videoChannelName}/${options.type}`
-
-  return makeDeleteRequest({
-    url: options.url,
-    token: options.accessToken,
-    path,
-    statusCodeExpected: 204
-  })
-}
-
-function setDefaultVideoChannel (servers: ServerInfo[]) {
-  const tasks: Promise<any>[] = []
-
-  for (const server of servers) {
-    const p = getMyUserInformation(server.url, server.accessToken)
-      .then(res => { server.videoChannel = (res.body as User).videoChannels[0] })
-
-    tasks.push(p)
-  }
-
-  return Promise.all(tasks)
-}
-
-async function getDefaultVideoChannel (url: string, token: string) {
-  const res = await getMyUserInformation(url, token)
-
-  return (res.body as MyUser).videoChannels[0].id
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  updateVideoChannelImage,
-  getVideoChannelsList,
-  getAccountVideoChannelsList,
-  addVideoChannel,
-  updateVideoChannel,
-  deleteVideoChannel,
-  getVideoChannel,
-  setDefaultVideoChannel,
-  deleteVideoChannelImage,
-  getDefaultVideoChannel
-}
diff --git a/shared/extra-utils/videos/video-comments.ts b/shared/extra-utils/videos/video-comments.ts
deleted file mode 100644
index 71b9f875a..000000000
--- a/shared/extra-utils/videos/video-comments.ts
+++ /dev/null
@@ -1,138 +0,0 @@
-/* eslint-disable @typescript-eslint/no-floating-promises */
-
-import * as request from 'supertest'
-import { makeDeleteRequest, makeGetRequest } from '../requests/requests'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getAdminVideoComments (options: {
-  url: string
-  token: string
-  start: number
-  count: number
-  sort?: string
-  isLocal?: boolean
-  search?: string
-  searchAccount?: string
-  searchVideo?: string
-}) {
-  const { url, token, start, count, sort, isLocal, search, searchAccount, searchVideo } = options
-  const path = '/api/v1/videos/comments'
-
-  const query = {
-    start,
-    count,
-    sort: sort || '-createdAt'
-  }
-
-  if (isLocal !== undefined) Object.assign(query, { isLocal })
-  if (search !== undefined) Object.assign(query, { search })
-  if (searchAccount !== undefined) Object.assign(query, { searchAccount })
-  if (searchVideo !== undefined) Object.assign(query, { searchVideo })
-
-  return makeGetRequest({
-    url,
-    path,
-    token,
-    query,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getVideoCommentThreads (url: string, videoId: number | string, start: number, count: number, sort?: string, token?: string) {
-  const path = '/api/v1/videos/' + videoId + '/comment-threads'
-
-  const req = request(url)
-    .get(path)
-    .query({ start: start })
-    .query({ count: count })
-
-  if (sort) req.query({ sort })
-  if (token) req.set('Authorization', 'Bearer ' + token)
-
-  return req.set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function getVideoThreadComments (url: string, videoId: number | string, threadId: number, token?: string) {
-  const path = '/api/v1/videos/' + videoId + '/comment-threads/' + threadId
-
-  const req = request(url)
-    .get(path)
-    .set('Accept', 'application/json')
-
-  if (token) req.set('Authorization', 'Bearer ' + token)
-
-  return req.expect(HttpStatusCode.OK_200)
-            .expect('Content-Type', /json/)
-}
-
-function addVideoCommentThread (
-  url: string,
-  token: string,
-  videoId: number | string,
-  text: string,
-  expectedStatus = HttpStatusCode.OK_200
-) {
-  const path = '/api/v1/videos/' + videoId + '/comment-threads'
-
-  return request(url)
-    .post(path)
-    .send({ text })
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(expectedStatus)
-}
-
-function addVideoCommentReply (
-  url: string,
-  token: string,
-  videoId: number | string,
-  inReplyToCommentId: number,
-  text: string,
-  expectedStatus = HttpStatusCode.OK_200
-) {
-  const path = '/api/v1/videos/' + videoId + '/comments/' + inReplyToCommentId
-
-  return request(url)
-    .post(path)
-    .send({ text })
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(expectedStatus)
-}
-
-async function findCommentId (url: string, videoId: number | string, text: string) {
-  const res = await getVideoCommentThreads(url, videoId, 0, 25, '-createdAt')
-
-  return res.body.data.find(c => c.text === text).id as number
-}
-
-function deleteVideoComment (
-  url: string,
-  token: string,
-  videoId: number | string,
-  commentId: number,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/videos/' + videoId + '/comments/' + commentId
-
-  return makeDeleteRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getVideoCommentThreads,
-  getAdminVideoComments,
-  getVideoThreadComments,
-  addVideoCommentThread,
-  addVideoCommentReply,
-  findCommentId,
-  deleteVideoComment
-}
diff --git a/shared/extra-utils/videos/video-history.ts b/shared/extra-utils/videos/video-history.ts
deleted file mode 100644
index b989e14dc..000000000
--- a/shared/extra-utils/videos/video-history.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { makeGetRequest, makePostBodyRequest, makePutBodyRequest } from '../requests/requests'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function userWatchVideo (
-  url: string,
-  token: string,
-  videoId: number | string,
-  currentTime: number,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/videos/' + videoId + '/watching'
-  const fields = { currentTime }
-
-  return makePutBodyRequest({ url, path, token, fields, statusCodeExpected })
-}
-
-function listMyVideosHistory (url: string, token: string, search?: string) {
-  const path = '/api/v1/users/me/history/videos'
-
-  return makeGetRequest({
-    url,
-    path,
-    token,
-    query: {
-      search
-    },
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function removeMyVideosHistory (url: string, token: string, beforeDate?: string) {
-  const path = '/api/v1/users/me/history/videos/remove'
-
-  return makePostBodyRequest({
-    url,
-    path,
-    token,
-    fields: beforeDate ? { beforeDate } : {},
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  userWatchVideo,
-  listMyVideosHistory,
-  removeMyVideosHistory
-}
diff --git a/shared/extra-utils/videos/video-imports.ts b/shared/extra-utils/videos/video-imports.ts
deleted file mode 100644
index 81c0163cb..000000000
--- a/shared/extra-utils/videos/video-imports.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-
-import { VideoImportCreate } from '../../models/videos'
-import { makeGetRequest, makeUploadRequest } from '../requests/requests'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getYoutubeVideoUrl () {
-  return 'https://www.youtube.com/watch?v=msX3jv1XdvM'
-}
-
-function getYoutubeHDRVideoUrl () {
-  /**
-   * The video is used to check format-selection correctness wrt. HDR,
-   * which brings its own set of oddities outside of a MediaSource.
-   * FIXME: refactor once HDR is supported at playback
-   *
-   * The video needs to have the following format_ids:
-   * (which you can check by using `youtube-dl <url> -F`):
-   * - 303 (1080p webm vp9)
-   * - 299 (1080p mp4 avc1)
-   * - 335 (1080p webm vp9.2 HDR)
-   *
-   * 15 jan. 2021: TEST VIDEO NOT CURRENTLY PROVIDING
-   * - 400 (1080p mp4 av01)
-   * - 315 (2160p webm vp9 HDR)
-   * - 337 (2160p webm vp9.2 HDR)
-   * - 401 (2160p mp4 av01 HDR)
-   */
-  return 'https://www.youtube.com/watch?v=qR5vOXbZsI4'
-}
-
-function getMagnetURI () {
-  // eslint-disable-next-line max-len
-  return 'magnet:?xs=https%3A%2F%2Fpeertube2.cpy.re%2Fstatic%2Ftorrents%2Fb209ca00-c8bb-4b2b-b421-1ede169f3dbc-720.torrent&xt=urn:btih:0f498834733e8057ed5c6f2ee2b4efd8d84a76ee&dn=super+peertube2+video&tr=wss%3A%2F%2Fpeertube2.cpy.re%3A443%2Ftracker%2Fsocket&tr=https%3A%2F%2Fpeertube2.cpy.re%2Ftracker%2Fannounce&ws=https%3A%2F%2Fpeertube2.cpy.re%2Fstatic%2Fwebseed%2Fb209ca00-c8bb-4b2b-b421-1ede169f3dbc-720.mp4'
-}
-
-function getBadVideoUrl () {
-  return 'https://download.cpy.re/peertube/bad_video.mp4'
-}
-
-function getGoodVideoUrl () {
-  return 'https://download.cpy.re/peertube/good_video.mp4'
-}
-
-function importVideo (
-  url: string,
-  token: string,
-  attributes: VideoImportCreate & { torrentfile?: string },
-  statusCodeExpected = HttpStatusCode.OK_200
-) {
-  const path = '/api/v1/videos/imports'
-
-  let attaches: any = {}
-  if (attributes.torrentfile) attaches = { torrentfile: attributes.torrentfile }
-
-  return makeUploadRequest({
-    url,
-    path,
-    token,
-    attaches,
-    fields: attributes,
-    statusCodeExpected
-  })
-}
-
-function getMyVideoImports (url: string, token: string, sort?: string) {
-  const path = '/api/v1/users/me/videos/imports'
-
-  const query = {}
-  if (sort) query['sort'] = sort
-
-  return makeGetRequest({
-    url,
-    query,
-    path,
-    token,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getBadVideoUrl,
-  getYoutubeVideoUrl,
-  getYoutubeHDRVideoUrl,
-  importVideo,
-  getMagnetURI,
-  getMyVideoImports,
-  getGoodVideoUrl
-}
diff --git a/shared/extra-utils/videos/video-playlists.ts b/shared/extra-utils/videos/video-playlists.ts
deleted file mode 100644
index c6f799e5d..000000000
--- a/shared/extra-utils/videos/video-playlists.ts
+++ /dev/null
@@ -1,320 +0,0 @@
-import { makeDeleteRequest, makeGetRequest, makePostBodyRequest, makePutBodyRequest, makeUploadRequest } from '../requests/requests'
-import { VideoPlaylistCreate } from '../../models/videos/playlist/video-playlist-create.model'
-import { omit } from 'lodash'
-import { VideoPlaylistUpdate } from '../../models/videos/playlist/video-playlist-update.model'
-import { VideoPlaylistElementCreate } from '../../models/videos/playlist/video-playlist-element-create.model'
-import { VideoPlaylistElementUpdate } from '../../models/videos/playlist/video-playlist-element-update.model'
-import { videoUUIDToId } from './videos'
-import { join } from 'path'
-import { root } from '..'
-import { readdir } from 'fs-extra'
-import { expect } from 'chai'
-import { VideoPlaylistType } from '../../models/videos/playlist/video-playlist-type.model'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getVideoPlaylistsList (url: string, start: number, count: number, sort?: string) {
-  const path = '/api/v1/video-playlists'
-
-  const query = {
-    start,
-    count,
-    sort
-  }
-
-  return makeGetRequest({
-    url,
-    path,
-    query,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getVideoChannelPlaylistsList (url: string, videoChannelName: string, start: number, count: number, sort?: string) {
-  const path = '/api/v1/video-channels/' + videoChannelName + '/video-playlists'
-
-  const query = {
-    start,
-    count,
-    sort
-  }
-
-  return makeGetRequest({
-    url,
-    path,
-    query,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getAccountPlaylistsList (url: string, accountName: string, start: number, count: number, sort?: string, search?: string) {
-  const path = '/api/v1/accounts/' + accountName + '/video-playlists'
-
-  const query = {
-    start,
-    count,
-    sort,
-    search
-  }
-
-  return makeGetRequest({
-    url,
-    path,
-    query,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getAccountPlaylistsListWithToken (
-  url: string,
-  token: string,
-  accountName: string,
-  start: number,
-  count: number,
-  playlistType?: VideoPlaylistType,
-  sort?: string
-) {
-  const path = '/api/v1/accounts/' + accountName + '/video-playlists'
-
-  const query = {
-    start,
-    count,
-    playlistType,
-    sort
-  }
-
-  return makeGetRequest({
-    url,
-    token,
-    path,
-    query,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getVideoPlaylist (url: string, playlistId: number | string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/video-playlists/' + playlistId
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected
-  })
-}
-
-function getVideoPlaylistWithToken (url: string, token: string, playlistId: number | string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/video-playlists/' + playlistId
-
-  return makeGetRequest({
-    url,
-    token,
-    path,
-    statusCodeExpected
-  })
-}
-
-function deleteVideoPlaylist (url: string, token: string, playlistId: number | string, statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/video-playlists/' + playlistId
-
-  return makeDeleteRequest({
-    url,
-    path,
-    token,
-    statusCodeExpected
-  })
-}
-
-function createVideoPlaylist (options: {
-  url: string
-  token: string
-  playlistAttrs: VideoPlaylistCreate
-  expectedStatus?: number
-}) {
-  const path = '/api/v1/video-playlists'
-
-  const fields = omit(options.playlistAttrs, 'thumbnailfile')
-
-  const attaches = options.playlistAttrs.thumbnailfile
-    ? { thumbnailfile: options.playlistAttrs.thumbnailfile }
-    : {}
-
-  return makeUploadRequest({
-    method: 'POST',
-    url: options.url,
-    path,
-    token: options.token,
-    fields,
-    attaches,
-    statusCodeExpected: options.expectedStatus || HttpStatusCode.OK_200
-  })
-}
-
-function updateVideoPlaylist (options: {
-  url: string
-  token: string
-  playlistAttrs: VideoPlaylistUpdate
-  playlistId: number | string
-  expectedStatus?: number
-}) {
-  const path = '/api/v1/video-playlists/' + options.playlistId
-
-  const fields = omit(options.playlistAttrs, 'thumbnailfile')
-
-  const attaches = options.playlistAttrs.thumbnailfile
-    ? { thumbnailfile: options.playlistAttrs.thumbnailfile }
-    : {}
-
-  return makeUploadRequest({
-    method: 'PUT',
-    url: options.url,
-    path,
-    token: options.token,
-    fields,
-    attaches,
-    statusCodeExpected: options.expectedStatus || HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-async function addVideoInPlaylist (options: {
-  url: string
-  token: string
-  playlistId: number | string
-  elementAttrs: VideoPlaylistElementCreate | { videoId: string }
-  expectedStatus?: number
-}) {
-  options.elementAttrs.videoId = await videoUUIDToId(options.url, options.elementAttrs.videoId)
-
-  const path = '/api/v1/video-playlists/' + options.playlistId + '/videos'
-
-  return makePostBodyRequest({
-    url: options.url,
-    path,
-    token: options.token,
-    fields: options.elementAttrs,
-    statusCodeExpected: options.expectedStatus || HttpStatusCode.OK_200
-  })
-}
-
-function updateVideoPlaylistElement (options: {
-  url: string
-  token: string
-  playlistId: number | string
-  playlistElementId: number | string
-  elementAttrs: VideoPlaylistElementUpdate
-  expectedStatus?: number
-}) {
-  const path = '/api/v1/video-playlists/' + options.playlistId + '/videos/' + options.playlistElementId
-
-  return makePutBodyRequest({
-    url: options.url,
-    path,
-    token: options.token,
-    fields: options.elementAttrs,
-    statusCodeExpected: options.expectedStatus || HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-function removeVideoFromPlaylist (options: {
-  url: string
-  token: string
-  playlistId: number | string
-  playlistElementId: number
-  expectedStatus?: number
-}) {
-  const path = '/api/v1/video-playlists/' + options.playlistId + '/videos/' + options.playlistElementId
-
-  return makeDeleteRequest({
-    url: options.url,
-    path,
-    token: options.token,
-    statusCodeExpected: options.expectedStatus || HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-function reorderVideosPlaylist (options: {
-  url: string
-  token: string
-  playlistId: number | string
-  elementAttrs: {
-    startPosition: number
-    insertAfterPosition: number
-    reorderLength?: number
-  }
-  expectedStatus?: number
-}) {
-  const path = '/api/v1/video-playlists/' + options.playlistId + '/videos/reorder'
-
-  return makePostBodyRequest({
-    url: options.url,
-    path,
-    token: options.token,
-    fields: options.elementAttrs,
-    statusCodeExpected: options.expectedStatus || HttpStatusCode.NO_CONTENT_204
-  })
-}
-
-async function checkPlaylistFilesWereRemoved (
-  playlistUUID: string,
-  internalServerNumber: number,
-  directories = [ 'thumbnails' ]
-) {
-  const testDirectory = 'test' + internalServerNumber
-
-  for (const directory of directories) {
-    const directoryPath = join(root(), testDirectory, directory)
-
-    const files = await readdir(directoryPath)
-    for (const file of files) {
-      expect(file).to.not.contain(playlistUUID)
-    }
-  }
-}
-
-function getVideoPlaylistPrivacies (url: string) {
-  const path = '/api/v1/video-playlists/privacies'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function doVideosExistInMyPlaylist (url: string, token: string, videoIds: number[]) {
-  const path = '/api/v1/users/me/video-playlists/videos-exist'
-
-  return makeGetRequest({
-    url,
-    token,
-    path,
-    query: { videoIds },
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getVideoPlaylistPrivacies,
-
-  getVideoPlaylistsList,
-  getVideoChannelPlaylistsList,
-  getAccountPlaylistsList,
-  getAccountPlaylistsListWithToken,
-
-  getVideoPlaylist,
-  getVideoPlaylistWithToken,
-
-  createVideoPlaylist,
-  updateVideoPlaylist,
-  deleteVideoPlaylist,
-
-  addVideoInPlaylist,
-  updateVideoPlaylistElement,
-  removeVideoFromPlaylist,
-
-  reorderVideosPlaylist,
-
-  checkPlaylistFilesWereRemoved,
-
-  doVideosExistInMyPlaylist
-}
diff --git a/shared/extra-utils/videos/video-streaming-playlists.ts b/shared/extra-utils/videos/video-streaming-playlists.ts
deleted file mode 100644
index 99c2e1880..000000000
--- a/shared/extra-utils/videos/video-streaming-playlists.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-import { makeRawRequest } from '../requests/requests'
-import { sha256 } from '../../../server/helpers/core-utils'
-import { VideoStreamingPlaylist } from '../../models/videos/video-streaming-playlist.model'
-import { expect } from 'chai'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getPlaylist (url: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  return makeRawRequest(url, statusCodeExpected)
-}
-
-function getSegment (url: string, statusCodeExpected = HttpStatusCode.OK_200, range?: string) {
-  return makeRawRequest(url, statusCodeExpected, range)
-}
-
-function getSegmentSha256 (url: string, statusCodeExpected = HttpStatusCode.OK_200) {
-  return makeRawRequest(url, statusCodeExpected)
-}
-
-async function checkSegmentHash (
-  baseUrlPlaylist: string,
-  baseUrlSegment: string,
-  videoUUID: string,
-  resolution: number,
-  hlsPlaylist: VideoStreamingPlaylist
-) {
-  const res = await getPlaylist(`${baseUrlPlaylist}/${videoUUID}/${resolution}.m3u8`)
-  const playlist = res.text
-
-  const videoName = `${videoUUID}-${resolution}-fragmented.mp4`
-
-  const matches = /#EXT-X-BYTERANGE:(\d+)@(\d+)/.exec(playlist)
-
-  const length = parseInt(matches[1], 10)
-  const offset = parseInt(matches[2], 10)
-  const range = `${offset}-${offset + length - 1}`
-
-  const res2 = await getSegment(`${baseUrlSegment}/${videoUUID}/${videoName}`, HttpStatusCode.PARTIAL_CONTENT_206, `bytes=${range}`)
-
-  const resSha = await getSegmentSha256(hlsPlaylist.segmentsSha256Url)
-
-  const sha256Server = resSha.body[videoName][range]
-  expect(sha256(res2.body)).to.equal(sha256Server)
-}
-
-async function checkLiveSegmentHash (
-  baseUrlSegment: string,
-  videoUUID: string,
-  segmentName: string,
-  hlsPlaylist: VideoStreamingPlaylist
-) {
-  const res2 = await getSegment(`${baseUrlSegment}/${videoUUID}/${segmentName}`)
-
-  const resSha = await getSegmentSha256(hlsPlaylist.segmentsSha256Url)
-
-  const sha256Server = resSha.body[segmentName]
-  expect(sha256(res2.body)).to.equal(sha256Server)
-}
-
-async function checkResolutionsInMasterPlaylist (playlistUrl: string, resolutions: number[]) {
-  const res = await getPlaylist(playlistUrl)
-
-  const masterPlaylist = res.text
-
-  for (const resolution of resolutions) {
-    const reg = new RegExp(
-      '#EXT-X-STREAM-INF:BANDWIDTH=\\d+,RESOLUTION=\\d+x' + resolution + ',(FRAME-RATE=\\d+,)?CODECS="avc1.64001f,mp4a.40.2"'
-    )
-
-    expect(masterPlaylist).to.match(reg)
-  }
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  getPlaylist,
-  getSegment,
-  checkResolutionsInMasterPlaylist,
-  getSegmentSha256,
-  checkLiveSegmentHash,
-  checkSegmentHash
-}
diff --git a/shared/extra-utils/videos/videos-command.ts b/shared/extra-utils/videos/videos-command.ts
new file mode 100644
index 000000000..98465e8f6
--- /dev/null
+++ b/shared/extra-utils/videos/videos-command.ts
@@ -0,0 +1,598 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/no-floating-promises */
+
+import { expect } from 'chai'
+import { createReadStream, stat } from 'fs-extra'
+import got, { Response as GotResponse } from 'got'
+import { omit, pick } from 'lodash'
+import validator from 'validator'
+import { buildUUID } from '@server/helpers/uuid'
+import { loadLanguages } from '@server/initializers/constants'
+import {
+  HttpStatusCode,
+  ResultList,
+  UserVideoRateType,
+  Video,
+  VideoCreate,
+  VideoCreateResult,
+  VideoDetails,
+  VideoFileMetadata,
+  VideoPrivacy,
+  VideosCommonQuery,
+  VideosWithSearchCommonQuery
+} from '@shared/models'
+import { buildAbsoluteFixturePath, wait } from '../miscs'
+import { unwrapBody } from '../requests'
+import { PeerTubeServer, waitJobs } from '../server'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export type VideoEdit = Partial<Omit<VideoCreate, 'thumbnailfile' | 'previewfile'>> & {
+  fixture?: string
+  thumbnailfile?: string
+  previewfile?: string
+}
+
+export class VideosCommand extends AbstractCommand {
+
+  constructor (server: PeerTubeServer) {
+    super(server)
+
+    loadLanguages()
+  }
+
+  getCategories (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/videos/categories'
+
+    return this.getRequestBody<{ [id: number]: string }>({
+      ...options,
+      path,
+
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getLicences (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/videos/licences'
+
+    return this.getRequestBody<{ [id: number]: string }>({
+      ...options,
+      path,
+
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getLanguages (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/videos/languages'
+
+    return this.getRequestBody<{ [id: string]: string }>({
+      ...options,
+      path,
+
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getPrivacies (options: OverrideCommandOptions = {}) {
+    const path = '/api/v1/videos/privacies'
+
+    return this.getRequestBody<{ [id in VideoPrivacy]: string }>({
+      ...options,
+      path,
+
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  getDescription (options: OverrideCommandOptions & {
+    descriptionPath: string
+  }) {
+    return this.getRequestBody<{ description: string }>({
+      ...options,
+      path: options.descriptionPath,
+
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getFileMetadata (options: OverrideCommandOptions & {
+    url: string
+  }) {
+    return unwrapBody<VideoFileMetadata>(this.getRawRequest({
+      ...options,
+
+      url: options.url,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    }))
+  }
+
+  // ---------------------------------------------------------------------------
+
+  view (options: OverrideCommandOptions & {
+    id: number | string
+    xForwardedFor?: string
+  }) {
+    const { id, xForwardedFor } = options
+    const path = '/api/v1/videos/' + id + '/views'
+
+    return this.postBodyRequest({
+      ...options,
+
+      path,
+      xForwardedFor,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  rate (options: OverrideCommandOptions & {
+    id: number | string
+    rating: UserVideoRateType
+  }) {
+    const { id, rating } = options
+    const path = '/api/v1/videos/' + id + '/rate'
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: { rating },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  get (options: OverrideCommandOptions & {
+    id: number | string
+  }) {
+    const path = '/api/v1/videos/' + options.id
+
+    return this.getRequestBody<VideoDetails>({
+      ...options,
+
+      path,
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  getWithToken (options: OverrideCommandOptions & {
+    id: number | string
+  }) {
+    return this.get({
+      ...options,
+
+      token: this.buildCommonRequestToken({ ...options, implicitToken: true })
+    })
+  }
+
+  async getId (options: OverrideCommandOptions & {
+    uuid: number | string
+  }) {
+    const { uuid } = options
+
+    if (validator.isUUID('' + uuid) === false) return uuid as number
+
+    const { id } = await this.get({ ...options, id: uuid })
+
+    return id
+  }
+
+  // ---------------------------------------------------------------------------
+
+  listMyVideos (options: OverrideCommandOptions & {
+    start?: number
+    count?: number
+    sort?: string
+    search?: string
+    isLive?: boolean
+  } = {}) {
+    const path = '/api/v1/users/me/videos'
+
+    return this.getRequestBody<ResultList<Video>>({
+      ...options,
+
+      path,
+      query: pick(options, [ 'start', 'count', 'sort', 'search', 'isLive' ]),
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  list (options: OverrideCommandOptions & VideosCommonQuery = {}) {
+    const path = '/api/v1/videos'
+
+    const query = this.buildListQuery(options)
+
+    return this.getRequestBody<ResultList<Video>>({
+      ...options,
+
+      path,
+      query: { sort: 'name', ...query },
+      implicitToken: false,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listWithToken (options: OverrideCommandOptions & VideosCommonQuery = {}) {
+    return this.list({
+      ...options,
+
+      token: this.buildCommonRequestToken({ ...options, implicitToken: true })
+    })
+  }
+
+  listByAccount (options: OverrideCommandOptions & VideosWithSearchCommonQuery & {
+    handle: string
+  }) {
+    const { handle, search } = options
+    const path = '/api/v1/accounts/' + handle + '/videos'
+
+    return this.getRequestBody<ResultList<Video>>({
+      ...options,
+
+      path,
+      query: { search, ...this.buildListQuery(options) },
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  listByChannel (options: OverrideCommandOptions & VideosWithSearchCommonQuery & {
+    handle: string
+  }) {
+    const { handle } = options
+    const path = '/api/v1/video-channels/' + handle + '/videos'
+
+    return this.getRequestBody<ResultList<Video>>({
+      ...options,
+
+      path,
+      query: this.buildListQuery(options),
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })
+  }
+
+  // ---------------------------------------------------------------------------
+
+  async find (options: OverrideCommandOptions & {
+    name: string
+  }) {
+    const { data } = await this.list(options)
+
+    return data.find(v => v.name === options.name)
+  }
+
+  // ---------------------------------------------------------------------------
+
+  update (options: OverrideCommandOptions & {
+    id: number | string
+    attributes?: VideoEdit
+  }) {
+    const { id, attributes = {} } = options
+    const path = '/api/v1/videos/' + id
+
+    // Upload request
+    if (attributes.thumbnailfile || attributes.previewfile) {
+      const attaches: any = {}
+      if (attributes.thumbnailfile) attaches.thumbnailfile = attributes.thumbnailfile
+      if (attributes.previewfile) attaches.previewfile = attributes.previewfile
+
+      return this.putUploadRequest({
+        ...options,
+
+        path,
+        fields: options.attributes,
+        attaches: {
+          thumbnailfile: attributes.thumbnailfile,
+          previewfile: attributes.previewfile
+        },
+        implicitToken: true,
+        defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+      })
+    }
+
+    return this.putBodyRequest({
+      ...options,
+
+      path,
+      fields: options.attributes,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+  }
+
+  remove (options: OverrideCommandOptions & {
+    id: number | string
+  }) {
+    const path = '/api/v1/videos/' + options.id
+
+    return unwrapBody(this.deleteRequest({
+      ...options,
+
+      path,
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+    }))
+  }
+
+  async removeAll () {
+    const { data } = await this.list()
+
+    for (const v of data) {
+      await this.remove({ id: v.id })
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+
+  async upload (options: OverrideCommandOptions & {
+    attributes?: VideoEdit
+    mode?: 'legacy' | 'resumable' // default legacy
+  } = {}) {
+    const { mode = 'legacy' } = options
+    let defaultChannelId = 1
+
+    try {
+      const { videoChannels } = await this.server.users.getMyInfo({ token: options.token })
+      defaultChannelId = videoChannels[0].id
+    } catch (e) { /* empty */ }
+
+    // Override default attributes
+    const attributes = {
+      name: 'my super video',
+      category: 5,
+      licence: 4,
+      language: 'zh',
+      channelId: defaultChannelId,
+      nsfw: true,
+      waitTranscoding: false,
+      description: 'my super description',
+      support: 'my super support text',
+      tags: [ 'tag' ],
+      privacy: VideoPrivacy.PUBLIC,
+      commentsEnabled: true,
+      downloadEnabled: true,
+      fixture: 'video_short.webm',
+
+      ...options.attributes
+    }
+
+    const created = mode === 'legacy'
+      ? await this.buildLegacyUpload({ ...options, attributes })
+      : await this.buildResumeUpload({ ...options, attributes })
+
+    // Wait torrent generation
+    const expectedStatus = this.buildExpectedStatus({ ...options, defaultExpectedStatus: HttpStatusCode.OK_200 })
+    if (expectedStatus === HttpStatusCode.OK_200) {
+      let video: VideoDetails
+
+      do {
+        video = await this.getWithToken({ ...options, id: created.uuid })
+
+        await wait(50)
+      } while (!video.files[0].torrentUrl)
+    }
+
+    return created
+  }
+
+  async buildLegacyUpload (options: OverrideCommandOptions & {
+    attributes: VideoEdit
+  }): Promise<VideoCreateResult> {
+    const path = '/api/v1/videos/upload'
+
+    return unwrapBody<{ video: VideoCreateResult }>(this.postUploadRequest({
+      ...options,
+
+      path,
+      fields: this.buildUploadFields(options.attributes),
+      attaches: this.buildUploadAttaches(options.attributes),
+      implicitToken: true,
+      defaultExpectedStatus: HttpStatusCode.OK_200
+    })).then(body => body.video || body as any)
+  }
+
+  async buildResumeUpload (options: OverrideCommandOptions & {
+    attributes: VideoEdit
+  }): Promise<VideoCreateResult> {
+    const { attributes, expectedStatus } = options
+
+    let size = 0
+    let videoFilePath: string
+    let mimetype = 'video/mp4'
+
+    if (attributes.fixture) {
+      videoFilePath = buildAbsoluteFixturePath(attributes.fixture)
+      size = (await stat(videoFilePath)).size
+
+      if (videoFilePath.endsWith('.mkv')) {
+        mimetype = 'video/x-matroska'
+      } else if (videoFilePath.endsWith('.webm')) {
+        mimetype = 'video/webm'
+      }
+    }
+
+    // Do not check status automatically, we'll check it manually
+    const initializeSessionRes = await this.prepareResumableUpload({ ...options, expectedStatus: null, attributes, size, mimetype })
+    const initStatus = initializeSessionRes.status
+
+    if (videoFilePath && initStatus === HttpStatusCode.CREATED_201) {
+      const locationHeader = initializeSessionRes.header['location']
+      expect(locationHeader).to.not.be.undefined
+
+      const pathUploadId = locationHeader.split('?')[1]
+
+      const result = await this.sendResumableChunks({ ...options, pathUploadId, videoFilePath, size })
+
+      return result.body?.video || result.body as any
+    }
+
+    const expectedInitStatus = expectedStatus === HttpStatusCode.OK_200
+      ? HttpStatusCode.CREATED_201
+      : expectedStatus
+
+    expect(initStatus).to.equal(expectedInitStatus)
+
+    return initializeSessionRes.body.video || initializeSessionRes.body
+  }
+
+  async prepareResumableUpload (options: OverrideCommandOptions & {
+    attributes: VideoEdit
+    size: number
+    mimetype: string
+  }) {
+    const { attributes, size, mimetype } = options
+
+    const path = '/api/v1/videos/upload-resumable'
+
+    return this.postUploadRequest({
+      ...options,
+
+      path,
+      headers: {
+        'X-Upload-Content-Type': mimetype,
+        'X-Upload-Content-Length': size.toString()
+      },
+      fields: { filename: attributes.fixture, ...this.buildUploadFields(options.attributes) },
+      // Fixture will be sent later
+      attaches: this.buildUploadAttaches(omit(options.attributes, 'fixture')),
+      implicitToken: true,
+
+      defaultExpectedStatus: null
+    })
+  }
+
+  sendResumableChunks (options: OverrideCommandOptions & {
+    pathUploadId: string
+    videoFilePath: string
+    size: number
+    contentLength?: number
+    contentRangeBuilder?: (start: number, chunk: any) => string
+  }) {
+    const { pathUploadId, videoFilePath, size, contentLength, contentRangeBuilder, expectedStatus = HttpStatusCode.OK_200 } = options
+
+    const path = '/api/v1/videos/upload-resumable'
+    let start = 0
+
+    const token = this.buildCommonRequestToken({ ...options, implicitToken: true })
+    const url = this.server.url
+
+    const readable = createReadStream(videoFilePath, { highWaterMark: 8 * 1024 })
+    return new Promise<GotResponse<{ video: VideoCreateResult }>>((resolve, reject) => {
+      readable.on('data', async function onData (chunk) {
+        readable.pause()
+
+        const headers = {
+          'Authorization': 'Bearer ' + token,
+          'Content-Type': 'application/octet-stream',
+          'Content-Range': contentRangeBuilder
+            ? contentRangeBuilder(start, chunk)
+            : `bytes ${start}-${start + chunk.length - 1}/${size}`,
+          'Content-Length': contentLength ? contentLength + '' : chunk.length + ''
+        }
+
+        const res = await got<{ video: VideoCreateResult }>({
+          url,
+          method: 'put',
+          headers,
+          path: path + '?' + pathUploadId,
+          body: chunk,
+          responseType: 'json',
+          throwHttpErrors: false
+        })
+
+        start += chunk.length
+
+        if (res.statusCode === expectedStatus) {
+          return resolve(res)
+        }
+
+        if (res.statusCode !== HttpStatusCode.PERMANENT_REDIRECT_308) {
+          readable.off('data', onData)
+          return reject(new Error('Incorrect transient behaviour sending intermediary chunks'))
+        }
+
+        readable.resume()
+      })
+    })
+  }
+
+  quickUpload (options: OverrideCommandOptions & {
+    name: string
+    nsfw?: boolean
+    privacy?: VideoPrivacy
+    fixture?: string
+  }) {
+    const attributes: VideoEdit = { name: options.name }
+    if (options.nsfw) attributes.nsfw = options.nsfw
+    if (options.privacy) attributes.privacy = options.privacy
+    if (options.fixture) attributes.fixture = options.fixture
+
+    return this.upload({ ...options, attributes })
+  }
+
+  async randomUpload (options: OverrideCommandOptions & {
+    wait?: boolean // default true
+    additionalParams?: VideoEdit & { prefixName?: string }
+  } = {}) {
+    const { wait = true, additionalParams } = options
+    const prefixName = additionalParams?.prefixName || ''
+    const name = prefixName + buildUUID()
+
+    const attributes = { name, ...additionalParams }
+
+    const result = await this.upload({ ...options, attributes })
+
+    if (wait) await waitJobs([ this.server ])
+
+    return { ...result, name }
+  }
+
+  // ---------------------------------------------------------------------------
+
+  private buildListQuery (options: VideosCommonQuery) {
+    return pick(options, [
+      'start',
+      'count',
+      'sort',
+      'nsfw',
+      'isLive',
+      'categoryOneOf',
+      'licenceOneOf',
+      'languageOneOf',
+      'tagsOneOf',
+      'tagsAllOf',
+      'filter',
+      'skipCount'
+    ])
+  }
+
+  private buildUploadFields (attributes: VideoEdit) {
+    return omit(attributes, [ 'fixture', 'thumbnailfile', 'previewfile' ])
+  }
+
+  private buildUploadAttaches (attributes: VideoEdit) {
+    const attaches: { [ name: string ]: string } = {}
+
+    for (const key of [ 'thumbnailfile', 'previewfile' ]) {
+      if (attributes[key]) attaches[key] = buildAbsoluteFixturePath(attributes[key])
+    }
+
+    if (attributes.fixture) attaches.videofile = buildAbsoluteFixturePath(attributes.fixture)
+
+    return attaches
+  }
+}
diff --git a/shared/extra-utils/videos/videos.ts b/shared/extra-utils/videos/videos.ts
index 469ea4d63..9a9bfb3cf 100644
--- a/shared/extra-utils/videos/videos.ts
+++ b/shared/extra-utils/videos/videos.ts
@@ -1,348 +1,20 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/no-floating-promises */
 
 import { expect } from 'chai'
-import { createReadStream, pathExists, readdir, readFile, stat } from 'fs-extra'
-import got, { Response as GotResponse } from 'got/dist/source'
-import * as parseTorrent from 'parse-torrent'
+import { pathExists, readdir } from 'fs-extra'
 import { join } from 'path'
-import * as request from 'supertest'
-import validator from 'validator'
 import { getLowercaseExtension } from '@server/helpers/core-utils'
-import { buildUUID } from '@server/helpers/uuid'
-import { HttpStatusCode } from '@shared/core-utils'
-import { VideosCommonQuery } from '@shared/models'
-import { loadLanguages, VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES, VIDEO_PRIVACIES } from '../../../server/initializers/constants'
-import { VideoDetails, VideoPrivacy } from '../../models/videos'
-import {
-  buildAbsoluteFixturePath,
-  buildServerDirectory,
-  dateIsValid,
-  immutableAssign,
-  testImage,
-  wait,
-  webtorrentAdd
-} from '../miscs/miscs'
-import { makeGetRequest, makePutBodyRequest, makeRawRequest, makeUploadRequest } from '../requests/requests'
-import { waitJobs } from '../server/jobs'
-import { ServerInfo } from '../server/servers'
-import { getMyUserInformation } from '../users/users'
-
-loadLanguages()
-
-type VideoAttributes = {
-  name?: string
-  category?: number
-  licence?: number
-  language?: string
-  nsfw?: boolean
-  commentsEnabled?: boolean
-  downloadEnabled?: boolean
-  waitTranscoding?: boolean
-  description?: string
-  originallyPublishedAt?: string
-  tags?: string[]
-  channelId?: number
-  privacy?: VideoPrivacy
-  fixture?: string
-  support?: string
-  thumbnailfile?: string
-  previewfile?: string
-  scheduleUpdate?: {
-    updateAt: string
-    privacy?: VideoPrivacy
-  }
-}
-
-function getVideoCategories (url: string) {
-  const path = '/api/v1/videos/categories'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getVideoLicences (url: string) {
-  const path = '/api/v1/videos/licences'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getVideoLanguages (url: string) {
-  const path = '/api/v1/videos/languages'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getVideoPrivacies (url: string) {
-  const path = '/api/v1/videos/privacies'
-
-  return makeGetRequest({
-    url,
-    path,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getVideo (url: string, id: number | string, expectedStatus = HttpStatusCode.OK_200) {
-  const path = '/api/v1/videos/' + id
-
-  return request(url)
-          .get(path)
-          .set('Accept', 'application/json')
-          .expect(expectedStatus)
-}
-
-async function getVideoIdFromUUID (url: string, uuid: string) {
-  const res = await getVideo(url, uuid)
-
-  return res.body.id
-}
-
-function getVideoFileMetadataUrl (url: string) {
-  return request(url)
-    .get('/')
-    .set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function viewVideo (url: string, id: number | string, expectedStatus = HttpStatusCode.NO_CONTENT_204, xForwardedFor?: string) {
-  const path = '/api/v1/videos/' + id + '/views'
-
-  const req = request(url)
-    .post(path)
-    .set('Accept', 'application/json')
-
-  if (xForwardedFor) {
-    req.set('X-Forwarded-For', xForwardedFor)
-  }
-
-  return req.expect(expectedStatus)
-}
-
-function getVideoWithToken (url: string, token: string, id: number | string, expectedStatus = HttpStatusCode.OK_200) {
-  const path = '/api/v1/videos/' + id
-
-  return request(url)
-    .get(path)
-    .set('Authorization', 'Bearer ' + token)
-    .set('Accept', 'application/json')
-    .expect(expectedStatus)
-}
-
-function getVideoDescription (url: string, descriptionPath: string) {
-  return request(url)
-    .get(descriptionPath)
-    .set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function getVideosList (url: string) {
-  const path = '/api/v1/videos'
-
-  return request(url)
-          .get(path)
-          .query({ sort: 'name' })
-          .set('Accept', 'application/json')
-          .expect(HttpStatusCode.OK_200)
-          .expect('Content-Type', /json/)
-}
-
-function getVideosListWithToken (url: string, token: string, query: { nsfw?: boolean } = {}) {
-  const path = '/api/v1/videos'
-
-  return request(url)
-    .get(path)
-    .set('Authorization', 'Bearer ' + token)
-    .query(immutableAssign(query, { sort: 'name' }))
-    .set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function getLocalVideos (url: string) {
-  const path = '/api/v1/videos'
-
-  return request(url)
-    .get(path)
-    .query({ sort: 'name', filter: 'local' })
-    .set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function getMyVideos (url: string, accessToken: string, start: number, count: number, sort?: string, search?: string) {
-  const path = '/api/v1/users/me/videos'
-
-  const req = request(url)
-    .get(path)
-    .query({ start: start })
-    .query({ count: count })
-    .query({ search: search })
-
-  if (sort) req.query({ sort })
-
-  return req.set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function getMyVideosWithFilter (url: string, accessToken: string, query: { isLive?: boolean }) {
-  const path = '/api/v1/users/me/videos'
-
-  return makeGetRequest({
-    url,
-    path,
-    token: accessToken,
-    query,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getAccountVideos (
-  url: string,
-  accessToken: string,
-  accountName: string,
-  start: number,
-  count: number,
-  sort?: string,
-  query: {
-    nsfw?: boolean
-    search?: string
-  } = {}
-) {
-  const path = '/api/v1/accounts/' + accountName + '/videos'
-
-  return makeGetRequest({
-    url,
-    path,
-    query: immutableAssign(query, {
-      start,
-      count,
-      sort
-    }),
-    token: accessToken,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getVideoChannelVideos (
-  url: string,
-  accessToken: string,
-  videoChannelName: string,
-  start: number,
-  count: number,
-  sort?: string,
-  query: { nsfw?: boolean } = {}
-) {
-  const path = '/api/v1/video-channels/' + videoChannelName + '/videos'
-
-  return makeGetRequest({
-    url,
-    path,
-    query: immutableAssign(query, {
-      start,
-      count,
-      sort
-    }),
-    token: accessToken,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getPlaylistVideos (
-  url: string,
-  accessToken: string,
-  playlistId: number | string,
-  start: number,
-  count: number,
-  query: { nsfw?: boolean } = {}
-) {
-  const path = '/api/v1/video-playlists/' + playlistId + '/videos'
-
-  return makeGetRequest({
-    url,
-    path,
-    query: immutableAssign(query, {
-      start,
-      count
-    }),
-    token: accessToken,
-    statusCodeExpected: HttpStatusCode.OK_200
-  })
-}
-
-function getVideosListPagination (url: string, start: number, count: number, sort?: string, skipCount?: boolean) {
-  const path = '/api/v1/videos'
-
-  const req = request(url)
-              .get(path)
-              .query({ start: start })
-              .query({ count: count })
-
-  if (sort) req.query({ sort })
-  if (skipCount) req.query({ skipCount })
-
-  return req.set('Accept', 'application/json')
-           .expect(HttpStatusCode.OK_200)
-           .expect('Content-Type', /json/)
-}
-
-function getVideosListSort (url: string, sort: string) {
-  const path = '/api/v1/videos'
-
-  return request(url)
-          .get(path)
-          .query({ sort: sort })
-          .set('Accept', 'application/json')
-          .expect(HttpStatusCode.OK_200)
-          .expect('Content-Type', /json/)
-}
-
-function getVideosWithFilters (url: string, query: VideosCommonQuery) {
-  const path = '/api/v1/videos'
-
-  return request(url)
-    .get(path)
-    .query(query)
-    .set('Accept', 'application/json')
-    .expect(HttpStatusCode.OK_200)
-    .expect('Content-Type', /json/)
-}
-
-function removeVideo (url: string, token: string, id: number | string, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/videos'
-
-  return request(url)
-          .delete(path + '/' + id)
-          .set('Accept', 'application/json')
-          .set('Authorization', 'Bearer ' + token)
-          .expect(expectedStatus)
-}
-
-async function removeAllVideos (server: ServerInfo) {
-  const resVideos = await getVideosList(server.url)
-
-  for (const v of resVideos.body.data) {
-    await removeVideo(server.url, server.accessToken, v.id)
-  }
-}
+import { HttpStatusCode } from '@shared/models'
+import { VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES, VIDEO_PRIVACIES } from '../../../server/initializers/constants'
+import { dateIsValid, testImage, webtorrentAdd } from '../miscs'
+import { makeRawRequest } from '../requests/requests'
+import { waitJobs } from '../server'
+import { PeerTubeServer } from '../server/server'
+import { VideoEdit } from './videos-command'
 
 async function checkVideoFilesWereRemoved (
   videoUUID: string,
-  serverNumber: number,
+  server: PeerTubeServer,
   directories = [
     'redundancy',
     'videos',
@@ -355,7 +27,7 @@ async function checkVideoFilesWereRemoved (
   ]
 ) {
   for (const directory of directories) {
-    const directoryPath = buildServerDirectory({ internalServerNumber: serverNumber }, directory)
+    const directoryPath = server.servers.buildDirectory(directory)
 
     const directoryExists = await pathExists(directoryPath)
     if (directoryExists === false) continue
@@ -367,280 +39,20 @@ async function checkVideoFilesWereRemoved (
   }
 }
 
-async function uploadVideo (
-  url: string,
-  accessToken: string,
-  videoAttributesArg: VideoAttributes,
-  specialStatus = HttpStatusCode.OK_200,
-  mode: 'legacy' | 'resumable' = 'legacy'
-) {
-  let defaultChannelId = '1'
-
-  try {
-    const res = await getMyUserInformation(url, accessToken)
-    defaultChannelId = res.body.videoChannels[0].id
-  } catch (e) { /* empty */ }
-
-  // Override default attributes
-  const attributes = Object.assign({
-    name: 'my super video',
-    category: 5,
-    licence: 4,
-    language: 'zh',
-    channelId: defaultChannelId,
-    nsfw: true,
-    waitTranscoding: false,
-    description: 'my super description',
-    support: 'my super support text',
-    tags: [ 'tag' ],
-    privacy: VideoPrivacy.PUBLIC,
-    commentsEnabled: true,
-    downloadEnabled: true,
-    fixture: 'video_short.webm'
-  }, videoAttributesArg)
-
-  const res = mode === 'legacy'
-    ? await buildLegacyUpload(url, accessToken, attributes, specialStatus)
-    : await buildResumeUpload(url, accessToken, attributes, specialStatus)
-
-  // Wait torrent generation
-  if (specialStatus === HttpStatusCode.OK_200) {
-    let video: VideoDetails
-    do {
-      const resVideo = await getVideoWithToken(url, accessToken, res.body.video.uuid)
-      video = resVideo.body
-
-      await wait(50)
-    } while (!video.files[0].torrentUrl)
-  }
-
-  return res
-}
-
 function checkUploadVideoParam (
-  url: string,
+  server: PeerTubeServer,
   token: string,
-  attributes: Partial<VideoAttributes>,
-  specialStatus = HttpStatusCode.OK_200,
+  attributes: Partial<VideoEdit>,
+  expectedStatus = HttpStatusCode.OK_200,
   mode: 'legacy' | 'resumable' = 'legacy'
 ) {
   return mode === 'legacy'
-    ? buildLegacyUpload(url, token, attributes, specialStatus)
-    : buildResumeUpload(url, token, attributes, specialStatus)
-}
-
-async function buildLegacyUpload (url: string, token: string, attributes: VideoAttributes, specialStatus = HttpStatusCode.OK_200) {
-  const path = '/api/v1/videos/upload'
-  const req = request(url)
-              .post(path)
-              .set('Accept', 'application/json')
-              .set('Authorization', 'Bearer ' + token)
-
-  buildUploadReq(req, attributes)
-
-  if (attributes.fixture !== undefined) {
-    req.attach('videofile', buildAbsoluteFixturePath(attributes.fixture))
-  }
-
-  return req.expect(specialStatus)
-}
-
-async function buildResumeUpload (url: string, token: string, attributes: VideoAttributes, specialStatus = HttpStatusCode.OK_200) {
-  let size = 0
-  let videoFilePath: string
-  let mimetype = 'video/mp4'
-
-  if (attributes.fixture) {
-    videoFilePath = buildAbsoluteFixturePath(attributes.fixture)
-    size = (await stat(videoFilePath)).size
-
-    if (videoFilePath.endsWith('.mkv')) {
-      mimetype = 'video/x-matroska'
-    } else if (videoFilePath.endsWith('.webm')) {
-      mimetype = 'video/webm'
-    }
-  }
-
-  const initializeSessionRes = await prepareResumableUpload({ url, token, attributes, size, mimetype })
-  const initStatus = initializeSessionRes.status
-
-  if (videoFilePath && initStatus === HttpStatusCode.CREATED_201) {
-    const locationHeader = initializeSessionRes.header['location']
-    expect(locationHeader).to.not.be.undefined
-
-    const pathUploadId = locationHeader.split('?')[1]
-
-    return sendResumableChunks({ url, token, pathUploadId, videoFilePath, size, specialStatus })
-  }
-
-  const expectedInitStatus = specialStatus === HttpStatusCode.OK_200
-    ? HttpStatusCode.CREATED_201
-    : specialStatus
-
-  expect(initStatus).to.equal(expectedInitStatus)
-
-  return initializeSessionRes
-}
-
-async function prepareResumableUpload (options: {
-  url: string
-  token: string
-  attributes: VideoAttributes
-  size: number
-  mimetype: string
-}) {
-  const { url, token, attributes, size, mimetype } = options
-
-  const path = '/api/v1/videos/upload-resumable'
-
-  const req = request(url)
-              .post(path)
-              .set('Authorization', 'Bearer ' + token)
-              .set('X-Upload-Content-Type', mimetype)
-              .set('X-Upload-Content-Length', size.toString())
-
-  buildUploadReq(req, attributes)
-
-  if (attributes.fixture) {
-    req.field('filename', attributes.fixture)
-  }
-
-  return req
-}
-
-function sendResumableChunks (options: {
-  url: string
-  token: string
-  pathUploadId: string
-  videoFilePath: string
-  size: number
-  specialStatus?: HttpStatusCode
-  contentLength?: number
-  contentRangeBuilder?: (start: number, chunk: any) => string
-}) {
-  const { url, token, pathUploadId, videoFilePath, size, specialStatus, contentLength, contentRangeBuilder } = options
-
-  const expectedStatus = specialStatus || HttpStatusCode.OK_200
-
-  const path = '/api/v1/videos/upload-resumable'
-  let start = 0
-
-  const readable = createReadStream(videoFilePath, { highWaterMark: 8 * 1024 })
-  return new Promise<GotResponse>((resolve, reject) => {
-    readable.on('data', async function onData (chunk) {
-      readable.pause()
-
-      const headers = {
-        'Authorization': 'Bearer ' + token,
-        'Content-Type': 'application/octet-stream',
-        'Content-Range': contentRangeBuilder
-          ? contentRangeBuilder(start, chunk)
-          : `bytes ${start}-${start + chunk.length - 1}/${size}`,
-        'Content-Length': contentLength ? contentLength + '' : chunk.length + ''
-      }
-
-      const res = await got({
-        url,
-        method: 'put',
-        headers,
-        path: path + '?' + pathUploadId,
-        body: chunk,
-        responseType: 'json',
-        throwHttpErrors: false
-      })
-
-      start += chunk.length
-
-      if (res.statusCode === expectedStatus) {
-        return resolve(res)
-      }
-
-      if (res.statusCode !== HttpStatusCode.PERMANENT_REDIRECT_308) {
-        readable.off('data', onData)
-        return reject(new Error('Incorrect transient behaviour sending intermediary chunks'))
-      }
-
-      readable.resume()
-    })
-  })
-}
-
-function updateVideo (
-  url: string,
-  accessToken: string,
-  id: number | string,
-  attributes: VideoAttributes,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/videos/' + id
-  const body = {}
-
-  if (attributes.name) body['name'] = attributes.name
-  if (attributes.category) body['category'] = attributes.category
-  if (attributes.licence) body['licence'] = attributes.licence
-  if (attributes.language) body['language'] = attributes.language
-  if (attributes.nsfw !== undefined) body['nsfw'] = JSON.stringify(attributes.nsfw)
-  if (attributes.commentsEnabled !== undefined) body['commentsEnabled'] = JSON.stringify(attributes.commentsEnabled)
-  if (attributes.downloadEnabled !== undefined) body['downloadEnabled'] = JSON.stringify(attributes.downloadEnabled)
-  if (attributes.originallyPublishedAt !== undefined) body['originallyPublishedAt'] = attributes.originallyPublishedAt
-  if (attributes.description) body['description'] = attributes.description
-  if (attributes.tags) body['tags'] = attributes.tags
-  if (attributes.privacy) body['privacy'] = attributes.privacy
-  if (attributes.channelId) body['channelId'] = attributes.channelId
-  if (attributes.scheduleUpdate) body['scheduleUpdate'] = attributes.scheduleUpdate
-
-  // Upload request
-  if (attributes.thumbnailfile || attributes.previewfile) {
-    const attaches: any = {}
-    if (attributes.thumbnailfile) attaches.thumbnailfile = attributes.thumbnailfile
-    if (attributes.previewfile) attaches.previewfile = attributes.previewfile
-
-    return makeUploadRequest({
-      url,
-      method: 'PUT',
-      path,
-      token: accessToken,
-      fields: body,
-      attaches,
-      statusCodeExpected
-    })
-  }
-
-  return makePutBodyRequest({
-    url,
-    path,
-    fields: body,
-    token: accessToken,
-    statusCodeExpected
-  })
-}
-
-function rateVideo (url: string, accessToken: string, id: number | string, rating: string, specialStatus = HttpStatusCode.NO_CONTENT_204) {
-  const path = '/api/v1/videos/' + id + '/rate'
-
-  return request(url)
-          .put(path)
-          .set('Accept', 'application/json')
-          .set('Authorization', 'Bearer ' + accessToken)
-          .send({ rating })
-          .expect(specialStatus)
-}
-
-function parseTorrentVideo (server: ServerInfo, videoUUID: string, resolution: number) {
-  return new Promise<any>((res, rej) => {
-    const torrentName = videoUUID + '-' + resolution + '.torrent'
-    const torrentPath = buildServerDirectory(server, join('torrents', torrentName))
-
-    readFile(torrentPath, (err, data) => {
-      if (err) return rej(err)
-
-      return res(parseTorrent(data))
-    })
-  })
+    ? server.videos.buildLegacyUpload({ token, attributes, expectedStatus })
+    : server.videos.buildResumeUpload({ token, attributes, expectedStatus })
 }
 
 async function completeVideoCheck (
-  url: string,
+  server: PeerTubeServer,
   video: any,
   attributes: {
     name: string
@@ -682,7 +94,7 @@ async function completeVideoCheck (
   if (!attributes.likes) attributes.likes = 0
   if (!attributes.dislikes) attributes.dislikes = 0
 
-  const host = new URL(url).host
+  const host = new URL(server.url).host
   const originHost = attributes.account.host
 
   expect(video.name).to.equal(attributes.name)
@@ -719,8 +131,7 @@ async function completeVideoCheck (
     expect(video.originallyPublishedAt).to.be.null
   }
 
-  const res = await getVideo(url, video.uuid)
-  const videoDetails: VideoDetails = res.body
+  const videoDetails = await server.videos.get({ id: video.uuid })
 
   expect(videoDetails.files).to.have.lengthOf(attributes.files.length)
   expect(videoDetails.tags).to.deep.equal(attributes.tags)
@@ -776,149 +187,33 @@ async function completeVideoCheck (
   }
 
   expect(videoDetails.thumbnailPath).to.exist
-  await testImage(url, attributes.thumbnailfile || attributes.fixture, videoDetails.thumbnailPath)
+  await testImage(server.url, attributes.thumbnailfile || attributes.fixture, videoDetails.thumbnailPath)
 
   if (attributes.previewfile) {
     expect(videoDetails.previewPath).to.exist
-    await testImage(url, attributes.previewfile, videoDetails.previewPath)
+    await testImage(server.url, attributes.previewfile, videoDetails.previewPath)
   }
 }
 
-async function videoUUIDToId (url: string, id: number | string) {
-  if (validator.isUUID('' + id) === false) return id
-
-  const res = await getVideo(url, id)
-  return res.body.id
-}
-
-async function uploadVideoAndGetId (options: {
-  server: ServerInfo
-  videoName: string
-  nsfw?: boolean
-  privacy?: VideoPrivacy
-  token?: string
-  fixture?: string
-}) {
-  const videoAttrs: any = { name: options.videoName }
-  if (options.nsfw) videoAttrs.nsfw = options.nsfw
-  if (options.privacy) videoAttrs.privacy = options.privacy
-  if (options.fixture) videoAttrs.fixture = options.fixture
-
-  const res = await uploadVideo(options.server.url, options.token || options.server.accessToken, videoAttrs)
-
-  return res.body.video as { id: number, uuid: string, shortUUID: string }
-}
-
-async function getLocalIdByUUID (url: string, uuid: string) {
-  const res = await getVideo(url, uuid)
-
-  return res.body.id
-}
-
 // serverNumber starts from 1
-async function uploadRandomVideoOnServers (servers: ServerInfo[], serverNumber: number, additionalParams: any = {}) {
+async function uploadRandomVideoOnServers (
+  servers: PeerTubeServer[],
+  serverNumber: number,
+  additionalParams?: VideoEdit & { prefixName?: string }
+) {
   const server = servers.find(s => s.serverNumber === serverNumber)
-  const res = await uploadRandomVideo(server, false, additionalParams)
+  const res = await server.videos.randomUpload({ wait: false, additionalParams })
 
   await waitJobs(servers)
 
   return res
 }
 
-async function uploadRandomVideo (server: ServerInfo, wait = true, additionalParams: any = {}) {
-  const prefixName = additionalParams.prefixName || ''
-  const name = prefixName + buildUUID()
-
-  const data = Object.assign({ name }, additionalParams)
-  const res = await uploadVideo(server.url, server.accessToken, data)
-
-  if (wait) await waitJobs([ server ])
-
-  return { uuid: res.body.video.uuid, name }
-}
-
 // ---------------------------------------------------------------------------
 
 export {
-  getVideoDescription,
-  getVideoCategories,
-  uploadRandomVideo,
-  getVideoLicences,
-  videoUUIDToId,
-  getVideoPrivacies,
-  getVideoLanguages,
-  getMyVideos,
-  getAccountVideos,
-  getVideoChannelVideos,
-  getVideo,
-  getVideoFileMetadataUrl,
-  getVideoWithToken,
-  getVideosList,
-  removeAllVideos,
   checkUploadVideoParam,
-  getVideosListPagination,
-  getVideosListSort,
-  removeVideo,
-  getVideosListWithToken,
-  uploadVideo,
-  sendResumableChunks,
-  getVideosWithFilters,
-  uploadRandomVideoOnServers,
-  updateVideo,
-  rateVideo,
-  viewVideo,
-  parseTorrentVideo,
-  getLocalVideos,
   completeVideoCheck,
-  checkVideoFilesWereRemoved,
-  getPlaylistVideos,
-  getMyVideosWithFilter,
-  uploadVideoAndGetId,
-  getLocalIdByUUID,
-  getVideoIdFromUUID,
-  prepareResumableUpload
-}
-
-// ---------------------------------------------------------------------------
-
-function buildUploadReq (req: request.Test, attributes: VideoAttributes) {
-
-  for (const key of [ 'name', 'support', 'channelId', 'description', 'originallyPublishedAt' ]) {
-    if (attributes[key] !== undefined) {
-      req.field(key, attributes[key])
-    }
-  }
-
-  for (const key of [ 'nsfw', 'commentsEnabled', 'downloadEnabled', 'waitTranscoding' ]) {
-    if (attributes[key] !== undefined) {
-      req.field(key, JSON.stringify(attributes[key]))
-    }
-  }
-
-  for (const key of [ 'language', 'privacy', 'category', 'licence' ]) {
-    if (attributes[key] !== undefined) {
-      req.field(key, attributes[key].toString())
-    }
-  }
-
-  const tags = attributes.tags || []
-  for (let i = 0; i < tags.length; i++) {
-    req.field('tags[' + i + ']', attributes.tags[i])
-  }
-
-  for (const key of [ 'thumbnailfile', 'previewfile' ]) {
-    if (attributes[key] !== undefined) {
-      req.attach(key, buildAbsoluteFixturePath(attributes[key]))
-    }
-  }
-
-  if (attributes.scheduleUpdate) {
-    if (attributes.scheduleUpdate.updateAt) {
-      req.field('scheduleUpdate[updateAt]', attributes.scheduleUpdate.updateAt)
-    }
-
-    if (attributes.scheduleUpdate.privacy) {
-      req.field('scheduleUpdate[privacy]', attributes.scheduleUpdate.privacy)
-    }
-  }
+  uploadRandomVideoOnServers,
+  checkVideoFilesWereRemoved
 }
diff --git a/shared/core-utils/miscs/http-error-codes.ts b/shared/models/http/http-error-codes.ts
index b2fbdfc5a..b2fbdfc5a 100644
--- a/shared/core-utils/miscs/http-error-codes.ts
+++ b/shared/models/http/http-error-codes.ts
diff --git a/shared/core-utils/miscs/http-methods.ts b/shared/models/http/http-methods.ts
index 1cfa458b9..1cfa458b9 100644
--- a/shared/core-utils/miscs/http-methods.ts
+++ b/shared/models/http/http-methods.ts
diff --git a/shared/models/http/index.ts b/shared/models/http/index.ts
new file mode 100644
index 000000000..ec991afe0
--- /dev/null
+++ b/shared/models/http/index.ts
@@ -0,0 +1,2 @@
+export * from './http-error-codes'
+export * from './http-methods'
diff --git a/shared/models/index.ts b/shared/models/index.ts
index 5c2bc480e..78723d830 100644
--- a/shared/models/index.ts
+++ b/shared/models/index.ts
@@ -4,6 +4,7 @@ export * from './bulk'
 export * from './common'
 export * from './custom-markup'
 export * from './feeds'
+export * from './http'
 export * from './joinpeertube'
 export * from './moderation'
 export * from './overviews'
diff --git a/shared/models/search/videos-common-query.model.ts b/shared/models/search/videos-common-query.model.ts
index bd02489ea..179266338 100644
--- a/shared/models/search/videos-common-query.model.ts
+++ b/shared/models/search/videos-common-query.model.ts
@@ -21,6 +21,8 @@ export interface VideosCommonQuery {
   tagsAllOf?: string[]
 
   filter?: VideoFilter
+
+  skipCount?: boolean
 }
 
 export interface VideosWithSearchCommonQuery extends VideosCommonQuery {
diff --git a/shared/models/server/debug.model.ts b/shared/models/server/debug.model.ts
index 7ceff9137..2ecabdeca 100644
--- a/shared/models/server/debug.model.ts
+++ b/shared/models/server/debug.model.ts
@@ -1,5 +1,6 @@
 export interface Debug {
   ip: string
+  activityPubMessagesWaiting: number
 }
 
 export interface SendDebugCommand {
diff --git a/shared/models/server/index.ts b/shared/models/server/index.ts
index 06bf5c599..0f7646c7a 100644
--- a/shared/models/server/index.ts
+++ b/shared/models/server/index.ts
@@ -10,4 +10,5 @@ export * from './peertube-problem-document.model'
 export * from './server-config.model'
 export * from './server-debug.model'
 export * from './server-error-code.enum'
+export * from './server-follow-create.model'
 export * from './server-stats.model'
diff --git a/shared/models/server/peertube-problem-document.model.ts b/shared/models/server/peertube-problem-document.model.ts
index e391d5aad..8dd96f7a3 100644
--- a/shared/models/server/peertube-problem-document.model.ts
+++ b/shared/models/server/peertube-problem-document.model.ts
@@ -1,4 +1,4 @@
-import { HttpStatusCode } from '../../core-utils'
+import { HttpStatusCode } from '../../models'
 import { OAuth2ErrorCode, ServerErrorCode } from './server-error-code.enum'
 
 export interface PeerTubeProblemDocumentData {
diff --git a/shared/models/server/server-follow-create.model.ts b/shared/models/server/server-follow-create.model.ts
new file mode 100644
index 000000000..3f90c7d6f
--- /dev/null
+++ b/shared/models/server/server-follow-create.model.ts
@@ -0,0 +1,4 @@
+export interface ServerFollowCreate {
+  hosts?: string[]
+  handles?: string[]
+}
diff --git a/shared/models/users/index.ts b/shared/models/users/index.ts
index a9d578054..b61a8cd40 100644
--- a/shared/models/users/index.ts
+++ b/shared/models/users/index.ts
@@ -1,3 +1,4 @@
+export * from './user-create-result.model'
 export * from './user-create.model'
 export * from './user-flag.model'
 export * from './user-login.model'
diff --git a/shared/models/users/user-create-result.model.ts b/shared/models/users/user-create-result.model.ts
new file mode 100644
index 000000000..835b241ed
--- /dev/null
+++ b/shared/models/users/user-create-result.model.ts
@@ -0,0 +1,7 @@
+export interface UserCreateResult {
+  id: number
+
+  account: {
+    id: number
+  }
+}
diff --git a/shared/models/videos/channel/index.ts b/shared/models/videos/channel/index.ts
index 9dbaa42da..6cdabffbd 100644
--- a/shared/models/videos/channel/index.ts
+++ b/shared/models/videos/channel/index.ts
@@ -1,3 +1,4 @@
+export * from './video-channel-create-result.model'
 export * from './video-channel-create.model'
 export * from './video-channel-update.model'
 export * from './video-channel.model'
diff --git a/shared/models/videos/channel/video-channel-create-result.model.ts b/shared/models/videos/channel/video-channel-create-result.model.ts
new file mode 100644
index 000000000..e3d7aeb4c
--- /dev/null
+++ b/shared/models/videos/channel/video-channel-create-result.model.ts
@@ -0,0 +1,3 @@
+export interface VideoChannelCreateResult {
+  id: number
+}
diff --git a/shared/models/videos/comment/index.ts b/shared/models/videos/comment/index.ts
index 7b9261a36..80c6c0724 100644
--- a/shared/models/videos/comment/index.ts
+++ b/shared/models/videos/comment/index.ts
@@ -1 +1,2 @@
+export * from './video-comment-create.model'
 export * from './video-comment.model'
diff --git a/shared/models/videos/comment/video-comment-create.model.ts b/shared/models/videos/comment/video-comment-create.model.ts
new file mode 100644
index 000000000..1f0135405
--- /dev/null
+++ b/shared/models/videos/comment/video-comment-create.model.ts
@@ -0,0 +1,3 @@
+export interface VideoCommentCreate {
+  text: string
+}
diff --git a/shared/models/videos/comment/video-comment.model.ts b/shared/models/videos/comment/video-comment.model.ts
index 79c0e4c0a..5a96f9d4a 100644
--- a/shared/models/videos/comment/video-comment.model.ts
+++ b/shared/models/videos/comment/video-comment.model.ts
@@ -1,3 +1,4 @@
+import { ResultList } from '@shared/models/common'
 import { Account } from '../../actors'
 
 export interface VideoComment {
@@ -36,11 +37,9 @@ export interface VideoCommentAdmin {
   }
 }
 
+export type VideoCommentThreads = ResultList<VideoComment> & { totalNotDeletedComments: number }
+
 export interface VideoCommentThreadTree {
   comment: VideoComment
   children: VideoCommentThreadTree[]
 }
-
-export interface VideoCommentCreate {
-  text: string
-}
diff --git a/shared/models/videos/playlist/index.ts b/shared/models/videos/playlist/index.ts
index f11a4bd28..a9e8ce496 100644
--- a/shared/models/videos/playlist/index.ts
+++ b/shared/models/videos/playlist/index.ts
@@ -1,6 +1,7 @@
 export * from './video-exist-in-playlist.model'
 export * from './video-playlist-create-result.model'
 export * from './video-playlist-create.model'
+export * from './video-playlist-element-create-result.model'
 export * from './video-playlist-element-create.model'
 export * from './video-playlist-element-update.model'
 export * from './video-playlist-element.model'
diff --git a/shared/models/videos/playlist/video-playlist-element-create-result.model.ts b/shared/models/videos/playlist/video-playlist-element-create-result.model.ts
new file mode 100644
index 000000000..dc475e7d8
--- /dev/null
+++ b/shared/models/videos/playlist/video-playlist-element-create-result.model.ts
@@ -0,0 +1,3 @@
+export interface VideoPlaylistElementCreateResult {
+  id: number
+}
diff --git a/shared/models/videos/video-update.model.ts b/shared/models/videos/video-update.model.ts
index e21ccae04..86653b959 100644
--- a/shared/models/videos/video-update.model.ts
+++ b/shared/models/videos/video-update.model.ts
@@ -1,5 +1,6 @@
 import { VideoPrivacy } from './video-privacy.enum'
 import { VideoScheduleUpdate } from './video-schedule-update.model'
+
 export interface VideoUpdate {
   name?: string
   category?: number