338 files changed, 12753 insertions, 13167 deletions

diff --git a/server/controllers/activitypub/client.ts b/server/controllers/activitypub/client.ts
index d7de1b9bd..bef4bc068 100644
--- a/server/controllers/activitypub/client.ts
+++ b/server/controllers/activitypub/client.ts
@@ -24,7 +24,7 @@ import {
   videosCustomGetValidator,
   videosShareValidator
 } from '../../middlewares'
-import { cacheRoute } from '../../middlewares/cache'
+import { cacheRoute } from '../../middlewares/cache/cache'
 import { getAccountVideoRateValidatorFactory, videoCommentGetValidator } from '../../middlewares/validators'
 import { videoFileRedundancyGetValidator, videoPlaylistRedundancyGetValidator } from '../../middlewares/validators/redundancy'
 import { videoPlaylistElementAPGetValidator, videoPlaylistsGetValidator } from '../../middlewares/validators/videos/video-playlists'
@@ -77,7 +77,7 @@ activityPubClientRouter.get('/accounts?/:name/dislikes/:videoId',
 activityPubClientRouter.get(
   [ '/videos/watch/:id', '/w/:id' ],
   executeIfActivityPub,
-  asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.ACTIVITY_PUB.VIDEOS)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.ACTIVITY_PUB.VIDEOS),
   asyncMiddleware(videosCustomGetValidator('all')),
   asyncMiddleware(videoController)
 )
diff --git a/server/controllers/activitypub/inbox.ts b/server/controllers/activitypub/inbox.ts
index 14f301ab7..30662990a 100644
--- a/server/controllers/activitypub/inbox.ts
+++ b/server/controllers/activitypub/inbox.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { InboxManager } from '@server/lib/activitypub/inbox-manager'
 import { Activity, ActivityPubCollection, ActivityPubOrderedCollection, RootActivity } from '../../../shared'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { isActivityValid } from '../../helpers/custom-validators/activitypub/activity'
 import { logger } from '../../helpers/logger'
 import { asyncMiddleware, checkSignature, localAccountValidator, localVideoChannelValidator, signatureValidator } from '../../middlewares'
diff --git a/server/controllers/api/abuse.ts b/server/controllers/api/abuse.ts
index ba5b94840..e851365e9 100644
--- a/server/controllers/api/abuse.ts
+++ b/server/controllers/api/abuse.ts
@@ -6,7 +6,7 @@ import { AbuseModel } from '@server/models/abuse/abuse'
 import { AbuseMessageModel } from '@server/models/abuse/abuse-message'
 import { getServerActor } from '@server/models/application/application'
 import { abusePredefinedReasonsMap } from '@shared/core-utils/abuse'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '@shared/models'
 import { AbuseCreate, AbuseState, UserRight } from '../../../shared'
 import { getFormattedObjects } from '../../helpers/utils'
 import { sequelizeTypescript } from '../../initializers/database'
diff --git a/server/controllers/api/accounts.ts b/server/controllers/api/accounts.ts
index 49a8e3195..55e2aaf62 100644
--- a/server/controllers/api/accounts.ts
+++ b/server/controllers/api/accounts.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
+import { pickCommonVideoQuery } from '@server/helpers/query'
 import { getServerActor } from '@server/models/application/application'
-import { VideosWithSearchCommonQuery } from '@shared/models'
 import { buildNSFWFilter, getCountVideos, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
 import { getFormattedObjects } from '../../helpers/utils'
 import { JobQueue } from '../../lib/job-queue'
@@ -159,27 +159,19 @@ async function listAccountVideos (req: express.Request, res: express.Response) {
   const account = res.locals.account
   const followerActorId = isUserAbleToSearchRemoteURI(res) ? null : undefined
   const countVideos = getCountVideos(req)
-  const query = req.query as VideosWithSearchCommonQuery
+  const query = pickCommonVideoQuery(req.query)
 
   const apiOptions = await Hooks.wrapObject({
+    ...query,
+
     followerActorId,
-    start: query.start,
-    count: query.count,
-    sort: query.sort,
+    search: req.query.search,
     includeLocalVideos: true,
-    categoryOneOf: query.categoryOneOf,
-    licenceOneOf: query.licenceOneOf,
-    languageOneOf: query.languageOneOf,
-    tagsOneOf: query.tagsOneOf,
-    tagsAllOf: query.tagsAllOf,
-    filter: query.filter,
-    isLive: query.isLive,
     nsfw: buildNSFWFilter(res, query.nsfw),
     withFiles: false,
     accountId: account.id,
     user: res.locals.oauth ? res.locals.oauth.token.User : undefined,
-    countVideos,
-    search: query.search
+    countVideos
   }, 'filter:api.accounts.videos.list.params')
 
   const resultList = await Hooks.wrapPromiseFun(
diff --git a/server/controllers/api/bulk.ts b/server/controllers/api/bulk.ts
index 192daccde..62121ece5 100644
--- a/server/controllers/api/bulk.ts
+++ b/server/controllers/api/bulk.ts
@@ -1,10 +1,10 @@
 import * as express from 'express'
-import { asyncMiddleware, authenticate } from '../../middlewares'
+import { removeComment } from '@server/lib/video-comment'
 import { bulkRemoveCommentsOfValidator } from '@server/middlewares/validators/bulk'
 import { VideoCommentModel } from '@server/models/video/video-comment'
-import { removeComment } from '@server/lib/video-comment'
+import { HttpStatusCode } from '@shared/models'
 import { BulkRemoveCommentsOfBody } from '@shared/models/bulk/bulk-remove-comments-of-body.model'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
+import { asyncMiddleware, authenticate } from '../../middlewares'
 
 const bulkRouter = express.Router()
 
diff --git a/server/controllers/api/config.ts b/server/controllers/api/config.ts
index 9bd8c21c5..ee733a38c 100644
--- a/server/controllers/api/config.ts
+++ b/server/controllers/api/config.ts
@@ -1,8 +1,8 @@
-import { ServerConfigManager } from '@server/lib/server-config-manager'
 import * as express from 'express'
 import { remove, writeJSON } from 'fs-extra'
 import { snakeCase } from 'lodash'
 import validator from 'validator'
+import { ServerConfigManager } from '@server/lib/server-config-manager'
 import { UserRight } from '../../../shared'
 import { About } from '../../../shared/models/server/about.model'
 import { CustomConfig } from '../../../shared/models/server/custom-config.model'
diff --git a/server/controllers/api/custom-page.ts b/server/controllers/api/custom-page.ts
index c19f03c56..68d8c2ea4 100644
--- a/server/controllers/api/custom-page.ts
+++ b/server/controllers/api/custom-page.ts
@@ -1,8 +1,7 @@
 import * as express from 'express'
 import { ServerConfigManager } from '@server/lib/server-config-manager'
 import { ActorCustomPageModel } from '@server/models/account/actor-custom-page'
-import { HttpStatusCode } from '@shared/core-utils'
-import { UserRight } from '@shared/models'
+import { HttpStatusCode, UserRight } from '@shared/models'
 import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../middlewares'
 
 const customPageRouter = express.Router()
diff --git a/server/controllers/api/index.ts b/server/controllers/api/index.ts
index 28378654a..93b14dadb 100644
--- a/server/controllers/api/index.ts
+++ b/server/controllers/api/index.ts
@@ -1,7 +1,7 @@
 import * as cors from 'cors'
 import * as express from 'express'
 import * as RateLimit from 'express-rate-limit'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models'
 import { badRequest } from '../../helpers/express-utils'
 import { CONFIG } from '../../initializers/config'
 import { abuseRouter } from './abuse'
diff --git a/server/controllers/api/oauth-clients.ts b/server/controllers/api/oauth-clients.ts
index 15bbf5c4d..f95f06864 100644
--- a/server/controllers/api/oauth-clients.ts
+++ b/server/controllers/api/oauth-clients.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { OAuthClientLocal } from '../../../shared'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { logger } from '../../helpers/logger'
 import { CONFIG } from '../../initializers/config'
 import { asyncMiddleware, openapiOperationDoc } from '../../middlewares'
diff --git a/server/controllers/api/overviews.ts b/server/controllers/api/overviews.ts
index ad879aad6..2dfac15ef 100644
--- a/server/controllers/api/overviews.ts
+++ b/server/controllers/api/overviews.ts
@@ -1,12 +1,13 @@
 import * as express from 'express'
+import * as memoizee from 'memoizee'
+import { logger } from '@server/helpers/logger'
+import { Hooks } from '@server/lib/plugins/hooks'
+import { VideoModel } from '@server/models/video/video'
+import { CategoryOverview, ChannelOverview, TagOverview, VideosOverview } from '../../../shared/models/overviews'
 import { buildNSFWFilter } from '../../helpers/express-utils'
-import { VideoModel } from '../../models/video/video'
+import { MEMOIZE_TTL, OVERVIEWS } from '../../initializers/constants'
 import { asyncMiddleware, optionalAuthenticate, videosOverviewValidator } from '../../middlewares'
 import { TagModel } from '../../models/video/tag'
-import { CategoryOverview, ChannelOverview, TagOverview, VideosOverview } from '../../../shared/models/overviews'
-import { MEMOIZE_TTL, OVERVIEWS } from '../../initializers/constants'
-import * as memoizee from 'memoizee'
-import { logger } from '@server/helpers/logger'
 
 const overviewsRouter = express.Router()
 
@@ -108,7 +109,7 @@ async function getVideos (
   res: express.Response,
   where: { videoChannelId?: number, tagsOneOf?: string[], categoryOneOf?: number[] }
 ) {
-  const query = Object.assign({
+  const query = await Hooks.wrapObject({
     start: 0,
     count: 12,
     sort: '-createdAt',
@@ -116,10 +117,16 @@ async function getVideos (
     nsfw: buildNSFWFilter(res),
     user: res.locals.oauth ? res.locals.oauth.token.User : undefined,
     withFiles: false,
-    countVideos: false
-  }, where)
+    countVideos: false,
+
+    ...where
+  }, 'filter:api.overviews.videos.list.params')
 
-  const { data } = await VideoModel.listForApi(query)
+  const { data } = await Hooks.wrapPromiseFun(
+    VideoModel.listForApi,
+    query,
+    'filter:api.overviews.videos.list.result'
+  )
 
   return data.map(d => d.toFormattedJSON())
 }
diff --git a/server/controllers/api/plugins.ts b/server/controllers/api/plugins.ts
index 1e6a02c49..3a9ef34e8 100644
--- a/server/controllers/api/plugins.ts
+++ b/server/controllers/api/plugins.ts
@@ -23,8 +23,8 @@ import {
   updatePluginSettingsValidator
 } from '@server/middlewares/validators/plugins'
 import { PluginModel } from '@server/models/server/plugin'
-import { HttpStatusCode } from '@shared/core-utils'
 import {
+  HttpStatusCode,
   InstallOrUpdatePlugin,
   ManagePlugin,
   PeertubePluginIndexList,
diff --git a/server/controllers/api/search/search-video-channels.ts b/server/controllers/api/search/search-video-channels.ts
index 16beeed60..eef222506 100644
--- a/server/controllers/api/search/search-video-channels.ts
+++ b/server/controllers/api/search/search-video-channels.ts
@@ -1,14 +1,14 @@
 import * as express from 'express'
 import { sanitizeUrl } from '@server/helpers/core-utils'
+import { pickSearchChannelQuery } from '@server/helpers/query'
 import { doJSONRequest } from '@server/helpers/requests'
 import { CONFIG } from '@server/initializers/config'
 import { WEBSERVER } from '@server/initializers/constants'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { buildMutedForSearchIndex, isSearchIndexSearch, isURISearch } from '@server/lib/search'
 import { getServerActor } from '@server/models/application/application'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
-import { ResultList, VideoChannel } from '@shared/models'
-import { VideoChannelsSearchQuery } from '../../../../shared/models/search'
+import { HttpStatusCode, ResultList, VideoChannel } from '@shared/models'
+import { VideoChannelsSearchQueryAfterSanitize } from '../../../../shared/models/search'
 import { isUserAbleToSearchRemoteURI } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
@@ -46,8 +46,8 @@ export { searchChannelsRouter }
 // ---------------------------------------------------------------------------
 
 function searchVideoChannels (req: express.Request, res: express.Response) {
-  const query: VideoChannelsSearchQuery = req.query
-  const search = query.search
+  const query = pickSearchChannelQuery(req.query)
+  let search = query.search || ''
 
   const parts = search.split('@')
 
@@ -58,7 +58,7 @@ function searchVideoChannels (req: express.Request, res: express.Response) {
   if (isURISearch(search) || isWebfingerSearch) return searchVideoChannelURI(search, isWebfingerSearch, res)
 
   // @username -> username to search in DB
-  if (query.search.startsWith('@')) query.search = query.search.replace(/^@/, '')
+  if (search.startsWith('@')) search = search.replace(/^@/, '')
 
   if (isSearchIndexSearch(query)) {
     return searchVideoChannelsIndex(query, res)
@@ -67,7 +67,7 @@ function searchVideoChannels (req: express.Request, res: express.Response) {
   return searchVideoChannelsDB(query, res)
 }
 
-async function searchVideoChannelsIndex (query: VideoChannelsSearchQuery, res: express.Response) {
+async function searchVideoChannelsIndex (query: VideoChannelsSearchQueryAfterSanitize, res: express.Response) {
   const result = await buildMutedForSearchIndex(res)
 
   const body = await Hooks.wrapObject(Object.assign(query, result), 'filter:api.search.video-channels.index.list.params')
@@ -91,15 +91,13 @@ async function searchVideoChannelsIndex (query: VideoChannelsSearchQuery, res: e
   }
 }
 
-async function searchVideoChannelsDB (query: VideoChannelsSearchQuery, res: express.Response) {
+async function searchVideoChannelsDB (query: VideoChannelsSearchQueryAfterSanitize, res: express.Response) {
   const serverActor = await getServerActor()
 
   const apiOptions = await Hooks.wrapObject({
-    actorId: serverActor.id,
-    search: query.search,
-    start: query.start,
-    count: query.count,
-    sort: query.sort
+    ...query,
+
+    actorId: serverActor.id
   }, 'filter:api.search.video-channels.local.list.params')
 
   const resultList = await Hooks.wrapPromiseFun(
diff --git a/server/controllers/api/search/search-video-playlists.ts b/server/controllers/api/search/search-video-playlists.ts
index b231ff1e2..0a56f19b7 100644
--- a/server/controllers/api/search/search-video-playlists.ts
+++ b/server/controllers/api/search/search-video-playlists.ts
@@ -2,17 +2,18 @@ import * as express from 'express'
 import { sanitizeUrl } from '@server/helpers/core-utils'
 import { isUserAbleToSearchRemoteURI } from '@server/helpers/express-utils'
 import { logger } from '@server/helpers/logger'
+import { pickSearchPlaylistQuery } from '@server/helpers/query'
 import { doJSONRequest } from '@server/helpers/requests'
 import { getFormattedObjects } from '@server/helpers/utils'
 import { CONFIG } from '@server/initializers/config'
+import { WEBSERVER } from '@server/initializers/constants'
 import { getOrCreateAPVideoPlaylist } from '@server/lib/activitypub/playlists/get'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { buildMutedForSearchIndex, isSearchIndexSearch, isURISearch } from '@server/lib/search'
 import { getServerActor } from '@server/models/application/application'
 import { VideoPlaylistModel } from '@server/models/video/video-playlist'
 import { MVideoPlaylistFullSummary } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
-import { ResultList, VideoPlaylist, VideoPlaylistsSearchQuery } from '@shared/models'
+import { HttpStatusCode, ResultList, VideoPlaylist, VideoPlaylistsSearchQueryAfterSanitize } from '@shared/models'
 import {
   asyncMiddleware,
   openapiOperationDoc,
@@ -23,7 +24,6 @@ import {
   videoPlaylistsListSearchValidator,
   videoPlaylistsSearchSortValidator
 } from '../../../middlewares'
-import { WEBSERVER } from '@server/initializers/constants'
 
 const searchPlaylistsRouter = express.Router()
 
@@ -45,7 +45,7 @@ export { searchPlaylistsRouter }
 // ---------------------------------------------------------------------------
 
 function searchVideoPlaylists (req: express.Request, res: express.Response) {
-  const query: VideoPlaylistsSearchQuery = req.query
+  const query = pickSearchPlaylistQuery(req.query)
   const search = query.search
 
   if (isURISearch(search)) return searchVideoPlaylistsURI(search, res)
@@ -57,7 +57,7 @@ function searchVideoPlaylists (req: express.Request, res: express.Response) {
   return searchVideoPlaylistsDB(query, res)
 }
 
-async function searchVideoPlaylistsIndex (query: VideoPlaylistsSearchQuery, res: express.Response) {
+async function searchVideoPlaylistsIndex (query: VideoPlaylistsSearchQueryAfterSanitize, res: express.Response) {
   const result = await buildMutedForSearchIndex(res)
 
   const body = await Hooks.wrapObject(Object.assign(query, result), 'filter:api.search.video-playlists.index.list.params')
@@ -81,15 +81,13 @@ async function searchVideoPlaylistsIndex (query: VideoPlaylistsSearchQuery, res:
   }
 }
 
-async function searchVideoPlaylistsDB (query: VideoPlaylistsSearchQuery, res: express.Response) {
+async function searchVideoPlaylistsDB (query: VideoPlaylistsSearchQueryAfterSanitize, res: express.Response) {
   const serverActor = await getServerActor()
 
   const apiOptions = await Hooks.wrapObject({
-    followerActorId: serverActor.id,
-    search: query.search,
-    start: query.start,
-    count: query.count,
-    sort: query.sort
+    ...query,
+
+    followerActorId: serverActor.id
   }, 'filter:api.search.video-playlists.local.list.params')
 
   const resultList = await Hooks.wrapPromiseFun(
diff --git a/server/controllers/api/search/search-videos.ts b/server/controllers/api/search/search-videos.ts
index b626baa28..4a6ce0de4 100644
--- a/server/controllers/api/search/search-videos.ts
+++ b/server/controllers/api/search/search-videos.ts
@@ -1,14 +1,14 @@
 import * as express from 'express'
 import { sanitizeUrl } from '@server/helpers/core-utils'
+import { pickSearchVideoQuery } from '@server/helpers/query'
 import { doJSONRequest } from '@server/helpers/requests'
 import { CONFIG } from '@server/initializers/config'
 import { WEBSERVER } from '@server/initializers/constants'
 import { getOrCreateAPVideo } from '@server/lib/activitypub/videos'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { buildMutedForSearchIndex, isSearchIndexSearch, isURISearch } from '@server/lib/search'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
-import { ResultList, Video } from '@shared/models'
-import { VideosSearchQuery } from '../../../../shared/models/search'
+import { HttpStatusCode, ResultList, Video } from '@shared/models'
+import { VideosSearchQueryAfterSanitize } from '../../../../shared/models/search'
 import { buildNSFWFilter, isUserAbleToSearchRemoteURI } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
@@ -47,7 +47,7 @@ export { searchVideosRouter }
 // ---------------------------------------------------------------------------
 
 function searchVideos (req: express.Request, res: express.Response) {
-  const query: VideosSearchQuery = req.query
+  const query = pickSearchVideoQuery(req.query)
   const search = query.search
 
   if (isURISearch(search)) {
@@ -61,10 +61,10 @@ function searchVideos (req: express.Request, res: express.Response) {
   return searchVideosDB(query, res)
 }
 
-async function searchVideosIndex (query: VideosSearchQuery, res: express.Response) {
+async function searchVideosIndex (query: VideosSearchQueryAfterSanitize, res: express.Response) {
   const result = await buildMutedForSearchIndex(res)
 
-  let body: VideosSearchQuery = Object.assign(query, result)
+  let body = { ...query, ...result }
 
   // Use the default instance NSFW policy if not specified
   if (!body.nsfw) {
@@ -98,13 +98,18 @@ async function searchVideosIndex (query: VideosSearchQuery, res: express.Respons
   }
 }
 
-async function searchVideosDB (query: VideosSearchQuery, res: express.Response) {
-  const apiOptions = await Hooks.wrapObject(Object.assign(query, {
+async function searchVideosDB (query: VideosSearchQueryAfterSanitize, res: express.Response) {
+  const apiOptions = await Hooks.wrapObject({
+    ...query,
+
     includeLocalVideos: true,
-    nsfw: buildNSFWFilter(res, query.nsfw),
     filter: query.filter,
-    user: res.locals.oauth ? res.locals.oauth.token.User : undefined
-  }), 'filter:api.search.videos.local.list.params')
+
+    nsfw: buildNSFWFilter(res, query.nsfw),
+    user: res.locals.oauth
+      ? res.locals.oauth.token.User
+      : undefined
+  }, 'filter:api.search.videos.local.list.params')
 
   const resultList = await Hooks.wrapPromiseFun(
     VideoModel.searchAndPopulateAccountAndServer,
diff --git a/server/controllers/api/server/contact.ts b/server/controllers/api/server/contact.ts
index caddc0909..b315e99cf 100644
--- a/server/controllers/api/server/contact.ts
+++ b/server/controllers/api/server/contact.ts
@@ -1,9 +1,9 @@
 import * as express from 'express'
-import { asyncMiddleware, contactAdministratorValidator } from '../../../middlewares'
-import { Redis } from '../../../lib/redis'
-import { Emailer } from '../../../lib/emailer'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { ContactForm } from '../../../../shared/models/server'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { Emailer } from '../../../lib/emailer'
+import { Redis } from '../../../lib/redis'
+import { asyncMiddleware, contactAdministratorValidator } from '../../../middlewares'
 
 const contactRouter = express.Router()
 
@@ -15,7 +15,7 @@ contactRouter.post('/contact',
 async function contactAdministrator (req: express.Request, res: express.Response) {
   const data = req.body as ContactForm
 
-  await Emailer.Instance.addContactFormJob(data.fromEmail, data.fromName, data.subject, data.body)
+  Emailer.Instance.addContactFormJob(data.fromEmail, data.fromName, data.subject, data.body)
 
   await Redis.Instance.setContactFormIp(req.ip)
 
diff --git a/server/controllers/api/server/debug.ts b/server/controllers/api/server/debug.ts
index a6e9147f3..0601b89ce 100644
--- a/server/controllers/api/server/debug.ts
+++ b/server/controllers/api/server/debug.ts
@@ -1,8 +1,8 @@
+import * as express from 'express'
 import { InboxManager } from '@server/lib/activitypub/inbox-manager'
 import { RemoveDanglingResumableUploadsScheduler } from '@server/lib/schedulers/remove-dangling-resumable-uploads-scheduler'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-import { SendDebugCommand } from '@shared/models'
-import * as express from 'express'
+import { Debug, SendDebugCommand } from '@shared/models'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { UserRight } from '../../../../shared/models/users'
 import { authenticate, ensureUserHasRight } from '../../../middlewares'
 
@@ -32,7 +32,7 @@ function getDebug (req: express.Request, res: express.Response) {
   return res.json({
     ip: req.ip,
     activityPubMessagesWaiting: InboxManager.Instance.getActivityPubMessagesWaiting()
-  })
+  } as Debug)
 }
 
 async function runCommand (req: express.Request, res: express.Response) {
diff --git a/server/controllers/api/server/follows.ts b/server/controllers/api/server/follows.ts
index 12357a2ca..cbe6b7e4f 100644
--- a/server/controllers/api/server/follows.ts
+++ b/server/controllers/api/server/follows.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { getServerActor } from '@server/models/application/application'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { UserRight } from '../../../../shared/models/users'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
@@ -29,6 +29,7 @@ import {
   removeFollowingValidator
 } from '../../../middlewares/validators'
 import { ActorFollowModel } from '../../../models/actor/actor-follow'
+import { ServerFollowCreate } from '@shared/models'
 
 const serverFollowsRouter = express.Router()
 serverFollowsRouter.get('/following',
@@ -45,10 +46,10 @@ serverFollowsRouter.post('/following',
   ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
   followValidator,
   setBodyHostsPort,
-  asyncMiddleware(followInstance)
+  asyncMiddleware(addFollow)
 )
 
-serverFollowsRouter.delete('/following/:host',
+serverFollowsRouter.delete('/following/:hostOrHandle',
   authenticate,
   ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
   asyncMiddleware(removeFollowingValidator),
@@ -125,8 +126,8 @@ async function listFollowers (req: express.Request, res: express.Response) {
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function followInstance (req: express.Request, res: express.Response) {
-  const hosts = req.body.hosts as string[]
+async function addFollow (req: express.Request, res: express.Response) {
+  const { hosts, handles } = req.body as ServerFollowCreate
   const follower = await getServerActor()
 
   for (const host of hosts) {
@@ -139,6 +140,18 @@ async function followInstance (req: express.Request, res: express.Response) {
     JobQueue.Instance.createJob({ type: 'activitypub-follow', payload })
   }
 
+  for (const handle of handles) {
+    const [ name, host ] = handle.split('@')
+
+    const payload = {
+      host,
+      name,
+      followerActorId: follower.id
+    }
+
+    JobQueue.Instance.createJob({ type: 'activitypub-follow', payload })
+  }
+
   return res.status(HttpStatusCode.NO_CONTENT_204).end()
 }
 
diff --git a/server/controllers/api/server/index.ts b/server/controllers/api/server/index.ts
index 6b8793a19..32fefefc0 100644
--- a/server/controllers/api/server/index.ts
+++ b/server/controllers/api/server/index.ts
@@ -1,11 +1,11 @@
 import * as express from 'express'
+import { contactRouter } from './contact'
+import { debugRouter } from './debug'
 import { serverFollowsRouter } from './follows'
-import { statsRouter } from './stats'
+import { logsRouter } from './logs'
 import { serverRedundancyRouter } from './redundancy'
 import { serverBlocklistRouter } from './server-blocklist'
-import { contactRouter } from './contact'
-import { logsRouter } from './logs'
-import { debugRouter } from './debug'
+import { statsRouter } from './stats'
 
 const serverRouter = express.Router()
 
diff --git a/server/controllers/api/server/logs.ts b/server/controllers/api/server/logs.ts
index 4b543d686..39eceb654 100644
--- a/server/controllers/api/server/logs.ts
+++ b/server/controllers/api/server/logs.ts
@@ -1,14 +1,13 @@
 import * as express from 'express'
-import { UserRight } from '../../../../shared/models/users'
-import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../../middlewares'
-import { mtimeSortFilesDesc } from '../../../../shared/core-utils/logs/logs'
 import { readdir, readFile } from 'fs-extra'
-import { AUDIT_LOG_FILENAME, MAX_LOGS_OUTPUT_CHARACTERS, LOG_FILENAME } from '../../../initializers/constants'
 import { join } from 'path'
-import { getAuditLogsValidator, getLogsValidator } from '../../../middlewares/validators/logs'
+import { logger, mtimeSortFilesDesc } from '@server/helpers/logger'
 import { LogLevel } from '../../../../shared/models/server/log-level.type'
+import { UserRight } from '../../../../shared/models/users'
 import { CONFIG } from '../../../initializers/config'
-import { logger } from '@server/helpers/logger'
+import { AUDIT_LOG_FILENAME, LOG_FILENAME, MAX_LOGS_OUTPUT_CHARACTERS } from '../../../initializers/constants'
+import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../../middlewares'
+import { getAuditLogsValidator, getLogsValidator } from '../../../middlewares/validators/logs'
 
 const logsRouter = express.Router()
 
diff --git a/server/controllers/api/server/redundancy.ts b/server/controllers/api/server/redundancy.ts
index bc593ad43..99d1c762b 100644
--- a/server/controllers/api/server/redundancy.ts
+++ b/server/controllers/api/server/redundancy.ts
@@ -1,5 +1,10 @@
 import * as express from 'express'
+import { JobQueue } from '@server/lib/job-queue'
+import { VideoRedundancyModel } from '@server/models/redundancy/video-redundancy'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { UserRight } from '../../../../shared/models/users'
+import { logger } from '../../../helpers/logger'
+import { removeRedundanciesOfServer, removeVideoRedundancy } from '../../../lib/redundancy'
 import {
   asyncMiddleware,
   authenticate,
@@ -10,16 +15,11 @@ import {
   videoRedundanciesSortValidator
 } from '../../../middlewares'
 import {
-  listVideoRedundanciesValidator,
-  updateServerRedundancyValidator,
   addVideoRedundancyValidator,
-  removeVideoRedundancyValidator
+  listVideoRedundanciesValidator,
+  removeVideoRedundancyValidator,
+  updateServerRedundancyValidator
 } from '../../../middlewares/validators/redundancy'
-import { removeRedundanciesOfServer, removeVideoRedundancy } from '../../../lib/redundancy'
-import { logger } from '../../../helpers/logger'
-import { VideoRedundancyModel } from '@server/models/redundancy/video-redundancy'
-import { JobQueue } from '@server/lib/job-queue'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 const serverRedundancyRouter = express.Router()
 
diff --git a/server/controllers/api/server/server-blocklist.ts b/server/controllers/api/server/server-blocklist.ts
index a86bc7d19..b3ee50d85 100644
--- a/server/controllers/api/server/server-blocklist.ts
+++ b/server/controllers/api/server/server-blocklist.ts
@@ -1,8 +1,9 @@
 import 'multer'
 import * as express from 'express'
 import { logger } from '@server/helpers/logger'
-import { UserNotificationModel } from '@server/models/user/user-notification'
 import { getServerActor } from '@server/models/application/application'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { UserRight } from '../../../../shared/models/users'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { addAccountInBlocklist, addServerInBlocklist, removeAccountFromBlocklist, removeServerFromBlocklist } from '../../../lib/blocklist'
@@ -25,7 +26,6 @@ import {
 } from '../../../middlewares/validators'
 import { AccountBlocklistModel } from '../../../models/account/account-blocklist'
 import { ServerBlocklistModel } from '../../../models/server/server-blocklist'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 const serverBlocklistRouter = express.Router()
 
diff --git a/server/controllers/api/server/stats.ts b/server/controllers/api/server/stats.ts
index 3aea12450..397702548 100644
--- a/server/controllers/api/server/stats.ts
+++ b/server/controllers/api/server/stats.ts
@@ -2,12 +2,12 @@ import * as express from 'express'
 import { StatsManager } from '@server/lib/stat-manager'
 import { ROUTE_CACHE_LIFETIME } from '../../../initializers/constants'
 import { asyncMiddleware } from '../../../middlewares'
-import { cacheRoute } from '../../../middlewares/cache'
+import { cacheRoute } from '../../../middlewares/cache/cache'
 
 const statsRouter = express.Router()
 
 statsRouter.get('/stats',
-  asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.STATS)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.STATS),
   asyncMiddleware(getStats)
 )
 
diff --git a/server/controllers/api/users/index.ts b/server/controllers/api/users/index.ts
index d907b49bf..be800e8b5 100644
--- a/server/controllers/api/users/index.ts
+++ b/server/controllers/api/users/index.ts
@@ -4,8 +4,8 @@ import { tokensRouter } from '@server/controllers/api/users/token'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { OAuthTokenModel } from '@server/models/oauth/oauth-token'
 import { MUser, MUserAccountDefault } from '@server/types/models'
-import { UserCreate, UserRight, UserRole, UserUpdate } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { UserCreate, UserCreateResult, UserRight, UserRole, UserUpdate } from '../../../../shared'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
 import { UserRegister } from '../../../../shared/models/users/user-register.model'
 import { auditLoggerFactory, getAuditIdFromRes, UserAuditView } from '../../../helpers/audit-logger'
@@ -220,7 +220,7 @@ async function createUser (req: express.Request, res: express.Response) {
       account: {
         id: account.id
       }
-    }
+    } as UserCreateResult
   })
 }
 
diff --git a/server/controllers/api/users/me.ts b/server/controllers/api/users/me.ts
index 1f2b2f9dd..ac6faca9c 100644
--- a/server/controllers/api/users/me.ts
+++ b/server/controllers/api/users/me.ts
@@ -2,8 +2,9 @@ import 'multer'
 import * as express from 'express'
 import { auditLoggerFactory, getAuditIdFromRes, UserAuditView } from '@server/helpers/audit-logger'
 import { Hooks } from '@server/lib/plugins/hooks'
+import { AttributesOnly } from '@shared/core-utils'
 import { ActorImageType, UserUpdateMe, UserVideoRate as FormattedUserVideoRate } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { UserVideoQuota } from '../../../../shared/models/users/user-video-quota.model'
 import { createReqFiles } from '../../../helpers/express-utils'
 import { getFormattedObjects } from '../../../helpers/utils'
@@ -31,7 +32,6 @@ import { AccountVideoRateModel } from '../../../models/account/account-video-rat
 import { UserModel } from '../../../models/user/user'
 import { VideoModel } from '../../../models/video/video'
 import { VideoImportModel } from '../../../models/video/video-import'
-import { AttributesOnly } from '@shared/core-utils'
 
 const auditLogger = auditLoggerFactory('users')
 
diff --git a/server/controllers/api/users/my-blocklist.ts b/server/controllers/api/users/my-blocklist.ts
index a1561b751..24fff83e3 100644
--- a/server/controllers/api/users/my-blocklist.ts
+++ b/server/controllers/api/users/my-blocklist.ts
@@ -1,6 +1,10 @@
-import * as express from 'express'
 import 'multer'
+import * as express from 'express'
+import { logger } from '@server/helpers/logger'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { getFormattedObjects } from '../../../helpers/utils'
+import { addAccountInBlocklist, addServerInBlocklist, removeAccountFromBlocklist, removeServerFromBlocklist } from '../../../lib/blocklist'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -18,11 +22,7 @@ import {
   unblockServerByAccountValidator
 } from '../../../middlewares/validators'
 import { AccountBlocklistModel } from '../../../models/account/account-blocklist'
-import { addAccountInBlocklist, addServerInBlocklist, removeAccountFromBlocklist, removeServerFromBlocklist } from '../../../lib/blocklist'
 import { ServerBlocklistModel } from '../../../models/server/server-blocklist'
-import { UserNotificationModel } from '@server/models/user/user-notification'
-import { logger } from '@server/helpers/logger'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 const myBlocklistRouter = express.Router()
 
diff --git a/server/controllers/api/users/my-history.ts b/server/controllers/api/users/my-history.ts
index cff1697ab..a6e723103 100644
--- a/server/controllers/api/users/my-history.ts
+++ b/server/controllers/api/users/my-history.ts
@@ -1,4 +1,7 @@
 import * as express from 'express'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
+import { getFormattedObjects } from '../../../helpers/utils'
+import { sequelizeTypescript } from '../../../initializers/database'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -8,10 +11,7 @@ import {
   userHistoryListValidator,
   userHistoryRemoveValidator
 } from '../../../middlewares'
-import { getFormattedObjects } from '../../../helpers/utils'
 import { UserVideoHistoryModel } from '../../../models/user/user-video-history'
-import { sequelizeTypescript } from '../../../initializers/database'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 const myVideosHistoryRouter = express.Router()
 
diff --git a/server/controllers/api/users/my-notifications.ts b/server/controllers/api/users/my-notifications.ts
index 2909770da..3beee07c0 100644
--- a/server/controllers/api/users/my-notifications.ts
+++ b/server/controllers/api/users/my-notifications.ts
@@ -1,7 +1,7 @@
 import 'multer'
 import * as express from 'express'
 import { UserNotificationModel } from '@server/models/user/user-notification'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { UserNotificationSetting } from '../../../../shared/models/users'
 import { getFormattedObjects } from '../../../helpers/utils'
 import {
diff --git a/server/controllers/api/users/my-subscriptions.ts b/server/controllers/api/users/my-subscriptions.ts
index 46a73d49e..26a715704 100644
--- a/server/controllers/api/users/my-subscriptions.ts
+++ b/server/controllers/api/users/my-subscriptions.ts
@@ -1,9 +1,9 @@
 import 'multer'
 import * as express from 'express'
+import { pickCommonVideoQuery } from '@server/helpers/query'
 import { sendUndoFollow } from '@server/lib/activitypub/send'
 import { VideoChannelModel } from '@server/models/video/video-channel'
-import { VideosCommonQuery } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { buildNSFWFilter, getCountVideos } from '../../../helpers/express-utils'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { WEBSERVER } from '../../../initializers/constants'
@@ -170,20 +170,13 @@ async function getUserSubscriptions (req: express.Request, res: express.Response
 async function getUserSubscriptionVideos (req: express.Request, res: express.Response) {
   const user = res.locals.oauth.token.User
   const countVideos = getCountVideos(req)
-  const query = req.query as VideosCommonQuery
+  const query = pickCommonVideoQuery(req.query)
 
   const resultList = await VideoModel.listForApi({
-    start: query.start,
-    count: query.count,
-    sort: query.sort,
+    ...query,
+
     includeLocalVideos: false,
-    categoryOneOf: query.categoryOneOf,
-    licenceOneOf: query.licenceOneOf,
-    languageOneOf: query.languageOneOf,
-    tagsOneOf: query.tagsOneOf,
-    tagsAllOf: query.tagsAllOf,
     nsfw: buildNSFWFilter(res, query.nsfw),
-    filter: query.filter,
     withFiles: false,
     followerActorId: user.Account.Actor.id,
     user,
diff --git a/server/controllers/api/users/my-video-playlists.ts b/server/controllers/api/users/my-video-playlists.ts
index d0bd99463..76e741ba5 100644
--- a/server/controllers/api/users/my-video-playlists.ts
+++ b/server/controllers/api/users/my-video-playlists.ts
@@ -1,8 +1,8 @@
 import * as express from 'express'
+import { VideosExistInPlaylists } from '../../../../shared/models/videos/playlist/video-exist-in-playlist.model'
 import { asyncMiddleware, authenticate } from '../../../middlewares'
 import { doVideosInPlaylistExistValidator } from '../../../middlewares/validators/videos/video-playlists'
 import { VideoPlaylistModel } from '../../../models/video/video-playlist'
-import { VideosExistInPlaylists } from '../../../../shared/models/videos/playlist/video-exist-in-playlist.model'
 
 const myVideoPlaylistsRouter = express.Router()
 
diff --git a/server/controllers/api/video-channel.ts b/server/controllers/api/video-channel.ts
index bc8d203b0..7bdb33737 100644
--- a/server/controllers/api/video-channel.ts
+++ b/server/controllers/api/video-channel.ts
@@ -1,9 +1,10 @@
 import * as express from 'express'
+import { pickCommonVideoQuery } from '@server/helpers/query'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { getServerActor } from '@server/models/application/application'
 import { MChannelBannerAccountDefault } from '@server/types/models'
-import { ActorImageType, VideoChannelCreate, VideoChannelUpdate, VideosCommonQuery } from '../../../shared'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { ActorImageType, VideoChannelCreate, VideoChannelUpdate } from '../../../shared'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { auditLoggerFactory, getAuditIdFromRes, VideoChannelAuditView } from '../../helpers/audit-logger'
 import { resetSequelizeInstance } from '../../helpers/database-utils'
 import { buildNSFWFilter, createReqFiles, getCountVideos, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
@@ -309,20 +310,13 @@ async function listVideoChannelVideos (req: express.Request, res: express.Respon
   const videoChannelInstance = res.locals.videoChannel
   const followerActorId = isUserAbleToSearchRemoteURI(res) ? null : undefined
   const countVideos = getCountVideos(req)
-  const query = req.query as VideosCommonQuery
+  const query = pickCommonVideoQuery(req.query)
 
   const apiOptions = await Hooks.wrapObject({
+    ...query,
+
     followerActorId,
-    start: query.start,
-    count: query.count,
-    sort: query.sort,
     includeLocalVideos: true,
-    categoryOneOf: query.categoryOneOf,
-    licenceOneOf: query.licenceOneOf,
-    languageOneOf: query.languageOneOf,
-    tagsOneOf: query.tagsOneOf,
-    tagsAllOf: query.tagsAllOf,
-    filter: query.filter,
     nsfw: buildNSFWFilter(res, query.nsfw),
     withFiles: false,
     videoChannelId: videoChannelInstance.id,
diff --git a/server/controllers/api/video-playlist.ts b/server/controllers/api/video-playlist.ts
index 87a6f6bbe..4971d0a77 100644
--- a/server/controllers/api/video-playlist.ts
+++ b/server/controllers/api/video-playlist.ts
@@ -5,7 +5,8 @@ import { scheduleRefreshIfNeeded } from '@server/lib/activitypub/playlists'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { getServerActor } from '@server/models/application/application'
 import { MVideoPlaylistFull, MVideoPlaylistThumbnail, MVideoThumbnail } from '@server/types/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { VideoPlaylistCreateResult, VideoPlaylistElementCreateResult } from '@shared/models'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { VideoPlaylistCreate } from '../../../shared/models/videos/playlist/video-playlist-create.model'
 import { VideoPlaylistElementCreate } from '../../../shared/models/videos/playlist/video-playlist-element-create.model'
 import { VideoPlaylistElementUpdate } from '../../../shared/models/videos/playlist/video-playlist-element-update.model'
@@ -202,7 +203,7 @@ async function addVideoPlaylist (req: express.Request, res: express.Response) {
       id: videoPlaylistCreated.id,
       shortUUID: uuidToShort(videoPlaylistCreated.uuid),
       uuid: videoPlaylistCreated.uuid
-    }
+    } as VideoPlaylistCreateResult
   })
 }
 
@@ -338,8 +339,8 @@ async function addVideoInPlaylist (req: express.Request, res: express.Response)
   return res.json({
     videoPlaylistElement: {
       id: playlistElement.id
-    }
-  }).end()
+    } as VideoPlaylistElementCreateResult
+  })
 }
 
 async function updateVideoPlaylistElement (req: express.Request, res: express.Response) {
diff --git a/server/controllers/api/videos/blacklist.ts b/server/controllers/api/videos/blacklist.ts
index 530e17965..6bc768471 100644
--- a/server/controllers/api/videos/blacklist.ts
+++ b/server/controllers/api/videos/blacklist.ts
@@ -1,6 +1,7 @@
 import * as express from 'express'
 import { blacklistVideo, unblacklistVideo } from '@server/lib/video-blacklist'
 import { UserRight, VideoBlacklistCreate } from '../../../../shared'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { sequelizeTypescript } from '../../../initializers/database'
@@ -19,7 +20,6 @@ import {
   videosBlacklistUpdateValidator
 } from '../../../middlewares'
 import { VideoBlacklistModel } from '../../../models/video/video-blacklist'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 const blacklistRouter = express.Router()
 
diff --git a/server/controllers/api/videos/captions.ts b/server/controllers/api/videos/captions.ts
index ad7423a31..4008de60f 100644
--- a/server/controllers/api/videos/captions.ts
+++ b/server/controllers/api/videos/captions.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { MVideoCaption } from '@server/types/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { moveAndProcessCaptionFile } from '../../../helpers/captions-utils'
 import { createReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
diff --git a/server/controllers/api/videos/comment.ts b/server/controllers/api/videos/comment.ts
index e6f28c1cb..cb696f652 100644
--- a/server/controllers/api/videos/comment.ts
+++ b/server/controllers/api/videos/comment.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-import { ResultList, ThreadsResultList, UserRight } from '../../../../shared/models'
-import { VideoCommentCreate } from '../../../../shared/models/videos/comment/video-comment.model'
+import { ResultList, ThreadsResultList, UserRight, VideoCommentCreate } from '../../../../shared/models'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
+import { VideoCommentThreads } from '../../../../shared/models/videos/comment/video-comment.model'
 import { auditLoggerFactory, CommentAuditView, getAuditIdFromRes } from '../../../helpers/audit-logger'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { sequelizeTypescript } from '../../../initializers/database'
@@ -136,7 +136,7 @@ async function listVideoThreads (req: express.Request, res: express.Response) {
   return res.json({
     ...getFormattedObjects(resultList.data, resultList.total),
     totalNotDeletedComments: resultList.totalNotDeletedComments
-  })
+  } as VideoCommentThreads)
 }
 
 async function listVideoThreadComments (req: express.Request, res: express.Response) {
diff --git a/server/controllers/api/videos/index.ts b/server/controllers/api/videos/index.ts
index 74b100e59..49490f79b 100644
--- a/server/controllers/api/videos/index.ts
+++ b/server/controllers/api/videos/index.ts
@@ -1,12 +1,12 @@
 import * as express from 'express'
 import toInt from 'validator/lib/toInt'
+import { pickCommonVideoQuery } from '@server/helpers/query'
 import { doJSONRequest } from '@server/helpers/requests'
 import { LiveManager } from '@server/lib/live'
 import { openapiOperationDoc } from '@server/middlewares/doc'
 import { getServerActor } from '@server/models/application/application'
 import { MVideoAccountLight } from '@server/types/models'
-import { VideosCommonQuery } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs'
+import { HttpStatusCode } from '../../../../shared/models'
 import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
 import { buildNSFWFilter, getCountVideos } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
@@ -211,22 +211,14 @@ async function getVideoFileMetadata (req: express.Request, res: express.Response
 }
 
 async function listVideos (req: express.Request, res: express.Response) {
-  const query = req.query as VideosCommonQuery
+  const query = pickCommonVideoQuery(req.query)
   const countVideos = getCountVideos(req)
 
   const apiOptions = await Hooks.wrapObject({
-    start: query.start,
-    count: query.count,
-    sort: query.sort,
+    ...query,
+
     includeLocalVideos: true,
-    categoryOneOf: query.categoryOneOf,
-    licenceOneOf: query.licenceOneOf,
-    languageOneOf: query.languageOneOf,
-    tagsOneOf: query.tagsOneOf,
-    tagsAllOf: query.tagsAllOf,
     nsfw: buildNSFWFilter(res, query.nsfw),
-    isLive: query.isLive,
-    filter: query.filter,
     withFiles: false,
     user: res.locals.oauth ? res.locals.oauth.token.User : undefined,
     countVideos
diff --git a/server/controllers/api/videos/live.ts b/server/controllers/api/videos/live.ts
index d8c51c2d4..ed4da8f47 100644
--- a/server/controllers/api/videos/live.ts
+++ b/server/controllers/api/videos/live.ts
@@ -11,7 +11,7 @@ import { videoLiveAddValidator, videoLiveGetValidator, videoLiveUpdateValidator
 import { VideoLiveModel } from '@server/models/video/video-live'
 import { MVideoDetails, MVideoFullLight } from '@server/types/models'
 import { LiveVideoCreate, LiveVideoUpdate, VideoState } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { logger } from '../../../helpers/logger'
 import { sequelizeTypescript } from '../../../initializers/database'
 import { updateVideoMiniatureFromExisting } from '../../../lib/thumbnail'
diff --git a/server/controllers/api/videos/ownership.ts b/server/controllers/api/videos/ownership.ts
index 1bb96e046..f48acbc68 100644
--- a/server/controllers/api/videos/ownership.ts
+++ b/server/controllers/api/videos/ownership.ts
@@ -1,6 +1,12 @@
 import * as express from 'express'
+import { MVideoFullLight } from '@server/types/models'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
+import { VideoChangeOwnershipStatus, VideoState } from '../../../../shared/models/videos'
 import { logger } from '../../../helpers/logger'
+import { getFormattedObjects } from '../../../helpers/utils'
 import { sequelizeTypescript } from '../../../initializers/database'
+import { sendUpdateVideo } from '../../../lib/activitypub/send'
+import { changeVideoChannelShare } from '../../../lib/activitypub/share'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -11,15 +17,9 @@ import {
   videosChangeOwnershipValidator,
   videosTerminateChangeOwnershipValidator
 } from '../../../middlewares'
+import { VideoModel } from '../../../models/video/video'
 import { VideoChangeOwnershipModel } from '../../../models/video/video-change-ownership'
-import { VideoChangeOwnershipStatus, VideoState } from '../../../../shared/models/videos'
 import { VideoChannelModel } from '../../../models/video/video-channel'
-import { getFormattedObjects } from '../../../helpers/utils'
-import { changeVideoChannelShare } from '../../../lib/activitypub/share'
-import { sendUpdateVideo } from '../../../lib/activitypub/send'
-import { VideoModel } from '../../../models/video/video'
-import { MVideoFullLight } from '@server/types/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 const ownershipVideoRouter = express.Router()
 
diff --git a/server/controllers/api/videos/rate.ts b/server/controllers/api/videos/rate.ts
index 84f42633e..96f6cd886 100644
--- a/server/controllers/api/videos/rate.ts
+++ b/server/controllers/api/videos/rate.ts
@@ -1,13 +1,13 @@
 import * as express from 'express'
 import { UserVideoRateUpdate } from '../../../../shared'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { logger } from '../../../helpers/logger'
 import { VIDEO_RATE_TYPES } from '../../../initializers/constants'
+import { sequelizeTypescript } from '../../../initializers/database'
 import { getLocalRateUrl, sendVideoRateChange } from '../../../lib/activitypub/video-rates'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videoUpdateRateValidator } from '../../../middlewares'
 import { AccountModel } from '../../../models/account/account'
 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
-import { sequelizeTypescript } from '../../../initializers/database'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 const rateVideoRouter = express.Router()
 
diff --git a/server/controllers/api/videos/update.ts b/server/controllers/api/videos/update.ts
index 8affe71c6..49639060b 100644
--- a/server/controllers/api/videos/update.ts
+++ b/server/controllers/api/videos/update.ts
@@ -2,10 +2,11 @@ import * as express from 'express'
 import { Transaction } from 'sequelize/types'
 import { changeVideoChannelShare } from '@server/lib/activitypub/share'
 import { buildVideoThumbnailsFromReq, setVideoTags } from '@server/lib/video'
+import { openapiOperationDoc } from '@server/middlewares/doc'
 import { FilteredModelAttributes } from '@server/types'
 import { MVideoFullLight } from '@server/types/models'
 import { VideoUpdate } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs'
+import { HttpStatusCode } from '../../../../shared/models'
 import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
 import { resetSequelizeInstance } from '../../../helpers/database-utils'
 import { createReqFiles } from '../../../helpers/express-utils'
@@ -20,7 +21,6 @@ import { autoBlacklistVideoIfNeeded } from '../../../lib/video-blacklist'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videosUpdateValidator } from '../../../middlewares'
 import { ScheduleVideoUpdateModel } from '../../../models/video/schedule-video-update'
 import { VideoModel } from '../../../models/video/video'
-import { openapiOperationDoc } from '@server/middlewares/doc'
 
 const lTags = loggerTagsFactory('api', 'video')
 const auditLogger = auditLoggerFactory('videos')
diff --git a/server/controllers/api/videos/upload.ts b/server/controllers/api/videos/upload.ts
index bcd21ac99..408f677ff 100644
--- a/server/controllers/api/videos/upload.ts
+++ b/server/controllers/api/videos/upload.ts
@@ -6,12 +6,12 @@ import { uuidToShort } from '@server/helpers/uuid'
 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
 import { getLocalVideoActivityPubUrl } from '@server/lib/activitypub/url'
 import { addOptimizeOrMergeAudioJob, buildLocalVideoFromReq, buildVideoThumbnailsFromReq, setVideoTags } from '@server/lib/video'
-import { generateVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
+import { generateWebTorrentVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
 import { openapiOperationDoc } from '@server/middlewares/doc'
 import { MVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
 import { uploadx } from '@uploadx/core'
 import { VideoCreate, VideoState } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs'
+import { HttpStatusCode } from '../../../../shared/models'
 import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { createReqFiles } from '../../../helpers/express-utils'
@@ -209,10 +209,12 @@ async function addVideo (options: {
   })
 
   createTorrentFederate(video, videoFile)
+    .then(() => {
+      if (video.state !== VideoState.TO_TRANSCODE) return
 
-  if (video.state === VideoState.TO_TRANSCODE) {
-    await addOptimizeOrMergeAudioJob(videoCreated, videoFile, user)
-  }
+      return addOptimizeOrMergeAudioJob(videoCreated, videoFile, user)
+    })
+    .catch(err => logger.error('Cannot add optimize/merge audio job for %s.', videoCreated.uuid, { err, ...lTags(videoCreated.uuid) }))
 
   Hooks.runAction('action:api.video.uploaded', { video: videoCreated })
 
@@ -240,7 +242,7 @@ async function buildNewFile (video: MVideo, videoPhysicalFile: express.VideoUplo
     videoFile.resolution = (await getVideoFileResolution(videoPhysicalFile.path)).videoFileResolution
   }
 
-  videoFile.filename = generateVideoFilename(video, false, videoFile.resolution, videoFile.extname)
+  videoFile.filename = generateWebTorrentVideoFilename(videoFile.resolution, videoFile.extname)
 
   return videoFile
 }
@@ -259,9 +261,9 @@ async function createTorrentAndSetInfoHashAsync (video: MVideo, fileArg: MVideoF
   return refreshedFile.save()
 }
 
-function createTorrentFederate (video: MVideoFullLight, videoFile: MVideoFile): void {
+function createTorrentFederate (video: MVideoFullLight, videoFile: MVideoFile) {
   // Create the torrent file in async way because it could be long
-  createTorrentAndSetInfoHashAsync(video, videoFile)
+  return createTorrentAndSetInfoHashAsync(video, videoFile)
     .catch(err => logger.error('Cannot create torrent file for video %s', video.url, { err, ...lTags(video.uuid) }))
     .then(() => VideoModel.loadAndPopulateAccountAndServerAndTags(video.id))
     .then(refreshedVideo => {
diff --git a/server/controllers/api/videos/watching.ts b/server/controllers/api/videos/watching.ts
index 8b15525aa..05c75e543 100644
--- a/server/controllers/api/videos/watching.ts
+++ b/server/controllers/api/videos/watching.ts
@@ -1,5 +1,6 @@
 import * as express from 'express'
 import { UserWatchingVideo } from '../../../../shared'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -8,7 +9,6 @@ import {
   videoWatchingValidator
 } from '../../../middlewares'
 import { UserVideoHistoryModel } from '../../../models/user/user-video-history'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 const watchingRouter = express.Router()
 
diff --git a/server/controllers/bots.ts b/server/controllers/bots.ts
index 9e92063d4..de0411608 100644
--- a/server/controllers/bots.ts
+++ b/server/controllers/bots.ts
@@ -1,20 +1,20 @@
 import * as express from 'express'
-import { asyncMiddleware } from '../middlewares'
-import { ROUTE_CACHE_LIFETIME, WEBSERVER } from '../initializers/constants'
+import { truncate } from 'lodash'
 import { SitemapStream, streamToPromise } from 'sitemap'
+import { buildNSFWFilter } from '../helpers/express-utils'
+import { ROUTE_CACHE_LIFETIME, WEBSERVER } from '../initializers/constants'
+import { asyncMiddleware } from '../middlewares'
+import { cacheRoute } from '../middlewares/cache/cache'
+import { AccountModel } from '../models/account/account'
 import { VideoModel } from '../models/video/video'
 import { VideoChannelModel } from '../models/video/video-channel'
-import { AccountModel } from '../models/account/account'
-import { cacheRoute } from '../middlewares/cache'
-import { buildNSFWFilter } from '../helpers/express-utils'
-import { truncate } from 'lodash'
 
 const botsRouter = express.Router()
 
 // Special route that add OpenGraph and oEmbed tags
 // Do not use a template engine for a so little thing
 botsRouter.use('/sitemap.xml',
-  asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.SITEMAP)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.SITEMAP),
   asyncMiddleware(getSitemap)
 )
 
@@ -75,13 +75,13 @@ async function getSitemapLocalVideoUrls () {
   })
 
   return data.map(v => ({
-    url: WEBSERVER.URL + '/w/' + v.uuid,
+    url: WEBSERVER.URL + v.getWatchStaticPath(),
     video: [
       {
         title: v.name,
         // Sitemap description should be < 2000 characters
         description: truncate(v.description || v.name, { length: 2000, omission: '...' }),
-        player_loc: WEBSERVER.URL + '/videos/embed/' + v.uuid,
+        player_loc: WEBSERVER.URL + v.getEmbedStaticPath(),
         thumbnail_loc: WEBSERVER.URL + v.getMiniatureStaticPath()
       }
     ]
diff --git a/server/controllers/client.ts b/server/controllers/client.ts
index eb1ee6cbd..ba3c54440 100644
--- a/server/controllers/client.ts
+++ b/server/controllers/client.ts
@@ -5,7 +5,7 @@ import { join } from 'path'
 import { logger } from '@server/helpers/logger'
 import { CONFIG } from '@server/initializers/config'
 import { Hooks } from '@server/lib/plugins/hooks'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 import { buildFileLocale, getCompleteLocale, is18nLocale, LOCALE_FILES } from '@shared/core-utils/i18n'
 import { root } from '../helpers/core-utils'
 import { STATIC_MAX_AGE } from '../initializers/constants'
diff --git a/server/controllers/download.ts b/server/controllers/download.ts
index 4293a32e2..ddacc1b68 100644
--- a/server/controllers/download.ts
+++ b/server/controllers/download.ts
@@ -5,8 +5,7 @@ import { VideosTorrentCache } from '@server/lib/files-cache/videos-torrent-cache
 import { Hooks } from '@server/lib/plugins/hooks'
 import { getVideoFilePath } from '@server/lib/video-paths'
 import { MStreamingPlaylist, MVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
-import { VideoStreamingPlaylistType } from '@shared/models'
+import { HttpStatusCode, VideoStreamingPlaylistType } from '@shared/models'
 import { STATIC_DOWNLOAD_PATHS } from '../initializers/constants'
 import { asyncMiddleware, videosDownloadValidator } from '../middlewares'
 
diff --git a/server/controllers/feeds.ts b/server/controllers/feeds.ts
index 435b12193..9fa70a7c8 100644
--- a/server/controllers/feeds.ts
+++ b/server/controllers/feeds.ts
@@ -16,20 +16,20 @@ import {
   videosSortValidator,
   videoSubscriptionFeedsValidator
 } from '../middlewares'
-import { cacheRoute } from '../middlewares/cache'
+import { cacheRouteFactory } from '../middlewares/cache/cache'
 import { VideoModel } from '../models/video/video'
 import { VideoCommentModel } from '../models/video/video-comment'
 
 const feedsRouter = express.Router()
 
+const cacheRoute = cacheRouteFactory({
+  headerBlacklist: [ 'Content-Type' ]
+})
+
 feedsRouter.get('/feeds/video-comments.:format',
   feedsFormatValidator,
   setFeedFormatContentType,
-  asyncMiddleware(cacheRoute({
-    headerBlacklist: [
-      'Content-Type'
-    ]
-  })(ROUTE_CACHE_LIFETIME.FEEDS)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.FEEDS),
   asyncMiddleware(videoFeedsValidator),
   asyncMiddleware(videoCommentsFeedsValidator),
   asyncMiddleware(generateVideoCommentsFeed)
@@ -40,11 +40,7 @@ feedsRouter.get('/feeds/videos.:format',
   setDefaultVideosSort,
   feedsFormatValidator,
   setFeedFormatContentType,
-  asyncMiddleware(cacheRoute({
-    headerBlacklist: [
-      'Content-Type'
-    ]
-  })(ROUTE_CACHE_LIFETIME.FEEDS)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.FEEDS),
   commonVideosFiltersValidator,
   asyncMiddleware(videoFeedsValidator),
   asyncMiddleware(generateVideoFeed)
@@ -55,11 +51,7 @@ feedsRouter.get('/feeds/subscriptions.:format',
   setDefaultVideosSort,
   feedsFormatValidator,
   setFeedFormatContentType,
-  asyncMiddleware(cacheRoute({
-    headerBlacklist: [
-      'Content-Type'
-    ]
-  })(ROUTE_CACHE_LIFETIME.FEEDS)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.FEEDS),
   commonVideosFiltersValidator,
   asyncMiddleware(videoSubscriptionFeedsValidator),
   asyncMiddleware(generateVideoFeedForSubscriptions)
@@ -294,7 +286,7 @@ function addVideosToFeed (feed, videos: VideoModel[]) {
     feed.addItem({
       title: video.name,
       id: video.url,
-      link: WEBSERVER.URL + '/w/' + video.uuid,
+      link: WEBSERVER.URL + video.getWatchStaticPath(),
       description: video.getTruncatedDescription(),
       content: video.description,
       author: [
diff --git a/server/controllers/lazy-static.ts b/server/controllers/lazy-static.ts
index 9a7dacba0..632e4dcd8 100644
--- a/server/controllers/lazy-static.ts
+++ b/server/controllers/lazy-static.ts
@@ -1,7 +1,7 @@
 import * as cors from 'cors'
 import * as express from 'express'
 import { VideosTorrentCache } from '@server/lib/files-cache/videos-torrent-cache'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { logger } from '../helpers/logger'
 import { LAZY_STATIC_PATHS, STATIC_MAX_AGE } from '../initializers/constants'
 import { VideosCaptionCache, VideosPreviewCache } from '../lib/files-cache'
diff --git a/server/controllers/live.ts b/server/controllers/live.ts
index f2686fb23..95d5c0135 100644
--- a/server/controllers/live.ts
+++ b/server/controllers/live.ts
@@ -2,7 +2,7 @@ import * as cors from 'cors'
 import * as express from 'express'
 import { mapToJSON } from '@server/helpers/core-utils'
 import { LiveSegmentShaStore } from '@server/lib/live'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '@shared/models'
 
 const liveRouter = express.Router()
 
diff --git a/server/controllers/plugins.ts b/server/controllers/plugins.ts
index 7213e3f15..11ab3f10a 100644
--- a/server/controllers/plugins.ts
+++ b/server/controllers/plugins.ts
@@ -3,7 +3,7 @@ import { join } from 'path'
 import { logger } from '@server/helpers/logger'
 import { optionalAuthenticate } from '@server/middlewares/auth'
 import { getCompleteLocale, is18nLocale } from '../../shared/core-utils/i18n'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { PluginType } from '../../shared/models/plugins/plugin.type'
 import { isTestInstance } from '../helpers/core-utils'
 import { PLUGIN_GLOBAL_CSS_PATH } from '../initializers/constants'
diff --git a/server/controllers/static.ts b/server/controllers/static.ts
index 35e024dda..912d7e36c 100644
--- a/server/controllers/static.ts
+++ b/server/controllers/static.ts
@@ -3,7 +3,7 @@ import * as express from 'express'
 import { join } from 'path'
 import { serveIndexHTML } from '@server/lib/client-html'
 import { ServerConfigManager } from '@server/lib/server-config-manager'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '@shared/models'
 import { HttpNodeinfoDiasporaSoftwareNsSchema20 } from '../../shared/models/nodeinfo/nodeinfo.model'
 import { root } from '../helpers/core-utils'
 import { CONFIG, isEmailEnabled } from '../initializers/config'
@@ -19,7 +19,7 @@ import {
 } from '../initializers/constants'
 import { getThemeOrDefault } from '../lib/plugins/theme-utils'
 import { asyncMiddleware } from '../middlewares'
-import { cacheRoute } from '../middlewares/cache'
+import { cacheRoute } from '../middlewares/cache/cache'
 import { UserModel } from '../models/user/user'
 import { VideoModel } from '../models/video/video'
 import { VideoCommentModel } from '../models/video/video-comment'
@@ -66,7 +66,7 @@ staticRouter.use(
 
 // robots.txt service
 staticRouter.get('/robots.txt',
-  asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.ROBOTS)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.ROBOTS),
   (_, res: express.Response) => {
     res.type('text/plain')
     return res.send(CONFIG.INSTANCE.ROBOTS)
@@ -86,7 +86,7 @@ staticRouter.get('/security.txt',
 )
 
 staticRouter.get('/.well-known/security.txt',
-  asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.SECURITYTXT)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.SECURITYTXT),
   (_, res: express.Response) => {
     res.type('text/plain')
     return res.send(CONFIG.INSTANCE.SECURITYTXT + CONFIG.INSTANCE.SECURITYTXT_CONTACT)
@@ -95,7 +95,7 @@ staticRouter.get('/.well-known/security.txt',
 
 // nodeinfo service
 staticRouter.use('/.well-known/nodeinfo',
-  asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.NODEINFO)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.NODEINFO),
   (_, res: express.Response) => {
     return res.json({
       links: [
@@ -108,13 +108,13 @@ staticRouter.use('/.well-known/nodeinfo',
   }
 )
 staticRouter.use('/nodeinfo/:version.json',
-  asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.NODEINFO)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.NODEINFO),
   asyncMiddleware(generateNodeinfo)
 )
 
 // dnt-policy.txt service (see https://www.eff.org/dnt-policy)
 staticRouter.use('/.well-known/dnt-policy.txt',
-  asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.DNT_POLICY)),
+  cacheRoute(ROUTE_CACHE_LIFETIME.DNT_POLICY),
   (_, res: express.Response) => {
     res.type('text/plain')
 
diff --git a/server/helpers/custom-validators/follows.ts b/server/helpers/custom-validators/follows.ts
index fbef7ad87..8f65552c3 100644
--- a/server/helpers/custom-validators/follows.ts
+++ b/server/helpers/custom-validators/follows.ts
@@ -1,4 +1,4 @@
-import { exists } from './misc'
+import { exists, isArray } from './misc'
 import { FollowState } from '@shared/models'
 
 function isFollowStateValid (value: FollowState) {
@@ -7,8 +7,24 @@ function isFollowStateValid (value: FollowState) {
   return value === 'pending' || value === 'accepted'
 }
 
+function isRemoteHandleValid (value: string) {
+  if (!exists(value)) return false
+  if (typeof value !== 'string') return false
+
+  return value.includes('@')
+}
+
+function isEachUniqueHandleValid (handles: string[]) {
+  return isArray(handles) &&
+    handles.every(handle => {
+      return isRemoteHandleValid(handle) && handles.indexOf(handle) === handles.lastIndexOf(handle)
+    })
+}
+
 // ---------------------------------------------------------------------------
 
 export {
-  isFollowStateValid
+  isFollowStateValid,
+  isRemoteHandleValid,
+  isEachUniqueHandleValid
 }
diff --git a/server/helpers/custom-validators/misc.ts b/server/helpers/custom-validators/misc.ts
index 528bfcfb8..c19a3e5eb 100644
--- a/server/helpers/custom-validators/misc.ts
+++ b/server/helpers/custom-validators/misc.ts
@@ -23,6 +23,10 @@ function isNotEmptyIntArray (value: any) {
   return Array.isArray(value) && value.every(v => validator.isInt('' + v)) && value.length !== 0
 }
 
+function isNotEmptyStringArray (value: any) {
+  return Array.isArray(value) && value.every(v => typeof v === 'string' && v.length !== 0) && value.length !== 0
+}
+
 function isArrayOf (value: any, validator: (value: any) => boolean) {
   return isArray(value) && value.every(v => validator(v))
 }
@@ -39,6 +43,10 @@ function isUUIDValid (value: string) {
   return exists(value) && validator.isUUID('' + value, 4)
 }
 
+function areUUIDsValid (values: string[]) {
+  return isArray(values) && values.every(v => isUUIDValid(v))
+}
+
 function isIdOrUUIDValid (value: string) {
   return isIdValid(value) || isUUIDValid(value)
 }
@@ -132,6 +140,10 @@ function toCompleteUUID (value: string) {
   return value
 }
 
+function toCompleteUUIDs (values: string[]) {
+  return values.map(v => toCompleteUUID(v))
+}
+
 function toIntOrNull (value: string) {
   const v = toValueOrNull(value)
 
@@ -179,7 +191,9 @@ export {
   isIntOrNull,
   isIdValid,
   isSafePath,
+  isNotEmptyStringArray,
   isUUIDValid,
+  toCompleteUUIDs,
   toCompleteUUID,
   isIdOrUUIDValid,
   isDateValid,
@@ -187,6 +201,7 @@ export {
   toBooleanOrNull,
   isBooleanValid,
   toIntOrNull,
+  areUUIDsValid,
   toArray,
   toIntArray,
   isFileFieldValid,
diff --git a/server/helpers/custom-validators/servers.ts b/server/helpers/custom-validators/servers.ts
index adf1ea497..c0f8b6aeb 100644
--- a/server/helpers/custom-validators/servers.ts
+++ b/server/helpers/custom-validators/servers.ts
@@ -19,7 +19,6 @@ function isHostValid (host: string) {
 
 function isEachUniqueHostValid (hosts: string[]) {
   return isArray(hosts) &&
-    hosts.length !== 0 &&
     hosts.every(host => {
       return isHostValid(host) && hosts.indexOf(host) === hosts.lastIndexOf(host)
     })
diff --git a/server/helpers/custom-validators/video-channels.ts b/server/helpers/custom-validators/video-channels.ts
index ded5d5171..249083f39 100644
--- a/server/helpers/custom-validators/video-channels.ts
+++ b/server/helpers/custom-validators/video-channels.ts
@@ -1,14 +1,20 @@
 import validator from 'validator'
 import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 import { exists } from './misc'
+import { isUserUsernameValid } from './users'
 
 const VIDEO_CHANNELS_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.VIDEO_CHANNELS
 
+function isVideoChannelUsernameValid (value: string) {
+  // Use the same constraints than user username
+  return isUserUsernameValid(value)
+}
+
 function isVideoChannelDescriptionValid (value: string) {
   return value === null || validator.isLength(value, VIDEO_CHANNELS_CONSTRAINTS_FIELDS.DESCRIPTION)
 }
 
-function isVideoChannelNameValid (value: string) {
+function isVideoChannelDisplayNameValid (value: string) {
   return exists(value) && validator.isLength(value, VIDEO_CHANNELS_CONSTRAINTS_FIELDS.NAME)
 }
 
@@ -19,7 +25,8 @@ function isVideoChannelSupportValid (value: string) {
 // ---------------------------------------------------------------------------
 
 export {
+  isVideoChannelUsernameValid,
   isVideoChannelDescriptionValid,
-  isVideoChannelNameValid,
+  isVideoChannelDisplayNameValid,
   isVideoChannelSupportValid
 }
diff --git a/server/helpers/custom-validators/video-ownership.ts b/server/helpers/custom-validators/video-ownership.ts
index 0e1c63bad..cf15b385a 100644
--- a/server/helpers/custom-validators/video-ownership.ts
+++ b/server/helpers/custom-validators/video-ownership.ts
@@ -1,7 +1,7 @@
 import { Response } from 'express'
 import { MUserId } from '@server/types/models'
 import { MVideoChangeOwnershipFull } from '@server/types/models/video/video-change-ownership'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 
 function checkUserCanTerminateOwnershipChange (user: MUserId, videoChangeOwnership: MVideoChangeOwnershipFull, res: Response) {
   if (videoChangeOwnership.NextOwner.userId === user.id) {
diff --git a/server/helpers/database-utils.ts b/server/helpers/database-utils.ts
index b5dc70c17..ec35295df 100644
--- a/server/helpers/database-utils.ts
+++ b/server/helpers/database-utils.ts
@@ -1,12 +1,12 @@
 import * as retry from 'async/retry'
 import * as Bluebird from 'bluebird'
-import { QueryTypes, Transaction } from 'sequelize'
+import { Transaction } from 'sequelize'
 import { Model } from 'sequelize-typescript'
 import { sequelizeTypescript } from '@server/initializers/database'
 import { logger } from './logger'
 
 function retryTransactionWrapper <T, A, B, C, D> (
-  functionToRetry: (arg1: A, arg2: B, arg3: C, arg4: D) => Promise<T> | Bluebird<T>,
+  functionToRetry: (arg1: A, arg2: B, arg3: C, arg4: D) => Promise<T>,
   arg1: A,
   arg2: B,
   arg3: C,
@@ -14,20 +14,20 @@ function retryTransactionWrapper <T, A, B, C, D> (
 ): Promise<T>
 
 function retryTransactionWrapper <T, A, B, C> (
-  functionToRetry: (arg1: A, arg2: B, arg3: C) => Promise<T> | Bluebird<T>,
+  functionToRetry: (arg1: A, arg2: B, arg3: C) => Promise<T>,
   arg1: A,
   arg2: B,
   arg3: C
 ): Promise<T>
 
 function retryTransactionWrapper <T, A, B> (
-  functionToRetry: (arg1: A, arg2: B) => Promise<T> | Bluebird<T>,
+  functionToRetry: (arg1: A, arg2: B) => Promise<T>,
   arg1: A,
   arg2: B
 ): Promise<T>
 
 function retryTransactionWrapper <T, A> (
-  functionToRetry: (arg1: A) => Promise<T> | Bluebird<T>,
+  functionToRetry: (arg1: A) => Promise<T>,
   arg1: A
 ): Promise<T>
 
@@ -36,7 +36,7 @@ function retryTransactionWrapper <T> (
 ): Promise<T>
 
 function retryTransactionWrapper <T> (
-  functionToRetry: (...args: any[]) => Promise<T> | Bluebird<T>,
+  functionToRetry: (...args: any[]) => Promise<T>,
   ...args: any[]
 ): Promise<T> {
   return transactionRetryer<T>(callback => {
@@ -84,25 +84,15 @@ function resetSequelizeInstance (instance: Model<any>, savedFields: object) {
   })
 }
 
-function deleteNonExistingModels <T extends { hasSameUniqueKeysThan (other: T): boolean } & Pick<Model, 'destroy'>> (
+function filterNonExistingModels <T extends { hasSameUniqueKeysThan (other: T): boolean }> (
   fromDatabase: T[],
-  newModels: T[],
-  t: Transaction
+  newModels: T[]
 ) {
   return fromDatabase.filter(f => !newModels.find(newModel => newModel.hasSameUniqueKeysThan(f)))
-              .map(f => f.destroy({ transaction: t }))
 }
 
-// Sequelize always skip the update if we only update updatedAt field
-function setAsUpdated (table: string, id: number, transaction?: Transaction) {
-  return sequelizeTypescript.query(
-    `UPDATE "${table}" SET "updatedAt" = :updatedAt WHERE id = :id`,
-    {
-      replacements: { table, id, updatedAt: new Date() },
-      type: QueryTypes.UPDATE,
-      transaction
-    }
-  )
+function deleteAllModels <T extends Pick<Model, 'destroy'>> (models: T[], transaction: Transaction) {
+  return Promise.all(models.map(f => f.destroy({ transaction })))
 }
 
 // ---------------------------------------------------------------------------
@@ -127,7 +117,7 @@ export {
   transactionRetryer,
   updateInstanceWithAnother,
   afterCommitIfTransaction,
-  deleteNonExistingModels,
-  setAsUpdated,
+  filterNonExistingModels,
+  deleteAllModels,
   runInReadCommittedTransaction
 }
diff --git a/server/helpers/express-utils.ts b/server/helpers/express-utils.ts
index 0ff113274..c299b70f1 100644
--- a/server/helpers/express-utils.ts
+++ b/server/helpers/express-utils.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import * as multer from 'multer'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { CONFIG } from '../initializers/config'
 import { REMOTE_SCHEME } from '../initializers/constants'
 import { getLowercaseExtension } from './core-utils'
diff --git a/server/helpers/ffmpeg-utils.ts b/server/helpers/ffmpeg-utils.ts
index 6f5a71b4a..61c8a6db2 100644
--- a/server/helpers/ffmpeg-utils.ts
+++ b/server/helpers/ffmpeg-utils.ts
@@ -212,14 +212,17 @@ async function transcode (options: TranscodeOptions) {
 
 async function getLiveTranscodingCommand (options: {
   rtmpUrl: string
+
   outPath: string
+  masterPlaylistName: string
+
   resolutions: number[]
   fps: number
 
   availableEncoders: AvailableEncoders
   profile: string
 }) {
-  const { rtmpUrl, outPath, resolutions, fps, availableEncoders, profile } = options
+  const { rtmpUrl, outPath, resolutions, fps, availableEncoders, profile, masterPlaylistName } = options
   const input = rtmpUrl
 
   const command = getFFmpeg(input, 'live')
@@ -301,14 +304,14 @@ async function getLiveTranscodingCommand (options: {
 
   command.complexFilter(complexFilter)
 
-  addDefaultLiveHLSParams(command, outPath)
+  addDefaultLiveHLSParams(command, outPath, masterPlaylistName)
 
   command.outputOption('-var_stream_map', varStreamMap.join(' '))
 
   return command
 }
 
-function getLiveMuxingCommand (rtmpUrl: string, outPath: string) {
+function getLiveMuxingCommand (rtmpUrl: string, outPath: string, masterPlaylistName: string) {
   const command = getFFmpeg(rtmpUrl, 'live')
 
   command.outputOption('-c:v copy')
@@ -316,7 +319,7 @@ function getLiveMuxingCommand (rtmpUrl: string, outPath: string) {
   command.outputOption('-map 0:a?')
   command.outputOption('-map 0:v?')
 
-  addDefaultLiveHLSParams(command, outPath)
+  addDefaultLiveHLSParams(command, outPath, masterPlaylistName)
 
   return command
 }
@@ -371,12 +374,12 @@ function addDefaultEncoderParams (options: {
   }
 }
 
-function addDefaultLiveHLSParams (command: ffmpeg.FfmpegCommand, outPath: string) {
+function addDefaultLiveHLSParams (command: ffmpeg.FfmpegCommand, outPath: string, masterPlaylistName: string) {
   command.outputOption('-hls_time ' + VIDEO_LIVE.SEGMENT_TIME_SECONDS)
   command.outputOption('-hls_list_size ' + VIDEO_LIVE.SEGMENTS_LIST_SIZE)
   command.outputOption('-hls_flags delete_segments+independent_segments')
   command.outputOption(`-hls_segment_filename ${join(outPath, '%v-%06d.ts')}`)
-  command.outputOption('-master_pl_name master.m3u8')
+  command.outputOption('-master_pl_name ' + masterPlaylistName)
   command.outputOption(`-f hls`)
 
   command.output(join(outPath, '%v.m3u8'))
@@ -700,6 +703,10 @@ async function runCommand (options: {
   const { command, silent = false, job } = options
 
   return new Promise<void>((res, rej) => {
+    let shellCommand: string
+
+    command.on('start', cmdline => { shellCommand = cmdline })
+
     command.on('error', (err, stdout, stderr) => {
       if (silent !== true) logger.error('Error in ffmpeg.', { stdout, stderr })
 
@@ -707,7 +714,7 @@ async function runCommand (options: {
     })
 
     command.on('end', (stdout, stderr) => {
-      logger.debug('FFmpeg command ended.', { stdout, stderr })
+      logger.debug('FFmpeg command ended.', { stdout, stderr, shellCommand })
 
       res()
     })
diff --git a/server/helpers/logger.ts b/server/helpers/logger.ts
index 29e06860d..20c3c3edb 100644
--- a/server/helpers/logger.ts
+++ b/server/helpers/logger.ts
@@ -1,5 +1,5 @@
 // Thanks http://tostring.it/2014/06/23/advanced-logging-with-nodejs/
-import { mkdirpSync } from 'fs-extra'
+import { mkdirpSync, stat } from 'fs-extra'
 import { omit } from 'lodash'
 import * as path from 'path'
 import { format as sqlFormat } from 'sql-formatter'
@@ -158,6 +158,26 @@ function loggerTagsFactory (...defaultTags: string[]): LoggerTagsFn {
   }
 }
 
+async function mtimeSortFilesDesc (files: string[], basePath: string) {
+  const promises = []
+  const out: { file: string, mtime: number }[] = []
+
+  for (const file of files) {
+    const p = stat(basePath + '/' + file)
+      .then(stats => {
+        if (stats.isFile()) out.push({ file, mtime: stats.mtime.getTime() })
+      })
+
+    promises.push(p)
+  }
+
+  await Promise.all(promises)
+
+  out.sort((a, b) => b.mtime - a.mtime)
+
+  return out
+}
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -168,6 +188,7 @@ export {
   labelFormatter,
   consoleLoggerFormat,
   jsonLoggerFormat,
+  mtimeSortFilesDesc,
   logger,
   loggerTagsFactory,
   bunyanLogger
diff --git a/server/helpers/query.ts b/server/helpers/query.ts
new file mode 100644
index 000000000..e711b15f2
--- /dev/null
+++ b/server/helpers/query.ts
@@ -0,0 +1,74 @@
+import { pick } from '@shared/core-utils'
+import {
+  VideoChannelsSearchQueryAfterSanitize,
+  VideoPlaylistsSearchQueryAfterSanitize,
+  VideosCommonQueryAfterSanitize,
+  VideosSearchQueryAfterSanitize
+} from '@shared/models'
+
+function pickCommonVideoQuery (query: VideosCommonQueryAfterSanitize) {
+  return pick(query, [
+    'start',
+    'count',
+    'sort',
+    'nsfw',
+    'isLive',
+    'categoryOneOf',
+    'licenceOneOf',
+    'languageOneOf',
+    'tagsOneOf',
+    'tagsAllOf',
+    'filter',
+    'skipCount'
+  ])
+}
+
+function pickSearchVideoQuery (query: VideosSearchQueryAfterSanitize) {
+  return {
+    ...pickCommonVideoQuery(query),
+
+    ...pick(query, [
+      'searchTarget',
+      'search',
+      'host',
+      'startDate',
+      'endDate',
+      'originallyPublishedStartDate',
+      'originallyPublishedEndDate',
+      'durationMin',
+      'durationMax',
+      'uuids'
+    ])
+  }
+}
+
+function pickSearchChannelQuery (query: VideoChannelsSearchQueryAfterSanitize) {
+  return pick(query, [
+    'searchTarget',
+    'search',
+    'start',
+    'count',
+    'sort',
+    'host',
+    'handles'
+  ])
+}
+
+function pickSearchPlaylistQuery (query: VideoPlaylistsSearchQueryAfterSanitize) {
+  return pick(query, [
+    'searchTarget',
+    'search',
+    'start',
+    'count',
+    'sort',
+    'host',
+    'uuids'
+  ])
+}
+
+export {
+  pickCommonVideoQuery,
+  pickSearchVideoQuery,
+  pickSearchPlaylistQuery,
+  pickSearchChannelQuery
+}
diff --git a/server/helpers/webtorrent.ts b/server/helpers/webtorrent.ts
index d8220ba9c..ecf63e93e 100644
--- a/server/helpers/webtorrent.ts
+++ b/server/helpers/webtorrent.ts
@@ -103,6 +103,11 @@ async function createTorrentAndSetInfoHash (
 
   await writeFile(torrentPath, torrent)
 
+  // Remove old torrent file if it existed
+  if (videoFile.hasTorrent()) {
+    await remove(join(CONFIG.STORAGE.TORRENTS_DIR, videoFile.torrentFilename))
+  }
+
   const parsedTorrent = parseTorrent(torrent)
   videoFile.infoHash = parsedTorrent.infoHash
   videoFile.torrentFilename = torrentFilename
diff --git a/server/helpers/youtube-dl.ts b/server/helpers/youtube-dl.ts
index fdd361390..3c80e7d41 100644
--- a/server/helpers/youtube-dl.ts
+++ b/server/helpers/youtube-dl.ts
@@ -3,7 +3,7 @@ import { ensureDir, move, pathExists, remove, writeFile } from 'fs-extra'
 import got from 'got'
 import { join } from 'path'
 import { CONFIG } from '@server/initializers/config'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { VideoResolution } from '../../shared/models/videos'
 import { CONSTRAINTS_FIELDS, VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES } from '../initializers/constants'
 import { peertubeTruncate, pipelinePromise, root } from './core-utils'
diff --git a/server/initializers/constants.ts b/server/initializers/constants.ts
index ab59320eb..5f121d9a4 100644
--- a/server/initializers/constants.ts
+++ b/server/initializers/constants.ts
@@ -2,7 +2,7 @@ import { CronRepeatOptions, EveryRepeatOptions } from 'bull'
 import { randomBytes } from 'crypto'
 import { invert } from 'lodash'
 import { join } from 'path'
-import { randomInt } from '../../shared/core-utils/miscs/miscs'
+import { randomInt } from '../../shared/core-utils/common/miscs'
 import {
   AbuseState,
   JobType,
@@ -24,7 +24,7 @@ import { CONFIG, registerConfigChangedHandler } from './config'
 
 // ---------------------------------------------------------------------------
 
-const LAST_MIGRATION_VERSION = 650
+const LAST_MIGRATION_VERSION = 655
 
 // ---------------------------------------------------------------------------
 
diff --git a/server/initializers/migrations/0655-streaming-playlist-filenames.ts b/server/initializers/migrations/0655-streaming-playlist-filenames.ts
new file mode 100644
index 000000000..9172a22c4
--- /dev/null
+++ b/server/initializers/migrations/0655-streaming-playlist-filenames.ts
@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction
+  queryInterface: Sequelize.QueryInterface
+  sequelize: Sequelize.Sequelize
+  db: any
+}): Promise<void> {
+  {
+    for (const column of [ 'playlistUrl', 'segmentsSha256Url' ]) {
+      const data = {
+        type: Sequelize.STRING,
+        allowNull: true,
+        defaultValue: null
+      }
+
+      await utils.queryInterface.changeColumn('videoStreamingPlaylist', column, data)
+    }
+  }
+
+  {
+    await utils.sequelize.query(
+      `UPDATE "videoStreamingPlaylist" SET "playlistUrl" = NULL, "segmentsSha256Url" = NULL ` +
+      `WHERE "videoId" IN (SELECT id FROM video WHERE remote IS FALSE)`
+    )
+  }
+
+  {
+    for (const column of [ 'playlistFilename', 'segmentsSha256Filename' ]) {
+      const data = {
+        type: Sequelize.STRING,
+        allowNull: true,
+        defaultValue: null
+      }
+
+      await utils.queryInterface.addColumn('videoStreamingPlaylist', column, data)
+    }
+  }
+
+  {
+    await utils.sequelize.query(
+      `UPDATE "videoStreamingPlaylist" SET "playlistFilename" = 'master.m3u8', "segmentsSha256Filename" = 'segments-sha256.json'`
+    )
+  }
+
+  {
+    for (const column of [ 'playlistFilename', 'segmentsSha256Filename' ]) {
+      const data = {
+        type: Sequelize.STRING,
+        allowNull: false,
+        defaultValue: null
+      }
+
+      await utils.queryInterface.changeColumn('videoStreamingPlaylist', column, data)
+    }
+  }
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/lib/activitypub/actors/refresh.ts b/server/lib/activitypub/actors/refresh.ts
index b2fe3932f..0acaa9f62 100644
--- a/server/lib/activitypub/actors/refresh.ts
+++ b/server/lib/activitypub/actors/refresh.ts
@@ -4,7 +4,7 @@ import { PeerTubeRequestError } from '@server/helpers/requests'
 import { ActorLoadByUrlType } from '@server/lib/model-loaders'
 import { ActorModel } from '@server/models/actor/actor'
 import { MActorAccountChannelId, MActorFull } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 import { fetchRemoteActor } from './shared'
 import { APActorUpdater } from './updater'
 import { getUrlFromWebfinger } from './webfinger'
diff --git a/server/lib/activitypub/crawl.ts b/server/lib/activitypub/crawl.ts
index cd117f571..28ff5225a 100644
--- a/server/lib/activitypub/crawl.ts
+++ b/server/lib/activitypub/crawl.ts
@@ -1,3 +1,4 @@
+import { retryTransactionWrapper } from '@server/helpers/database-utils'
 import * as Bluebird from 'bluebird'
 import { URL } from 'url'
 import { ActivityPubOrderedCollection } from '../../../shared/models/activitypub'
@@ -51,7 +52,7 @@ async function crawlCollectionPage <T> (argUrl: string, handler: HandlerFunction
     }
   }
 
-  if (cleaner) await cleaner(startDate)
+  if (cleaner) await retryTransactionWrapper(cleaner, startDate)
 }
 
 export {
diff --git a/server/lib/activitypub/follow.ts b/server/lib/activitypub/follow.ts
index c1bd667e0..741b54df5 100644
--- a/server/lib/activitypub/follow.ts
+++ b/server/lib/activitypub/follow.ts
@@ -31,6 +31,21 @@ async function autoFollowBackIfNeeded (actorFollow: MActorFollowActors, transact
   }
 }
 
+// If we only have an host, use a default account handle
+function getRemoteNameAndHost (handleOrHost: string) {
+  let name = SERVER_ACTOR_NAME
+  let host = handleOrHost
+
+  const splitted = handleOrHost.split('@')
+  if (splitted.length === 2) {
+    name = splitted[0]
+    host = splitted[1]
+  }
+
+  return { name, host }
+}
+
 export {
-  autoFollowBackIfNeeded
+  autoFollowBackIfNeeded,
+  getRemoteNameAndHost
 }
diff --git a/server/lib/activitypub/playlists/refresh.ts b/server/lib/activitypub/playlists/refresh.ts
index ef3cb3fe4..493e8c7ec 100644
--- a/server/lib/activitypub/playlists/refresh.ts
+++ b/server/lib/activitypub/playlists/refresh.ts
@@ -2,7 +2,7 @@ import { logger, loggerTagsFactory } from '@server/helpers/logger'
 import { PeerTubeRequestError } from '@server/helpers/requests'
 import { JobQueue } from '@server/lib/job-queue'
 import { MVideoPlaylist, MVideoPlaylistOwner } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 import { createOrUpdateVideoPlaylist } from './create-update'
 import { fetchRemoteVideoPlaylist } from './shared'
 
diff --git a/server/lib/activitypub/url.ts b/server/lib/activitypub/url.ts
index 7816b0be0..338398f2b 100644
--- a/server/lib/activitypub/url.ts
+++ b/server/lib/activitypub/url.ts
@@ -1,5 +1,6 @@
 import { WEBSERVER } from '../../initializers/constants'
 import {
+  MAbuseFull,
   MAbuseId,
   MActor,
   MActorFollowActors,
@@ -112,6 +113,14 @@ function getUndoActivityPubUrl (originalUrl: string) {
   return originalUrl + '/undo'
 }
 
+// ---------------------------------------------------------------------------
+
+function getAbuseTargetUrl (abuse: MAbuseFull) {
+  return abuse.VideoAbuse?.Video?.url ||
+    abuse.VideoCommentAbuse?.VideoComment?.url ||
+    abuse.FlaggedAccount.Actor.url
+}
+
 export {
   getLocalVideoActivityPubUrl,
   getLocalVideoPlaylistActivityPubUrl,
@@ -135,5 +144,6 @@ export {
   getLocalVideoSharesActivityPubUrl,
   getLocalVideoCommentsActivityPubUrl,
   getLocalVideoLikesActivityPubUrl,
-  getLocalVideoDislikesActivityPubUrl
+  getLocalVideoDislikesActivityPubUrl,
+  getAbuseTargetUrl
 }
diff --git a/server/lib/activitypub/videos/refresh.ts b/server/lib/activitypub/videos/refresh.ts
index a7b82f286..3af08acf4 100644
--- a/server/lib/activitypub/videos/refresh.ts
+++ b/server/lib/activitypub/videos/refresh.ts
@@ -4,7 +4,7 @@ import { ActorFollowScoreCache } from '@server/lib/files-cache'
 import { VideoLoadByUrlType } from '@server/lib/model-loaders'
 import { VideoModel } from '@server/models/video/video'
 import { MVideoAccountLightBlacklistAllFiles, MVideoThumbnail } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 import { fetchRemoteVideo, SyncParam, syncVideoExternalAttributes } from './shared'
 import { APVideoUpdater } from './updater'
 
diff --git a/server/lib/activitypub/videos/shared/abstract-builder.ts b/server/lib/activitypub/videos/shared/abstract-builder.ts
index e89c94bcd..f995fe637 100644
--- a/server/lib/activitypub/videos/shared/abstract-builder.ts
+++ b/server/lib/activitypub/videos/shared/abstract-builder.ts
@@ -1,6 +1,6 @@
 import { Transaction } from 'sequelize/types'
 import { checkUrlsSameHost } from '@server/helpers/activitypub'
-import { deleteNonExistingModels } from '@server/helpers/database-utils'
+import { deleteAllModels, filterNonExistingModels } from '@server/helpers/database-utils'
 import { logger, LoggerTagsFn } from '@server/helpers/logger'
 import { updatePlaceholderThumbnail, updateVideoMiniatureFromUrl } from '@server/lib/thumbnail'
 import { setVideoTags } from '@server/lib/video'
@@ -111,8 +111,7 @@ export abstract class APVideoAbstractBuilder {
     const newVideoFiles = videoFileAttributes.map(a => new VideoFileModel(a))
 
     // Remove video files that do not exist anymore
-    const destroyTasks = deleteNonExistingModels(video.VideoFiles || [], newVideoFiles, t)
-    await Promise.all(destroyTasks)
+    await deleteAllModels(filterNonExistingModels(video.VideoFiles || [], newVideoFiles), t)
 
     // Update or add other one
     const upsertTasks = newVideoFiles.map(f => VideoFileModel.customUpsert(f, 'video', t))
@@ -124,13 +123,11 @@ export abstract class APVideoAbstractBuilder {
     const newStreamingPlaylists = streamingPlaylistAttributes.map(a => new VideoStreamingPlaylistModel(a))
 
     // Remove video playlists that do not exist anymore
-    const destroyTasks = deleteNonExistingModels(video.VideoStreamingPlaylists || [], newStreamingPlaylists, t)
-    await Promise.all(destroyTasks)
+    await deleteAllModels(filterNonExistingModels(video.VideoStreamingPlaylists || [], newStreamingPlaylists), t)
 
     video.VideoStreamingPlaylists = []
 
     for (const playlistAttributes of streamingPlaylistAttributes) {
-
       const streamingPlaylistModel = await this.insertOrReplaceStreamingPlaylist(playlistAttributes, t)
       streamingPlaylistModel.Video = video
 
@@ -163,8 +160,7 @@ export abstract class APVideoAbstractBuilder {
 
     const newVideoFiles: MVideoFile[] = getFileAttributesFromUrl(playlistModel, tagObjects).map(a => new VideoFileModel(a))
 
-    const destroyTasks = deleteNonExistingModels(oldStreamingPlaylistFiles, newVideoFiles, t)
-    await Promise.all(destroyTasks)
+    await deleteAllModels(filterNonExistingModels(oldStreamingPlaylistFiles, newVideoFiles), t)
 
     // Update or add other one
     const upsertTasks = newVideoFiles.map(f => VideoFileModel.customUpsert(f, 'streaming-playlist', t))
diff --git a/server/lib/activitypub/videos/shared/object-to-model-attributes.ts b/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
index 85548428c..1fa16295d 100644
--- a/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
+++ b/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
@@ -7,10 +7,11 @@ import { logger } from '@server/helpers/logger'
 import { getExtFromMimetype } from '@server/helpers/video'
 import { ACTIVITY_PUB, MIMETYPES, P2P_MEDIA_LOADER_PEER_VERSION, PREVIEWS_SIZE, THUMBNAILS_SIZE } from '@server/initializers/constants'
 import { generateTorrentFileName } from '@server/lib/video-paths'
+import { VideoCaptionModel } from '@server/models/video/video-caption'
 import { VideoFileModel } from '@server/models/video/video-file'
 import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist'
 import { FilteredModelAttributes } from '@server/types'
-import { MChannelId, MStreamingPlaylist, MStreamingPlaylistVideo, MVideo, MVideoFile, MVideoId } from '@server/types/models'
+import { isStreamingPlaylist, MChannelId, MStreamingPlaylistVideo, MVideo, MVideoFile, MVideoId } from '@server/types/models'
 import {
   ActivityHashTagObject,
   ActivityMagnetUrlObject,
@@ -23,7 +24,6 @@ import {
   VideoPrivacy,
   VideoStreamingPlaylistType
 } from '@shared/models'
-import { VideoCaptionModel } from '@server/models/video/video-caption'
 
 function getThumbnailFromIcons (videoObject: VideoObject) {
   let validIcons = videoObject.icon.filter(i => i.width > THUMBNAILS_SIZE.minWidth)
@@ -80,8 +80,8 @@ function getFileAttributesFromUrl (
 
     const extname = getExtFromMimetype(MIMETYPES.VIDEO.MIMETYPE_EXT, fileUrl.mediaType)
     const resolution = fileUrl.height
-    const videoId = (videoOrPlaylist as MStreamingPlaylist).playlistUrl ? null : videoOrPlaylist.id
-    const videoStreamingPlaylistId = (videoOrPlaylist as MStreamingPlaylist).playlistUrl ? videoOrPlaylist.id : null
+    const videoId = isStreamingPlaylist(videoOrPlaylist) ? null : videoOrPlaylist.id
+    const videoStreamingPlaylistId = isStreamingPlaylist(videoOrPlaylist) ? videoOrPlaylist.id : null
 
     const attribute = {
       extname,
@@ -130,8 +130,13 @@ function getStreamingPlaylistAttributesFromObject (video: MVideoId, videoObject:
 
     const attribute = {
       type: VideoStreamingPlaylistType.HLS,
+
+      playlistFilename: basename(playlistUrlObject.href),
       playlistUrl: playlistUrlObject.href,
+
+      segmentsSha256Filename: basename(segmentsSha256UrlObject.href),
       segmentsSha256Url: segmentsSha256UrlObject.href,
+
       p2pMediaLoaderInfohashes: VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(playlistUrlObject.href, files),
       p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
       videoId: video.id,
diff --git a/server/lib/client-html.ts b/server/lib/client-html.ts
index 72194416d..e093d35f7 100644
--- a/server/lib/client-html.ts
+++ b/server/lib/client-html.ts
@@ -5,7 +5,7 @@ import validator from 'validator'
 import { escapeHTML } from '@shared/core-utils/renderer'
 import { HTMLServerConfig } from '@shared/models'
 import { buildFileLocale, getDefaultLocale, is18nLocale, POSSIBLE_LOCALES } from '../../shared/core-utils/i18n/i18n'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { VideoPlaylistPrivacy, VideoPrivacy } from '../../shared/models/videos'
 import { isTestInstance, sha256 } from '../helpers/core-utils'
 import { logger } from '../helpers/logger'
@@ -44,6 +44,8 @@ type Tags = {
   originUrl: string
   description: string
 
+  disallowIndexation?: boolean
+
   embed?: {
     url: string
     createdAt: string
@@ -162,7 +164,7 @@ class ClientHtml {
     let customHtml = ClientHtml.addTitleTag(html, escapeHTML(videoPlaylist.name))
     customHtml = ClientHtml.addDescriptionTag(customHtml, mdToPlainText(videoPlaylist.description))
 
-    const url = videoPlaylist.getWatchUrl()
+    const url = WEBSERVER.URL + videoPlaylist.getWatchStaticPath()
     const originUrl = videoPlaylist.url
     const title = escapeHTML(videoPlaylist.name)
     const siteName = escapeHTML(CONFIG.INSTANCE.NAME)
@@ -285,7 +287,8 @@ class ClientHtml {
       image,
       ogType,
       twitterCard,
-      schemaType
+      schemaType,
+      disallowIndexation: !entity.Actor.isOwned()
     })
 
     return customHtml
@@ -488,7 +491,7 @@ class ClientHtml {
     const twitterCardMetaTags = this.generateTwitterCardMetaTags(tagsValues)
     const schemaTags = this.generateSchemaTags(tagsValues)
 
-    const { url, title, embed, originUrl } = tagsValues
+    const { url, title, embed, originUrl, disallowIndexation } = tagsValues
 
     const oembedLinkTags: { type: string, href: string, title: string }[] = []
 
@@ -536,6 +539,10 @@ class ClientHtml {
     // SEO, use origin URL
     tagsString += `<link rel="canonical" href="${originUrl}" />`
 
+    if (disallowIndexation) {
+      tagsString += `<meta name="robots" content="noindex" />`
+    }
+
     return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.META_TAGS, tagsString)
   }
 }
diff --git a/server/lib/emailer.ts b/server/lib/emailer.ts
index 458214f88..6bb61484b 100644
--- a/server/lib/emailer.ts
+++ b/server/lib/emailer.ts
@@ -1,20 +1,15 @@
 import { readFileSync } from 'fs-extra'
-import { merge } from 'lodash'
+import { isArray, merge } from 'lodash'
 import { createTransport, Transporter } from 'nodemailer'
 import { join } from 'path'
-import { VideoChannelModel } from '@server/models/video/video-channel'
-import { MVideoBlacklistLightVideo, MVideoBlacklistVideo } from '@server/types/models/video/video-blacklist'
-import { MVideoImport, MVideoImportVideo } from '@server/types/models/video/video-import'
-import { AbuseState, EmailPayload, UserAbuse } from '@shared/models'
+import { EmailPayload } from '@shared/models'
 import { SendEmailDefaultOptions } from '../../shared/models/server/emailer.model'
 import { isTestInstance, root } from '../helpers/core-utils'
 import { bunyanLogger, logger } from '../helpers/logger'
 import { CONFIG, isEmailEnabled } from '../initializers/config'
 import { WEBSERVER } from '../initializers/constants'
-import { MAbuseFull, MAbuseMessage, MAccountDefault, MActorFollowActors, MActorFollowFull, MPlugin, MUser } from '../types/models'
-import { MCommentOwnerVideo, MVideo, MVideoAccountLight } from '../types/models/video'
+import { MUser } from '../types/models'
 import { JobQueue } from './job-queue'
-import { toSafeHtml } from '../helpers/markdown'
 
 const Email = require('email-templates')
 
@@ -59,429 +54,6 @@ class Emailer {
     }
   }
 
-  addNewVideoFromSubscriberNotification (to: string[], video: MVideoAccountLight) {
-    const channelName = video.VideoChannel.getDisplayName()
-    const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
-
-    const emailPayload: EmailPayload = {
-      to,
-      subject: channelName + ' just published a new video',
-      text: `Your subscription ${channelName} just published a new video: "${video.name}".`,
-      locals: {
-        title: 'New content ',
-        action: {
-          text: 'View video',
-          url: videoUrl
-        }
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addNewFollowNotification (to: string[], actorFollow: MActorFollowFull, followType: 'account' | 'channel') {
-    const followingName = (actorFollow.ActorFollowing.VideoChannel || actorFollow.ActorFollowing.Account).getDisplayName()
-
-    const emailPayload: EmailPayload = {
-      template: 'follower-on-channel',
-      to,
-      subject: `New follower on your channel ${followingName}`,
-      locals: {
-        followerName: actorFollow.ActorFollower.Account.getDisplayName(),
-        followerUrl: actorFollow.ActorFollower.url,
-        followingName,
-        followingUrl: actorFollow.ActorFollowing.url,
-        followType
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addNewInstanceFollowerNotification (to: string[], actorFollow: MActorFollowActors) {
-    const awaitingApproval = actorFollow.state === 'pending' ? ' awaiting manual approval.' : ''
-
-    const emailPayload: EmailPayload = {
-      to,
-      subject: 'New instance follower',
-      text: `Your instance has a new follower: ${actorFollow.ActorFollower.url}${awaitingApproval}.`,
-      locals: {
-        title: 'New instance follower',
-        action: {
-          text: 'Review followers',
-          url: WEBSERVER.URL + '/admin/follows/followers-list'
-        }
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addAutoInstanceFollowingNotification (to: string[], actorFollow: MActorFollowActors) {
-    const instanceUrl = actorFollow.ActorFollowing.url
-    const emailPayload: EmailPayload = {
-      to,
-      subject: 'Auto instance following',
-      text: `Your instance automatically followed a new instance: <a href="${instanceUrl}">${instanceUrl}</a>.`
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  myVideoPublishedNotification (to: string[], video: MVideo) {
-    const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
-
-    const emailPayload: EmailPayload = {
-      to,
-      subject: `Your video ${video.name} has been published`,
-      text: `Your video "${video.name}" has been published.`,
-      locals: {
-        title: 'You video is live',
-        action: {
-          text: 'View video',
-          url: videoUrl
-        }
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  myVideoImportSuccessNotification (to: string[], videoImport: MVideoImportVideo) {
-    const videoUrl = WEBSERVER.URL + videoImport.Video.getWatchStaticPath()
-
-    const emailPayload: EmailPayload = {
-      to,
-      subject: `Your video import ${videoImport.getTargetIdentifier()} is complete`,
-      text: `Your video "${videoImport.getTargetIdentifier()}" just finished importing.`,
-      locals: {
-        title: 'Import complete',
-        action: {
-          text: 'View video',
-          url: videoUrl
-        }
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  myVideoImportErrorNotification (to: string[], videoImport: MVideoImport) {
-    const importUrl = WEBSERVER.URL + '/my-library/video-imports'
-
-    const text =
-      `Your video import "${videoImport.getTargetIdentifier()}" encountered an error.` +
-      '\n\n' +
-      `See your videos import dashboard for more information: <a href="${importUrl}">${importUrl}</a>.`
-
-    const emailPayload: EmailPayload = {
-      to,
-      subject: `Your video import "${videoImport.getTargetIdentifier()}" encountered an error`,
-      text,
-      locals: {
-        title: 'Import failed',
-        action: {
-          text: 'Review imports',
-          url: importUrl
-        }
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addNewCommentOnMyVideoNotification (to: string[], comment: MCommentOwnerVideo) {
-    const video = comment.Video
-    const videoUrl = WEBSERVER.URL + comment.Video.getWatchStaticPath()
-    const commentUrl = WEBSERVER.URL + comment.getCommentStaticPath()
-    const commentHtml = toSafeHtml(comment.text)
-
-    const emailPayload: EmailPayload = {
-      template: 'video-comment-new',
-      to,
-      subject: 'New comment on your video ' + video.name,
-      locals: {
-        accountName: comment.Account.getDisplayName(),
-        accountUrl: comment.Account.Actor.url,
-        comment,
-        commentHtml,
-        video,
-        videoUrl,
-        action: {
-          text: 'View comment',
-          url: commentUrl
-        }
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addNewCommentMentionNotification (to: string[], comment: MCommentOwnerVideo) {
-    const accountName = comment.Account.getDisplayName()
-    const video = comment.Video
-    const videoUrl = WEBSERVER.URL + comment.Video.getWatchStaticPath()
-    const commentUrl = WEBSERVER.URL + comment.getCommentStaticPath()
-    const commentHtml = toSafeHtml(comment.text)
-
-    const emailPayload: EmailPayload = {
-      template: 'video-comment-mention',
-      to,
-      subject: 'Mention on video ' + video.name,
-      locals: {
-        comment,
-        commentHtml,
-        video,
-        videoUrl,
-        accountName,
-        action: {
-          text: 'View comment',
-          url: commentUrl
-        }
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addAbuseModeratorsNotification (to: string[], parameters: {
-    abuse: UserAbuse
-    abuseInstance: MAbuseFull
-    reporter: string
-  }) {
-    const { abuse, abuseInstance, reporter } = parameters
-
-    const action = {
-      text: 'View report #' + abuse.id,
-      url: WEBSERVER.URL + '/admin/moderation/abuses/list?search=%23' + abuse.id
-    }
-
-    let emailPayload: EmailPayload
-
-    if (abuseInstance.VideoAbuse) {
-      const video = abuseInstance.VideoAbuse.Video
-      const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
-
-      emailPayload = {
-        template: 'video-abuse-new',
-        to,
-        subject: `New video abuse report from ${reporter}`,
-        locals: {
-          videoUrl,
-          isLocal: video.remote === false,
-          videoCreatedAt: new Date(video.createdAt).toLocaleString(),
-          videoPublishedAt: new Date(video.publishedAt).toLocaleString(),
-          videoName: video.name,
-          reason: abuse.reason,
-          videoChannel: abuse.video.channel,
-          reporter,
-          action
-        }
-      }
-    } else if (abuseInstance.VideoCommentAbuse) {
-      const comment = abuseInstance.VideoCommentAbuse.VideoComment
-      const commentUrl = WEBSERVER.URL + comment.Video.getWatchStaticPath() + ';threadId=' + comment.getThreadId()
-
-      emailPayload = {
-        template: 'video-comment-abuse-new',
-        to,
-        subject: `New comment abuse report from ${reporter}`,
-        locals: {
-          commentUrl,
-          videoName: comment.Video.name,
-          isLocal: comment.isOwned(),
-          commentCreatedAt: new Date(comment.createdAt).toLocaleString(),
-          reason: abuse.reason,
-          flaggedAccount: abuseInstance.FlaggedAccount.getDisplayName(),
-          reporter,
-          action
-        }
-      }
-    } else {
-      const account = abuseInstance.FlaggedAccount
-      const accountUrl = account.getClientUrl()
-
-      emailPayload = {
-        template: 'account-abuse-new',
-        to,
-        subject: `New account abuse report from ${reporter}`,
-        locals: {
-          accountUrl,
-          accountDisplayName: account.getDisplayName(),
-          isLocal: account.isOwned(),
-          reason: abuse.reason,
-          reporter,
-          action
-        }
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addAbuseStateChangeNotification (to: string[], abuse: MAbuseFull) {
-    const text = abuse.state === AbuseState.ACCEPTED
-      ? 'Report #' + abuse.id + ' has been accepted'
-      : 'Report #' + abuse.id + ' has been rejected'
-
-    const abuseUrl = WEBSERVER.URL + '/my-account/abuses?search=%23' + abuse.id
-
-    const action = {
-      text,
-      url: abuseUrl
-    }
-
-    const emailPayload: EmailPayload = {
-      template: 'abuse-state-change',
-      to,
-      subject: text,
-      locals: {
-        action,
-        abuseId: abuse.id,
-        abuseUrl,
-        isAccepted: abuse.state === AbuseState.ACCEPTED
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addAbuseNewMessageNotification (
-    to: string[],
-    options: {
-      target: 'moderator' | 'reporter'
-      abuse: MAbuseFull
-      message: MAbuseMessage
-      accountMessage: MAccountDefault
-    }) {
-    const { abuse, target, message, accountMessage } = options
-
-    const text = 'New message on report #' + abuse.id
-    const abuseUrl = target === 'moderator'
-      ? WEBSERVER.URL + '/admin/moderation/abuses/list?search=%23' + abuse.id
-      : WEBSERVER.URL + '/my-account/abuses?search=%23' + abuse.id
-
-    const action = {
-      text,
-      url: abuseUrl
-    }
-
-    const emailPayload: EmailPayload = {
-      template: 'abuse-new-message',
-      to,
-      subject: text,
-      locals: {
-        abuseId: abuse.id,
-        abuseUrl: action.url,
-        messageAccountName: accountMessage.getDisplayName(),
-        messageText: message.message,
-        action
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  async addVideoAutoBlacklistModeratorsNotification (to: string[], videoBlacklist: MVideoBlacklistLightVideo) {
-    const videoAutoBlacklistUrl = WEBSERVER.URL + '/admin/moderation/video-auto-blacklist/list'
-    const videoUrl = WEBSERVER.URL + videoBlacklist.Video.getWatchStaticPath()
-    const channel = (await VideoChannelModel.loadAndPopulateAccount(videoBlacklist.Video.channelId)).toFormattedSummaryJSON()
-
-    const emailPayload: EmailPayload = {
-      template: 'video-auto-blacklist-new',
-      to,
-      subject: 'A new video is pending moderation',
-      locals: {
-        channel,
-        videoUrl,
-        videoName: videoBlacklist.Video.name,
-        action: {
-          text: 'Review autoblacklist',
-          url: videoAutoBlacklistUrl
-        }
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addNewUserRegistrationNotification (to: string[], user: MUser) {
-    const emailPayload: EmailPayload = {
-      template: 'user-registered',
-      to,
-      subject: `a new user registered on ${CONFIG.INSTANCE.NAME}: ${user.username}`,
-      locals: {
-        user
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addVideoBlacklistNotification (to: string[], videoBlacklist: MVideoBlacklistVideo) {
-    const videoName = videoBlacklist.Video.name
-    const videoUrl = WEBSERVER.URL + videoBlacklist.Video.getWatchStaticPath()
-
-    const reasonString = videoBlacklist.reason ? ` for the following reason: ${videoBlacklist.reason}` : ''
-    const blockedString = `Your video ${videoName} (${videoUrl} on ${CONFIG.INSTANCE.NAME} has been blacklisted${reasonString}.`
-
-    const emailPayload: EmailPayload = {
-      to,
-      subject: `Video ${videoName} blacklisted`,
-      text: blockedString,
-      locals: {
-        title: 'Your video was blacklisted'
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addVideoUnblacklistNotification (to: string[], video: MVideo) {
-    const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
-
-    const emailPayload: EmailPayload = {
-      to,
-      subject: `Video ${video.name} unblacklisted`,
-      text: `Your video "${video.name}" (${videoUrl}) on ${CONFIG.INSTANCE.NAME} has been unblacklisted.`,
-      locals: {
-        title: 'Your video was unblacklisted'
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addNewPeerTubeVersionNotification (to: string[], latestVersion: string) {
-    const emailPayload: EmailPayload = {
-      to,
-      template: 'peertube-version-new',
-      subject: `A new PeerTube version is available: ${latestVersion}`,
-      locals: {
-        latestVersion
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
-  addNewPlugionVersionNotification (to: string[], plugin: MPlugin) {
-    const pluginUrl = WEBSERVER.URL + '/admin/plugins/list-installed?pluginType=' + plugin.type
-
-    const emailPayload: EmailPayload = {
-      to,
-      template: 'plugin-version-new',
-      subject: `A new plugin/theme version is available: ${plugin.name}@${plugin.latestVersion}`,
-      locals: {
-        pluginName: plugin.name,
-        latestVersion: plugin.latestVersion,
-        pluginUrl
-      }
-    }
-
-    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
-  }
-
   addPasswordResetEmailJob (username: string, to: string, resetPasswordUrl: string) {
     const emailPayload: EmailPayload = {
       template: 'password-reset',
@@ -578,7 +150,11 @@ class Emailer {
       subjectPrefix: CONFIG.EMAIL.SUBJECT.PREFIX
     })
 
-    for (const to of options.to) {
+    const toEmails = isArray(options.to)
+      ? options.to
+      : [ options.to ]
+
+    for (const to of toEmails) {
       const baseOptions: SendEmailDefaultOptions = {
         template: 'common',
         message: {
diff --git a/server/lib/hls.ts b/server/lib/hls.ts
index 05be403f3..32b02bc26 100644
--- a/server/lib/hls.ts
+++ b/server/lib/hls.ts
@@ -1,7 +1,7 @@
 import { close, ensureDir, move, open, outputJSON, pathExists, read, readFile, remove, writeFile } from 'fs-extra'
 import { flatten, uniq } from 'lodash'
 import { basename, dirname, join } from 'path'
-import { MVideoWithFile } from '@server/types/models'
+import { MStreamingPlaylistFilesVideo, MVideoWithFile } from '@server/types/models'
 import { sha256 } from '../helpers/core-utils'
 import { getAudioStreamCodec, getVideoStreamCodec, getVideoStreamSize } from '../helpers/ffprobe-utils'
 import { logger } from '../helpers/logger'
@@ -12,7 +12,7 @@ import { HLS_STREAMING_PLAYLIST_DIRECTORY, P2P_MEDIA_LOADER_PEER_VERSION } from
 import { sequelizeTypescript } from '../initializers/database'
 import { VideoFileModel } from '../models/video/video-file'
 import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
-import { getVideoFilePath } from './video-paths'
+import { getHlsResolutionPlaylistFilename, getVideoFilePath } from './video-paths'
 
 async function updateStreamingPlaylistsInfohashesIfNeeded () {
   const playlistsToUpdate = await VideoStreamingPlaylistModel.listByIncorrectPeerVersion()
@@ -22,25 +22,29 @@ async function updateStreamingPlaylistsInfohashesIfNeeded () {
     await sequelizeTypescript.transaction(async t => {
       const videoFiles = await VideoFileModel.listByStreamingPlaylist(playlist.id, t)
 
-      playlist.p2pMediaLoaderInfohashes = VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(playlist.playlistUrl, videoFiles)
+      playlist.assignP2PMediaLoaderInfoHashes(playlist.Video, videoFiles)
       playlist.p2pMediaLoaderPeerVersion = P2P_MEDIA_LOADER_PEER_VERSION
+
       await playlist.save({ transaction: t })
     })
   }
 }
 
-async function updateMasterHLSPlaylist (video: MVideoWithFile) {
+async function updateMasterHLSPlaylist (video: MVideoWithFile, playlist: MStreamingPlaylistFilesVideo) {
   const directory = join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid)
+
   const masterPlaylists: string[] = [ '#EXTM3U', '#EXT-X-VERSION:3' ]
-  const masterPlaylistPath = join(directory, VideoStreamingPlaylistModel.getMasterHlsPlaylistFilename())
-  const streamingPlaylist = video.getHLSPlaylist()
 
-  for (const file of streamingPlaylist.VideoFiles) {
+  const masterPlaylistPath = join(directory, playlist.playlistFilename)
+
+  for (const file of playlist.VideoFiles) {
+    const playlistFilename = getHlsResolutionPlaylistFilename(file.filename)
+
     // If we did not generated a playlist for this resolution, skip
-    const filePlaylistPath = join(directory, VideoStreamingPlaylistModel.getHlsPlaylistFilename(file.resolution))
+    const filePlaylistPath = join(directory, playlistFilename)
     if (await pathExists(filePlaylistPath) === false) continue
 
-    const videoFilePath = getVideoFilePath(streamingPlaylist, file)
+    const videoFilePath = getVideoFilePath(playlist, file)
 
     const size = await getVideoStreamSize(videoFilePath)
 
@@ -58,29 +62,28 @@ async function updateMasterHLSPlaylist (video: MVideoWithFile) {
     line += `,CODECS="${codecs.filter(c => !!c).join(',')}"`
 
     masterPlaylists.push(line)
-    masterPlaylists.push(VideoStreamingPlaylistModel.getHlsPlaylistFilename(file.resolution))
+    masterPlaylists.push(playlistFilename)
   }
 
   await writeFile(masterPlaylistPath, masterPlaylists.join('\n') + '\n')
 }
 
-async function updateSha256VODSegments (video: MVideoWithFile) {
+async function updateSha256VODSegments (video: MVideoWithFile, playlist: MStreamingPlaylistFilesVideo) {
   const json: { [filename: string]: { [range: string]: string } } = {}
 
   const playlistDirectory = join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid)
-  const hlsPlaylist = video.getHLSPlaylist()
 
   // For all the resolutions available for this video
-  for (const file of hlsPlaylist.VideoFiles) {
+  for (const file of playlist.VideoFiles) {
     const rangeHashes: { [range: string]: string } = {}
 
-    const videoPath = getVideoFilePath(hlsPlaylist, file)
-    const playlistPath = join(playlistDirectory, VideoStreamingPlaylistModel.getHlsPlaylistFilename(file.resolution))
+    const videoPath = getVideoFilePath(playlist, file)
+    const resolutionPlaylistPath = join(playlistDirectory, getHlsResolutionPlaylistFilename(file.filename))
 
     // Maybe the playlist is not generated for this resolution yet
-    if (!await pathExists(playlistPath)) continue
+    if (!await pathExists(resolutionPlaylistPath)) continue
 
-    const playlistContent = await readFile(playlistPath)
+    const playlistContent = await readFile(resolutionPlaylistPath)
     const ranges = getRangesFromPlaylist(playlistContent.toString())
 
     const fd = await open(videoPath, 'r')
@@ -96,7 +99,7 @@ async function updateSha256VODSegments (video: MVideoWithFile) {
     json[videoFilename] = rangeHashes
   }
 
-  const outputPath = join(playlistDirectory, VideoStreamingPlaylistModel.getHlsSha256SegmentsFilename())
+  const outputPath = join(playlistDirectory, playlist.segmentsSha256Filename)
   await outputJSON(outputPath, json)
 }
 
diff --git a/server/lib/job-queue/handlers/activitypub-cleaner.ts b/server/lib/job-queue/handlers/activitypub-cleaner.ts
index 1caca1dcc..56e2b0ceb 100644
--- a/server/lib/job-queue/handlers/activitypub-cleaner.ts
+++ b/server/lib/job-queue/handlers/activitypub-cleaner.ts
@@ -12,7 +12,7 @@ import { AP_CLEANER_CONCURRENCY } from '@server/initializers/constants'
 import { VideoModel } from '@server/models/video/video'
 import { VideoCommentModel } from '@server/models/video/video-comment'
 import { VideoShareModel } from '@server/models/video/video-share'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 import { logger } from '../../../helpers/logger'
 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
 
diff --git a/server/lib/job-queue/handlers/video-file-import.ts b/server/lib/job-queue/handlers/video-file-import.ts
index 187cb652e..4d199f247 100644
--- a/server/lib/job-queue/handlers/video-file-import.ts
+++ b/server/lib/job-queue/handlers/video-file-import.ts
@@ -2,7 +2,7 @@ import * as Bull from 'bull'
 import { copy, stat } from 'fs-extra'
 import { getLowercaseExtension } from '@server/helpers/core-utils'
 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
-import { generateVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
+import { generateWebTorrentVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
 import { UserModel } from '@server/models/user/user'
 import { MVideoFullLight } from '@server/types/models'
 import { VideoFileImportPayload } from '@shared/models'
@@ -61,8 +61,7 @@ async function updateVideoFile (video: MVideoFullLight, inputFilePath: string) {
 
   if (currentVideoFile) {
     // Remove old file and old torrent
-    await video.removeFile(currentVideoFile)
-    await currentVideoFile.removeTorrent()
+    await video.removeFileAndTorrent(currentVideoFile)
     // Remove the old video file from the array
     video.VideoFiles = video.VideoFiles.filter(f => f !== currentVideoFile)
 
@@ -72,7 +71,7 @@ async function updateVideoFile (video: MVideoFullLight, inputFilePath: string) {
   const newVideoFile = new VideoFileModel({
     resolution: videoFileResolution,
     extname: fileExt,
-    filename: generateVideoFilename(video, false, videoFileResolution, fileExt),
+    filename: generateWebTorrentVideoFilename(videoFileResolution, fileExt),
     size,
     fps,
     videoId: video.id
diff --git a/server/lib/job-queue/handlers/video-import.ts b/server/lib/job-queue/handlers/video-import.ts
index 55498003d..5fd2039b1 100644
--- a/server/lib/job-queue/handlers/video-import.ts
+++ b/server/lib/job-queue/handlers/video-import.ts
@@ -8,7 +8,7 @@ import { Hooks } from '@server/lib/plugins/hooks'
 import { ServerConfigManager } from '@server/lib/server-config-manager'
 import { isAbleToUploadVideo } from '@server/lib/user'
 import { addOptimizeOrMergeAudioJob } from '@server/lib/video'
-import { generateVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
+import { generateWebTorrentVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
 import { ThumbnailModel } from '@server/models/video/thumbnail'
 import { MVideoImportDefault, MVideoImportDefaultFiles, MVideoImportVideo } from '@server/types/models/video/video-import'
 import {
@@ -124,7 +124,7 @@ async function processFile (downloader: () => Promise<string>, videoImport: MVid
       extname: fileExt,
       resolution: videoFileResolution,
       size: stats.size,
-      filename: generateVideoFilename(videoImport.Video, false, videoFileResolution, fileExt),
+      filename: generateWebTorrentVideoFilename(videoFileResolution, fileExt),
       fps,
       videoId: videoImport.videoId
     }
@@ -235,7 +235,7 @@ async function processFile (downloader: () => Promise<string>, videoImport: MVid
       })
     })
 
-    Notifier.Instance.notifyOnFinishedVideoImport(videoImportUpdated, true)
+    Notifier.Instance.notifyOnFinishedVideoImport({ videoImport: videoImportUpdated, success: true })
 
     if (video.isBlacklisted()) {
       const videoBlacklist = Object.assign(video.VideoBlacklist, { Video: video })
@@ -263,7 +263,7 @@ async function processFile (downloader: () => Promise<string>, videoImport: MVid
     }
     await videoImport.save()
 
-    Notifier.Instance.notifyOnFinishedVideoImport(videoImport, false)
+    Notifier.Instance.notifyOnFinishedVideoImport({ videoImport, success: false })
 
     throw err
   }
diff --git a/server/lib/job-queue/handlers/video-live-ending.ts b/server/lib/job-queue/handlers/video-live-ending.ts
index 9eba41bf8..386ccdc7b 100644
--- a/server/lib/job-queue/handlers/video-live-ending.ts
+++ b/server/lib/job-queue/handlers/video-live-ending.ts
@@ -7,12 +7,12 @@ import { buildConcatenatedName, cleanupLive, LiveSegmentShaStore } from '@server
 import { generateVideoMiniature } from '@server/lib/thumbnail'
 import { generateHlsPlaylistResolutionFromTS } from '@server/lib/transcoding/video-transcoding'
 import { publishAndFederateIfNeeded } from '@server/lib/video'
-import { getHLSDirectory } from '@server/lib/video-paths'
+import { generateHLSMasterPlaylistFilename, generateHlsSha256SegmentsFilename, getHLSDirectory } from '@server/lib/video-paths'
 import { VideoModel } from '@server/models/video/video'
 import { VideoFileModel } from '@server/models/video/video-file'
 import { VideoLiveModel } from '@server/models/video/video-live'
 import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist'
-import { MVideo, MVideoLive } from '@server/types/models'
+import { MStreamingPlaylist, MVideo, MVideoLive } from '@server/types/models'
 import { ThumbnailType, VideoLiveEndingPayload, VideoState } from '@shared/models'
 import { logger } from '../../../helpers/logger'
 
@@ -43,7 +43,7 @@ async function processVideoLiveEnding (job: Bull.Job) {
     return cleanupLive(video, streamingPlaylist)
   }
 
-  return saveLive(video, live)
+  return saveLive(video, live, streamingPlaylist)
 }
 
 // ---------------------------------------------------------------------------
@@ -54,14 +54,14 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function saveLive (video: MVideo, live: MVideoLive) {
+async function saveLive (video: MVideo, live: MVideoLive, streamingPlaylist: MStreamingPlaylist) {
   const hlsDirectory = getHLSDirectory(video, false)
   const replayDirectory = join(hlsDirectory, VIDEO_LIVE.REPLAY_DIRECTORY)
 
   const rootFiles = await readdir(hlsDirectory)
 
   const playlistFiles = rootFiles.filter(file => {
-    return file.endsWith('.m3u8') && file !== 'master.m3u8'
+    return file.endsWith('.m3u8') && file !== streamingPlaylist.playlistFilename
   })
 
   await cleanupLiveFiles(hlsDirectory)
@@ -80,7 +80,12 @@ async function saveLive (video: MVideo, live: MVideoLive) {
 
   const hlsPlaylist = videoWithFiles.getHLSPlaylist()
   await VideoFileModel.removeHLSFilesOfVideoId(hlsPlaylist.id)
+
+  // Reset playlist
   hlsPlaylist.VideoFiles = []
+  hlsPlaylist.playlistFilename = generateHLSMasterPlaylistFilename()
+  hlsPlaylist.segmentsSha256Filename = generateHlsSha256SegmentsFilename()
+  await hlsPlaylist.save()
 
   let durationDone = false
 
diff --git a/server/lib/job-queue/handlers/video-transcoding.ts b/server/lib/job-queue/handlers/video-transcoding.ts
index f5ba6f435..2abb351ce 100644
--- a/server/lib/job-queue/handlers/video-transcoding.ts
+++ b/server/lib/job-queue/handlers/video-transcoding.ts
@@ -28,21 +28,10 @@ import { JobQueue } from '../job-queue'
 
 type HandlerFunction = (job: Bull.Job, payload: VideoTranscodingPayload, video: MVideoFullLight, user: MUser) => Promise<any>
 
-const handlers: { [ id: string ]: HandlerFunction } = {
-  // Deprecated, introduced in 3.1
-  'hls': handleHLSJob,
+const handlers: { [ id in VideoTranscodingPayload['type'] ]: HandlerFunction } = {
   'new-resolution-to-hls': handleHLSJob,
-
-  // Deprecated, introduced in 3.1
-  'new-resolution': handleNewWebTorrentResolutionJob,
   'new-resolution-to-webtorrent': handleNewWebTorrentResolutionJob,
-
-  // Deprecated, introduced in 3.1
-  'merge-audio': handleWebTorrentMergeAudioJob,
   'merge-audio-to-webtorrent': handleWebTorrentMergeAudioJob,
-
-  // Deprecated, introduced in 3.1
-  'optimize': handleWebTorrentOptimizeJob,
   'optimize-to-webtorrent': handleWebTorrentOptimizeJob
 }
 
@@ -125,8 +114,7 @@ async function onHlsPlaylistGeneration (video: MVideoFullLight, user: MUser, pay
   if (payload.isMaxQuality && CONFIG.TRANSCODING.WEBTORRENT.ENABLED === false) {
     // Remove webtorrent files if not enabled
     for (const file of video.VideoFiles) {
-      await video.removeFile(file)
-      await file.removeTorrent()
+      await video.removeFileAndTorrent(file)
       await file.destroy()
     }
 
diff --git a/server/lib/live/live-manager.ts b/server/lib/live/live-manager.ts
index 014cd3fcf..f106d69fb 100644
--- a/server/lib/live/live-manager.ts
+++ b/server/lib/live/live-manager.ts
@@ -4,24 +4,25 @@ import { isTestInstance } from '@server/helpers/core-utils'
 import { computeResolutionsToTranscode, getVideoFileFPS, getVideoFileResolution } from '@server/helpers/ffprobe-utils'
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
 import { CONFIG, registerConfigChangedHandler } from '@server/initializers/config'
-import { P2P_MEDIA_LOADER_PEER_VERSION, VIDEO_LIVE, VIEW_LIFETIME, WEBSERVER } from '@server/initializers/constants'
+import { P2P_MEDIA_LOADER_PEER_VERSION, VIDEO_LIVE, VIEW_LIFETIME } from '@server/initializers/constants'
 import { UserModel } from '@server/models/user/user'
 import { VideoModel } from '@server/models/video/video'
 import { VideoLiveModel } from '@server/models/video/video-live'
 import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist'
-import { MStreamingPlaylist, MStreamingPlaylistVideo, MVideo, MVideoLiveVideo } from '@server/types/models'
+import { MStreamingPlaylistVideo, MVideo, MVideoLiveVideo } from '@server/types/models'
 import { VideoState, VideoStreamingPlaylistType } from '@shared/models'
 import { federateVideoIfNeeded } from '../activitypub/videos'
 import { JobQueue } from '../job-queue'
 import { PeerTubeSocket } from '../peertube-socket'
+import { generateHLSMasterPlaylistFilename, generateHlsSha256SegmentsFilename } from '../video-paths'
 import { LiveQuotaStore } from './live-quota-store'
 import { LiveSegmentShaStore } from './live-segment-sha-store'
 import { cleanupLive } from './live-utils'
 import { MuxingSession } from './shared'
 
-const NodeRtmpSession = require('node-media-server/node_rtmp_session')
-const context = require('node-media-server/node_core_ctx')
-const nodeMediaServerLogger = require('node-media-server/node_core_logger')
+const NodeRtmpSession = require('node-media-server/src/node_rtmp_session')
+const context = require('node-media-server/src/node_core_ctx')
+const nodeMediaServerLogger = require('node-media-server/src/node_core_logger')
 
 // Disable node media server logs
 nodeMediaServerLogger.setLogType(0)
@@ -392,19 +393,18 @@ class LiveManager {
     return resolutionsEnabled.concat([ originResolution ])
   }
 
-  private async createLivePlaylist (video: MVideo, allResolutions: number[]) {
-    const playlistUrl = WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsMasterPlaylistStaticPath(video.uuid)
-    const [ videoStreamingPlaylist ] = await VideoStreamingPlaylistModel.upsert({
-      videoId: video.id,
-      playlistUrl,
-      segmentsSha256Url: WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsSha256SegmentsStaticPath(video.uuid, video.isLive),
-      p2pMediaLoaderInfohashes: VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(playlistUrl, allResolutions),
-      p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
+  private async createLivePlaylist (video: MVideo, allResolutions: number[]): Promise<MStreamingPlaylistVideo> {
+    const playlist = await VideoStreamingPlaylistModel.loadOrGenerate(video)
 
-      type: VideoStreamingPlaylistType.HLS
-    }, { returning: true }) as [ MStreamingPlaylist, boolean ]
+    playlist.playlistFilename = generateHLSMasterPlaylistFilename(true)
+    playlist.segmentsSha256Filename = generateHlsSha256SegmentsFilename(true)
 
-    return Object.assign(videoStreamingPlaylist, { Video: video })
+    playlist.p2pMediaLoaderPeerVersion = P2P_MEDIA_LOADER_PEER_VERSION
+    playlist.type = VideoStreamingPlaylistType.HLS
+
+    playlist.assignP2PMediaLoaderInfoHashes(video, allResolutions)
+
+    return playlist.save()
   }
 
   static get Instance () {
diff --git a/server/lib/live/shared/muxing-session.ts b/server/lib/live/shared/muxing-session.ts
index 26467f060..709d6c615 100644
--- a/server/lib/live/shared/muxing-session.ts
+++ b/server/lib/live/shared/muxing-session.ts
@@ -112,13 +112,16 @@ class MuxingSession extends EventEmitter {
     this.ffmpegCommand = CONFIG.LIVE.TRANSCODING.ENABLED
       ? await getLiveTranscodingCommand({
         rtmpUrl: this.rtmpUrl,
+
         outPath,
+        masterPlaylistName: this.streamingPlaylist.playlistFilename,
+
         resolutions: this.allResolutions,
         fps: this.fps,
         availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
         profile: CONFIG.LIVE.TRANSCODING.PROFILE
       })
-      : getLiveMuxingCommand(this.rtmpUrl, outPath)
+      : getLiveMuxingCommand(this.rtmpUrl, outPath, this.streamingPlaylist.playlistFilename)
 
     logger.info('Running live muxing/transcoding for %s.', this.videoUUID, this.lTags)
 
@@ -182,7 +185,7 @@ class MuxingSession extends EventEmitter {
   }
 
   private watchMasterFile (outPath: string) {
-    this.masterWatcher = chokidar.watch(outPath + '/master.m3u8')
+    this.masterWatcher = chokidar.watch(outPath + '/' + this.streamingPlaylist.playlistFilename)
 
     this.masterWatcher.on('add', async () => {
       this.emit('master-playlist-created', { videoId: this.videoId })
diff --git a/server/lib/moderation.ts b/server/lib/moderation.ts
index 14e00518e..a42ab5b7f 100644
--- a/server/lib/moderation.ts
+++ b/server/lib/moderation.ts
@@ -23,7 +23,7 @@ import { ActivityCreate } from '../../shared/models/activitypub'
 import { VideoObject } from '../../shared/models/activitypub/objects'
 import { VideoCommentObject } from '../../shared/models/activitypub/objects/video-comment-object'
 import { LiveVideoCreate, VideoCreate, VideoImportCreate } from '../../shared/models/videos'
-import { VideoCommentCreate } from '../../shared/models/videos/comment/video-comment.model'
+import { VideoCommentCreate } from '../../shared/models/videos/comment'
 import { ActorModel } from '../models/actor/actor'
 import { UserModel } from '../models/user/user'
 import { VideoModel } from '../models/video/video'
diff --git a/server/lib/notifier.ts b/server/lib/notifier.ts
deleted file mode 100644
index 1f9ff16df..000000000
--- a/server/lib/notifier.ts
+++ /dev/null
@@ -1,796 +0,0 @@
-import { AccountModel } from '@server/models/account/account'
-import { getServerActor } from '@server/models/application/application'
-import { ServerBlocklistModel } from '@server/models/server/server-blocklist'
-import {
-  MUser,
-  MUserAccount,
-  MUserDefault,
-  MUserNotifSettingAccount,
-  MUserWithNotificationSetting,
-  UserNotificationModelForApi
-} from '@server/types/models/user'
-import { MVideoBlacklistLightVideo, MVideoBlacklistVideo } from '@server/types/models/video/video-blacklist'
-import { MVideoImportVideo } from '@server/types/models/video/video-import'
-import { UserAbuse } from '@shared/models'
-import { UserNotificationSettingValue, UserNotificationType, UserRight } from '../../shared/models/users'
-import { VideoPrivacy, VideoState } from '../../shared/models/videos'
-import { logger } from '../helpers/logger'
-import { CONFIG } from '../initializers/config'
-import { AccountBlocklistModel } from '../models/account/account-blocklist'
-import { UserModel } from '../models/user/user'
-import { UserNotificationModel } from '../models/user/user-notification'
-import { MAbuseFull, MAbuseMessage, MAccountServer, MActorFollowFull, MApplication, MPlugin } from '../types/models'
-import { MCommentOwnerVideo, MVideoAccountLight, MVideoFullLight } from '../types/models/video'
-import { isBlockedByServerOrAccount } from './blocklist'
-import { Emailer } from './emailer'
-import { PeerTubeSocket } from './peertube-socket'
-
-class Notifier {
-
-  private static instance: Notifier
-
-  private constructor () {
-  }
-
-  notifyOnNewVideoIfNeeded (video: MVideoAccountLight): void {
-    // Only notify on public and published videos which are not blacklisted
-    if (video.privacy !== VideoPrivacy.PUBLIC || video.state !== VideoState.PUBLISHED || video.isBlacklisted()) return
-
-    this.notifySubscribersOfNewVideo(video)
-        .catch(err => logger.error('Cannot notify subscribers of new video %s.', video.url, { err }))
-  }
-
-  notifyOnVideoPublishedAfterTranscoding (video: MVideoFullLight): void {
-    // don't notify if didn't wait for transcoding or video is still blacklisted/waiting for scheduled update
-    if (!video.waitTranscoding || video.VideoBlacklist || video.ScheduleVideoUpdate) return
-
-    this.notifyOwnedVideoHasBeenPublished(video)
-        .catch(err => logger.error('Cannot notify owner that its video %s has been published after transcoding.', video.url, { err }))
-  }
-
-  notifyOnVideoPublishedAfterScheduledUpdate (video: MVideoFullLight): void {
-    // don't notify if video is still blacklisted or waiting for transcoding
-    if (video.VideoBlacklist || (video.waitTranscoding && video.state !== VideoState.PUBLISHED)) return
-
-    this.notifyOwnedVideoHasBeenPublished(video)
-        .catch(err => logger.error('Cannot notify owner that its video %s has been published after scheduled update.', video.url, { err }))
-  }
-
-  notifyOnVideoPublishedAfterRemovedFromAutoBlacklist (video: MVideoFullLight): void {
-    // don't notify if video is still waiting for transcoding or scheduled update
-    if (video.ScheduleVideoUpdate || (video.waitTranscoding && video.state !== VideoState.PUBLISHED)) return
-
-    this.notifyOwnedVideoHasBeenPublished(video)
-        .catch(err => {
-          logger.error('Cannot notify owner that its video %s has been published after removed from auto-blacklist.', video.url, { err })
-        })
-  }
-
-  notifyOnNewComment (comment: MCommentOwnerVideo): void {
-    this.notifyVideoOwnerOfNewComment(comment)
-        .catch(err => logger.error('Cannot notify video owner of new comment %s.', comment.url, { err }))
-
-    this.notifyOfCommentMention(comment)
-        .catch(err => logger.error('Cannot notify mentions of comment %s.', comment.url, { err }))
-  }
-
-  notifyOnNewAbuse (parameters: { abuse: UserAbuse, abuseInstance: MAbuseFull, reporter: string }): void {
-    this.notifyModeratorsOfNewAbuse(parameters)
-        .catch(err => logger.error('Cannot notify of new abuse %d.', parameters.abuseInstance.id, { err }))
-  }
-
-  notifyOnVideoAutoBlacklist (videoBlacklist: MVideoBlacklistLightVideo): void {
-    this.notifyModeratorsOfVideoAutoBlacklist(videoBlacklist)
-        .catch(err => logger.error('Cannot notify of auto-blacklist of video %s.', videoBlacklist.Video.url, { err }))
-  }
-
-  notifyOnVideoBlacklist (videoBlacklist: MVideoBlacklistVideo): void {
-    this.notifyVideoOwnerOfBlacklist(videoBlacklist)
-        .catch(err => logger.error('Cannot notify video owner of new video blacklist of %s.', videoBlacklist.Video.url, { err }))
-  }
-
-  notifyOnVideoUnblacklist (video: MVideoFullLight): void {
-    this.notifyVideoOwnerOfUnblacklist(video)
-        .catch(err => logger.error('Cannot notify video owner of unblacklist of %s.', video.url, { err }))
-  }
-
-  notifyOnFinishedVideoImport (videoImport: MVideoImportVideo, success: boolean): void {
-    this.notifyOwnerVideoImportIsFinished(videoImport, success)
-        .catch(err => logger.error('Cannot notify owner that its video import %s is finished.', videoImport.getTargetIdentifier(), { err }))
-  }
-
-  notifyOnNewUserRegistration (user: MUserDefault): void {
-    this.notifyModeratorsOfNewUserRegistration(user)
-        .catch(err => logger.error('Cannot notify moderators of new user registration (%s).', user.username, { err }))
-  }
-
-  notifyOfNewUserFollow (actorFollow: MActorFollowFull): void {
-    this.notifyUserOfNewActorFollow(actorFollow)
-        .catch(err => {
-          logger.error(
-            'Cannot notify owner of channel %s of a new follow by %s.',
-            actorFollow.ActorFollowing.VideoChannel.getDisplayName(),
-            actorFollow.ActorFollower.Account.getDisplayName(),
-            { err }
-          )
-        })
-  }
-
-  notifyOfNewInstanceFollow (actorFollow: MActorFollowFull): void {
-    this.notifyAdminsOfNewInstanceFollow(actorFollow)
-        .catch(err => {
-          logger.error('Cannot notify administrators of new follower %s.', actorFollow.ActorFollower.url, { err })
-        })
-  }
-
-  notifyOfAutoInstanceFollowing (actorFollow: MActorFollowFull): void {
-    this.notifyAdminsOfAutoInstanceFollowing(actorFollow)
-        .catch(err => {
-          logger.error('Cannot notify administrators of auto instance following %s.', actorFollow.ActorFollowing.url, { err })
-        })
-  }
-
-  notifyOnAbuseStateChange (abuse: MAbuseFull): void {
-    this.notifyReporterOfAbuseStateChange(abuse)
-      .catch(err => {
-        logger.error('Cannot notify reporter of abuse %d state change.', abuse.id, { err })
-      })
-  }
-
-  notifyOnAbuseMessage (abuse: MAbuseFull, message: MAbuseMessage): void {
-    this.notifyOfNewAbuseMessage(abuse, message)
-      .catch(err => {
-        logger.error('Cannot notify on new abuse %d message.', abuse.id, { err })
-      })
-  }
-
-  notifyOfNewPeerTubeVersion (application: MApplication, latestVersion: string) {
-    this.notifyAdminsOfNewPeerTubeVersion(application, latestVersion)
-      .catch(err => {
-        logger.error('Cannot notify on new PeerTubeb version %s.', latestVersion, { err })
-      })
-  }
-
-  notifyOfNewPluginVersion (plugin: MPlugin) {
-    this.notifyAdminsOfNewPluginVersion(plugin)
-      .catch(err => {
-        logger.error('Cannot notify on new plugin version %s.', plugin.name, { err })
-      })
-  }
-
-  private async notifySubscribersOfNewVideo (video: MVideoAccountLight) {
-    // List all followers that are users
-    const users = await UserModel.listUserSubscribersOf(video.VideoChannel.actorId)
-
-    logger.info('Notifying %d users of new video %s.', users.length, video.url)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.newVideoFromSubscription
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION,
-        userId: user.id,
-        videoId: video.id
-      })
-      notification.Video = video
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addNewVideoFromSubscriberNotification(emails, video)
-    }
-
-    return this.notify({ users, settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyVideoOwnerOfNewComment (comment: MCommentOwnerVideo) {
-    if (comment.Video.isOwned() === false) return
-
-    const user = await UserModel.loadByVideoId(comment.videoId)
-
-    // Not our user or user comments its own video
-    if (!user || comment.Account.userId === user.id) return
-
-    if (await this.isBlockedByServerOrUser(comment.Account, user)) return
-
-    logger.info('Notifying user %s of new comment %s.', user.username, comment.url)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.newCommentOnMyVideo
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.NEW_COMMENT_ON_MY_VIDEO,
-        userId: user.id,
-        commentId: comment.id
-      })
-      notification.Comment = comment
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addNewCommentOnMyVideoNotification(emails, comment)
-    }
-
-    return this.notify({ users: [ user ], settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyOfCommentMention (comment: MCommentOwnerVideo) {
-    const extractedUsernames = comment.extractMentions()
-    logger.debug(
-      'Extracted %d username from comment %s.', extractedUsernames.length, comment.url,
-      { usernames: extractedUsernames, text: comment.text }
-    )
-
-    let users = await UserModel.listByUsernames(extractedUsernames)
-
-    if (comment.Video.isOwned()) {
-      const userException = await UserModel.loadByVideoId(comment.videoId)
-      users = users.filter(u => u.id !== userException.id)
-    }
-
-    // Don't notify if I mentioned myself
-    users = users.filter(u => u.Account.id !== comment.accountId)
-
-    if (users.length === 0) return
-
-    const serverAccountId = (await getServerActor()).Account.id
-    const sourceAccounts = users.map(u => u.Account.id).concat([ serverAccountId ])
-
-    const accountMutedHash = await AccountBlocklistModel.isAccountMutedByMulti(sourceAccounts, comment.accountId)
-    const instanceMutedHash = await ServerBlocklistModel.isServerMutedByMulti(sourceAccounts, comment.Account.Actor.serverId)
-
-    logger.info('Notifying %d users of new comment %s.', users.length, comment.url)
-
-    function settingGetter (user: MUserNotifSettingAccount) {
-      const accountId = user.Account.id
-      if (
-        accountMutedHash[accountId] === true || instanceMutedHash[accountId] === true ||
-        accountMutedHash[serverAccountId] === true || instanceMutedHash[serverAccountId] === true
-      ) {
-        return UserNotificationSettingValue.NONE
-      }
-
-      return user.NotificationSetting.commentMention
-    }
-
-    async function notificationCreator (user: MUserNotifSettingAccount) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.COMMENT_MENTION,
-        userId: user.id,
-        commentId: comment.id
-      })
-      notification.Comment = comment
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addNewCommentMentionNotification(emails, comment)
-    }
-
-    return this.notify({ users, settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyUserOfNewActorFollow (actorFollow: MActorFollowFull) {
-    if (actorFollow.ActorFollowing.isOwned() === false) return
-
-    // Account follows one of our account?
-    let followType: 'account' | 'channel' = 'channel'
-    let user = await UserModel.loadByChannelActorId(actorFollow.ActorFollowing.id)
-
-    // Account follows one of our channel?
-    if (!user) {
-      user = await UserModel.loadByAccountActorId(actorFollow.ActorFollowing.id)
-      followType = 'account'
-    }
-
-    if (!user) return
-
-    const followerAccount = actorFollow.ActorFollower.Account
-    const followerAccountWithActor = Object.assign(followerAccount, { Actor: actorFollow.ActorFollower })
-
-    if (await this.isBlockedByServerOrUser(followerAccountWithActor, user)) return
-
-    logger.info('Notifying user %s of new follower: %s.', user.username, followerAccount.getDisplayName())
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.newFollow
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.NEW_FOLLOW,
-        userId: user.id,
-        actorFollowId: actorFollow.id
-      })
-      notification.ActorFollow = actorFollow
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addNewFollowNotification(emails, actorFollow, followType)
-    }
-
-    return this.notify({ users: [ user ], settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyAdminsOfNewInstanceFollow (actorFollow: MActorFollowFull) {
-    const admins = await UserModel.listWithRight(UserRight.MANAGE_SERVER_FOLLOW)
-
-    const follower = Object.assign(actorFollow.ActorFollower.Account, { Actor: actorFollow.ActorFollower })
-    if (await this.isBlockedByServerOrUser(follower)) return
-
-    logger.info('Notifying %d administrators of new instance follower: %s.', admins.length, actorFollow.ActorFollower.url)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.newInstanceFollower
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.NEW_INSTANCE_FOLLOWER,
-        userId: user.id,
-        actorFollowId: actorFollow.id
-      })
-      notification.ActorFollow = actorFollow
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addNewInstanceFollowerNotification(emails, actorFollow)
-    }
-
-    return this.notify({ users: admins, settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyAdminsOfAutoInstanceFollowing (actorFollow: MActorFollowFull) {
-    const admins = await UserModel.listWithRight(UserRight.MANAGE_SERVER_FOLLOW)
-
-    logger.info('Notifying %d administrators of auto instance following: %s.', admins.length, actorFollow.ActorFollowing.url)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.autoInstanceFollowing
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.AUTO_INSTANCE_FOLLOWING,
-        userId: user.id,
-        actorFollowId: actorFollow.id
-      })
-      notification.ActorFollow = actorFollow
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addAutoInstanceFollowingNotification(emails, actorFollow)
-    }
-
-    return this.notify({ users: admins, settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyModeratorsOfNewAbuse (parameters: {
-    abuse: UserAbuse
-    abuseInstance: MAbuseFull
-    reporter: string
-  }) {
-    const { abuse, abuseInstance } = parameters
-
-    const moderators = await UserModel.listWithRight(UserRight.MANAGE_ABUSES)
-    if (moderators.length === 0) return
-
-    const url = this.getAbuseUrl(abuseInstance)
-
-    logger.info('Notifying %s user/moderators of new abuse %s.', moderators.length, url)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.abuseAsModerator
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.NEW_ABUSE_FOR_MODERATORS,
-        userId: user.id,
-        abuseId: abuse.id
-      })
-      notification.Abuse = abuseInstance
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addAbuseModeratorsNotification(emails, parameters)
-    }
-
-    return this.notify({ users: moderators, settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyReporterOfAbuseStateChange (abuse: MAbuseFull) {
-    // Only notify our users
-    if (abuse.ReporterAccount.isOwned() !== true) return
-
-    const url = this.getAbuseUrl(abuse)
-
-    logger.info('Notifying reporter of abuse % of state change.', url)
-
-    const reporter = await UserModel.loadByAccountActorId(abuse.ReporterAccount.actorId)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.abuseStateChange
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.ABUSE_STATE_CHANGE,
-        userId: user.id,
-        abuseId: abuse.id
-      })
-      notification.Abuse = abuse
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addAbuseStateChangeNotification(emails, abuse)
-    }
-
-    return this.notify({ users: [ reporter ], settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyOfNewAbuseMessage (abuse: MAbuseFull, message: MAbuseMessage) {
-    const url = this.getAbuseUrl(abuse)
-    logger.info('Notifying reporter and moderators of new abuse message on %s.', url)
-
-    const accountMessage = await AccountModel.load(message.accountId)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.abuseNewMessage
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.ABUSE_NEW_MESSAGE,
-        userId: user.id,
-        abuseId: abuse.id
-      })
-      notification.Abuse = abuse
-
-      return notification
-    }
-
-    function emailSenderReporter (emails: string[]) {
-      return Emailer.Instance.addAbuseNewMessageNotification(emails, { target: 'reporter', abuse, message, accountMessage })
-    }
-
-    function emailSenderModerators (emails: string[]) {
-      return Emailer.Instance.addAbuseNewMessageNotification(emails, { target: 'moderator', abuse, message, accountMessage })
-    }
-
-    async function buildReporterOptions () {
-      // Only notify our users
-      if (abuse.ReporterAccount.isOwned() !== true) return undefined
-
-      const reporter = await UserModel.loadByAccountActorId(abuse.ReporterAccount.actorId)
-      // Don't notify my own message
-      if (reporter.Account.id === message.accountId) return undefined
-
-      return { users: [ reporter ], settingGetter, notificationCreator, emailSender: emailSenderReporter }
-    }
-
-    async function buildModeratorsOptions () {
-      let moderators = await UserModel.listWithRight(UserRight.MANAGE_ABUSES)
-      // Don't notify my own message
-      moderators = moderators.filter(m => m.Account.id !== message.accountId)
-
-      if (moderators.length === 0) return undefined
-
-      return { users: moderators, settingGetter, notificationCreator, emailSender: emailSenderModerators }
-    }
-
-    const options = await Promise.all([
-      buildReporterOptions(),
-      buildModeratorsOptions()
-    ])
-
-    return Promise.all(
-      options
-        .filter(opt => !!opt)
-        .map(opt => this.notify(opt))
-    )
-  }
-
-  private async notifyModeratorsOfVideoAutoBlacklist (videoBlacklist: MVideoBlacklistLightVideo) {
-    const moderators = await UserModel.listWithRight(UserRight.MANAGE_VIDEO_BLACKLIST)
-    if (moderators.length === 0) return
-
-    logger.info('Notifying %s moderators of video auto-blacklist %s.', moderators.length, videoBlacklist.Video.url)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.videoAutoBlacklistAsModerator
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.VIDEO_AUTO_BLACKLIST_FOR_MODERATORS,
-        userId: user.id,
-        videoBlacklistId: videoBlacklist.id
-      })
-      notification.VideoBlacklist = videoBlacklist
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addVideoAutoBlacklistModeratorsNotification(emails, videoBlacklist)
-    }
-
-    return this.notify({ users: moderators, settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyVideoOwnerOfBlacklist (videoBlacklist: MVideoBlacklistVideo) {
-    const user = await UserModel.loadByVideoId(videoBlacklist.videoId)
-    if (!user) return
-
-    logger.info('Notifying user %s that its video %s has been blacklisted.', user.username, videoBlacklist.Video.url)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.blacklistOnMyVideo
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.BLACKLIST_ON_MY_VIDEO,
-        userId: user.id,
-        videoBlacklistId: videoBlacklist.id
-      })
-      notification.VideoBlacklist = videoBlacklist
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addVideoBlacklistNotification(emails, videoBlacklist)
-    }
-
-    return this.notify({ users: [ user ], settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyVideoOwnerOfUnblacklist (video: MVideoFullLight) {
-    const user = await UserModel.loadByVideoId(video.id)
-    if (!user) return
-
-    logger.info('Notifying user %s that its video %s has been unblacklisted.', user.username, video.url)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.blacklistOnMyVideo
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.UNBLACKLIST_ON_MY_VIDEO,
-        userId: user.id,
-        videoId: video.id
-      })
-      notification.Video = video
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addVideoUnblacklistNotification(emails, video)
-    }
-
-    return this.notify({ users: [ user ], settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyOwnedVideoHasBeenPublished (video: MVideoFullLight) {
-    const user = await UserModel.loadByVideoId(video.id)
-    if (!user) return
-
-    logger.info('Notifying user %s of the publication of its video %s.', user.username, video.url)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.myVideoPublished
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.MY_VIDEO_PUBLISHED,
-        userId: user.id,
-        videoId: video.id
-      })
-      notification.Video = video
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.myVideoPublishedNotification(emails, video)
-    }
-
-    return this.notify({ users: [ user ], settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyOwnerVideoImportIsFinished (videoImport: MVideoImportVideo, success: boolean) {
-    const user = await UserModel.loadByVideoImportId(videoImport.id)
-    if (!user) return
-
-    logger.info('Notifying user %s its video import %s is finished.', user.username, videoImport.getTargetIdentifier())
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.myVideoImportFinished
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: success ? UserNotificationType.MY_VIDEO_IMPORT_SUCCESS : UserNotificationType.MY_VIDEO_IMPORT_ERROR,
-        userId: user.id,
-        videoImportId: videoImport.id
-      })
-      notification.VideoImport = videoImport
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return success
-        ? Emailer.Instance.myVideoImportSuccessNotification(emails, videoImport)
-        : Emailer.Instance.myVideoImportErrorNotification(emails, videoImport)
-    }
-
-    return this.notify({ users: [ user ], settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyModeratorsOfNewUserRegistration (registeredUser: MUserDefault) {
-    const moderators = await UserModel.listWithRight(UserRight.MANAGE_USERS)
-    if (moderators.length === 0) return
-
-    logger.info(
-      'Notifying %s moderators of new user registration of %s.',
-      moderators.length, registeredUser.username
-    )
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.newUserRegistration
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.NEW_USER_REGISTRATION,
-        userId: user.id,
-        accountId: registeredUser.Account.id
-      })
-      notification.Account = registeredUser.Account
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addNewUserRegistrationNotification(emails, registeredUser)
-    }
-
-    return this.notify({ users: moderators, settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyAdminsOfNewPeerTubeVersion (application: MApplication, latestVersion: string) {
-    // Use the debug right to know who is an administrator
-    const admins = await UserModel.listWithRight(UserRight.MANAGE_DEBUG)
-    if (admins.length === 0) return
-
-    logger.info('Notifying %s admins of new PeerTube version %s.', admins.length, latestVersion)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.newPeerTubeVersion
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.NEW_PEERTUBE_VERSION,
-        userId: user.id,
-        applicationId: application.id
-      })
-      notification.Application = application
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addNewPeerTubeVersionNotification(emails, latestVersion)
-    }
-
-    return this.notify({ users: admins, settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notifyAdminsOfNewPluginVersion (plugin: MPlugin) {
-    // Use the debug right to know who is an administrator
-    const admins = await UserModel.listWithRight(UserRight.MANAGE_DEBUG)
-    if (admins.length === 0) return
-
-    logger.info('Notifying %s admins of new plugin version %s@%s.', admins.length, plugin.name, plugin.latestVersion)
-
-    function settingGetter (user: MUserWithNotificationSetting) {
-      return user.NotificationSetting.newPluginVersion
-    }
-
-    async function notificationCreator (user: MUserWithNotificationSetting) {
-      const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
-        type: UserNotificationType.NEW_PLUGIN_VERSION,
-        userId: user.id,
-        pluginId: plugin.id
-      })
-      notification.Plugin = plugin
-
-      return notification
-    }
-
-    function emailSender (emails: string[]) {
-      return Emailer.Instance.addNewPlugionVersionNotification(emails, plugin)
-    }
-
-    return this.notify({ users: admins, settingGetter, notificationCreator, emailSender })
-  }
-
-  private async notify<T extends MUserWithNotificationSetting> (options: {
-    users: T[]
-    notificationCreator: (user: T) => Promise<UserNotificationModelForApi>
-    emailSender: (emails: string[]) => void
-    settingGetter: (user: T) => UserNotificationSettingValue
-  }) {
-    const emails: string[] = []
-
-    for (const user of options.users) {
-      if (this.isWebNotificationEnabled(options.settingGetter(user))) {
-        const notification = await options.notificationCreator(user)
-
-        PeerTubeSocket.Instance.sendNotification(user.id, notification)
-      }
-
-      if (this.isEmailEnabled(user, options.settingGetter(user))) {
-        emails.push(user.email)
-      }
-    }
-
-    if (emails.length !== 0) {
-      options.emailSender(emails)
-    }
-  }
-
-  private isEmailEnabled (user: MUser, value: UserNotificationSettingValue) {
-    if (CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION === true && user.emailVerified === false) return false
-
-    return value & UserNotificationSettingValue.EMAIL
-  }
-
-  private isWebNotificationEnabled (value: UserNotificationSettingValue) {
-    return value & UserNotificationSettingValue.WEB
-  }
-
-  private isBlockedByServerOrUser (targetAccount: MAccountServer, user?: MUserAccount) {
-    return isBlockedByServerOrAccount(targetAccount, user?.Account)
-  }
-
-  private getAbuseUrl (abuse: MAbuseFull) {
-    return abuse.VideoAbuse?.Video?.url ||
-      abuse.VideoCommentAbuse?.VideoComment?.url ||
-      abuse.FlaggedAccount.Actor.url
-  }
-
-  static get Instance () {
-    return this.instance || (this.instance = new this())
-  }
-}
-
-// ---------------------------------------------------------------------------
-
-export {
-  Notifier
-}
diff --git a/server/lib/notifier/index.ts b/server/lib/notifier/index.ts
new file mode 100644
index 000000000..5bc2f5f50
--- /dev/null
+++ b/server/lib/notifier/index.ts
@@ -0,0 +1 @@
+export * from './notifier'
diff --git a/server/lib/notifier/notifier.ts b/server/lib/notifier/notifier.ts
new file mode 100644
index 000000000..8b68d2e69
--- /dev/null
+++ b/server/lib/notifier/notifier.ts
@@ -0,0 +1,259 @@
+import { MUser, MUserDefault } from '@server/types/models/user'
+import { MVideoBlacklistLightVideo, MVideoBlacklistVideo } from '@server/types/models/video/video-blacklist'
+import { UserNotificationSettingValue } from '../../../shared/models/users'
+import { logger } from '../../helpers/logger'
+import { CONFIG } from '../../initializers/config'
+import { MAbuseFull, MAbuseMessage, MActorFollowFull, MApplication, MPlugin } from '../../types/models'
+import { MCommentOwnerVideo, MVideoAccountLight, MVideoFullLight } from '../../types/models/video'
+import { JobQueue } from '../job-queue'
+import { PeerTubeSocket } from '../peertube-socket'
+import {
+  AbstractNotification,
+  AbuseStateChangeForReporter,
+  AutoFollowForInstance,
+  CommentMention,
+  FollowForInstance,
+  FollowForUser,
+  ImportFinishedForOwner,
+  ImportFinishedForOwnerPayload,
+  NewAbuseForModerators,
+  NewAbuseMessageForModerators,
+  NewAbuseMessageForReporter,
+  NewAbusePayload,
+  NewAutoBlacklistForModerators,
+  NewBlacklistForOwner,
+  NewCommentForVideoOwner,
+  NewPeerTubeVersionForAdmins,
+  NewPluginVersionForAdmins,
+  NewVideoForSubscribers,
+  OwnedPublicationAfterAutoUnblacklist,
+  OwnedPublicationAfterScheduleUpdate,
+  OwnedPublicationAfterTranscoding,
+  RegistrationForModerators,
+  UnblacklistForOwner
+} from './shared'
+
+class Notifier {
+
+  private readonly notificationModels = {
+    newVideo: [ NewVideoForSubscribers ],
+    publicationAfterTranscoding: [ OwnedPublicationAfterTranscoding ],
+    publicationAfterScheduleUpdate: [ OwnedPublicationAfterScheduleUpdate ],
+    publicationAfterAutoUnblacklist: [ OwnedPublicationAfterAutoUnblacklist ],
+    newComment: [ CommentMention, NewCommentForVideoOwner ],
+    newAbuse: [ NewAbuseForModerators ],
+    newBlacklist: [ NewBlacklistForOwner ],
+    unblacklist: [ UnblacklistForOwner ],
+    importFinished: [ ImportFinishedForOwner ],
+    userRegistration: [ RegistrationForModerators ],
+    userFollow: [ FollowForUser ],
+    instanceFollow: [ FollowForInstance ],
+    autoInstanceFollow: [ AutoFollowForInstance ],
+    newAutoBlacklist: [ NewAutoBlacklistForModerators ],
+    abuseStateChange: [ AbuseStateChangeForReporter ],
+    newAbuseMessage: [ NewAbuseMessageForReporter, NewAbuseMessageForModerators ],
+    newPeertubeVersion: [ NewPeerTubeVersionForAdmins ],
+    newPluginVersion: [ NewPluginVersionForAdmins ]
+  }
+
+  private static instance: Notifier
+
+  private constructor () {
+  }
+
+  notifyOnNewVideoIfNeeded (video: MVideoAccountLight): void {
+    const models = this.notificationModels.newVideo
+
+    this.sendNotifications(models, video)
+      .catch(err => logger.error('Cannot notify subscribers of new video %s.', video.url, { err }))
+  }
+
+  notifyOnVideoPublishedAfterTranscoding (video: MVideoFullLight): void {
+    const models = this.notificationModels.publicationAfterTranscoding
+
+    this.sendNotifications(models, video)
+      .catch(err => logger.error('Cannot notify owner that its video %s has been published after transcoding.', video.url, { err }))
+  }
+
+  notifyOnVideoPublishedAfterScheduledUpdate (video: MVideoFullLight): void {
+    const models = this.notificationModels.publicationAfterScheduleUpdate
+
+    this.sendNotifications(models, video)
+      .catch(err => logger.error('Cannot notify owner that its video %s has been published after scheduled update.', video.url, { err }))
+  }
+
+  notifyOnVideoPublishedAfterRemovedFromAutoBlacklist (video: MVideoFullLight): void {
+    const models = this.notificationModels.publicationAfterAutoUnblacklist
+
+    this.sendNotifications(models, video)
+      .catch(err => {
+        logger.error('Cannot notify owner that its video %s has been published after removed from auto-blacklist.', video.url, { err })
+      })
+  }
+
+  notifyOnNewComment (comment: MCommentOwnerVideo): void {
+    const models = this.notificationModels.newComment
+
+    this.sendNotifications(models, comment)
+      .catch(err => logger.error('Cannot notify of new comment.', comment.url, { err }))
+  }
+
+  notifyOnNewAbuse (payload: NewAbusePayload): void {
+    const models = this.notificationModels.newAbuse
+
+    this.sendNotifications(models, payload)
+      .catch(err => logger.error('Cannot notify of new abuse %d.', payload.abuseInstance.id, { err }))
+  }
+
+  notifyOnVideoAutoBlacklist (videoBlacklist: MVideoBlacklistLightVideo): void {
+    const models = this.notificationModels.newAutoBlacklist
+
+    this.sendNotifications(models, videoBlacklist)
+      .catch(err => logger.error('Cannot notify of auto-blacklist of video %s.', videoBlacklist.Video.url, { err }))
+  }
+
+  notifyOnVideoBlacklist (videoBlacklist: MVideoBlacklistVideo): void {
+    const models = this.notificationModels.newBlacklist
+
+    this.sendNotifications(models, videoBlacklist)
+      .catch(err => logger.error('Cannot notify video owner of new video blacklist of %s.', videoBlacklist.Video.url, { err }))
+  }
+
+  notifyOnVideoUnblacklist (video: MVideoFullLight): void {
+    const models = this.notificationModels.unblacklist
+
+    this.sendNotifications(models, video)
+        .catch(err => logger.error('Cannot notify video owner of unblacklist of %s.', video.url, { err }))
+  }
+
+  notifyOnFinishedVideoImport (payload: ImportFinishedForOwnerPayload): void {
+    const models = this.notificationModels.importFinished
+
+    this.sendNotifications(models, payload)
+        .catch(err => {
+          logger.error('Cannot notify owner that its video import %s is finished.', payload.videoImport.getTargetIdentifier(), { err })
+        })
+  }
+
+  notifyOnNewUserRegistration (user: MUserDefault): void {
+    const models = this.notificationModels.userRegistration
+
+    this.sendNotifications(models, user)
+      .catch(err => logger.error('Cannot notify moderators of new user registration (%s).', user.username, { err }))
+  }
+
+  notifyOfNewUserFollow (actorFollow: MActorFollowFull): void {
+    const models = this.notificationModels.userFollow
+
+    this.sendNotifications(models, actorFollow)
+      .catch(err => {
+        logger.error(
+          'Cannot notify owner of channel %s of a new follow by %s.',
+          actorFollow.ActorFollowing.VideoChannel.getDisplayName(),
+          actorFollow.ActorFollower.Account.getDisplayName(),
+          { err }
+        )
+      })
+  }
+
+  notifyOfNewInstanceFollow (actorFollow: MActorFollowFull): void {
+    const models = this.notificationModels.instanceFollow
+
+    this.sendNotifications(models, actorFollow)
+      .catch(err => logger.error('Cannot notify administrators of new follower %s.', actorFollow.ActorFollower.url, { err }))
+  }
+
+  notifyOfAutoInstanceFollowing (actorFollow: MActorFollowFull): void {
+    const models = this.notificationModels.autoInstanceFollow
+
+    this.sendNotifications(models, actorFollow)
+      .catch(err => logger.error('Cannot notify administrators of auto instance following %s.', actorFollow.ActorFollowing.url, { err }))
+  }
+
+  notifyOnAbuseStateChange (abuse: MAbuseFull): void {
+    const models = this.notificationModels.abuseStateChange
+
+    this.sendNotifications(models, abuse)
+      .catch(err => logger.error('Cannot notify of abuse %d state change.', abuse.id, { err }))
+  }
+
+  notifyOnAbuseMessage (abuse: MAbuseFull, message: MAbuseMessage): void {
+    const models = this.notificationModels.newAbuseMessage
+
+    this.sendNotifications(models, { abuse, message })
+      .catch(err => logger.error('Cannot notify on new abuse %d message.', abuse.id, { err }))
+  }
+
+  notifyOfNewPeerTubeVersion (application: MApplication, latestVersion: string) {
+    const models = this.notificationModels.newPeertubeVersion
+
+    this.sendNotifications(models, { application, latestVersion })
+      .catch(err => logger.error('Cannot notify on new PeerTubeb version %s.', latestVersion, { err }))
+  }
+
+  notifyOfNewPluginVersion (plugin: MPlugin) {
+    const models = this.notificationModels.newPluginVersion
+
+    this.sendNotifications(models, plugin)
+      .catch(err => logger.error('Cannot notify on new plugin version %s.', plugin.name, { err }))
+  }
+
+  private async notify <T> (object: AbstractNotification<T>) {
+    await object.prepare()
+
+    const users = object.getTargetUsers()
+
+    if (users.length === 0) return
+    if (await object.isDisabled()) return
+
+    object.log()
+
+    const toEmails: string[] = []
+
+    for (const user of users) {
+      const setting = object.getSetting(user)
+
+      if (this.isWebNotificationEnabled(setting)) {
+        const notification = await object.createNotification(user)
+
+        PeerTubeSocket.Instance.sendNotification(user.id, notification)
+      }
+
+      if (this.isEmailEnabled(user, setting)) {
+        toEmails.push(user.email)
+      }
+    }
+
+    for (const to of toEmails) {
+      const payload = await object.createEmail(to)
+      JobQueue.Instance.createJob({ type: 'email', payload })
+    }
+  }
+
+  private isEmailEnabled (user: MUser, value: UserNotificationSettingValue) {
+    if (CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION === true && user.emailVerified === false) return false
+
+    return value & UserNotificationSettingValue.EMAIL
+  }
+
+  private isWebNotificationEnabled (value: UserNotificationSettingValue) {
+    return value & UserNotificationSettingValue.WEB
+  }
+
+  private async sendNotifications <T> (models: (new (payload: T) => AbstractNotification<T>)[], payload: T) {
+    for (const model of models) {
+      // eslint-disable-next-line new-cap
+      await this.notify(new model(payload))
+    }
+  }
+
+  static get Instance () {
+    return this.instance || (this.instance = new this())
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  Notifier
+}
diff --git a/server/lib/notifier/shared/abuse/abstract-new-abuse-message.ts b/server/lib/notifier/shared/abuse/abstract-new-abuse-message.ts
new file mode 100644
index 000000000..1425c38ec
--- /dev/null
+++ b/server/lib/notifier/shared/abuse/abstract-new-abuse-message.ts
@@ -0,0 +1,67 @@
+import { WEBSERVER } from '@server/initializers/constants'
+import { AccountModel } from '@server/models/account/account'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MAbuseFull, MAbuseMessage, MAccountDefault, MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export type NewAbuseMessagePayload = {
+  abuse: MAbuseFull
+  message: MAbuseMessage
+}
+
+export abstract class AbstractNewAbuseMessage extends AbstractNotification <NewAbuseMessagePayload> {
+  protected messageAccount: MAccountDefault
+
+  async loadMessageAccount () {
+    this.messageAccount = await AccountModel.load(this.message.accountId)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.abuseNewMessage
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.ABUSE_NEW_MESSAGE,
+      userId: user.id,
+      abuseId: this.abuse.id
+    })
+    notification.Abuse = this.abuse
+
+    return notification
+  }
+
+  protected createEmailFor (to: string, target: 'moderator' | 'reporter') {
+    const text = 'New message on report #' + this.abuse.id
+    const abuseUrl = target === 'moderator'
+      ? WEBSERVER.URL + '/admin/moderation/abuses/list?search=%23' + this.abuse.id
+      : WEBSERVER.URL + '/my-account/abuses?search=%23' + this.abuse.id
+
+    const action = {
+      text,
+      url: abuseUrl
+    }
+
+    return {
+      template: 'abuse-new-message',
+      to,
+      subject: text,
+      locals: {
+        abuseId: this.abuse.id,
+        abuseUrl: action.url,
+        messageAccountName: this.messageAccount.getDisplayName(),
+        messageText: this.message.message,
+        action
+      }
+    }
+  }
+
+  protected get abuse () {
+    return this.payload.abuse
+  }
+
+  protected get message () {
+    return this.payload.message
+  }
+}
diff --git a/server/lib/notifier/shared/abuse/abuse-state-change-for-reporter.ts b/server/lib/notifier/shared/abuse/abuse-state-change-for-reporter.ts
new file mode 100644
index 000000000..968b5bca9
--- /dev/null
+++ b/server/lib/notifier/shared/abuse/abuse-state-change-for-reporter.ts
@@ -0,0 +1,74 @@
+import { logger } from '@server/helpers/logger'
+import { WEBSERVER } from '@server/initializers/constants'
+import { getAbuseTargetUrl } from '@server/lib/activitypub/url'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MAbuseFull, MUserDefault, MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { AbuseState, UserNotificationType } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class AbuseStateChangeForReporter extends AbstractNotification <MAbuseFull> {
+
+  private user: MUserDefault
+
+  async prepare () {
+    const reporter = this.abuse.ReporterAccount
+    if (reporter.isOwned() !== true) return
+
+    this.user = await UserModel.loadByAccountActorId(this.abuse.ReporterAccount.actorId)
+  }
+
+  log () {
+    logger.info('Notifying reporter of abuse % of state change.', getAbuseTargetUrl(this.abuse))
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.abuseStateChange
+  }
+
+  getTargetUsers () {
+    if (!this.user) return []
+
+    return [ this.user ]
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.ABUSE_STATE_CHANGE,
+      userId: user.id,
+      abuseId: this.abuse.id
+    })
+    notification.Abuse = this.abuse
+
+    return notification
+  }
+
+  createEmail (to: string) {
+    const text = this.abuse.state === AbuseState.ACCEPTED
+      ? 'Report #' + this.abuse.id + ' has been accepted'
+      : 'Report #' + this.abuse.id + ' has been rejected'
+
+    const abuseUrl = WEBSERVER.URL + '/my-account/abuses?search=%23' + this.abuse.id
+
+    const action = {
+      text,
+      url: abuseUrl
+    }
+
+    return {
+      template: 'abuse-state-change',
+      to,
+      subject: text,
+      locals: {
+        action,
+        abuseId: this.abuse.id,
+        abuseUrl,
+        isAccepted: this.abuse.state === AbuseState.ACCEPTED
+      }
+    }
+  }
+
+  private get abuse () {
+    return this.payload
+  }
+}
diff --git a/server/lib/notifier/shared/abuse/index.ts b/server/lib/notifier/shared/abuse/index.ts
new file mode 100644
index 000000000..7b54c5591
--- /dev/null
+++ b/server/lib/notifier/shared/abuse/index.ts
@@ -0,0 +1,4 @@
+export * from './abuse-state-change-for-reporter'
+export * from './new-abuse-for-moderators'
+export * from './new-abuse-message-for-reporter'
+export * from './new-abuse-message-for-moderators'
diff --git a/server/lib/notifier/shared/abuse/new-abuse-for-moderators.ts b/server/lib/notifier/shared/abuse/new-abuse-for-moderators.ts
new file mode 100644
index 000000000..c3c7c5515
--- /dev/null
+++ b/server/lib/notifier/shared/abuse/new-abuse-for-moderators.ts
@@ -0,0 +1,119 @@
+import { logger } from '@server/helpers/logger'
+import { WEBSERVER } from '@server/initializers/constants'
+import { getAbuseTargetUrl } from '@server/lib/activitypub/url'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MAbuseFull, MUserDefault, MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { UserAbuse, UserNotificationType, UserRight } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export type NewAbusePayload = { abuse: UserAbuse, abuseInstance: MAbuseFull, reporter: string }
+
+export class NewAbuseForModerators extends AbstractNotification <NewAbusePayload> {
+  private moderators: MUserDefault[]
+
+  async prepare () {
+    this.moderators = await UserModel.listWithRight(UserRight.MANAGE_ABUSES)
+  }
+
+  log () {
+    logger.info('Notifying %s user/moderators of new abuse %s.', this.moderators.length, getAbuseTargetUrl(this.payload.abuseInstance))
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.abuseAsModerator
+  }
+
+  getTargetUsers () {
+    return this.moderators
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.NEW_ABUSE_FOR_MODERATORS,
+      userId: user.id,
+      abuseId: this.payload.abuseInstance.id
+    })
+    notification.Abuse = this.payload.abuseInstance
+
+    return notification
+  }
+
+  createEmail (to: string) {
+    const abuseInstance = this.payload.abuseInstance
+
+    if (abuseInstance.VideoAbuse) return this.createVideoAbuseEmail(to)
+    if (abuseInstance.VideoCommentAbuse) return this.createCommentAbuseEmail(to)
+
+    return this.createAccountAbuseEmail(to)
+  }
+
+  private createVideoAbuseEmail (to: string) {
+    const video = this.payload.abuseInstance.VideoAbuse.Video
+    const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
+
+    return {
+      template: 'video-abuse-new',
+      to,
+      subject: `New video abuse report from ${this.payload.reporter}`,
+      locals: {
+        videoUrl,
+        isLocal: video.remote === false,
+        videoCreatedAt: new Date(video.createdAt).toLocaleString(),
+        videoPublishedAt: new Date(video.publishedAt).toLocaleString(),
+        videoName: video.name,
+        reason: this.payload.abuse.reason,
+        videoChannel: this.payload.abuse.video.channel,
+        reporter: this.payload.reporter,
+        action: this.buildEmailAction()
+      }
+    }
+  }
+
+  private createCommentAbuseEmail (to: string) {
+    const comment = this.payload.abuseInstance.VideoCommentAbuse.VideoComment
+    const commentUrl = WEBSERVER.URL + comment.Video.getWatchStaticPath() + ';threadId=' + comment.getThreadId()
+
+    return {
+      template: 'video-comment-abuse-new',
+      to,
+      subject: `New comment abuse report from ${this.payload.reporter}`,
+      locals: {
+        commentUrl,
+        videoName: comment.Video.name,
+        isLocal: comment.isOwned(),
+        commentCreatedAt: new Date(comment.createdAt).toLocaleString(),
+        reason: this.payload.abuse.reason,
+        flaggedAccount: this.payload.abuseInstance.FlaggedAccount.getDisplayName(),
+        reporter: this.payload.reporter,
+        action: this.buildEmailAction()
+      }
+    }
+  }
+
+  private createAccountAbuseEmail (to: string) {
+    const account = this.payload.abuseInstance.FlaggedAccount
+    const accountUrl = account.getClientUrl()
+
+    return {
+      template: 'account-abuse-new',
+      to,
+      subject: `New account abuse report from ${this.payload.reporter}`,
+      locals: {
+        accountUrl,
+        accountDisplayName: account.getDisplayName(),
+        isLocal: account.isOwned(),
+        reason: this.payload.abuse.reason,
+        reporter: this.payload.reporter,
+        action: this.buildEmailAction()
+      }
+    }
+  }
+
+  private buildEmailAction () {
+    return {
+      text: 'View report #' + this.payload.abuseInstance.id,
+      url: WEBSERVER.URL + '/admin/moderation/abuses/list?search=%23' + this.payload.abuseInstance.id
+    }
+  }
+}
diff --git a/server/lib/notifier/shared/abuse/new-abuse-message-for-moderators.ts b/server/lib/notifier/shared/abuse/new-abuse-message-for-moderators.ts
new file mode 100644
index 000000000..9d0629690
--- /dev/null
+++ b/server/lib/notifier/shared/abuse/new-abuse-message-for-moderators.ts
@@ -0,0 +1,32 @@
+import { logger } from '@server/helpers/logger'
+import { getAbuseTargetUrl } from '@server/lib/activitypub/url'
+import { UserModel } from '@server/models/user/user'
+import { MUserDefault } from '@server/types/models'
+import { UserRight } from '@shared/models'
+import { AbstractNewAbuseMessage } from './abstract-new-abuse-message'
+
+export class NewAbuseMessageForModerators extends AbstractNewAbuseMessage {
+  private moderators: MUserDefault[]
+
+  async prepare () {
+    this.moderators = await UserModel.listWithRight(UserRight.MANAGE_ABUSES)
+
+    // Don't notify my own message
+    this.moderators = this.moderators.filter(m => m.Account.id !== this.message.accountId)
+    if (this.moderators.length === 0) return
+
+    await this.loadMessageAccount()
+  }
+
+  log () {
+    logger.info('Notifying moderators of new abuse message on %s.', getAbuseTargetUrl(this.abuse))
+  }
+
+  getTargetUsers () {
+    return this.moderators
+  }
+
+  createEmail (to: string) {
+    return this.createEmailFor(to, 'moderator')
+  }
+}
diff --git a/server/lib/notifier/shared/abuse/new-abuse-message-for-reporter.ts b/server/lib/notifier/shared/abuse/new-abuse-message-for-reporter.ts
new file mode 100644
index 000000000..c5bbb5447
--- /dev/null
+++ b/server/lib/notifier/shared/abuse/new-abuse-message-for-reporter.ts
@@ -0,0 +1,36 @@
+import { logger } from '@server/helpers/logger'
+import { getAbuseTargetUrl } from '@server/lib/activitypub/url'
+import { UserModel } from '@server/models/user/user'
+import { MUserDefault } from '@server/types/models'
+import { AbstractNewAbuseMessage } from './abstract-new-abuse-message'
+
+export class NewAbuseMessageForReporter extends AbstractNewAbuseMessage {
+  private reporter: MUserDefault
+
+  async prepare () {
+    // Only notify our users
+    if (this.abuse.ReporterAccount.isOwned() !== true) return
+
+    await this.loadMessageAccount()
+
+    const reporter = await UserModel.loadByAccountActorId(this.abuse.ReporterAccount.actorId)
+    // Don't notify my own message
+    if (reporter.Account.id === this.message.accountId) return
+
+    this.reporter = reporter
+  }
+
+  log () {
+    logger.info('Notifying reporter of new abuse message on %s.', getAbuseTargetUrl(this.abuse))
+  }
+
+  getTargetUsers () {
+    if (!this.reporter) return []
+
+    return [ this.reporter ]
+  }
+
+  createEmail (to: string) {
+    return this.createEmailFor(to, 'reporter')
+  }
+}
diff --git a/server/lib/notifier/shared/blacklist/index.ts b/server/lib/notifier/shared/blacklist/index.ts
new file mode 100644
index 000000000..2f98d88ae
--- /dev/null
+++ b/server/lib/notifier/shared/blacklist/index.ts
@@ -0,0 +1,3 @@
+export * from './new-auto-blacklist-for-moderators'
+export * from './new-blacklist-for-owner'
+export * from './unblacklist-for-owner'
diff --git a/server/lib/notifier/shared/blacklist/new-auto-blacklist-for-moderators.ts b/server/lib/notifier/shared/blacklist/new-auto-blacklist-for-moderators.ts
new file mode 100644
index 000000000..a92a49a0c
--- /dev/null
+++ b/server/lib/notifier/shared/blacklist/new-auto-blacklist-for-moderators.ts
@@ -0,0 +1,60 @@
+import { logger } from '@server/helpers/logger'
+import { WEBSERVER } from '@server/initializers/constants'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { VideoChannelModel } from '@server/models/video/video-channel'
+import { MUserDefault, MUserWithNotificationSetting, MVideoBlacklistLightVideo, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType, UserRight } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class NewAutoBlacklistForModerators extends AbstractNotification <MVideoBlacklistLightVideo> {
+  private moderators: MUserDefault[]
+
+  async prepare () {
+    this.moderators = await UserModel.listWithRight(UserRight.MANAGE_VIDEO_BLACKLIST)
+  }
+
+  log () {
+    logger.info('Notifying %s moderators of video auto-blacklist %s.', this.moderators.length, this.payload.Video.url)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.videoAutoBlacklistAsModerator
+  }
+
+  getTargetUsers () {
+    return this.moderators
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.VIDEO_AUTO_BLACKLIST_FOR_MODERATORS,
+      userId: user.id,
+      videoBlacklistId: this.payload.id
+    })
+    notification.VideoBlacklist = this.payload
+
+    return notification
+  }
+
+  async createEmail (to: string) {
+    const videoAutoBlacklistUrl = WEBSERVER.URL + '/admin/moderation/video-auto-blacklist/list'
+    const videoUrl = WEBSERVER.URL + this.payload.Video.getWatchStaticPath()
+    const channel = await VideoChannelModel.loadAndPopulateAccount(this.payload.Video.channelId)
+
+    return {
+      template: 'video-auto-blacklist-new',
+      to,
+      subject: 'A new video is pending moderation',
+      locals: {
+        channel: channel.toFormattedSummaryJSON(),
+        videoUrl,
+        videoName: this.payload.Video.name,
+        action: {
+          text: 'Review autoblacklist',
+          url: videoAutoBlacklistUrl
+        }
+      }
+    }
+  }
+}
diff --git a/server/lib/notifier/shared/blacklist/new-blacklist-for-owner.ts b/server/lib/notifier/shared/blacklist/new-blacklist-for-owner.ts
new file mode 100644
index 000000000..45bc30eb2
--- /dev/null
+++ b/server/lib/notifier/shared/blacklist/new-blacklist-for-owner.ts
@@ -0,0 +1,58 @@
+import { logger } from '@server/helpers/logger'
+import { CONFIG } from '@server/initializers/config'
+import { WEBSERVER } from '@server/initializers/constants'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MUserDefault, MUserWithNotificationSetting, MVideoBlacklistVideo, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class NewBlacklistForOwner extends AbstractNotification <MVideoBlacklistVideo> {
+  private user: MUserDefault
+
+  async prepare () {
+    this.user = await UserModel.loadByVideoId(this.payload.videoId)
+  }
+
+  log () {
+    logger.info('Notifying user %s that its video %s has been blacklisted.', this.user.username, this.payload.Video.url)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.blacklistOnMyVideo
+  }
+
+  getTargetUsers () {
+    if (!this.user) return []
+
+    return [ this.user ]
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.BLACKLIST_ON_MY_VIDEO,
+      userId: user.id,
+      videoBlacklistId: this.payload.id
+    })
+    notification.VideoBlacklist = this.payload
+
+    return notification
+  }
+
+  createEmail (to: string) {
+    const videoName = this.payload.Video.name
+    const videoUrl = WEBSERVER.URL + this.payload.Video.getWatchStaticPath()
+
+    const reasonString = this.payload.reason ? ` for the following reason: ${this.payload.reason}` : ''
+    const blockedString = `Your video ${videoName} (${videoUrl} on ${CONFIG.INSTANCE.NAME} has been blacklisted${reasonString}.`
+
+    return {
+      to,
+      subject: `Video ${videoName} blacklisted`,
+      text: blockedString,
+      locals: {
+        title: 'Your video was blacklisted'
+      }
+    }
+  }
+}
diff --git a/server/lib/notifier/shared/blacklist/unblacklist-for-owner.ts b/server/lib/notifier/shared/blacklist/unblacklist-for-owner.ts
new file mode 100644
index 000000000..21f5a1c2d
--- /dev/null
+++ b/server/lib/notifier/shared/blacklist/unblacklist-for-owner.ts
@@ -0,0 +1,55 @@
+import { logger } from '@server/helpers/logger'
+import { CONFIG } from '@server/initializers/config'
+import { WEBSERVER } from '@server/initializers/constants'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MUserDefault, MUserWithNotificationSetting, MVideoFullLight, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class UnblacklistForOwner extends AbstractNotification <MVideoFullLight> {
+  private user: MUserDefault
+
+  async prepare () {
+    this.user = await UserModel.loadByVideoId(this.payload.id)
+  }
+
+  log () {
+    logger.info('Notifying user %s that its video %s has been unblacklisted.', this.user.username, this.payload.url)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.blacklistOnMyVideo
+  }
+
+  getTargetUsers () {
+    if (!this.user) return []
+
+    return [ this.user ]
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.UNBLACKLIST_ON_MY_VIDEO,
+      userId: user.id,
+      videoId: this.payload.id
+    })
+    notification.Video = this.payload
+
+    return notification
+  }
+
+  createEmail (to: string) {
+    const video = this.payload
+    const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
+
+    return {
+      to,
+      subject: `Video ${video.name} unblacklisted`,
+      text: `Your video "${video.name}" (${videoUrl}) on ${CONFIG.INSTANCE.NAME} has been unblacklisted.`,
+      locals: {
+        title: 'Your video was unblacklisted'
+      }
+    }
+  }
+}
diff --git a/server/lib/notifier/shared/comment/comment-mention.ts b/server/lib/notifier/shared/comment/comment-mention.ts
new file mode 100644
index 000000000..4f84d8dea
--- /dev/null
+++ b/server/lib/notifier/shared/comment/comment-mention.ts
@@ -0,0 +1,111 @@
+import { logger } from '@server/helpers/logger'
+import { toSafeHtml } from '@server/helpers/markdown'
+import { WEBSERVER } from '@server/initializers/constants'
+import { AccountBlocklistModel } from '@server/models/account/account-blocklist'
+import { getServerActor } from '@server/models/application/application'
+import { ServerBlocklistModel } from '@server/models/server/server-blocklist'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import {
+  MCommentOwnerVideo,
+  MUserDefault,
+  MUserNotifSettingAccount,
+  MUserWithNotificationSetting,
+  UserNotificationModelForApi
+} from '@server/types/models'
+import { UserNotificationSettingValue, UserNotificationType } from '@shared/models'
+import { AbstractNotification } from '../common'
+
+export class CommentMention extends AbstractNotification <MCommentOwnerVideo, MUserNotifSettingAccount> {
+  private users: MUserDefault[]
+
+  private serverAccountId: number
+
+  private accountMutedHash: { [ id: number ]: boolean }
+  private instanceMutedHash: { [ id: number ]: boolean }
+
+  async prepare () {
+    const extractedUsernames = this.payload.extractMentions()
+    logger.debug(
+      'Extracted %d username from comment %s.', extractedUsernames.length, this.payload.url,
+      { usernames: extractedUsernames, text: this.payload.text }
+    )
+
+    this.users = await UserModel.listByUsernames(extractedUsernames)
+
+    if (this.payload.Video.isOwned()) {
+      const userException = await UserModel.loadByVideoId(this.payload.videoId)
+      this.users = this.users.filter(u => u.id !== userException.id)
+    }
+
+    // Don't notify if I mentioned myself
+    this.users = this.users.filter(u => u.Account.id !== this.payload.accountId)
+
+    if (this.users.length === 0) return
+
+    this.serverAccountId = (await getServerActor()).Account.id
+
+    const sourceAccounts = this.users.map(u => u.Account.id).concat([ this.serverAccountId ])
+
+    this.accountMutedHash = await AccountBlocklistModel.isAccountMutedByMulti(sourceAccounts, this.payload.accountId)
+    this.instanceMutedHash = await ServerBlocklistModel.isServerMutedByMulti(sourceAccounts, this.payload.Account.Actor.serverId)
+  }
+
+  log () {
+    logger.info('Notifying %d users of new comment %s.', this.users.length, this.payload.url)
+  }
+
+  getSetting (user: MUserNotifSettingAccount) {
+    const accountId = user.Account.id
+    if (
+      this.accountMutedHash[accountId] === true || this.instanceMutedHash[accountId] === true ||
+      this.accountMutedHash[this.serverAccountId] === true || this.instanceMutedHash[this.serverAccountId] === true
+    ) {
+      return UserNotificationSettingValue.NONE
+    }
+
+    return user.NotificationSetting.commentMention
+  }
+
+  getTargetUsers () {
+    return this.users
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.COMMENT_MENTION,
+      userId: user.id,
+      commentId: this.payload.id
+    })
+    notification.Comment = this.payload
+
+    return notification
+  }
+
+  createEmail (to: string) {
+    const comment = this.payload
+
+    const accountName = comment.Account.getDisplayName()
+    const video = comment.Video
+    const videoUrl = WEBSERVER.URL + comment.Video.getWatchStaticPath()
+    const commentUrl = WEBSERVER.URL + comment.getCommentStaticPath()
+    const commentHtml = toSafeHtml(comment.text)
+
+    return {
+      template: 'video-comment-mention',
+      to,
+      subject: 'Mention on video ' + video.name,
+      locals: {
+        comment,
+        commentHtml,
+        video,
+        videoUrl,
+        accountName,
+        action: {
+          text: 'View comment',
+          url: commentUrl
+        }
+      }
+    }
+  }
+}
diff --git a/server/lib/notifier/shared/comment/index.ts b/server/lib/notifier/shared/comment/index.ts
new file mode 100644
index 000000000..ae01a9646
--- /dev/null
+++ b/server/lib/notifier/shared/comment/index.ts
@@ -0,0 +1,2 @@
+export * from './comment-mention'
+export * from './new-comment-for-video-owner'
diff --git a/server/lib/notifier/shared/comment/new-comment-for-video-owner.ts b/server/lib/notifier/shared/comment/new-comment-for-video-owner.ts
new file mode 100644
index 000000000..b76fc15bf
--- /dev/null
+++ b/server/lib/notifier/shared/comment/new-comment-for-video-owner.ts
@@ -0,0 +1,76 @@
+import { logger } from '@server/helpers/logger'
+import { toSafeHtml } from '@server/helpers/markdown'
+import { WEBSERVER } from '@server/initializers/constants'
+import { isBlockedByServerOrAccount } from '@server/lib/blocklist'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MCommentOwnerVideo, MUserDefault, MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class NewCommentForVideoOwner extends AbstractNotification <MCommentOwnerVideo> {
+  private user: MUserDefault
+
+  async prepare () {
+    this.user = await UserModel.loadByVideoId(this.payload.videoId)
+  }
+
+  log () {
+    logger.info('Notifying owner of a video %s of new comment %s.', this.user.username, this.payload.url)
+  }
+
+  isDisabled () {
+    if (this.payload.Video.isOwned() === false) return true
+
+    // Not our user or user comments its own video
+    if (!this.user || this.payload.Account.userId === this.user.id) return true
+
+    return isBlockedByServerOrAccount(this.payload.Account, this.user.Account)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.newCommentOnMyVideo
+  }
+
+  getTargetUsers () {
+    if (!this.user) return []
+
+    return [ this.user ]
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.NEW_COMMENT_ON_MY_VIDEO,
+      userId: user.id,
+      commentId: this.payload.id
+    })
+    notification.Comment = this.payload
+
+    return notification
+  }
+
+  createEmail (to: string) {
+    const video = this.payload.Video
+    const videoUrl = WEBSERVER.URL + this.payload.Video.getWatchStaticPath()
+    const commentUrl = WEBSERVER.URL + this.payload.getCommentStaticPath()
+    const commentHtml = toSafeHtml(this.payload.text)
+
+    return {
+      template: 'video-comment-new',
+      to,
+      subject: 'New comment on your video ' + video.name,
+      locals: {
+        accountName: this.payload.Account.getDisplayName(),
+        accountUrl: this.payload.Account.Actor.url,
+        comment: this.payload,
+        commentHtml,
+        video,
+        videoUrl,
+        action: {
+          text: 'View comment',
+          url: commentUrl
+        }
+      }
+    }
+  }
+}
diff --git a/server/lib/notifier/shared/common/abstract-notification.ts b/server/lib/notifier/shared/common/abstract-notification.ts
new file mode 100644
index 000000000..53e2e02d5
--- /dev/null
+++ b/server/lib/notifier/shared/common/abstract-notification.ts
@@ -0,0 +1,23 @@
+import { MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { EmailPayload, UserNotificationSettingValue } from '@shared/models'
+
+export abstract class AbstractNotification <T, U = MUserWithNotificationSetting> {
+
+  constructor (protected readonly payload: T) {
+
+  }
+
+  abstract prepare (): Promise<void>
+  abstract log (): void
+
+  abstract getSetting (user: U): UserNotificationSettingValue
+  abstract getTargetUsers (): U[]
+
+  abstract createNotification (user: U): Promise<UserNotificationModelForApi>
+  abstract createEmail (to: string): EmailPayload | Promise<EmailPayload>
+
+  isDisabled (): boolean | Promise<boolean> {
+    return false
+  }
+
+}
diff --git a/server/lib/notifier/shared/common/index.ts b/server/lib/notifier/shared/common/index.ts
new file mode 100644
index 000000000..0b2570278
--- /dev/null
+++ b/server/lib/notifier/shared/common/index.ts
@@ -0,0 +1 @@
+export * from './abstract-notification'
diff --git a/server/lib/notifier/shared/follow/auto-follow-for-instance.ts b/server/lib/notifier/shared/follow/auto-follow-for-instance.ts
new file mode 100644
index 000000000..16cc62984
--- /dev/null
+++ b/server/lib/notifier/shared/follow/auto-follow-for-instance.ts
@@ -0,0 +1,51 @@
+import { logger } from '@server/helpers/logger'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MActorFollowFull, MUserDefault, MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType, UserRight } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class AutoFollowForInstance extends AbstractNotification <MActorFollowFull> {
+  private admins: MUserDefault[]
+
+  async prepare () {
+    this.admins = await UserModel.listWithRight(UserRight.MANAGE_SERVER_FOLLOW)
+  }
+
+  log () {
+    logger.info('Notifying %d administrators of auto instance following: %s.', this.admins.length, this.actorFollow.ActorFollowing.url)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.autoInstanceFollowing
+  }
+
+  getTargetUsers () {
+    return this.admins
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.AUTO_INSTANCE_FOLLOWING,
+      userId: user.id,
+      actorFollowId: this.actorFollow.id
+    })
+    notification.ActorFollow = this.actorFollow
+
+    return notification
+  }
+
+  async createEmail (to: string) {
+    const instanceUrl = this.actorFollow.ActorFollowing.url
+
+    return {
+      to,
+      subject: 'Auto instance following',
+      text: `Your instance automatically followed a new instance: <a href="${instanceUrl}">${instanceUrl}</a>.`
+    }
+  }
+
+  private get actorFollow () {
+    return this.payload
+  }
+}
diff --git a/server/lib/notifier/shared/follow/follow-for-instance.ts b/server/lib/notifier/shared/follow/follow-for-instance.ts
new file mode 100644
index 000000000..9ab269cf1
--- /dev/null
+++ b/server/lib/notifier/shared/follow/follow-for-instance.ts
@@ -0,0 +1,68 @@
+import { logger } from '@server/helpers/logger'
+import { WEBSERVER } from '@server/initializers/constants'
+import { isBlockedByServerOrAccount } from '@server/lib/blocklist'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MActorFollowFull, MUserDefault, MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType, UserRight } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class FollowForInstance extends AbstractNotification <MActorFollowFull> {
+  private admins: MUserDefault[]
+
+  async prepare () {
+    this.admins = await UserModel.listWithRight(UserRight.MANAGE_SERVER_FOLLOW)
+  }
+
+  isDisabled () {
+    const follower = Object.assign(this.actorFollow.ActorFollower.Account, { Actor: this.actorFollow.ActorFollower })
+
+    return isBlockedByServerOrAccount(follower)
+  }
+
+  log () {
+    logger.info('Notifying %d administrators of new instance follower: %s.', this.admins.length, this.actorFollow.ActorFollower.url)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.newInstanceFollower
+  }
+
+  getTargetUsers () {
+    return this.admins
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.NEW_INSTANCE_FOLLOWER,
+      userId: user.id,
+      actorFollowId: this.actorFollow.id
+    })
+    notification.ActorFollow = this.actorFollow
+
+    return notification
+  }
+
+  async createEmail (to: string) {
+    const awaitingApproval = this.actorFollow.state === 'pending'
+      ? ' awaiting manual approval.'
+      : ''
+
+    return {
+      to,
+      subject: 'New instance follower',
+      text: `Your instance has a new follower: ${this.actorFollow.ActorFollower.url}${awaitingApproval}.`,
+      locals: {
+        title: 'New instance follower',
+        action: {
+          text: 'Review followers',
+          url: WEBSERVER.URL + '/admin/follows/followers-list'
+        }
+      }
+    }
+  }
+
+  private get actorFollow () {
+    return this.payload
+  }
+}
diff --git a/server/lib/notifier/shared/follow/follow-for-user.ts b/server/lib/notifier/shared/follow/follow-for-user.ts
new file mode 100644
index 000000000..2d0f675a8
--- /dev/null
+++ b/server/lib/notifier/shared/follow/follow-for-user.ts
@@ -0,0 +1,82 @@
+import { logger } from '@server/helpers/logger'
+import { isBlockedByServerOrAccount } from '@server/lib/blocklist'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MActorFollowFull, MUserDefault, MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class FollowForUser extends AbstractNotification <MActorFollowFull> {
+  private followType: 'account' | 'channel'
+  private user: MUserDefault
+
+  async prepare () {
+    // Account follows one of our account?
+    this.followType = 'channel'
+    this.user = await UserModel.loadByChannelActorId(this.actorFollow.ActorFollowing.id)
+
+    // Account follows one of our channel?
+    if (!this.user) {
+      this.user = await UserModel.loadByAccountActorId(this.actorFollow.ActorFollowing.id)
+      this.followType = 'account'
+    }
+  }
+
+  async isDisabled () {
+    if (this.payload.ActorFollowing.isOwned() === false) return true
+
+    const followerAccount = this.actorFollow.ActorFollower.Account
+    const followerAccountWithActor = Object.assign(followerAccount, { Actor: this.actorFollow.ActorFollower })
+
+    return isBlockedByServerOrAccount(followerAccountWithActor, this.user.Account)
+  }
+
+  log () {
+    logger.info('Notifying user %s of new follower: %s.', this.user.username, this.actorFollow.ActorFollower.Account.getDisplayName())
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.newFollow
+  }
+
+  getTargetUsers () {
+    if (!this.user) return []
+
+    return [ this.user ]
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.NEW_FOLLOW,
+      userId: user.id,
+      actorFollowId: this.actorFollow.id
+    })
+    notification.ActorFollow = this.actorFollow
+
+    return notification
+  }
+
+  async createEmail (to: string) {
+    const following = this.actorFollow.ActorFollowing
+    const follower = this.actorFollow.ActorFollower
+
+    const followingName = (following.VideoChannel || following.Account).getDisplayName()
+
+    return {
+      template: 'follower-on-channel',
+      to,
+      subject: `New follower on your channel ${followingName}`,
+      locals: {
+        followerName: follower.Account.getDisplayName(),
+        followerUrl: follower.url,
+        followingName,
+        followingUrl: following.url,
+        followType: this.followType
+      }
+    }
+  }
+
+  private get actorFollow () {
+    return this.payload
+  }
+}
diff --git a/server/lib/notifier/shared/follow/index.ts b/server/lib/notifier/shared/follow/index.ts
new file mode 100644
index 000000000..27f5289d9
--- /dev/null
+++ b/server/lib/notifier/shared/follow/index.ts
@@ -0,0 +1,3 @@
+export * from './auto-follow-for-instance'
+export * from './follow-for-instance'
+export * from './follow-for-user'
diff --git a/server/lib/notifier/shared/index.ts b/server/lib/notifier/shared/index.ts
new file mode 100644
index 000000000..cc3ce8c7c
--- /dev/null
+++ b/server/lib/notifier/shared/index.ts
@@ -0,0 +1,7 @@
+export * from './abuse'
+export * from './blacklist'
+export * from './comment'
+export * from './common'
+export * from './follow'
+export * from './instance'
+export * from './video-publication'
diff --git a/server/lib/notifier/shared/instance/index.ts b/server/lib/notifier/shared/instance/index.ts
new file mode 100644
index 000000000..c3bb22aec
--- /dev/null
+++ b/server/lib/notifier/shared/instance/index.ts
@@ -0,0 +1,3 @@
+export * from './new-peertube-version-for-admins'
+export * from './new-plugin-version-for-admins'
+export * from './registration-for-moderators'
diff --git a/server/lib/notifier/shared/instance/new-peertube-version-for-admins.ts b/server/lib/notifier/shared/instance/new-peertube-version-for-admins.ts
new file mode 100644
index 000000000..ab5bfb1ac
--- /dev/null
+++ b/server/lib/notifier/shared/instance/new-peertube-version-for-admins.ts
@@ -0,0 +1,54 @@
+import { logger } from '@server/helpers/logger'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MApplication, MUserDefault, MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType, UserRight } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export type NewPeerTubeVersionForAdminsPayload = {
+  application: MApplication
+  latestVersion: string
+}
+
+export class NewPeerTubeVersionForAdmins extends AbstractNotification <NewPeerTubeVersionForAdminsPayload> {
+  private admins: MUserDefault[]
+
+  async prepare () {
+    // Use the debug right to know who is an administrator
+    this.admins = await UserModel.listWithRight(UserRight.MANAGE_DEBUG)
+  }
+
+  log () {
+    logger.info('Notifying %s admins of new PeerTube version %s.', this.admins.length, this.payload.latestVersion)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.newPeerTubeVersion
+  }
+
+  getTargetUsers () {
+    return this.admins
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.NEW_PEERTUBE_VERSION,
+      userId: user.id,
+      applicationId: this.payload.application.id
+    })
+    notification.Application = this.payload.application
+
+    return notification
+  }
+
+  async createEmail (to: string) {
+    return {
+      to,
+      template: 'peertube-version-new',
+      subject: `A new PeerTube version is available: ${this.payload.latestVersion}`,
+      locals: {
+        latestVersion: this.payload.latestVersion
+      }
+    }
+  }
+}
diff --git a/server/lib/notifier/shared/instance/new-plugin-version-for-admins.ts b/server/lib/notifier/shared/instance/new-plugin-version-for-admins.ts
new file mode 100644
index 000000000..e5e456a70
--- /dev/null
+++ b/server/lib/notifier/shared/instance/new-plugin-version-for-admins.ts
@@ -0,0 +1,58 @@
+import { logger } from '@server/helpers/logger'
+import { WEBSERVER } from '@server/initializers/constants'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MPlugin, MUserDefault, MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType, UserRight } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class NewPluginVersionForAdmins extends AbstractNotification <MPlugin> {
+  private admins: MUserDefault[]
+
+  async prepare () {
+    // Use the debug right to know who is an administrator
+    this.admins = await UserModel.listWithRight(UserRight.MANAGE_DEBUG)
+  }
+
+  log () {
+    logger.info('Notifying %s admins of new PeerTube version %s.', this.admins.length, this.payload.latestVersion)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.newPluginVersion
+  }
+
+  getTargetUsers () {
+    return this.admins
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.NEW_PLUGIN_VERSION,
+      userId: user.id,
+      pluginId: this.plugin.id
+    })
+    notification.Plugin = this.plugin
+
+    return notification
+  }
+
+  async createEmail (to: string) {
+    const pluginUrl = WEBSERVER.URL + '/admin/plugins/list-installed?pluginType=' + this.plugin.type
+
+    return {
+      to,
+      template: 'plugin-version-new',
+      subject: `A new plugin/theme version is available: ${this.plugin.name}@${this.plugin.latestVersion}`,
+      locals: {
+        pluginName: this.plugin.name,
+        latestVersion: this.plugin.latestVersion,
+        pluginUrl
+      }
+    }
+  }
+
+  private get plugin () {
+    return this.payload
+  }
+}
diff --git a/server/lib/notifier/shared/instance/registration-for-moderators.ts b/server/lib/notifier/shared/instance/registration-for-moderators.ts
new file mode 100644
index 000000000..4deb5a2cc
--- /dev/null
+++ b/server/lib/notifier/shared/instance/registration-for-moderators.ts
@@ -0,0 +1,49 @@
+import { logger } from '@server/helpers/logger'
+import { CONFIG } from '@server/initializers/config'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MUserDefault, MUserWithNotificationSetting, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType, UserRight } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class RegistrationForModerators extends AbstractNotification <MUserDefault> {
+  private moderators: MUserDefault[]
+
+  async prepare () {
+    this.moderators = await UserModel.listWithRight(UserRight.MANAGE_USERS)
+  }
+
+  log () {
+    logger.info('Notifying %s moderators of new user registration of %s.', this.moderators.length, this.payload.username)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.newUserRegistration
+  }
+
+  getTargetUsers () {
+    return this.moderators
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.NEW_USER_REGISTRATION,
+      userId: user.id,
+      accountId: this.payload.Account.id
+    })
+    notification.Account = this.payload.Account
+
+    return notification
+  }
+
+  async createEmail (to: string) {
+    return {
+      template: 'user-registered',
+      to,
+      subject: `a new user registered on ${CONFIG.INSTANCE.NAME}: ${this.payload.username}`,
+      locals: {
+        user: this.payload
+      }
+    }
+  }
+}
diff --git a/server/lib/notifier/shared/video-publication/abstract-owned-video-publication.ts b/server/lib/notifier/shared/video-publication/abstract-owned-video-publication.ts
new file mode 100644
index 000000000..fd06e080d
--- /dev/null
+++ b/server/lib/notifier/shared/video-publication/abstract-owned-video-publication.ts
@@ -0,0 +1,57 @@
+import { logger } from '@server/helpers/logger'
+import { WEBSERVER } from '@server/initializers/constants'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MUserDefault, MUserWithNotificationSetting, MVideoFullLight, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export abstract class AbstractOwnedVideoPublication extends AbstractNotification <MVideoFullLight> {
+  protected user: MUserDefault
+
+  async prepare () {
+    this.user = await UserModel.loadByVideoId(this.payload.id)
+  }
+
+  log () {
+    logger.info('Notifying user %s of the publication of its video %s.', this.user.username, this.payload.url)
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.myVideoPublished
+  }
+
+  getTargetUsers () {
+    if (!this.user) return []
+
+    return [ this.user ]
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.MY_VIDEO_PUBLISHED,
+      userId: user.id,
+      videoId: this.payload.id
+    })
+    notification.Video = this.payload
+
+    return notification
+  }
+
+  createEmail (to: string) {
+    const videoUrl = WEBSERVER.URL + this.payload.getWatchStaticPath()
+
+    return {
+      to,
+      subject: `Your video ${this.payload.name} has been published`,
+      text: `Your video "${this.payload.name}" has been published.`,
+      locals: {
+        title: 'You video is live',
+        action: {
+          text: 'View video',
+          url: videoUrl
+        }
+      }
+    }
+  }
+}
diff --git a/server/lib/notifier/shared/video-publication/import-finished-for-owner.ts b/server/lib/notifier/shared/video-publication/import-finished-for-owner.ts
new file mode 100644
index 000000000..9f374b6f9
--- /dev/null
+++ b/server/lib/notifier/shared/video-publication/import-finished-for-owner.ts
@@ -0,0 +1,97 @@
+import { logger } from '@server/helpers/logger'
+import { WEBSERVER } from '@server/initializers/constants'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MUserDefault, MUserWithNotificationSetting, MVideoImportVideo, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export type ImportFinishedForOwnerPayload = {
+  videoImport: MVideoImportVideo
+  success: boolean
+}
+
+export class ImportFinishedForOwner extends AbstractNotification <ImportFinishedForOwnerPayload> {
+  private user: MUserDefault
+
+  async prepare () {
+    this.user = await UserModel.loadByVideoImportId(this.videoImport.id)
+  }
+
+  log () {
+    logger.info('Notifying user %s its video import %s is finished.', this.user.username, this.videoImport.getTargetIdentifier())
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.myVideoImportFinished
+  }
+
+  getTargetUsers () {
+    if (!this.user) return []
+
+    return [ this.user ]
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: this.payload.success
+        ? UserNotificationType.MY_VIDEO_IMPORT_SUCCESS
+        : UserNotificationType.MY_VIDEO_IMPORT_ERROR,
+
+      userId: user.id,
+      videoImportId: this.videoImport.id
+    })
+    notification.VideoImport = this.videoImport
+
+    return notification
+  }
+
+  createEmail (to: string) {
+    if (this.payload.success) return this.createSuccessEmail(to)
+
+    return this.createFailEmail(to)
+  }
+
+  private createSuccessEmail (to: string) {
+    const videoUrl = WEBSERVER.URL + this.videoImport.Video.getWatchStaticPath()
+
+    return {
+      to,
+      subject: `Your video import ${this.videoImport.getTargetIdentifier()} is complete`,
+      text: `Your video "${this.videoImport.getTargetIdentifier()}" just finished importing.`,
+      locals: {
+        title: 'Import complete',
+        action: {
+          text: 'View video',
+          url: videoUrl
+        }
+      }
+    }
+  }
+
+  private createFailEmail (to: string) {
+    const importUrl = WEBSERVER.URL + '/my-library/video-imports'
+
+    const text =
+      `Your video import "${this.videoImport.getTargetIdentifier()}" encountered an error.` +
+      '\n\n' +
+      `See your videos import dashboard for more information: <a href="${importUrl}">${importUrl}</a>.`
+
+    return {
+      to,
+      subject: `Your video import "${this.videoImport.getTargetIdentifier()}" encountered an error`,
+      text,
+      locals: {
+        title: 'Import failed',
+        action: {
+          text: 'Review imports',
+          url: importUrl
+        }
+      }
+    }
+  }
+
+  private get videoImport () {
+    return this.payload.videoImport
+  }
+}
diff --git a/server/lib/notifier/shared/video-publication/index.ts b/server/lib/notifier/shared/video-publication/index.ts
new file mode 100644
index 000000000..940774504
--- /dev/null
+++ b/server/lib/notifier/shared/video-publication/index.ts
@@ -0,0 +1,5 @@
+export * from './new-video-for-subscribers'
+export * from './import-finished-for-owner'
+export * from './owned-publication-after-auto-unblacklist'
+export * from './owned-publication-after-schedule-update'
+export * from './owned-publication-after-transcoding'
diff --git a/server/lib/notifier/shared/video-publication/new-video-for-subscribers.ts b/server/lib/notifier/shared/video-publication/new-video-for-subscribers.ts
new file mode 100644
index 000000000..4253a0930
--- /dev/null
+++ b/server/lib/notifier/shared/video-publication/new-video-for-subscribers.ts
@@ -0,0 +1,61 @@
+import { logger } from '@server/helpers/logger'
+import { WEBSERVER } from '@server/initializers/constants'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MUserWithNotificationSetting, MVideoAccountLight, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType, VideoPrivacy, VideoState } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class NewVideoForSubscribers extends AbstractNotification <MVideoAccountLight> {
+  private users: MUserWithNotificationSetting[]
+
+  async prepare () {
+    // List all followers that are users
+    this.users = await UserModel.listUserSubscribersOf(this.payload.VideoChannel.actorId)
+  }
+
+  log () {
+    logger.info('Notifying %d users of new video %s.', this.users.length, this.payload.url)
+  }
+
+  isDisabled () {
+    return this.payload.privacy !== VideoPrivacy.PUBLIC || this.payload.state !== VideoState.PUBLISHED || this.payload.isBlacklisted()
+  }
+
+  getSetting (user: MUserWithNotificationSetting) {
+    return user.NotificationSetting.newVideoFromSubscription
+  }
+
+  getTargetUsers () {
+    return this.users
+  }
+
+  async createNotification (user: MUserWithNotificationSetting) {
+    const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+      type: UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION,
+      userId: user.id,
+      videoId: this.payload.id
+    })
+    notification.Video = this.payload
+
+    return notification
+  }
+
+  createEmail (to: string) {
+    const channelName = this.payload.VideoChannel.getDisplayName()
+    const videoUrl = WEBSERVER.URL + this.payload.getWatchStaticPath()
+
+    return {
+      to,
+      subject: channelName + ' just published a new video',
+      text: `Your subscription ${channelName} just published a new video: "${this.payload.name}".`,
+      locals: {
+        title: 'New content ',
+        action: {
+          text: 'View video',
+          url: videoUrl
+        }
+      }
+    }
+  }
+}
diff --git a/server/lib/notifier/shared/video-publication/owned-publication-after-auto-unblacklist.ts b/server/lib/notifier/shared/video-publication/owned-publication-after-auto-unblacklist.ts
new file mode 100644
index 000000000..27d89a5c7
--- /dev/null
+++ b/server/lib/notifier/shared/video-publication/owned-publication-after-auto-unblacklist.ts
@@ -0,0 +1,11 @@
+
+import { VideoState } from '@shared/models'
+import { AbstractOwnedVideoPublication } from './abstract-owned-video-publication'
+
+export class OwnedPublicationAfterAutoUnblacklist extends AbstractOwnedVideoPublication {
+
+  isDisabled () {
+    // Don't notify if video is still waiting for transcoding or scheduled update
+    return !!this.payload.ScheduleVideoUpdate || (this.payload.waitTranscoding && this.payload.state !== VideoState.PUBLISHED)
+  }
+}
diff --git a/server/lib/notifier/shared/video-publication/owned-publication-after-schedule-update.ts b/server/lib/notifier/shared/video-publication/owned-publication-after-schedule-update.ts
new file mode 100644
index 000000000..2e253b358
--- /dev/null
+++ b/server/lib/notifier/shared/video-publication/owned-publication-after-schedule-update.ts
@@ -0,0 +1,10 @@
+import { VideoState } from '@shared/models'
+import { AbstractOwnedVideoPublication } from './abstract-owned-video-publication'
+
+export class OwnedPublicationAfterScheduleUpdate extends AbstractOwnedVideoPublication {
+
+  isDisabled () {
+    // Don't notify if video is still blacklisted or waiting for transcoding
+    return !!this.payload.VideoBlacklist || (this.payload.waitTranscoding && this.payload.state !== VideoState.PUBLISHED)
+  }
+}
diff --git a/server/lib/notifier/shared/video-publication/owned-publication-after-transcoding.ts b/server/lib/notifier/shared/video-publication/owned-publication-after-transcoding.ts
new file mode 100644
index 000000000..4fab1090f
--- /dev/null
+++ b/server/lib/notifier/shared/video-publication/owned-publication-after-transcoding.ts
@@ -0,0 +1,9 @@
+import { AbstractOwnedVideoPublication } from './abstract-owned-video-publication'
+
+export class OwnedPublicationAfterTranscoding extends AbstractOwnedVideoPublication {
+
+  isDisabled () {
+    // Don't notify if didn't wait for transcoding or video is still blacklisted/waiting for scheduled update
+    return !this.payload.waitTranscoding || !!this.payload.VideoBlacklist || !!this.payload.ScheduleVideoUpdate
+  }
+}
diff --git a/server/lib/plugins/register-helpers.ts b/server/lib/plugins/register-helpers.ts
index 09275f9ba..af533effd 100644
--- a/server/lib/plugins/register-helpers.ts
+++ b/server/lib/plugins/register-helpers.ts
@@ -1,13 +1,7 @@
 import * as express from 'express'
 import { logger } from '@server/helpers/logger'
-import {
-  VIDEO_CATEGORIES,
-  VIDEO_LANGUAGES,
-  VIDEO_LICENCES,
-  VIDEO_PLAYLIST_PRIVACIES,
-  VIDEO_PRIVACIES
-} from '@server/initializers/constants'
 import { onExternalUserAuthenticated } from '@server/lib/auth/external-auth'
+import { VideoConstantManagerFactory } from '@server/lib/plugins/video-constant-manager-factory'
 import { PluginModel } from '@server/models/server/plugin'
 import {
   RegisterServerAuthExternalOptions,
@@ -18,41 +12,18 @@ import {
 } from '@server/types/plugins'
 import {
   EncoderOptionsBuilder,
-  PluginPlaylistPrivacyManager,
   PluginSettingsManager,
   PluginStorageManager,
-  PluginVideoCategoryManager,
-  PluginVideoLanguageManager,
-  PluginVideoLicenceManager,
-  PluginVideoPrivacyManager,
   RegisterServerHookOptions,
   RegisterServerSettingOptions,
-  serverHookObject
+  serverHookObject,
+  VideoPlaylistPrivacy,
+  VideoPrivacy
 } from '@shared/models'
 import { VideoTranscodingProfilesManager } from '../transcoding/video-transcoding-profiles'
 import { buildPluginHelpers } from './plugin-helpers-builder'
 
-type AlterableVideoConstant = 'language' | 'licence' | 'category' | 'privacy' | 'playlistPrivacy'
-type VideoConstant = { [key in number | string]: string }
-
-type UpdatedVideoConstant = {
-  [name in AlterableVideoConstant]: {
-    [ npmName: string]: {
-      added: { key: number | string, label: string }[]
-      deleted: { key: number | string, label: string }[]
-    }
-  }
-}
-
 export class RegisterHelpers {
-  private readonly updatedVideoConstants: UpdatedVideoConstant = {
-    playlistPrivacy: { },
-    privacy: { },
-    language: { },
-    licence: { },
-    category: { }
-  }
-
   private readonly transcodingProfiles: {
     [ npmName: string ]: {
       type: 'vod' | 'live'
@@ -78,6 +49,7 @@ export class RegisterHelpers {
   private readonly onSettingsChangeCallbacks: ((settings: any) => Promise<any>)[] = []
 
   private readonly router: express.Router
+  private readonly videoConstantManagerFactory: VideoConstantManagerFactory
 
   constructor (
     private readonly npmName: string,
@@ -85,6 +57,7 @@ export class RegisterHelpers {
     private readonly onHookAdded: (options: RegisterServerHookOptions) => void
   ) {
     this.router = express.Router()
+    this.videoConstantManagerFactory = new VideoConstantManagerFactory(this.npmName)
   }
 
   buildRegisterHelpers (): RegisterServerOptions {
@@ -96,13 +69,13 @@ export class RegisterHelpers {
     const settingsManager = this.buildSettingsManager()
     const storageManager = this.buildStorageManager()
 
-    const videoLanguageManager = this.buildVideoLanguageManager()
+    const videoLanguageManager = this.videoConstantManagerFactory.createVideoConstantManager<string>('language')
 
-    const videoLicenceManager = this.buildVideoLicenceManager()
-    const videoCategoryManager = this.buildVideoCategoryManager()
+    const videoLicenceManager = this.videoConstantManagerFactory.createVideoConstantManager<number>('licence')
+    const videoCategoryManager = this.videoConstantManagerFactory.createVideoConstantManager<number>('category')
 
-    const videoPrivacyManager = this.buildVideoPrivacyManager()
-    const playlistPrivacyManager = this.buildPlaylistPrivacyManager()
+    const videoPrivacyManager = this.videoConstantManagerFactory.createVideoConstantManager<VideoPrivacy>('privacy')
+    const playlistPrivacyManager = this.videoConstantManagerFactory.createVideoConstantManager<VideoPlaylistPrivacy>('playlistPrivacy')
 
     const transcodingManager = this.buildTranscodingManager()
 
@@ -122,12 +95,38 @@ export class RegisterHelpers {
       settingsManager,
       storageManager,
 
-      videoLanguageManager,
-      videoCategoryManager,
-      videoLicenceManager,
+      videoLanguageManager: {
+        ...videoLanguageManager,
+        /** @deprecated use `addConstant` instead **/
+        addLanguage: videoLanguageManager.addConstant,
+        /** @deprecated use `deleteConstant` instead **/
+        deleteLanguage: videoLanguageManager.deleteConstant
+      },
+      videoCategoryManager: {
+        ...videoCategoryManager,
+        /** @deprecated use `addConstant` instead **/
+        addCategory: videoCategoryManager.addConstant,
+        /** @deprecated use `deleteConstant` instead **/
+        deleteCategory: videoCategoryManager.deleteConstant
+      },
+      videoLicenceManager: {
+        ...videoLicenceManager,
+        /** @deprecated use `addConstant` instead **/
+        addLicence: videoLicenceManager.addConstant,
+        /** @deprecated use `deleteConstant` instead **/
+        deleteLicence: videoLicenceManager.deleteConstant
+      },
 
-      videoPrivacyManager,
-      playlistPrivacyManager,
+      videoPrivacyManager: {
+        ...videoPrivacyManager,
+        /** @deprecated use `deleteConstant` instead **/
+        deletePrivacy: videoPrivacyManager.deleteConstant
+      },
+      playlistPrivacyManager: {
+        ...playlistPrivacyManager,
+        /** @deprecated use `deleteConstant` instead **/
+        deletePlaylistPrivacy: playlistPrivacyManager.deleteConstant
+      },
 
       transcodingManager,
 
@@ -141,29 +140,7 @@ export class RegisterHelpers {
   }
 
   reinitVideoConstants (npmName: string) {
-    const hash = {
-      language: VIDEO_LANGUAGES,
-      licence: VIDEO_LICENCES,
-      category: VIDEO_CATEGORIES,
-      privacy: VIDEO_PRIVACIES,
-      playlistPrivacy: VIDEO_PLAYLIST_PRIVACIES
-    }
-    const types: AlterableVideoConstant[] = [ 'language', 'licence', 'category', 'privacy', 'playlistPrivacy' ]
-
-    for (const type of types) {
-      const updatedConstants = this.updatedVideoConstants[type][npmName]
-      if (!updatedConstants) continue
-
-      for (const added of updatedConstants.added) {
-        delete hash[type][added.key]
-      }
-
-      for (const deleted of updatedConstants.deleted) {
-        hash[type][deleted.key] = deleted.label
-      }
-
-      delete this.updatedVideoConstants[type][npmName]
-    }
+    this.videoConstantManagerFactory.resetVideoConstants(npmName)
   }
 
   reinitTranscodingProfilesAndEncoders (npmName: string) {
@@ -291,119 +268,6 @@ export class RegisterHelpers {
     }
   }
 
-  private buildVideoLanguageManager (): PluginVideoLanguageManager {
-    return {
-      addLanguage: (key: string, label: string) => {
-        return this.addConstant({ npmName: this.npmName, type: 'language', obj: VIDEO_LANGUAGES, key, label })
-      },
-
-      deleteLanguage: (key: string) => {
-        return this.deleteConstant({ npmName: this.npmName, type: 'language', obj: VIDEO_LANGUAGES, key })
-      }
-    }
-  }
-
-  private buildVideoCategoryManager (): PluginVideoCategoryManager {
-    return {
-      addCategory: (key: number, label: string) => {
-        return this.addConstant({ npmName: this.npmName, type: 'category', obj: VIDEO_CATEGORIES, key, label })
-      },
-
-      deleteCategory: (key: number) => {
-        return this.deleteConstant({ npmName: this.npmName, type: 'category', obj: VIDEO_CATEGORIES, key })
-      }
-    }
-  }
-
-  private buildVideoPrivacyManager (): PluginVideoPrivacyManager {
-    return {
-      deletePrivacy: (key: number) => {
-        return this.deleteConstant({ npmName: this.npmName, type: 'privacy', obj: VIDEO_PRIVACIES, key })
-      }
-    }
-  }
-
-  private buildPlaylistPrivacyManager (): PluginPlaylistPrivacyManager {
-    return {
-      deletePlaylistPrivacy: (key: number) => {
-        return this.deleteConstant({ npmName: this.npmName, type: 'playlistPrivacy', obj: VIDEO_PLAYLIST_PRIVACIES, key })
-      }
-    }
-  }
-
-  private buildVideoLicenceManager (): PluginVideoLicenceManager {
-    return {
-      addLicence: (key: number, label: string) => {
-        return this.addConstant({ npmName: this.npmName, type: 'licence', obj: VIDEO_LICENCES, key, label })
-      },
-
-      deleteLicence: (key: number) => {
-        return this.deleteConstant({ npmName: this.npmName, type: 'licence', obj: VIDEO_LICENCES, key })
-      }
-    }
-  }
-
-  private addConstant<T extends string | number> (parameters: {
-    npmName: string
-    type: AlterableVideoConstant
-    obj: VideoConstant
-    key: T
-    label: string
-  }) {
-    const { npmName, type, obj, key, label } = parameters
-
-    if (obj[key]) {
-      logger.warn('Cannot add %s %s by plugin %s: key already exists.', type, npmName, key)
-      return false
-    }
-
-    if (!this.updatedVideoConstants[type][npmName]) {
-      this.updatedVideoConstants[type][npmName] = {
-        added: [],
-        deleted: []
-      }
-    }
-
-    this.updatedVideoConstants[type][npmName].added.push({ key, label })
-    obj[key] = label
-
-    return true
-  }
-
-  private deleteConstant<T extends string | number> (parameters: {
-    npmName: string
-    type: AlterableVideoConstant
-    obj: VideoConstant
-    key: T
-  }) {
-    const { npmName, type, obj, key } = parameters
-
-    if (!obj[key]) {
-      logger.warn('Cannot delete %s by plugin %s: key %s does not exist.', type, npmName, key)
-      return false
-    }
-
-    if (!this.updatedVideoConstants[type][npmName]) {
-      this.updatedVideoConstants[type][npmName] = {
-        added: [],
-        deleted: []
-      }
-    }
-
-    const updatedConstants = this.updatedVideoConstants[type][npmName]
-
-    const alreadyAdded = updatedConstants.added.find(a => a.key === key)
-    if (alreadyAdded) {
-      updatedConstants.added.filter(a => a.key !== key)
-    } else if (obj[key]) {
-      updatedConstants.deleted.push({ key, label: obj[key] })
-    }
-
-    delete obj[key]
-
-    return true
-  }
-
   private buildTranscodingManager () {
     const self = this
 
diff --git a/server/lib/plugins/video-constant-manager-factory.ts b/server/lib/plugins/video-constant-manager-factory.ts
new file mode 100644
index 000000000..f04dde29f
--- /dev/null
+++ b/server/lib/plugins/video-constant-manager-factory.ts
@@ -0,0 +1,139 @@
+import { logger } from '@server/helpers/logger'
+import {
+  VIDEO_CATEGORIES,
+  VIDEO_LANGUAGES,
+  VIDEO_LICENCES,
+  VIDEO_PLAYLIST_PRIVACIES,
+  VIDEO_PRIVACIES
+} from '@server/initializers/constants'
+import { ConstantManager } from '@shared/models/plugins/server/plugin-constant-manager.model'
+
+type AlterableVideoConstant = 'language' | 'licence' | 'category' | 'privacy' | 'playlistPrivacy'
+type VideoConstant = Record<number | string, string>
+
+type UpdatedVideoConstant = {
+  [name in AlterableVideoConstant]: {
+    [ npmName: string]: {
+      added: VideoConstant[]
+      deleted: VideoConstant[]
+    }
+  }
+}
+
+const constantsHash: { [key in AlterableVideoConstant]: VideoConstant } = {
+  language: VIDEO_LANGUAGES,
+  licence: VIDEO_LICENCES,
+  category: VIDEO_CATEGORIES,
+  privacy: VIDEO_PRIVACIES,
+  playlistPrivacy: VIDEO_PLAYLIST_PRIVACIES
+}
+
+export class VideoConstantManagerFactory {
+  private readonly updatedVideoConstants: UpdatedVideoConstant = {
+    playlistPrivacy: { },
+    privacy: { },
+    language: { },
+    licence: { },
+    category: { }
+  }
+
+  constructor (
+    private readonly npmName: string
+  ) {}
+
+  public resetVideoConstants (npmName: string) {
+    const types: AlterableVideoConstant[] = [ 'language', 'licence', 'category', 'privacy', 'playlistPrivacy' ]
+    for (const type of types) {
+      this.resetConstants({ npmName, type })
+    }
+  }
+
+  private resetConstants (parameters: { npmName: string, type: AlterableVideoConstant }) {
+    const { npmName, type } = parameters
+    const updatedConstants = this.updatedVideoConstants[type][npmName]
+
+    if (!updatedConstants) return
+
+    for (const added of updatedConstants.added) {
+      delete constantsHash[type][added.key]
+    }
+
+    for (const deleted of updatedConstants.deleted) {
+      constantsHash[type][deleted.key] = deleted.label
+    }
+
+    delete this.updatedVideoConstants[type][npmName]
+  }
+
+  public createVideoConstantManager<K extends number | string>(type: AlterableVideoConstant): ConstantManager<K> {
+    const { npmName } = this
+    return {
+      addConstant: (key: K, label: string) => this.addConstant({ npmName, type, key, label }),
+      deleteConstant: (key: K) => this.deleteConstant({ npmName, type, key }),
+      getConstantValue: (key: K) => constantsHash[type][key],
+      getConstants: () => constantsHash[type] as Record<K, string>,
+      resetConstants: () => this.resetConstants({ npmName, type })
+    }
+  }
+
+  private addConstant<T extends string | number> (parameters: {
+    npmName: string
+    type: AlterableVideoConstant
+    key: T
+    label: string
+  }) {
+    const { npmName, type, key, label } = parameters
+    const obj = constantsHash[type]
+
+    if (obj[key]) {
+      logger.warn('Cannot add %s %s by plugin %s: key already exists.', type, npmName, key)
+      return false
+    }
+
+    if (!this.updatedVideoConstants[type][npmName]) {
+      this.updatedVideoConstants[type][npmName] = {
+        added: [],
+        deleted: []
+      }
+    }
+
+    this.updatedVideoConstants[type][npmName].added.push({ key: key, label } as VideoConstant)
+    obj[key] = label
+
+    return true
+  }
+
+  private deleteConstant<T extends string | number> (parameters: {
+    npmName: string
+    type: AlterableVideoConstant
+    key: T
+  }) {
+    const { npmName, type, key } = parameters
+    const obj = constantsHash[type]
+
+    if (!obj[key]) {
+      logger.warn('Cannot delete %s by plugin %s: key %s does not exist.', type, npmName, key)
+      return false
+    }
+
+    if (!this.updatedVideoConstants[type][npmName]) {
+      this.updatedVideoConstants[type][npmName] = {
+        added: [],
+        deleted: []
+      }
+    }
+
+    const updatedConstants = this.updatedVideoConstants[type][npmName]
+
+    const alreadyAdded = updatedConstants.added.find(a => a.key === key)
+    if (alreadyAdded) {
+      updatedConstants.added.filter(a => a.key !== key)
+    } else if (obj[key]) {
+      updatedConstants.deleted.push({ key, label: obj[key] } as VideoConstant)
+    }
+
+    delete obj[key]
+
+    return true
+  }
+}
diff --git a/server/lib/schedulers/plugins-check-scheduler.ts b/server/lib/schedulers/plugins-check-scheduler.ts
index 9a1ae3ec5..c95e109b0 100644
--- a/server/lib/schedulers/plugins-check-scheduler.ts
+++ b/server/lib/schedulers/plugins-check-scheduler.ts
@@ -1,12 +1,12 @@
+import { chunk } from 'lodash'
+import { compareSemVer } from '@shared/core-utils'
 import { logger } from '../../helpers/logger'
-import { AbstractScheduler } from './abstract-scheduler'
-import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
 import { CONFIG } from '../../initializers/config'
+import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
 import { PluginModel } from '../../models/server/plugin'
-import { chunk } from 'lodash'
-import { getLatestPluginsVersion } from '../plugins/plugin-index'
-import { compareSemVer } from '../../../shared/core-utils/miscs/miscs'
 import { Notifier } from '../notifier'
+import { getLatestPluginsVersion } from '../plugins/plugin-index'
+import { AbstractScheduler } from './abstract-scheduler'
 
 export class PluginsCheckScheduler extends AbstractScheduler {
 
diff --git a/server/lib/schedulers/videos-redundancy-scheduler.ts b/server/lib/schedulers/videos-redundancy-scheduler.ts
index b5a5eb697..103ab1fab 100644
--- a/server/lib/schedulers/videos-redundancy-scheduler.ts
+++ b/server/lib/schedulers/videos-redundancy-scheduler.ts
@@ -267,7 +267,8 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
     logger.info('Duplicating %s streaming playlist in videos redundancy with "%s" strategy.', video.url, strategy)
 
     const destDirectory = join(HLS_REDUNDANCY_DIRECTORY, video.uuid)
-    await downloadPlaylistSegments(playlist.playlistUrl, destDirectory, VIDEO_IMPORT_TIMEOUT)
+    const masterPlaylistUrl = playlist.getMasterPlaylistUrl(video)
+    await downloadPlaylistSegments(masterPlaylistUrl, destDirectory, VIDEO_IMPORT_TIMEOUT)
 
     const createdModel: MVideoRedundancyStreamingPlaylistVideo = await VideoRedundancyModel.create({
       expiresOn,
@@ -282,7 +283,7 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
 
     await sendCreateCacheFile(serverActor, video, createdModel)
 
-    logger.info('Duplicated playlist %s -> %s.', playlist.playlistUrl, createdModel.url)
+    logger.info('Duplicated playlist %s -> %s.', masterPlaylistUrl, createdModel.url)
   }
 
   private async extendsExpirationOf (redundancy: MVideoRedundancyVideo, expiresAfterMs: number) {
@@ -330,7 +331,7 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
   private buildEntryLogId (object: MVideoRedundancyFileVideo | MVideoRedundancyStreamingPlaylistVideo) {
     if (isMVideoRedundancyFileVideo(object)) return `${object.VideoFile.Video.url}-${object.VideoFile.resolution}`
 
-    return `${object.VideoStreamingPlaylist.playlistUrl}`
+    return `${object.VideoStreamingPlaylist.getMasterPlaylistUrl(object.VideoStreamingPlaylist.Video)}`
   }
 
   private getTotalFileSizes (files: MVideoFile[], playlists: MStreamingPlaylistFiles[]) {
diff --git a/server/lib/transcoding/video-transcoding.ts b/server/lib/transcoding/video-transcoding.ts
index 1ad63baf3..d2a556360 100644
--- a/server/lib/transcoding/video-transcoding.ts
+++ b/server/lib/transcoding/video-transcoding.ts
@@ -10,11 +10,18 @@ import { transcode, TranscodeOptions, TranscodeOptionsType } from '../../helpers
 import { canDoQuickTranscode, getDurationFromVideoFile, getMetadataFromFile, getVideoFileFPS } from '../../helpers/ffprobe-utils'
 import { logger } from '../../helpers/logger'
 import { CONFIG } from '../../initializers/config'
-import { HLS_STREAMING_PLAYLIST_DIRECTORY, P2P_MEDIA_LOADER_PEER_VERSION, WEBSERVER } from '../../initializers/constants'
+import { HLS_STREAMING_PLAYLIST_DIRECTORY, P2P_MEDIA_LOADER_PEER_VERSION } from '../../initializers/constants'
 import { VideoFileModel } from '../../models/video/video-file'
 import { VideoStreamingPlaylistModel } from '../../models/video/video-streaming-playlist'
 import { updateMasterHLSPlaylist, updateSha256VODSegments } from '../hls'
-import { generateVideoFilename, generateVideoStreamingPlaylistName, getVideoFilePath } from '../video-paths'
+import {
+  generateHLSMasterPlaylistFilename,
+  generateHlsSha256SegmentsFilename,
+  generateHLSVideoFilename,
+  generateWebTorrentVideoFilename,
+  getHlsResolutionPlaylistFilename,
+  getVideoFilePath
+} from '../video-paths'
 import { VideoTranscodingProfilesManager } from './video-transcoding-profiles'
 
 /**
@@ -60,7 +67,7 @@ async function optimizeOriginalVideofile (video: MVideoFullLight, inputVideoFile
 
     // Important to do this before getVideoFilename() to take in account the new filename
     inputVideoFile.extname = newExtname
-    inputVideoFile.filename = generateVideoFilename(video, false, resolution, newExtname)
+    inputVideoFile.filename = generateWebTorrentVideoFilename(resolution, newExtname)
 
     const videoOutputPath = getVideoFilePath(video, inputVideoFile)
 
@@ -86,7 +93,7 @@ async function transcodeNewWebTorrentResolution (video: MVideoFullLight, resolut
   const newVideoFile = new VideoFileModel({
     resolution,
     extname,
-    filename: generateVideoFilename(video, false, resolution, extname),
+    filename: generateWebTorrentVideoFilename(resolution, extname),
     size: 0,
     videoId: video.id
   })
@@ -169,7 +176,7 @@ async function mergeAudioVideofile (video: MVideoFullLight, resolution: VideoRes
 
   // Important to do this before getVideoFilename() to take in account the new file extension
   inputVideoFile.extname = newExtname
-  inputVideoFile.filename = generateVideoFilename(video, false, inputVideoFile.resolution, newExtname)
+  inputVideoFile.filename = generateWebTorrentVideoFilename(inputVideoFile.resolution, newExtname)
 
   const videoOutputPath = getVideoFilePath(video, inputVideoFile)
   // ffmpeg generated a new video file, so update the video duration
@@ -271,15 +278,15 @@ async function generateHlsPlaylistCommon (options: {
   const videoTranscodedBasePath = join(transcodeDirectory, type)
   await ensureDir(videoTranscodedBasePath)
 
-  const videoFilename = generateVideoStreamingPlaylistName(video.uuid, resolution)
-  const playlistFilename = VideoStreamingPlaylistModel.getHlsPlaylistFilename(resolution)
-  const playlistFileTranscodePath = join(videoTranscodedBasePath, playlistFilename)
+  const videoFilename = generateHLSVideoFilename(resolution)
+  const resolutionPlaylistFilename = getHlsResolutionPlaylistFilename(videoFilename)
+  const resolutionPlaylistFileTranscodePath = join(videoTranscodedBasePath, resolutionPlaylistFilename)
 
   const transcodeOptions = {
     type,
 
     inputPath,
-    outputPath: playlistFileTranscodePath,
+    outputPath: resolutionPlaylistFileTranscodePath,
 
     availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
     profile: CONFIG.TRANSCODING.PROFILE,
@@ -299,19 +306,23 @@ async function generateHlsPlaylistCommon (options: {
 
   await transcode(transcodeOptions)
 
-  const playlistUrl = WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsMasterPlaylistStaticPath(video.uuid)
-
   // Create or update the playlist
-  const [ videoStreamingPlaylist ] = await VideoStreamingPlaylistModel.upsert({
-    videoId: video.id,
-    playlistUrl,
-    segmentsSha256Url: WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsSha256SegmentsStaticPath(video.uuid, video.isLive),
-    p2pMediaLoaderInfohashes: [],
-    p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
+  const playlist = await VideoStreamingPlaylistModel.loadOrGenerate(video)
+
+  if (!playlist.playlistFilename) {
+    playlist.playlistFilename = generateHLSMasterPlaylistFilename(video.isLive)
+  }
+
+  if (!playlist.segmentsSha256Filename) {
+    playlist.segmentsSha256Filename = generateHlsSha256SegmentsFilename(video.isLive)
+  }
+
+  playlist.p2pMediaLoaderInfohashes = []
+  playlist.p2pMediaLoaderPeerVersion = P2P_MEDIA_LOADER_PEER_VERSION
 
-    type: VideoStreamingPlaylistType.HLS
-  }, { returning: true }) as [ MStreamingPlaylistFilesVideo, boolean ]
-  videoStreamingPlaylist.Video = video
+  playlist.type = VideoStreamingPlaylistType.HLS
+
+  await playlist.save()
 
   // Build the new playlist file
   const extname = extnameUtil(videoFilename)
@@ -319,20 +330,20 @@ async function generateHlsPlaylistCommon (options: {
     resolution,
     extname,
     size: 0,
-    filename: generateVideoFilename(video, true, resolution, extname),
+    filename: videoFilename,
     fps: -1,
-    videoStreamingPlaylistId: videoStreamingPlaylist.id
+    videoStreamingPlaylistId: playlist.id
   })
 
-  const videoFilePath = getVideoFilePath(videoStreamingPlaylist, newVideoFile)
+  const videoFilePath = getVideoFilePath(playlist, newVideoFile)
 
   // Move files from tmp transcoded directory to the appropriate place
   const baseHlsDirectory = join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid)
   await ensureDir(baseHlsDirectory)
 
   // Move playlist file
-  const playlistPath = join(baseHlsDirectory, playlistFilename)
-  await move(playlistFileTranscodePath, playlistPath, { overwrite: true })
+  const resolutionPlaylistPath = join(baseHlsDirectory, resolutionPlaylistFilename)
+  await move(resolutionPlaylistFileTranscodePath, resolutionPlaylistPath, { overwrite: true })
   // Move video file
   await move(join(videoTranscodedBasePath, videoFilename), videoFilePath, { overwrite: true })
 
@@ -342,20 +353,20 @@ async function generateHlsPlaylistCommon (options: {
   newVideoFile.fps = await getVideoFileFPS(videoFilePath)
   newVideoFile.metadata = await getMetadataFromFile(videoFilePath)
 
-  await createTorrentAndSetInfoHash(videoStreamingPlaylist, newVideoFile)
+  await createTorrentAndSetInfoHash(playlist, newVideoFile)
 
   await VideoFileModel.customUpsert(newVideoFile, 'streaming-playlist', undefined)
-  videoStreamingPlaylist.VideoFiles = await videoStreamingPlaylist.$get('VideoFiles')
 
-  videoStreamingPlaylist.p2pMediaLoaderInfohashes = VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(
-    playlistUrl, videoStreamingPlaylist.VideoFiles
-  )
-  await videoStreamingPlaylist.save()
+  const playlistWithFiles = playlist as MStreamingPlaylistFilesVideo
+  playlistWithFiles.VideoFiles = await playlist.$get('VideoFiles')
+  playlist.assignP2PMediaLoaderInfoHashes(video, playlistWithFiles.VideoFiles)
+
+  await playlist.save()
 
-  video.setHLSPlaylist(videoStreamingPlaylist)
+  video.setHLSPlaylist(playlist)
 
-  await updateMasterHLSPlaylist(video)
-  await updateSha256VODSegments(video)
+  await updateMasterHLSPlaylist(video, playlistWithFiles)
+  await updateSha256VODSegments(video, playlistWithFiles)
 
-  return playlistPath
+  return resolutionPlaylistPath
 }
diff --git a/server/lib/video-paths.ts b/server/lib/video-paths.ts
index 1708c479a..1e4382108 100644
--- a/server/lib/video-paths.ts
+++ b/server/lib/video-paths.ts
@@ -3,29 +3,17 @@ import { extractVideo } from '@server/helpers/video'
 import { CONFIG } from '@server/initializers/config'
 import { HLS_REDUNDANCY_DIRECTORY, HLS_STREAMING_PLAYLIST_DIRECTORY, STATIC_PATHS, WEBSERVER } from '@server/initializers/constants'
 import { isStreamingPlaylist, MStreamingPlaylist, MStreamingPlaylistVideo, MVideo, MVideoFile, MVideoUUID } from '@server/types/models'
+import { buildUUID } from '@server/helpers/uuid'
+import { removeFragmentedMP4Ext } from '@shared/core-utils'
 
 // ################## Video file name ##################
 
-function generateVideoFilename (videoOrPlaylist: MVideo | MStreamingPlaylistVideo, isHls: boolean, resolution: number, extname: string) {
-  const video = extractVideo(videoOrPlaylist)
-
-  // FIXME: use a generated uuid instead, that will break compatibility with PeerTube < 3.1
-  // const uuid = uuidv4()
-  const uuid = video.uuid
-
-  if (isHls) {
-    return generateVideoStreamingPlaylistName(uuid, resolution)
-  }
-
-  return generateWebTorrentVideoName(uuid, resolution, extname)
+function generateWebTorrentVideoFilename (resolution: number, extname: string) {
+  return buildUUID() + '-' + resolution + extname
 }
 
-function generateVideoStreamingPlaylistName (uuid: string, resolution: number) {
-  return `${uuid}-${resolution}-fragmented.mp4`
-}
-
-function generateWebTorrentVideoName (uuid: string, resolution: number, extname: string) {
-  return uuid + '-' + resolution + extname
+function generateHLSVideoFilename (resolution: number) {
+  return `${buildUUID()}-${resolution}-fragmented.mp4`
 }
 
 function getVideoFilePath (videoOrPlaylist: MVideo | MStreamingPlaylistVideo, videoFile: MVideoFile, isRedundancy = false) {
@@ -63,15 +51,28 @@ function getHLSDirectory (video: MVideoUUID, isRedundancy = false) {
   return join(baseDir, video.uuid)
 }
 
+function getHlsResolutionPlaylistFilename (videoFilename: string) {
+  // Video file name already contain resolution
+  return removeFragmentedMP4Ext(videoFilename) + '.m3u8'
+}
+
+function generateHLSMasterPlaylistFilename (isLive = false) {
+  if (isLive) return 'master.m3u8'
+
+  return buildUUID() + '-master.m3u8'
+}
+
+function generateHlsSha256SegmentsFilename (isLive = false) {
+  if (isLive) return 'segments-sha256.json'
+
+  return buildUUID() + '-segments-sha256.json'
+}
+
 // ################## Torrents ##################
 
 function generateTorrentFileName (videoOrPlaylist: MVideo | MStreamingPlaylistVideo, resolution: number) {
-  const video = extractVideo(videoOrPlaylist)
   const extension = '.torrent'
-
-  // FIXME: use a generated uuid instead, that will break compatibility with PeerTube < 3.1
-  // const uuid = uuidv4()
-  const uuid = video.uuid
+  const uuid = buildUUID()
 
   if (isStreamingPlaylist(videoOrPlaylist)) {
     return `${uuid}-${resolution}-${videoOrPlaylist.getStringType()}${extension}`
@@ -95,15 +96,18 @@ function getLocalVideoFileMetadataUrl (video: MVideoUUID, videoFile: MVideoFile)
 // ---------------------------------------------------------------------------
 
 export {
-  generateVideoStreamingPlaylistName,
-  generateWebTorrentVideoName,
-  generateVideoFilename,
+  generateHLSVideoFilename,
+  generateWebTorrentVideoFilename,
+
   getVideoFilePath,
 
   generateTorrentFileName,
   getTorrentFilePath,
 
   getHLSDirectory,
+  generateHLSMasterPlaylistFilename,
+  generateHlsSha256SegmentsFilename,
+  getHlsResolutionPlaylistFilename,
 
   getLocalVideoFileMetadataUrl,
 
diff --git a/server/lib/video.ts b/server/lib/video.ts
index daf998704..61fee4949 100644
--- a/server/lib/video.ts
+++ b/server/lib/video.ts
@@ -5,7 +5,7 @@ import { sequelizeTypescript } from '@server/initializers/database'
 import { TagModel } from '@server/models/video/tag'
 import { VideoModel } from '@server/models/video/video'
 import { FilteredModelAttributes } from '@server/types'
-import { MThumbnail, MUserId, MVideo, MVideoFile, MVideoTag, MVideoThumbnail, MVideoUUID } from '@server/types/models'
+import { MThumbnail, MUserId, MVideoFile, MVideoTag, MVideoThumbnail, MVideoUUID } from '@server/types/models'
 import { ThumbnailType, VideoCreate, VideoPrivacy, VideoTranscodingPayload } from '@shared/models'
 import { federateVideoIfNeeded } from './activitypub/videos'
 import { JobQueue } from './job-queue/job-queue'
@@ -105,7 +105,7 @@ async function publishAndFederateIfNeeded (video: MVideoUUID, wasLive = false) {
   }
 }
 
-async function addOptimizeOrMergeAudioJob (video: MVideo, videoFile: MVideoFile, user: MUserId) {
+async function addOptimizeOrMergeAudioJob (video: MVideoUUID, videoFile: MVideoFile, user: MUserId) {
   let dataInput: VideoTranscodingPayload
 
   if (videoFile.isAudio()) {
diff --git a/server/middlewares/activitypub.ts b/server/middlewares/activitypub.ts
index 6b43b7764..6ef90b275 100644
--- a/server/middlewares/activitypub.ts
+++ b/server/middlewares/activitypub.ts
@@ -2,7 +2,7 @@ import { NextFunction, Request, Response } from 'express'
 import { getAPId } from '@server/helpers/activitypub'
 import { isActorDeleteActivityValid } from '@server/helpers/custom-validators/activitypub/actor'
 import { ActivityDelete, ActivityPubSignature } from '../../shared'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { logger } from '../helpers/logger'
 import { isHTTPSignatureVerified, isJsonLDSignatureVerified, parseHTTPSignature } from '../helpers/peertube-crypto'
 import { ACCEPT_HEADERS, ACTIVITY_PUB, HTTP_SIGNATURE } from '../initializers/constants'
diff --git a/server/middlewares/auth.ts b/server/middlewares/auth.ts
index 176461cc2..9e6327b23 100644
--- a/server/middlewares/auth.ts
+++ b/server/middlewares/auth.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { Socket } from 'socket.io'
 import { getAccessToken } from '@server/lib/auth/oauth-model'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { logger } from '../helpers/logger'
 import { handleOAuthAuthenticate } from '../lib/auth/oauth'
 
diff --git a/server/middlewares/cache.ts b/server/middlewares/cache.ts
deleted file mode 100644
index 0708ee8e8..000000000
--- a/server/middlewares/cache.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { Redis } from '../lib/redis'
-import * as apicache from 'apicache'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
-
-// Ensure Redis is initialized
-Redis.Instance.init()
-
-const defaultOptions = {
-  redisClient: Redis.Instance.getClient(),
-  appendKey: () => Redis.Instance.getPrefix(),
-  statusCodes: {
-    exclude: [
-      HttpStatusCode.FORBIDDEN_403,
-      HttpStatusCode.NOT_FOUND_404
-    ]
-  }
-}
-
-const cacheRoute = (extraOptions = {}) => apicache.options({
-  ...defaultOptions,
-  ...extraOptions
-}).middleware
-
-// ---------------------------------------------------------------------------
-
-export {
-  cacheRoute
-}
diff --git a/server/middlewares/cache/cache.ts b/server/middlewares/cache/cache.ts
new file mode 100644
index 000000000..48162a0ae
--- /dev/null
+++ b/server/middlewares/cache/cache.ts
@@ -0,0 +1,32 @@
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
+import { Redis } from '../../lib/redis'
+import { ApiCache, APICacheOptions } from './shared'
+
+// Ensure Redis is initialized
+Redis.Instance.init()
+
+const defaultOptions: APICacheOptions = {
+  excludeStatus: [
+    HttpStatusCode.FORBIDDEN_403,
+    HttpStatusCode.NOT_FOUND_404
+  ]
+}
+
+function cacheRoute (duration: string) {
+  const instance = new ApiCache(defaultOptions)
+
+  return instance.buildMiddleware(duration)
+}
+
+function cacheRouteFactory (options: APICacheOptions) {
+  const instance = new ApiCache({ ...defaultOptions, ...options })
+
+  return instance.buildMiddleware.bind(instance)
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  cacheRoute,
+  cacheRouteFactory
+}
diff --git a/server/middlewares/cache/index.ts b/server/middlewares/cache/index.ts
new file mode 100644
index 000000000..79b512828
--- /dev/null
+++ b/server/middlewares/cache/index.ts
@@ -0,0 +1 @@
+export * from './cache'
diff --git a/server/middlewares/cache/shared/api-cache.ts b/server/middlewares/cache/shared/api-cache.ts
new file mode 100644
index 000000000..f9f7b1b67
--- /dev/null
+++ b/server/middlewares/cache/shared/api-cache.ts
@@ -0,0 +1,269 @@
+// Thanks: https://github.com/kwhitley/apicache
+// We duplicated the library because it is unmaintened and prevent us to upgrade to recent NodeJS versions
+
+import * as express from 'express'
+import { OutgoingHttpHeaders } from 'http'
+import { isTestInstance, parseDurationToMs } from '@server/helpers/core-utils'
+import { logger } from '@server/helpers/logger'
+import { Redis } from '@server/lib/redis'
+import { HttpStatusCode } from '@shared/models'
+
+export interface APICacheOptions {
+  headerBlacklist?: string[]
+  excludeStatus?: HttpStatusCode[]
+}
+
+interface CacheObject {
+  status: number
+  headers: OutgoingHttpHeaders
+  data: any
+  encoding: BufferEncoding
+  timestamp: number
+}
+
+export class ApiCache {
+
+  private readonly options: APICacheOptions
+  private readonly timers: { [ id: string ]: NodeJS.Timeout } = {}
+
+  private index: { all: string[] } = { all: [] }
+
+  constructor (options: APICacheOptions) {
+    this.options = {
+      headerBlacklist: [],
+      excludeStatus: [],
+
+      ...options
+    }
+  }
+
+  buildMiddleware (strDuration: string) {
+    const duration = parseDurationToMs(strDuration)
+
+    return (req: express.Request, res: express.Response, next: express.NextFunction) => {
+      const key = Redis.Instance.getPrefix() + 'api-cache-' + req.originalUrl
+      const redis = Redis.Instance.getClient()
+
+      if (!redis.connected) return this.makeResponseCacheable(res, next, key, duration)
+
+      try {
+        redis.hgetall(key, (err, obj) => {
+          if (!err && obj && obj.response) {
+            return this.sendCachedResponse(req, res, JSON.parse(obj.response), duration)
+          }
+
+          return this.makeResponseCacheable(res, next, key, duration)
+        })
+      } catch (err) {
+        return this.makeResponseCacheable(res, next, key, duration)
+      }
+    }
+  }
+
+  private shouldCacheResponse (response: express.Response) {
+    if (!response) return false
+    if (this.options.excludeStatus.includes(response.statusCode)) return false
+
+    return true
+  }
+
+  private addIndexEntries (key: string) {
+    this.index.all.unshift(key)
+  }
+
+  private filterBlacklistedHeaders (headers: OutgoingHttpHeaders) {
+    return Object.keys(headers)
+      .filter(key => !this.options.headerBlacklist.includes(key))
+      .reduce((acc, header) => {
+        acc[header] = headers[header]
+
+        return acc
+      }, {})
+  }
+
+  private createCacheObject (status: number, headers: OutgoingHttpHeaders, data: any, encoding: BufferEncoding) {
+    return {
+      status,
+      headers: this.filterBlacklistedHeaders(headers),
+      data,
+      encoding,
+
+      // Seconds since epoch, used to properly decrement max-age headers in cached responses.
+      timestamp: new Date().getTime() / 1000
+    } as CacheObject
+  }
+
+  private cacheResponse (key: string, value: object, duration: number) {
+    const redis = Redis.Instance.getClient()
+
+    if (redis.connected) {
+      try {
+        redis.hset(key, 'response', JSON.stringify(value))
+        redis.hset(key, 'duration', duration + '')
+        redis.expire(key, duration / 1000)
+      } catch (err) {
+        logger.error('Cannot set cache in redis.', { err })
+      }
+    }
+
+    // add automatic cache clearing from duration, includes max limit on setTimeout
+    this.timers[key] = setTimeout(() => this.clear(key), Math.min(duration, 2147483647))
+  }
+
+  private accumulateContent (res: express.Response, content: any) {
+    if (!content) return
+
+    if (typeof content === 'string') {
+      res.locals.apicache.content = (res.locals.apicache.content || '') + content
+      return
+    }
+
+    if (Buffer.isBuffer(content)) {
+      let oldContent = res.locals.apicache.content
+
+      if (typeof oldContent === 'string') {
+        oldContent = Buffer.from(oldContent)
+      }
+
+      if (!oldContent) {
+        oldContent = Buffer.alloc(0)
+      }
+
+      res.locals.apicache.content = Buffer.concat(
+        [ oldContent, content ],
+        oldContent.length + content.length
+      )
+
+      return
+    }
+
+    res.locals.apicache.content = content
+  }
+
+  private makeResponseCacheable (res: express.Response, next: express.NextFunction, key: string, duration: number) {
+    const self = this
+
+    res.locals.apicache = {
+      write: res.write,
+      writeHead: res.writeHead,
+      end: res.end,
+      cacheable: true,
+      content: undefined,
+      headers: {}
+    }
+
+    // Patch express
+    res.writeHead = function () {
+      if (self.shouldCacheResponse(res)) {
+        res.setHeader('cache-control', 'max-age=' + (duration / 1000).toFixed(0))
+      } else {
+        res.setHeader('cache-control', 'no-cache, no-store, must-revalidate')
+      }
+
+      res.locals.apicache.headers = Object.assign({}, res.getHeaders())
+      return res.locals.apicache.writeHead.apply(this, arguments as any)
+    }
+
+    res.write = function (chunk: any) {
+      self.accumulateContent(res, chunk)
+      return res.locals.apicache.write.apply(this, arguments as any)
+    }
+
+    res.end = function (content: any, encoding: BufferEncoding) {
+      if (self.shouldCacheResponse(res)) {
+        self.accumulateContent(res, content)
+
+        if (res.locals.apicache.cacheable && res.locals.apicache.content) {
+          self.addIndexEntries(key)
+
+          const headers = res.locals.apicache.headers || res.getHeaders()
+          const cacheObject = self.createCacheObject(
+            res.statusCode,
+            headers,
+            res.locals.apicache.content,
+            encoding
+          )
+          self.cacheResponse(key, cacheObject, duration)
+        }
+      }
+
+      res.locals.apicache.end.apply(this, arguments as any)
+    } as any
+
+    next()
+  }
+
+  private sendCachedResponse (request: express.Request, response: express.Response, cacheObject: CacheObject, duration: number) {
+    const headers = response.getHeaders()
+
+    if (isTestInstance()) {
+      Object.assign(headers, {
+        'x-api-cache-cached': 'true'
+      })
+    }
+
+    Object.assign(headers, this.filterBlacklistedHeaders(cacheObject.headers || {}), {
+      // Set properly decremented max-age header
+      // This ensures that max-age is in sync with the cache expiration
+      'cache-control':
+        'max-age=' +
+        Math.max(
+          0,
+          (duration / 1000 - (new Date().getTime() / 1000 - cacheObject.timestamp))
+        ).toFixed(0)
+    })
+
+    // unstringify buffers
+    let data = cacheObject.data
+    if (data && data.type === 'Buffer') {
+      data = typeof data.data === 'number'
+        ? Buffer.alloc(data.data)
+        : Buffer.from(data.data)
+    }
+
+    // Test Etag against If-None-Match for 304
+    const cachedEtag = cacheObject.headers.etag
+    const requestEtag = request.headers['if-none-match']
+
+    if (requestEtag && cachedEtag === requestEtag) {
+      response.writeHead(304, headers)
+      return response.end()
+    }
+
+    response.writeHead(cacheObject.status || 200, headers)
+
+    return response.end(data, cacheObject.encoding)
+  }
+
+  private clear (target: string) {
+    const redis = Redis.Instance.getClient()
+
+    if (target) {
+      clearTimeout(this.timers[target])
+      delete this.timers[target]
+
+      try {
+        redis.del(target)
+      } catch (err) {
+        logger.error('Cannot delete %s in redis cache.', target, { err })
+      }
+
+      this.index.all = this.index.all.filter(key => key !== target)
+    } else {
+      for (const key of this.index.all) {
+        clearTimeout(this.timers[key])
+        delete this.timers[key]
+
+        try {
+          redis.del(key)
+        } catch (err) {
+          logger.error('Cannot delete %s in redis cache.', key, { err })
+        }
+      }
+
+      this.index.all = []
+    }
+
+    return this.index
+  }
+}
diff --git a/server/middlewares/cache/shared/index.ts b/server/middlewares/cache/shared/index.ts
new file mode 100644
index 000000000..c707eaf7a
--- /dev/null
+++ b/server/middlewares/cache/shared/index.ts
@@ -0,0 +1 @@
+export * from './api-cache'
diff --git a/server/middlewares/error.ts b/server/middlewares/error.ts
index e3eb1c8f5..af5a9c29a 100644
--- a/server/middlewares/error.ts
+++ b/server/middlewares/error.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { ProblemDocument, ProblemDocumentExtension } from 'http-problem-details'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 
 function apiFailMiddleware (req: express.Request, res: express.Response, next: express.NextFunction) {
   res.fail = options => {
diff --git a/server/middlewares/index.ts b/server/middlewares/index.ts
index 413653dac..a0035f623 100644
--- a/server/middlewares/index.ts
+++ b/server/middlewares/index.ts
@@ -1,4 +1,5 @@
 export * from './validators'
+export * from './cache'
 export * from './activitypub'
 export * from './async'
 export * from './auth'
diff --git a/server/middlewares/servers.ts b/server/middlewares/servers.ts
index 9aa56bc93..cf70d901e 100644
--- a/server/middlewares/servers.ts
+++ b/server/middlewares/servers.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
+import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { getHostWithPort } from '../helpers/express-utils'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
 
 function setBodyHostsPort (req: express.Request, res: express.Response, next: express.NextFunction) {
   if (!req.body.hosts) return next()
diff --git a/server/middlewares/user-right.ts b/server/middlewares/user-right.ts
index d1888c2d3..c8c694f05 100644
--- a/server/middlewares/user-right.ts
+++ b/server/middlewares/user-right.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { UserRight } from '../../shared'
+import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { logger } from '../helpers/logger'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
 
 function ensureUserHasRight (userRight: UserRight) {
   return function (req: express.Request, res: express.Response, next: express.NextFunction) {
diff --git a/server/middlewares/validators/abuse.ts b/server/middlewares/validators/abuse.ts
index c048bc6af..f4d9c3af2 100644
--- a/server/middlewares/validators/abuse.ts
+++ b/server/middlewares/validators/abuse.ts
@@ -16,7 +16,7 @@ import { exists, isIdOrUUIDValid, isIdValid, toCompleteUUID, toIntOrNull } from
 import { logger } from '@server/helpers/logger'
 import { AbuseMessageModel } from '@server/models/abuse/abuse-message'
 import { AbuseCreate, UserRight } from '@shared/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { areValidationErrors, doesAbuseExist, doesAccountIdExist, doesCommentIdExist, doesVideoExist } from './shared'
 
 const abuseReportValidator = [
diff --git a/server/middlewares/validators/activitypub/activity.ts b/server/middlewares/validators/activitypub/activity.ts
index cc6acd4b1..d24e4427b 100644
--- a/server/middlewares/validators/activitypub/activity.ts
+++ b/server/middlewares/validators/activitypub/activity.ts
@@ -1,8 +1,8 @@
 import * as express from 'express'
+import { getServerActor } from '@server/models/application/application'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { isRootActivityValid } from '../../../helpers/custom-validators/activitypub/activity'
 import { logger } from '../../../helpers/logger'
-import { getServerActor } from '@server/models/application/application'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 async function activityPubValidator (req: express.Request, res: express.Response, next: express.NextFunction) {
   logger.debug('Checking activity pub parameters')
diff --git a/server/middlewares/validators/blocklist.ts b/server/middlewares/validators/blocklist.ts
index 826b16fc8..f15b293e9 100644
--- a/server/middlewares/validators/blocklist.ts
+++ b/server/middlewares/validators/blocklist.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { body, param } from 'express-validator'
 import { getServerActor } from '@server/models/application/application'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { isHostValid } from '../../helpers/custom-validators/servers'
 import { logger } from '../../helpers/logger'
 import { WEBSERVER } from '../../initializers/constants'
diff --git a/server/middlewares/validators/bulk.ts b/server/middlewares/validators/bulk.ts
index 9bb95f5b7..6fec58149 100644
--- a/server/middlewares/validators/bulk.ts
+++ b/server/middlewares/validators/bulk.ts
@@ -1,8 +1,7 @@
 import * as express from 'express'
 import { body } from 'express-validator'
 import { isBulkRemoveCommentsOfScopeValid } from '@server/helpers/custom-validators/bulk'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
-import { UserRight } from '@shared/models'
+import { HttpStatusCode, UserRight } from '@shared/models'
 import { BulkRemoveCommentsOfBody } from '@shared/models/bulk/bulk-remove-comments-of-body.model'
 import { logger } from '../../helpers/logger'
 import { areValidationErrors, doesAccountNameWithHostExist } from './shared'
diff --git a/server/middlewares/validators/feeds.ts b/server/middlewares/validators/feeds.ts
index 51b8fdd19..d29bebf64 100644
--- a/server/middlewares/validators/feeds.ts
+++ b/server/middlewares/validators/feeds.ts
@@ -1,7 +1,6 @@
 import * as express from 'express'
 import { param, query } from 'express-validator'
-
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { isValidRSSFeed } from '../../helpers/custom-validators/feeds'
 import { exists, isIdOrUUIDValid, isIdValid, toCompleteUUID } from '../../helpers/custom-validators/misc'
 import { logger } from '../../helpers/logger'
diff --git a/server/middlewares/validators/follows.ts b/server/middlewares/validators/follows.ts
index 205baca48..16abdd096 100644
--- a/server/middlewares/validators/follows.ts
+++ b/server/middlewares/validators/follows.ts
@@ -1,18 +1,20 @@
 import * as express from 'express'
 import { body, param, query } from 'express-validator'
-import { isFollowStateValid } from '@server/helpers/custom-validators/follows'
+import { isEachUniqueHandleValid, isFollowStateValid, isRemoteHandleValid } from '@server/helpers/custom-validators/follows'
 import { loadActorUrlOrGetFromWebfinger } from '@server/lib/activitypub/actors'
+import { getRemoteNameAndHost } from '@server/lib/activitypub/follow'
 import { getServerActor } from '@server/models/application/application'
 import { MActorFollowActorsDefault } from '@server/types/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { isTestInstance } from '../../helpers/core-utils'
 import { isActorTypeValid, isValidActorHandle } from '../../helpers/custom-validators/activitypub/actor'
 import { isEachUniqueHostValid, isHostValid } from '../../helpers/custom-validators/servers'
 import { logger } from '../../helpers/logger'
-import { SERVER_ACTOR_NAME, WEBSERVER } from '../../initializers/constants'
+import { WEBSERVER } from '../../initializers/constants'
 import { ActorModel } from '../../models/actor/actor'
 import { ActorFollowModel } from '../../models/actor/actor-follow'
 import { areValidationErrors } from './shared'
+import { ServerFollowCreate } from '@shared/models'
 
 const listFollowsValidator = [
   query('state')
@@ -30,29 +32,46 @@ const listFollowsValidator = [
 ]
 
 const followValidator = [
-  body('hosts').custom(isEachUniqueHostValid).withMessage('Should have an array of unique hosts'),
+  body('hosts')
+    .toArray()
+    .custom(isEachUniqueHostValid).withMessage('Should have an array of unique hosts'),
+
+  body('handles')
+    .toArray()
+    .custom(isEachUniqueHandleValid).withMessage('Should have an array of handles'),
 
   (req: express.Request, res: express.Response, next: express.NextFunction) => {
-    // Force https if the administrator wants to make friends
+    // Force https if the administrator wants to follow remote actors
     if (isTestInstance() === false && WEBSERVER.SCHEME === 'http') {
       return res
         .status(HttpStatusCode.INTERNAL_SERVER_ERROR_500)
         .json({
           error: 'Cannot follow on a non HTTPS web server.'
         })
-        .end()
     }
 
     logger.debug('Checking follow parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return
 
+    const body: ServerFollowCreate = req.body
+    if (body.hosts.length === 0 && body.handles.length === 0) {
+
+      return res
+        .status(HttpStatusCode.BAD_REQUEST_400)
+        .json({
+          error: 'You must provide at least one handle or one host.'
+        })
+    }
+
     return next()
   }
 ]
 
 const removeFollowingValidator = [
-  param('host').custom(isHostValid).withMessage('Should have a valid host'),
+  param('hostOrHandle')
+    .custom(value => isHostValid(value) || isRemoteHandleValid(value))
+    .withMessage('Should have a valid host/handle'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     logger.debug('Checking unfollowing parameters', { parameters: req.params })
@@ -60,12 +79,14 @@ const removeFollowingValidator = [
     if (areValidationErrors(req, res)) return
 
     const serverActor = await getServerActor()
-    const follow = await ActorFollowModel.loadByActorAndTargetNameAndHostForAPI(serverActor.id, SERVER_ACTOR_NAME, req.params.host)
+
+    const { name, host } = getRemoteNameAndHost(req.params.hostOrHandle)
+    const follow = await ActorFollowModel.loadByActorAndTargetNameAndHostForAPI(serverActor.id, name, host)
 
     if (!follow) {
       return res.fail({
         status: HttpStatusCode.NOT_FOUND_404,
-        message: `Following ${req.params.host} not found.`
+        message: `Follow ${req.params.hostOrHandle} not found.`
       })
     }
 
diff --git a/server/middlewares/validators/oembed.ts b/server/middlewares/validators/oembed.ts
index 0a82e6932..e5fc0c277 100644
--- a/server/middlewares/validators/oembed.ts
+++ b/server/middlewares/validators/oembed.ts
@@ -4,7 +4,7 @@ import { join } from 'path'
 import { loadVideo } from '@server/lib/model-loaders'
 import { VideoPlaylistModel } from '@server/models/video/video-playlist'
 import { VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { isTestInstance } from '../../helpers/core-utils'
 import { isIdOrUUIDValid, toCompleteUUID } from '../../helpers/custom-validators/misc'
 import { logger } from '../../helpers/logger'
diff --git a/server/middlewares/validators/plugins.ts b/server/middlewares/validators/plugins.ts
index 8c76d2e36..3fb2176b9 100644
--- a/server/middlewares/validators/plugins.ts
+++ b/server/middlewares/validators/plugins.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { body, param, query, ValidationChain } from 'express-validator'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { PluginType } from '../../../shared/models/plugins/plugin.type'
 import { InstallOrUpdatePlugin } from '../../../shared/models/plugins/server/api/install-plugin.model'
 import { exists, isBooleanValid, isSafePath, toBooleanOrNull, toIntOrNull } from '../../helpers/custom-validators/misc'
diff --git a/server/middlewares/validators/redundancy.ts b/server/middlewares/validators/redundancy.ts
index 116c8c611..f1b2ff5cd 100644
--- a/server/middlewares/validators/redundancy.ts
+++ b/server/middlewares/validators/redundancy.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { body, param, query } from 'express-validator'
 import { isVideoRedundancyTarget } from '@server/helpers/custom-validators/video-redundancies'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import {
   exists,
   isBooleanValid,
diff --git a/server/middlewares/validators/search.ts b/server/middlewares/validators/search.ts
index 7bbf81048..27d0e541d 100644
--- a/server/middlewares/validators/search.ts
+++ b/server/middlewares/validators/search.ts
@@ -1,13 +1,18 @@
 import * as express from 'express'
 import { query } from 'express-validator'
 import { isSearchTargetValid } from '@server/helpers/custom-validators/search'
-import { isDateValid } from '../../helpers/custom-validators/misc'
+import { isHostValid } from '@server/helpers/custom-validators/servers'
+import { areUUIDsValid, isDateValid, isNotEmptyStringArray, toCompleteUUIDs } from '../../helpers/custom-validators/misc'
 import { logger } from '../../helpers/logger'
 import { areValidationErrors } from './shared'
 
 const videosSearchValidator = [
   query('search').optional().not().isEmpty().withMessage('Should have a valid search'),
 
+  query('host')
+    .optional()
+    .custom(isHostValid).withMessage('Should have a valid host'),
+
   query('startDate')
     .optional()
     .custom(isDateValid).withMessage('Should have a start date that conforms to ISO 8601'),
@@ -22,8 +27,18 @@ const videosSearchValidator = [
     .optional()
     .custom(isDateValid).withMessage('Should have a published end date that conforms to ISO 8601'),
 
-  query('durationMin').optional().isInt().withMessage('Should have a valid min duration'),
-  query('durationMax').optional().isInt().withMessage('Should have a valid max duration'),
+  query('durationMin')
+    .optional()
+    .isInt().withMessage('Should have a valid min duration'),
+  query('durationMax')
+    .optional()
+    .isInt().withMessage('Should have a valid max duration'),
+
+  query('uuids')
+    .optional()
+    .toArray()
+    .customSanitizer(toCompleteUUIDs)
+    .custom(areUUIDsValid).withMessage('Should have valid uuids'),
 
   query('searchTarget').optional().custom(isSearchTargetValid).withMessage('Should have a valid search target'),
 
@@ -37,8 +52,22 @@ const videosSearchValidator = [
 ]
 
 const videoChannelsListSearchValidator = [
-  query('search').not().isEmpty().withMessage('Should have a valid search'),
-  query('searchTarget').optional().custom(isSearchTargetValid).withMessage('Should have a valid search target'),
+  query('search')
+    .optional()
+    .not().isEmpty().withMessage('Should have a valid search'),
+
+  query('host')
+    .optional()
+    .custom(isHostValid).withMessage('Should have a valid host'),
+
+  query('searchTarget')
+    .optional()
+    .custom(isSearchTargetValid).withMessage('Should have a valid search target'),
+
+  query('handles')
+    .optional()
+    .toArray()
+    .custom(isNotEmptyStringArray).withMessage('Should have valid handles'),
 
   (req: express.Request, res: express.Response, next: express.NextFunction) => {
     logger.debug('Checking video channels search query', { parameters: req.query })
@@ -50,8 +79,23 @@ const videoChannelsListSearchValidator = [
 ]
 
 const videoPlaylistsListSearchValidator = [
-  query('search').not().isEmpty().withMessage('Should have a valid search'),
-  query('searchTarget').optional().custom(isSearchTargetValid).withMessage('Should have a valid search target'),
+  query('search')
+    .optional()
+    .not().isEmpty().withMessage('Should have a valid search'),
+
+  query('host')
+    .optional()
+    .custom(isHostValid).withMessage('Should have a valid host'),
+
+  query('searchTarget')
+    .optional()
+    .custom(isSearchTargetValid).withMessage('Should have a valid search target'),
+
+  query('uuids')
+    .optional()
+    .toArray()
+    .customSanitizer(toCompleteUUIDs)
+    .custom(areUUIDsValid).withMessage('Should have valid uuids'),
 
   (req: express.Request, res: express.Response, next: express.NextFunction) => {
     logger.debug('Checking video playlists search query', { parameters: req.query })
diff --git a/server/middlewares/validators/server.ts b/server/middlewares/validators/server.ts
index fc7239b25..29fdc13d2 100644
--- a/server/middlewares/validators/server.ts
+++ b/server/middlewares/validators/server.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { body } from 'express-validator'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { isHostValid, isValidContactBody } from '../../helpers/custom-validators/servers'
 import { isUserDisplayNameValid } from '../../helpers/custom-validators/users'
 import { logger } from '../../helpers/logger'
diff --git a/server/middlewares/validators/shared/abuses.ts b/server/middlewares/validators/shared/abuses.ts
index 4a20a55fa..2b8d86ba5 100644
--- a/server/middlewares/validators/shared/abuses.ts
+++ b/server/middlewares/validators/shared/abuses.ts
@@ -1,6 +1,6 @@
 import { Response } from 'express'
 import { AbuseModel } from '@server/models/abuse/abuse'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 
 async function doesAbuseExist (abuseId: number | string, res: Response) {
   const abuse = await AbuseModel.loadByIdWithReporter(parseInt(abuseId + '', 10))
diff --git a/server/middlewares/validators/shared/accounts.ts b/server/middlewares/validators/shared/accounts.ts
index 04da15441..fe4f83aa0 100644
--- a/server/middlewares/validators/shared/accounts.ts
+++ b/server/middlewares/validators/shared/accounts.ts
@@ -2,7 +2,7 @@ import { Response } from 'express'
 import { AccountModel } from '@server/models/account/account'
 import { UserModel } from '@server/models/user/user'
 import { MAccountDefault } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 
 function doesAccountIdExist (id: number | string, res: Response, sendNotFound = true) {
   const promise = AccountModel.load(parseInt(id + '', 10))
diff --git a/server/middlewares/validators/shared/video-blacklists.ts b/server/middlewares/validators/shared/video-blacklists.ts
index 01491c10f..f85b39b23 100644
--- a/server/middlewares/validators/shared/video-blacklists.ts
+++ b/server/middlewares/validators/shared/video-blacklists.ts
@@ -1,6 +1,6 @@
 import { Response } from 'express'
 import { VideoBlacklistModel } from '@server/models/video/video-blacklist'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 
 async function doesVideoBlacklistExist (videoId: number, res: Response) {
   const videoBlacklist = await VideoBlacklistModel.loadByVideoId(videoId)
diff --git a/server/middlewares/validators/shared/video-captions.ts b/server/middlewares/validators/shared/video-captions.ts
index 80f6c5a52..831b366ea 100644
--- a/server/middlewares/validators/shared/video-captions.ts
+++ b/server/middlewares/validators/shared/video-captions.ts
@@ -1,7 +1,7 @@
 import { Response } from 'express'
 import { VideoCaptionModel } from '@server/models/video/video-caption'
 import { MVideoId } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 
 async function doesVideoCaptionExist (video: MVideoId, language: string, res: Response) {
   const videoCaption = await VideoCaptionModel.loadByVideoIdAndLanguage(video.id, language)
diff --git a/server/middlewares/validators/shared/video-channels.ts b/server/middlewares/validators/shared/video-channels.ts
index fe2e663b7..3fc3d012a 100644
--- a/server/middlewares/validators/shared/video-channels.ts
+++ b/server/middlewares/validators/shared/video-channels.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { VideoChannelModel } from '@server/models/video/video-channel'
 import { MChannelBannerAccountDefault } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 
 async function doesLocalVideoChannelNameExist (name: string, res: express.Response) {
   const videoChannel = await VideoChannelModel.loadLocalByNameAndPopulateAccount(name)
diff --git a/server/middlewares/validators/shared/video-comments.ts b/server/middlewares/validators/shared/video-comments.ts
index 83ea15c98..60132fb6e 100644
--- a/server/middlewares/validators/shared/video-comments.ts
+++ b/server/middlewares/validators/shared/video-comments.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { VideoCommentModel } from '@server/models/video/video-comment'
 import { MVideoId } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 
 async function doesVideoCommentThreadExist (idArg: number | string, video: MVideoId, res: express.Response) {
   const id = parseInt(idArg + '', 10)
diff --git a/server/middlewares/validators/shared/video-imports.ts b/server/middlewares/validators/shared/video-imports.ts
index 0f984bc17..50b49ffcb 100644
--- a/server/middlewares/validators/shared/video-imports.ts
+++ b/server/middlewares/validators/shared/video-imports.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { VideoImportModel } from '@server/models/video/video-import'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 
 async function doesVideoImportExist (id: number, res: express.Response) {
   const videoImport = await VideoImportModel.loadAndPopulateVideo(id)
diff --git a/server/middlewares/validators/shared/video-ownerships.ts b/server/middlewares/validators/shared/video-ownerships.ts
index fc27006ce..93a23ef40 100644
--- a/server/middlewares/validators/shared/video-ownerships.ts
+++ b/server/middlewares/validators/shared/video-ownerships.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { VideoChangeOwnershipModel } from '@server/models/video/video-change-ownership'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 
 async function doesChangeVideoOwnershipExist (idArg: number | string, res: express.Response) {
   const id = parseInt(idArg + '', 10)
diff --git a/server/middlewares/validators/shared/video-playlists.ts b/server/middlewares/validators/shared/video-playlists.ts
index d762859a8..3f6768179 100644
--- a/server/middlewares/validators/shared/video-playlists.ts
+++ b/server/middlewares/validators/shared/video-playlists.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { VideoPlaylistModel } from '@server/models/video/video-playlist'
 import { MVideoPlaylist } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
 
 export type VideoPlaylistFetchType = 'summary' | 'all'
 async function doesVideoPlaylistExist (id: number | string, res: express.Response, fetchType: VideoPlaylistFetchType = 'summary') {
diff --git a/server/middlewares/validators/shared/videos.ts b/server/middlewares/validators/shared/videos.ts
index 2c66c1a3a..71b81654f 100644
--- a/server/middlewares/validators/shared/videos.ts
+++ b/server/middlewares/validators/shared/videos.ts
@@ -12,8 +12,7 @@ import {
   MVideoImmutable,
   MVideoThumbnail
 } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
-import { UserRight } from '@shared/models'
+import { HttpStatusCode, UserRight } from '@shared/models'
 
 async function doesVideoExist (id: number | string, res: Response, fetchType: VideoLoadType = 'all') {
   const userId = res.locals.oauth ? res.locals.oauth.token.User.id : undefined
diff --git a/server/middlewares/validators/themes.ts b/server/middlewares/validators/themes.ts
index d4716257f..2953b9505 100644
--- a/server/middlewares/validators/themes.ts
+++ b/server/middlewares/validators/themes.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { param } from 'express-validator'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { isSafePath } from '../../helpers/custom-validators/misc'
 import { isPluginNameValid, isPluginVersionValid } from '../../helpers/custom-validators/plugins'
 import { logger } from '../../helpers/logger'
diff --git a/server/middlewares/validators/user-subscriptions.ts b/server/middlewares/validators/user-subscriptions.ts
index ab7962923..df5777771 100644
--- a/server/middlewares/validators/user-subscriptions.ts
+++ b/server/middlewares/validators/user-subscriptions.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { body, param, query } from 'express-validator'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { areValidActorHandles, isValidActorHandle } from '../../helpers/custom-validators/activitypub/actor'
 import { toArray } from '../../helpers/custom-validators/misc'
 import { logger } from '../../helpers/logger'
diff --git a/server/middlewares/validators/users.ts b/server/middlewares/validators/users.ts
index 698d7d814..bc8607523 100644
--- a/server/middlewares/validators/users.ts
+++ b/server/middlewares/validators/users.ts
@@ -3,10 +3,9 @@ import { body, param, query } from 'express-validator'
 import { omit } from 'lodash'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { MUserDefault } from '@server/types/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { UserRole } from '../../../shared/models/users'
 import { UserRegister } from '../../../shared/models/users/user-register.model'
-import { isActorPreferredUsernameValid } from '../../helpers/custom-validators/activitypub/actor'
 import { toBooleanOrNull, toIntOrNull } from '../../helpers/custom-validators/misc'
 import { isThemeNameValid } from '../../helpers/custom-validators/plugins'
 import {
@@ -28,7 +27,7 @@ import {
   isUserVideoQuotaValid,
   isUserVideosHistoryEnabledValid
 } from '../../helpers/custom-validators/users'
-import { isVideoChannelNameValid } from '../../helpers/custom-validators/video-channels'
+import { isVideoChannelDisplayNameValid, isVideoChannelUsernameValid } from '../../helpers/custom-validators/video-channels'
 import { logger } from '../../helpers/logger'
 import { isThemeRegistered } from '../../lib/plugins/theme-utils'
 import { Redis } from '../../lib/redis'
@@ -56,9 +55,12 @@ const usersAddValidator = [
   body('username').custom(isUserUsernameValid).withMessage('Should have a valid username (lowercase alphanumeric characters)'),
   body('password').custom(isUserPasswordValidOrEmpty).withMessage('Should have a valid password'),
   body('email').isEmail().withMessage('Should have a valid email'),
-  body('channelName').optional().custom(isActorPreferredUsernameValid).withMessage('Should have a valid channel name'),
+
+  body('channelName').optional().custom(isVideoChannelUsernameValid).withMessage('Should have a valid channel name'),
+
   body('videoQuota').custom(isUserVideoQuotaValid).withMessage('Should have a valid user quota'),
   body('videoQuotaDaily').custom(isUserVideoQuotaDailyValid).withMessage('Should have a valid daily user quota'),
+
   body('role')
     .customSanitizer(toIntOrNull)
     .custom(isUserRoleValid).withMessage('Should have a valid role'),
@@ -106,10 +108,10 @@ const usersRegisterValidator = [
 
   body('channel.name')
     .optional()
-    .custom(isActorPreferredUsernameValid).withMessage('Should have a valid channel name'),
+    .custom(isVideoChannelUsernameValid).withMessage('Should have a valid channel name'),
   body('channel.displayName')
     .optional()
-    .custom(isVideoChannelNameValid).withMessage('Should have a valid display name'),
+    .custom(isVideoChannelDisplayNameValid).withMessage('Should have a valid display name'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     logger.debug('Checking usersRegister parameters', { parameters: omit(req.body, 'password') })
diff --git a/server/middlewares/validators/videos/video-blacklist.ts b/server/middlewares/validators/videos/video-blacklist.ts
index 21141d84d..3a4937b7b 100644
--- a/server/middlewares/validators/videos/video-blacklist.ts
+++ b/server/middlewares/validators/videos/video-blacklist.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { body, query } from 'express-validator'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { isBooleanValid, toBooleanOrNull, toIntOrNull } from '../../../helpers/custom-validators/misc'
 import { isVideoBlacklistReasonValid, isVideoBlacklistTypeValid } from '../../../helpers/custom-validators/video-blacklist'
 import { logger } from '../../../helpers/logger'
diff --git a/server/middlewares/validators/videos/video-channels.ts b/server/middlewares/validators/videos/video-channels.ts
index e7df185e4..3b5693d23 100644
--- a/server/middlewares/validators/videos/video-channels.ts
+++ b/server/middlewares/validators/videos/video-channels.ts
@@ -3,13 +3,13 @@ import { body, param, query } from 'express-validator'
 import { VIDEO_CHANNELS } from '@server/initializers/constants'
 import { MChannelAccountDefault, MUser } from '@server/types/models'
 import { UserRight } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-import { isActorPreferredUsernameValid } from '../../../helpers/custom-validators/activitypub/actor'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { isBooleanValid, toBooleanOrNull } from '../../../helpers/custom-validators/misc'
 import {
   isVideoChannelDescriptionValid,
-  isVideoChannelNameValid,
-  isVideoChannelSupportValid
+  isVideoChannelDisplayNameValid,
+  isVideoChannelSupportValid,
+  isVideoChannelUsernameValid
 } from '../../../helpers/custom-validators/video-channels'
 import { logger } from '../../../helpers/logger'
 import { ActorModel } from '../../../models/actor/actor'
@@ -17,8 +17,8 @@ import { VideoChannelModel } from '../../../models/video/video-channel'
 import { areValidationErrors, doesLocalVideoChannelNameExist, doesVideoChannelNameWithHostExist } from '../shared'
 
 const videoChannelsAddValidator = [
-  body('name').custom(isActorPreferredUsernameValid).withMessage('Should have a valid channel name'),
-  body('displayName').custom(isVideoChannelNameValid).withMessage('Should have a valid display name'),
+  body('name').custom(isVideoChannelUsernameValid).withMessage('Should have a valid channel name'),
+  body('displayName').custom(isVideoChannelDisplayNameValid).withMessage('Should have a valid display name'),
   body('description').optional().custom(isVideoChannelDescriptionValid).withMessage('Should have a valid description'),
   body('support').optional().custom(isVideoChannelSupportValid).withMessage('Should have a valid support text'),
 
@@ -50,7 +50,7 @@ const videoChannelsUpdateValidator = [
   param('nameWithHost').exists().withMessage('Should have an video channel name with host'),
   body('displayName')
     .optional()
-    .custom(isVideoChannelNameValid).withMessage('Should have a valid display name'),
+    .custom(isVideoChannelDisplayNameValid).withMessage('Should have a valid display name'),
   body('description')
     .optional()
     .custom(isVideoChannelDescriptionValid).withMessage('Should have a valid description'),
@@ -117,7 +117,7 @@ const videoChannelsNameWithHostValidator = [
 ]
 
 const localVideoChannelValidator = [
-  param('name').custom(isVideoChannelNameValid).withMessage('Should have a valid video channel name'),
+  param('name').custom(isVideoChannelDisplayNameValid).withMessage('Should have a valid video channel name'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     logger.debug('Checking localVideoChannelValidator parameters', { parameters: req.params })
diff --git a/server/middlewares/validators/videos/video-comments.ts b/server/middlewares/validators/videos/video-comments.ts
index 885506ebe..61c2ed92f 100644
--- a/server/middlewares/validators/videos/video-comments.ts
+++ b/server/middlewares/validators/videos/video-comments.ts
@@ -2,7 +2,7 @@ import * as express from 'express'
 import { body, param, query } from 'express-validator'
 import { MUserAccountUrl } from '@server/types/models'
 import { UserRight } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { exists, isBooleanValid, isIdValid, toBooleanOrNull } from '../../../helpers/custom-validators/misc'
 import { isValidVideoCommentText } from '../../../helpers/custom-validators/video-comments'
 import { logger } from '../../../helpers/logger'
diff --git a/server/middlewares/validators/videos/video-imports.ts b/server/middlewares/validators/videos/video-imports.ts
index 85dc647ce..52b839e56 100644
--- a/server/middlewares/validators/videos/video-imports.ts
+++ b/server/middlewares/validators/videos/video-imports.ts
@@ -2,7 +2,7 @@ import * as express from 'express'
 import { body } from 'express-validator'
 import { isPreImportVideoAccepted } from '@server/lib/moderation'
 import { Hooks } from '@server/lib/plugins/hooks'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '@shared/models'
 import { VideoImportCreate } from '@shared/models/videos/import/video-import-create.model'
 import { isIdValid, toIntOrNull } from '../../../helpers/custom-validators/misc'
 import { isVideoImportTargetUrlValid, isVideoImportTorrentFile } from '../../../helpers/custom-validators/video-imports'
diff --git a/server/middlewares/validators/videos/video-live.ts b/server/middlewares/validators/videos/video-live.ts
index 7cfb935e3..97e8b4510 100644
--- a/server/middlewares/validators/videos/video-live.ts
+++ b/server/middlewares/validators/videos/video-live.ts
@@ -5,8 +5,7 @@ import { isLocalLiveVideoAccepted } from '@server/lib/moderation'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { VideoModel } from '@server/models/video/video'
 import { VideoLiveModel } from '@server/models/video/video-live'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
-import { ServerErrorCode, UserRight, VideoState } from '@shared/models'
+import { HttpStatusCode, ServerErrorCode, UserRight, VideoState } from '@shared/models'
 import { isBooleanValid, isIdValid, toBooleanOrNull, toIntOrNull } from '../../../helpers/custom-validators/misc'
 import { isVideoNameValid } from '../../../helpers/custom-validators/videos'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
diff --git a/server/middlewares/validators/videos/video-ownership-changes.ts b/server/middlewares/validators/videos/video-ownership-changes.ts
index 54ac46c99..a7f0b72c3 100644
--- a/server/middlewares/validators/videos/video-ownership-changes.ts
+++ b/server/middlewares/validators/videos/video-ownership-changes.ts
@@ -6,8 +6,14 @@ import { logger } from '@server/helpers/logger'
 import { isAbleToUploadVideo } from '@server/lib/user'
 import { AccountModel } from '@server/models/account/account'
 import { MVideoWithAllFiles } from '@server/types/models'
-import { HttpStatusCode } from '@shared/core-utils'
-import { ServerErrorCode, UserRight, VideoChangeOwnershipAccept, VideoChangeOwnershipStatus, VideoState } from '@shared/models'
+import {
+  HttpStatusCode,
+  ServerErrorCode,
+  UserRight,
+  VideoChangeOwnershipAccept,
+  VideoChangeOwnershipStatus,
+  VideoState
+} from '@shared/models'
 import {
   areValidationErrors,
   checkUserCanManageVideo,
diff --git a/server/middlewares/validators/videos/video-playlists.ts b/server/middlewares/validators/videos/video-playlists.ts
index 5ee7ee0ce..ab84b4814 100644
--- a/server/middlewares/validators/videos/video-playlists.ts
+++ b/server/middlewares/validators/videos/video-playlists.ts
@@ -3,7 +3,7 @@ import { body, param, query, ValidationChain } from 'express-validator'
 import { ExpressPromiseHandler } from '@server/types/express'
 import { MUserAccountId } from '@server/types/models'
 import { UserRight, VideoPlaylistCreate, VideoPlaylistUpdate } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
 import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
 import {
diff --git a/server/middlewares/validators/videos/video-rates.ts b/server/middlewares/validators/videos/video-rates.ts
index 5d5dfb222..5fe78b39e 100644
--- a/server/middlewares/validators/videos/video-rates.ts
+++ b/server/middlewares/validators/videos/video-rates.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { body, param, query } from 'express-validator'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { VideoRateType } from '../../../../shared/models/videos'
 import { isAccountNameValid } from '../../../helpers/custom-validators/accounts'
 import { isIdValid } from '../../../helpers/custom-validators/misc'
diff --git a/server/middlewares/validators/videos/video-shares.ts b/server/middlewares/validators/videos/video-shares.ts
index 7e54b6fc0..3b8d61768 100644
--- a/server/middlewares/validators/videos/video-shares.ts
+++ b/server/middlewares/validators/videos/video-shares.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { param } from 'express-validator'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { isIdValid } from '../../../helpers/custom-validators/misc'
 import { logger } from '../../../helpers/logger'
 import { VideoShareModel } from '../../../models/video/video-share'
diff --git a/server/middlewares/validators/videos/video-watch.ts b/server/middlewares/validators/videos/video-watch.ts
index 43306f7cd..431515eb1 100644
--- a/server/middlewares/validators/videos/video-watch.ts
+++ b/server/middlewares/validators/videos/video-watch.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { body } from 'express-validator'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { toIntOrNull } from '../../../helpers/custom-validators/misc'
 import { logger } from '../../../helpers/logger'
 import { areValidationErrors, doesVideoExist, isValidVideoIdParam } from '../shared'
diff --git a/server/middlewares/validators/videos/videos.ts b/server/middlewares/validators/videos/videos.ts
index 49e10e2b5..13187f398 100644
--- a/server/middlewares/validators/videos/videos.ts
+++ b/server/middlewares/validators/videos/videos.ts
@@ -6,7 +6,7 @@ import { getServerActor } from '@server/models/application/application'
 import { ExpressPromiseHandler } from '@server/types/express'
 import { MUserAccountId, MVideoFullLight } from '@server/types/models'
 import { ServerErrorCode, UserRight, VideoPrivacy } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import {
   exists,
   isBooleanValid,
@@ -188,7 +188,7 @@ const videosAddResumableInitValidator = getCommonVideoEditAttributes().concat([
     // multer required unsetting the Content-Type, now we can set it for node-uploadx
     req.headers['content-type'] = 'application/json; charset=utf-8'
     // place previewfile in metadata so that uploadx saves it in .META
-    if (req.files['previewfile']) req.body.previewfile = req.files['previewfile']
+    if (req.files?.['previewfile']) req.body.previewfile = req.files['previewfile']
 
     return next()
   }
diff --git a/server/middlewares/validators/webfinger.ts b/server/middlewares/validators/webfinger.ts
index bcdd136c6..131360820 100644
--- a/server/middlewares/validators/webfinger.ts
+++ b/server/middlewares/validators/webfinger.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { query } from 'express-validator'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '../../../shared/models/http/http-error-codes'
 import { isWebfingerLocalResourceValid } from '../../helpers/custom-validators/webfinger'
 import { getHostWithPort } from '../../helpers/express-utils'
 import { logger } from '../../helpers/logger'
diff --git a/server/models/account/account.ts b/server/models/account/account.ts
index 665ecd595..37194a119 100644
--- a/server/models/account/account.ts
+++ b/server/models/account/account.ts
@@ -52,6 +52,7 @@ export enum ScopeNames {
 export type SummaryOptions = {
   actorRequired?: boolean // Default: true
   whereActor?: WhereOptions
+  whereServer?: WhereOptions
   withAccountBlockerIds?: number[]
 }
 
@@ -65,12 +66,11 @@ export type SummaryOptions = {
 }))
 @Scopes(() => ({
   [ScopeNames.SUMMARY]: (options: SummaryOptions = {}) => {
-    const whereActor = options.whereActor || undefined
-
     const serverInclude: IncludeOptions = {
       attributes: [ 'host' ],
       model: ServerModel.unscoped(),
-      required: false
+      required: !!options.whereServer,
+      where: options.whereServer
     }
 
     const queryInclude: Includeable[] = [
@@ -78,7 +78,7 @@ export type SummaryOptions = {
         attributes: [ 'id', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
         model: ActorModel.unscoped(),
         required: options.actorRequired ?? true,
-        where: whereActor,
+        where: options.whereActor,
         include: [
           serverInclude,
 
diff --git a/server/models/actor/actor-follow.ts b/server/models/actor/actor-follow.ts
index 3a09e51d6..283856d3f 100644
--- a/server/models/actor/actor-follow.ts
+++ b/server/models/actor/actor-follow.ts
@@ -20,7 +20,6 @@ import {
 } from 'sequelize-typescript'
 import { isActivityPubUrlValid } from '@server/helpers/custom-validators/activitypub/misc'
 import { getServerActor } from '@server/models/application/application'
-import { VideoModel } from '@server/models/video/video'
 import {
   MActorFollowActorsDefault,
   MActorFollowActorsDefaultSubscription,
@@ -36,6 +35,7 @@ import { logger } from '../../helpers/logger'
 import { ACTOR_FOLLOW_SCORE, CONSTRAINTS_FIELDS, FOLLOW_STATES, SERVER_ACTOR_NAME } from '../../initializers/constants'
 import { AccountModel } from '../account/account'
 import { ServerModel } from '../server/server'
+import { doesExist } from '../shared/query'
 import { createSafeIn, getFollowsSort, getSort, searchAttribute, throwIfNotValid } from '../utils'
 import { VideoChannelModel } from '../video/video-channel'
 import { ActorModel, unusedActorAttributesForAPI } from './actor'
@@ -166,14 +166,8 @@ export class ActorFollowModel extends Model<Partial<AttributesOnly<ActorFollowMo
 
   static isFollowedBy (actorId: number, followerActorId: number) {
     const query = 'SELECT 1 FROM "actorFollow" WHERE "actorId" = $followerActorId AND "targetActorId" = $actorId LIMIT 1'
-    const options = {
-      type: QueryTypes.SELECT as QueryTypes.SELECT,
-      bind: { actorId, followerActorId },
-      raw: true
-    }
 
-    return VideoModel.sequelize.query(query, options)
-                     .then(results => results.length === 1)
+    return doesExist(query, { actorId, followerActorId })
   }
 
   static loadByActorAndTarget (actorId: number, targetActorId: number, t?: Transaction): Promise<MActorFollowActorsDefault> {
@@ -324,13 +318,13 @@ export class ActorFollowModel extends Model<Partial<AttributesOnly<ActorFollowMo
 
     const followWhere = state ? { state } : {}
     const followingWhere: WhereOptions = {}
-    const followingServerWhere: WhereOptions = {}
 
     if (search) {
-      Object.assign(followingServerWhere, {
-        host: {
-          [Op.iLike]: '%' + search + '%'
-        }
+      Object.assign(followWhere, {
+        [Op.or]: [
+          searchAttribute(options.search, '$ActorFollowing.preferredUsername$'),
+          searchAttribute(options.search, '$ActorFollowing.Server.host$')
+        ]
       })
     }
 
@@ -361,8 +355,7 @@ export class ActorFollowModel extends Model<Partial<AttributesOnly<ActorFollowMo
           include: [
             {
               model: ServerModel,
-              required: true,
-              where: followingServerWhere
+              required: true
             }
           ]
         }
@@ -391,13 +384,13 @@ export class ActorFollowModel extends Model<Partial<AttributesOnly<ActorFollowMo
 
     const followWhere = state ? { state } : {}
     const followerWhere: WhereOptions = {}
-    const followerServerWhere: WhereOptions = {}
 
     if (search) {
-      Object.assign(followerServerWhere, {
-        host: {
-          [Op.iLike]: '%' + search + '%'
-        }
+      Object.assign(followWhere, {
+        [Op.or]: [
+          searchAttribute(search, '$ActorFollower.preferredUsername$'),
+          searchAttribute(search, '$ActorFollower.Server.host$')
+        ]
       })
     }
 
@@ -420,8 +413,7 @@ export class ActorFollowModel extends Model<Partial<AttributesOnly<ActorFollowMo
           include: [
             {
               model: ServerModel,
-              required: true,
-              where: followerServerWhere
+              required: true
             }
           ]
         },
diff --git a/server/models/redundancy/video-redundancy.ts b/server/models/redundancy/video-redundancy.ts
index ccda023e0..d645be248 100644
--- a/server/models/redundancy/video-redundancy.ts
+++ b/server/models/redundancy/video-redundancy.ts
@@ -160,8 +160,8 @@ export class VideoRedundancyModel extends Model<Partial<AttributesOnly<VideoRedu
       const logIdentifier = `${videoFile.Video.uuid}-${videoFile.resolution}`
       logger.info('Removing duplicated video file %s.', logIdentifier)
 
-      videoFile.Video.removeFile(videoFile, true)
-               .catch(err => logger.error('Cannot delete %s files.', logIdentifier, { err }))
+      videoFile.Video.removeFileAndTorrent(videoFile, true)
+        .catch(err => logger.error('Cannot delete %s files.', logIdentifier, { err }))
     }
 
     if (instance.videoStreamingPlaylistId) {
diff --git a/server/models/shared/index.ts b/server/models/shared/index.ts
new file mode 100644
index 000000000..5b97510e0
--- /dev/null
+++ b/server/models/shared/index.ts
@@ -0,0 +1,2 @@
+export * from './query'
+export * from './update'
diff --git a/server/models/shared/query.ts b/server/models/shared/query.ts
new file mode 100644
index 000000000..036cc13c6
--- /dev/null
+++ b/server/models/shared/query.ts
@@ -0,0 +1,17 @@
+import { BindOrReplacements, QueryTypes } from 'sequelize'
+import { sequelizeTypescript } from '@server/initializers/database'
+
+function doesExist (query: string, bind?: BindOrReplacements) {
+  const options = {
+    type: QueryTypes.SELECT as QueryTypes.SELECT,
+    bind,
+    raw: true
+  }
+
+  return sequelizeTypescript.query(query, options)
+            .then(results => results.length === 1)
+}
+
+export {
+  doesExist
+}
diff --git a/server/models/shared/update.ts b/server/models/shared/update.ts
new file mode 100644
index 000000000..d338211e3
--- /dev/null
+++ b/server/models/shared/update.ts
@@ -0,0 +1,18 @@
+import { QueryTypes, Transaction } from 'sequelize'
+import { sequelizeTypescript } from '@server/initializers/database'
+
+// Sequelize always skip the update if we only update updatedAt field
+function setAsUpdated (table: string, id: number, transaction?: Transaction) {
+  return sequelizeTypescript.query(
+    `UPDATE "${table}" SET "updatedAt" = :updatedAt WHERE id = :id`,
+    {
+      replacements: { table, id, updatedAt: new Date() },
+      type: QueryTypes.UPDATE,
+      transaction
+    }
+  )
+}
+
+export {
+  setAsUpdated
+}
diff --git a/server/models/user/user-notification.ts b/server/models/user/user-notification.ts
index a7f84e9ca..04c5513a9 100644
--- a/server/models/user/user-notification.ts
+++ b/server/models/user/user-notification.ts
@@ -1,5 +1,6 @@
 import { FindOptions, ModelIndexesOptions, Op, WhereOptions } from 'sequelize'
 import { AllowNull, BelongsTo, Column, CreatedAt, Default, ForeignKey, Is, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
+import { uuidToShort } from '@server/helpers/uuid'
 import { UserNotificationIncludes, UserNotificationModelForApi } from '@server/types/models/user'
 import { AttributesOnly } from '@shared/core-utils'
 import { UserNotification, UserNotificationType } from '../../../shared'
@@ -615,6 +616,7 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
     return {
       id: video.id,
       uuid: video.uuid,
+      shortUUID: uuidToShort(video.uuid),
       name: video.name
     }
   }
@@ -628,6 +630,7 @@ export class UserNotificationModel extends Model<Partial<AttributesOnly<UserNoti
           ? {
             id: abuse.VideoCommentAbuse.VideoComment.Video.id,
             name: abuse.VideoCommentAbuse.VideoComment.Video.name,
+            shortUUID: uuidToShort(abuse.VideoCommentAbuse.VideoComment.Video.uuid),
             uuid: abuse.VideoCommentAbuse.VideoComment.Video.uuid
           }
           : undefined
diff --git a/server/models/video/formatter/video-format-utils.ts b/server/models/video/formatter/video-format-utils.ts
index ab4cf53a8..8a54de3b0 100644
--- a/server/models/video/formatter/video-format-utils.ts
+++ b/server/models/video/formatter/video-format-utils.ts
@@ -182,8 +182,8 @@ function streamingPlaylistsModelToFormattedJSON (
       return {
         id: playlist.id,
         type: playlist.type,
-        playlistUrl: playlist.playlistUrl,
-        segmentsSha256Url: playlist.segmentsSha256Url,
+        playlistUrl: playlist.getMasterPlaylistUrl(video),
+        segmentsSha256Url: playlist.getSha256SegmentsUrl(video),
         redundancies,
         files
       }
@@ -331,7 +331,7 @@ function videoModelToActivityPubObject (video: MVideoAP): VideoObject {
       type: 'Link',
       name: 'sha256',
       mediaType: 'application/json' as 'application/json',
-      href: playlist.segmentsSha256Url
+      href: playlist.getSha256SegmentsUrl(video)
     })
 
     addVideoFilesInAPAcc(tag, video, playlist.VideoFiles || [])
@@ -339,7 +339,7 @@ function videoModelToActivityPubObject (video: MVideoAP): VideoObject {
     url.push({
       type: 'Link',
       mediaType: 'application/x-mpegURL' as 'application/x-mpegURL',
-      href: playlist.playlistUrl,
+      href: playlist.getMasterPlaylistUrl(video),
       tag
     })
   }
diff --git a/server/models/video/sql/shared/video-tables.ts b/server/models/video/sql/shared/video-tables.ts
index abdd22188..742d19099 100644
--- a/server/models/video/sql/shared/video-tables.ts
+++ b/server/models/video/sql/shared/video-tables.ts
@@ -92,12 +92,13 @@ export class VideoTables {
   }
 
   getStreamingPlaylistAttributes () {
-    let playlistKeys = [ 'id', 'playlistUrl', 'type' ]
+    let playlistKeys = [ 'id', 'playlistUrl', 'playlistFilename', 'type' ]
 
     if (this.mode === 'get') {
       playlistKeys = playlistKeys.concat([
         'p2pMediaLoaderInfohashes',
         'p2pMediaLoaderPeerVersion',
+        'segmentsSha256Filename',
         'segmentsSha256Url',
         'videoId',
         'createdAt',
diff --git a/server/models/video/sql/videos-id-list-query-builder.ts b/server/models/video/sql/videos-id-list-query-builder.ts
index 30b251f0f..7625c003d 100644
--- a/server/models/video/sql/videos-id-list-query-builder.ts
+++ b/server/models/video/sql/videos-id-list-query-builder.ts
@@ -1,6 +1,7 @@
 import { Sequelize } from 'sequelize'
 import validator from 'validator'
 import { exists } from '@server/helpers/custom-validators/misc'
+import { WEBSERVER } from '@server/initializers/constants'
 import { buildDirectionAndField, createSafeIn } from '@server/models/utils'
 import { MUserAccountId, MUserId } from '@server/types/models'
 import { VideoFilter, VideoPrivacy, VideoState } from '@shared/models'
@@ -25,6 +26,7 @@ export type BuildVideosListQueryOptions = {
 
   nsfw?: boolean
   filter?: VideoFilter
+  host?: string
   isLive?: boolean
 
   categoryOneOf?: number[]
@@ -33,6 +35,8 @@ export type BuildVideosListQueryOptions = {
   tagsOneOf?: string[]
   tagsAllOf?: string[]
 
+  uuids?: string[]
+
   withFiles?: boolean
 
   accountId?: number
@@ -131,6 +135,10 @@ export class VideosIdListQueryBuilder extends AbstractVideosQueryBuilder {
       this.whereOnlyLocal()
     }
 
+    if (options.host) {
+      this.whereHost(options.host)
+    }
+
     if (options.accountId) {
       this.whereAccountId(options.accountId)
     }
@@ -155,6 +163,10 @@ export class VideosIdListQueryBuilder extends AbstractVideosQueryBuilder {
       this.whereTagsAllOf(options.tagsAllOf)
     }
 
+    if (options.uuids) {
+      this.whereUUIDs(options.uuids)
+    }
+
     if (options.nsfw === true) {
       this.whereNSFW()
     } else if (options.nsfw === false) {
@@ -291,6 +303,19 @@ export class VideosIdListQueryBuilder extends AbstractVideosQueryBuilder {
     this.and.push('"video"."remote" IS FALSE')
   }
 
+  private whereHost (host: string) {
+    // Local instance
+    if (host === WEBSERVER.HOST) {
+      this.and.push('"accountActor"."serverId" IS NULL')
+      return
+    }
+
+    this.joins.push('INNER JOIN "server" ON "server"."id" = "accountActor"."serverId"')
+
+    this.and.push('"server"."host" = :host')
+    this.replacements.host = host
+  }
+
   private whereAccountId (accountId: number) {
     this.and.push('"account"."id" = :accountId')
     this.replacements.accountId = accountId
@@ -304,16 +329,16 @@ export class VideosIdListQueryBuilder extends AbstractVideosQueryBuilder {
   private whereFollowerActorId (followerActorId: number, includeLocalVideos: boolean) {
     let query =
     '(' +
-    '  EXISTS (' +
+    '  EXISTS (' + // Videos shared by actors we follow
     '    SELECT 1 FROM "videoShare" ' +
     '    INNER JOIN "actorFollow" "actorFollowShare" ON "actorFollowShare"."targetActorId" = "videoShare"."actorId" ' +
     '    AND "actorFollowShare"."actorId" = :followerActorId AND "actorFollowShare"."state" = \'accepted\' ' +
     '    WHERE "videoShare"."videoId" = "video"."id"' +
     '  )' +
     '  OR' +
-    '  EXISTS (' +
+    '  EXISTS (' + // Videos published by accounts we follow
     '    SELECT 1 from "actorFollow" ' +
-    '    WHERE "actorFollow"."targetActorId" = "videoChannel"."actorId" AND "actorFollow"."actorId" = :followerActorId ' +
+    '    WHERE "actorFollow"."targetActorId" = "account"."actorId" AND "actorFollow"."actorId" = :followerActorId ' +
     '    AND "actorFollow"."state" = \'accepted\'' +
     '  )'
 
@@ -367,6 +392,10 @@ export class VideosIdListQueryBuilder extends AbstractVideosQueryBuilder {
     )
   }
 
+  private whereUUIDs (uuids: string[]) {
+    this.and.push('"video"."uuid" IN (' + createSafeIn(this.sequelize, uuids) + ')')
+  }
+
   private whereCategoryOneOf (categoryOneOf: number[]) {
     this.and.push('"video"."category" IN (:categoryOneOf)')
     this.replacements.categoryOneOf = categoryOneOf
diff --git a/server/models/video/video-channel.ts b/server/models/video/video-channel.ts
index 183e7448c..278149d60 100644
--- a/server/models/video/video-channel.ts
+++ b/server/models/video/video-channel.ts
@@ -1,4 +1,4 @@
-import { FindOptions, Includeable, literal, Op, QueryTypes, ScopeOptions, Transaction } from 'sequelize'
+import { FindOptions, Includeable, literal, Op, QueryTypes, ScopeOptions, Transaction, WhereOptions } from 'sequelize'
 import {
   AllowNull,
   BeforeDestroy,
@@ -17,14 +17,13 @@ import {
   Table,
   UpdatedAt
 } from 'sequelize-typescript'
-import { setAsUpdated } from '@server/helpers/database-utils'
 import { MAccountActor } from '@server/types/models'
-import { AttributesOnly } from '@shared/core-utils'
+import { AttributesOnly, pick } from '@shared/core-utils'
 import { ActivityPubActor } from '../../../shared/models/activitypub'
 import { VideoChannel, VideoChannelSummary } from '../../../shared/models/videos'
 import {
   isVideoChannelDescriptionValid,
-  isVideoChannelNameValid,
+  isVideoChannelDisplayNameValid,
   isVideoChannelSupportValid
 } from '../../helpers/custom-validators/video-channels'
 import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
@@ -41,6 +40,7 @@ import { ActorModel, unusedActorAttributesForAPI } from '../actor/actor'
 import { ActorFollowModel } from '../actor/actor-follow'
 import { ActorImageModel } from '../actor/actor-image'
 import { ServerModel } from '../server/server'
+import { setAsUpdated } from '../shared'
 import { buildServerIdsFollowedBy, buildTrigramSearchIndex, createSimilarityAttribute, getSort, throwIfNotValid } from '../utils'
 import { VideoModel } from './video'
 import { VideoPlaylistModel } from './video-playlist'
@@ -58,6 +58,8 @@ export enum ScopeNames {
 type AvailableForListOptions = {
   actorId: number
   search?: string
+  host?: string
+  handles?: string[]
 }
 
 type AvailableWithStatsOptions = {
@@ -83,7 +85,62 @@ export type SummaryOptions = {
     // Only list local channels OR channels that are on an instance followed by actorId
     const inQueryInstanceFollow = buildServerIdsFollowedBy(options.actorId)
 
+    const whereActorAnd: WhereOptions[] = [
+      {
+        [Op.or]: [
+          {
+            serverId: null
+          },
+          {
+            serverId: {
+              [Op.in]: Sequelize.literal(inQueryInstanceFollow)
+            }
+          }
+        ]
+      }
+    ]
+
+    let serverRequired = false
+    let whereServer: WhereOptions
+
+    if (options.host && options.host !== WEBSERVER.HOST) {
+      serverRequired = true
+      whereServer = { host: options.host }
+    }
+
+    if (options.host === WEBSERVER.HOST) {
+      whereActorAnd.push({
+        serverId: null
+      })
+    }
+
+    let rootWhere: WhereOptions
+    if (options.handles) {
+      const or: WhereOptions[] = []
+
+      for (const handle of options.handles || []) {
+        const [ preferredUsername, host ] = handle.split('@')
+
+        if (!host) {
+          or.push({
+            '$Actor.preferredUsername$': preferredUsername,
+            '$Actor.serverId$': null
+          })
+        } else {
+          or.push({
+            '$Actor.preferredUsername$': preferredUsername,
+            '$Actor.Server.host$': host
+          })
+        }
+      }
+
+      rootWhere = {
+        [Op.or]: or
+      }
+    }
+
     return {
+      where: rootWhere,
       include: [
         {
           attributes: {
@@ -91,19 +148,20 @@ export type SummaryOptions = {
           },
           model: ActorModel,
           where: {
-            [Op.or]: [
-              {
-                serverId: null
-              },
-              {
-                serverId: {
-                  [Op.in]: Sequelize.literal(inQueryInstanceFollow)
-                }
-              }
-            ]
+            [Op.and]: whereActorAnd
           },
           include: [
             {
+              model: ServerModel,
+              required: serverRequired,
+              where: whereServer
+            },
+            {
+              model: ActorImageModel,
+              as: 'Avatar',
+              required: false
+            },
+            {
               model: ActorImageModel,
               as: 'Banner',
               required: false
@@ -250,7 +308,7 @@ export type SummaryOptions = {
 export class VideoChannelModel extends Model<Partial<AttributesOnly<VideoChannelModel>>> {
 
   @AllowNull(false)
-  @Is('VideoChannelName', value => throwIfNotValid(value, isVideoChannelNameValid, 'name'))
+  @Is('VideoChannelName', value => throwIfNotValid(value, isVideoChannelDisplayNameValid, 'name'))
   @Column
   name: string
 
@@ -380,30 +438,6 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
     }
   }
 
-  static listForApi (parameters: {
-    actorId: number
-    start: number
-    count: number
-    sort: string
-  }) {
-    const { actorId } = parameters
-
-    const query = {
-      offset: parameters.start,
-      limit: parameters.count,
-      order: getSort(parameters.sort)
-    }
-
-    return VideoChannelModel
-      .scope({
-        method: [ ScopeNames.FOR_API, { actorId } as AvailableForListOptions ]
-      })
-      .findAndCountAll(query)
-      .then(({ rows, count }) => {
-        return { total: count, data: rows }
-      })
-  }
-
   static listLocalsForSitemap (sort: string): Promise<MChannelActor[]> {
     const query = {
       attributes: [ ],
@@ -425,26 +459,43 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
       .findAll(query)
   }
 
-  static searchForApi (options: {
-    actorId: number
-    search: string
+  static listForApi (parameters: Pick<AvailableForListOptions, 'actorId'> & {
     start: number
     count: number
     sort: string
   }) {
-    const attributesInclude = []
-    const escapedSearch = VideoChannelModel.sequelize.escape(options.search)
-    const escapedLikeSearch = VideoChannelModel.sequelize.escape('%' + options.search + '%')
-    attributesInclude.push(createSimilarityAttribute('VideoChannelModel.name', options.search))
+    const { actorId } = parameters
 
     const query = {
-      attributes: {
-        include: attributesInclude
-      },
-      offset: options.start,
-      limit: options.count,
-      order: getSort(options.sort),
-      where: {
+      offset: parameters.start,
+      limit: parameters.count,
+      order: getSort(parameters.sort)
+    }
+
+    return VideoChannelModel
+      .scope({
+        method: [ ScopeNames.FOR_API, { actorId } as AvailableForListOptions ]
+      })
+      .findAndCountAll(query)
+      .then(({ rows, count }) => {
+        return { total: count, data: rows }
+      })
+  }
+
+  static searchForApi (options: Pick<AvailableForListOptions, 'actorId' | 'search' | 'host' | 'handles'> & {
+    start: number
+    count: number
+    sort: string
+  }) {
+    let attributesInclude: any[] = [ literal('0 as similarity') ]
+    let where: WhereOptions
+
+    if (options.search) {
+      const escapedSearch = VideoChannelModel.sequelize.escape(options.search)
+      const escapedLikeSearch = VideoChannelModel.sequelize.escape('%' + options.search + '%')
+      attributesInclude = [ createSimilarityAttribute('VideoChannelModel.name', options.search) ]
+
+      where = {
         [Op.or]: [
           Sequelize.literal(
             'lower(immutable_unaccent("VideoChannelModel"."name")) % lower(immutable_unaccent(' + escapedSearch + '))'
@@ -456,9 +507,19 @@ ON              "Account->Actor"."serverId" = "Account->Actor->Server"."id"`
       }
     }
 
+    const query = {
+      attributes: {
+        include: attributesInclude
+      },
+      offset: options.start,
+      limit: options.count,
+      order: getSort(options.sort),
+      where
+    }
+
     return VideoChannelModel
       .scope({
-        method: [ ScopeNames.FOR_API, { actorId: options.actorId } as AvailableForListOptions ]
+        method: [ ScopeNames.FOR_API, pick(options, [ 'actorId', 'host', 'handles' ]) as AvailableForListOptions ]
       })
       .findAndCountAll(query)
       .then(({ rows, count }) => {
diff --git a/server/models/video/video-file.ts b/server/models/video/video-file.ts
index 22cf63804..09fc5288b 100644
--- a/server/models/video/video-file.ts
+++ b/server/models/video/video-file.ts
@@ -1,7 +1,7 @@
 import { remove } from 'fs-extra'
 import * as memoizee from 'memoizee'
 import { join } from 'path'
-import { FindOptions, Op, QueryTypes, Transaction } from 'sequelize'
+import { FindOptions, Op, Transaction } from 'sequelize'
 import {
   AllowNull,
   BelongsTo,
@@ -44,6 +44,7 @@ import {
 } from '../../initializers/constants'
 import { MVideoFile, MVideoFileStreamingPlaylistVideo, MVideoFileVideo } from '../../types/models/video/video-file'
 import { VideoRedundancyModel } from '../redundancy/video-redundancy'
+import { doesExist } from '../shared'
 import { parseAggregateResult, throwIfNotValid } from '../utils'
 import { VideoModel } from './video'
 import { VideoStreamingPlaylistModel } from './video-streaming-playlist'
@@ -250,14 +251,8 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
 
   static doesInfohashExist (infoHash: string) {
     const query = 'SELECT 1 FROM "videoFile" WHERE "infoHash" = $infoHash LIMIT 1'
-    const options = {
-      type: QueryTypes.SELECT as QueryTypes.SELECT,
-      bind: { infoHash },
-      raw: true
-    }
 
-    return VideoModel.sequelize.query(query, options)
-              .then(results => results.length === 1)
+    return doesExist(query, { infoHash })
   }
 
   static async doesVideoExistForVideoFile (id: number, videoIdOrUUID: number | string) {
@@ -266,6 +261,33 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
     return !!videoFile
   }
 
+  static async doesOwnedTorrentFileExist (filename: string) {
+    const query = 'SELECT 1 FROM "videoFile" ' +
+                  'LEFT JOIN "video" "webtorrent" ON "webtorrent"."id" = "videoFile"."videoId" AND "webtorrent"."remote" IS FALSE ' +
+                  'LEFT JOIN "videoStreamingPlaylist" ON "videoStreamingPlaylist"."id" = "videoFile"."videoStreamingPlaylistId" ' +
+                  'LEFT JOIN "video" "hlsVideo" ON "hlsVideo"."id" = "videoStreamingPlaylist"."videoId" AND "hlsVideo"."remote" IS FALSE ' +
+                  'WHERE "torrentFilename" = $filename AND ("hlsVideo"."id" IS NOT NULL OR "webtorrent"."id" IS NOT NULL) LIMIT 1'
+
+    return doesExist(query, { filename })
+  }
+
+  static async doesOwnedWebTorrentVideoFileExist (filename: string) {
+    const query = 'SELECT 1 FROM "videoFile" INNER JOIN "video" ON "video"."id" = "videoFile"."videoId" AND "video"."remote" IS FALSE ' +
+                  'WHERE "filename" = $filename LIMIT 1'
+
+    return doesExist(query, { filename })
+  }
+
+  static loadByFilename (filename: string) {
+    const query = {
+      where: {
+        filename
+      }
+    }
+
+    return VideoFileModel.findOne(query)
+  }
+
   static loadWithVideoOrPlaylistByTorrentFilename (filename: string) {
     const query = {
       where: {
@@ -443,10 +465,9 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
   }
 
   getFileDownloadUrl (video: MVideoWithHost) {
-    const basePath = this.isHLS()
-      ? STATIC_DOWNLOAD_PATHS.HLS_VIDEOS
-      : STATIC_DOWNLOAD_PATHS.VIDEOS
-    const path = join(basePath, this.filename)
+    const path = this.isHLS()
+      ? join(STATIC_DOWNLOAD_PATHS.HLS_VIDEOS, `${video.uuid}-${this.resolution}-fragmented${this.extname}`)
+      : join(STATIC_DOWNLOAD_PATHS.VIDEOS, `${video.uuid}-${this.resolution}${this.extname}`)
 
     if (video.isOwned()) return WEBSERVER.URL + path
 
diff --git a/server/models/video/video-playlist.ts b/server/models/video/video-playlist.ts
index af81c9906..630684a88 100644
--- a/server/models/video/video-playlist.ts
+++ b/server/models/video/video-playlist.ts
@@ -17,10 +17,9 @@ import {
   Table,
   UpdatedAt
 } from 'sequelize-typescript'
-import { setAsUpdated } from '@server/helpers/database-utils'
 import { buildUUID, uuidToShort } from '@server/helpers/uuid'
 import { MAccountId, MChannelId } from '@server/types/models'
-import { AttributesOnly } from '@shared/core-utils'
+import { AttributesOnly, buildPlaylistEmbedPath, buildPlaylistWatchPath, pick } from '@shared/core-utils'
 import { ActivityIconObject } from '../../../shared/models/activitypub/objects'
 import { PlaylistObject } from '../../../shared/models/activitypub/objects/playlist-object'
 import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
@@ -53,6 +52,7 @@ import {
 } from '../../types/models/video/video-playlist'
 import { AccountModel, ScopeNames as AccountScopeNames, SummaryOptions } from '../account/account'
 import { ActorModel } from '../actor/actor'
+import { setAsUpdated } from '../shared'
 import {
   buildServerIdsFollowedBy,
   buildTrigramSearchIndex,
@@ -82,6 +82,8 @@ type AvailableForListOptions = {
   videoChannelId?: number
   listMyPlaylists?: boolean
   search?: string
+  host?: string
+  uuids?: string[]
   withVideos?: boolean
 }
 
@@ -141,9 +143,19 @@ function getVideoLengthSelect () {
     ]
   },
   [ScopeNames.AVAILABLE_FOR_LIST]: (options: AvailableForListOptions) => {
+    const whereAnd: WhereOptions[] = []
+
+    const whereServer = options.host && options.host !== WEBSERVER.HOST
+      ? { host: options.host }
+      : undefined
+
     let whereActor: WhereOptions = {}
 
-    const whereAnd: WhereOptions[] = []
+    if (options.host === WEBSERVER.HOST) {
+      whereActor = {
+        [Op.and]: [ { serverId: null } ]
+      }
+    }
 
     if (options.listMyPlaylists !== true) {
       whereAnd.push({
@@ -168,9 +180,7 @@ function getVideoLengthSelect () {
         })
       }
 
-      whereActor = {
-        [Op.or]: whereActorOr
-      }
+      Object.assign(whereActor, { [Op.or]: whereActorOr })
     }
 
     if (options.accountId) {
@@ -191,18 +201,26 @@ function getVideoLengthSelect () {
       })
     }
 
+    if (options.uuids) {
+      whereAnd.push({
+        uuid: {
+          [Op.in]: options.uuids
+        }
+      })
+    }
+
     if (options.withVideos === true) {
       whereAnd.push(
         literal(`(${getVideoLengthSelect()}) != 0`)
       )
     }
 
-    const attributesInclude = []
+    let attributesInclude: any[] = [ literal('0 as similarity') ]
 
     if (options.search) {
       const escapedSearch = VideoPlaylistModel.sequelize.escape(options.search)
       const escapedLikeSearch = VideoPlaylistModel.sequelize.escape('%' + options.search + '%')
-      attributesInclude.push(createSimilarityAttribute('VideoPlaylistModel.name', options.search))
+      attributesInclude = [ createSimilarityAttribute('VideoPlaylistModel.name', options.search) ]
 
       whereAnd.push({
         [Op.or]: [
@@ -228,7 +246,7 @@ function getVideoLengthSelect () {
       include: [
         {
           model: AccountModel.scope({
-            method: [ AccountScopeNames.SUMMARY, { whereActor } as SummaryOptions ]
+            method: [ AccountScopeNames.SUMMARY, { whereActor, whereServer } as SummaryOptions ]
           }),
           required: true
         },
@@ -339,17 +357,10 @@ export class VideoPlaylistModel extends Model<Partial<AttributesOnly<VideoPlayli
   })
   Thumbnail: ThumbnailModel
 
-  static listForApi (options: {
-    followerActorId: number
+  static listForApi (options: AvailableForListOptions & {
     start: number
     count: number
     sort: string
-    type?: VideoPlaylistType
-    accountId?: number
-    videoChannelId?: number
-    listMyPlaylists?: boolean
-    search?: string
-    withVideos?: boolean // false by default
   }) {
     const query = {
       offset: options.start,
@@ -362,12 +373,8 @@ export class VideoPlaylistModel extends Model<Partial<AttributesOnly<VideoPlayli
         method: [
           ScopeNames.AVAILABLE_FOR_LIST,
           {
-            type: options.type,
-            followerActorId: options.followerActorId,
-            accountId: options.accountId,
-            videoChannelId: options.videoChannelId,
-            listMyPlaylists: options.listMyPlaylists,
-            search: options.search,
+            ...pick(options, [ 'type', 'followerActorId', 'accountId', 'videoChannelId', 'listMyPlaylists', 'search', 'host', 'uuids' ]),
+
             withVideos: options.withVideos || false
           } as AvailableForListOptions
         ]
@@ -384,15 +391,14 @@ export class VideoPlaylistModel extends Model<Partial<AttributesOnly<VideoPlayli
       })
   }
 
-  static searchForApi (options: {
-    followerActorId: number
+  static searchForApi (options: Pick<AvailableForListOptions, 'followerActorId' | 'search'| 'host'| 'uuids'> & {
     start: number
     count: number
     sort: string
-    search?: string
   }) {
     return VideoPlaylistModel.listForApi({
       ...options,
+
       type: VideoPlaylistType.REGULAR,
       listMyPlaylists: false,
       withVideos: true
@@ -560,12 +566,12 @@ export class VideoPlaylistModel extends Model<Partial<AttributesOnly<VideoPlayli
     return join(STATIC_PATHS.THUMBNAILS, this.Thumbnail.filename)
   }
 
-  getWatchUrl () {
-    return WEBSERVER.URL + '/w/p/' + this.uuid
+  getWatchStaticPath () {
+    return buildPlaylistWatchPath({ shortUUID: uuidToShort(this.uuid) })
   }
 
   getEmbedStaticPath () {
-    return '/video-playlists/embed/' + this.uuid
+    return buildPlaylistEmbedPath(this)
   }
 
   static async getStats () {
diff --git a/server/models/video/video-streaming-playlist.ts b/server/models/video/video-streaming-playlist.ts
index d627e8c9d..d591a3134 100644
--- a/server/models/video/video-streaming-playlist.ts
+++ b/server/models/video/video-streaming-playlist.ts
@@ -1,19 +1,27 @@
 import * as memoizee from 'memoizee'
 import { join } from 'path'
-import { Op, QueryTypes } from 'sequelize'
+import { Op } from 'sequelize'
 import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, HasMany, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
 import { VideoFileModel } from '@server/models/video/video-file'
-import { MStreamingPlaylist } from '@server/types/models'
+import { MStreamingPlaylist, MVideo } from '@server/types/models'
+import { AttributesOnly } from '@shared/core-utils'
 import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
 import { sha1 } from '../../helpers/core-utils'
 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
 import { isArrayOf } from '../../helpers/custom-validators/misc'
 import { isVideoFileInfoHashValid } from '../../helpers/custom-validators/videos'
-import { CONSTRAINTS_FIELDS, MEMOIZE_LENGTH, MEMOIZE_TTL, P2P_MEDIA_LOADER_PEER_VERSION, STATIC_PATHS } from '../../initializers/constants'
+import {
+  CONSTRAINTS_FIELDS,
+  MEMOIZE_LENGTH,
+  MEMOIZE_TTL,
+  P2P_MEDIA_LOADER_PEER_VERSION,
+  STATIC_PATHS,
+  WEBSERVER
+} from '../../initializers/constants'
 import { VideoRedundancyModel } from '../redundancy/video-redundancy'
+import { doesExist } from '../shared'
 import { throwIfNotValid } from '../utils'
 import { VideoModel } from './video'
-import { AttributesOnly } from '@shared/core-utils'
 
 @Table({
   tableName: 'videoStreamingPlaylist',
@@ -43,7 +51,11 @@ export class VideoStreamingPlaylistModel extends Model<Partial<AttributesOnly<Vi
   type: VideoStreamingPlaylistType
 
   @AllowNull(false)
-  @Is('PlaylistUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'playlist url'))
+  @Column
+  playlistFilename: string
+
+  @AllowNull(true)
+  @Is('PlaylistUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'playlist url', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.URL.max))
   playlistUrl: string
 
@@ -57,7 +69,11 @@ export class VideoStreamingPlaylistModel extends Model<Partial<AttributesOnly<Vi
   p2pMediaLoaderPeerVersion: number
 
   @AllowNull(false)
-  @Is('VideoStreamingSegmentsSha256Url', value => throwIfNotValid(value, isActivityPubUrlValid, 'segments sha256 url'))
+  @Column
+  segmentsSha256Filename: string
+
+  @AllowNull(true)
+  @Is('VideoStreamingSegmentsSha256Url', value => throwIfNotValid(value, isActivityPubUrlValid, 'segments sha256 url', true))
   @Column
   segmentsSha256Url: string
 
@@ -98,14 +114,8 @@ export class VideoStreamingPlaylistModel extends Model<Partial<AttributesOnly<Vi
 
   static doesInfohashExist (infoHash: string) {
     const query = 'SELECT 1 FROM "videoStreamingPlaylist" WHERE $infoHash = ANY("p2pMediaLoaderInfohashes") LIMIT 1'
-    const options = {
-      type: QueryTypes.SELECT as QueryTypes.SELECT,
-      bind: { infoHash },
-      raw: true
-    }
 
-    return VideoModel.sequelize.query<object>(query, options)
-              .then(results => results.length === 1)
+    return doesExist(query, { infoHash })
   }
 
   static buildP2PMediaLoaderInfoHashes (playlistUrl: string, files: unknown[]) {
@@ -125,7 +135,13 @@ export class VideoStreamingPlaylistModel extends Model<Partial<AttributesOnly<Vi
         p2pMediaLoaderPeerVersion: {
           [Op.ne]: P2P_MEDIA_LOADER_PEER_VERSION
         }
-      }
+      },
+      include: [
+        {
+          model: VideoModel.unscoped(),
+          required: true
+        }
+      ]
     }
 
     return VideoStreamingPlaylistModel.findAll(query)
@@ -144,7 +160,7 @@ export class VideoStreamingPlaylistModel extends Model<Partial<AttributesOnly<Vi
     return VideoStreamingPlaylistModel.findByPk(id, options)
   }
 
-  static loadHLSPlaylistByVideo (videoId: number) {
+  static loadHLSPlaylistByVideo (videoId: number): Promise<MStreamingPlaylist> {
     const options = {
       where: {
         type: VideoStreamingPlaylistType.HLS,
@@ -155,30 +171,29 @@ export class VideoStreamingPlaylistModel extends Model<Partial<AttributesOnly<Vi
     return VideoStreamingPlaylistModel.findOne(options)
   }
 
-  static getHlsPlaylistFilename (resolution: number) {
-    return resolution + '.m3u8'
-  }
+  static async loadOrGenerate (video: MVideo) {
+    let playlist = await VideoStreamingPlaylistModel.loadHLSPlaylistByVideo(video.id)
+    if (!playlist) playlist = new VideoStreamingPlaylistModel()
 
-  static getMasterHlsPlaylistFilename () {
-    return 'master.m3u8'
+    return Object.assign(playlist, { videoId: video.id, Video: video })
   }
 
-  static getHlsSha256SegmentsFilename () {
-    return 'segments-sha256.json'
-  }
+  assignP2PMediaLoaderInfoHashes (video: MVideo, files: unknown[]) {
+    const masterPlaylistUrl = this.getMasterPlaylistUrl(video)
 
-  static getHlsMasterPlaylistStaticPath (videoUUID: string) {
-    return join(STATIC_PATHS.STREAMING_PLAYLISTS.HLS, videoUUID, VideoStreamingPlaylistModel.getMasterHlsPlaylistFilename())
+    this.p2pMediaLoaderInfohashes = VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(masterPlaylistUrl, files)
   }
 
-  static getHlsPlaylistStaticPath (videoUUID: string, resolution: number) {
-    return join(STATIC_PATHS.STREAMING_PLAYLISTS.HLS, videoUUID, VideoStreamingPlaylistModel.getHlsPlaylistFilename(resolution))
+  getMasterPlaylistUrl (video: MVideo) {
+    if (video.isOwned()) return WEBSERVER.URL + this.getMasterPlaylistStaticPath(video.uuid)
+
+    return this.playlistUrl
   }
 
-  static getHlsSha256SegmentsStaticPath (videoUUID: string, isLive: boolean) {
-    if (isLive) return join('/live', 'segments-sha256', videoUUID)
+  getSha256SegmentsUrl (video: MVideo) {
+    if (video.isOwned()) return WEBSERVER.URL + this.getSha256SegmentsStaticPath(video.uuid, video.isLive)
 
-    return join(STATIC_PATHS.STREAMING_PLAYLISTS.HLS, videoUUID, VideoStreamingPlaylistModel.getHlsSha256SegmentsFilename())
+    return this.segmentsSha256Url
   }
 
   getStringType () {
@@ -195,4 +210,14 @@ export class VideoStreamingPlaylistModel extends Model<Partial<AttributesOnly<Vi
     return this.type === other.type &&
       this.videoId === other.videoId
   }
+
+  private getMasterPlaylistStaticPath (videoUUID: string) {
+    return join(STATIC_PATHS.STREAMING_PLAYLISTS.HLS, videoUUID, this.playlistFilename)
+  }
+
+  private getSha256SegmentsStaticPath (videoUUID: string, isLive: boolean) {
+    if (isLive) return join('/live', 'segments-sha256', videoUUID)
+
+    return join(STATIC_PATHS.STREAMING_PLAYLISTS.HLS, videoUUID, this.segmentsSha256Filename)
+  }
 }
diff --git a/server/models/video/video.ts b/server/models/video/video.ts
index 1e5648a36..56a5b0e18 100644
--- a/server/models/video/video.ts
+++ b/server/models/video/video.ts
@@ -24,14 +24,14 @@ import {
   Table,
   UpdatedAt
 } from 'sequelize-typescript'
-import { setAsUpdated } from '@server/helpers/database-utils'
 import { buildNSFWFilter } from '@server/helpers/express-utils'
+import { uuidToShort } from '@server/helpers/uuid'
 import { getPrivaciesForFederation, isPrivacyForFederation, isStateForFederation } from '@server/helpers/video'
 import { LiveManager } from '@server/lib/live/live-manager'
 import { getHLSDirectory, getVideoFilePath } from '@server/lib/video-paths'
 import { getServerActor } from '@server/models/application/application'
 import { ModelCache } from '@server/models/model-cache'
-import { AttributesOnly } from '@shared/core-utils'
+import { AttributesOnly, buildVideoEmbedPath, buildVideoWatchPath, pick } from '@shared/core-utils'
 import { VideoFile } from '@shared/models/videos/video-file.model'
 import { ResultList, UserRight, VideoPrivacy, VideoState } from '../../../shared'
 import { VideoObject } from '../../../shared/models/activitypub/objects'
@@ -91,6 +91,7 @@ import { VideoRedundancyModel } from '../redundancy/video-redundancy'
 import { ServerModel } from '../server/server'
 import { TrackerModel } from '../server/tracker'
 import { VideoTrackerModel } from '../server/video-tracker'
+import { setAsUpdated } from '../shared'
 import { UserModel } from '../user/user'
 import { UserVideoHistoryModel } from '../user/user-video-history'
 import { buildTrigramSearchIndex, buildWhereIdOrUUID, getVideoSort, isOutdated, throwIfNotValid } from '../utils'
@@ -762,8 +763,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
 
       // Remove physical files and torrents
       instance.VideoFiles.forEach(file => {
-        tasks.push(instance.removeFile(file))
-        tasks.push(file.removeTorrent())
+        tasks.push(instance.removeFileAndTorrent(file))
       })
 
       // Remove playlists file
@@ -1070,7 +1070,8 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
     const trendingDays = options.sort.endsWith('trending')
       ? CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS
       : undefined
-    let trendingAlgorithm
+
+    let trendingAlgorithm: string
     if (options.sort.endsWith('hot')) trendingAlgorithm = 'hot'
     if (options.sort.endsWith('best')) trendingAlgorithm = 'best'
 
@@ -1082,40 +1083,44 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
       : serverActor.id
 
     const queryOptions = {
-      start: options.start,
-      count: options.count,
-      sort: options.sort,
+      ...pick(options, [
+        'start',
+        'count',
+        'sort',
+        'nsfw',
+        'isLive',
+        'categoryOneOf',
+        'licenceOneOf',
+        'languageOneOf',
+        'tagsOneOf',
+        'tagsAllOf',
+        'filter',
+        'withFiles',
+        'accountId',
+        'videoChannelId',
+        'videoPlaylistId',
+        'includeLocalVideos',
+        'user',
+        'historyOfUser',
+        'search'
+      ]),
+
       followerActorId,
       serverAccountId: serverActor.Account.id,
-      nsfw: options.nsfw,
-      isLive: options.isLive,
-      categoryOneOf: options.categoryOneOf,
-      licenceOneOf: options.licenceOneOf,
-      languageOneOf: options.languageOneOf,
-      tagsOneOf: options.tagsOneOf,
-      tagsAllOf: options.tagsAllOf,
-      filter: options.filter,
-      withFiles: options.withFiles,
-      accountId: options.accountId,
-      videoChannelId: options.videoChannelId,
-      videoPlaylistId: options.videoPlaylistId,
-      includeLocalVideos: options.includeLocalVideos,
-      user: options.user,
-      historyOfUser: options.historyOfUser,
       trendingDays,
-      trendingAlgorithm,
-      search: options.search
+      trendingAlgorithm
     }
 
     return VideoModel.getAvailableForApi(queryOptions, options.countVideos)
   }
 
   static async searchAndPopulateAccountAndServer (options: {
+    start: number
+    count: number
+    sort: string
     includeLocalVideos: boolean
     search?: string
-    start?: number
-    count?: number
-    sort?: string
+    host?: string
     startDate?: string // ISO 8601
     endDate?: string // ISO 8601
     originallyPublishedStartDate?: string
@@ -1131,41 +1136,38 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
     durationMax?: number // seconds
     user?: MUserAccountId
     filter?: VideoFilter
+    uuids?: string[]
   }) {
     const serverActor = await getServerActor()
 
     const queryOptions = {
-      followerActorId: serverActor.id,
-      serverAccountId: serverActor.Account.id,
-
-      includeLocalVideos: options.includeLocalVideos,
-      nsfw: options.nsfw,
-      isLive: options.isLive,
-
-      categoryOneOf: options.categoryOneOf,
-      licenceOneOf: options.licenceOneOf,
-      languageOneOf: options.languageOneOf,
+      ...pick(options, [
+        'includeLocalVideos',
+        'nsfw',
+        'isLive',
+        'categoryOneOf',
+        'licenceOneOf',
+        'languageOneOf',
+        'tagsOneOf',
+        'tagsAllOf',
+        'user',
+        'filter',
+        'host',
+        'start',
+        'count',
+        'sort',
+        'startDate',
+        'endDate',
+        'originallyPublishedStartDate',
+        'originallyPublishedEndDate',
+        'durationMin',
+        'durationMax',
+        'uuids',
+        'search'
+      ]),
 
-      tagsOneOf: options.tagsOneOf,
-      tagsAllOf: options.tagsAllOf,
-
-      user: options.user,
-      filter: options.filter,
-
-      start: options.start,
-      count: options.count,
-      sort: options.sort,
-
-      startDate: options.startDate,
-      endDate: options.endDate,
-
-      originallyPublishedStartDate: options.originallyPublishedStartDate,
-      originallyPublishedEndDate: options.originallyPublishedEndDate,
-
-      durationMin: options.durationMin,
-      durationMax: options.durationMax,
-
-      search: options.search
+      followerActorId: serverActor.id,
+      serverAccountId: serverActor.Account.id
     }
 
     return VideoModel.getAvailableForApi(queryOptions)
@@ -1579,11 +1581,11 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
   }
 
   getWatchStaticPath () {
-    return '/w/' + this.uuid
+    return buildVideoWatchPath({ shortUUID: uuidToShort(this.uuid) })
   }
 
   getEmbedStaticPath () {
-    return '/videos/embed/' + this.uuid
+    return buildVideoEmbedPath(this)
   }
 
   getMiniatureStaticPath () {
@@ -1670,10 +1672,13 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
                                        .concat(toAdd)
   }
 
-  removeFile (videoFile: MVideoFile, isRedundancy = false) {
+  removeFileAndTorrent (videoFile: MVideoFile, isRedundancy = false) {
     const filePath = getVideoFilePath(this, videoFile, isRedundancy)
-    return remove(filePath)
-      .catch(err => logger.warn('Cannot delete file %s.', filePath, { err }))
+
+    const promises: Promise<any>[] = [ remove(filePath) ]
+    if (!isRedundancy) promises.push(videoFile.removeTorrent())
+
+    return Promise.all(promises)
   }
 
   async removeStreamingPlaylistFiles (streamingPlaylist: MStreamingPlaylist, isRedundancy = false) {
diff --git a/server/tests/api/activitypub/cleaner.ts b/server/tests/api/activitypub/cleaner.ts
index 75ef56ce3..51cf6e599 100644
--- a/server/tests/api/activitypub/cleaner.ts
+++ b/server/tests/api/activitypub/cleaner.ts
@@ -4,24 +4,18 @@ import 'mocha'
 import * as chai from 'chai'
 import {
   cleanupTests,
-  closeAllSequelize,
-  deleteAll,
+  createMultipleServers,
   doubleFollow,
-  getCount,
-  selectQuery,
-  setVideoField,
-  updateQuery,
-  wait
-} from '../../../../shared/extra-utils'
-import { flushAndRunMultipleServers, ServerInfo, setAccessTokensToServers } from '../../../../shared/extra-utils/index'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { addVideoCommentThread, getVideoCommentThreads } from '../../../../shared/extra-utils/videos/video-comments'
-import { getVideo, rateVideo, uploadVideoAndGetId } from '../../../../shared/extra-utils/videos/videos'
+  PeerTubeServer,
+  setAccessTokensToServers,
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test AP cleaner', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoUUID1: string
   let videoUUID2: string
   let videoUUID3: string
@@ -36,7 +30,7 @@ describe('Test AP cleaner', function () {
         videos: { cleanup_remote_interactions: true }
       }
     }
-    servers = await flushAndRunMultipleServers(3, config)
+    servers = await createMultipleServers(3, config)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -52,9 +46,9 @@ describe('Test AP cleaner', function () {
     // Create 1 comment per video
     // Update 1 remote URL and 1 local URL on
 
-    videoUUID1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'server 1' })).uuid
-    videoUUID2 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'server 2' })).uuid
-    videoUUID3 = (await uploadVideoAndGetId({ server: servers[2], videoName: 'server 3' })).uuid
+    videoUUID1 = (await servers[0].videos.quickUpload({ name: 'server 1' })).uuid
+    videoUUID2 = (await servers[1].videos.quickUpload({ name: 'server 2' })).uuid
+    videoUUID3 = (await servers[2].videos.quickUpload({ name: 'server 3' })).uuid
 
     videoUUIDs = [ videoUUID1, videoUUID2, videoUUID3 ]
 
@@ -62,8 +56,8 @@ describe('Test AP cleaner', function () {
 
     for (const server of servers) {
       for (const uuid of videoUUIDs) {
-        await rateVideo(server.url, server.accessToken, uuid, 'like')
-        await addVideoCommentThread(server.url, server.accessToken, uuid, 'comment')
+        await server.videos.rate({ id: uuid, rating: 'like' })
+        await server.comments.createThread({ videoId: uuid, text: 'comment' })
       }
     }
 
@@ -73,9 +67,10 @@ describe('Test AP cleaner', function () {
   it('Should have the correct likes', async function () {
     for (const server of servers) {
       for (const uuid of videoUUIDs) {
-        const res = await getVideo(server.url, uuid)
-        expect(res.body.likes).to.equal(3)
-        expect(res.body.dislikes).to.equal(0)
+        const video = await server.videos.get({ id: uuid })
+
+        expect(video.likes).to.equal(3)
+        expect(video.dislikes).to.equal(0)
       }
     }
   })
@@ -83,9 +78,9 @@ describe('Test AP cleaner', function () {
   it('Should destroy server 3 internal likes and correctly clean them', async function () {
     this.timeout(20000)
 
-    await deleteAll(servers[2].internalServerNumber, 'accountVideoRate')
+    await servers[2].sql.deleteAll('accountVideoRate')
     for (const uuid of videoUUIDs) {
-      await setVideoField(servers[2].internalServerNumber, uuid, 'likes', '0')
+      await servers[2].sql.setVideoField(uuid, 'likes', '0')
     }
 
     await wait(5000)
@@ -93,16 +88,16 @@ describe('Test AP cleaner', function () {
 
     // Updated rates of my video
     {
-      const res = await getVideo(servers[0].url, videoUUID1)
-      expect(res.body.likes).to.equal(2)
-      expect(res.body.dislikes).to.equal(0)
+      const video = await servers[0].videos.get({ id: videoUUID1 })
+      expect(video.likes).to.equal(2)
+      expect(video.dislikes).to.equal(0)
     }
 
     // Did not update rates of a remote video
     {
-      const res = await getVideo(servers[0].url, videoUUID2)
-      expect(res.body.likes).to.equal(3)
-      expect(res.body.dislikes).to.equal(0)
+      const video = await servers[0].videos.get({ id: videoUUID2 })
+      expect(video.likes).to.equal(3)
+      expect(video.dislikes).to.equal(0)
     }
   })
 
@@ -111,7 +106,7 @@ describe('Test AP cleaner', function () {
 
     for (const server of servers) {
       for (const uuid of videoUUIDs) {
-        await rateVideo(server.url, server.accessToken, uuid, 'dislike')
+        await server.videos.rate({ id: uuid, rating: 'dislike' })
       }
     }
 
@@ -119,9 +114,9 @@ describe('Test AP cleaner', function () {
 
     for (const server of servers) {
       for (const uuid of videoUUIDs) {
-        const res = await getVideo(server.url, uuid)
-        expect(res.body.likes).to.equal(0)
-        expect(res.body.dislikes).to.equal(3)
+        const video = await server.videos.get({ id: uuid })
+        expect(video.likes).to.equal(0)
+        expect(video.dislikes).to.equal(3)
       }
     }
   })
@@ -129,10 +124,10 @@ describe('Test AP cleaner', function () {
   it('Should destroy server 3 internal dislikes and correctly clean them', async function () {
     this.timeout(20000)
 
-    await deleteAll(servers[2].internalServerNumber, 'accountVideoRate')
+    await servers[2].sql.deleteAll('accountVideoRate')
 
     for (const uuid of videoUUIDs) {
-      await setVideoField(servers[2].internalServerNumber, uuid, 'dislikes', '0')
+      await servers[2].sql.setVideoField(uuid, 'dislikes', '0')
     }
 
     await wait(5000)
@@ -140,31 +135,31 @@ describe('Test AP cleaner', function () {
 
     // Updated rates of my video
     {
-      const res = await getVideo(servers[0].url, videoUUID1)
-      expect(res.body.likes).to.equal(0)
-      expect(res.body.dislikes).to.equal(2)
+      const video = await servers[0].videos.get({ id: videoUUID1 })
+      expect(video.likes).to.equal(0)
+      expect(video.dislikes).to.equal(2)
     }
 
     // Did not update rates of a remote video
     {
-      const res = await getVideo(servers[0].url, videoUUID2)
-      expect(res.body.likes).to.equal(0)
-      expect(res.body.dislikes).to.equal(3)
+      const video = await servers[0].videos.get({ id: videoUUID2 })
+      expect(video.likes).to.equal(0)
+      expect(video.dislikes).to.equal(3)
     }
   })
 
   it('Should destroy server 3 internal shares and correctly clean them', async function () {
     this.timeout(20000)
 
-    const preCount = await getCount(servers[0].internalServerNumber, 'videoShare')
+    const preCount = await servers[0].sql.getCount('videoShare')
     expect(preCount).to.equal(6)
 
-    await deleteAll(servers[2].internalServerNumber, 'videoShare')
+    await servers[2].sql.deleteAll('videoShare')
     await wait(5000)
     await waitJobs(servers)
 
     // Still 6 because we don't have remote shares on local videos
-    const postCount = await getCount(servers[0].internalServerNumber, 'videoShare')
+    const postCount = await servers[0].sql.getCount('videoShare')
     expect(postCount).to.equal(6)
   })
 
@@ -172,18 +167,18 @@ describe('Test AP cleaner', function () {
     this.timeout(20000)
 
     {
-      const res = await getVideoCommentThreads(servers[0].url, videoUUID1, 0, 5)
-      expect(res.body.total).to.equal(3)
+      const { total } = await servers[0].comments.listThreads({ videoId: videoUUID1 })
+      expect(total).to.equal(3)
     }
 
-    await deleteAll(servers[2].internalServerNumber, 'videoComment')
+    await servers[2].sql.deleteAll('videoComment')
 
     await wait(5000)
     await waitJobs(servers)
 
     {
-      const res = await getVideoCommentThreads(servers[0].url, videoUUID1, 0, 5)
-      expect(res.body.total).to.equal(2)
+      const { total } = await servers[0].comments.listThreads({ videoId: videoUUID1 })
+      expect(total).to.equal(2)
     }
   })
 
@@ -193,7 +188,7 @@ describe('Test AP cleaner', function () {
     async function check (like: string, ofServerUrl: string, urlSuffix: string, remote: 'true' | 'false') {
       const query = `SELECT "videoId", "accountVideoRate".url FROM "accountVideoRate" ` +
         `INNER JOIN video ON "accountVideoRate"."videoId" = video.id AND remote IS ${remote} WHERE "accountVideoRate"."url" LIKE '${like}'`
-      const res = await selectQuery(servers[0].internalServerNumber, query)
+      const res = await servers[0].sql.selectQuery(query)
 
       for (const rate of res) {
         const matcher = new RegExp(`^${ofServerUrl}/accounts/root/dislikes/\\d+${urlSuffix}$`)
@@ -222,7 +217,7 @@ describe('Test AP cleaner', function () {
 
     {
       const query = `UPDATE "accountVideoRate" SET url = url || 'stan'`
-      await updateQuery(servers[1].internalServerNumber, query)
+      await servers[1].sql.updateQuery(query)
 
       await wait(5000)
       await waitJobs(servers)
@@ -239,7 +234,7 @@ describe('Test AP cleaner', function () {
       const query = `SELECT "videoId", "videoComment".url, uuid as "videoUUID" FROM "videoComment" ` +
         `INNER JOIN video ON "videoComment"."videoId" = video.id AND remote IS ${remote} WHERE "videoComment"."url" LIKE '${like}'`
 
-      const res = await selectQuery(servers[0].internalServerNumber, query)
+      const res = await servers[0].sql.selectQuery(query)
 
       for (const comment of res) {
         const matcher = new RegExp(`${ofServerUrl}/videos/watch/${comment.videoUUID}/comments/\\d+${urlSuffix}`)
@@ -265,7 +260,7 @@ describe('Test AP cleaner', function () {
 
     {
       const query = `UPDATE "videoComment" SET url = url || 'kyle'`
-      await updateQuery(servers[1].internalServerNumber, query)
+      await servers[1].sql.updateQuery(query)
 
       await wait(5000)
       await waitJobs(servers)
@@ -277,7 +272,5 @@ describe('Test AP cleaner', function () {
 
   after(async function () {
     await cleanupTests(servers)
-
-    await closeAllSequelize(servers)
   })
 })
diff --git a/server/tests/api/activitypub/client.ts b/server/tests/api/activitypub/client.ts
index be94e219c..c3e4b7f74 100644
--- a/server/tests/api/activitypub/client.ts
+++ b/server/tests/api/activitypub/client.ts
@@ -2,24 +2,21 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { VideoPlaylistPrivacy } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   cleanupTests,
-  createVideoPlaylist,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
   makeActivityPubGetRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  setDefaultVideoChannel,
-  uploadVideoAndGetId
-} from '../../../../shared/extra-utils'
+  setDefaultVideoChannel
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoPlaylistPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test activitypub', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let video: { id: number, uuid: string, shortUUID: string }
   let playlist: { id: number, uuid: string, shortUUID: string }
 
@@ -64,19 +61,18 @@ describe('Test activitypub', function () {
   before(async function () {
     this.timeout(30000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
     {
-      video = await uploadVideoAndGetId({ server: servers[0], videoName: 'video' })
+      video = await servers[0].videos.quickUpload({ name: 'video' })
     }
 
     {
-      const playlistAttrs = { displayName: 'playlist', privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: servers[0].videoChannel.id }
-      const resCreate = await createVideoPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistAttrs })
-      playlist = resCreate.body.videoPlaylist
+      const attributes = { displayName: 'playlist', privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: servers[0].store.channel.id }
+      playlist = await servers[0].playlists.create({ attributes })
     }
 
     await doubleFollow(servers[0], servers[1])
diff --git a/server/tests/api/activitypub/fetch.ts b/server/tests/api/activitypub/fetch.ts
index 35fd94eed..422a75d6e 100644
--- a/server/tests/api/activitypub/fetch.ts
+++ b/server/tests/api/activitypub/fetch.ts
@@ -1,61 +1,44 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
-import {
-  cleanupTests,
-  closeAllSequelize,
-  createUser,
-  doubleFollow,
-  flushAndRunMultipleServers,
-  getVideosListSort,
-  ServerInfo,
-  setAccessTokensToServers,
-  setActorField,
-  setVideoField,
-  uploadVideo,
-  userLogin,
-  waitJobs
-} from '../../../../shared/extra-utils'
 import * as chai from 'chai'
-import { Video } from '../../../../shared/models/videos'
+import { cleanupTests, createMultipleServers, doubleFollow, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test ActivityPub fetcher', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
 
     const user = { username: 'user1', password: 'password' }
     for (const server of servers) {
-      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+      await server.users.create({ username: user.username, password: user.password })
     }
 
-    const userAccessToken = await userLogin(servers[0], user)
+    const userAccessToken = await servers[0].login.getAccessToken(user)
 
-    await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video root' })
-    const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'bad video root' })
-    const badVideoUUID = res.body.video.uuid
-    await uploadVideo(servers[0].url, userAccessToken, { name: 'video user' })
+    await servers[0].videos.upload({ attributes: { name: 'video root' } })
+    const { uuid } = await servers[0].videos.upload({ attributes: { name: 'bad video root' } })
+    await servers[0].videos.upload({ token: userAccessToken, attributes: { name: 'video user' } })
 
     {
       const to = 'http://localhost:' + servers[0].port + '/accounts/user1'
       const value = 'http://localhost:' + servers[1].port + '/accounts/user1'
-      await setActorField(servers[0].internalServerNumber, to, 'url', value)
+      await servers[0].sql.setActorField(to, 'url', value)
     }
 
     {
-      const value = 'http://localhost:' + servers[2].port + '/videos/watch/' + badVideoUUID
-      await setVideoField(servers[0].internalServerNumber, badVideoUUID, 'url', value)
+      const value = 'http://localhost:' + servers[2].port + '/videos/watch/' + uuid
+      await servers[0].sql.setVideoField(uuid, 'url', value)
     }
   })
 
@@ -66,20 +49,18 @@ describe('Test ActivityPub fetcher', function () {
     await waitJobs(servers)
 
     {
-      const res = await getVideosListSort(servers[0].url, 'createdAt')
-      expect(res.body.total).to.equal(3)
+      const { total, data } = await servers[0].videos.list({ sort: 'createdAt' })
 
-      const data: Video[] = res.body.data
+      expect(total).to.equal(3)
       expect(data[0].name).to.equal('video root')
       expect(data[1].name).to.equal('bad video root')
       expect(data[2].name).to.equal('video user')
     }
 
     {
-      const res = await getVideosListSort(servers[1].url, 'createdAt')
-      expect(res.body.total).to.equal(1)
+      const { total, data } = await servers[1].videos.list({ sort: 'createdAt' })
 
-      const data: Video[] = res.body.data
+      expect(total).to.equal(1)
       expect(data[0].name).to.equal('video root')
     }
   })
@@ -88,7 +69,5 @@ describe('Test ActivityPub fetcher', function () {
     this.timeout(20000)
 
     await cleanupTests(servers)
-
-    await closeAllSequelize(servers)
   })
 })
diff --git a/server/tests/api/activitypub/helpers.ts b/server/tests/api/activitypub/helpers.ts
index 66d7631b7..57b1cab23 100644
--- a/server/tests/api/activitypub/helpers.ts
+++ b/server/tests/api/activitypub/helpers.ts
@@ -2,11 +2,10 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import { buildRequestStub } from '../../../../shared/extra-utils/miscs/stubs'
-import { isHTTPSignatureVerified, isJsonLDSignatureVerified, parseHTTPSignature } from '../../../helpers/peertube-crypto'
 import { cloneDeep } from 'lodash'
+import { buildAbsoluteFixturePath, buildRequestStub } from '@shared/extra-utils'
 import { buildSignedActivity } from '../../../helpers/activitypub'
-import { buildAbsoluteFixturePath } from '@shared/extra-utils'
+import { isHTTPSignatureVerified, isJsonLDSignatureVerified, parseHTTPSignature } from '../../../helpers/peertube-crypto'
 
 describe('Test activity pub helpers', function () {
   describe('When checking the Linked Signature', function () {
diff --git a/server/tests/api/activitypub/refresher.ts b/server/tests/api/activitypub/refresher.ts
index c717f1a30..81fee0044 100644
--- a/server/tests/api/activitypub/refresher.ts
+++ b/server/tests/api/activitypub/refresher.ts
@@ -2,32 +2,20 @@
 
 import 'mocha'
 import {
-  cleanupTests, closeAllSequelize,
-  createVideoPlaylist,
+  cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  generateUserAccessToken,
-  getVideo,
-  getVideoPlaylist,
   killallServers,
-  reRunServer,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  setActorField,
   setDefaultVideoChannel,
-  setPlaylistField,
-  setVideoField,
-  uploadVideo,
-  uploadVideoAndGetId,
   wait,
   waitJobs
-} from '../../../../shared/extra-utils'
-import { getAccount } from '../../../../shared/extra-utils/users/accounts'
-import { VideoPlaylistPrivacy } from '../../../../shared/models/videos'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoPlaylistPrivacy } from '@shared/models'
 
 describe('Test AP refresher', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoUUID1: string
   let videoUUID2: string
   let videoUUID3: string
@@ -37,36 +25,36 @@ describe('Test AP refresher', function () {
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2, { transcoding: { enabled: false } })
+    servers = await createMultipleServers(2, { transcoding: { enabled: false } })
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
     {
-      videoUUID1 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video1' })).uuid
-      videoUUID2 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video2' })).uuid
-      videoUUID3 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video3' })).uuid
+      videoUUID1 = (await servers[1].videos.quickUpload({ name: 'video1' })).uuid
+      videoUUID2 = (await servers[1].videos.quickUpload({ name: 'video2' })).uuid
+      videoUUID3 = (await servers[1].videos.quickUpload({ name: 'video3' })).uuid
     }
 
     {
-      const a1 = await generateUserAccessToken(servers[1], 'user1')
-      await uploadVideo(servers[1].url, a1, { name: 'video4' })
+      const token1 = await servers[1].users.generateUserAndToken('user1')
+      await servers[1].videos.upload({ token: token1, attributes: { name: 'video4' } })
 
-      const a2 = await generateUserAccessToken(servers[1], 'user2')
-      await uploadVideo(servers[1].url, a2, { name: 'video5' })
+      const token2 = await servers[1].users.generateUserAndToken('user2')
+      await servers[1].videos.upload({ token: token2, attributes: { name: 'video5' } })
     }
 
     {
-      const playlistAttrs = { displayName: 'playlist1', privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: servers[1].videoChannel.id }
-      const res = await createVideoPlaylist({ url: servers[1].url, token: servers[1].accessToken, playlistAttrs })
-      playlistUUID1 = res.body.videoPlaylist.uuid
+      const attributes = { displayName: 'playlist1', privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: servers[1].store.channel.id }
+      const created = await servers[1].playlists.create({ attributes })
+      playlistUUID1 = created.uuid
     }
 
     {
-      const playlistAttrs = { displayName: 'playlist2', privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: servers[1].videoChannel.id }
-      const res = await createVideoPlaylist({ url: servers[1].url, token: servers[1].accessToken, playlistAttrs })
-      playlistUUID2 = res.body.videoPlaylist.uuid
+      const attributes = { displayName: 'playlist2', privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: servers[1].store.channel.id }
+      const created = await servers[1].playlists.create({ attributes })
+      playlistUUID2 = created.uuid
     }
 
     await doubleFollow(servers[0], servers[1])
@@ -80,34 +68,34 @@ describe('Test AP refresher', function () {
       await wait(10000)
 
       // Change UUID so the remote server returns a 404
-      await setVideoField(servers[1].internalServerNumber, videoUUID1, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b174f')
+      await servers[1].sql.setVideoField(videoUUID1, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b174f')
 
-      await getVideo(servers[0].url, videoUUID1)
-      await getVideo(servers[0].url, videoUUID2)
+      await servers[0].videos.get({ id: videoUUID1 })
+      await servers[0].videos.get({ id: videoUUID2 })
 
       await waitJobs(servers)
 
-      await getVideo(servers[0].url, videoUUID1, HttpStatusCode.NOT_FOUND_404)
-      await getVideo(servers[0].url, videoUUID2, HttpStatusCode.OK_200)
+      await servers[0].videos.get({ id: videoUUID1, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+      await servers[0].videos.get({ id: videoUUID2 })
     })
 
     it('Should not update a remote video if the remote instance is down', async function () {
       this.timeout(70000)
 
-      killallServers([ servers[1] ])
+      await killallServers([ servers[1] ])
 
-      await setVideoField(servers[1].internalServerNumber, videoUUID3, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b174e')
+      await servers[1].sql.setVideoField(videoUUID3, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b174e')
 
       // Video will need a refresh
       await wait(10000)
 
-      await getVideo(servers[0].url, videoUUID3)
+      await servers[0].videos.get({ id: videoUUID3 })
       // The refresh should fail
       await waitJobs([ servers[0] ])
 
-      await reRunServer(servers[1])
+      await servers[1].run()
 
-      await getVideo(servers[0].url, videoUUID3, HttpStatusCode.OK_200)
+      await servers[0].videos.get({ id: videoUUID3 })
     })
   })
 
@@ -116,19 +104,21 @@ describe('Test AP refresher', function () {
     it('Should remove a deleted actor', async function () {
       this.timeout(60000)
 
+      const command = servers[0].accounts
+
       await wait(10000)
 
       // Change actor name so the remote server returns a 404
       const to = 'http://localhost:' + servers[1].port + '/accounts/user2'
-      await setActorField(servers[1].internalServerNumber, to, 'preferredUsername', 'toto')
+      await servers[1].sql.setActorField(to, 'preferredUsername', 'toto')
 
-      await getAccount(servers[0].url, 'user1@localhost:' + servers[1].port)
-      await getAccount(servers[0].url, 'user2@localhost:' + servers[1].port)
+      await command.get({ accountName: 'user1@localhost:' + servers[1].port })
+      await command.get({ accountName: 'user2@localhost:' + servers[1].port })
 
       await waitJobs(servers)
 
-      await getAccount(servers[0].url, 'user1@localhost:' + servers[1].port, HttpStatusCode.OK_200)
-      await getAccount(servers[0].url, 'user2@localhost:' + servers[1].port, HttpStatusCode.NOT_FOUND_404)
+      await command.get({ accountName: 'user1@localhost:' + servers[1].port, expectedStatus: HttpStatusCode.OK_200 })
+      await command.get({ accountName: 'user2@localhost:' + servers[1].port, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
   })
 
@@ -140,15 +130,15 @@ describe('Test AP refresher', function () {
       await wait(10000)
 
       // Change UUID so the remote server returns a 404
-      await setPlaylistField(servers[1].internalServerNumber, playlistUUID2, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b178e')
+      await servers[1].sql.setPlaylistField(playlistUUID2, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b178e')
 
-      await getVideoPlaylist(servers[0].url, playlistUUID1)
-      await getVideoPlaylist(servers[0].url, playlistUUID2)
+      await servers[0].playlists.get({ playlistId: playlistUUID1 })
+      await servers[0].playlists.get({ playlistId: playlistUUID2 })
 
       await waitJobs(servers)
 
-      await getVideoPlaylist(servers[0].url, playlistUUID1, HttpStatusCode.OK_200)
-      await getVideoPlaylist(servers[0].url, playlistUUID2, HttpStatusCode.NOT_FOUND_404)
+      await servers[0].playlists.get({ playlistId: playlistUUID1, expectedStatus: HttpStatusCode.OK_200 })
+      await servers[0].playlists.get({ playlistId: playlistUUID2, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
   })
 
@@ -156,7 +146,5 @@ describe('Test AP refresher', function () {
     this.timeout(10000)
 
     await cleanupTests(servers)
-
-    await closeAllSequelize(servers)
   })
 })
diff --git a/server/tests/api/activitypub/security.ts b/server/tests/api/activitypub/security.ts
index 61db272f6..94d946563 100644
--- a/server/tests/api/activitypub/security.ts
+++ b/server/tests/api/activitypub/security.ts
@@ -2,45 +2,35 @@
 
 import 'mocha'
 import * as chai from 'chai'
+import { activityPubContextify, buildSignedActivity } from '@server/helpers/activitypub'
 import { buildDigest } from '@server/helpers/peertube-crypto'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-import {
-  buildAbsoluteFixturePath,
-  cleanupTests,
-  closeAllSequelize,
-  flushAndRunMultipleServers,
-  killallServers,
-  reRunServer,
-  ServerInfo,
-  setActorField,
-  wait
-} from '../../../../shared/extra-utils'
-import { makeFollowRequest, makePOSTAPRequest } from '../../../../shared/extra-utils/requests/activitypub'
-import { activityPubContextify, buildSignedActivity } from '../../../helpers/activitypub'
-import { HTTP_SIGNATURE } from '../../../initializers/constants'
-import { buildGlobalHeaders } from '../../../lib/job-queue/handlers/utils/activitypub-http-utils'
+import { HTTP_SIGNATURE } from '@server/initializers/constants'
+import { buildGlobalHeaders } from '@server/lib/job-queue/handlers/utils/activitypub-http-utils'
+import { buildAbsoluteFixturePath, cleanupTests, createMultipleServers, killallServers, PeerTubeServer, wait } from '@shared/extra-utils'
+import { makeFollowRequest, makePOSTAPRequest } from '@shared/extra-utils/requests/activitypub'
+import { HttpStatusCode } from '@shared/models'
 
 const expect = chai.expect
 
-function setKeysOfServer (onServer: ServerInfo, ofServer: ServerInfo, publicKey: string, privateKey: string) {
+function setKeysOfServer (onServer: PeerTubeServer, ofServer: PeerTubeServer, publicKey: string, privateKey: string) {
   const url = 'http://localhost:' + ofServer.port + '/accounts/peertube'
 
   return Promise.all([
-    setActorField(onServer.internalServerNumber, url, 'publicKey', publicKey),
-    setActorField(onServer.internalServerNumber, url, 'privateKey', privateKey)
+    onServer.sql.setActorField(url, 'publicKey', publicKey),
+    onServer.sql.setActorField(url, 'privateKey', privateKey)
   ])
 }
 
-function setUpdatedAtOfServer (onServer: ServerInfo, ofServer: ServerInfo, updatedAt: string) {
+function setUpdatedAtOfServer (onServer: PeerTubeServer, ofServer: PeerTubeServer, updatedAt: string) {
   const url = 'http://localhost:' + ofServer.port + '/accounts/peertube'
 
   return Promise.all([
-    setActorField(onServer.internalServerNumber, url, 'createdAt', updatedAt),
-    setActorField(onServer.internalServerNumber, url, 'updatedAt', updatedAt)
+    onServer.sql.setActorField(url, 'createdAt', updatedAt),
+    onServer.sql.setActorField(url, 'updatedAt', updatedAt)
   ])
 }
 
-function getAnnounceWithoutContext (server: ServerInfo) {
+function getAnnounceWithoutContext (server: PeerTubeServer) {
   const json = require(buildAbsoluteFixturePath('./ap-json/peertube/announce-without-context.json'))
   const result: typeof json = {}
 
@@ -56,7 +46,7 @@ function getAnnounceWithoutContext (server: ServerInfo) {
 }
 
 describe('Test ActivityPub security', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let url: string
 
   const keys = require(buildAbsoluteFixturePath('./ap-json/peertube/keys.json'))
@@ -74,7 +64,7 @@ describe('Test ActivityPub security', function () {
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     url = servers[0].url + '/inbox'
 
@@ -173,8 +163,8 @@ describe('Test ActivityPub security', function () {
       await setUpdatedAtOfServer(servers[0], servers[1], '2015-07-17 22:00:00+00')
 
       // Invalid peertube actor cache
-      killallServers([ servers[1] ])
-      await reRunServer(servers[1])
+      await killallServers([ servers[1] ])
+      await servers[1].run()
 
       const body = activityPubContextify(getAnnounceWithoutContext(servers[1]))
       const headers = buildGlobalHeaders(body)
@@ -294,7 +284,5 @@ describe('Test ActivityPub security', function () {
     this.timeout(10000)
 
     await cleanupTests(servers)
-
-    await closeAllSequelize(servers)
   })
 })
diff --git a/server/tests/api/check-params/abuses.ts b/server/tests/api/check-params/abuses.ts
index 2054776cc..fb9a5fd8b 100644
--- a/server/tests/api/check-params/abuses.ts
+++ b/server/tests/api/check-params/abuses.ts
@@ -1,66 +1,49 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { AbuseCreate, AbuseState } from '@shared/models'
 import {
-  addAbuseMessage,
+  AbusesCommand,
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   cleanupTests,
-  createUser,
-  deleteAbuse,
-  deleteAbuseMessage,
+  createSingleServer,
   doubleFollow,
-  flushAndRunServer,
-  generateUserAccessToken,
-  getAdminAbusesList,
-  getVideoIdFromUUID,
-  listAbuseMessages,
   makeGetRequest,
   makePostBodyRequest,
-  reportAbuse,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateAbuse,
-  uploadVideo,
-  userLogin,
   waitJobs
-} from '../../../../shared/extra-utils'
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+} from '@shared/extra-utils'
+import { AbuseCreate, AbuseState, HttpStatusCode } from '@shared/models'
 
 describe('Test abuses API validators', function () {
   const basePath = '/api/v1/abuses/'
 
-  let server: ServerInfo
+  let server: PeerTubeServer
 
-  let userAccessToken = ''
-  let userAccessToken2 = ''
+  let userToken = ''
+  let userToken2 = ''
   let abuseId: number
   let messageId: number
 
+  let command: AbusesCommand
+
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
-    const username = 'user1'
-    const password = 'my super password'
-    await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
-    userAccessToken = await userLogin(server, { username, password })
+    userToken = await server.users.generateUserAndToken('user_1')
+    userToken2 = await server.users.generateUserAndToken('user_2')
 
-    {
-      userAccessToken2 = await generateUserAccessToken(server, 'user_2')
-    }
+    server.store.videoCreated = await server.videos.upload()
 
-    const res = await uploadVideo(server.url, server.accessToken, {})
-    server.video = res.body.video
+    command = server.abuses
   })
 
   describe('When listing abuses for admins', function () {
@@ -82,7 +65,7 @@ describe('Test abuses API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -90,8 +73,8 @@ describe('Test abuses API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        token: userToken,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -126,7 +109,7 @@ describe('Test abuses API validators', function () {
         videoIs: 'deleted'
       }
 
-      await makeGetRequest({ url: server.url, path, token: server.accessToken, query, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, path, token: server.accessToken, query, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -134,32 +117,32 @@ describe('Test abuses API validators', function () {
     const path = '/api/v1/users/me/abuses'
 
     it('Should fail with a bad start pagination', async function () {
-      await checkBadStartPagination(server.url, path, userAccessToken)
+      await checkBadStartPagination(server.url, path, userToken)
     })
 
     it('Should fail with a bad count pagination', async function () {
-      await checkBadCountPagination(server.url, path, userAccessToken)
+      await checkBadCountPagination(server.url, path, userToken)
     })
 
     it('Should fail with an incorrect sort', async function () {
-      await checkBadSortPagination(server.url, path, userAccessToken)
+      await checkBadSortPagination(server.url, path, userToken)
     })
 
     it('Should fail with a non authenticated user', async function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
     it('Should fail with a bad id filter', async function () {
-      await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { id: 'toto' } })
+      await makeGetRequest({ url: server.url, path, token: userToken, query: { id: 'toto' } })
     })
 
     it('Should fail with a bad state filter', async function () {
-      await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { state: 'toto' } })
-      await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { state: 0 } })
+      await makeGetRequest({ url: server.url, path, token: userToken, query: { state: 'toto' } })
+      await makeGetRequest({ url: server.url, path, token: userToken, query: { state: 0 } })
     })
 
     it('Should succeed with the correct params', async function () {
@@ -168,7 +151,7 @@ describe('Test abuses API validators', function () {
         state: 2
       }
 
-      await makeGetRequest({ url: server.url, path, token: userAccessToken, query, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, path, token: userToken, query, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -177,12 +160,12 @@ describe('Test abuses API validators', function () {
 
     it('Should fail with nothing', async function () {
       const fields = {}
-      await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields })
+      await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
     })
 
     it('Should fail with a wrong video', async function () {
       const fields = { video: { id: 'blabla' }, reason: 'my super reason' }
-      await makePostBodyRequest({ url: server.url, path: path, token: userAccessToken, fields })
+      await makePostBodyRequest({ url: server.url, path: path, token: userToken, fields })
     })
 
     it('Should fail with an unknown video', async function () {
@@ -190,15 +173,15 @@ describe('Test abuses API validators', function () {
       await makePostBodyRequest({
         url: server.url,
         path,
-        token: userAccessToken,
+        token: userToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
     it('Should fail with a wrong comment', async function () {
       const fields = { comment: { id: 'blabla' }, reason: 'my super reason' }
-      await makePostBodyRequest({ url: server.url, path: path, token: userAccessToken, fields })
+      await makePostBodyRequest({ url: server.url, path: path, token: userToken, fields })
     })
 
     it('Should fail with an unknown comment', async function () {
@@ -206,15 +189,15 @@ describe('Test abuses API validators', function () {
       await makePostBodyRequest({
         url: server.url,
         path,
-        token: userAccessToken,
+        token: userToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
     it('Should fail with a wrong account', async function () {
       const fields = { account: { id: 'blabla' }, reason: 'my super reason' }
-      await makePostBodyRequest({ url: server.url, path: path, token: userAccessToken, fields })
+      await makePostBodyRequest({ url: server.url, path: path, token: userToken, fields })
     })
 
     it('Should fail with an unknown account', async function () {
@@ -222,9 +205,9 @@ describe('Test abuses API validators', function () {
       await makePostBodyRequest({
         url: server.url,
         path,
-        token: userAccessToken,
+        token: userToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -233,65 +216,65 @@ describe('Test abuses API validators', function () {
       await makePostBodyRequest({
         url: server.url,
         path,
-        token: userAccessToken,
+        token: userToken,
         fields,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
     it('Should fail with a non authenticated user', async function () {
-      const fields = { video: { id: server.video.id }, reason: 'my super reason' }
+      const fields = { video: { id: server.store.videoCreated.id }, reason: 'my super reason' }
 
-      await makePostBodyRequest({ url: server.url, path, token: 'hello', fields, statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makePostBodyRequest({ url: server.url, path, token: 'hello', fields, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a reason too short', async function () {
-      const fields = { video: { id: server.video.id }, reason: 'h' }
+      const fields = { video: { id: server.store.videoCreated.id }, reason: 'h' }
 
-      await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields })
+      await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
     })
 
     it('Should fail with a too big reason', async function () {
-      const fields = { video: { id: server.video.id }, reason: 'super'.repeat(605) }
+      const fields = { video: { id: server.store.videoCreated.id }, reason: 'super'.repeat(605) }
 
-      await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields })
+      await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
     })
 
     it('Should succeed with the correct parameters (basic)', async function () {
-      const fields: AbuseCreate = { video: { id: server.video.shortUUID }, reason: 'my super reason' }
+      const fields: AbuseCreate = { video: { id: server.store.videoCreated.shortUUID }, reason: 'my super reason' }
 
       const res = await makePostBodyRequest({
         url: server.url,
         path,
-        token: userAccessToken,
+        token: userToken,
         fields,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
       abuseId = res.body.abuse.id
     })
 
     it('Should fail with a wrong predefined reason', async function () {
-      const fields = { video: { id: server.video.id }, reason: 'my super reason', predefinedReasons: [ 'wrongPredefinedReason' ] }
+      const fields = { video: server.store.videoCreated, reason: 'my super reason', predefinedReasons: [ 'wrongPredefinedReason' ] }
 
-      await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields })
+      await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
     })
 
     it('Should fail with negative timestamps', async function () {
-      const fields = { video: { id: server.video.id, startAt: -1 }, reason: 'my super reason' }
+      const fields = { video: { id: server.store.videoCreated.id, startAt: -1 }, reason: 'my super reason' }
 
-      await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields })
+      await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
     })
 
     it('Should fail mith misordered startAt/endAt', async function () {
-      const fields = { video: { id: server.video.id, startAt: 5, endAt: 1 }, reason: 'my super reason' }
+      const fields = { video: { id: server.store.videoCreated.id, startAt: 5, endAt: 1 }, reason: 'my super reason' }
 
-      await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields })
+      await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
     })
 
     it('Should succeed with the corret parameters (advanced)', async function () {
       const fields: AbuseCreate = {
         video: {
-          id: server.video.id,
+          id: server.store.videoCreated.id,
           startAt: 1,
           endAt: 5
         },
@@ -299,37 +282,37 @@ describe('Test abuses API validators', function () {
         predefinedReasons: [ 'serverRules' ]
       }
 
-      await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makePostBodyRequest({ url: server.url, path, token: userToken, fields, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
   describe('When updating an abuse', function () {
 
     it('Should fail with a non authenticated user', async function () {
-      await updateAbuse(server.url, 'blabla', abuseId, {}, HttpStatusCode.UNAUTHORIZED_401)
+      await command.update({ token: 'blabla', abuseId, body: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a non admin user', async function () {
-      await updateAbuse(server.url, userAccessToken, abuseId, {}, HttpStatusCode.FORBIDDEN_403)
+      await command.update({ token: userToken, abuseId, body: {}, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a bad abuse id', async function () {
-      await updateAbuse(server.url, server.accessToken, 45, {}, HttpStatusCode.NOT_FOUND_404)
+      await command.update({ abuseId: 45, body: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a bad state', async function () {
       const body = { state: 5 }
-      await updateAbuse(server.url, server.accessToken, abuseId, body, HttpStatusCode.BAD_REQUEST_400)
+      await command.update({ abuseId, body, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with a bad moderation comment', async function () {
       const body = { moderationComment: 'b'.repeat(3001) }
-      await updateAbuse(server.url, server.accessToken, abuseId, body, HttpStatusCode.BAD_REQUEST_400)
+      await command.update({ abuseId, body, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should succeed with the correct params', async function () {
       const body = { state: AbuseState.ACCEPTED }
-      await updateAbuse(server.url, server.accessToken, abuseId, body)
+      await command.update({ abuseId, body })
     })
   })
 
@@ -337,23 +320,23 @@ describe('Test abuses API validators', function () {
     const message = 'my super message'
 
     it('Should fail with an invalid abuse id', async function () {
-      await addAbuseMessage(server.url, userAccessToken2, 888, message, HttpStatusCode.NOT_FOUND_404)
+      await command.addMessage({ token: userToken2, abuseId: 888, message, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a non authenticated user', async function () {
-      await addAbuseMessage(server.url, 'fake_token', abuseId, message, HttpStatusCode.UNAUTHORIZED_401)
+      await command.addMessage({ token: 'fake_token', abuseId, message, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with an invalid logged in user', async function () {
-      await addAbuseMessage(server.url, userAccessToken2, abuseId, message, HttpStatusCode.FORBIDDEN_403)
+      await command.addMessage({ token: userToken2, abuseId, message, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with an invalid message', async function () {
-      await addAbuseMessage(server.url, userAccessToken, abuseId, 'a'.repeat(5000), HttpStatusCode.BAD_REQUEST_400)
+      await command.addMessage({ token: userToken, abuseId, message: 'a'.repeat(5000), expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should suceed with the correct params', async function () {
-      const res = await addAbuseMessage(server.url, userAccessToken, abuseId, message)
+      const res = await command.addMessage({ token: userToken, abuseId, message })
       messageId = res.body.abuseMessage.id
     })
   })
@@ -361,96 +344,90 @@ describe('Test abuses API validators', function () {
   describe('When listing abuse messages', function () {
 
     it('Should fail with an invalid abuse id', async function () {
-      await listAbuseMessages(server.url, userAccessToken, 888, HttpStatusCode.NOT_FOUND_404)
+      await command.listMessages({ token: userToken, abuseId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a non authenticated user', async function () {
-      await listAbuseMessages(server.url, 'fake_token', abuseId, HttpStatusCode.UNAUTHORIZED_401)
+      await command.listMessages({ token: 'fake_token', abuseId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with an invalid logged in user', async function () {
-      await listAbuseMessages(server.url, userAccessToken2, abuseId, HttpStatusCode.FORBIDDEN_403)
+      await command.listMessages({ token: userToken2, abuseId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await listAbuseMessages(server.url, userAccessToken, abuseId)
+      await command.listMessages({ token: userToken, abuseId })
     })
   })
 
   describe('When deleting an abuse message', function () {
-
     it('Should fail with an invalid abuse id', async function () {
-      await deleteAbuseMessage(server.url, userAccessToken, 888, messageId, HttpStatusCode.NOT_FOUND_404)
+      await command.deleteMessage({ token: userToken, abuseId: 888, messageId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with an invalid message id', async function () {
-      await deleteAbuseMessage(server.url, userAccessToken, abuseId, 888, HttpStatusCode.NOT_FOUND_404)
+      await command.deleteMessage({ token: userToken, abuseId, messageId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a non authenticated user', async function () {
-      await deleteAbuseMessage(server.url, 'fake_token', abuseId, messageId, HttpStatusCode.UNAUTHORIZED_401)
+      await command.deleteMessage({ token: 'fake_token', abuseId, messageId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with an invalid logged in user', async function () {
-      await deleteAbuseMessage(server.url, userAccessToken2, abuseId, messageId, HttpStatusCode.FORBIDDEN_403)
+      await command.deleteMessage({ token: userToken2, abuseId, messageId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await deleteAbuseMessage(server.url, userAccessToken, abuseId, messageId)
+      await command.deleteMessage({ token: userToken, abuseId, messageId })
     })
   })
 
   describe('When deleting a video abuse', function () {
 
     it('Should fail with a non authenticated user', async function () {
-      await deleteAbuse(server.url, 'blabla', abuseId, HttpStatusCode.UNAUTHORIZED_401)
+      await command.delete({ token: 'blabla', abuseId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a non admin user', async function () {
-      await deleteAbuse(server.url, userAccessToken, abuseId, HttpStatusCode.FORBIDDEN_403)
+      await command.delete({ token: userToken, abuseId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a bad abuse id', async function () {
-      await deleteAbuse(server.url, server.accessToken, 45, HttpStatusCode.NOT_FOUND_404)
+      await command.delete({ abuseId: 45, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await deleteAbuse(server.url, server.accessToken, abuseId)
+      await command.delete({ abuseId })
     })
   })
 
   describe('When trying to manage messages of a remote abuse', function () {
     let remoteAbuseId: number
-    let anotherServer: ServerInfo
+    let anotherServer: PeerTubeServer
 
     before(async function () {
       this.timeout(50000)
 
-      anotherServer = await flushAndRunServer(2)
+      anotherServer = await createSingleServer(2)
       await setAccessTokensToServers([ anotherServer ])
 
       await doubleFollow(anotherServer, server)
 
-      const server2VideoId = await getVideoIdFromUUID(anotherServer.url, server.video.uuid)
-      await reportAbuse({
-        url: anotherServer.url,
-        token: anotherServer.accessToken,
-        reason: 'remote server',
-        videoId: server2VideoId
-      })
+      const server2VideoId = await anotherServer.videos.getId({ uuid: server.store.videoCreated.uuid })
+      await anotherServer.abuses.report({ reason: 'remote server', videoId: server2VideoId })
 
       await waitJobs([ server, anotherServer ])
 
-      const res = await getAdminAbusesList({ url: server.url, token: server.accessToken, sort: '-createdAt' })
-      remoteAbuseId = res.body.data[0].id
+      const body = await command.getAdminList({ sort: '-createdAt' })
+      remoteAbuseId = body.data[0].id
     })
 
     it('Should fail when listing abuse messages of a remote abuse', async function () {
-      await listAbuseMessages(server.url, server.accessToken, remoteAbuseId, HttpStatusCode.BAD_REQUEST_400)
+      await command.listMessages({ abuseId: remoteAbuseId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail when creating abuse message of a remote abuse', async function () {
-      await addAbuseMessage(server.url, server.accessToken, remoteAbuseId, 'message', HttpStatusCode.BAD_REQUEST_400)
+      await command.addMessage({ abuseId: remoteAbuseId, message: 'message', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     after(async function () {
diff --git a/server/tests/api/check-params/accounts.ts b/server/tests/api/check-params/accounts.ts
index d1712cff6..141d869b7 100644
--- a/server/tests/api/check-params/accounts.ts
+++ b/server/tests/api/check-params/accounts.ts
@@ -1,26 +1,26 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
-import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { getAccount } from '../../../../shared/extra-utils/users/accounts'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+  checkBadStartPagination,
+  cleanupTests,
+  createSingleServer,
+  PeerTubeServer
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test accounts API validators', function () {
   const path = '/api/v1/accounts/'
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
   })
 
   describe('When listing accounts', function () {
@@ -38,8 +38,9 @@ describe('Test accounts API validators', function () {
   })
 
   describe('When getting an account', function () {
+
     it('Should return 404 with a non existing name', async function () {
-      await getAccount(server.url, 'arfaze', HttpStatusCode.NOT_FOUND_404)
+      await server.accounts.get({ accountName: 'arfaze', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
   })
 
diff --git a/server/tests/api/check-params/blocklist.ts b/server/tests/api/check-params/blocklist.ts
index 5ed8810ce..7d5fae5cf 100644
--- a/server/tests/api/check-params/blocklist.ts
+++ b/server/tests/api/check-params/blocklist.ts
@@ -1,43 +1,38 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
 import {
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   cleanupTests,
-  createUser,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
   makeDeleteRequest,
   makeGetRequest,
   makePostBodyRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test blocklist API validators', function () {
-  let servers: ServerInfo[]
-  let server: ServerInfo
+  let servers: PeerTubeServer[]
+  let server: PeerTubeServer
   let userAccessToken: string
 
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     server = servers[0]
 
     const user = { username: 'user1', password: 'password' }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+    await server.users.create({ username: user.username, password: user.password })
 
-    userAccessToken = await userLogin(server, user)
+    userAccessToken = await server.login.getAccessToken(user)
 
     await doubleFollow(servers[0], servers[1])
   })
@@ -54,7 +49,7 @@ describe('Test blocklist API validators', function () {
           await makeGetRequest({
             url: server.url,
             path,
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -77,7 +72,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path,
             fields: { accountName: 'user1' },
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -87,7 +82,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { accountName: 'user2' },
-            statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+            expectedStatus: HttpStatusCode.NOT_FOUND_404
           })
         })
 
@@ -97,7 +92,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { accountName: 'root' },
-            statusCodeExpected: HttpStatusCode.CONFLICT_409
+            expectedStatus: HttpStatusCode.CONFLICT_409
           })
         })
 
@@ -107,7 +102,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { accountName: 'user1' },
-            statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+            expectedStatus: HttpStatusCode.NO_CONTENT_204
           })
         })
       })
@@ -117,7 +112,7 @@ describe('Test blocklist API validators', function () {
           await makeDeleteRequest({
             url: server.url,
             path: path + '/user1',
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -126,7 +121,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path: path + '/user2',
             token: server.accessToken,
-            statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+            expectedStatus: HttpStatusCode.NOT_FOUND_404
           })
         })
 
@@ -135,7 +130,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path: path + '/user1',
             token: server.accessToken,
-            statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+            expectedStatus: HttpStatusCode.NO_CONTENT_204
           })
         })
       })
@@ -149,7 +144,7 @@ describe('Test blocklist API validators', function () {
           await makeGetRequest({
             url: server.url,
             path,
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -172,7 +167,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path,
             fields: { host: 'localhost:9002' },
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -182,7 +177,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { host: 'localhost:9003' },
-            statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+            expectedStatus: HttpStatusCode.NO_CONTENT_204
           })
         })
 
@@ -192,7 +187,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { host: 'localhost:' + server.port },
-            statusCodeExpected: HttpStatusCode.CONFLICT_409
+            expectedStatus: HttpStatusCode.CONFLICT_409
           })
         })
 
@@ -202,7 +197,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { host: 'localhost:' + servers[1].port },
-            statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+            expectedStatus: HttpStatusCode.NO_CONTENT_204
           })
         })
       })
@@ -212,7 +207,7 @@ describe('Test blocklist API validators', function () {
           await makeDeleteRequest({
             url: server.url,
             path: path + '/localhost:' + servers[1].port,
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -221,7 +216,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path: path + '/localhost:9004',
             token: server.accessToken,
-            statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+            expectedStatus: HttpStatusCode.NOT_FOUND_404
           })
         })
 
@@ -230,7 +225,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path: path + '/localhost:' + servers[1].port,
             token: server.accessToken,
-            statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+            expectedStatus: HttpStatusCode.NO_CONTENT_204
           })
         })
       })
@@ -247,7 +242,7 @@ describe('Test blocklist API validators', function () {
           await makeGetRequest({
             url: server.url,
             path,
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -256,7 +251,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             token: userAccessToken,
             path,
-            statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+            expectedStatus: HttpStatusCode.FORBIDDEN_403
           })
         })
 
@@ -279,7 +274,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path,
             fields: { accountName: 'user1' },
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -289,7 +284,7 @@ describe('Test blocklist API validators', function () {
             token: userAccessToken,
             path,
             fields: { accountName: 'user1' },
-            statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+            expectedStatus: HttpStatusCode.FORBIDDEN_403
           })
         })
 
@@ -299,7 +294,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { accountName: 'user2' },
-            statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+            expectedStatus: HttpStatusCode.NOT_FOUND_404
           })
         })
 
@@ -309,7 +304,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { accountName: 'root' },
-            statusCodeExpected: HttpStatusCode.CONFLICT_409
+            expectedStatus: HttpStatusCode.CONFLICT_409
           })
         })
 
@@ -319,7 +314,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { accountName: 'user1' },
-            statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+            expectedStatus: HttpStatusCode.NO_CONTENT_204
           })
         })
       })
@@ -329,7 +324,7 @@ describe('Test blocklist API validators', function () {
           await makeDeleteRequest({
             url: server.url,
             path: path + '/user1',
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -338,7 +333,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path: path + '/user1',
             token: userAccessToken,
-            statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+            expectedStatus: HttpStatusCode.FORBIDDEN_403
           })
         })
 
@@ -347,7 +342,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path: path + '/user2',
             token: server.accessToken,
-            statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+            expectedStatus: HttpStatusCode.NOT_FOUND_404
           })
         })
 
@@ -356,7 +351,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path: path + '/user1',
             token: server.accessToken,
-            statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+            expectedStatus: HttpStatusCode.NO_CONTENT_204
           })
         })
       })
@@ -370,7 +365,7 @@ describe('Test blocklist API validators', function () {
           await makeGetRequest({
             url: server.url,
             path,
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -379,7 +374,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             token: userAccessToken,
             path,
-            statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+            expectedStatus: HttpStatusCode.FORBIDDEN_403
           })
         })
 
@@ -402,7 +397,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path,
             fields: { host: 'localhost:' + servers[1].port },
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -412,7 +407,7 @@ describe('Test blocklist API validators', function () {
             token: userAccessToken,
             path,
             fields: { host: 'localhost:' + servers[1].port },
-            statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+            expectedStatus: HttpStatusCode.FORBIDDEN_403
           })
         })
 
@@ -422,7 +417,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { host: 'localhost:9003' },
-            statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+            expectedStatus: HttpStatusCode.NO_CONTENT_204
           })
         })
 
@@ -432,7 +427,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { host: 'localhost:' + server.port },
-            statusCodeExpected: HttpStatusCode.CONFLICT_409
+            expectedStatus: HttpStatusCode.CONFLICT_409
           })
         })
 
@@ -442,7 +437,7 @@ describe('Test blocklist API validators', function () {
             token: server.accessToken,
             path,
             fields: { host: 'localhost:' + servers[1].port },
-            statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+            expectedStatus: HttpStatusCode.NO_CONTENT_204
           })
         })
       })
@@ -452,7 +447,7 @@ describe('Test blocklist API validators', function () {
           await makeDeleteRequest({
             url: server.url,
             path: path + '/localhost:' + servers[1].port,
-            statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+            expectedStatus: HttpStatusCode.UNAUTHORIZED_401
           })
         })
 
@@ -461,7 +456,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path: path + '/localhost:' + servers[1].port,
             token: userAccessToken,
-            statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+            expectedStatus: HttpStatusCode.FORBIDDEN_403
           })
         })
 
@@ -470,7 +465,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path: path + '/localhost:9004',
             token: server.accessToken,
-            statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+            expectedStatus: HttpStatusCode.NOT_FOUND_404
           })
         })
 
@@ -479,7 +474,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             path: path + '/localhost:' + servers[1].port,
             token: server.accessToken,
-            statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+            expectedStatus: HttpStatusCode.NO_CONTENT_204
           })
         })
       })
diff --git a/server/tests/api/check-params/bulk.ts b/server/tests/api/check-params/bulk.ts
index 07b920ba7..bc9d7784d 100644
--- a/server/tests/api/check-params/bulk.ts
+++ b/server/tests/api/check-params/bulk.ts
@@ -1,19 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import {
-  cleanupTests,
-  createUser,
-  flushAndRunServer,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { makePostBodyRequest } from '../../../../shared/extra-utils/requests/requests'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { cleanupTests, createSingleServer, makePostBodyRequest, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test bulk API validators', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken: string
 
   // ---------------------------------------------------------------
@@ -21,13 +13,13 @@ describe('Test bulk API validators', function () {
   before(async function () {
     this.timeout(120000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
     const user = { username: 'user1', password: 'password' }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+    await server.users.create({ username: user.username, password: user.password })
 
-    userAccessToken = await userLogin(server, user)
+    userAccessToken = await server.login.getAccessToken(user)
   })
 
   describe('When removing comments of', function () {
@@ -38,7 +30,7 @@ describe('Test bulk API validators', function () {
         url: server.url,
         path,
         fields: { accountName: 'user1', scope: 'my-videos' },
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -48,7 +40,7 @@ describe('Test bulk API validators', function () {
         token: server.accessToken,
         path,
         fields: { accountName: 'user2', scope: 'my-videos' },
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -58,7 +50,7 @@ describe('Test bulk API validators', function () {
         token: server.accessToken,
         path,
         fields: { accountName: 'user1', scope: 'my-videoss' },
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -68,7 +60,7 @@ describe('Test bulk API validators', function () {
         token: userAccessToken,
         path,
         fields: { accountName: 'user1', scope: 'instance' },
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -78,7 +70,7 @@ describe('Test bulk API validators', function () {
         token: server.accessToken,
         path,
         fields: { accountName: 'user1', scope: 'instance' },
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
diff --git a/server/tests/api/check-params/config.ts b/server/tests/api/check-params/config.ts
index 9549070ef..87cb2287e 100644
--- a/server/tests/api/check-params/config.ts
+++ b/server/tests/api/check-params/config.ts
@@ -1,26 +1,21 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import { omit } from 'lodash'
 import 'mocha'
-import { CustomConfig } from '../../../../shared/models/server/custom-config.model'
-
+import { omit } from 'lodash'
 import {
   cleanupTests,
-  createUser,
-  flushAndRunServer,
-  immutableAssign,
+  createSingleServer,
   makeDeleteRequest,
   makeGetRequest,
   makePutBodyRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { CustomConfig, HttpStatusCode } from '@shared/models'
 
 describe('Test config API validators', function () {
   const path = '/api/v1/config/custom'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken: string
   const updateParams: CustomConfig = {
     instance: {
@@ -201,7 +196,7 @@ describe('Test config API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -209,8 +204,8 @@ describe('Test config API validators', function () {
       username: 'user1',
       password: 'password'
     }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(server, user)
+    await server.users.create({ username: user.username, password: user.password })
+    userAccessToken = await server.login.getAccessToken(user)
   })
 
   describe('When getting the configuration', function () {
@@ -218,7 +213,7 @@ describe('Test config API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -227,7 +222,7 @@ describe('Test config API validators', function () {
         url: server.url,
         path,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
   })
@@ -238,7 +233,7 @@ describe('Test config API validators', function () {
         url: server.url,
         path,
         fields: updateParams,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -248,7 +243,7 @@ describe('Test config API validators', function () {
         path,
         fields: updateParams,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -260,47 +255,53 @@ describe('Test config API validators', function () {
         path,
         fields: newUpdateParams,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
     it('Should fail with a bad default NSFW policy', async function () {
-      const newUpdateParams = immutableAssign(updateParams, {
+      const newUpdateParams = {
+        ...updateParams,
+
         instance: {
           defaultNSFWPolicy: 'hello'
         }
-      })
+      }
 
       await makePutBodyRequest({
         url: server.url,
         path,
         fields: newUpdateParams,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
     it('Should fail if email disabled and signup requires email verification', async function () {
       // opposite scenario - success when enable enabled - covered via tests/api/users/user-verification.ts
-      const newUpdateParams = immutableAssign(updateParams, {
+      const newUpdateParams = {
+        ...updateParams,
+
         signup: {
           enabled: true,
           limit: 5,
           requiresEmailVerification: true
         }
-      })
+      }
 
       await makePutBodyRequest({
         url: server.url,
         path,
         fields: newUpdateParams,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
     it('Should fail with a disabled webtorrent & hls transcoding', async function () {
-      const newUpdateParams = immutableAssign(updateParams, {
+      const newUpdateParams = {
+        ...updateParams,
+
         transcoding: {
           hls: {
             enabled: false
@@ -309,14 +310,14 @@ describe('Test config API validators', function () {
             enabled: false
           }
         }
-      })
+      }
 
       await makePutBodyRequest({
         url: server.url,
         path,
         fields: newUpdateParams,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -326,7 +327,7 @@ describe('Test config API validators', function () {
         path,
         fields: updateParams,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -336,7 +337,7 @@ describe('Test config API validators', function () {
       await makeDeleteRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -345,7 +346,7 @@ describe('Test config API validators', function () {
         url: server.url,
         path,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
   })
diff --git a/server/tests/api/check-params/contact-form.ts b/server/tests/api/check-params/contact-form.ts
index c7f9c1b47..1df9993da 100644
--- a/server/tests/api/check-params/contact-form.ts
+++ b/server/tests/api/check-params/contact-form.ts
@@ -1,14 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
-import { cleanupTests, flushAndRunServer, immutableAssign, killallServers, reRunServer, ServerInfo } from '../../../../shared/extra-utils'
-import { sendContactForm } from '../../../../shared/extra-utils/server/contact-form'
-import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { cleanupTests, createSingleServer, killallServers, MockSmtpServer, PeerTubeServer } from '@shared/extra-utils'
+import { ContactFormCommand } from '@shared/extra-utils/server'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test contact form API validators', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   const emails: object[] = []
   const defaultBody = {
     fromName: 'super name',
@@ -17,6 +15,7 @@ describe('Test contact form API validators', function () {
     body: 'Hello, how are you?'
   }
   let emailPort: number
+  let command: ContactFormCommand
 
   // ---------------------------------------------------------------
 
@@ -26,86 +25,51 @@ describe('Test contact form API validators', function () {
     emailPort = await MockSmtpServer.Instance.collectEmails(emails)
 
     // Email is disabled
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
+    command = server.contactForm
   })
 
   it('Should not accept a contact form if emails are disabled', async function () {
-    await sendContactForm(immutableAssign(defaultBody, { url: server.url, expectedStatus: HttpStatusCode.CONFLICT_409 }))
+    await command.send({ ...defaultBody, expectedStatus: HttpStatusCode.CONFLICT_409 })
   })
 
   it('Should not accept a contact form if it is disabled in the configuration', async function () {
     this.timeout(10000)
 
-    killallServers([ server ])
+    await killallServers([ server ])
 
     // Contact form is disabled
-    await reRunServer(server, { smtp: { hostname: 'localhost', port: emailPort }, contact_form: { enabled: false } })
-    await sendContactForm(immutableAssign(defaultBody, { url: server.url, expectedStatus: HttpStatusCode.CONFLICT_409 }))
+    await server.run({ smtp: { hostname: 'localhost', port: emailPort }, contact_form: { enabled: false } })
+    await command.send({ ...defaultBody, expectedStatus: HttpStatusCode.CONFLICT_409 })
   })
 
   it('Should not accept a contact form if from email is invalid', async function () {
     this.timeout(10000)
 
-    killallServers([ server ])
+    await killallServers([ server ])
 
     // Email & contact form enabled
-    await reRunServer(server, { smtp: { hostname: 'localhost', port: emailPort } })
-
-    await sendContactForm(immutableAssign(defaultBody, {
-      url: server.url,
-      expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-      fromEmail: 'badEmail'
-    }))
-    await sendContactForm(immutableAssign(defaultBody, {
-      url: server.url,
-      expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-      fromEmail: 'badEmail@'
-    }))
-    await sendContactForm(immutableAssign(defaultBody, {
-      url: server.url,
-      expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-      fromEmail: undefined
-    }))
+    await server.run({ smtp: { hostname: 'localhost', port: emailPort } })
+
+    await command.send({ ...defaultBody, fromEmail: 'badEmail', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await command.send({ ...defaultBody, fromEmail: 'badEmail@', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await command.send({ ...defaultBody, fromEmail: undefined, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should not accept a contact form if from name is invalid', async function () {
-    await sendContactForm(immutableAssign(defaultBody, {
-      url: server.url,
-      expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-      fromName: 'name'.repeat(100)
-    }))
-    await sendContactForm(immutableAssign(defaultBody, {
-      url: server.url,
-      expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-      fromName: ''
-    }))
-    await sendContactForm(immutableAssign(defaultBody, {
-      url: server.url,
-      expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-      fromName: undefined
-    }))
+    await command.send({ ...defaultBody, fromName: 'name'.repeat(100), expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await command.send({ ...defaultBody, fromName: '', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await command.send({ ...defaultBody, fromName: undefined, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should not accept a contact form if body is invalid', async function () {
-    await sendContactForm(immutableAssign(defaultBody, {
-      url: server.url,
-      expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-      body: 'body'.repeat(5000)
-    }))
-    await sendContactForm(immutableAssign(defaultBody, {
-      url: server.url,
-      expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-      body: 'a'
-    }))
-    await sendContactForm(immutableAssign(defaultBody, {
-      url: server.url,
-      expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-      body: undefined
-    }))
+    await command.send({ ...defaultBody, body: 'body'.repeat(5000), expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await command.send({ ...defaultBody, body: 'a', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await command.send({ ...defaultBody, body: undefined, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should accept a contact form with the correct parameters', async function () {
-    await sendContactForm(immutableAssign(defaultBody, { url: server.url }))
+    await command.send(defaultBody)
   })
 
   after(async function () {
diff --git a/server/tests/api/check-params/custom-pages.ts b/server/tests/api/check-params/custom-pages.ts
index 74ca3384c..9fbbea315 100644
--- a/server/tests/api/check-params/custom-pages.ts
+++ b/server/tests/api/check-params/custom-pages.ts
@@ -1,21 +1,20 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   cleanupTests,
-  createUser,
-  flushAndRunServer,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { makeGetRequest, makePutBodyRequest } from '../../../../shared/extra-utils/requests/requests'
+  createSingleServer,
+  makeGetRequest,
+  makePutBodyRequest,
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test custom pages validators', function () {
   const path = '/api/v1/custom-pages/homepage/instance'
 
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken: string
 
   // ---------------------------------------------------------------
@@ -23,13 +22,13 @@ describe('Test custom pages validators', function () {
   before(async function () {
     this.timeout(120000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
     const user = { username: 'user1', password: 'password' }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+    await server.users.create({ username: user.username, password: user.password })
 
-    userAccessToken = await userLogin(server, user)
+    userAccessToken = await server.login.getAccessToken(user)
   })
 
   describe('When updating instance homepage', function () {
@@ -39,7 +38,7 @@ describe('Test custom pages validators', function () {
         url: server.url,
         path,
         fields: { content: 'super content' },
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -49,7 +48,7 @@ describe('Test custom pages validators', function () {
         path,
         token: userAccessToken,
         fields: { content: 'super content' },
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -59,7 +58,7 @@ describe('Test custom pages validators', function () {
         path,
         token: server.accessToken,
         fields: { content: 'super content' },
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -70,7 +69,7 @@ describe('Test custom pages validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
diff --git a/server/tests/api/check-params/debug.ts b/server/tests/api/check-params/debug.ts
index 37bf0f99b..a55786359 100644
--- a/server/tests/api/check-params/debug.ts
+++ b/server/tests/api/check-params/debug.ts
@@ -1,21 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
-import {
-  cleanupTests,
-  createUser,
-  flushAndRunServer,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { makeGetRequest } from '../../../../shared/extra-utils/requests/requests'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { cleanupTests, createSingleServer, makeGetRequest, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test debug API validators', function () {
   const path = '/api/v1/server/debug'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken = ''
 
   // ---------------------------------------------------------------
@@ -23,7 +14,7 @@ describe('Test debug API validators', function () {
   before(async function () {
     this.timeout(120000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -31,8 +22,8 @@ describe('Test debug API validators', function () {
       username: 'user1',
       password: 'my super password'
     }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(server, user)
+    await server.users.create({ username: user.username, password: user.password })
+    userAccessToken = await server.login.getAccessToken(user)
   })
 
   describe('When getting debug endpoint', function () {
@@ -41,7 +32,7 @@ describe('Test debug API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -50,7 +41,7 @@ describe('Test debug API validators', function () {
         url: server.url,
         path,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -60,7 +51,7 @@ describe('Test debug API validators', function () {
         path,
         token: server.accessToken,
         query: { startDate: new Date().toISOString() },
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
diff --git a/server/tests/api/check-params/follows.ts b/server/tests/api/check-params/follows.ts
index c03dd5c9c..2bc9f6b96 100644
--- a/server/tests/api/check-params/follows.ts
+++ b/server/tests/api/check-params/follows.ts
@@ -1,33 +1,29 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
-import {
-  cleanupTests,
-  createUser,
-  flushAndRunServer,
-  makeDeleteRequest, makeGetRequest,
-  makePostBodyRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+  checkBadStartPagination,
+  cleanupTests,
+  createSingleServer,
+  makeDeleteRequest,
+  makeGetRequest,
+  makePostBodyRequest,
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test server follows API validators', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
   })
@@ -36,64 +32,68 @@ describe('Test server follows API validators', function () {
     let userAccessToken = null
 
     before(async function () {
-      const user = {
-        username: 'user1',
-        password: 'password'
-      }
-
-      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-      userAccessToken = await userLogin(server, user)
+      userAccessToken = await server.users.generateUserAndToken('user1')
     })
 
     describe('When adding follows', function () {
       const path = '/api/v1/server/following'
 
-      it('Should fail without hosts', async function () {
+      it('Should fail with nothing', async function () {
         await makePostBodyRequest({
           url: server.url,
           path,
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       })
 
-      it('Should fail if hosts is not an array', async function () {
+      it('Should fail if hosts is not composed by hosts', async function () {
         await makePostBodyRequest({
           url: server.url,
           path,
+          fields: { hosts: [ 'localhost:9002', 'localhost:coucou' ] },
           token: server.accessToken,
-          fields: { hosts: 'localhost:9002' },
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       })
 
-      it('Should fail if the array is not composed by hosts', async function () {
+      it('Should fail if hosts is composed with http schemes', async function () {
         await makePostBodyRequest({
           url: server.url,
           path,
-          fields: { hosts: [ 'localhost:9002', 'localhost:coucou' ] },
+          fields: { hosts: [ 'localhost:9002', 'http://localhost:9003' ] },
+          token: server.accessToken,
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
+        })
+      })
+
+      it('Should fail if hosts are not unique', async function () {
+        await makePostBodyRequest({
+          url: server.url,
+          path,
+          fields: { urls: [ 'localhost:9002', 'localhost:9002' ] },
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       })
 
-      it('Should fail if the array is composed with http schemes', async function () {
+      it('Should fail if handles is not composed by handles', async function () {
         await makePostBodyRequest({
           url: server.url,
           path,
-          fields: { hosts: [ 'localhost:9002', 'http://localhost:9003' ] },
+          fields: { handles: [ 'hello@example.com', 'localhost:9001' ] },
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       })
 
-      it('Should fail if hosts are not unique', async function () {
+      it('Should fail if handles are not unique', async function () {
         await makePostBodyRequest({
           url: server.url,
           path,
-          fields: { urls: [ 'localhost:9002', 'localhost:9002' ] },
+          fields: { urls: [ 'hello@example.com', 'hello@example.com' ] },
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       })
 
@@ -103,7 +103,7 @@ describe('Test server follows API validators', function () {
           path,
           fields: { hosts: [ 'localhost:9002' ] },
           token: 'fake_token',
-          statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401
         })
       })
 
@@ -113,7 +113,7 @@ describe('Test server follows API validators', function () {
           path,
           fields: { hosts: [ 'localhost:9002' ] },
           token: userAccessToken,
-          statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+          expectedStatus: HttpStatusCode.FORBIDDEN_403
         })
       })
     })
@@ -157,7 +157,7 @@ describe('Test server follows API validators', function () {
         await makeGetRequest({
           url: server.url,
           path,
-          statusCodeExpected: HttpStatusCode.OK_200,
+          expectedStatus: HttpStatusCode.OK_200,
           query: {
             state: 'accepted',
             actorType: 'Application'
@@ -206,7 +206,7 @@ describe('Test server follows API validators', function () {
         await makeGetRequest({
           url: server.url,
           path,
-          statusCodeExpected: HttpStatusCode.OK_200,
+          expectedStatus: HttpStatusCode.OK_200,
           query: {
             state: 'accepted'
           }
@@ -222,7 +222,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto@localhost:9002',
           token: 'fake_token',
-          statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401
         })
       })
 
@@ -231,7 +231,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto@localhost:9002',
           token: userAccessToken,
-          statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+          expectedStatus: HttpStatusCode.FORBIDDEN_403
         })
       })
 
@@ -240,7 +240,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto',
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       })
 
@@ -249,7 +249,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto@localhost:9003',
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+          expectedStatus: HttpStatusCode.NOT_FOUND_404
         })
       })
     })
@@ -262,7 +262,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto@localhost:9002/accept',
           token: 'fake_token',
-          statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401
         })
       })
 
@@ -271,7 +271,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto@localhost:9002/accept',
           token: userAccessToken,
-          statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+          expectedStatus: HttpStatusCode.FORBIDDEN_403
         })
       })
 
@@ -280,7 +280,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto/accept',
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       })
 
@@ -289,7 +289,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto@localhost:9003/accept',
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+          expectedStatus: HttpStatusCode.NOT_FOUND_404
         })
       })
     })
@@ -302,7 +302,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto@localhost:9002/reject',
           token: 'fake_token',
-          statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401
         })
       })
 
@@ -311,7 +311,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto@localhost:9002/reject',
           token: userAccessToken,
-          statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+          expectedStatus: HttpStatusCode.FORBIDDEN_403
         })
       })
 
@@ -320,7 +320,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto/reject',
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       })
 
@@ -329,7 +329,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/toto@localhost:9003/reject',
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+          expectedStatus: HttpStatusCode.NOT_FOUND_404
         })
       })
     })
@@ -342,7 +342,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/localhost:9002',
           token: 'fake_token',
-          statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401
         })
       })
 
@@ -351,7 +351,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/localhost:9002',
           token: userAccessToken,
-          statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+          expectedStatus: HttpStatusCode.FORBIDDEN_403
         })
       })
 
@@ -360,7 +360,7 @@ describe('Test server follows API validators', function () {
           url: server.url,
           path: path + '/example.com',
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+          expectedStatus: HttpStatusCode.NOT_FOUND_404
         })
       })
     })
diff --git a/server/tests/api/check-params/jobs.ts b/server/tests/api/check-params/jobs.ts
index 3c1d2049b..23d95d8e4 100644
--- a/server/tests/api/check-params/jobs.ts
+++ b/server/tests/api/check-params/jobs.ts
@@ -1,26 +1,21 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
-import {
-  cleanupTests,
-  createUser,
-  flushAndRunServer,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { makeGetRequest } from '../../../../shared/extra-utils/requests/requests'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+  checkBadStartPagination,
+  cleanupTests,
+  createSingleServer,
+  makeGetRequest,
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test jobs API validators', function () {
   const path = '/api/v1/jobs/failed'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken = ''
 
   // ---------------------------------------------------------------
@@ -28,7 +23,7 @@ describe('Test jobs API validators', function () {
   before(async function () {
     this.timeout(120000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -36,8 +31,8 @@ describe('Test jobs API validators', function () {
       username: 'user1',
       password: 'my super password'
     }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(server, user)
+    await server.users.create({ username: user.username, password: user.password })
+    userAccessToken = await server.login.getAccessToken(user)
   })
 
   describe('When listing jobs', function () {
@@ -77,7 +72,7 @@ describe('Test jobs API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -86,7 +81,7 @@ describe('Test jobs API validators', function () {
         url: server.url,
         path,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
diff --git a/server/tests/api/check-params/live.ts b/server/tests/api/check-params/live.ts
index 933d8abf2..700b4724d 100644
--- a/server/tests/api/check-params/live.ts
+++ b/server/tests/api/check-params/live.ts
@@ -2,69 +2,64 @@
 
 import 'mocha'
 import { omit } from 'lodash'
-import { LiveVideo, VideoCreateResult, VideoPrivacy } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   buildAbsoluteFixturePath,
   cleanupTests,
-  createUser,
-  flushAndRunServer,
-  getLive,
-  getMyUserInformation,
-  immutableAssign,
+  createSingleServer,
+  LiveCommand,
   makePostBodyRequest,
   makeUploadRequest,
-  runAndTestFfmpegStreamError,
+  PeerTubeServer,
   sendRTMPStream,
-  ServerInfo,
   setAccessTokensToServers,
-  stopFfmpeg,
-  updateCustomSubConfig,
-  updateLive,
-  uploadVideoAndGetId,
-  userLogin,
-  waitUntilLivePublished
-} from '../../../../shared/extra-utils'
+  stopFfmpeg
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoCreateResult, VideoPrivacy } from '@shared/models'
 
 describe('Test video lives API validator', function () {
   const path = '/api/v1/videos/live'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken = ''
   let channelId: number
   let video: VideoCreateResult
   let videoIdNotLive: number
+  let command: LiveCommand
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
-    await updateCustomSubConfig(server.url, server.accessToken, {
-      live: {
-        enabled: true,
-        maxInstanceLives: 20,
-        maxUserLives: 20,
-        allowReplay: true
+    await server.config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          maxInstanceLives: 20,
+          maxUserLives: 20,
+          allowReplay: true
+        }
       }
     })
 
     const username = 'user1'
     const password = 'my super password'
-    await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
-    userAccessToken = await userLogin(server, { username, password })
+    await server.users.create({ username: username, password: password })
+    userAccessToken = await server.login.getAccessToken({ username, password })
 
     {
-      const res = await getMyUserInformation(server.url, server.accessToken)
-      channelId = res.body.videoChannels[0].id
+      const { videoChannels } = await server.users.getMyInfo()
+      channelId = videoChannels[0].id
     }
 
     {
-      videoIdNotLive = (await uploadVideoAndGetId({ server, videoName: 'not live' })).id
+      videoIdNotLive = (await server.videos.quickUpload({ name: 'not live' })).id
     }
+
+    command = server.live
   })
 
   describe('When creating a live', function () {
@@ -96,37 +91,37 @@ describe('Test video lives API validator', function () {
     })
 
     it('Should fail with a long name', async function () {
-      const fields = immutableAssign(baseCorrectParams, { name: 'super'.repeat(65) })
+      const fields = { ...baseCorrectParams, name: 'super'.repeat(65) }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad category', async function () {
-      const fields = immutableAssign(baseCorrectParams, { category: 125 })
+      const fields = { ...baseCorrectParams, category: 125 }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad licence', async function () {
-      const fields = immutableAssign(baseCorrectParams, { licence: 125 })
+      const fields = { ...baseCorrectParams, licence: 125 }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad language', async function () {
-      const fields = immutableAssign(baseCorrectParams, { language: 'a'.repeat(15) })
+      const fields = { ...baseCorrectParams, language: 'a'.repeat(15) }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a long description', async function () {
-      const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(2500) })
+      const fields = { ...baseCorrectParams, description: 'super'.repeat(2500) }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a long support text', async function () {
-      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
+      const fields = { ...baseCorrectParams, support: 'super'.repeat(201) }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -138,7 +133,7 @@ describe('Test video lives API validator', function () {
     })
 
     it('Should fail with a bad channel', async function () {
-      const fields = immutableAssign(baseCorrectParams, { channelId: 545454 })
+      const fields = { ...baseCorrectParams, channelId: 545454 }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -148,31 +143,31 @@ describe('Test video lives API validator', function () {
         username: 'fake',
         password: 'fake_password'
       }
-      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+      await server.users.create({ username: user.username, password: user.password })
 
-      const accessTokenUser = await userLogin(server, user)
-      const res = await getMyUserInformation(server.url, accessTokenUser)
-      const customChannelId = res.body.videoChannels[0].id
+      const accessTokenUser = await server.login.getAccessToken(user)
+      const { videoChannels } = await server.users.getMyInfo({ token: accessTokenUser })
+      const customChannelId = videoChannels[0].id
 
-      const fields = immutableAssign(baseCorrectParams, { channelId: customChannelId })
+      const fields = { ...baseCorrectParams, channelId: customChannelId }
 
       await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields })
     })
 
     it('Should fail with too many tags', async function () {
-      const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] })
+      const fields = { ...baseCorrectParams, tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a tag length too low', async function () {
-      const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 't' ] })
+      const fields = { ...baseCorrectParams, tags: [ 'tag1', 't' ] }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a tag length too big', async function () {
-      const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] })
+      const fields = { ...baseCorrectParams, tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -214,7 +209,7 @@ describe('Test video lives API validator', function () {
     })
 
     it('Should fail with save replay and permanent live set to true', async function () {
-      const fields = immutableAssign(baseCorrectParams, { saveReplay: true, permanentLive: true })
+      const fields = { ...baseCorrectParams, saveReplay: true, permanentLive: true }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -227,16 +222,18 @@ describe('Test video lives API validator', function () {
         path,
         token: server.accessToken,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       video = res.body.video
     })
 
     it('Should forbid if live is disabled', async function () {
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        live: {
-          enabled: false
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          live: {
+            enabled: false
+          }
         }
       })
 
@@ -245,17 +242,19 @@ describe('Test video lives API validator', function () {
         path,
         token: server.accessToken,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
     it('Should forbid to save replay if not enabled by the admin', async function () {
-      const fields = immutableAssign(baseCorrectParams, { saveReplay: true })
-
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        live: {
-          enabled: true,
-          allowReplay: false
+      const fields = { ...baseCorrectParams, saveReplay: true }
+
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          live: {
+            enabled: true,
+            allowReplay: false
+          }
         }
       })
 
@@ -264,17 +263,19 @@ describe('Test video lives API validator', function () {
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
     it('Should allow to save replay if enabled by the admin', async function () {
-      const fields = immutableAssign(baseCorrectParams, { saveReplay: true })
-
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        live: {
-          enabled: true,
-          allowReplay: true
+      const fields = { ...baseCorrectParams, saveReplay: true }
+
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          live: {
+            enabled: true,
+            allowReplay: true
+          }
         }
       })
 
@@ -283,15 +284,17 @@ describe('Test video lives API validator', function () {
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
 
     it('Should not allow live if max instance lives is reached', async function () {
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        live: {
-          enabled: true,
-          maxInstanceLives: 1
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          live: {
+            enabled: true,
+            maxInstanceLives: 1
+          }
         }
       })
 
@@ -300,16 +303,18 @@ describe('Test video lives API validator', function () {
         path,
         token: server.accessToken,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
     it('Should not allow live if max user lives is reached', async function () {
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        live: {
-          enabled: true,
-          maxInstanceLives: 20,
-          maxUserLives: 1
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          live: {
+            enabled: true,
+            maxInstanceLives: 20,
+            maxUserLives: 1
+          }
         }
       })
 
@@ -318,7 +323,7 @@ describe('Test video lives API validator', function () {
         path,
         token: server.accessToken,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
   })
@@ -326,110 +331,112 @@ describe('Test video lives API validator', function () {
   describe('When getting live information', function () {
 
     it('Should fail without access token', async function () {
-      await getLive(server.url, '', video.id, HttpStatusCode.UNAUTHORIZED_401)
+      await command.get({ token: '', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a bad access token', async function () {
-      await getLive(server.url, 'toto', video.id, HttpStatusCode.UNAUTHORIZED_401)
+      await command.get({ token: 'toto', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with access token of another user', async function () {
-      await getLive(server.url, userAccessToken, video.id, HttpStatusCode.FORBIDDEN_403)
+      await command.get({ token: userAccessToken, videoId: video.id, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a bad video id', async function () {
-      await getLive(server.url, server.accessToken, 'toto', HttpStatusCode.BAD_REQUEST_400)
+      await command.get({ videoId: 'toto', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with an unknown video id', async function () {
-      await getLive(server.url, server.accessToken, 454555, HttpStatusCode.NOT_FOUND_404)
+      await command.get({ videoId: 454555, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a non live video', async function () {
-      await getLive(server.url, server.accessToken, videoIdNotLive, HttpStatusCode.NOT_FOUND_404)
+      await command.get({ videoId: videoIdNotLive, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await getLive(server.url, server.accessToken, video.id)
-      await getLive(server.url, server.accessToken, video.shortUUID)
+      await command.get({ videoId: video.id })
+      await command.get({ videoId: video.uuid })
+      await command.get({ videoId: video.shortUUID })
     })
   })
 
   describe('When updating live information', async function () {
 
     it('Should fail without access token', async function () {
-      await updateLive(server.url, '', video.id, {}, HttpStatusCode.UNAUTHORIZED_401)
+      await command.update({ token: '', videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a bad access token', async function () {
-      await updateLive(server.url, 'toto', video.id, {}, HttpStatusCode.UNAUTHORIZED_401)
+      await command.update({ token: 'toto', videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with access token of another user', async function () {
-      await updateLive(server.url, userAccessToken, video.id, {}, HttpStatusCode.FORBIDDEN_403)
+      await command.update({ token: userAccessToken, videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a bad video id', async function () {
-      await updateLive(server.url, server.accessToken, 'toto', {}, HttpStatusCode.BAD_REQUEST_400)
+      await command.update({ videoId: 'toto', fields: {}, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with an unknown video id', async function () {
-      await updateLive(server.url, server.accessToken, 454555, {}, HttpStatusCode.NOT_FOUND_404)
+      await command.update({ videoId: 454555, fields: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a non live video', async function () {
-      await updateLive(server.url, server.accessToken, videoIdNotLive, {}, HttpStatusCode.NOT_FOUND_404)
+      await command.update({ videoId: videoIdNotLive, fields: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with save replay and permanent live set to true', async function () {
       const fields = { saveReplay: true, permanentLive: true }
 
-      await updateLive(server.url, server.accessToken, video.id, fields, HttpStatusCode.BAD_REQUEST_400)
+      await command.update({ videoId: video.id, fields, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await updateLive(server.url, server.accessToken, video.id, { saveReplay: false })
-      await updateLive(server.url, server.accessToken, video.shortUUID, { saveReplay: false })
+      await command.update({ videoId: video.id, fields: { saveReplay: false } })
+      await command.update({ videoId: video.uuid, fields: { saveReplay: false } })
+      await command.update({ videoId: video.shortUUID, fields: { saveReplay: false } })
     })
 
     it('Should fail to update replay status if replay is not allowed on the instance', async function () {
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        live: {
-          enabled: true,
-          allowReplay: false
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          live: {
+            enabled: true,
+            allowReplay: false
+          }
         }
       })
 
-      await updateLive(server.url, server.accessToken, video.id, { saveReplay: true }, HttpStatusCode.FORBIDDEN_403)
+      await command.update({ videoId: video.id, fields: { saveReplay: true }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail to update a live if it has already started', async function () {
       this.timeout(40000)
 
-      const resLive = await getLive(server.url, server.accessToken, video.id)
-      const live: LiveVideo = resLive.body
+      const live = await command.get({ videoId: video.id })
 
-      const command = sendRTMPStream(live.rtmpUrl, live.streamKey)
+      const ffmpegCommand = sendRTMPStream(live.rtmpUrl, live.streamKey)
 
-      await waitUntilLivePublished(server.url, server.accessToken, video.id)
-      await updateLive(server.url, server.accessToken, video.id, {}, HttpStatusCode.BAD_REQUEST_400)
+      await command.waitUntilPublished({ videoId: video.id })
+      await command.update({ videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
-      await stopFfmpeg(command)
+      await stopFfmpeg(ffmpegCommand)
     })
 
     it('Should fail to stream twice in the save live', async function () {
       this.timeout(40000)
 
-      const resLive = await getLive(server.url, server.accessToken, video.id)
-      const live: LiveVideo = resLive.body
+      const live = await command.get({ videoId: video.id })
 
-      const command = sendRTMPStream(live.rtmpUrl, live.streamKey)
+      const ffmpegCommand = sendRTMPStream(live.rtmpUrl, live.streamKey)
 
-      await waitUntilLivePublished(server.url, server.accessToken, video.id)
+      await command.waitUntilPublished({ videoId: video.id })
 
-      await runAndTestFfmpegStreamError(server.url, server.accessToken, video.id, true)
+      await command.runAndTestStreamError({ videoId: video.id, shouldHaveError: true })
 
-      await stopFfmpeg(command)
+      await stopFfmpeg(ffmpegCommand)
     })
   })
 
diff --git a/server/tests/api/check-params/logs.ts b/server/tests/api/check-params/logs.ts
index dac1e6b98..05372257a 100644
--- a/server/tests/api/check-params/logs.ts
+++ b/server/tests/api/check-params/logs.ts
@@ -1,21 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
-import {
-  cleanupTests,
-  createUser,
-  flushAndRunServer,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { makeGetRequest } from '../../../../shared/extra-utils/requests/requests'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { cleanupTests, createSingleServer, makeGetRequest, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test logs API validators', function () {
   const path = '/api/v1/server/logs'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken = ''
 
   // ---------------------------------------------------------------
@@ -23,7 +14,7 @@ describe('Test logs API validators', function () {
   before(async function () {
     this.timeout(120000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -31,8 +22,8 @@ describe('Test logs API validators', function () {
       username: 'user1',
       password: 'my super password'
     }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(server, user)
+    await server.users.create({ username: user.username, password: user.password })
+    userAccessToken = await server.login.getAccessToken(user)
   })
 
   describe('When getting logs', function () {
@@ -41,7 +32,7 @@ describe('Test logs API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -50,7 +41,7 @@ describe('Test logs API validators', function () {
         url: server.url,
         path,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -59,7 +50,7 @@ describe('Test logs API validators', function () {
         url: server.url,
         path,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -69,7 +60,7 @@ describe('Test logs API validators', function () {
         path,
         token: server.accessToken,
         query: { startDate: 'toto' },
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -79,7 +70,7 @@ describe('Test logs API validators', function () {
         path,
         token: server.accessToken,
         query: { startDate: new Date().toISOString(), endDate: 'toto' },
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -89,7 +80,7 @@ describe('Test logs API validators', function () {
         path,
         token: server.accessToken,
         query: { startDate: new Date().toISOString(), level: 'toto' },
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -99,7 +90,7 @@ describe('Test logs API validators', function () {
         path,
         token: server.accessToken,
         query: { startDate: new Date().toISOString() },
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
diff --git a/server/tests/api/check-params/plugins.ts b/server/tests/api/check-params/plugins.ts
index a833fe6ff..33f84ecbc 100644
--- a/server/tests/api/check-params/plugins.ts
+++ b/server/tests/api/check-params/plugins.ts
@@ -1,27 +1,22 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { HttpStatusCode } from '@shared/core-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination,
   cleanupTests,
-  createUser,
-  flushAndRunServer,
-  immutableAssign,
-  installPlugin,
+  createSingleServer,
   makeGetRequest,
   makePostBodyRequest,
   makePutBodyRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
+  PeerTubeServer,
+  setAccessTokensToServers
 } from '@shared/extra-utils'
-import { PeerTubePlugin, PluginType } from '@shared/models'
+import { HttpStatusCode, PeerTubePlugin, PluginType } from '@shared/models'
 
 describe('Test server plugins API validators', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken = null
 
   const npmPlugin = 'peertube-plugin-hello-world'
@@ -37,7 +32,7 @@ describe('Test server plugins API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -46,17 +41,17 @@ describe('Test server plugins API validators', function () {
       password: 'password'
     }
 
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(server, user)
+    await server.users.create({ username: user.username, password: user.password })
+    userAccessToken = await server.login.getAccessToken(user)
 
     {
-      const res = await installPlugin({ url: server.url, accessToken: server.accessToken, npmName: npmPlugin })
+      const res = await server.plugins.install({ npmName: npmPlugin })
       const plugin = res.body as PeerTubePlugin
       npmVersion = plugin.version
     }
 
     {
-      const res = await installPlugin({ url: server.url, accessToken: server.accessToken, npmName: themePlugin })
+      const res = await server.plugins.install({ npmName: themePlugin })
       const plugin = res.body as PeerTubePlugin
       themeVersion = plugin.version
     }
@@ -74,7 +69,7 @@ describe('Test server plugins API validators', function () {
       ]
 
       for (const p of paths) {
-        await makeGetRequest({ url: server.url, path: p, statusCodeExpected: HttpStatusCode.NOT_FOUND_404 })
+        await makeGetRequest({ url: server.url, path: p, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
     })
 
@@ -82,7 +77,7 @@ describe('Test server plugins API validators', function () {
       await makeGetRequest({
         url: server.url,
         path: '/themes/' + pluginName + '/' + npmVersion + '/static/images/chocobo.png',
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -97,7 +92,7 @@ describe('Test server plugins API validators', function () {
       ]
 
       for (const p of paths) {
-        await makeGetRequest({ url: server.url, path: p, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+        await makeGetRequest({ url: server.url, path: p, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
       }
     })
 
@@ -111,14 +106,14 @@ describe('Test server plugins API validators', function () {
       ]
 
       for (const p of paths) {
-        await makeGetRequest({ url: server.url, path: p, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+        await makeGetRequest({ url: server.url, path: p, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
       }
     })
 
     it('Should fail with an unknown auth name', async function () {
       const path = '/plugins/' + pluginName + '/' + npmVersion + '/auth/bad-auth'
 
-      await makeGetRequest({ url: server.url, path, statusCodeExpected: HttpStatusCode.NOT_FOUND_404 })
+      await makeGetRequest({ url: server.url, path, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with an unknown static file', async function () {
@@ -130,7 +125,7 @@ describe('Test server plugins API validators', function () {
       ]
 
       for (const p of paths) {
-        await makeGetRequest({ url: server.url, path: p, statusCodeExpected: HttpStatusCode.NOT_FOUND_404 })
+        await makeGetRequest({ url: server.url, path: p, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
     })
 
@@ -138,7 +133,7 @@ describe('Test server plugins API validators', function () {
       await makeGetRequest({
         url: server.url,
         path: '/themes/' + themeName + '/' + themeVersion + '/css/assets/fake.css',
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -152,11 +147,11 @@ describe('Test server plugins API validators', function () {
       ]
 
       for (const p of paths) {
-        await makeGetRequest({ url: server.url, path: p, statusCodeExpected: HttpStatusCode.OK_200 })
+        await makeGetRequest({ url: server.url, path: p, expectedStatus: HttpStatusCode.OK_200 })
       }
 
       const authPath = '/plugins/' + pluginName + '/' + npmVersion + '/auth/fake-auth'
-      await makeGetRequest({ url: server.url, path: authPath, statusCodeExpected: HttpStatusCode.FOUND_302 })
+      await makeGetRequest({ url: server.url, path: authPath, expectedStatus: HttpStatusCode.FOUND_302 })
     })
   })
 
@@ -174,7 +169,7 @@ describe('Test server plugins API validators', function () {
         path,
         token: 'fake_token',
         query: baseQuery,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -184,7 +179,7 @@ describe('Test server plugins API validators', function () {
         path,
         token: userAccessToken,
         query: baseQuery,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -201,7 +196,7 @@ describe('Test server plugins API validators', function () {
     })
 
     it('Should fail with an invalid plugin type', async function () {
-      const query = immutableAssign(baseQuery, { pluginType: 5 })
+      const query = { ...baseQuery, pluginType: 5 }
 
       await makeGetRequest({
         url: server.url,
@@ -212,7 +207,7 @@ describe('Test server plugins API validators', function () {
     })
 
     it('Should fail with an invalid current peertube engine', async function () {
-      const query = immutableAssign(baseQuery, { currentPeerTubeEngine: '1.0' })
+      const query = { ...baseQuery, currentPeerTubeEngine: '1.0' }
 
       await makeGetRequest({
         url: server.url,
@@ -228,7 +223,7 @@ describe('Test server plugins API validators', function () {
         path,
         token: server.accessToken,
         query: baseQuery,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -245,7 +240,7 @@ describe('Test server plugins API validators', function () {
         path,
         token: 'fake_token',
         query: baseQuery,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -255,7 +250,7 @@ describe('Test server plugins API validators', function () {
         path,
         token: userAccessToken,
         query: baseQuery,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -272,7 +267,7 @@ describe('Test server plugins API validators', function () {
     })
 
     it('Should fail with an invalid plugin type', async function () {
-      const query = immutableAssign(baseQuery, { pluginType: 5 })
+      const query = { ...baseQuery, pluginType: 5 }
 
       await makeGetRequest({
         url: server.url,
@@ -288,7 +283,7 @@ describe('Test server plugins API validators', function () {
         path,
         token: server.accessToken,
         query: baseQuery,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -302,7 +297,7 @@ describe('Test server plugins API validators', function () {
           url: server.url,
           path: path + suffix,
           token: 'fake_token',
-          statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401
         })
       }
     })
@@ -313,7 +308,7 @@ describe('Test server plugins API validators', function () {
           url: server.url,
           path: path + suffix,
           token: userAccessToken,
-          statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+          expectedStatus: HttpStatusCode.FORBIDDEN_403
         })
       }
     })
@@ -324,7 +319,7 @@ describe('Test server plugins API validators', function () {
           url: server.url,
           path: path + suffix,
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       }
 
@@ -333,7 +328,7 @@ describe('Test server plugins API validators', function () {
           url: server.url,
           path: path + suffix,
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       }
     })
@@ -344,7 +339,7 @@ describe('Test server plugins API validators', function () {
           url: server.url,
           path: path + suffix,
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+          expectedStatus: HttpStatusCode.NOT_FOUND_404
         })
       }
     })
@@ -355,7 +350,7 @@ describe('Test server plugins API validators', function () {
           url: server.url,
           path: path + suffix,
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.OK_200
+          expectedStatus: HttpStatusCode.OK_200
         })
       }
     })
@@ -371,7 +366,7 @@ describe('Test server plugins API validators', function () {
         path: path + npmPlugin + '/settings',
         fields: { settings },
         token: 'fake_token',
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -381,7 +376,7 @@ describe('Test server plugins API validators', function () {
         path: path + npmPlugin + '/settings',
         fields: { settings },
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -391,7 +386,7 @@ describe('Test server plugins API validators', function () {
         path: path + 'toto/settings',
         fields: { settings },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
 
       await makePutBodyRequest({
@@ -399,7 +394,7 @@ describe('Test server plugins API validators', function () {
         path: path + 'peertube-plugin-TOTO/settings',
         fields: { settings },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -409,7 +404,7 @@ describe('Test server plugins API validators', function () {
         path: path + 'peertube-plugin-toto/settings',
         fields: { settings },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -419,7 +414,7 @@ describe('Test server plugins API validators', function () {
         path: path + npmPlugin + '/settings',
         fields: { settings },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -434,7 +429,7 @@ describe('Test server plugins API validators', function () {
           path: path + suffix,
           fields: { npmName: npmPlugin },
           token: 'fake_token',
-          statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401
         })
       }
     })
@@ -446,7 +441,7 @@ describe('Test server plugins API validators', function () {
           path: path + suffix,
           fields: { npmName: npmPlugin },
           token: userAccessToken,
-          statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+          expectedStatus: HttpStatusCode.FORBIDDEN_403
         })
       }
     })
@@ -458,7 +453,7 @@ describe('Test server plugins API validators', function () {
           path: path + suffix,
           fields: { npmName: 'toto' },
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       }
 
@@ -468,7 +463,7 @@ describe('Test server plugins API validators', function () {
           path: path + suffix,
           fields: { npmName: 'peertube-plugin-TOTO' },
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       }
     })
@@ -488,7 +483,7 @@ describe('Test server plugins API validators', function () {
           path: path + obj.suffix,
           fields: { npmName: npmPlugin },
           token: server.accessToken,
-          statusCodeExpected: obj.status
+          expectedStatus: obj.status
         })
       }
     })
diff --git a/server/tests/api/check-params/redundancy.ts b/server/tests/api/check-params/redundancy.ts
index dac6938de..d9f905549 100644
--- a/server/tests/api/check-params/redundancy.ts
+++ b/server/tests/api/check-params/redundancy.ts
@@ -1,30 +1,25 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { VideoCreateResult } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination,
   cleanupTests,
-  createUser,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getVideo,
   makeDeleteRequest,
   makeGetRequest,
   makePostBodyRequest,
   makePutBodyRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  uploadVideoAndGetId,
-  userLogin,
   waitJobs
-} from '../../../../shared/extra-utils'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoCreateResult } from '@shared/models'
 
 describe('Test server redundancy API validators', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let userAccessToken = null
   let videoIdLocal: number
   let videoRemote: VideoCreateResult
@@ -34,7 +29,7 @@ describe('Test server redundancy API validators', function () {
   before(async function () {
     this.timeout(80000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
     await doubleFollow(servers[0], servers[1])
@@ -44,17 +39,16 @@ describe('Test server redundancy API validators', function () {
       password: 'password'
     }
 
-    await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(servers[0], user)
+    await servers[0].users.create({ username: user.username, password: user.password })
+    userAccessToken = await servers[0].login.getAccessToken(user)
 
-    videoIdLocal = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video' })).id
+    videoIdLocal = (await servers[0].videos.quickUpload({ name: 'video' })).id
 
-    const remoteUUID = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video' })).uuid
+    const remoteUUID = (await servers[1].videos.quickUpload({ name: 'video' })).uuid
 
     await waitJobs(servers)
 
-    const resVideo = await getVideo(servers[0].url, remoteUUID)
-    videoRemote = resVideo.body
+    videoRemote = await servers[0].videos.get({ id: remoteUUID })
   })
 
   describe('When listing redundancies', function () {
@@ -69,11 +63,11 @@ describe('Test server redundancy API validators', function () {
     })
 
     it('Should fail with an invalid token', async function () {
-      await makeGetRequest({ url, path, token: 'fake_token', statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makeGetRequest({ url, path, token: 'fake_token', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail if the user is not an administrator', async function () {
-      await makeGetRequest({ url, path, token: userAccessToken, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
+      await makeGetRequest({ url, path, token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a bad start pagination', async function () {
@@ -97,7 +91,7 @@ describe('Test server redundancy API validators', function () {
     })
 
     it('Should succeed with the correct params', async function () {
-      await makeGetRequest({ url, path, token, query: { target: 'my-videos' }, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url, path, token, query: { target: 'my-videos' }, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -113,11 +107,11 @@ describe('Test server redundancy API validators', function () {
     })
 
     it('Should fail with an invalid token', async function () {
-      await makePostBodyRequest({ url, path, token: 'fake_token', statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makePostBodyRequest({ url, path, token: 'fake_token', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail if the user is not an administrator', async function () {
-      await makePostBodyRequest({ url, path, token: userAccessToken, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
+      await makePostBodyRequest({ url, path, token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail without a video id', async function () {
@@ -129,7 +123,7 @@ describe('Test server redundancy API validators', function () {
     })
 
     it('Should fail with a not found video id', async function () {
-      await makePostBodyRequest({ url, path, token, fields: { videoId: 6565 }, statusCodeExpected: HttpStatusCode.NOT_FOUND_404 })
+      await makePostBodyRequest({ url, path, token, fields: { videoId: 6565 }, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a local a video id', async function () {
@@ -142,7 +136,7 @@ describe('Test server redundancy API validators', function () {
         path,
         token,
         fields: { videoId: videoRemote.shortUUID },
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
 
@@ -156,7 +150,7 @@ describe('Test server redundancy API validators', function () {
         path,
         token,
         fields: { videoId: videoRemote.uuid },
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
   })
@@ -173,11 +167,11 @@ describe('Test server redundancy API validators', function () {
     })
 
     it('Should fail with an invalid token', async function () {
-      await makeDeleteRequest({ url, path: path + '1', token: 'fake_token', statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makeDeleteRequest({ url, path: path + '1', token: 'fake_token', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail if the user is not an administrator', async function () {
-      await makeDeleteRequest({ url, path: path + '1', token: userAccessToken, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
+      await makeDeleteRequest({ url, path: path + '1', token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with an incorrect video id', async function () {
@@ -185,7 +179,7 @@ describe('Test server redundancy API validators', function () {
     })
 
     it('Should fail with a not found video redundancy', async function () {
-      await makeDeleteRequest({ url, path: path + '454545', token, statusCodeExpected: HttpStatusCode.NOT_FOUND_404 })
+      await makeDeleteRequest({ url, path: path + '454545', token, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
   })
 
@@ -198,7 +192,7 @@ describe('Test server redundancy API validators', function () {
         path: path + '/localhost:' + servers[1].port,
         fields: { redundancyAllowed: true },
         token: 'fake_token',
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -208,7 +202,7 @@ describe('Test server redundancy API validators', function () {
         path: path + '/localhost:' + servers[1].port,
         fields: { redundancyAllowed: true },
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -218,7 +212,7 @@ describe('Test server redundancy API validators', function () {
         path: path + '/example.com',
         fields: { redundancyAllowed: true },
         token: servers[0].accessToken,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -228,7 +222,7 @@ describe('Test server redundancy API validators', function () {
         path: path + '/localhost:' + servers[1].port,
         fields: { blabla: true },
         token: servers[0].accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -238,7 +232,7 @@ describe('Test server redundancy API validators', function () {
         path: path + '/localhost:' + servers[1].port,
         fields: { redundancyAllowed: true },
         token: servers[0].accessToken,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
diff --git a/server/tests/api/check-params/search.ts b/server/tests/api/check-params/search.ts
index 20ad46cff..cc15d2593 100644
--- a/server/tests/api/check-params/search.ts
+++ b/server/tests/api/check-params/search.ts
@@ -2,41 +2,39 @@
 
 import 'mocha'
 import {
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   cleanupTests,
-  flushAndRunServer,
-  immutableAssign,
+  createSingleServer,
   makeGetRequest,
-  ServerInfo,
-  updateCustomSubConfig,
+  PeerTubeServer,
   setAccessTokensToServers
-} from '../../../../shared/extra-utils'
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-
-function updateSearchIndex (server: ServerInfo, enabled: boolean, disableLocalSearch = false) {
-  return updateCustomSubConfig(server.url, server.accessToken, {
-    search: {
-      searchIndex: {
-        enabled,
-        disableLocalSearch
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
+
+function updateSearchIndex (server: PeerTubeServer, enabled: boolean, disableLocalSearch = false) {
+  return server.config.updateCustomSubConfig({
+    newConfig: {
+      search: {
+        searchIndex: {
+          enabled,
+          disableLocalSearch
+        }
       }
     }
   })
 }
 
 describe('Test videos API validator', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
   })
 
@@ -59,84 +57,104 @@ describe('Test videos API validator', function () {
       await checkBadSortPagination(server.url, path, null, query)
     })
 
-    it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path, query, statusCodeExpected: HttpStatusCode.OK_200 })
+    it('Should succeed with the correct parameters', async function () {
+      await makeGetRequest({ url: server.url, path, query, expectedStatus: HttpStatusCode.OK_200 })
     })
 
     it('Should fail with an invalid category', async function () {
-      const customQuery1 = immutableAssign(query, { categoryOneOf: [ 'aa', 'b' ] })
-      await makeGetRequest({ url: server.url, path, query: customQuery1, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+      const customQuery1 = { ...query, categoryOneOf: [ 'aa', 'b' ] }
+      await makeGetRequest({ url: server.url, path, query: customQuery1, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
-      const customQuery2 = immutableAssign(query, { categoryOneOf: 'a' })
-      await makeGetRequest({ url: server.url, path, query: customQuery2, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+      const customQuery2 = { ...query, categoryOneOf: 'a' }
+      await makeGetRequest({ url: server.url, path, query: customQuery2, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should succeed with a valid category', async function () {
-      const customQuery1 = immutableAssign(query, { categoryOneOf: [ 1, 7 ] })
-      await makeGetRequest({ url: server.url, path, query: customQuery1, statusCodeExpected: HttpStatusCode.OK_200 })
+      const customQuery1 = { ...query, categoryOneOf: [ 1, 7 ] }
+      await makeGetRequest({ url: server.url, path, query: customQuery1, expectedStatus: HttpStatusCode.OK_200 })
 
-      const customQuery2 = immutableAssign(query, { categoryOneOf: 1 })
-      await makeGetRequest({ url: server.url, path, query: customQuery2, statusCodeExpected: HttpStatusCode.OK_200 })
+      const customQuery2 = { ...query, categoryOneOf: 1 }
+      await makeGetRequest({ url: server.url, path, query: customQuery2, expectedStatus: HttpStatusCode.OK_200 })
     })
 
     it('Should fail with an invalid licence', async function () {
-      const customQuery1 = immutableAssign(query, { licenceOneOf: [ 'aa', 'b' ] })
-      await makeGetRequest({ url: server.url, path, query: customQuery1, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+      const customQuery1 = { ...query, licenceOneOf: [ 'aa', 'b' ] }
+      await makeGetRequest({ url: server.url, path, query: customQuery1, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
-      const customQuery2 = immutableAssign(query, { licenceOneOf: 'a' })
-      await makeGetRequest({ url: server.url, path, query: customQuery2, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+      const customQuery2 = { ...query, licenceOneOf: 'a' }
+      await makeGetRequest({ url: server.url, path, query: customQuery2, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should succeed with a valid licence', async function () {
-      const customQuery1 = immutableAssign(query, { licenceOneOf: [ 1, 2 ] })
-      await makeGetRequest({ url: server.url, path, query: customQuery1, statusCodeExpected: HttpStatusCode.OK_200 })
+      const customQuery1 = { ...query, licenceOneOf: [ 1, 2 ] }
+      await makeGetRequest({ url: server.url, path, query: customQuery1, expectedStatus: HttpStatusCode.OK_200 })
 
-      const customQuery2 = immutableAssign(query, { licenceOneOf: 1 })
-      await makeGetRequest({ url: server.url, path, query: customQuery2, statusCodeExpected: HttpStatusCode.OK_200 })
+      const customQuery2 = { ...query, licenceOneOf: 1 }
+      await makeGetRequest({ url: server.url, path, query: customQuery2, expectedStatus: HttpStatusCode.OK_200 })
     })
 
     it('Should succeed with a valid language', async function () {
-      const customQuery1 = immutableAssign(query, { languageOneOf: [ 'fr', 'en' ] })
-      await makeGetRequest({ url: server.url, path, query: customQuery1, statusCodeExpected: HttpStatusCode.OK_200 })
+      const customQuery1 = { ...query, languageOneOf: [ 'fr', 'en' ] }
+      await makeGetRequest({ url: server.url, path, query: customQuery1, expectedStatus: HttpStatusCode.OK_200 })
 
-      const customQuery2 = immutableAssign(query, { languageOneOf: 'fr' })
-      await makeGetRequest({ url: server.url, path, query: customQuery2, statusCodeExpected: HttpStatusCode.OK_200 })
+      const customQuery2 = { ...query, languageOneOf: 'fr' }
+      await makeGetRequest({ url: server.url, path, query: customQuery2, expectedStatus: HttpStatusCode.OK_200 })
     })
 
     it('Should succeed with valid tags', async function () {
-      const customQuery1 = immutableAssign(query, { tagsOneOf: [ 'tag1', 'tag2' ] })
-      await makeGetRequest({ url: server.url, path, query: customQuery1, statusCodeExpected: HttpStatusCode.OK_200 })
+      const customQuery1 = { ...query, tagsOneOf: [ 'tag1', 'tag2' ] }
+      await makeGetRequest({ url: server.url, path, query: customQuery1, expectedStatus: HttpStatusCode.OK_200 })
 
-      const customQuery2 = immutableAssign(query, { tagsOneOf: 'tag1' })
-      await makeGetRequest({ url: server.url, path, query: customQuery2, statusCodeExpected: HttpStatusCode.OK_200 })
+      const customQuery2 = { ...query, tagsOneOf: 'tag1' }
+      await makeGetRequest({ url: server.url, path, query: customQuery2, expectedStatus: HttpStatusCode.OK_200 })
 
-      const customQuery3 = immutableAssign(query, { tagsAllOf: [ 'tag1', 'tag2' ] })
-      await makeGetRequest({ url: server.url, path, query: customQuery3, statusCodeExpected: HttpStatusCode.OK_200 })
+      const customQuery3 = { ...query, tagsAllOf: [ 'tag1', 'tag2' ] }
+      await makeGetRequest({ url: server.url, path, query: customQuery3, expectedStatus: HttpStatusCode.OK_200 })
 
-      const customQuery4 = immutableAssign(query, { tagsAllOf: 'tag1' })
-      await makeGetRequest({ url: server.url, path, query: customQuery4, statusCodeExpected: HttpStatusCode.OK_200 })
+      const customQuery4 = { ...query, tagsAllOf: 'tag1' }
+      await makeGetRequest({ url: server.url, path, query: customQuery4, expectedStatus: HttpStatusCode.OK_200 })
     })
 
     it('Should fail with invalid durations', async function () {
-      const customQuery1 = immutableAssign(query, { durationMin: 'hello' })
-      await makeGetRequest({ url: server.url, path, query: customQuery1, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+      const customQuery1 = { ...query, durationMin: 'hello' }
+      await makeGetRequest({ url: server.url, path, query: customQuery1, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
-      const customQuery2 = immutableAssign(query, { durationMax: 'hello' })
-      await makeGetRequest({ url: server.url, path, query: customQuery2, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+      const customQuery2 = { ...query, durationMax: 'hello' }
+      await makeGetRequest({ url: server.url, path, query: customQuery2, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with invalid dates', async function () {
-      const customQuery1 = immutableAssign(query, { startDate: 'hello' })
-      await makeGetRequest({ url: server.url, path, query: customQuery1, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+      const customQuery1 = { ...query, startDate: 'hello' }
+      await makeGetRequest({ url: server.url, path, query: customQuery1, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+
+      const customQuery2 = { ...query, endDate: 'hello' }
+      await makeGetRequest({ url: server.url, path, query: customQuery2, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+
+      const customQuery3 = { ...query, originallyPublishedStartDate: 'hello' }
+      await makeGetRequest({ url: server.url, path, query: customQuery3, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+
+      const customQuery4 = { ...query, originallyPublishedEndDate: 'hello' }
+      await makeGetRequest({ url: server.url, path, query: customQuery4, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should fail with an invalid host', async function () {
+      const customQuery = { ...query, host: '6565' }
+      await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
 
-      const customQuery2 = immutableAssign(query, { endDate: 'hello' })
-      await makeGetRequest({ url: server.url, path, query: customQuery2, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+    it('Should succeed with a host', async function () {
+      const customQuery = { ...query, host: 'example.com' }
+      await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.OK_200 })
+    })
 
-      const customQuery3 = immutableAssign(query, { originallyPublishedStartDate: 'hello' })
-      await makeGetRequest({ url: server.url, path, query: customQuery3, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+    it('Should fail with invalid uuids', async function () {
+      const customQuery = { ...query, uuids: [ '6565', 'dfd70b83-639f-4980-94af-304a56ab4b35' ] }
+      await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
 
-      const customQuery4 = immutableAssign(query, { originallyPublishedEndDate: 'hello' })
-      await makeGetRequest({ url: server.url, path, query: customQuery4, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+    it('Should succeed with valid uuids', async function () {
+      const customQuery = { ...query, uuids: [ 'dfd70b83-639f-4980-94af-304a56ab4b35' ] }
+      await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -144,7 +162,8 @@ describe('Test videos API validator', function () {
     const path = '/api/v1/search/video-playlists/'
 
     const query = {
-      search: 'coucou'
+      search: 'coucou',
+      host: 'example.com'
     }
 
     it('Should fail with a bad start pagination', async function () {
@@ -159,8 +178,17 @@ describe('Test videos API validator', function () {
       await checkBadSortPagination(server.url, path, null, query)
     })
 
-    it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path, query, statusCodeExpected: HttpStatusCode.OK_200 })
+    it('Should fail with an invalid host', async function () {
+      await makeGetRequest({ url: server.url, path, query: { ...query, host: '6565' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should fail with invalid uuids', async function () {
+      const customQuery = { ...query, uuids: [ '6565', 'dfd70b83-639f-4980-94af-304a56ab4b35' ] }
+      await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      await makeGetRequest({ url: server.url, path, query, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -168,7 +196,8 @@ describe('Test videos API validator', function () {
     const path = '/api/v1/search/video-channels/'
 
     const query = {
-      search: 'coucou'
+      search: 'coucou',
+      host: 'example.com'
     }
 
     it('Should fail with a bad start pagination', async function () {
@@ -183,8 +212,16 @@ describe('Test videos API validator', function () {
       await checkBadSortPagination(server.url, path, null, query)
     })
 
-    it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path, query, statusCodeExpected: HttpStatusCode.OK_200 })
+    it('Should fail with an invalid host', async function () {
+      await makeGetRequest({ url: server.url, path, query: { ...query, host: '6565' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should fail with invalid handles', async function () {
+      await makeGetRequest({ url: server.url, path, query: { ...query, handles: [ '' ] }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      await makeGetRequest({ url: server.url, path, query, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -202,42 +239,42 @@ describe('Test videos API validator', function () {
 
       for (const path of paths) {
         {
-          const customQuery = immutableAssign(query, { searchTarget: 'hello' })
-          await makeGetRequest({ url: server.url, path, query: customQuery, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+          const customQuery = { ...query, searchTarget: 'hello' }
+          await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
         }
 
         {
-          const customQuery = immutableAssign(query, { searchTarget: undefined })
-          await makeGetRequest({ url: server.url, path, query: customQuery, statusCodeExpected: HttpStatusCode.OK_200 })
+          const customQuery = { ...query, searchTarget: undefined }
+          await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.OK_200 })
         }
 
         {
-          const customQuery = immutableAssign(query, { searchTarget: 'local' })
-          await makeGetRequest({ url: server.url, path, query: customQuery, statusCodeExpected: HttpStatusCode.OK_200 })
+          const customQuery = { ...query, searchTarget: 'local' }
+          await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.OK_200 })
         }
 
         {
-          const customQuery = immutableAssign(query, { searchTarget: 'search-index' })
-          await makeGetRequest({ url: server.url, path, query: customQuery, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+          const customQuery = { ...query, searchTarget: 'search-index' }
+          await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
         }
 
         await updateSearchIndex(server, true, true)
 
         {
-          const customQuery = immutableAssign(query, { searchTarget: 'local' })
-          await makeGetRequest({ url: server.url, path, query: customQuery, statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 })
+          const customQuery = { ...query, searchTarget: 'local' }
+          await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
         }
 
         {
-          const customQuery = immutableAssign(query, { searchTarget: 'search-index' })
-          await makeGetRequest({ url: server.url, path, query: customQuery, statusCodeExpected: HttpStatusCode.OK_200 })
+          const customQuery = { ...query, searchTarget: 'search-index' }
+          await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.OK_200 })
         }
 
         await updateSearchIndex(server, true, false)
 
         {
-          const customQuery = immutableAssign(query, { searchTarget: 'local' })
-          await makeGetRequest({ url: server.url, path, query: customQuery, statusCodeExpected: HttpStatusCode.OK_200 })
+          const customQuery = { ...query, searchTarget: 'local' }
+          await makeGetRequest({ url: server.url, path, query: customQuery, expectedStatus: HttpStatusCode.OK_200 })
         }
 
         await updateSearchIndex(server, false, false)
diff --git a/server/tests/api/check-params/services.ts b/server/tests/api/check-params/services.ts
index 514e3da70..8d795fabc 100644
--- a/server/tests/api/check-params/services.ts
+++ b/server/tests/api/check-params/services.ts
@@ -1,22 +1,18 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
 import {
   cleanupTests,
-  flushAndRunServer,
+  createSingleServer,
   makeGetRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  uploadVideo,
-  createVideoPlaylist,
   setDefaultVideoChannel
-} from '../../../../shared/extra-utils'
-import { VideoPlaylistPrivacy } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoPlaylistPrivacy } from '@shared/models'
 
 describe('Test services API validators', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let playlistUUID: string
 
   // ---------------------------------------------------------------
@@ -24,27 +20,22 @@ describe('Test services API validators', function () {
   before(async function () {
     this.timeout(60000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
     await setDefaultVideoChannel([ server ])
 
-    {
-      const res = await uploadVideo(server.url, server.accessToken, { name: 'my super name' })
-      server.video = res.body.video
-    }
+    server.store.videoCreated = await server.videos.upload({ attributes: { name: 'my super name' } })
 
     {
-      const res = await createVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
+      const created = await server.playlists.create({
+        attributes: {
           displayName: 'super playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: server.videoChannel.id
+          videoChannelId: server.store.channel.id
         }
       })
 
-      playlistUUID = res.body.videoPlaylist.uuid
+      playlistUUID = created.uuid
     }
   })
 
@@ -56,7 +47,7 @@ describe('Test services API validators', function () {
     })
 
     it('Should fail with an invalid host', async function () {
-      const embedUrl = 'http://hello.com/videos/watch/' + server.video.uuid
+      const embedUrl = 'http://hello.com/videos/watch/' + server.store.videoCreated.uuid
       await checkParamEmbed(server, embedUrl)
     })
 
@@ -71,37 +62,37 @@ describe('Test services API validators', function () {
     })
 
     it('Should fail with an invalid path', async function () {
-      const embedUrl = `http://localhost:${server.port}/videos/watchs/${server.video.uuid}`
+      const embedUrl = `http://localhost:${server.port}/videos/watchs/${server.store.videoCreated.uuid}`
 
       await checkParamEmbed(server, embedUrl)
     })
 
     it('Should fail with an invalid max height', async function () {
-      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.video.uuid}`
+      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.store.videoCreated.uuid}`
 
       await checkParamEmbed(server, embedUrl, HttpStatusCode.BAD_REQUEST_400, { maxheight: 'hello' })
     })
 
     it('Should fail with an invalid max width', async function () {
-      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.video.uuid}`
+      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.store.videoCreated.uuid}`
 
       await checkParamEmbed(server, embedUrl, HttpStatusCode.BAD_REQUEST_400, { maxwidth: 'hello' })
     })
 
     it('Should fail with an invalid format', async function () {
-      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.video.uuid}`
+      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.store.videoCreated.uuid}`
 
       await checkParamEmbed(server, embedUrl, HttpStatusCode.BAD_REQUEST_400, { format: 'blabla' })
     })
 
     it('Should fail with a non supported format', async function () {
-      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.video.uuid}`
+      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.store.videoCreated.uuid}`
 
       await checkParamEmbed(server, embedUrl, HttpStatusCode.NOT_IMPLEMENTED_501, { format: 'xml' })
     })
 
     it('Should succeed with the correct params with a video', async function () {
-      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.video.uuid}`
+      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.store.videoCreated.uuid}`
       const query = {
         format: 'json',
         maxheight: 400,
@@ -128,13 +119,13 @@ describe('Test services API validators', function () {
   })
 })
 
-function checkParamEmbed (server: ServerInfo, embedUrl: string, statusCodeExpected = HttpStatusCode.BAD_REQUEST_400, query = {}) {
+function checkParamEmbed (server: PeerTubeServer, embedUrl: string, expectedStatus = HttpStatusCode.BAD_REQUEST_400, query = {}) {
   const path = '/services/oembed'
 
   return makeGetRequest({
     url: server.url,
     path,
     query: Object.assign(query, { url: embedUrl }),
-    statusCodeExpected
+    expectedStatus
   })
 }
diff --git a/server/tests/api/check-params/upload-quota.ts b/server/tests/api/check-params/upload-quota.ts
index d0fbec415..322e93d0d 100644
--- a/server/tests/api/check-params/upload-quota.ts
+++ b/server/tests/api/check-params/upload-quota.ts
@@ -2,46 +2,39 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import { HttpStatusCode, randomInt } from '@shared/core-utils'
-import { getGoodVideoUrl, getMagnetURI, getMyVideoImports, importVideo } from '@shared/extra-utils/videos/video-imports'
-import { MyUser, VideoImport, VideoImportState, VideoPrivacy } from '@shared/models'
+import { randomInt } from '@shared/core-utils'
 import {
   cleanupTests,
-  flushAndRunServer,
-  getMyUserInformation,
-  immutableAssign,
-  registerUser,
-  ServerInfo,
+  createSingleServer,
+  FIXTURE_URLS,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
-  updateUser,
-  uploadVideo,
-  userLogin,
+  VideosCommand,
   waitJobs
-} from '../../../../shared/extra-utils'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoImportState, VideoPrivacy } from '@shared/models'
 
 describe('Test upload quota', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let rootId: number
+  let command: VideosCommand
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
     await setDefaultVideoChannel([ server ])
 
-    const res = await getMyUserInformation(server.url, server.accessToken)
-    rootId = (res.body as MyUser).id
+    const user = await server.users.getMyInfo()
+    rootId = user.id
 
-    await updateUser({
-      url: server.url,
-      userId: rootId,
-      accessToken: server.accessToken,
-      videoQuota: 42
-    })
+    await server.users.update({ userId: rootId, videoQuota: 42 })
+
+    command = server.videos
   })
 
   describe('When having a video quota', function () {
@@ -50,49 +43,48 @@ describe('Test upload quota', function () {
       this.timeout(30000)
 
       const user = { username: 'registered' + randomInt(1, 1500), password: 'password' }
-      await registerUser(server.url, user.username, user.password)
-      const userAccessToken = await userLogin(server, user)
+      await server.users.register(user)
+      const userToken = await server.login.getAccessToken(user)
 
-      const videoAttributes = { fixture: 'video_short2.webm' }
+      const attributes = { fixture: 'video_short2.webm' }
       for (let i = 0; i < 5; i++) {
-        await uploadVideo(server.url, userAccessToken, videoAttributes)
+        await command.upload({ token: userToken, attributes })
       }
 
-      await uploadVideo(server.url, userAccessToken, videoAttributes, HttpStatusCode.PAYLOAD_TOO_LARGE_413, 'legacy')
+      await command.upload({ token: userToken, attributes, expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413, mode: 'legacy' })
     })
 
     it('Should fail with a registered user having too many videos with resumable upload', async function () {
       this.timeout(30000)
 
       const user = { username: 'registered' + randomInt(1, 1500), password: 'password' }
-      await registerUser(server.url, user.username, user.password)
-      const userAccessToken = await userLogin(server, user)
+      await server.users.register(user)
+      const userToken = await server.login.getAccessToken(user)
 
-      const videoAttributes = { fixture: 'video_short2.webm' }
+      const attributes = { fixture: 'video_short2.webm' }
       for (let i = 0; i < 5; i++) {
-        await uploadVideo(server.url, userAccessToken, videoAttributes)
+        await command.upload({ token: userToken, attributes })
       }
 
-      await uploadVideo(server.url, userAccessToken, videoAttributes, HttpStatusCode.PAYLOAD_TOO_LARGE_413, 'resumable')
+      await command.upload({ token: userToken, attributes, expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413, mode: 'resumable' })
     })
 
     it('Should fail to import with HTTP/Torrent/magnet', async function () {
       this.timeout(120000)
 
       const baseAttributes = {
-        channelId: server.videoChannel.id,
+        channelId: server.store.channel.id,
         privacy: VideoPrivacy.PUBLIC
       }
-      await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getGoodVideoUrl() }))
-      await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
-      await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' as any }))
+      await server.imports.importVideo({ attributes: { ...baseAttributes, targetUrl: FIXTURE_URLS.goodVideo } })
+      await server.imports.importVideo({ attributes: { ...baseAttributes, magnetUri: FIXTURE_URLS.magnet } })
+      await server.imports.importVideo({ attributes: { ...baseAttributes, torrentfile: 'video-720p.torrent' as any } })
 
       await waitJobs([ server ])
 
-      const res = await getMyVideoImports(server.url, server.accessToken)
+      const { total, data: videoImports } = await server.imports.getMyVideoImports()
+      expect(total).to.equal(3)
 
-      expect(res.body.total).to.equal(3)
-      const videoImports: VideoImport[] = res.body.data
       expect(videoImports).to.have.lengthOf(3)
 
       for (const videoImport of videoImports) {
@@ -106,43 +98,34 @@ describe('Test upload quota', function () {
   describe('When having a daily video quota', function () {
 
     it('Should fail with a user having too many videos daily', async function () {
-      await updateUser({
-        url: server.url,
-        userId: rootId,
-        accessToken: server.accessToken,
-        videoQuotaDaily: 42
-      })
+      await server.users.update({ userId: rootId, videoQuotaDaily: 42 })
 
-      await uploadVideo(server.url, server.accessToken, {}, HttpStatusCode.PAYLOAD_TOO_LARGE_413, 'legacy')
-      await uploadVideo(server.url, server.accessToken, {}, HttpStatusCode.PAYLOAD_TOO_LARGE_413, 'resumable')
+      await command.upload({ expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413, mode: 'legacy' })
+      await command.upload({ expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413, mode: 'resumable' })
     })
   })
 
   describe('When having an absolute and daily video quota', function () {
     it('Should fail if exceeding total quota', async function () {
-      await updateUser({
-        url: server.url,
+      await server.users.update({
         userId: rootId,
-        accessToken: server.accessToken,
         videoQuota: 42,
         videoQuotaDaily: 1024 * 1024 * 1024
       })
 
-      await uploadVideo(server.url, server.accessToken, {}, HttpStatusCode.PAYLOAD_TOO_LARGE_413, 'legacy')
-      await uploadVideo(server.url, server.accessToken, {}, HttpStatusCode.PAYLOAD_TOO_LARGE_413, 'resumable')
+      await command.upload({ expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413, mode: 'legacy' })
+      await command.upload({ expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413, mode: 'resumable' })
     })
 
     it('Should fail if exceeding daily quota', async function () {
-      await updateUser({
-        url: server.url,
+      await server.users.update({
         userId: rootId,
-        accessToken: server.accessToken,
         videoQuota: 1024 * 1024 * 1024,
         videoQuotaDaily: 42
       })
 
-      await uploadVideo(server.url, server.accessToken, {}, HttpStatusCode.PAYLOAD_TOO_LARGE_413, 'legacy')
-      await uploadVideo(server.url, server.accessToken, {}, HttpStatusCode.PAYLOAD_TOO_LARGE_413, 'resumable')
+      await command.upload({ expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413, mode: 'legacy' })
+      await command.upload({ expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413, mode: 'resumable' })
     })
   })
 
diff --git a/server/tests/api/check-params/user-notifications.ts b/server/tests/api/check-params/user-notifications.ts
index 26d4423f9..17edf5aa1 100644
--- a/server/tests/api/check-params/user-notifications.ts
+++ b/server/tests/api/check-params/user-notifications.ts
@@ -2,35 +2,30 @@
 
 import 'mocha'
 import { io } from 'socket.io-client'
-
 import {
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   cleanupTests,
-  flushAndRunServer,
-  immutableAssign,
+  createSingleServer,
   makeGetRequest,
   makePostBodyRequest,
   makePutBodyRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   wait
-} from '../../../../shared/extra-utils'
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { UserNotificationSetting, UserNotificationSettingValue } from '../../../../shared/models/users'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+} from '@shared/extra-utils'
+import { HttpStatusCode, UserNotificationSetting, UserNotificationSettingValue } from '@shared/models'
 
 describe('Test user notifications API validators', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
   })
@@ -58,7 +53,7 @@ describe('Test user notifications API validators', function () {
           unread: 'toto'
         },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
 
@@ -66,7 +61,7 @@ describe('Test user notifications API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -75,7 +70,7 @@ describe('Test user notifications API validators', function () {
         url: server.url,
         path,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -91,7 +86,7 @@ describe('Test user notifications API validators', function () {
           ids: [ 'hello' ]
         },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
 
       await makePostBodyRequest({
@@ -101,7 +96,7 @@ describe('Test user notifications API validators', function () {
           ids: [ ]
         },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
 
       await makePostBodyRequest({
@@ -111,7 +106,7 @@ describe('Test user notifications API validators', function () {
           ids: 5
         },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -122,7 +117,7 @@ describe('Test user notifications API validators', function () {
         fields: {
           ids: [ 5 ]
         },
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -134,7 +129,7 @@ describe('Test user notifications API validators', function () {
           ids: [ 5 ]
         },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -146,7 +141,7 @@ describe('Test user notifications API validators', function () {
       await makePostBodyRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -155,7 +150,7 @@ describe('Test user notifications API validators', function () {
         url: server.url,
         path,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -187,32 +182,32 @@ describe('Test user notifications API validators', function () {
         path,
         token: server.accessToken,
         fields: { newVideoFromSubscription: UserNotificationSettingValue.WEB },
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
     it('Should fail with incorrect field values', async function () {
       {
-        const fields = immutableAssign(correctFields, { newCommentOnMyVideo: 15 })
+        const fields = { ...correctFields, newCommentOnMyVideo: 15 }
 
         await makePutBodyRequest({
           url: server.url,
           path,
           token: server.accessToken,
           fields,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       }
 
       {
-        const fields = immutableAssign(correctFields, { newCommentOnMyVideo: 'toto' })
+        const fields = { ...correctFields, newCommentOnMyVideo: 'toto' }
 
         await makePutBodyRequest({
           url: server.url,
           path,
           fields,
           token: server.accessToken,
-          statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+          expectedStatus: HttpStatusCode.BAD_REQUEST_400
         })
       }
     })
@@ -222,7 +217,7 @@ describe('Test user notifications API validators', function () {
         url: server.url,
         path,
         fields: correctFields,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -232,7 +227,7 @@ describe('Test user notifications API validators', function () {
         path,
         token: server.accessToken,
         fields: correctFields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
diff --git a/server/tests/api/check-params/user-subscriptions.ts b/server/tests/api/check-params/user-subscriptions.ts
index 538201647..624069c80 100644
--- a/server/tests/api/check-params/user-subscriptions.ts
+++ b/server/tests/api/check-params/user-subscriptions.ts
@@ -1,30 +1,24 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
 import {
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   cleanupTests,
-  createUser,
-  flushAndRunServer,
+  createSingleServer,
   makeDeleteRequest,
   makeGetRequest,
   makePostBodyRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
-
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+  waitJobs
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test user subscriptions API validators', function () {
   const path = '/api/v1/users/me/subscriptions'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken = ''
 
   // ---------------------------------------------------------------
@@ -32,7 +26,7 @@ describe('Test user subscriptions API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -40,8 +34,8 @@ describe('Test user subscriptions API validators', function () {
       username: 'user1',
       password: 'my super password'
     }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(server, user)
+    await server.users.create({ username: user.username, password: user.password })
+    userAccessToken = await server.login.getAccessToken(user)
   })
 
   describe('When listing my subscriptions', function () {
@@ -61,7 +55,7 @@ describe('Test user subscriptions API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -70,7 +64,7 @@ describe('Test user subscriptions API validators', function () {
         url: server.url,
         path,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -94,7 +88,7 @@ describe('Test user subscriptions API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -103,7 +97,7 @@ describe('Test user subscriptions API validators', function () {
         url: server.url,
         path,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -114,7 +108,7 @@ describe('Test user subscriptions API validators', function () {
         url: server.url,
         path,
         fields: { uri: 'user1_channel@localhost:' + server.port },
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -124,7 +118,7 @@ describe('Test user subscriptions API validators', function () {
         path,
         token: server.accessToken,
         fields: { uri: 'root' },
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
 
       await makePostBodyRequest({
@@ -132,7 +126,7 @@ describe('Test user subscriptions API validators', function () {
         path,
         token: server.accessToken,
         fields: { uri: 'root@' },
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
 
       await makePostBodyRequest({
@@ -140,7 +134,7 @@ describe('Test user subscriptions API validators', function () {
         path,
         token: server.accessToken,
         fields: { uri: 'root@hello@' },
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -152,7 +146,7 @@ describe('Test user subscriptions API validators', function () {
         path,
         token: server.accessToken,
         fields: { uri: 'user1_channel@localhost:' + server.port },
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
 
       await waitJobs([ server ])
@@ -164,7 +158,7 @@ describe('Test user subscriptions API validators', function () {
       await makeGetRequest({
         url: server.url,
         path: path + '/user1_channel@localhost:' + server.port,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -173,21 +167,21 @@ describe('Test user subscriptions API validators', function () {
         url: server.url,
         path: path + '/root',
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
 
       await makeGetRequest({
         url: server.url,
         path: path + '/root@',
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
 
       await makeGetRequest({
         url: server.url,
         path: path + '/root@hello@',
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -196,7 +190,7 @@ describe('Test user subscriptions API validators', function () {
         url: server.url,
         path: path + '/root1@localhost:' + server.port,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -205,7 +199,7 @@ describe('Test user subscriptions API validators', function () {
         url: server.url,
         path: path + '/user1_channel@localhost:' + server.port,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -217,7 +211,7 @@ describe('Test user subscriptions API validators', function () {
       await makeGetRequest({
         url: server.url,
         path: existPath,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -227,7 +221,7 @@ describe('Test user subscriptions API validators', function () {
         path: existPath,
         query: { uris: 'toto' },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
 
       await makeGetRequest({
@@ -235,7 +229,7 @@ describe('Test user subscriptions API validators', function () {
         path: existPath,
         query: { 'uris[]': 1 },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -245,7 +239,7 @@ describe('Test user subscriptions API validators', function () {
         path: existPath,
         query: { 'uris[]': 'coucou@localhost:' + server.port },
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -255,7 +249,7 @@ describe('Test user subscriptions API validators', function () {
       await makeDeleteRequest({
         url: server.url,
         path: path + '/user1_channel@localhost:' + server.port,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -264,21 +258,21 @@ describe('Test user subscriptions API validators', function () {
         url: server.url,
         path: path + '/root',
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
 
       await makeDeleteRequest({
         url: server.url,
         path: path + '/root@',
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
 
       await makeDeleteRequest({
         url: server.url,
         path: path + '/root@hello@',
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -287,7 +281,7 @@ describe('Test user subscriptions API validators', function () {
         url: server.url,
         path: path + '/root1@localhost:' + server.port,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -296,7 +290,7 @@ describe('Test user subscriptions API validators', function () {
         url: server.url,
         path: path + '/user1_channel@localhost:' + server.port,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
diff --git a/server/tests/api/check-params/users.ts b/server/tests/api/check-params/users.ts
index 70a872ce5..9d8f933db 100644
--- a/server/tests/api/check-params/users.ts
+++ b/server/tests/api/check-params/users.ts
@@ -2,43 +2,24 @@
 
 import 'mocha'
 import { omit } from 'lodash'
-import { User, UserRole, VideoCreateResult } from '../../../../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoChannel,
-  blockUser,
   buildAbsoluteFixturePath,
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   cleanupTests,
-  createUser,
-  deleteMe,
-  flushAndRunServer,
-  getMyUserInformation,
-  getMyUserVideoRating,
-  getUserScopedTokens,
-  getUsersList,
-  immutableAssign,
+  createSingleServer,
   killallServers,
   makeGetRequest,
   makePostBodyRequest,
   makePutBodyRequest,
   makeUploadRequest,
-  registerUser,
-  removeUser,
-  renewUserScopedTokens,
-  reRunServer,
-  ServerInfo,
+  MockSmtpServer,
+  PeerTubeServer,
   setAccessTokensToServers,
-  unblockUser,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
+  UsersCommand
+} from '@shared/extra-utils'
+import { HttpStatusCode, UserAdminFlag, UserRole, VideoCreateResult } from '@shared/models'
 
 describe('Test users API validators', function () {
   const path = '/api/v1/users/'
@@ -46,10 +27,10 @@ describe('Test users API validators', function () {
   let rootId: number
   let moderatorId: number
   let video: VideoCreateResult
-  let server: ServerInfo
-  let serverWithRegistrationDisabled: ServerInfo
-  let userAccessToken = ''
-  let moderatorAccessToken = ''
+  let server: PeerTubeServer
+  let serverWithRegistrationDisabled: PeerTubeServer
+  let userToken = ''
+  let moderatorToken = ''
   let emailPort: number
   let overrideConfig: Object
 
@@ -65,8 +46,8 @@ describe('Test users API validators', function () {
 
     {
       const res = await Promise.all([
-        flushAndRunServer(1, overrideConfig),
-        flushAndRunServer(2)
+        createSingleServer(1, overrideConfig),
+        createSingleServer(2)
       ])
 
       server = res[0]
@@ -76,66 +57,31 @@ describe('Test users API validators', function () {
     }
 
     {
-      const user = {
-        username: 'user1',
-        password: 'my super password'
-      }
-
-      const videoQuota = 42000000
-      await createUser({
-        url: server.url,
-        accessToken: server.accessToken,
-        username: user.username,
-        password: user.password,
-        videoQuota: videoQuota
-      })
-      userAccessToken = await userLogin(server, user)
+      const user = { username: 'user1' }
+      await server.users.create({ ...user })
+      userToken = await server.login.getAccessToken(user)
     }
 
     {
-      const moderator = {
-        username: 'moderator1',
-        password: 'super password'
-      }
-
-      await createUser({
-        url: server.url,
-        accessToken: server.accessToken,
-        username: moderator.username,
-        password: moderator.password,
-        role: UserRole.MODERATOR
-      })
-
-      moderatorAccessToken = await userLogin(server, moderator)
+      const moderator = { username: 'moderator1' }
+      await server.users.create({ ...moderator, role: UserRole.MODERATOR })
+      moderatorToken = await server.login.getAccessToken(moderator)
     }
 
     {
-      const moderator = {
-        username: 'moderator2',
-        password: 'super password'
-      }
-
-      await createUser({
-        url: server.url,
-        accessToken: server.accessToken,
-        username: moderator.username,
-        password: moderator.password,
-        role: UserRole.MODERATOR
-      })
+      const moderator = { username: 'moderator2' }
+      await server.users.create({ ...moderator, role: UserRole.MODERATOR })
     }
 
     {
-      const res = await uploadVideo(server.url, server.accessToken, {})
-      video = res.body.video
+      video = await server.videos.upload()
     }
 
     {
-      const res = await getUsersList(server.url, server.accessToken)
-      const users: User[] = res.body.data
-
-      userId = users.find(u => u.username === 'user1').id
-      rootId = users.find(u => u.username === 'root').id
-      moderatorId = users.find(u => u.username === 'moderator2').id
+      const { data } = await server.users.list()
+      userId = data.find(u => u.username === 'user1').id
+      rootId = data.find(u => u.username === 'root').id
+      moderatorId = data.find(u => u.username === 'moderator2').id
     }
   })
 
@@ -156,7 +102,7 @@ describe('Test users API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -164,8 +110,8 @@ describe('Test users API validators', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        token: userToken,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
   })
@@ -182,25 +128,25 @@ describe('Test users API validators', function () {
     }
 
     it('Should fail with a too small username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: '' })
+      const fields = { ...baseCorrectParams, username: '' }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a too long username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
+      const fields = { ...baseCorrectParams, username: 'super'.repeat(50) }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a not lowercase username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: 'Toto' })
+      const fields = { ...baseCorrectParams, username: 'Toto' }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with an incorrect username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
+      const fields = { ...baseCorrectParams, username: 'my username' }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -212,25 +158,25 @@ describe('Test users API validators', function () {
     })
 
     it('Should fail with an invalid email', async function () {
-      const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
+      const fields = { ...baseCorrectParams, email: 'test_example.com' }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a too small password', async function () {
-      const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
+      const fields = { ...baseCorrectParams, password: 'bla' }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a too long password', async function () {
-      const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
+      const fields = { ...baseCorrectParams, password: 'super'.repeat(61) }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with empty password and no smtp configured', async function () {
-      const fields = immutableAssign(baseCorrectParams, { password: '' })
+      const fields = { ...baseCorrectParams, password: '' }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -238,33 +184,37 @@ describe('Test users API validators', function () {
     it('Should succeed with no password on a server with smtp enabled', async function () {
       this.timeout(20000)
 
-      killallServers([ server ])
+      await killallServers([ server ])
+
+      const config = {
+        ...overrideConfig,
 
-      const config = immutableAssign(overrideConfig, {
         smtp: {
           hostname: 'localhost',
           port: emailPort
         }
-      })
-      await reRunServer(server, config)
+      }
+      await server.run(config)
+
+      const fields = {
+        ...baseCorrectParams,
 
-      const fields = immutableAssign(baseCorrectParams, {
         password: '',
         username: 'create_password',
         email: 'create_password@example.com'
-      })
+      }
 
       await makePostBodyRequest({
         url: server.url,
         path: path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
 
     it('Should fail with invalid admin flags', async function () {
-      const fields = immutableAssign(baseCorrectParams, { adminFlags: 'toto' })
+      const fields = { ...baseCorrectParams, adminFlags: 'toto' }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -275,31 +225,31 @@ describe('Test users API validators', function () {
         path,
         token: 'super token',
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
     it('Should fail if we add a user with the same username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: 'user1' })
+      const fields = { ...baseCorrectParams, username: 'user1' }
 
       await makePostBodyRequest({
         url: server.url,
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
 
     it('Should fail if we add a user with the same email', async function () {
-      const fields = immutableAssign(baseCorrectParams, { email: 'user1@example.com' })
+      const fields = { ...baseCorrectParams, email: 'user1@example.com' }
 
       await makePostBodyRequest({
         url: server.url,
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
 
@@ -316,13 +266,13 @@ describe('Test users API validators', function () {
     })
 
     it('Should fail with an invalid videoQuota', async function () {
-      const fields = immutableAssign(baseCorrectParams, { videoQuota: -5 })
+      const fields = { ...baseCorrectParams, videoQuota: -5 }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with an invalid videoQuotaDaily', async function () {
-      const fields = immutableAssign(baseCorrectParams, { videoQuotaDaily: -7 })
+      const fields = { ...baseCorrectParams, videoQuotaDaily: -7 }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -334,46 +284,46 @@ describe('Test users API validators', function () {
     })
 
     it('Should fail with an invalid user role', async function () {
-      const fields = immutableAssign(baseCorrectParams, { role: 88989 })
+      const fields = { ...baseCorrectParams, role: 88989 }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a "peertube" username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
+      const fields = { ...baseCorrectParams, username: 'peertube' }
 
       await makePostBodyRequest({
         url: server.url,
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
 
     it('Should fail to create a moderator or an admin with a moderator', async function () {
       for (const role of [ UserRole.MODERATOR, UserRole.ADMINISTRATOR ]) {
-        const fields = immutableAssign(baseCorrectParams, { role })
+        const fields = { ...baseCorrectParams, role }
 
         await makePostBodyRequest({
           url: server.url,
           path,
-          token: moderatorAccessToken,
+          token: moderatorToken,
           fields,
-          statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+          expectedStatus: HttpStatusCode.FORBIDDEN_403
         })
       }
     })
 
     it('Should succeed to create a user with a moderator', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: 'a4656', email: 'a4656@example.com', role: UserRole.USER })
+      const fields = { ...baseCorrectParams, username: 'a4656', email: 'a4656@example.com', role: UserRole.USER }
 
       await makePostBodyRequest({
         url: server.url,
         path,
-        token: moderatorAccessToken,
+        token: moderatorToken,
         fields,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
 
@@ -383,16 +333,13 @@ describe('Test users API validators', function () {
         path,
         token: server.accessToken,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
 
     it('Should fail with a non admin user', async function () {
-      const user = {
-        username: 'user1',
-        password: 'my super password'
-      }
-      userAccessToken = await userLogin(server, user)
+      const user = { username: 'user1' }
+      userToken = await server.login.getAccessToken(user)
 
       const fields = {
         username: 'user3',
@@ -400,11 +347,12 @@ describe('Test users API validators', function () {
         password: 'my super password',
         videoQuota: 42000000
       }
-      await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
+      await makePostBodyRequest({ url: server.url, path, token: userToken, fields, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
   })
 
   describe('When updating my account', function () {
+
     it('Should fail with an invalid email attribute', async function () {
       const fields = {
         email: 'blabla'
@@ -415,29 +363,29 @@ describe('Test users API validators', function () {
 
     it('Should fail with a too small password', async function () {
       const fields = {
-        currentPassword: 'my super password',
+        currentPassword: 'password',
         password: 'bla'
       }
 
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail with a too long password', async function () {
       const fields = {
-        currentPassword: 'my super password',
+        currentPassword: 'password',
         password: 'super'.repeat(61)
       }
 
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail without the current password', async function () {
       const fields = {
-        currentPassword: 'my super password',
+        currentPassword: 'password',
         password: 'super'.repeat(61)
       }
 
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail with an invalid current password', async function () {
@@ -449,9 +397,9 @@ describe('Test users API validators', function () {
       await makePutBodyRequest({
         url: server.url,
         path: path + 'me',
-        token: userAccessToken,
+        token: userToken,
         fields,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -460,7 +408,7 @@ describe('Test users API validators', function () {
         nsfwPolicy: 'hello'
       }
 
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail with an invalid autoPlayVideo attribute', async function () {
@@ -468,7 +416,7 @@ describe('Test users API validators', function () {
         autoPlayVideo: -1
       }
 
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail with an invalid autoPlayNextVideo attribute', async function () {
@@ -476,7 +424,7 @@ describe('Test users API validators', function () {
         autoPlayNextVideo: -1
       }
 
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail with an invalid videosHistoryEnabled attribute', async function () {
@@ -484,12 +432,12 @@ describe('Test users API validators', function () {
         videosHistoryEnabled: -1
       }
 
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail with an non authenticated user', async function () {
       const fields = {
-        currentPassword: 'my super password',
+        currentPassword: 'password',
         password: 'my super password'
       }
 
@@ -498,7 +446,7 @@ describe('Test users API validators', function () {
         path: path + 'me',
         token: 'super token',
         fields,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -507,7 +455,7 @@ describe('Test users API validators', function () {
         description: 'super'.repeat(201)
       }
 
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail with an invalid videoLanguages attribute', async function () {
@@ -516,7 +464,7 @@ describe('Test users API validators', function () {
           videoLanguages: 'toto'
         }
 
-        await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+        await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
       }
 
       {
@@ -529,18 +477,18 @@ describe('Test users API validators', function () {
           videoLanguages: languages
         }
 
-        await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+        await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
       }
     })
 
     it('Should fail with an invalid theme', async function () {
       const fields = { theme: 'invalid' }
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail with an unknown theme', async function () {
       const fields = { theme: 'peertube-theme-unknown' }
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail with an invalid noInstanceConfigWarningModal attribute', async function () {
@@ -548,7 +496,7 @@ describe('Test users API validators', function () {
         noInstanceConfigWarningModal: -1
       }
 
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should fail with an invalid noWelcomeModal attribute', async function () {
@@ -556,12 +504,12 @@ describe('Test users API validators', function () {
         noWelcomeModal: -1
       }
 
-      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+      await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
     })
 
     it('Should succeed to change password with the correct params', async function () {
       const fields = {
-        currentPassword: 'my super password',
+        currentPassword: 'password',
         password: 'my super password',
         nsfwPolicy: 'blur',
         autoPlayVideo: false,
@@ -574,9 +522,9 @@ describe('Test users API validators', function () {
       await makePutBodyRequest({
         url: server.url,
         path: path + 'me',
-        token: userAccessToken,
+        token: userToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
 
@@ -589,9 +537,9 @@ describe('Test users API validators', function () {
       await makePutBodyRequest({
         url: server.url,
         path: path + 'me',
-        token: userAccessToken,
+        token: userToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -623,7 +571,7 @@ describe('Test users API validators', function () {
         path: path + '/me/avatar/pick',
         fields,
         attaches,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -638,7 +586,7 @@ describe('Test users API validators', function () {
         token: server.accessToken,
         fields,
         attaches,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -646,28 +594,28 @@ describe('Test users API validators', function () {
   describe('When managing my scoped tokens', function () {
 
     it('Should fail to get my scoped tokens with an non authenticated user', async function () {
-      await getUserScopedTokens(server.url, null, HttpStatusCode.UNAUTHORIZED_401)
+      await server.users.getMyScopedTokens({ token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail to get my scoped tokens with a bad token', async function () {
-      await getUserScopedTokens(server.url, 'bad', HttpStatusCode.UNAUTHORIZED_401)
+      await server.users.getMyScopedTokens({ token: 'bad', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 
     })
 
     it('Should succeed to get my scoped tokens', async function () {
-      await getUserScopedTokens(server.url, server.accessToken)
+      await server.users.getMyScopedTokens()
     })
 
     it('Should fail to renew my scoped tokens with an non authenticated user', async function () {
-      await renewUserScopedTokens(server.url, null, HttpStatusCode.UNAUTHORIZED_401)
+      await server.users.renewMyScopedTokens({ token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail to renew my scoped tokens with a bad token', async function () {
-      await renewUserScopedTokens(server.url, 'bad', HttpStatusCode.UNAUTHORIZED_401)
+      await server.users.renewMyScopedTokens({ token: 'bad', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should succeed to renew my scoped tokens', async function () {
-      await renewUserScopedTokens(server.url, server.accessToken)
+      await server.users.renewMyScopedTokens()
     })
   })
 
@@ -678,16 +626,16 @@ describe('Test users API validators', function () {
         url: server.url,
         path: path + userId,
         token: 'super token',
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
     it('Should fail with a non admin user', async function () {
-      await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
+      await makeGetRequest({ url: server.url, path, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await makeGetRequest({ url: server.url, path: path + userId, token: server.accessToken, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, path: path + userId, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -727,7 +675,7 @@ describe('Test users API validators', function () {
 
     it('Should fail with a too small password', async function () {
       const fields = {
-        currentPassword: 'my super password',
+        currentPassword: 'password',
         password: 'bla'
       }
 
@@ -736,7 +684,7 @@ describe('Test users API validators', function () {
 
     it('Should fail with a too long password', async function () {
       const fields = {
-        currentPassword: 'my super password',
+        currentPassword: 'password',
         password: 'super'.repeat(61)
       }
 
@@ -753,7 +701,7 @@ describe('Test users API validators', function () {
         path: path + userId,
         token: 'super token',
         fields,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -779,9 +727,9 @@ describe('Test users API validators', function () {
       await makePutBodyRequest({
         url: server.url,
         path: path + moderatorId,
-        token: moderatorAccessToken,
+        token: moderatorToken,
         fields,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -793,9 +741,9 @@ describe('Test users API validators', function () {
       await makePutBodyRequest({
         url: server.url,
         path: path + userId,
-        token: moderatorAccessToken,
+        token: moderatorToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
 
@@ -812,38 +760,44 @@ describe('Test users API validators', function () {
         path: path + userId,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
 
   describe('When getting my information', function () {
     it('Should fail with a non authenticated user', async function () {
-      await getMyUserInformation(server.url, 'fake_token', HttpStatusCode.UNAUTHORIZED_401)
+      await server.users.getMyInfo({ token: 'fake_token', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should success with the correct parameters', async function () {
-      await getMyUserInformation(server.url, userAccessToken)
+      await server.users.getMyInfo({ token: userToken })
     })
   })
 
   describe('When getting my video rating', function () {
+    let command: UsersCommand
+
+    before(function () {
+      command = server.users
+    })
+
     it('Should fail with a non authenticated user', async function () {
-      await getMyUserVideoRating(server.url, 'fake_token', video.id, HttpStatusCode.UNAUTHORIZED_401)
+      await command.getMyRating({ token: 'fake_token', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with an incorrect video uuid', async function () {
-      await getMyUserVideoRating(server.url, server.accessToken, 'blabla', HttpStatusCode.BAD_REQUEST_400)
+      await command.getMyRating({ videoId: 'blabla', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with an unknown video', async function () {
-      await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', HttpStatusCode.NOT_FOUND_404)
+      await command.getMyRating({ videoId: '4da6fde3-88f7-4d16-b119-108df5630b06', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should succeed with the correct parameters', async function () {
-      await getMyUserVideoRating(server.url, server.accessToken, video.id)
-      await getMyUserVideoRating(server.url, server.accessToken, video.uuid)
-      await getMyUserVideoRating(server.url, server.accessToken, video.shortUUID)
+      await command.getMyRating({ videoId: video.id })
+      await command.getMyRating({ videoId: video.uuid })
+      await command.getMyRating({ videoId: video.shortUUID })
     })
   })
 
@@ -851,80 +805,93 @@ describe('Test users API validators', function () {
     const path = '/api/v1/accounts/user1/ratings'
 
     it('Should fail with a bad start pagination', async function () {
-      await checkBadStartPagination(server.url, path, userAccessToken)
+      await checkBadStartPagination(server.url, path, userToken)
     })
 
     it('Should fail with a bad count pagination', async function () {
-      await checkBadCountPagination(server.url, path, userAccessToken)
+      await checkBadCountPagination(server.url, path, userToken)
     })
 
     it('Should fail with an incorrect sort', async function () {
-      await checkBadSortPagination(server.url, path, userAccessToken)
+      await checkBadSortPagination(server.url, path, userToken)
     })
 
     it('Should fail with a unauthenticated user', async function () {
-      await makeGetRequest({ url: server.url, path, statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makeGetRequest({ url: server.url, path, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a another user', async function () {
-      await makeGetRequest({ url: server.url, path, token: server.accessToken, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
+      await makeGetRequest({ url: server.url, path, token: server.accessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a bad type', async function () {
       await makeGetRequest({
         url: server.url,
         path,
-        token: userAccessToken,
+        token: userToken,
         query: { rating: 'toto ' },
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
     it('Should succeed with the correct params', async function () {
-      await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, path, token: userToken, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
   describe('When blocking/unblocking/removing user', function () {
+
     it('Should fail with an incorrect id', async function () {
-      await removeUser(server.url, 'blabla', server.accessToken, HttpStatusCode.BAD_REQUEST_400)
-      await blockUser(server.url, 'blabla', server.accessToken, HttpStatusCode.BAD_REQUEST_400)
-      await unblockUser(server.url, 'blabla', server.accessToken, HttpStatusCode.BAD_REQUEST_400)
+      const options = { userId: 'blabla' as any, expectedStatus: HttpStatusCode.BAD_REQUEST_400 }
+
+      await server.users.remove(options)
+      await server.users.banUser({ userId: 'blabla' as any, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+      await server.users.unbanUser({ userId: 'blabla' as any, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with the root user', async function () {
-      await removeUser(server.url, rootId, server.accessToken, HttpStatusCode.BAD_REQUEST_400)
-      await blockUser(server.url, rootId, server.accessToken, HttpStatusCode.BAD_REQUEST_400)
-      await unblockUser(server.url, rootId, server.accessToken, HttpStatusCode.BAD_REQUEST_400)
+      const options = { userId: rootId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 }
+
+      await server.users.remove(options)
+      await server.users.banUser(options)
+      await server.users.unbanUser(options)
     })
 
     it('Should return 404 with a non existing id', async function () {
-      await removeUser(server.url, 4545454, server.accessToken, HttpStatusCode.NOT_FOUND_404)
-      await blockUser(server.url, 4545454, server.accessToken, HttpStatusCode.NOT_FOUND_404)
-      await unblockUser(server.url, 4545454, server.accessToken, HttpStatusCode.NOT_FOUND_404)
+      const options = { userId: 4545454, expectedStatus: HttpStatusCode.NOT_FOUND_404 }
+
+      await server.users.remove(options)
+      await server.users.banUser(options)
+      await server.users.unbanUser(options)
     })
 
     it('Should fail with a non admin user', async function () {
-      await removeUser(server.url, userId, userAccessToken, HttpStatusCode.FORBIDDEN_403)
-      await blockUser(server.url, userId, userAccessToken, HttpStatusCode.FORBIDDEN_403)
-      await unblockUser(server.url, userId, userAccessToken, HttpStatusCode.FORBIDDEN_403)
+      const options = { userId, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 }
+
+      await server.users.remove(options)
+      await server.users.banUser(options)
+      await server.users.unbanUser(options)
     })
 
     it('Should fail on a moderator with a moderator', async function () {
-      await removeUser(server.url, moderatorId, moderatorAccessToken, HttpStatusCode.FORBIDDEN_403)
-      await blockUser(server.url, moderatorId, moderatorAccessToken, HttpStatusCode.FORBIDDEN_403)
-      await unblockUser(server.url, moderatorId, moderatorAccessToken, HttpStatusCode.FORBIDDEN_403)
+      const options = { userId: moderatorId, token: moderatorToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 }
+
+      await server.users.remove(options)
+      await server.users.banUser(options)
+      await server.users.unbanUser(options)
     })
 
     it('Should succeed on a user with a moderator', async function () {
-      await blockUser(server.url, userId, moderatorAccessToken)
-      await unblockUser(server.url, userId, moderatorAccessToken)
+      const options = { userId, token: moderatorToken }
+
+      await server.users.banUser(options)
+      await server.users.unbanUser(options)
     })
   })
 
   describe('When deleting our account', function () {
     it('Should fail with with the root account', async function () {
-      await deleteMe(server.url, server.accessToken, HttpStatusCode.BAD_REQUEST_400)
+      await server.users.deleteMe({ expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
   })
 
@@ -938,19 +905,19 @@ describe('Test users API validators', function () {
     }
 
     it('Should fail with a too small username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: '' })
+      const fields = { ...baseCorrectParams, username: '' }
 
       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
     })
 
     it('Should fail with a too long username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
+      const fields = { ...baseCorrectParams, username: 'super'.repeat(50) }
 
       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
     })
 
     it('Should fail with an incorrect username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
+      const fields = { ...baseCorrectParams, username: 'my username' }
 
       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
     })
@@ -962,108 +929,108 @@ describe('Test users API validators', function () {
     })
 
     it('Should fail with an invalid email', async function () {
-      const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
+      const fields = { ...baseCorrectParams, email: 'test_example.com' }
 
       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
     })
 
     it('Should fail with a too small password', async function () {
-      const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
+      const fields = { ...baseCorrectParams, password: 'bla' }
 
       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
     })
 
     it('Should fail with a too long password', async function () {
-      const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
+      const fields = { ...baseCorrectParams, password: 'super'.repeat(61) }
 
       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
     })
 
     it('Should fail if we register a user with the same username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: 'root' })
+      const fields = { ...baseCorrectParams, username: 'root' }
 
       await makePostBodyRequest({
         url: server.url,
         path: registrationPath,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
 
     it('Should fail with a "peertube" username', async function () {
-      const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
+      const fields = { ...baseCorrectParams, username: 'peertube' }
 
       await makePostBodyRequest({
         url: server.url,
         path: registrationPath,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
 
     it('Should fail if we register a user with the same email', async function () {
-      const fields = immutableAssign(baseCorrectParams, { email: 'admin' + server.internalServerNumber + '@example.com' })
+      const fields = { ...baseCorrectParams, email: 'admin' + server.internalServerNumber + '@example.com' }
 
       await makePostBodyRequest({
         url: server.url,
         path: registrationPath,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
 
     it('Should fail with a bad display name', async function () {
-      const fields = immutableAssign(baseCorrectParams, { displayName: 'a'.repeat(150) })
+      const fields = { ...baseCorrectParams, displayName: 'a'.repeat(150) }
 
       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad channel name', async function () {
-      const fields = immutableAssign(baseCorrectParams, { channel: { name: '[]azf', displayName: 'toto' } })
+      const fields = { ...baseCorrectParams, channel: { name: '[]azf', displayName: 'toto' } }
 
       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad channel display name', async function () {
-      const fields = immutableAssign(baseCorrectParams, { channel: { name: 'toto', displayName: '' } })
+      const fields = { ...baseCorrectParams, channel: { name: 'toto', displayName: '' } }
 
       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
     })
 
     it('Should fail with a channel name that is the same as username', async function () {
       const source = { username: 'super_user', channel: { name: 'super_user', displayName: 'display name' } }
-      const fields = immutableAssign(baseCorrectParams, source)
+      const fields = { ...baseCorrectParams, ...source }
 
       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
     })
 
     it('Should fail with an existing channel', async function () {
-      const videoChannelAttributesArg = { name: 'existing_channel', displayName: 'hello', description: 'super description' }
-      await addVideoChannel(server.url, server.accessToken, videoChannelAttributesArg)
+      const attributes = { name: 'existing_channel', displayName: 'hello', description: 'super description' }
+      await server.channels.create({ attributes })
 
-      const fields = immutableAssign(baseCorrectParams, { channel: { name: 'existing_channel', displayName: 'toto' } })
+      const fields = { ...baseCorrectParams, channel: { name: 'existing_channel', displayName: 'toto' } }
 
       await makePostBodyRequest({
         url: server.url,
         path: registrationPath,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
 
     it('Should succeed with the correct params', async function () {
-      const fields = immutableAssign(baseCorrectParams, { channel: { name: 'super_channel', displayName: 'toto' } })
+      const fields = { ...baseCorrectParams, channel: { name: 'super_channel', displayName: 'toto' } }
 
       await makePostBodyRequest({
         url: server.url,
         path: registrationPath,
         token: server.accessToken,
         fields: fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
 
@@ -1079,14 +1046,14 @@ describe('Test users API validators', function () {
         path: registrationPath,
         token: serverWithRegistrationDisabled.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
   })
 
   describe('When registering multiple users on a server with users limit', function () {
     it('Should fail when after 3 registrations', async function () {
-      await registerUser(server.url, 'user42', 'super password', HttpStatusCode.FORBIDDEN_403)
+      await server.users.register({ username: 'user42', expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
   })
 
@@ -1113,7 +1080,7 @@ describe('Test users API validators', function () {
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -1141,7 +1108,7 @@ describe('Test users API validators', function () {
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
diff --git a/server/tests/api/check-params/video-blacklist.ts b/server/tests/api/check-params/video-blacklist.ts
index ce7f5fa17..1f926d227 100644
--- a/server/tests/api/check-params/video-blacklist.ts
+++ b/server/tests/api/check-params/video-blacklist.ts
@@ -1,46 +1,37 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
+import { expect } from 'chai'
 import {
+  BlacklistCommand,
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   cleanupTests,
-  createUser,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getBlacklistedVideosList,
-  getVideo,
-  getVideoWithToken,
   makePostBodyRequest,
   makePutBodyRequest,
-  removeVideoFromBlacklist,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  uploadVideo,
-  userLogin,
   waitJobs
-} from '../../../../shared/extra-utils'
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { VideoBlacklistType, VideoDetails } from '../../../../shared/models/videos'
-import { expect } from 'chai'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoBlacklistType } from '@shared/models'
 
 describe('Test video blacklist API validators', function () {
-  let servers: ServerInfo[]
-  let notBlacklistedVideoId: number
+  let servers: PeerTubeServer[]
+  let notBlacklistedVideoId: string
   let remoteVideoUUID: string
   let userAccessToken1 = ''
   let userAccessToken2 = ''
+  let command: BlacklistCommand
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
     await doubleFollow(servers[0], servers[1])
@@ -48,40 +39,41 @@ describe('Test video blacklist API validators', function () {
     {
       const username = 'user1'
       const password = 'my super password'
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: username, password: password })
-      userAccessToken1 = await userLogin(servers[0], { username, password })
+      await servers[0].users.create({ username: username, password: password })
+      userAccessToken1 = await servers[0].login.getAccessToken({ username, password })
     }
 
     {
       const username = 'user2'
       const password = 'my super password'
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: username, password: password })
-      userAccessToken2 = await userLogin(servers[0], { username, password })
+      await servers[0].users.create({ username: username, password: password })
+      userAccessToken2 = await servers[0].login.getAccessToken({ username, password })
     }
 
     {
-      const res = await uploadVideo(servers[0].url, userAccessToken1, {})
-      servers[0].video = res.body.video
+      servers[0].store.videoCreated = await servers[0].videos.upload({ token: userAccessToken1 })
     }
 
     {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, {})
-      notBlacklistedVideoId = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload()
+      notBlacklistedVideoId = uuid
     }
 
     {
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, {})
-      remoteVideoUUID = res.body.video.uuid
+      const { uuid } = await servers[1].videos.upload()
+      remoteVideoUUID = uuid
     }
 
     await waitJobs(servers)
+
+    command = servers[0].blacklist
   })
 
   describe('When adding a video in blacklist', function () {
     const basePath = '/api/v1/videos/'
 
     it('Should fail with nothing', async function () {
-      const path = basePath + servers[0].video + '/blacklist'
+      const path = basePath + servers[0].store.videoCreated + '/blacklist'
       const fields = {}
       await makePostBodyRequest({ url: servers[0].url, path, token: servers[0].accessToken, fields })
     })
@@ -93,25 +85,25 @@ describe('Test video blacklist API validators', function () {
     })
 
     it('Should fail with a non authenticated user', async function () {
-      const path = basePath + servers[0].video + '/blacklist'
+      const path = basePath + servers[0].store.videoCreated + '/blacklist'
       const fields = {}
-      await makePostBodyRequest({ url: servers[0].url, path, token: 'hello', fields, statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makePostBodyRequest({ url: servers[0].url, path, token: 'hello', fields, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a non admin user', async function () {
-      const path = basePath + servers[0].video + '/blacklist'
+      const path = basePath + servers[0].store.videoCreated + '/blacklist'
       const fields = {}
       await makePostBodyRequest({
         url: servers[0].url,
         path,
         token: userAccessToken2,
         fields,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
     it('Should fail with an invalid reason', async function () {
-      const path = basePath + servers[0].video.uuid + '/blacklist'
+      const path = basePath + servers[0].store.videoCreated.uuid + '/blacklist'
       const fields = { reason: 'a'.repeat(305) }
 
       await makePostBodyRequest({ url: servers[0].url, path, token: servers[0].accessToken, fields })
@@ -126,12 +118,12 @@ describe('Test video blacklist API validators', function () {
         path,
         token: servers[0].accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
 
     it('Should succeed with the correct params', async function () {
-      const path = basePath + servers[0].video.uuid + '/blacklist'
+      const path = basePath + servers[0].store.videoCreated.uuid + '/blacklist'
       const fields = {}
 
       await makePostBodyRequest({
@@ -139,7 +131,7 @@ describe('Test video blacklist API validators', function () {
         path,
         token: servers[0].accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -161,37 +153,37 @@ describe('Test video blacklist API validators', function () {
         path,
         token: servers[0].accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
     it('Should fail with a non authenticated user', async function () {
-      const path = basePath + servers[0].video + '/blacklist'
+      const path = basePath + servers[0].store.videoCreated + '/blacklist'
       const fields = {}
-      await makePutBodyRequest({ url: servers[0].url, path, token: 'hello', fields, statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makePutBodyRequest({ url: servers[0].url, path, token: 'hello', fields, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a non admin user', async function () {
-      const path = basePath + servers[0].video + '/blacklist'
+      const path = basePath + servers[0].store.videoCreated + '/blacklist'
       const fields = {}
       await makePutBodyRequest({
         url: servers[0].url,
         path,
         token: userAccessToken2,
         fields,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
     it('Should fail with an invalid reason', async function () {
-      const path = basePath + servers[0].video.uuid + '/blacklist'
+      const path = basePath + servers[0].store.videoCreated.uuid + '/blacklist'
       const fields = { reason: 'a'.repeat(305) }
 
       await makePutBodyRequest({ url: servers[0].url, path, token: servers[0].accessToken, fields })
     })
 
     it('Should succeed with the correct params', async function () {
-      const path = basePath + servers[0].video.shortUUID + '/blacklist'
+      const path = basePath + servers[0].store.videoCreated.shortUUID + '/blacklist'
       const fields = { reason: 'hello' }
 
       await makePutBodyRequest({
@@ -199,7 +191,7 @@ describe('Test video blacklist API validators', function () {
         path,
         token: servers[0].accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -207,52 +199,61 @@ describe('Test video blacklist API validators', function () {
   describe('When getting blacklisted video', function () {
 
     it('Should fail with a non authenticated user', async function () {
-      await getVideo(servers[0].url, servers[0].video.uuid, HttpStatusCode.UNAUTHORIZED_401)
+      await servers[0].videos.get({ id: servers[0].store.videoCreated.uuid, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with another user', async function () {
-      await getVideoWithToken(servers[0].url, userAccessToken2, servers[0].video.uuid, HttpStatusCode.FORBIDDEN_403)
+      await servers[0].videos.getWithToken({
+        token: userAccessToken2,
+        id: servers[0].store.videoCreated.uuid,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
     })
 
     it('Should succeed with the owner authenticated user', async function () {
-      const res = await getVideoWithToken(servers[0].url, userAccessToken1, servers[0].video.uuid, HttpStatusCode.OK_200)
-      const video: VideoDetails = res.body
-
+      const video = await servers[0].videos.getWithToken({ token: userAccessToken1, id: servers[0].store.videoCreated.uuid })
       expect(video.blacklisted).to.be.true
     })
 
     it('Should succeed with an admin', async function () {
-      const video = servers[0].video
+      const video = servers[0].store.videoCreated
 
       for (const id of [ video.id, video.uuid, video.shortUUID ]) {
-        const res = await getVideoWithToken(servers[0].url, servers[0].accessToken, id, HttpStatusCode.OK_200)
-        const video: VideoDetails = res.body
-
+        const video = await servers[0].videos.getWithToken({ id, expectedStatus: HttpStatusCode.OK_200 })
         expect(video.blacklisted).to.be.true
       }
     })
   })
 
   describe('When removing a video in blacklist', function () {
+
     it('Should fail with a non authenticated user', async function () {
-      await removeVideoFromBlacklist(servers[0].url, 'fake token', servers[0].video.uuid, HttpStatusCode.UNAUTHORIZED_401)
+      await command.remove({
+        token: 'fake token',
+        videoId: servers[0].store.videoCreated.uuid,
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
+      })
     })
 
     it('Should fail with a non admin user', async function () {
-      await removeVideoFromBlacklist(servers[0].url, userAccessToken2, servers[0].video.uuid, HttpStatusCode.FORBIDDEN_403)
+      await command.remove({
+        token: userAccessToken2,
+        videoId: servers[0].store.videoCreated.uuid,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
     })
 
     it('Should fail with an incorrect id', async function () {
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, 'hello', HttpStatusCode.BAD_REQUEST_400)
+      await command.remove({ videoId: 'hello', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with a not blacklisted video', async function () {
       // The video was not added to the blacklist so it should fail
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, notBlacklistedVideoId, HttpStatusCode.NOT_FOUND_404)
+      await command.remove({ videoId: notBlacklistedVideoId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, servers[0].video.uuid, HttpStatusCode.NO_CONTENT_204)
+      await command.remove({ videoId: servers[0].store.videoCreated.uuid, expectedStatus: HttpStatusCode.NO_CONTENT_204 })
     })
   })
 
@@ -260,11 +261,11 @@ describe('Test video blacklist API validators', function () {
     const basePath = '/api/v1/videos/blacklist/'
 
     it('Should fail with a non authenticated user', async function () {
-      await getBlacklistedVideosList({ url: servers[0].url, token: 'fake token', specialStatus: HttpStatusCode.UNAUTHORIZED_401 })
+      await servers[0].blacklist.list({ token: 'fake token', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a non admin user', async function () {
-      await getBlacklistedVideosList({ url: servers[0].url, token: userAccessToken2, specialStatus: HttpStatusCode.FORBIDDEN_403 })
+      await servers[0].blacklist.list({ token: userAccessToken2, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a bad start pagination', async function () {
@@ -280,16 +281,11 @@ describe('Test video blacklist API validators', function () {
     })
 
     it('Should fail with an invalid type', async function () {
-      await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        type: 0,
-        specialStatus: HttpStatusCode.BAD_REQUEST_400
-      })
+      await servers[0].blacklist.list({ type: 0, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should succeed with the correct parameters', async function () {
-      await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, type: VideoBlacklistType.MANUAL })
+      await servers[0].blacklist.list({ type: VideoBlacklistType.MANUAL })
     })
   })
 
diff --git a/server/tests/api/check-params/video-captions.ts b/server/tests/api/check-params/video-captions.ts
index c0595c04d..90f429314 100644
--- a/server/tests/api/check-params/video-captions.ts
+++ b/server/tests/api/check-params/video-captions.ts
@@ -1,27 +1,22 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { VideoCreateResult } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   buildAbsoluteFixturePath,
   cleanupTests,
-  createUser,
-  flushAndRunServer,
+  createSingleServer,
   makeDeleteRequest,
   makeGetRequest,
   makeUploadRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { createVideoCaption } from '../../../../shared/extra-utils/videos/video-captions'
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoCreateResult } from '@shared/models'
 
 describe('Test video captions API validator', function () {
   const path = '/api/v1/videos/'
 
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken: string
   let video: VideoCreateResult
 
@@ -30,22 +25,19 @@ describe('Test video captions API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
-    {
-      const res = await uploadVideo(server.url, server.accessToken, {})
-      video = res.body.video
-    }
+    video = await server.videos.upload()
 
     {
       const user = {
         username: 'user1',
         password: 'my super password'
       }
-      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-      userAccessToken = await userLogin(server, user)
+      await server.users.create({ username: user.username, password: user.password })
+      userAccessToken = await server.login.getAccessToken(user)
     }
   })
 
@@ -74,7 +66,7 @@ describe('Test video captions API validator', function () {
         token: server.accessToken,
         fields,
         attaches,
-        statusCodeExpected: 404
+        expectedStatus: 404
       })
     })
 
@@ -110,7 +102,7 @@ describe('Test video captions API validator', function () {
         path: captionPath,
         fields,
         attaches,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -123,7 +115,7 @@ describe('Test video captions API validator', function () {
         token: 'blabla',
         fields,
         attaches,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -141,7 +133,7 @@ describe('Test video captions API validator', function () {
     //     token: server.accessToken,
     //     fields,
     //     attaches,
-    //     statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+    //     expectedStatus: HttpStatusCode.BAD_REQUEST_400
     //   })
     // })
 
@@ -154,14 +146,12 @@ describe('Test video captions API validator', function () {
     //     videoId: video.uuid,
     //     fixture: 'subtitle-bad.txt',
     //     mimeType: 'application/octet-stream',
-    //     statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+    //     expectedStatus: HttpStatusCode.BAD_REQUEST_400
     //   })
     // })
 
     it('Should succeed with a valid captionfile extension and octet-stream mime type', async function () {
-      await createVideoCaption({
-        url: server.url,
-        accessToken: server.accessToken,
+      await server.captions.add({
         language: 'zh',
         videoId: video.uuid,
         fixture: 'subtitle-good.srt',
@@ -183,7 +173,7 @@ describe('Test video captions API validator', function () {
     //     token: server.accessToken,
     //     fields,
     //     attaches,
-    //     statusCodeExpected: HttpStatusCode.INTERNAL_SERVER_ERROR_500
+    //     expectedStatus: HttpStatusCode.INTERNAL_SERVER_ERROR_500
     //   })
     // })
 
@@ -196,7 +186,7 @@ describe('Test video captions API validator', function () {
         token: server.accessToken,
         fields,
         attaches,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -210,12 +200,12 @@ describe('Test video captions API validator', function () {
       await makeGetRequest({
         url: server.url,
         path: path + '4da6fde3-88f7-4d16-b119-108df5630b06/captions',
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
     it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path: path + video.shortUUID + '/captions', statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, path: path + video.shortUUID + '/captions', expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -233,7 +223,7 @@ describe('Test video captions API validator', function () {
         url: server.url,
         path: path + '4da6fde3-88f7-4d16-b119-108df5630b06/captions/fr',
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -257,12 +247,12 @@ describe('Test video captions API validator', function () {
 
     it('Should fail without access token', async function () {
       const captionPath = path + video.shortUUID + '/captions/fr'
-      await makeDeleteRequest({ url: server.url, path: captionPath, statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makeDeleteRequest({ url: server.url, path: captionPath, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a bad access token', async function () {
       const captionPath = path + video.shortUUID + '/captions/fr'
-      await makeDeleteRequest({ url: server.url, path: captionPath, token: 'coucou', statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makeDeleteRequest({ url: server.url, path: captionPath, token: 'coucou', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with another user', async function () {
@@ -271,7 +261,7 @@ describe('Test video captions API validator', function () {
         url: server.url,
         path: captionPath,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -281,7 +271,7 @@ describe('Test video captions API validator', function () {
         url: server.url,
         path: captionPath,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
diff --git a/server/tests/api/check-params/video-channels.ts b/server/tests/api/check-params/video-channels.ts
index 5c02afd31..2e63916d4 100644
--- a/server/tests/api/check-params/video-channels.ts
+++ b/server/tests/api/check-params/video-channels.ts
@@ -3,43 +3,37 @@
 import 'mocha'
 import * as chai from 'chai'
 import { omit } from 'lodash'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   buildAbsoluteFixturePath,
+  ChannelsCommand,
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   cleanupTests,
-  createUser,
-  deleteVideoChannel,
-  flushAndRunServer,
-  getAccountVideoChannelsList,
-  immutableAssign,
+  createSingleServer,
   makeGetRequest,
   makePostBodyRequest,
   makePutBodyRequest,
   makeUploadRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { VideoChannelUpdate } from '../../../../shared/models/videos'
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoChannelUpdate } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test video channels API validator', function () {
   const videoChannelPath = '/api/v1/video-channels'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let accessTokenUser: string
+  let command: ChannelsCommand
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -49,9 +43,11 @@ describe('Test video channels API validator', function () {
     }
 
     {
-      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-      accessTokenUser = await userLogin(server, user)
+      await server.users.create({ username: user.username, password: user.password })
+      accessTokenUser = await server.login.getAccessToken(user)
     }
+
+    command = server.channels
   })
 
   describe('When listing a video channels', function () {
@@ -84,14 +80,14 @@ describe('Test video channels API validator', function () {
     })
 
     it('Should fail with a unknown account', async function () {
-      await getAccountVideoChannelsList({ url: server.url, accountName: 'unknown', specialStatus: HttpStatusCode.NOT_FOUND_404 })
+      await server.channels.listByAccount({ accountName: 'unknown', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should succeed with the correct parameters', async function () {
       await makeGetRequest({
         url: server.url,
         path: accountChannelPath,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -110,7 +106,7 @@ describe('Test video channels API validator', function () {
         path: videoChannelPath,
         token: 'none',
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -125,7 +121,7 @@ describe('Test video channels API validator', function () {
     })
 
     it('Should fail with a bad name', async function () {
-      const fields = immutableAssign(baseCorrectParams, { name: 'super name' })
+      const fields = { ...baseCorrectParams, name: 'super name' }
       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
     })
 
@@ -135,17 +131,17 @@ describe('Test video channels API validator', function () {
     })
 
     it('Should fail with a long name', async function () {
-      const fields = immutableAssign(baseCorrectParams, { displayName: 'super'.repeat(25) })
+      const fields = { ...baseCorrectParams, displayName: 'super'.repeat(25) }
       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
     })
 
     it('Should fail with a long description', async function () {
-      const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(201) })
+      const fields = { ...baseCorrectParams, description: 'super'.repeat(201) }
       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
     })
 
     it('Should fail with a long support text', async function () {
-      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
+      const fields = { ...baseCorrectParams, support: 'super'.repeat(201) }
       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
     })
 
@@ -155,7 +151,7 @@ describe('Test video channels API validator', function () {
         path: videoChannelPath,
         token: server.accessToken,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
 
@@ -165,7 +161,7 @@ describe('Test video channels API validator', function () {
         path: videoChannelPath,
         token: server.accessToken,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
   })
@@ -189,7 +185,7 @@ describe('Test video channels API validator', function () {
         path,
         token: 'hi',
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -199,27 +195,27 @@ describe('Test video channels API validator', function () {
         path,
         token: accessTokenUser,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
     it('Should fail with a long name', async function () {
-      const fields = immutableAssign(baseCorrectParams, { displayName: 'super'.repeat(25) })
+      const fields = { ...baseCorrectParams, displayName: 'super'.repeat(25) }
       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a long description', async function () {
-      const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(201) })
+      const fields = { ...baseCorrectParams, description: 'super'.repeat(201) }
       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a long support text', async function () {
-      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
+      const fields = { ...baseCorrectParams, support: 'super'.repeat(201) }
       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad bulkVideosSupportUpdate field', async function () {
-      const fields = immutableAssign(baseCorrectParams, { bulkVideosSupportUpdate: 'super' })
+      const fields = { ...baseCorrectParams, bulkVideosSupportUpdate: 'super' }
       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
@@ -229,7 +225,7 @@ describe('Test video channels API validator', function () {
         path,
         token: server.accessToken,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -274,7 +270,7 @@ describe('Test video channels API validator', function () {
           path: `${path}/${type}/pick`,
           fields,
           attaches,
-          statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401
         })
       }
     })
@@ -291,7 +287,7 @@ describe('Test video channels API validator', function () {
           token: server.accessToken,
           fields,
           attaches,
-          statusCodeExpected: HttpStatusCode.OK_200
+          expectedStatus: HttpStatusCode.OK_200
         })
       }
     })
@@ -302,7 +298,7 @@ describe('Test video channels API validator', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: videoChannelPath,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body.data).to.be.an('array')
@@ -312,7 +308,7 @@ describe('Test video channels API validator', function () {
       await makeGetRequest({
         url: server.url,
         path: videoChannelPath + '/super_channel2',
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -320,30 +316,30 @@ describe('Test video channels API validator', function () {
       await makeGetRequest({
         url: server.url,
         path: videoChannelPath + '/super_channel',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
 
   describe('When deleting a video channel', function () {
     it('Should fail with a non authenticated user', async function () {
-      await deleteVideoChannel(server.url, 'coucou', 'super_channel', HttpStatusCode.UNAUTHORIZED_401)
+      await command.delete({ token: 'coucou', channelName: 'super_channel', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with another authenticated user', async function () {
-      await deleteVideoChannel(server.url, accessTokenUser, 'super_channel', HttpStatusCode.FORBIDDEN_403)
+      await command.delete({ token: accessTokenUser, channelName: 'super_channel', expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with an unknown video channel id', async function () {
-      await deleteVideoChannel(server.url, server.accessToken, 'super_channel2', HttpStatusCode.NOT_FOUND_404)
+      await command.delete({ channelName: 'super_channel2', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should succeed with the correct parameters', async function () {
-      await deleteVideoChannel(server.url, server.accessToken, 'super_channel')
+      await command.delete({ channelName: 'super_channel' })
     })
 
     it('Should fail to delete the last user video channel', async function () {
-      await deleteVideoChannel(server.url, server.accessToken, 'root_channel', HttpStatusCode.CONFLICT_409)
+      await command.delete({ channelName: 'root_channel', expectedStatus: HttpStatusCode.CONFLICT_409 })
     })
   })
 
diff --git a/server/tests/api/check-params/video-comments.ts b/server/tests/api/check-params/video-comments.ts
index a38420851..2d9ee1e0d 100644
--- a/server/tests/api/check-params/video-comments.ts
+++ b/server/tests/api/check-params/video-comments.ts
@@ -2,33 +2,26 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { VideoCreateResult } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   cleanupTests,
-  createUser,
-  flushAndRunServer,
+  createSingleServer,
   makeDeleteRequest,
   makeGetRequest,
   makePostBodyRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils'
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments'
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoCreateResult } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test video comments API validator', function () {
   let pathThread: string
   let pathComment: string
-  let server: ServerInfo
+  let server: PeerTubeServer
   let video: VideoCreateResult
   let userAccessToken: string
   let userAccessToken2: string
@@ -39,32 +32,31 @@ describe('Test video comments API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
     {
-      const res = await uploadVideo(server.url, server.accessToken, {})
-      video = res.body.video
+      video = await server.videos.upload({ attributes: {} })
       pathThread = '/api/v1/videos/' + video.uuid + '/comment-threads'
     }
 
     {
-      const res = await addVideoCommentThread(server.url, server.accessToken, video.uuid, 'coucou')
-      commentId = res.body.comment.id
+      const created = await server.comments.createThread({ videoId: video.uuid, text: 'coucou' })
+      commentId = created.id
       pathComment = '/api/v1/videos/' + video.uuid + '/comments/' + commentId
     }
 
     {
       const user = { username: 'user1', password: 'my super password' }
-      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-      userAccessToken = await userLogin(server, user)
+      await server.users.create({ username: user.username, password: user.password })
+      userAccessToken = await server.login.getAccessToken(user)
     }
 
     {
       const user = { username: 'user2', password: 'my super password' }
-      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-      userAccessToken2 = await userLogin(server, user)
+      await server.users.create({ username: user.username, password: user.password })
+      userAccessToken2 = await server.login.getAccessToken(user)
     }
   })
 
@@ -85,7 +77,7 @@ describe('Test video comments API validator', function () {
       await makeGetRequest({
         url: server.url,
         path: '/api/v1/videos/ba708d62-e3d7-45d9-9d73-41b9097cc02d/comment-threads',
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
   })
@@ -95,7 +87,7 @@ describe('Test video comments API validator', function () {
       await makeGetRequest({
         url: server.url,
         path: '/api/v1/videos/ba708d62-e3d7-45d9-9d73-41b9097cc02d/comment-threads/' + commentId,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -103,7 +95,7 @@ describe('Test video comments API validator', function () {
       await makeGetRequest({
         url: server.url,
         path: '/api/v1/videos/' + video.shortUUID + '/comment-threads/156',
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -111,7 +103,7 @@ describe('Test video comments API validator', function () {
       await makeGetRequest({
         url: server.url,
         path: '/api/v1/videos/' + video.shortUUID + '/comment-threads/' + commentId,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -127,7 +119,7 @@ describe('Test video comments API validator', function () {
         path: pathThread,
         token: 'none',
         fields,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -160,7 +152,7 @@ describe('Test video comments API validator', function () {
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -173,7 +165,7 @@ describe('Test video comments API validator', function () {
         path: pathThread,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
@@ -188,7 +180,7 @@ describe('Test video comments API validator', function () {
         path: pathComment,
         token: 'none',
         fields,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -221,7 +213,7 @@ describe('Test video comments API validator', function () {
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -235,7 +227,7 @@ describe('Test video comments API validator', function () {
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -248,14 +240,14 @@ describe('Test video comments API validator', function () {
         path: pathComment,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
 
   describe('When removing video comments', function () {
     it('Should fail with a non authenticated user', async function () {
-      await makeDeleteRequest({ url: server.url, path: pathComment, token: 'none', statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makeDeleteRequest({ url: server.url, path: pathComment, token: 'none', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with another user', async function () {
@@ -263,32 +255,32 @@ describe('Test video comments API validator', function () {
         url: server.url,
         path: pathComment,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
     it('Should fail with an incorrect video', async function () {
       const path = '/api/v1/videos/ba708d62-e3d7-45d9-9d73-41b9097cc02d/comments/' + commentId
-      await makeDeleteRequest({ url: server.url, path, token: server.accessToken, statusCodeExpected: HttpStatusCode.NOT_FOUND_404 })
+      await makeDeleteRequest({ url: server.url, path, token: server.accessToken, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with an incorrect comment', async function () {
       const path = '/api/v1/videos/' + video.uuid + '/comments/124'
-      await makeDeleteRequest({ url: server.url, path, token: server.accessToken, statusCodeExpected: HttpStatusCode.NOT_FOUND_404 })
+      await makeDeleteRequest({ url: server.url, path, token: server.accessToken, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should succeed with the same user', async function () {
       let commentToDelete: number
 
       {
-        const res = await addVideoCommentThread(server.url, userAccessToken, video.uuid, 'hello')
-        commentToDelete = res.body.comment.id
+        const created = await server.comments.createThread({ videoId: video.uuid, token: userAccessToken, text: 'hello' })
+        commentToDelete = created.id
       }
 
       const path = '/api/v1/videos/' + video.uuid + '/comments/' + commentToDelete
 
-      await makeDeleteRequest({ url: server.url, path, token: userAccessToken2, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
-      await makeDeleteRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: HttpStatusCode.NO_CONTENT_204 })
+      await makeDeleteRequest({ url: server.url, path, token: userAccessToken2, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+      await makeDeleteRequest({ url: server.url, path, token: userAccessToken, expectedStatus: HttpStatusCode.NO_CONTENT_204 })
     })
 
     it('Should succeed with the owner of the video', async function () {
@@ -296,19 +288,19 @@ describe('Test video comments API validator', function () {
       let anotherVideoUUID: string
 
       {
-        const res = await uploadVideo(server.url, userAccessToken, { name: 'video' })
-        anotherVideoUUID = res.body.video.uuid
+        const { uuid } = await server.videos.upload({ token: userAccessToken, attributes: { name: 'video' } })
+        anotherVideoUUID = uuid
       }
 
       {
-        const res = await addVideoCommentThread(server.url, server.accessToken, anotherVideoUUID, 'hello')
-        commentToDelete = res.body.comment.id
+        const created = await server.comments.createThread({ videoId: anotherVideoUUID, text: 'hello' })
+        commentToDelete = created.id
       }
 
       const path = '/api/v1/videos/' + anotherVideoUUID + '/comments/' + commentToDelete
 
-      await makeDeleteRequest({ url: server.url, path, token: userAccessToken2, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
-      await makeDeleteRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: HttpStatusCode.NO_CONTENT_204 })
+      await makeDeleteRequest({ url: server.url, path, token: userAccessToken2, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+      await makeDeleteRequest({ url: server.url, path, token: userAccessToken, expectedStatus: HttpStatusCode.NO_CONTENT_204 })
     })
 
     it('Should succeed with the correct parameters', async function () {
@@ -316,15 +308,14 @@ describe('Test video comments API validator', function () {
         url: server.url,
         path: pathComment,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
 
   describe('When a video has comments disabled', function () {
     before(async function () {
-      const res = await uploadVideo(server.url, server.accessToken, { commentsEnabled: false })
-      video = res.body.video
+      video = await server.videos.upload({ attributes: { commentsEnabled: false } })
       pathThread = '/api/v1/videos/' + video.uuid + '/comment-threads'
     })
 
@@ -332,7 +323,7 @@ describe('Test video comments API validator', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: pathThread,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
       expect(res.body.total).to.equal(0)
       expect(res.body.data).to.have.lengthOf(0)
@@ -349,7 +340,7 @@ describe('Test video comments API validator', function () {
         path: pathThread,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
 
@@ -375,7 +366,7 @@ describe('Test video comments API validator', function () {
       await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -384,7 +375,7 @@ describe('Test video comments API validator', function () {
         url: server.url,
         path,
         token: userAccessToken,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
@@ -399,7 +390,7 @@ describe('Test video comments API validator', function () {
           searchAccount: 'toto',
           searchVideo: 'toto'
         },
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
diff --git a/server/tests/api/check-params/video-imports.ts b/server/tests/api/check-params/video-imports.ts
index a27b624d0..d6d745488 100644
--- a/server/tests/api/check-params/video-imports.ts
+++ b/server/tests/api/check-params/video-imports.ts
@@ -2,33 +2,25 @@
 
 import 'mocha'
 import { omit } from 'lodash'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   buildAbsoluteFixturePath,
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   cleanupTests,
-  createUser,
-  flushAndRunServer,
-  getMyUserInformation,
-  immutableAssign,
+  createSingleServer,
+  FIXTURE_URLS,
   makeGetRequest,
   makePostBodyRequest,
   makeUploadRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  updateCustomSubConfig,
-  userLogin
-} from '../../../../shared/extra-utils'
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { getGoodVideoUrl, getMagnetURI } from '../../../../shared/extra-utils/videos/video-imports'
-import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
 
 describe('Test video imports API validator', function () {
   const path = '/api/v1/videos/imports'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken = ''
   let channelId: number
 
@@ -37,18 +29,18 @@ describe('Test video imports API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
     const username = 'user1'
     const password = 'my super password'
-    await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
-    userAccessToken = await userLogin(server, { username, password })
+    await server.users.create({ username: username, password: password })
+    userAccessToken = await server.login.getAccessToken({ username, password })
 
     {
-      const res = await getMyUserInformation(server.url, server.accessToken)
-      channelId = res.body.videoChannels[0].id
+      const { videoChannels } = await server.users.getMyInfo()
+      channelId = videoChannels[0].id
     }
   })
 
@@ -68,7 +60,7 @@ describe('Test video imports API validator', function () {
     })
 
     it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path: myPath, statusCodeExpected: HttpStatusCode.OK_200, token: server.accessToken })
+      await makeGetRequest({ url: server.url, path: myPath, expectedStatus: HttpStatusCode.OK_200, token: server.accessToken })
     })
   })
 
@@ -77,7 +69,7 @@ describe('Test video imports API validator', function () {
 
     before(function () {
       baseCorrectParams = {
-        targetUrl: getGoodVideoUrl(),
+        targetUrl: FIXTURE_URLS.goodVideo,
         name: 'my super name',
         category: 5,
         licence: 1,
@@ -106,48 +98,48 @@ describe('Test video imports API validator', function () {
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
     it('Should fail with a bad target url', async function () {
-      const fields = immutableAssign(baseCorrectParams, { targetUrl: 'htt://hello' })
+      const fields = { ...baseCorrectParams, targetUrl: 'htt://hello' }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a long name', async function () {
-      const fields = immutableAssign(baseCorrectParams, { name: 'super'.repeat(65) })
+      const fields = { ...baseCorrectParams, name: 'super'.repeat(65) }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad category', async function () {
-      const fields = immutableAssign(baseCorrectParams, { category: 125 })
+      const fields = { ...baseCorrectParams, category: 125 }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad licence', async function () {
-      const fields = immutableAssign(baseCorrectParams, { licence: 125 })
+      const fields = { ...baseCorrectParams, licence: 125 }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad language', async function () {
-      const fields = immutableAssign(baseCorrectParams, { language: 'a'.repeat(15) })
+      const fields = { ...baseCorrectParams, language: 'a'.repeat(15) }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a long description', async function () {
-      const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(2500) })
+      const fields = { ...baseCorrectParams, description: 'super'.repeat(2500) }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a long support text', async function () {
-      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
+      const fields = { ...baseCorrectParams, support: 'super'.repeat(201) }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -159,7 +151,7 @@ describe('Test video imports API validator', function () {
     })
 
     it('Should fail with a bad channel', async function () {
-      const fields = immutableAssign(baseCorrectParams, { channelId: 545454 })
+      const fields = { ...baseCorrectParams, channelId: 545454 }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -169,31 +161,31 @@ describe('Test video imports API validator', function () {
         username: 'fake',
         password: 'fake_password'
       }
-      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+      await server.users.create({ username: user.username, password: user.password })
 
-      const accessTokenUser = await userLogin(server, user)
-      const res = await getMyUserInformation(server.url, accessTokenUser)
-      const customChannelId = res.body.videoChannels[0].id
+      const accessTokenUser = await server.login.getAccessToken(user)
+      const { videoChannels } = await server.users.getMyInfo({ token: accessTokenUser })
+      const customChannelId = videoChannels[0].id
 
-      const fields = immutableAssign(baseCorrectParams, { channelId: customChannelId })
+      const fields = { ...baseCorrectParams, channelId: customChannelId }
 
       await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields })
     })
 
     it('Should fail with too many tags', async function () {
-      const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] })
+      const fields = { ...baseCorrectParams, tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a tag length too low', async function () {
-      const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 't' ] })
+      const fields = { ...baseCorrectParams, tags: [ 'tag1', 't' ] }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a tag length too big', async function () {
-      const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] })
+      const fields = { ...baseCorrectParams, tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -245,7 +237,7 @@ describe('Test video imports API validator', function () {
 
     it('Should fail with an invalid magnet URI', async function () {
       let fields = omit(baseCorrectParams, 'targetUrl')
-      fields = immutableAssign(fields, { magnetUri: 'blabla' })
+      fields = { ...fields, magnetUri: 'blabla' }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -258,19 +250,21 @@ describe('Test video imports API validator', function () {
         path,
         token: server.accessToken,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
 
     it('Should forbid to import http videos', async function () {
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        import: {
-          videos: {
-            http: {
-              enabled: false
-            },
-            torrent: {
-              enabled: true
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          import: {
+            videos: {
+              http: {
+                enabled: false
+              },
+              torrent: {
+                enabled: true
+              }
             }
           }
         }
@@ -281,33 +275,35 @@ describe('Test video imports API validator', function () {
         path,
         token: server.accessToken,
         fields: baseCorrectParams,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
 
     it('Should forbid to import torrent videos', async function () {
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        import: {
-          videos: {
-            http: {
-              enabled: true
-            },
-            torrent: {
-              enabled: false
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          import: {
+            videos: {
+              http: {
+                enabled: true
+              },
+              torrent: {
+                enabled: false
+              }
             }
           }
         }
       })
 
       let fields = omit(baseCorrectParams, 'targetUrl')
-      fields = immutableAssign(fields, { magnetUri: getMagnetURI() })
+      fields = { ...fields, magnetUri: FIXTURE_URLS.magnet }
 
       await makePostBodyRequest({
         url: server.url,
         path,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
 
       fields = omit(fields, 'magnetUri')
@@ -321,7 +317,7 @@ describe('Test video imports API validator', function () {
         token: server.accessToken,
         fields,
         attaches,
-        statusCodeExpected: HttpStatusCode.CONFLICT_409
+        expectedStatus: HttpStatusCode.CONFLICT_409
       })
     })
   })
diff --git a/server/tests/api/check-params/video-playlists.ts b/server/tests/api/check-params/video-playlists.ts
index 18253d11a..e4d541b48 100644
--- a/server/tests/api/check-params/video-playlists.ts
+++ b/server/tests/api/check-params/video-playlists.ts
@@ -1,34 +1,31 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { VideoPlaylistCreateResult, VideoPlaylistPrivacy, VideoPlaylistType } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoInPlaylist,
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination,
   cleanupTests,
-  createVideoPlaylist,
-  deleteVideoPlaylist,
-  flushAndRunServer,
-  generateUserAccessToken,
-  getAccountPlaylistsListWithToken,
-  getVideoPlaylist,
-  immutableAssign,
+  createSingleServer,
   makeGetRequest,
-  removeVideoFromPlaylist,
-  reorderVideosPlaylist,
-  ServerInfo,
+  PeerTubeServer,
+  PlaylistsCommand,
   setAccessTokensToServers,
-  setDefaultVideoChannel,
-  updateVideoPlaylist,
-  updateVideoPlaylistElement,
-  uploadVideoAndGetId
-} from '../../../../shared/extra-utils'
+  setDefaultVideoChannel
+} from '@shared/extra-utils'
+import {
+  HttpStatusCode,
+  VideoPlaylistCreate,
+  VideoPlaylistCreateResult,
+  VideoPlaylistElementCreate,
+  VideoPlaylistElementUpdate,
+  VideoPlaylistPrivacy,
+  VideoPlaylistReorder,
+  VideoPlaylistType
+} from '@shared/models'
 
 describe('Test video playlists API validator', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken: string
 
   let playlist: VideoPlaylistCreateResult
@@ -36,49 +33,54 @@ describe('Test video playlists API validator', function () {
 
   let watchLaterPlaylistId: number
   let videoId: number
-  let playlistElementId: number
+  let elementId: number
+
+  let command: PlaylistsCommand
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
     await setDefaultVideoChannel([ server ])
 
-    userAccessToken = await generateUserAccessToken(server, 'user1')
-    videoId = (await uploadVideoAndGetId({ server, videoName: 'video 1' })).id
+    userAccessToken = await server.users.generateUserAndToken('user1')
+    videoId = (await server.videos.quickUpload({ name: 'video 1' })).id
+
+    command = server.playlists
 
     {
-      const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root', 0, 5, VideoPlaylistType.WATCH_LATER)
-      watchLaterPlaylistId = res.body.data[0].id
+      const { data } = await command.listByAccount({
+        token: server.accessToken,
+        handle: 'root',
+        start: 0,
+        count: 5,
+        playlistType: VideoPlaylistType.WATCH_LATER
+      })
+      watchLaterPlaylistId = data[0].id
     }
 
     {
-      const res = await createVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
+      playlist = await command.create({
+        attributes: {
           displayName: 'super playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: server.videoChannel.id
+          videoChannelId: server.store.channel.id
         }
       })
-      playlist = res.body.videoPlaylist
     }
 
     {
-      const res = await createVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
+      const created = await command.create({
+        attributes: {
           displayName: 'private',
           privacy: VideoPlaylistPrivacy.PRIVATE
         }
       })
-      privatePlaylistUUID = res.body.videoPlaylist.uuid
+      privatePlaylistUUID = created.uuid
     }
   })
 
@@ -117,7 +119,7 @@ describe('Test video playlists API validator', function () {
       await makeGetRequest({
         url: server.url,
         path: accountPath,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404,
+        expectedStatus: HttpStatusCode.NOT_FOUND_404,
         token: server.accessToken
       })
     })
@@ -128,18 +130,18 @@ describe('Test video playlists API validator', function () {
       await makeGetRequest({
         url: server.url,
         path: accountPath,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404,
+        expectedStatus: HttpStatusCode.NOT_FOUND_404,
         token: server.accessToken
       })
     })
 
     it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path: globalPath, statusCodeExpected: HttpStatusCode.OK_200, token: server.accessToken })
-      await makeGetRequest({ url: server.url, path: accountPath, statusCodeExpected: HttpStatusCode.OK_200, token: server.accessToken })
+      await makeGetRequest({ url: server.url, path: globalPath, expectedStatus: HttpStatusCode.OK_200, token: server.accessToken })
+      await makeGetRequest({ url: server.url, path: accountPath, expectedStatus: HttpStatusCode.OK_200, token: server.accessToken })
       await makeGetRequest({
         url: server.url,
         path: videoChannelPath,
-        statusCodeExpected: HttpStatusCode.OK_200,
+        expectedStatus: HttpStatusCode.OK_200,
         token: server.accessToken
       })
     })
@@ -157,141 +159,144 @@ describe('Test video playlists API validator', function () {
     })
 
     it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path: path + playlist.shortUUID + '/videos', statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, path: path + playlist.shortUUID + '/videos', expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
   describe('When getting a video playlist', function () {
     it('Should fail with a bad id or uuid', async function () {
-      await getVideoPlaylist(server.url, 'toto', HttpStatusCode.BAD_REQUEST_400)
+      await command.get({ playlistId: 'toto', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with an unknown playlist', async function () {
-      await getVideoPlaylist(server.url, 42, HttpStatusCode.NOT_FOUND_404)
+      await command.get({ playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail to get an unlisted playlist with the number id', async function () {
-      const res = await createVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
+      const playlist = await command.create({
+        attributes: {
           displayName: 'super playlist',
-          videoChannelId: server.videoChannel.id,
+          videoChannelId: server.store.channel.id,
           privacy: VideoPlaylistPrivacy.UNLISTED
         }
       })
-      const playlist = res.body.videoPlaylist
 
-      await getVideoPlaylist(server.url, playlist.id, HttpStatusCode.NOT_FOUND_404)
-      await getVideoPlaylist(server.url, playlist.uuid, HttpStatusCode.OK_200)
+      await command.get({ playlistId: playlist.id, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+      await command.get({ playlistId: playlist.uuid, expectedStatus: HttpStatusCode.OK_200 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await getVideoPlaylist(server.url, playlist.uuid, HttpStatusCode.OK_200)
+      await command.get({ playlistId: playlist.uuid, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
   describe('When creating/updating a video playlist', function () {
-    const getBase = (playlistAttrs: any = {}, wrapper: any = {}) => {
-      return Object.assign({
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: Object.assign({
+    const getBase = (
+      attributes?: Partial<VideoPlaylistCreate>,
+      wrapper?: Partial<Parameters<PlaylistsCommand['create']>[0]>
+    ) => {
+      return {
+        attributes: {
           displayName: 'display name',
           privacy: VideoPlaylistPrivacy.UNLISTED,
           thumbnailfile: 'thumbnail.jpg',
-          videoChannelId: server.videoChannel.id
-        }, playlistAttrs)
-      }, wrapper)
+          videoChannelId: server.store.channel.id,
+
+          ...attributes
+        },
+
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+
+        ...wrapper
+      }
     }
     const getUpdate = (params: any, playlistId: number | string) => {
-      return immutableAssign(params, { playlistId: playlistId })
+      return { ...params, playlistId: playlistId }
     }
 
     it('Should fail with an unauthenticated user', async function () {
       const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 
-      await createVideoPlaylist(params)
-      await updateVideoPlaylist(getUpdate(params, playlist.shortUUID))
+      await command.create(params)
+      await command.update(getUpdate(params, playlist.shortUUID))
     })
 
     it('Should fail without displayName', async function () {
       const params = getBase({ displayName: undefined })
 
-      await createVideoPlaylist(params)
+      await command.create(params)
     })
 
     it('Should fail with an incorrect display name', async function () {
       const params = getBase({ displayName: 's'.repeat(300) })
 
-      await createVideoPlaylist(params)
-      await updateVideoPlaylist(getUpdate(params, playlist.shortUUID))
+      await command.create(params)
+      await command.update(getUpdate(params, playlist.shortUUID))
     })
 
     it('Should fail with an incorrect description', async function () {
       const params = getBase({ description: 't' })
 
-      await createVideoPlaylist(params)
-      await updateVideoPlaylist(getUpdate(params, playlist.shortUUID))
+      await command.create(params)
+      await command.update(getUpdate(params, playlist.shortUUID))
     })
 
     it('Should fail with an incorrect privacy', async function () {
       const params = getBase({ privacy: 45 })
 
-      await createVideoPlaylist(params)
-      await updateVideoPlaylist(getUpdate(params, playlist.shortUUID))
+      await command.create(params)
+      await command.update(getUpdate(params, playlist.shortUUID))
     })
 
     it('Should fail with an unknown video channel id', async function () {
       const params = getBase({ videoChannelId: 42 }, { expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 
-      await createVideoPlaylist(params)
-      await updateVideoPlaylist(getUpdate(params, playlist.shortUUID))
+      await command.create(params)
+      await command.update(getUpdate(params, playlist.shortUUID))
     })
 
     it('Should fail with an incorrect thumbnail file', async function () {
       const params = getBase({ thumbnailfile: 'video_short.mp4' })
 
-      await createVideoPlaylist(params)
-      await updateVideoPlaylist(getUpdate(params, playlist.shortUUID))
+      await command.create(params)
+      await command.update(getUpdate(params, playlist.shortUUID))
     })
 
     it('Should fail with a thumbnail file too big', async function () {
       const params = getBase({ thumbnailfile: 'preview-big.png' })
 
-      await createVideoPlaylist(params)
-      await updateVideoPlaylist(getUpdate(params, playlist.shortUUID))
+      await command.create(params)
+      await command.update(getUpdate(params, playlist.shortUUID))
     })
 
     it('Should fail to set "public" a playlist not assigned to a channel', async function () {
       const params = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: undefined })
-      const params2 = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: 'null' })
-      const params3 = getBase({ privacy: undefined, videoChannelId: 'null' })
+      const params2 = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: 'null' as any })
+      const params3 = getBase({ privacy: undefined, videoChannelId: 'null' as any })
 
-      await createVideoPlaylist(params)
-      await createVideoPlaylist(params2)
-      await updateVideoPlaylist(getUpdate(params, privatePlaylistUUID))
-      await updateVideoPlaylist(getUpdate(params2, playlist.shortUUID))
-      await updateVideoPlaylist(getUpdate(params3, playlist.shortUUID))
+      await command.create(params)
+      await command.create(params2)
+      await command.update(getUpdate(params, privatePlaylistUUID))
+      await command.update(getUpdate(params2, playlist.shortUUID))
+      await command.update(getUpdate(params3, playlist.shortUUID))
     })
 
     it('Should fail with an unknown playlist to update', async function () {
-      await updateVideoPlaylist(getUpdate(
+      await command.update(getUpdate(
         getBase({}, { expectedStatus: HttpStatusCode.NOT_FOUND_404 }),
         42
       ))
     })
 
     it('Should fail to update a playlist of another user', async function () {
-      await updateVideoPlaylist(getUpdate(
+      await command.update(getUpdate(
         getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 }),
         playlist.shortUUID
       ))
     })
 
     it('Should fail to update the watch later playlist', async function () {
-      await updateVideoPlaylist(getUpdate(
+      await command.update(getUpdate(
         getBase({}, { expectedStatus: HttpStatusCode.BAD_REQUEST_400 }),
         watchLaterPlaylistId
       ))
@@ -300,146 +305,158 @@ describe('Test video playlists API validator', function () {
     it('Should succeed with the correct params', async function () {
       {
         const params = getBase({}, { expectedStatus: HttpStatusCode.OK_200 })
-        await createVideoPlaylist(params)
+        await command.create(params)
       }
 
       {
         const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
-        await updateVideoPlaylist(getUpdate(params, playlist.shortUUID))
+        await command.update(getUpdate(params, playlist.shortUUID))
       }
     })
   })
 
   describe('When adding an element in a playlist', function () {
-    const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
-      return Object.assign({
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlist.id,
-        elementAttrs: Object.assign({
+    const getBase = (
+      attributes?: Partial<VideoPlaylistElementCreate>,
+      wrapper?: Partial<Parameters<PlaylistsCommand['addElement']>[0]>
+    ) => {
+      return {
+        attributes: {
           videoId,
           startTimestamp: 2,
-          stopTimestamp: 3
-        }, elementAttrs)
-      }, wrapper)
+          stopTimestamp: 3,
+
+          ...attributes
+        },
+
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+        playlistId: playlist.id,
+
+        ...wrapper
+      }
     }
 
     it('Should fail with an unauthenticated user', async function () {
       const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
-      await addVideoInPlaylist(params)
+      await command.addElement(params)
     })
 
     it('Should fail with the playlist of another user', async function () {
       const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      await addVideoInPlaylist(params)
+      await command.addElement(params)
     })
 
     it('Should fail with an unknown or incorrect playlist id', async function () {
       {
         const params = getBase({}, { playlistId: 'toto' })
-        await addVideoInPlaylist(params)
+        await command.addElement(params)
       }
 
       {
         const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-        await addVideoInPlaylist(params)
+        await command.addElement(params)
       }
     })
 
     it('Should fail with an unknown or incorrect video id', async function () {
       const params = getBase({ videoId: 42 }, { expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-      await addVideoInPlaylist(params)
+      await command.addElement(params)
     })
 
     it('Should fail with a bad start/stop timestamp', async function () {
       {
         const params = getBase({ startTimestamp: -42 })
-        await addVideoInPlaylist(params)
+        await command.addElement(params)
       }
 
       {
         const params = getBase({ stopTimestamp: 'toto' as any })
-        await addVideoInPlaylist(params)
+        await command.addElement(params)
       }
     })
 
     it('Succeed with the correct params', async function () {
       const params = getBase({}, { expectedStatus: HttpStatusCode.OK_200 })
-      const res = await addVideoInPlaylist(params)
-      playlistElementId = res.body.videoPlaylistElement.id
+      const created = await command.addElement(params)
+      elementId = created.id
     })
   })
 
   describe('When updating an element in a playlist', function () {
-    const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
-      return Object.assign({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: Object.assign({
+    const getBase = (
+      attributes?: Partial<VideoPlaylistElementUpdate>,
+      wrapper?: Partial<Parameters<PlaylistsCommand['updateElement']>[0]>
+    ) => {
+      return {
+        attributes: {
           startTimestamp: 1,
-          stopTimestamp: 2
-        }, elementAttrs),
-        playlistElementId,
+          stopTimestamp: 2,
+
+          ...attributes
+        },
+
+        elementId,
         playlistId: playlist.id,
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400
-      }, wrapper)
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+
+        ...wrapper
+      }
     }
 
     it('Should fail with an unauthenticated user', async function () {
       const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
-      await updateVideoPlaylistElement(params)
+      await command.updateElement(params)
     })
 
     it('Should fail with the playlist of another user', async function () {
       const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      await updateVideoPlaylistElement(params)
+      await command.updateElement(params)
     })
 
     it('Should fail with an unknown or incorrect playlist id', async function () {
       {
         const params = getBase({}, { playlistId: 'toto' })
-        await updateVideoPlaylistElement(params)
+        await command.updateElement(params)
       }
 
       {
         const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-        await updateVideoPlaylistElement(params)
+        await command.updateElement(params)
       }
     })
 
     it('Should fail with an unknown or incorrect playlistElement id', async function () {
       {
-        const params = getBase({}, { playlistElementId: 'toto' })
-        await updateVideoPlaylistElement(params)
+        const params = getBase({}, { elementId: 'toto' })
+        await command.updateElement(params)
       }
 
       {
-        const params = getBase({}, { playlistElementId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-        await updateVideoPlaylistElement(params)
+        const params = getBase({}, { elementId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+        await command.updateElement(params)
       }
     })
 
     it('Should fail with a bad start/stop timestamp', async function () {
       {
         const params = getBase({ startTimestamp: 'toto' as any })
-        await updateVideoPlaylistElement(params)
+        await command.updateElement(params)
       }
 
       {
         const params = getBase({ stopTimestamp: -42 })
-        await updateVideoPlaylistElement(params)
+        await command.updateElement(params)
       }
     })
 
     it('Should fail with an unknown element', async function () {
-      const params = getBase({}, { playlistElementId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-      await updateVideoPlaylistElement(params)
+      const params = getBase({}, { elementId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+      await command.updateElement(params)
     })
 
     it('Succeed with the correct params', async function () {
       const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
-      await updateVideoPlaylistElement(params)
+      await command.updateElement(params)
     })
   })
 
@@ -447,110 +464,111 @@ describe('Test video playlists API validator', function () {
     let videoId3: number
     let videoId4: number
 
-    const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
-      return Object.assign({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlist.shortUUID,
-        elementAttrs: Object.assign({
+    const getBase = (
+      attributes?: Partial<VideoPlaylistReorder>,
+      wrapper?: Partial<Parameters<PlaylistsCommand['reorderElements']>[0]>
+    ) => {
+      return {
+        attributes: {
           startPosition: 1,
           insertAfterPosition: 2,
-          reorderLength: 3
-        }, elementAttrs),
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400
-      }, wrapper)
+          reorderLength: 3,
+
+          ...attributes
+        },
+
+        playlistId: playlist.shortUUID,
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+
+        ...wrapper
+      }
     }
 
     before(async function () {
-      videoId3 = (await uploadVideoAndGetId({ server, videoName: 'video 3' })).id
-      videoId4 = (await uploadVideoAndGetId({ server, videoName: 'video 4' })).id
+      videoId3 = (await server.videos.quickUpload({ name: 'video 3' })).id
+      videoId4 = (await server.videos.quickUpload({ name: 'video 4' })).id
 
       for (const id of [ videoId3, videoId4 ]) {
-        await addVideoInPlaylist({
-          url: server.url,
-          token: server.accessToken,
-          playlistId: playlist.shortUUID,
-          elementAttrs: { videoId: id }
-        })
+        await command.addElement({ playlistId: playlist.shortUUID, attributes: { videoId: id } })
       }
     })
 
     it('Should fail with an unauthenticated user', async function () {
       const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
-      await reorderVideosPlaylist(params)
+      await command.reorderElements(params)
     })
 
     it('Should fail with the playlist of another user', async function () {
       const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      await reorderVideosPlaylist(params)
+      await command.reorderElements(params)
     })
 
     it('Should fail with an invalid playlist', async function () {
       {
         const params = getBase({}, { playlistId: 'toto' })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
 
       {
         const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
     })
 
     it('Should fail with an invalid start position', async function () {
       {
         const params = getBase({ startPosition: -1 })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
 
       {
         const params = getBase({ startPosition: 'toto' as any })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
 
       {
         const params = getBase({ startPosition: 42 })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
     })
 
     it('Should fail with an invalid insert after position', async function () {
       {
         const params = getBase({ insertAfterPosition: 'toto' as any })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
 
       {
         const params = getBase({ insertAfterPosition: -2 })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
 
       {
         const params = getBase({ insertAfterPosition: 42 })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
     })
 
     it('Should fail with an invalid reorder length', async function () {
       {
         const params = getBase({ reorderLength: 'toto' as any })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
 
       {
         const params = getBase({ reorderLength: -2 })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
 
       {
         const params = getBase({ reorderLength: 42 })
-        await reorderVideosPlaylist(params)
+        await command.reorderElements(params)
       }
     })
 
     it('Succeed with the correct params', async function () {
       const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
-      await reorderVideosPlaylist(params)
+      await command.reorderElements(params)
     })
   })
 
@@ -562,7 +580,7 @@ describe('Test video playlists API validator', function () {
         url: server.url,
         path,
         query: { videoIds: [ 1, 2 ] },
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       })
     })
 
@@ -595,82 +613,82 @@ describe('Test video playlists API validator', function () {
         token: server.accessToken,
         path,
         query: { videoIds: [ 1, 2 ] },
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     })
   })
 
   describe('When deleting an element in a playlist', function () {
-    const getBase = (wrapper: any = {}) => {
-      return Object.assign({
-        url: server.url,
-        token: server.accessToken,
-        playlistElementId,
+    const getBase = (wrapper: Partial<Parameters<PlaylistsCommand['removeElement']>[0]>) => {
+      return {
+        elementId,
         playlistId: playlist.uuid,
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400
-      }, wrapper)
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+
+        ...wrapper
+      }
     }
 
     it('Should fail with an unauthenticated user', async function () {
       const params = getBase({ token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
-      await removeVideoFromPlaylist(params)
+      await command.removeElement(params)
     })
 
     it('Should fail with the playlist of another user', async function () {
       const params = getBase({ token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      await removeVideoFromPlaylist(params)
+      await command.removeElement(params)
     })
 
     it('Should fail with an unknown or incorrect playlist id', async function () {
       {
         const params = getBase({ playlistId: 'toto' })
-        await removeVideoFromPlaylist(params)
+        await command.removeElement(params)
       }
 
       {
         const params = getBase({ playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-        await removeVideoFromPlaylist(params)
+        await command.removeElement(params)
       }
     })
 
     it('Should fail with an unknown or incorrect video id', async function () {
       {
-        const params = getBase({ playlistElementId: 'toto' })
-        await removeVideoFromPlaylist(params)
+        const params = getBase({ elementId: 'toto' as any })
+        await command.removeElement(params)
       }
 
       {
-        const params = getBase({ playlistElementId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-        await removeVideoFromPlaylist(params)
+        const params = getBase({ elementId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+        await command.removeElement(params)
       }
     })
 
     it('Should fail with an unknown element', async function () {
-      const params = getBase({ playlistElementId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-      await removeVideoFromPlaylist(params)
+      const params = getBase({ elementId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+      await command.removeElement(params)
     })
 
     it('Succeed with the correct params', async function () {
       const params = getBase({ expectedStatus: HttpStatusCode.NO_CONTENT_204 })
-      await removeVideoFromPlaylist(params)
+      await command.removeElement(params)
     })
   })
 
   describe('When deleting a playlist', function () {
     it('Should fail with an unknown playlist', async function () {
-      await deleteVideoPlaylist(server.url, server.accessToken, 42, HttpStatusCode.NOT_FOUND_404)
+      await command.delete({ playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a playlist of another user', async function () {
-      await deleteVideoPlaylist(server.url, userAccessToken, playlist.uuid, HttpStatusCode.FORBIDDEN_403)
+      await command.delete({ token: userAccessToken, playlistId: playlist.uuid, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with the watch later playlist', async function () {
-      await deleteVideoPlaylist(server.url, server.accessToken, watchLaterPlaylistId, HttpStatusCode.BAD_REQUEST_400)
+      await command.delete({ playlistId: watchLaterPlaylistId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await deleteVideoPlaylist(server.url, server.accessToken, playlist.uuid)
+      await command.delete({ playlistId: playlist.uuid })
     })
   })
 
diff --git a/server/tests/api/check-params/videos-filter.ts b/server/tests/api/check-params/videos-filter.ts
index 4d54a4fd0..d08570bbe 100644
--- a/server/tests/api/check-params/videos-filter.ts
+++ b/server/tests/api/check-params/videos-filter.ts
@@ -3,18 +3,15 @@
 import 'mocha'
 import {
   cleanupTests,
-  createUser,
-  flushAndRunServer,
+  createSingleServer,
   makeGetRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  setDefaultVideoChannel,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { UserRole } from '../../../../shared/models/users'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+  setDefaultVideoChannel
+} from '@shared/extra-utils'
+import { HttpStatusCode, UserRole } from '@shared/models'
 
-async function testEndpoints (server: ServerInfo, token: string, filter: string, statusCodeExpected: HttpStatusCode) {
+async function testEndpoints (server: PeerTubeServer, token: string, filter: string, expectedStatus: HttpStatusCode) {
   const paths = [
     '/api/v1/video-channels/root_channel/videos',
     '/api/v1/accounts/root/videos',
@@ -30,13 +27,13 @@ async function testEndpoints (server: ServerInfo, token: string, filter: string,
       query: {
         filter
       },
-      statusCodeExpected
+      expectedStatus
     })
   }
 }
 
 describe('Test video filters validators', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken: string
   let moderatorAccessToken: string
 
@@ -45,28 +42,19 @@ describe('Test video filters validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
     await setDefaultVideoChannel([ server ])
 
     const user = { username: 'user1', password: 'my super password' }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(server, user)
+    await server.users.create({ username: user.username, password: user.password })
+    userAccessToken = await server.login.getAccessToken(user)
 
     const moderator = { username: 'moderator', password: 'my super password' }
-    await createUser(
-      {
-        url: server.url,
-        accessToken: server.accessToken,
-        username: moderator.username,
-        password: moderator.password,
-        videoQuota: undefined,
-        videoQuotaDaily: undefined,
-        role: UserRole.MODERATOR
-      }
-    )
-    moderatorAccessToken = await userLogin(server, moderator)
+    await server.users.create({ username: moderator.username, password: moderator.password, role: UserRole.MODERATOR })
+
+    moderatorAccessToken = await server.login.getAccessToken(moderator)
   })
 
   describe('When setting a video filter', function () {
@@ -100,7 +88,7 @@ describe('Test video filters validators', function () {
         await makeGetRequest({
           url: server.url,
           path: '/feeds/videos.json',
-          statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401,
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401,
           query: {
             filter
           }
@@ -112,7 +100,7 @@ describe('Test video filters validators', function () {
       await makeGetRequest({
         url: server.url,
         path: '/feeds/videos.json',
-        statusCodeExpected: HttpStatusCode.OK_200,
+        expectedStatus: HttpStatusCode.OK_200,
         query: {
           filter: 'local'
         }
diff --git a/server/tests/api/check-params/videos-history.ts b/server/tests/api/check-params/videos-history.ts
index 0e91fe0a8..c3c309ed2 100644
--- a/server/tests/api/check-params/videos-history.ts
+++ b/server/tests/api/check-params/videos-history.ts
@@ -5,42 +5,39 @@ import {
   checkBadCountPagination,
   checkBadStartPagination,
   cleanupTests,
-  flushAndRunServer,
+  createSingleServer,
   makeGetRequest,
   makePostBodyRequest,
   makePutBodyRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo
-} from '../../../../shared/extra-utils'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test videos history API validator', function () {
   const myHistoryPath = '/api/v1/users/me/history/videos'
   const myHistoryRemove = myHistoryPath + '/remove'
   let watchingPath: string
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
-    const res = await uploadVideo(server.url, server.accessToken, {})
-    const videoUUID = res.body.video.uuid
-
-    watchingPath = '/api/v1/videos/' + videoUUID + '/watching'
+    const { uuid } = await server.videos.upload()
+    watchingPath = '/api/v1/videos/' + uuid + '/watching'
   })
 
   describe('When notifying a user is watching a video', function () {
 
     it('Should fail with an unauthenticated user', async function () {
       const fields = { currentTime: 5 }
-      await makePutBodyRequest({ url: server.url, path: watchingPath, fields, statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makePutBodyRequest({ url: server.url, path: watchingPath, fields, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with an incorrect video id', async function () {
@@ -51,7 +48,7 @@ describe('Test videos history API validator', function () {
         path,
         fields,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -64,7 +61,7 @@ describe('Test videos history API validator', function () {
         path,
         fields,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -75,7 +72,7 @@ describe('Test videos history API validator', function () {
         path: watchingPath,
         fields,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -87,7 +84,7 @@ describe('Test videos history API validator', function () {
         path: watchingPath,
         fields,
         token: server.accessToken,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -102,17 +99,17 @@ describe('Test videos history API validator', function () {
     })
 
     it('Should fail with an unauthenticated user', async function () {
-      await makeGetRequest({ url: server.url, path: myHistoryPath, statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makeGetRequest({ url: server.url, path: myHistoryPath, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await makeGetRequest({ url: server.url, token: server.accessToken, path: myHistoryPath, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, token: server.accessToken, path: myHistoryPath, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
   describe('When removing user videos history', function () {
     it('Should fail with an unauthenticated user', async function () {
-      await makePostBodyRequest({ url: server.url, path: myHistoryPath + '/remove', statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401 })
+      await makePostBodyRequest({ url: server.url, path: myHistoryPath + '/remove', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a bad beforeDate parameter', async function () {
@@ -122,7 +119,7 @@ describe('Test videos history API validator', function () {
         token: server.accessToken,
         path: myHistoryRemove,
         fields: body,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -133,7 +130,7 @@ describe('Test videos history API validator', function () {
         token: server.accessToken,
         path: myHistoryRemove,
         fields: body,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
 
@@ -142,7 +139,7 @@ describe('Test videos history API validator', function () {
         url: server.url,
         token: server.accessToken,
         path: myHistoryRemove,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
diff --git a/server/tests/api/check-params/videos-overviews.ts b/server/tests/api/check-params/videos-overviews.ts
index 69d7fc471..c2139d74b 100644
--- a/server/tests/api/check-params/videos-overviews.ts
+++ b/server/tests/api/check-params/videos-overviews.ts
@@ -1,29 +1,28 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../../shared/extra-utils'
-import { getVideosOverview } from '@shared/extra-utils/overviews/overviews'
+import { cleanupTests, createSingleServer, PeerTubeServer } from '@shared/extra-utils'
 
 describe('Test videos overview', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
   })
 
   describe('When getting videos overview', function () {
 
     it('Should fail with a bad pagination', async function () {
-      await getVideosOverview(server.url, 0, 400)
-      await getVideosOverview(server.url, 100, 400)
+      await server.overviews.getVideos({ page: 0, expectedStatus: 400 })
+      await server.overviews.getVideos({ page: 100, expectedStatus: 400 })
     })
 
     it('Should succeed with a good pagination', async function () {
-      await getVideosOverview(server.url, 1)
+      await server.overviews.getVideos({ page: 1 })
     })
   })
 
diff --git a/server/tests/api/check-params/videos.ts b/server/tests/api/check-params/videos.ts
index 4d7a9a23b..e11ca0c82 100644
--- a/server/tests/api/check-params/videos.ts
+++ b/server/tests/api/check-params/videos.ts
@@ -5,39 +5,28 @@ import * as chai from 'chai'
 import { omit } from 'lodash'
 import { join } from 'path'
 import { randomInt } from '@shared/core-utils'
-import { PeerTubeProblemDocument, VideoCreateResult } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
   checkUploadVideoParam,
   cleanupTests,
-  createUser,
-  flushAndRunServer,
-  getMyUserInformation,
-  getVideo,
-  getVideosList,
-  immutableAssign,
+  createSingleServer,
   makeDeleteRequest,
   makeGetRequest,
   makePutBodyRequest,
   makeUploadRequest,
-  removeVideo,
+  PeerTubeServer,
   root,
-  ServerInfo,
-  setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/extra-utils'
-import {
-  checkBadCountPagination,
-  checkBadSortPagination,
-  checkBadStartPagination
-} from '../../../../shared/extra-utils/requests/check-api-params'
-import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode, PeerTubeProblemDocument, VideoCreateResult, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test videos API validator', function () {
   const path = '/api/v1/videos/'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken = ''
   let accountName: string
   let channelId: number
@@ -49,20 +38,20 @@ describe('Test videos API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
     const username = 'user1'
     const password = 'my super password'
-    await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
-    userAccessToken = await userLogin(server, { username, password })
+    await server.users.create({ username: username, password: password })
+    userAccessToken = await server.login.getAccessToken({ username, password })
 
     {
-      const res = await getMyUserInformation(server.url, server.accessToken)
-      channelId = res.body.videoChannels[0].id
-      channelName = res.body.videoChannels[0].name
-      accountName = res.body.account.name + '@' + res.body.account.host
+      const body = await server.users.getMyInfo()
+      channelId = body.videoChannels[0].id
+      channelName = body.videoChannels[0].name
+      accountName = body.account.name + '@' + body.account.host
     }
   })
 
@@ -80,11 +69,11 @@ describe('Test videos API validator', function () {
     })
 
     it('Should fail with a bad skipVideos query', async function () {
-      await makeGetRequest({ url: server.url, path, statusCodeExpected: HttpStatusCode.OK_200, query: { skipCount: 'toto' } })
+      await makeGetRequest({ url: server.url, path, expectedStatus: HttpStatusCode.OK_200, query: { skipCount: 'toto' } })
     })
 
     it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path, statusCodeExpected: HttpStatusCode.OK_200, query: { skipCount: false } })
+      await makeGetRequest({ url: server.url, path, expectedStatus: HttpStatusCode.OK_200, query: { skipCount: false } })
     })
   })
 
@@ -94,7 +83,7 @@ describe('Test videos API validator', function () {
       await makeGetRequest({
         url: server.url,
         path: join(path, 'search'),
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
@@ -111,7 +100,7 @@ describe('Test videos API validator', function () {
     })
 
     it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, path, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -131,7 +120,7 @@ describe('Test videos API validator', function () {
     })
 
     it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, token: server.accessToken, path, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, token: server.accessToken, path, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -155,7 +144,7 @@ describe('Test videos API validator', function () {
     })
 
     it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, path, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -179,7 +168,7 @@ describe('Test videos API validator', function () {
     })
 
     it('Should success with the correct parameters', async function () {
-      await makeGetRequest({ url: server.url, path, statusCodeExpected: HttpStatusCode.OK_200 })
+      await makeGetRequest({ url: server.url, path, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -214,70 +203,70 @@ describe('Test videos API validator', function () {
       it('Should fail with nothing', async function () {
         const fields = {}
         const attaches = {}
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail without name', async function () {
         const fields = omit(baseCorrectParams, 'name')
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a long name', async function () {
-        const fields = immutableAssign(baseCorrectParams, { name: 'super'.repeat(65) })
+        const fields = { ...baseCorrectParams, name: 'super'.repeat(65) }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a bad category', async function () {
-        const fields = immutableAssign(baseCorrectParams, { category: 125 })
+        const fields = { ...baseCorrectParams, category: 125 }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a bad licence', async function () {
-        const fields = immutableAssign(baseCorrectParams, { licence: 125 })
+        const fields = { ...baseCorrectParams, licence: 125 }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a bad language', async function () {
-        const fields = immutableAssign(baseCorrectParams, { language: 'a'.repeat(15) })
+        const fields = { ...baseCorrectParams, language: 'a'.repeat(15) }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a long description', async function () {
-        const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(2500) })
+        const fields = { ...baseCorrectParams, description: 'super'.repeat(2500) }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a long support text', async function () {
-        const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
+        const fields = { ...baseCorrectParams, support: 'super'.repeat(201) }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail without a channel', async function () {
         const fields = omit(baseCorrectParams, 'channelId')
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a bad channel', async function () {
-        const fields = immutableAssign(baseCorrectParams, { channelId: 545454 })
+        const fields = { ...baseCorrectParams, channelId: 545454 }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with another user channel', async function () {
@@ -285,69 +274,71 @@ describe('Test videos API validator', function () {
           username: 'fake' + randomInt(0, 1500),
           password: 'fake_password'
         }
-        await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+        await server.users.create({ username: user.username, password: user.password })
 
-        const accessTokenUser = await userLogin(server, user)
-        const res = await getMyUserInformation(server.url, accessTokenUser)
-        const customChannelId = res.body.videoChannels[0].id
+        const accessTokenUser = await server.login.getAccessToken(user)
+        const { videoChannels } = await server.users.getMyInfo({ token: accessTokenUser })
+        const customChannelId = videoChannels[0].id
 
-        const fields = immutableAssign(baseCorrectParams, { channelId: customChannelId })
+        const fields = { ...baseCorrectParams, channelId: customChannelId }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, userAccessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, userAccessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with too many tags', async function () {
-        const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] })
+        const fields = { ...baseCorrectParams, tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a tag length too low', async function () {
-        const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 't' ] })
+        const fields = { ...baseCorrectParams, tags: [ 'tag1', 't' ] }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a tag length too big', async function () {
-        const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] })
+        const fields = { ...baseCorrectParams, tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a bad schedule update (miss updateAt)', async function () {
-        const fields = immutableAssign(baseCorrectParams, { scheduleUpdate: { privacy: VideoPrivacy.PUBLIC } })
+        const fields = { ...baseCorrectParams, scheduleUpdate: { privacy: VideoPrivacy.PUBLIC } }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a bad schedule update (wrong updateAt)', async function () {
-        const fields = immutableAssign(baseCorrectParams, {
+        const fields = {
+          ...baseCorrectParams,
+
           scheduleUpdate: {
             privacy: VideoPrivacy.PUBLIC,
             updateAt: 'toto'
           }
-        })
+        }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a bad originally published at attribute', async function () {
-        const fields = immutableAssign(baseCorrectParams, { originallyPublishedAt: 'toto' })
+        const fields = { ...baseCorrectParams, originallyPublishedAt: 'toto' }
         const attaches = baseCorrectAttaches
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail without an input file', async function () {
         const fields = baseCorrectParams
         const attaches = {}
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with an incorrect input file', async function () {
@@ -355,7 +346,7 @@ describe('Test videos API validator', function () {
         let attaches = { fixture: join(root(), 'server', 'tests', 'fixtures', 'video_short_fake.webm') }
 
         await checkUploadVideoParam(
-          server.url,
+          server,
           server.accessToken,
           { ...fields, ...attaches },
           HttpStatusCode.UNPROCESSABLE_ENTITY_422,
@@ -364,7 +355,7 @@ describe('Test videos API validator', function () {
 
         attaches = { fixture: join(root(), 'server', 'tests', 'fixtures', 'video_short.mkv') }
         await checkUploadVideoParam(
-          server.url,
+          server,
           server.accessToken,
           { ...fields, ...attaches },
           HttpStatusCode.UNSUPPORTED_MEDIA_TYPE_415,
@@ -379,7 +370,7 @@ describe('Test videos API validator', function () {
           fixture: join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
         }
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a big thumbnail file', async function () {
@@ -389,7 +380,7 @@ describe('Test videos API validator', function () {
           fixture: join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
         }
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with an incorrect preview file', async function () {
@@ -399,7 +390,7 @@ describe('Test videos API validator', function () {
           fixture: join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
         }
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should fail with a big preview file', async function () {
@@ -409,17 +400,17 @@ describe('Test videos API validator', function () {
           fixture: join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
         }
 
-        await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
+        await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.BAD_REQUEST_400, mode)
       })
 
       it('Should report the appropriate error', async function () {
-        const fields = immutableAssign(baseCorrectParams, { language: 'a'.repeat(15) })
+        const fields = { ...baseCorrectParams, language: 'a'.repeat(15) }
         const attaches = baseCorrectAttaches
 
         const attributes = { ...fields, ...attaches }
-        const res = await checkUploadVideoParam(server.url, server.accessToken, attributes, HttpStatusCode.BAD_REQUEST_400, mode)
+        const body = await checkUploadVideoParam(server, server.accessToken, attributes, HttpStatusCode.BAD_REQUEST_400, mode)
 
-        const error = res.body as PeerTubeProblemDocument
+        const error = body as unknown as PeerTubeProblemDocument
 
         if (mode === 'legacy') {
           expect(error.docs).to.equal('https://docs.joinpeertube.org/api-rest-reference.html#operation/uploadLegacy')
@@ -444,23 +435,27 @@ describe('Test videos API validator', function () {
 
         {
           const attaches = baseCorrectAttaches
-          await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.OK_200, mode)
+          await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.OK_200, mode)
         }
 
         {
-          const attaches = immutableAssign(baseCorrectAttaches, {
+          const attaches = {
+            ...baseCorrectAttaches,
+
             videofile: join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
-          })
+          }
 
-          await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.OK_200, mode)
+          await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.OK_200, mode)
         }
 
         {
-          const attaches = immutableAssign(baseCorrectAttaches, {
+          const attaches = {
+            ...baseCorrectAttaches,
+
             videofile: join(root(), 'server', 'tests', 'fixtures', 'video_short.ogv')
-          })
+          }
 
-          await checkUploadVideoParam(server.url, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.OK_200, mode)
+          await checkUploadVideoParam(server, server.accessToken, { ...fields, ...attaches }, HttpStatusCode.OK_200, mode)
         }
       })
     }
@@ -489,8 +484,8 @@ describe('Test videos API validator', function () {
     }
 
     before(async function () {
-      const res = await getVideosList(server.url)
-      video = res.body.data[0]
+      const { data } = await server.videos.list()
+      video = data[0]
     })
 
     it('Should fail with nothing', async function () {
@@ -511,84 +506,84 @@ describe('Test videos API validator', function () {
         path: path + '4da6fde3-88f7-4d16-b119-108df5630b06',
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
     it('Should fail with a long name', async function () {
-      const fields = immutableAssign(baseCorrectParams, { name: 'super'.repeat(65) })
+      const fields = { ...baseCorrectParams, name: 'super'.repeat(65) }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad category', async function () {
-      const fields = immutableAssign(baseCorrectParams, { category: 125 })
+      const fields = { ...baseCorrectParams, category: 125 }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad licence', async function () {
-      const fields = immutableAssign(baseCorrectParams, { licence: 125 })
+      const fields = { ...baseCorrectParams, licence: 125 }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad language', async function () {
-      const fields = immutableAssign(baseCorrectParams, { language: 'a'.repeat(15) })
+      const fields = { ...baseCorrectParams, language: 'a'.repeat(15) }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a long description', async function () {
-      const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(2500) })
+      const fields = { ...baseCorrectParams, description: 'super'.repeat(2500) }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a long support text', async function () {
-      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
+      const fields = { ...baseCorrectParams, support: 'super'.repeat(201) }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad channel', async function () {
-      const fields = immutableAssign(baseCorrectParams, { channelId: 545454 })
+      const fields = { ...baseCorrectParams, channelId: 545454 }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with too many tags', async function () {
-      const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] })
+      const fields = { ...baseCorrectParams, tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a tag length too low', async function () {
-      const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 't' ] })
+      const fields = { ...baseCorrectParams, tags: [ 'tag1', 't' ] }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a tag length too big', async function () {
-      const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] })
+      const fields = { ...baseCorrectParams, tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad schedule update (miss updateAt)', async function () {
-      const fields = immutableAssign(baseCorrectParams, { scheduleUpdate: { privacy: VideoPrivacy.PUBLIC } })
+      const fields = { ...baseCorrectParams, scheduleUpdate: { privacy: VideoPrivacy.PUBLIC } }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad schedule update (wrong updateAt)', async function () {
-      const fields = immutableAssign(baseCorrectParams, { scheduleUpdate: { updateAt: 'toto', privacy: VideoPrivacy.PUBLIC } })
+      const fields = { ...baseCorrectParams, scheduleUpdate: { updateAt: 'toto', privacy: VideoPrivacy.PUBLIC } }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
 
     it('Should fail with a bad originally published at param', async function () {
-      const fields = immutableAssign(baseCorrectParams, { originallyPublishedAt: 'toto' })
+      const fields = { ...baseCorrectParams, originallyPublishedAt: 'toto' }
 
       await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
     })
@@ -665,14 +660,14 @@ describe('Test videos API validator', function () {
         path: path + video.shortUUID,
         token: userAccessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
     })
 
     it('Should fail with a video of another server')
 
     it('Shoud report the appropriate error', async function () {
-      const fields = immutableAssign(baseCorrectParams, { licence: 125 })
+      const fields = { ...baseCorrectParams, licence: 125 }
 
       const res = await makePutBodyRequest({ url: server.url, path: path + video.shortUUID, token: server.accessToken, fields })
       const error = res.body as PeerTubeProblemDocument
@@ -697,7 +692,7 @@ describe('Test videos API validator', function () {
         path: path + video.shortUUID,
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -707,7 +702,7 @@ describe('Test videos API validator', function () {
       const res = await makeGetRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body.data).to.be.an('array')
@@ -715,16 +710,16 @@ describe('Test videos API validator', function () {
     })
 
     it('Should fail without a correct uuid', async function () {
-      await getVideo(server.url, 'coucou', HttpStatusCode.BAD_REQUEST_400)
+      await server.videos.get({ id: 'coucou', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should return 404 with an incorrect video', async function () {
-      await getVideo(server.url, '4da6fde3-88f7-4d16-b119-108df5630b06', HttpStatusCode.NOT_FOUND_404)
+      await server.videos.get({ id: '4da6fde3-88f7-4d16-b119-108df5630b06', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Shoud report the appropriate error', async function () {
-      const res = await getVideo(server.url, 'hi', HttpStatusCode.BAD_REQUEST_400)
-      const error = res.body as PeerTubeProblemDocument
+      const body = await server.videos.get({ id: 'hi', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+      const error = body as unknown as PeerTubeProblemDocument
 
       expect(error.docs).to.equal('https://docs.joinpeertube.org/api-rest-reference.html#operation/getVideo')
 
@@ -739,16 +734,16 @@ describe('Test videos API validator', function () {
     })
 
     it('Should succeed with the correct parameters', async function () {
-      await getVideo(server.url, video.shortUUID)
+      await server.videos.get({ id: video.shortUUID })
     })
   })
 
   describe('When rating a video', function () {
-    let videoId
+    let videoId: number
 
     before(async function () {
-      const res = await getVideosList(server.url)
-      videoId = res.body.data[0].id
+      const { data } = await server.videos.list()
+      videoId = data[0].id
     })
 
     it('Should fail without a valid uuid', async function () {
@@ -767,7 +762,7 @@ describe('Test videos API validator', function () {
         path: path + '4da6fde3-88f7-4d16-b119-108df5630b06/rate',
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -787,7 +782,7 @@ describe('Test videos API validator', function () {
         path: path + videoId + '/rate',
         token: server.accessToken,
         fields,
-        statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+        expectedStatus: HttpStatusCode.NO_CONTENT_204
       })
     })
   })
@@ -797,27 +792,27 @@ describe('Test videos API validator', function () {
       await makeDeleteRequest({
         url: server.url,
         path,
-        statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
     })
 
     it('Should fail without a correct uuid', async function () {
-      await removeVideo(server.url, server.accessToken, 'hello', HttpStatusCode.BAD_REQUEST_400)
+      await server.videos.remove({ id: 'hello', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with a video which does not exist', async function () {
-      await removeVideo(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', HttpStatusCode.NOT_FOUND_404)
+      await server.videos.remove({ id: '4da6fde3-88f7-4d16-b119-108df5630b06', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a video of another user without the appropriate right', async function () {
-      await removeVideo(server.url, userAccessToken, video.uuid, HttpStatusCode.FORBIDDEN_403)
+      await server.videos.remove({ token: userAccessToken, id: video.uuid, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a video of another server')
 
     it('Shoud report the appropriate error', async function () {
-      const res = await removeVideo(server.url, server.accessToken, 'hello', HttpStatusCode.BAD_REQUEST_400)
-      const error = res.body as PeerTubeProblemDocument
+      const body = await server.videos.remove({ id: 'hello', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+      const error = body as PeerTubeProblemDocument
 
       expect(error.docs).to.equal('https://docs.joinpeertube.org/api-rest-reference.html#operation/delVideo')
 
@@ -832,7 +827,7 @@ describe('Test videos API validator', function () {
     })
 
     it('Should succeed with the correct parameters', async function () {
-      await removeVideo(server.url, server.accessToken, video.uuid)
+      await server.videos.remove({ id: video.uuid })
     })
   })
 
diff --git a/server/tests/api/live/live-constraints.ts b/server/tests/api/live/live-constraints.ts
index cc635de33..4acde3cc5 100644
--- a/server/tests/api/live/live-constraints.ts
+++ b/server/tests/api/live/live-constraints.ts
@@ -2,31 +2,24 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { VideoDetails, VideoPrivacy } from '@shared/models'
+import { VideoPrivacy } from '@shared/models'
 import {
-  checkLiveCleanup,
+  checkLiveCleanupAfterSave,
   cleanupTests,
-  createLive,
+  ConfigCommand,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  generateUser,
-  getCustomConfigResolutions,
-  getVideo,
-  runAndTestFfmpegStreamError,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
-  updateCustomSubConfig,
-  updateUser,
   wait,
-  waitJobs,
-  waitUntilLivePublished
+  waitJobs
 } from '../../../../shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test live constraints', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let userId: number
   let userAccessToken: string
   let userChannelId: number
@@ -39,32 +32,28 @@ describe('Test live constraints', function () {
       saveReplay
     }
 
-    const res = await createLive(servers[0].url, userAccessToken, liveAttributes)
-    return res.body.video.uuid as string
+    const { uuid } = await servers[0].live.create({ token: userAccessToken, fields: liveAttributes })
+    return uuid
   }
 
   async function checkSaveReplay (videoId: string, resolutions = [ 720 ]) {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoId)
-
-      const video: VideoDetails = res.body
+      const video = await server.videos.get({ id: videoId })
       expect(video.isLive).to.be.false
       expect(video.duration).to.be.greaterThan(0)
     }
 
-    await checkLiveCleanup(servers[0], videoId, resolutions)
+    await checkLiveCleanupAfterSave(servers[0], videoId, resolutions)
   }
 
   async function waitUntilLivePublishedOnAllServers (videoId: string) {
     for (const server of servers) {
-      await waitUntilLivePublished(server.url, server.accessToken, videoId)
+      await server.live.waitUntilPublished({ videoId })
     }
   }
 
   function updateQuota (options: { total: number, daily: number }) {
-    return updateUser({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    return servers[0].users.update({
       userId,
       videoQuota: options.total,
       videoQuotaDaily: options.daily
@@ -74,24 +63,26 @@ describe('Test live constraints', function () {
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      live: {
-        enabled: true,
-        allowReplay: true,
-        transcoding: {
-          enabled: false
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          transcoding: {
+            enabled: false
+          }
         }
       }
     })
 
     {
-      const res = await generateUser(servers[0], 'user1')
+      const res = await servers[0].users.generate('user1')
       userId = res.userId
       userChannelId = res.userChannelId
       userAccessToken = res.token
@@ -107,7 +98,7 @@ describe('Test live constraints', function () {
     this.timeout(60000)
 
     const userVideoLiveoId = await createLiveWrapper(false)
-    await runAndTestFfmpegStreamError(servers[0].url, userAccessToken, userVideoLiveoId, false)
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: false })
   })
 
   it('Should have size limit depending on user global quota if save replay is enabled', async function () {
@@ -117,7 +108,7 @@ describe('Test live constraints', function () {
     await wait(5000)
 
     const userVideoLiveoId = await createLiveWrapper(true)
-    await runAndTestFfmpegStreamError(servers[0].url, userAccessToken, userVideoLiveoId, true)
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
 
     await waitUntilLivePublishedOnAllServers(userVideoLiveoId)
     await waitJobs(servers)
@@ -134,7 +125,7 @@ describe('Test live constraints', function () {
     await updateQuota({ total: -1, daily: 1 })
 
     const userVideoLiveoId = await createLiveWrapper(true)
-    await runAndTestFfmpegStreamError(servers[0].url, userAccessToken, userVideoLiveoId, true)
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
 
     await waitUntilLivePublishedOnAllServers(userVideoLiveoId)
     await waitJobs(servers)
@@ -151,26 +142,28 @@ describe('Test live constraints', function () {
     await updateQuota({ total: 10 * 1000 * 1000, daily: -1 })
 
     const userVideoLiveoId = await createLiveWrapper(true)
-    await runAndTestFfmpegStreamError(servers[0].url, userAccessToken, userVideoLiveoId, false)
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: false })
   })
 
   it('Should have max duration limit', async function () {
     this.timeout(60000)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      live: {
-        enabled: true,
-        allowReplay: true,
-        maxDuration: 1,
-        transcoding: {
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
           enabled: true,
-          resolutions: getCustomConfigResolutions(true)
+          allowReplay: true,
+          maxDuration: 1,
+          transcoding: {
+            enabled: true,
+            resolutions: ConfigCommand.getCustomConfigResolutions(true)
+          }
         }
       }
     })
 
     const userVideoLiveoId = await createLiveWrapper(true)
-    await runAndTestFfmpegStreamError(servers[0].url, userAccessToken, userVideoLiveoId, true)
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
 
     await waitUntilLivePublishedOnAllServers(userVideoLiveoId)
     await waitJobs(servers)
diff --git a/server/tests/api/live/live-permanent.ts b/server/tests/api/live/live-permanent.ts
index 71b7d28a8..f07d4cfec 100644
--- a/server/tests/api/live/live-permanent.ts
+++ b/server/tests/api/live/live-permanent.ts
@@ -2,59 +2,50 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { LiveVideoCreate, VideoDetails, VideoPrivacy, VideoState } from '@shared/models'
+import { LiveVideoCreate, VideoPrivacy, VideoState } from '@shared/models'
 import {
   cleanupTests,
-  createLive,
+  ConfigCommand,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getCustomConfigResolutions,
-  getLive,
-  getPlaylistsCount,
-  getVideo,
-  sendRTMPStreamInVideo,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   stopFfmpeg,
-  updateCustomSubConfig,
-  updateLive,
   wait,
-  waitJobs,
-  waitUntilLivePublished,
-  waitUntilLiveWaiting
+  waitJobs
 } from '../../../../shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Permanent live', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoUUID: string
 
   async function createLiveWrapper (permanentLive: boolean) {
     const attributes: LiveVideoCreate = {
-      channelId: servers[0].videoChannel.id,
+      channelId: servers[0].store.channel.id,
       privacy: VideoPrivacy.PUBLIC,
       name: 'my super live',
       saveReplay: false,
       permanentLive
     }
 
-    const res = await createLive(servers[0].url, servers[0].accessToken, attributes)
-    return res.body.video.uuid
+    const { uuid } = await servers[0].live.create({ fields: attributes })
+    return uuid
   }
 
   async function checkVideoState (videoId: string, state: VideoState) {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoId)
-      expect((res.body as VideoDetails).state.id).to.equal(state)
+      const video = await server.videos.get({ id: videoId })
+      expect(video.state.id).to.equal(state)
     }
   }
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -63,14 +54,16 @@ describe('Permanent live', function () {
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      live: {
-        enabled: true,
-        allowReplay: true,
-        maxDuration: -1,
-        transcoding: {
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
           enabled: true,
-          resolutions: getCustomConfigResolutions(true)
+          allowReplay: true,
+          maxDuration: -1,
+          transcoding: {
+            enabled: true,
+            resolutions: ConfigCommand.getCustomConfigResolutions(true)
+          }
         }
       }
     })
@@ -82,15 +75,15 @@ describe('Permanent live', function () {
     const videoUUID = await createLiveWrapper(false)
 
     {
-      const res = await getLive(servers[0].url, servers[0].accessToken, videoUUID)
-      expect(res.body.permanentLive).to.be.false
+      const live = await servers[0].live.get({ videoId: videoUUID })
+      expect(live.permanentLive).to.be.false
     }
 
-    await updateLive(servers[0].url, servers[0].accessToken, videoUUID, { permanentLive: true })
+    await servers[0].live.update({ videoId: videoUUID, fields: { permanentLive: true } })
 
     {
-      const res = await getLive(servers[0].url, servers[0].accessToken, videoUUID)
-      expect(res.body.permanentLive).to.be.true
+      const live = await servers[0].live.get({ videoId: videoUUID })
+      expect(live.permanentLive).to.be.true
     }
   })
 
@@ -99,8 +92,8 @@ describe('Permanent live', function () {
 
     videoUUID = await createLiveWrapper(true)
 
-    const res = await getLive(servers[0].url, servers[0].accessToken, videoUUID)
-    expect(res.body.permanentLive).to.be.true
+    const live = await servers[0].live.get({ videoId: videoUUID })
+    expect(live.permanentLive).to.be.true
 
     await waitJobs(servers)
   })
@@ -108,16 +101,16 @@ describe('Permanent live', function () {
   it('Should stream into this permanent live', async function () {
     this.timeout(120000)
 
-    const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, videoUUID)
+    const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
 
     for (const server of servers) {
-      await waitUntilLivePublished(server.url, server.accessToken, videoUUID)
+      await server.live.waitUntilPublished({ videoId: videoUUID })
     }
 
     await checkVideoState(videoUUID, VideoState.PUBLISHED)
 
-    await stopFfmpeg(command)
-    await waitUntilLiveWaiting(servers[0].url, servers[0].accessToken, videoUUID)
+    await stopFfmpeg(ffmpegCommand)
+    await servers[0].live.waitUntilWaiting({ videoId: videoUUID })
 
     await waitJobs(servers)
   })
@@ -129,9 +122,7 @@ describe('Permanent live', function () {
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-
-      const videoDetails = res.body as VideoDetails
+      const videoDetails = await server.videos.get({ id: videoUUID })
       expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
     }
   })
@@ -145,31 +136,33 @@ describe('Permanent live', function () {
   it('Should be able to stream again in the permanent live', async function () {
     this.timeout(20000)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      live: {
-        enabled: true,
-        allowReplay: true,
-        maxDuration: -1,
-        transcoding: {
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
           enabled: true,
-          resolutions: getCustomConfigResolutions(false)
+          allowReplay: true,
+          maxDuration: -1,
+          transcoding: {
+            enabled: true,
+            resolutions: ConfigCommand.getCustomConfigResolutions(false)
+          }
         }
       }
     })
 
-    const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, videoUUID)
+    const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
 
     for (const server of servers) {
-      await waitUntilLivePublished(server.url, server.accessToken, videoUUID)
+      await server.live.waitUntilPublished({ videoId: videoUUID })
     }
 
     await checkVideoState(videoUUID, VideoState.PUBLISHED)
 
-    const count = await getPlaylistsCount(servers[0], videoUUID)
+    const count = await servers[0].live.countPlaylists({ videoUUID })
     // master playlist and 720p playlist
     expect(count).to.equal(2)
 
-    await stopFfmpeg(command)
+    await stopFfmpeg(ffmpegCommand)
   })
 
   after(async function () {
diff --git a/server/tests/api/live/live-save-replay.ts b/server/tests/api/live/live-save-replay.ts
index 3d4736c8f..8f1fb78a5 100644
--- a/server/tests/api/live/live-save-replay.ts
+++ b/server/tests/api/live/live-save-replay.ts
@@ -3,97 +3,85 @@
 import 'mocha'
 import * as chai from 'chai'
 import { FfmpegCommand } from 'fluent-ffmpeg'
-import { LiveVideoCreate, VideoDetails, VideoPrivacy, VideoState } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoToBlacklist,
-  checkLiveCleanup,
+  checkLiveCleanupAfterSave,
   cleanupTests,
-  createLive,
+  ConfigCommand,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getCustomConfigResolutions,
-  getVideo,
-  getVideosList,
-  removeVideo,
-  sendRTMPStreamInVideo,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   stopFfmpeg,
   testFfmpegStreamError,
-  updateCustomSubConfig,
-  updateVideo,
   wait,
-  waitJobs,
-  waitUntilLiveEnded,
-  waitUntilLivePublished,
-  waitUntilLiveSaved
-} from '../../../../shared/extra-utils'
+  waitJobs
+} from '@shared/extra-utils'
+import { HttpStatusCode, LiveVideoCreate, VideoPrivacy, VideoState } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Save replay setting', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let liveVideoUUID: string
   let ffmpegCommand: FfmpegCommand
 
   async function createLiveWrapper (saveReplay: boolean) {
     if (liveVideoUUID) {
       try {
-        await removeVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+        await servers[0].videos.remove({ id: liveVideoUUID })
         await waitJobs(servers)
       } catch {}
     }
 
     const attributes: LiveVideoCreate = {
-      channelId: servers[0].videoChannel.id,
+      channelId: servers[0].store.channel.id,
       privacy: VideoPrivacy.PUBLIC,
       name: 'my super live',
       saveReplay
     }
 
-    const res = await createLive(servers[0].url, servers[0].accessToken, attributes)
-    return res.body.video.uuid
+    const { uuid } = await servers[0].live.create({ fields: attributes })
+    return uuid
   }
 
-  async function checkVideosExist (videoId: string, existsInList: boolean, getStatus?: number) {
+  async function checkVideosExist (videoId: string, existsInList: boolean, expectedStatus?: number) {
     for (const server of servers) {
       const length = existsInList ? 1 : 0
 
-      const resVideos = await getVideosList(server.url)
-      expect(resVideos.body.data).to.have.lengthOf(length)
-      expect(resVideos.body.total).to.equal(length)
+      const { data, total } = await server.videos.list()
+      expect(data).to.have.lengthOf(length)
+      expect(total).to.equal(length)
 
-      if (getStatus) {
-        await getVideo(server.url, videoId, getStatus)
+      if (expectedStatus) {
+        await server.videos.get({ id: videoId, expectedStatus })
       }
     }
   }
 
   async function checkVideoState (videoId: string, state: VideoState) {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoId)
-      expect((res.body as VideoDetails).state.id).to.equal(state)
+      const video = await server.videos.get({ id: videoId })
+      expect(video.state.id).to.equal(state)
     }
   }
 
   async function waitUntilLivePublishedOnAllServers (videoId: string) {
     for (const server of servers) {
-      await waitUntilLivePublished(server.url, server.accessToken, videoId)
+      await server.live.waitUntilPublished({ videoId })
     }
   }
 
   async function waitUntilLiveSavedOnAllServers (videoId: string) {
     for (const server of servers) {
-      await waitUntilLiveSaved(server.url, server.accessToken, videoId)
+      await server.live.waitUntilSaved({ videoId })
     }
   }
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -102,14 +90,16 @@ describe('Save replay setting', function () {
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      live: {
-        enabled: true,
-        allowReplay: true,
-        maxDuration: -1,
-        transcoding: {
-          enabled: false,
-          resolutions: getCustomConfigResolutions(true)
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          maxDuration: -1,
+          transcoding: {
+            enabled: false,
+            resolutions: ConfigCommand.getCustomConfigResolutions(true)
+          }
         }
       }
     })
@@ -135,7 +125,7 @@ describe('Save replay setting', function () {
     it('Should correctly have updated the live and federated it when streaming in the live', async function () {
       this.timeout(30000)
 
-      ffmpegCommand = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+      ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
 
       await waitUntilLivePublishedOnAllServers(liveVideoUUID)
 
@@ -151,7 +141,7 @@ describe('Save replay setting', function () {
       await stopFfmpeg(ffmpegCommand)
 
       for (const server of servers) {
-        await waitUntilLiveEnded(server.url, server.accessToken, liveVideoUUID)
+        await server.live.waitUntilEnded({ videoId: liveVideoUUID })
       }
       await waitJobs(servers)
 
@@ -160,7 +150,7 @@ describe('Save replay setting', function () {
       await checkVideoState(liveVideoUUID, VideoState.LIVE_ENDED)
 
       // No resolutions saved since we did not save replay
-      await checkLiveCleanup(servers[0], liveVideoUUID, [])
+      await checkLiveCleanupAfterSave(servers[0], liveVideoUUID, [])
     })
 
     it('Should correctly terminate the stream on blacklist and delete the live', async function () {
@@ -168,7 +158,7 @@ describe('Save replay setting', function () {
 
       liveVideoUUID = await createLiveWrapper(false)
 
-      ffmpegCommand = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+      ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
 
       await waitUntilLivePublishedOnAllServers(liveVideoUUID)
 
@@ -176,7 +166,7 @@ describe('Save replay setting', function () {
       await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
 
       await Promise.all([
-        addVideoToBlacklist(servers[0].url, servers[0].accessToken, liveVideoUUID, 'bad live', true),
+        servers[0].blacklist.add({ videoId: liveVideoUUID, reason: 'bad live', unfederate: true }),
         testFfmpegStreamError(ffmpegCommand, true)
       ])
 
@@ -184,12 +174,12 @@ describe('Save replay setting', function () {
 
       await checkVideosExist(liveVideoUUID, false)
 
-      await getVideo(servers[0].url, liveVideoUUID, HttpStatusCode.UNAUTHORIZED_401)
-      await getVideo(servers[1].url, liveVideoUUID, HttpStatusCode.NOT_FOUND_404)
+      await servers[0].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+      await servers[1].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 
       await wait(5000)
       await waitJobs(servers)
-      await checkLiveCleanup(servers[0], liveVideoUUID, [])
+      await checkLiveCleanupAfterSave(servers[0], liveVideoUUID, [])
     })
 
     it('Should correctly terminate the stream on delete and delete the video', async function () {
@@ -197,7 +187,7 @@ describe('Save replay setting', function () {
 
       liveVideoUUID = await createLiveWrapper(false)
 
-      ffmpegCommand = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+      ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
 
       await waitUntilLivePublishedOnAllServers(liveVideoUUID)
 
@@ -206,14 +196,14 @@ describe('Save replay setting', function () {
 
       await Promise.all([
         testFfmpegStreamError(ffmpegCommand, true),
-        removeVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+        servers[0].videos.remove({ id: liveVideoUUID })
       ])
 
       await wait(5000)
       await waitJobs(servers)
 
       await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
-      await checkLiveCleanup(servers[0], liveVideoUUID, [])
+      await checkLiveCleanupAfterSave(servers[0], liveVideoUUID, [])
     })
   })
 
@@ -233,7 +223,7 @@ describe('Save replay setting', function () {
     it('Should correctly have updated the live and federated it when streaming in the live', async function () {
       this.timeout(20000)
 
-      ffmpegCommand = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+      ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
       await waitUntilLivePublishedOnAllServers(liveVideoUUID)
 
       await waitJobs(servers)
@@ -258,18 +248,18 @@ describe('Save replay setting', function () {
     it('Should update the saved live and correctly federate the updated attributes', async function () {
       this.timeout(30000)
 
-      await updateVideo(servers[0].url, servers[0].accessToken, liveVideoUUID, { name: 'video updated' })
+      await servers[0].videos.update({ id: liveVideoUUID, attributes: { name: 'video updated' } })
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideo(server.url, liveVideoUUID)
-        expect(res.body.name).to.equal('video updated')
-        expect(res.body.isLive).to.be.false
+        const video = await server.videos.get({ id: liveVideoUUID })
+        expect(video.name).to.equal('video updated')
+        expect(video.isLive).to.be.false
       }
     })
 
     it('Should have cleaned up the live files', async function () {
-      await checkLiveCleanup(servers[0], liveVideoUUID, [ 720 ])
+      await checkLiveCleanupAfterSave(servers[0], liveVideoUUID, [ 720 ])
     })
 
     it('Should correctly terminate the stream on blacklist and blacklist the saved replay video', async function () {
@@ -277,14 +267,14 @@ describe('Save replay setting', function () {
 
       liveVideoUUID = await createLiveWrapper(true)
 
-      ffmpegCommand = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+      ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
       await waitUntilLivePublishedOnAllServers(liveVideoUUID)
 
       await waitJobs(servers)
       await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
 
       await Promise.all([
-        addVideoToBlacklist(servers[0].url, servers[0].accessToken, liveVideoUUID, 'bad live', true),
+        servers[0].blacklist.add({ videoId: liveVideoUUID, reason: 'bad live', unfederate: true }),
         testFfmpegStreamError(ffmpegCommand, true)
       ])
 
@@ -292,12 +282,12 @@ describe('Save replay setting', function () {
 
       await checkVideosExist(liveVideoUUID, false)
 
-      await getVideo(servers[0].url, liveVideoUUID, HttpStatusCode.UNAUTHORIZED_401)
-      await getVideo(servers[1].url, liveVideoUUID, HttpStatusCode.NOT_FOUND_404)
+      await servers[0].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+      await servers[1].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 
       await wait(5000)
       await waitJobs(servers)
-      await checkLiveCleanup(servers[0], liveVideoUUID, [ 720 ])
+      await checkLiveCleanupAfterSave(servers[0], liveVideoUUID, [ 720 ])
     })
 
     it('Should correctly terminate the stream on delete and delete the video', async function () {
@@ -305,14 +295,14 @@ describe('Save replay setting', function () {
 
       liveVideoUUID = await createLiveWrapper(true)
 
-      ffmpegCommand = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+      ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
       await waitUntilLivePublishedOnAllServers(liveVideoUUID)
 
       await waitJobs(servers)
       await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
 
       await Promise.all([
-        removeVideo(servers[0].url, servers[0].accessToken, liveVideoUUID),
+        servers[0].videos.remove({ id: liveVideoUUID }),
         testFfmpegStreamError(ffmpegCommand, true)
       ])
 
@@ -320,7 +310,7 @@ describe('Save replay setting', function () {
       await waitJobs(servers)
 
       await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
-      await checkLiveCleanup(servers[0], liveVideoUUID, [])
+      await checkLiveCleanupAfterSave(servers[0], liveVideoUUID, [])
     })
   })
 
diff --git a/server/tests/api/live/live-socket-messages.ts b/server/tests/api/live/live-socket-messages.ts
index e00909ade..2a1f9f108 100644
--- a/server/tests/api/live/live-socket-messages.ts
+++ b/server/tests/api/live/live-socket-messages.ts
@@ -2,47 +2,42 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { getLiveNotificationSocket } from '@shared/extra-utils/socket/socket-io'
 import { VideoPrivacy, VideoState } from '@shared/models'
 import {
   cleanupTests,
-  createLive,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getVideoIdFromUUID,
-  sendRTMPStreamInVideo,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   stopFfmpeg,
-  updateCustomSubConfig,
-  viewVideo,
   wait,
   waitJobs,
-  waitUntilLiveEnded,
   waitUntilLivePublishedOnAllServers
 } from '../../../../shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test live', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      live: {
-        enabled: true,
-        allowReplay: true,
-        transcoding: {
-          enabled: false
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          transcoding: {
+            enabled: false
+          }
         }
       }
     })
@@ -56,12 +51,12 @@ describe('Test live', function () {
     async function createLiveWrapper () {
       const liveAttributes = {
         name: 'live video',
-        channelId: servers[0].videoChannel.id,
+        channelId: servers[0].store.channel.id,
         privacy: VideoPrivacy.PUBLIC
       }
 
-      const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes)
-      return res.body.video.uuid
+      const { uuid } = await servers[0].live.create({ fields: liveAttributes })
+      return uuid
     }
 
     it('Should correctly send a message when the live starts and ends', async function () {
@@ -74,22 +69,22 @@ describe('Test live', function () {
       await waitJobs(servers)
 
       {
-        const videoId = await getVideoIdFromUUID(servers[0].url, liveVideoUUID)
+        const videoId = await servers[0].videos.getId({ uuid: liveVideoUUID })
 
-        const localSocket = getLiveNotificationSocket(servers[0].url)
+        const localSocket = servers[0].socketIO.getLiveNotificationSocket()
         localSocket.on('state-change', data => localStateChanges.push(data.state))
         localSocket.emit('subscribe', { videoId })
       }
 
       {
-        const videoId = await getVideoIdFromUUID(servers[1].url, liveVideoUUID)
+        const videoId = await servers[1].videos.getId({ uuid: liveVideoUUID })
 
-        const remoteSocket = getLiveNotificationSocket(servers[1].url)
+        const remoteSocket = servers[1].socketIO.getLiveNotificationSocket()
         remoteSocket.on('state-change', data => remoteStateChanges.push(data.state))
         remoteSocket.emit('subscribe', { videoId })
       }
 
-      const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+      const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
 
       await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
       await waitJobs(servers)
@@ -99,10 +94,10 @@ describe('Test live', function () {
         expect(stateChanges[stateChanges.length - 1]).to.equal(VideoState.PUBLISHED)
       }
 
-      await stopFfmpeg(command)
+      await stopFfmpeg(ffmpegCommand)
 
       for (const server of servers) {
-        await waitUntilLiveEnded(server.url, server.accessToken, liveVideoUUID)
+        await server.live.waitUntilEnded({ videoId: liveVideoUUID })
       }
       await waitJobs(servers)
 
@@ -122,22 +117,22 @@ describe('Test live', function () {
       await waitJobs(servers)
 
       {
-        const videoId = await getVideoIdFromUUID(servers[0].url, liveVideoUUID)
+        const videoId = await servers[0].videos.getId({ uuid: liveVideoUUID })
 
-        const localSocket = getLiveNotificationSocket(servers[0].url)
+        const localSocket = servers[0].socketIO.getLiveNotificationSocket()
         localSocket.on('views-change', data => { localLastVideoViews = data.views })
         localSocket.emit('subscribe', { videoId })
       }
 
       {
-        const videoId = await getVideoIdFromUUID(servers[1].url, liveVideoUUID)
+        const videoId = await servers[1].videos.getId({ uuid: liveVideoUUID })
 
-        const remoteSocket = getLiveNotificationSocket(servers[1].url)
+        const remoteSocket = servers[1].socketIO.getLiveNotificationSocket()
         remoteSocket.on('views-change', data => { remoteLastVideoViews = data.views })
         remoteSocket.emit('subscribe', { videoId })
       }
 
-      const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+      const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
 
       await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
       await waitJobs(servers)
@@ -145,8 +140,8 @@ describe('Test live', function () {
       expect(localLastVideoViews).to.equal(0)
       expect(remoteLastVideoViews).to.equal(0)
 
-      await viewVideo(servers[0].url, liveVideoUUID)
-      await viewVideo(servers[1].url, liveVideoUUID)
+      await servers[0].videos.view({ id: liveVideoUUID })
+      await servers[1].videos.view({ id: liveVideoUUID })
 
       await waitJobs(servers)
       await wait(5000)
@@ -155,7 +150,7 @@ describe('Test live', function () {
       expect(localLastVideoViews).to.equal(2)
       expect(remoteLastVideoViews).to.equal(2)
 
-      await stopFfmpeg(command)
+      await stopFfmpeg(ffmpegCommand)
     })
 
     it('Should not receive a notification after unsubscribe', async function () {
@@ -166,13 +161,13 @@ describe('Test live', function () {
       const liveVideoUUID = await createLiveWrapper()
       await waitJobs(servers)
 
-      const videoId = await getVideoIdFromUUID(servers[0].url, liveVideoUUID)
+      const videoId = await servers[0].videos.getId({ uuid: liveVideoUUID })
 
-      const socket = getLiveNotificationSocket(servers[0].url)
+      const socket = servers[0].socketIO.getLiveNotificationSocket()
       socket.on('state-change', data => stateChanges.push(data.state))
       socket.emit('subscribe', { videoId })
 
-      const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+      const command = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
 
       await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
       await waitJobs(servers)
diff --git a/server/tests/api/live/live-views.ts b/server/tests/api/live/live-views.ts
index a44d21ffa..5e3a79c64 100644
--- a/server/tests/api/live/live-views.ts
+++ b/server/tests/api/live/live-views.ts
@@ -3,20 +3,15 @@
 import 'mocha'
 import * as chai from 'chai'
 import { FfmpegCommand } from 'fluent-ffmpeg'
-import { VideoDetails, VideoPrivacy } from '@shared/models'
+import { VideoPrivacy } from '@shared/models'
 import {
   cleanupTests,
-  createLive,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getVideo,
-  sendRTMPStreamInVideo,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   stopFfmpeg,
-  updateCustomSubConfig,
-  viewVideo,
   wait,
   waitJobs,
   waitUntilLivePublishedOnAllServers
@@ -25,23 +20,25 @@ import {
 const expect = chai.expect
 
 describe('Test live', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      live: {
-        enabled: true,
-        allowReplay: true,
-        transcoding: {
-          enabled: false
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          transcoding: {
+            enabled: false
+          }
         }
       }
     })
@@ -56,9 +53,7 @@ describe('Test live', function () {
 
     async function countViews (expected: number) {
       for (const server of servers) {
-        const res = await getVideo(server.url, liveVideoId)
-        const video: VideoDetails = res.body
-
+        const video = await server.videos.get({ id: liveVideoId })
         expect(video.views).to.equal(expected)
       }
     }
@@ -68,14 +63,14 @@ describe('Test live', function () {
 
       const liveAttributes = {
         name: 'live video',
-        channelId: servers[0].videoChannel.id,
+        channelId: servers[0].store.channel.id,
         privacy: VideoPrivacy.PUBLIC
       }
 
-      const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes)
-      liveVideoId = res.body.video.uuid
+      const live = await servers[0].live.create({ fields: liveAttributes })
+      liveVideoId = live.uuid
 
-      command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId)
+      command = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoId })
       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
       await waitJobs(servers)
     })
@@ -87,8 +82,8 @@ describe('Test live', function () {
     it('Should view a live twice and display 1 view', async function () {
       this.timeout(30000)
 
-      await viewVideo(servers[0].url, liveVideoId)
-      await viewVideo(servers[0].url, liveVideoId)
+      await servers[0].videos.view({ id: liveVideoId })
+      await servers[0].videos.view({ id: liveVideoId })
 
       await wait(7000)
 
@@ -109,9 +104,9 @@ describe('Test live', function () {
     it('Should view a live on a remote and on local and display 2 views', async function () {
       this.timeout(30000)
 
-      await viewVideo(servers[0].url, liveVideoId)
-      await viewVideo(servers[1].url, liveVideoId)
-      await viewVideo(servers[1].url, liveVideoId)
+      await servers[0].videos.view({ id: liveVideoId })
+      await servers[1].videos.view({ id: liveVideoId })
+      await servers[1].videos.view({ id: liveVideoId })
 
       await wait(7000)
       await waitJobs(servers)
diff --git a/server/tests/api/live/live.ts b/server/tests/api/live/live.ts
index 50397924e..d555cff19 100644
--- a/server/tests/api/live/live.ts
+++ b/server/tests/api/live/live.ts
@@ -2,75 +2,70 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { join } from 'path'
+import { basename, join } from 'path'
 import { ffprobePromise, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
-import { LiveVideo, LiveVideoCreate, Video, VideoDetails, VideoPrivacy, VideoState, VideoStreamingPlaylistType } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoToBlacklist,
-  buildServerDirectory,
-  checkLiveCleanup,
+  checkLiveCleanupAfterSave,
   checkLiveSegmentHash,
   checkResolutionsInMasterPlaylist,
   cleanupTests,
-  createLive,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getLive,
-  getMyVideosWithFilter,
-  getPlaylist,
-  getVideo,
-  getVideosList,
-  getVideosWithFilters,
   killallServers,
+  LiveCommand,
   makeRawRequest,
-  removeVideo,
-  reRunServer,
+  PeerTubeServer,
   sendRTMPStream,
-  sendRTMPStreamInVideo,
-  ServerInfo,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   stopFfmpeg,
   testFfmpegStreamError,
   testImage,
-  updateCustomSubConfig,
-  updateLive,
-  uploadVideoAndGetId,
   wait,
   waitJobs,
-  waitUntilLiveEnded,
-  waitUntilLivePublished,
-  waitUntilLivePublishedOnAllServers,
-  waitUntilLiveSegmentGeneration
-} from '../../../../shared/extra-utils'
+  waitUntilLivePublishedOnAllServers
+} from '@shared/extra-utils'
+import {
+  HttpStatusCode,
+  LiveVideo,
+  LiveVideoCreate,
+  VideoDetails,
+  VideoPrivacy,
+  VideoState,
+  VideoStreamingPlaylistType
+} from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test live', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
+  let commands: LiveCommand[]
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      live: {
-        enabled: true,
-        allowReplay: true,
-        transcoding: {
-          enabled: false
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          transcoding: {
+            enabled: false
+          }
         }
       }
     })
 
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
+
+    commands = servers.map(s => s.live)
   })
 
   describe('Live creation, update and delete', function () {
@@ -85,7 +80,7 @@ describe('Test live', function () {
         language: 'fr',
         description: 'super live description',
         support: 'support field',
-        channelId: servers[0].videoChannel.id,
+        channelId: servers[0].store.channel.id,
         nsfw: false,
         waitTranscoding: false,
         name: 'my super live',
@@ -98,14 +93,13 @@ describe('Test live', function () {
         thumbnailfile: 'video_short1.webm.jpg'
       }
 
-      const res = await createLive(servers[0].url, servers[0].accessToken, attributes)
-      liveVideoUUID = res.body.video.uuid
+      const live = await commands[0].create({ fields: attributes })
+      liveVideoUUID = live.uuid
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const resVideo = await getVideo(server.url, liveVideoUUID)
-        const video: VideoDetails = resVideo.body
+        const video = await server.videos.get({ id: liveVideoUUID })
 
         expect(video.category.id).to.equal(1)
         expect(video.licence.id).to.equal(2)
@@ -113,8 +107,8 @@ describe('Test live', function () {
         expect(video.description).to.equal('super live description')
         expect(video.support).to.equal('support field')
 
-        expect(video.channel.name).to.equal(servers[0].videoChannel.name)
-        expect(video.channel.host).to.equal(servers[0].videoChannel.host)
+        expect(video.channel.name).to.equal(servers[0].store.channel.name)
+        expect(video.channel.host).to.equal(servers[0].store.channel.host)
 
         expect(video.isLive).to.be.true
 
@@ -129,8 +123,7 @@ describe('Test live', function () {
         await testImage(server.url, 'video_short1-preview.webm', video.previewPath)
         await testImage(server.url, 'video_short1.webm', video.thumbnailPath)
 
-        const resLive = await getLive(server.url, server.accessToken, liveVideoUUID)
-        const live: LiveVideo = resLive.body
+        const live = await server.live.get({ videoId: liveVideoUUID })
 
         if (server.url === servers[0].url) {
           expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live')
@@ -149,20 +142,18 @@ describe('Test live', function () {
 
       const attributes: LiveVideoCreate = {
         name: 'default live thumbnail',
-        channelId: servers[0].videoChannel.id,
+        channelId: servers[0].store.channel.id,
         privacy: VideoPrivacy.UNLISTED,
         nsfw: true
       }
 
-      const res = await createLive(servers[0].url, servers[0].accessToken, attributes)
-      const videoId = res.body.video.uuid
+      const live = await commands[0].create({ fields: attributes })
+      const videoId = live.uuid
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const resVideo = await getVideo(server.url, videoId)
-        const video: VideoDetails = resVideo.body
-
+        const video = await server.videos.get({ id: videoId })
         expect(video.privacy.id).to.equal(VideoPrivacy.UNLISTED)
         expect(video.nsfw).to.be.true
 
@@ -173,28 +164,27 @@ describe('Test live', function () {
 
     it('Should not have the live listed since nobody streams into', async function () {
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { total, data } = await server.videos.list()
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
       }
     })
 
     it('Should not be able to update a live of another server', async function () {
-      await updateLive(servers[1].url, servers[1].accessToken, liveVideoUUID, { saveReplay: false }, HttpStatusCode.FORBIDDEN_403)
+      await commands[1].update({ videoId: liveVideoUUID, fields: { saveReplay: false }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should update the live', async function () {
       this.timeout(10000)
 
-      await updateLive(servers[0].url, servers[0].accessToken, liveVideoUUID, { saveReplay: false })
+      await commands[0].update({ videoId: liveVideoUUID, fields: { saveReplay: false } })
       await waitJobs(servers)
     })
 
     it('Have the live updated', async function () {
       for (const server of servers) {
-        const res = await getLive(server.url, server.accessToken, liveVideoUUID)
-        const live: LiveVideo = res.body
+        const live = await server.live.get({ videoId: liveVideoUUID })
 
         if (server.url === servers[0].url) {
           expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live')
@@ -211,77 +201,75 @@ describe('Test live', function () {
     it('Delete the live', async function () {
       this.timeout(10000)
 
-      await removeVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
+      await servers[0].videos.remove({ id: liveVideoUUID })
       await waitJobs(servers)
     })
 
     it('Should have the live deleted', async function () {
       for (const server of servers) {
-        await getVideo(server.url, liveVideoUUID, HttpStatusCode.NOT_FOUND_404)
-        await getLive(server.url, server.accessToken, liveVideoUUID, HttpStatusCode.NOT_FOUND_404)
+        await server.videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+        await server.live.get({ videoId: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
     })
   })
 
   describe('Live filters', function () {
-    let command: any
+    let ffmpegCommand: any
     let liveVideoId: string
     let vodVideoId: string
 
     before(async function () {
       this.timeout(120000)
 
-      vodVideoId = (await uploadVideoAndGetId({ server: servers[0], videoName: 'vod video' })).uuid
+      vodVideoId = (await servers[0].videos.quickUpload({ name: 'vod video' })).uuid
 
-      const liveOptions = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: servers[0].videoChannel.id }
-      const resLive = await createLive(servers[0].url, servers[0].accessToken, liveOptions)
-      liveVideoId = resLive.body.video.uuid
+      const liveOptions = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: servers[0].store.channel.id }
+      const live = await commands[0].create({ fields: liveOptions })
+      liveVideoId = live.uuid
 
-      command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId)
+      ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoId })
       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
       await waitJobs(servers)
     })
 
     it('Should only display lives', async function () {
-      const res = await getVideosWithFilters(servers[0].url, { isLive: true })
+      const { data, total } = await servers[0].videos.list({ isLive: true })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].name).to.equal('live')
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].name).to.equal('live')
     })
 
     it('Should not display lives', async function () {
-      const res = await getVideosWithFilters(servers[0].url, { isLive: false })
+      const { data, total } = await servers[0].videos.list({ isLive: false })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].name).to.equal('vod video')
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].name).to.equal('vod video')
     })
 
     it('Should display my lives', async function () {
       this.timeout(60000)
 
-      await stopFfmpeg(command)
+      await stopFfmpeg(ffmpegCommand)
       await waitJobs(servers)
 
-      const res = await getMyVideosWithFilter(servers[0].url, servers[0].accessToken, { isLive: true })
-      const videos = res.body.data as Video[]
+      const { data } = await servers[0].videos.listMyVideos({ isLive: true })
 
-      const result = videos.every(v => v.isLive)
+      const result = data.every(v => v.isLive)
       expect(result).to.be.true
     })
 
     it('Should not display my lives', async function () {
-      const res = await getMyVideosWithFilter(servers[0].url, servers[0].accessToken, { isLive: false })
-      const videos = res.body.data as Video[]
+      const { data } = await servers[0].videos.listMyVideos({ isLive: false })
 
-      const result = videos.every(v => !v.isLive)
+      const result = data.every(v => !v.isLive)
       expect(result).to.be.true
     })
 
     after(async function () {
-      await removeVideo(servers[0].url, servers[0].accessToken, vodVideoId)
-      await removeVideo(servers[0].url, servers[0].accessToken, liveVideoId)
+      await servers[0].videos.remove({ id: vodVideoId })
+      await servers[0].videos.remove({ id: liveVideoId })
     })
   })
 
@@ -296,18 +284,17 @@ describe('Test live', function () {
     async function createLiveWrapper () {
       const liveAttributes = {
         name: 'user live',
-        channelId: servers[0].videoChannel.id,
+        channelId: servers[0].store.channel.id,
         privacy: VideoPrivacy.PUBLIC,
         saveReplay: false
       }
 
-      const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes)
-      const uuid = res.body.video.uuid
+      const { uuid } = await commands[0].create({ fields: liveAttributes })
 
-      const resLive = await getLive(servers[0].url, servers[0].accessToken, uuid)
-      const resVideo = await getVideo(servers[0].url, uuid)
+      const live = await commands[0].get({ videoId: uuid })
+      const video = await servers[0].videos.get({ id: uuid })
 
-      return Object.assign(resVideo.body, resLive.body) as LiveVideo & VideoDetails
+      return Object.assign(video, live)
     }
 
     it('Should not allow a stream without the appropriate path', async function () {
@@ -335,13 +322,12 @@ describe('Test live', function () {
 
     it('Should list this live now someone stream into it', async function () {
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { total, data } = await server.videos.list()
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
-
-        const video: Video = res.body.data[0]
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
 
+        const video = data[0]
         expect(video.name).to.equal('user live')
         expect(video.isLive).to.be.true
       }
@@ -352,7 +338,7 @@ describe('Test live', function () {
 
       liveVideo = await createLiveWrapper()
 
-      await addVideoToBlacklist(servers[0].url, servers[0].accessToken, liveVideo.uuid)
+      await servers[0].blacklist.add({ videoId: liveVideo.uuid })
 
       const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey)
       await testFfmpegStreamError(command, true)
@@ -363,7 +349,7 @@ describe('Test live', function () {
 
       liveVideo = await createLiveWrapper()
 
-      await removeVideo(servers[0].url, servers[0].accessToken, liveVideo.uuid)
+      await servers[0].videos.remove({ id: liveVideo.uuid })
 
       const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey)
       await testFfmpegStreamError(command, true)
@@ -376,24 +362,21 @@ describe('Test live', function () {
     async function createLiveWrapper (saveReplay: boolean) {
       const liveAttributes = {
         name: 'live video',
-        channelId: servers[0].videoChannel.id,
+        channelId: servers[0].store.channel.id,
         privacy: VideoPrivacy.PUBLIC,
         saveReplay
       }
 
-      const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes)
-      return res.body.video.uuid
+      const { uuid } = await commands[0].create({ fields: liveAttributes })
+      return uuid
     }
 
     async function testVideoResolutions (liveVideoId: string, resolutions: number[]) {
       for (const server of servers) {
-        const resList = await getVideosList(server.url)
-        const videos: Video[] = resList.body.data
-
-        expect(videos.find(v => v.uuid === liveVideoId)).to.exist
+        const { data } = await server.videos.list()
+        expect(data.find(v => v.uuid === liveVideoId)).to.exist
 
-        const resVideo = await getVideo(server.url, liveVideoId)
-        const video: VideoDetails = resVideo.body
+        const video = await server.videos.get({ id: liveVideoId })
 
         expect(video.streamingPlaylists).to.have.lengthOf(1)
 
@@ -403,39 +386,48 @@ describe('Test live', function () {
         // Only finite files are displayed
         expect(hlsPlaylist.files).to.have.lengthOf(0)
 
-        await checkResolutionsInMasterPlaylist(hlsPlaylist.playlistUrl, resolutions)
+        await checkResolutionsInMasterPlaylist({ server, playlistUrl: hlsPlaylist.playlistUrl, resolutions })
 
         for (let i = 0; i < resolutions.length; i++) {
           const segmentNum = 3
           const segmentName = `${i}-00000${segmentNum}.ts`
-          await waitUntilLiveSegmentGeneration(servers[0], video.uuid, i, segmentNum)
+          await commands[0].waitUntilSegmentGeneration({ videoUUID: video.uuid, resolution: i, segment: segmentNum })
 
-          const res = await getPlaylist(`${servers[0].url}/static/streaming-playlists/hls/${video.uuid}/${i}.m3u8`)
-          const subPlaylist = res.text
+          const subPlaylist = await servers[0].streamingPlaylists.get({
+            url: `${servers[0].url}/static/streaming-playlists/hls/${video.uuid}/${i}.m3u8`
+          })
 
           expect(subPlaylist).to.contain(segmentName)
 
           const baseUrlAndPath = servers[0].url + '/static/streaming-playlists/hls'
-          await checkLiveSegmentHash(baseUrlAndPath, video.uuid, segmentName, hlsPlaylist)
+          await checkLiveSegmentHash({
+            server,
+            baseUrlSegment: baseUrlAndPath,
+            videoUUID: video.uuid,
+            segmentName,
+            hlsPlaylist
+          })
         }
       }
     }
 
     function updateConf (resolutions: number[]) {
-      return updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-        live: {
-          enabled: true,
-          allowReplay: true,
-          maxDuration: -1,
-          transcoding: {
+      return servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          live: {
             enabled: true,
-            resolutions: {
-              '240p': resolutions.includes(240),
-              '360p': resolutions.includes(360),
-              '480p': resolutions.includes(480),
-              '720p': resolutions.includes(720),
-              '1080p': resolutions.includes(1080),
-              '2160p': resolutions.includes(2160)
+            allowReplay: true,
+            maxDuration: -1,
+            transcoding: {
+              enabled: true,
+              resolutions: {
+                '240p': resolutions.includes(240),
+                '360p': resolutions.includes(360),
+                '480p': resolutions.includes(480),
+                '720p': resolutions.includes(720),
+                '1080p': resolutions.includes(1080),
+                '2160p': resolutions.includes(2160)
+              }
             }
           }
         }
@@ -451,13 +443,13 @@ describe('Test live', function () {
 
       liveVideoId = await createLiveWrapper(false)
 
-      const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId)
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId })
       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
       await waitJobs(servers)
 
       await testVideoResolutions(liveVideoId, [ 720 ])
 
-      await stopFfmpeg(command)
+      await stopFfmpeg(ffmpegCommand)
     })
 
     it('Should enable transcoding with some resolutions', async function () {
@@ -467,13 +459,13 @@ describe('Test live', function () {
       await updateConf(resolutions)
       liveVideoId = await createLiveWrapper(false)
 
-      const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId)
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId })
       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
       await waitJobs(servers)
 
       await testVideoResolutions(liveVideoId, resolutions)
 
-      await stopFfmpeg(command)
+      await stopFfmpeg(ffmpegCommand)
     })
 
     it('Should enable transcoding with some resolutions and correctly save them', async function () {
@@ -484,14 +476,14 @@ describe('Test live', function () {
       await updateConf(resolutions)
       liveVideoId = await createLiveWrapper(true)
 
-      const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId, 'video_short2.webm')
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
       await waitJobs(servers)
 
       await testVideoResolutions(liveVideoId, resolutions)
 
-      await stopFfmpeg(command)
-      await waitUntilLiveEnded(servers[0].url, servers[0].accessToken, liveVideoId)
+      await stopFfmpeg(ffmpegCommand)
+      await commands[0].waitUntilEnded({ videoId: liveVideoId })
 
       await waitJobs(servers)
 
@@ -504,8 +496,7 @@ describe('Test live', function () {
       }
 
       for (const server of servers) {
-        const resVideo = await getVideo(server.url, liveVideoId)
-        const video: VideoDetails = resVideo.body
+        const video = await server.videos.get({ id: liveVideoId })
 
         expect(video.state.id).to.equal(VideoState.PUBLISHED)
         expect(video.duration).to.be.greaterThan(1)
@@ -515,6 +506,10 @@ describe('Test live', function () {
         await makeRawRequest(hlsPlaylist.playlistUrl, HttpStatusCode.OK_200)
         await makeRawRequest(hlsPlaylist.segmentsSha256Url, HttpStatusCode.OK_200)
 
+        // We should have generated random filenames
+        expect(basename(hlsPlaylist.playlistUrl)).to.not.equal('master.m3u8')
+        expect(basename(hlsPlaylist.segmentsSha256Url)).to.not.equal('segments-sha256.json')
+
         expect(hlsPlaylist.files).to.have.lengthOf(resolutions.length)
 
         for (const resolution of resolutions) {
@@ -529,8 +524,10 @@ describe('Test live', function () {
             expect(file.fps).to.be.approximately(30, 2)
           }
 
-          const filename = `${video.uuid}-${resolution}-fragmented.mp4`
-          const segmentPath = buildServerDirectory(servers[0], join('streaming-playlists', 'hls', video.uuid, filename))
+          const filename = basename(file.fileUrl)
+          expect(filename).to.not.contain(video.uuid)
+
+          const segmentPath = servers[0].servers.buildDirectory(join('streaming-playlists', 'hls', video.uuid, filename))
 
           const probe = await ffprobePromise(segmentPath)
           const videoStream = await getVideoStreamFromFile(segmentPath, probe)
@@ -546,7 +543,7 @@ describe('Test live', function () {
     it('Should correctly have cleaned up the live files', async function () {
       this.timeout(30000)
 
-      await checkLiveCleanup(servers[0], liveVideoId, [ 240, 360, 720 ])
+      await checkLiveCleanupAfterSave(servers[0], liveVideoId, [ 240, 360, 720 ])
     })
   })
 
@@ -557,13 +554,13 @@ describe('Test live', function () {
     async function createLiveWrapper (saveReplay: boolean) {
       const liveAttributes = {
         name: 'live video',
-        channelId: servers[0].videoChannel.id,
+        channelId: servers[0].store.channel.id,
         privacy: VideoPrivacy.PUBLIC,
         saveReplay
       }
 
-      const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes)
-      return res.body.video.uuid
+      const { uuid } = await commands[0].create({ fields: liveAttributes })
+      return uuid
     }
 
     before(async function () {
@@ -573,20 +570,20 @@ describe('Test live', function () {
       liveVideoReplayId = await createLiveWrapper(true)
 
       await Promise.all([
-        sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId),
-        sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoReplayId)
+        commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId }),
+        commands[0].sendRTMPStreamInVideo({ videoId: liveVideoReplayId })
       ])
 
       await Promise.all([
-        waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoId),
-        waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoReplayId)
+        commands[0].waitUntilPublished({ videoId: liveVideoId }),
+        commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
       ])
 
-      await waitUntilLiveSegmentGeneration(servers[0], liveVideoId, 0, 2)
-      await waitUntilLiveSegmentGeneration(servers[0], liveVideoReplayId, 0, 2)
+      await commands[0].waitUntilSegmentGeneration({ videoUUID: liveVideoId, resolution: 0, segment: 2 })
+      await commands[0].waitUntilSegmentGeneration({ videoUUID: liveVideoReplayId, resolution: 0, segment: 2 })
 
       await killallServers([ servers[0] ])
-      await reRunServer(servers[0])
+      await servers[0].run()
 
       await wait(5000)
     })
@@ -594,13 +591,13 @@ describe('Test live', function () {
     it('Should cleanup lives', async function () {
       this.timeout(60000)
 
-      await waitUntilLiveEnded(servers[0].url, servers[0].accessToken, liveVideoId)
+      await commands[0].waitUntilEnded({ videoId: liveVideoId })
     })
 
     it('Should save a live replay', async function () {
       this.timeout(120000)
 
-      await waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoReplayId)
+      await commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
     })
   })
 
diff --git a/server/tests/api/moderation/abuses.ts b/server/tests/api/moderation/abuses.ts
index fb765e7e3..c258414ce 100644
--- a/server/tests/api/moderation/abuses.ts
+++ b/server/tests/api/moderation/abuses.ts
@@ -3,70 +3,37 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  AbuseFilter,
-  AbuseMessage,
-  AbusePredefinedReasonsString,
-  AbuseState,
-  Account,
-  AdminAbuse,
-  UserAbuse,
-  VideoComment
-} from '@shared/models'
-import {
-  addAbuseMessage,
-  addVideoCommentThread,
+  AbusesCommand,
   cleanupTests,
-  createUser,
-  deleteAbuse,
-  deleteAbuseMessage,
-  deleteVideoComment,
-  flushAndRunMultipleServers,
-  generateUserAccessToken,
-  getAccount,
-  getAdminAbusesList,
-  getUserAbusesList,
-  getVideoCommentThreads,
-  getVideoIdFromUUID,
-  getVideosList,
-  immutableAssign,
-  listAbuseMessages,
-  removeUser,
-  removeVideo,
-  reportAbuse,
-  ServerInfo,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateAbuse,
-  uploadVideo,
-  uploadVideoAndGetId,
-  userLogin
-} from '../../../../shared/extra-utils/index'
-import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  addAccountToServerBlocklist,
-  addServerToServerBlocklist,
-  removeAccountFromServerBlocklist,
-  removeServerFromServerBlocklist
-} from '../../../../shared/extra-utils/users/blocklist'
+  waitJobs
+} from '@shared/extra-utils'
+import { AbuseMessage, AbusePredefinedReasonsString, AbuseState, AdminAbuse, UserAbuse } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test abuses', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let abuseServer1: AdminAbuse
   let abuseServer2: AdminAbuse
+  let commands: AbusesCommand[]
 
   before(async function () {
     this.timeout(50000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
 
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
+
+    commands = servers.map(s => s.abuses)
   })
 
   describe('Video abuses', function () {
@@ -75,179 +42,189 @@ describe('Test abuses', function () {
       this.timeout(50000)
 
       // Upload some videos on each servers
-      const video1Attributes = {
-        name: 'my super name for server 1',
-        description: 'my super description for server 1'
+      {
+        const attributes = {
+          name: 'my super name for server 1',
+          description: 'my super description for server 1'
+        }
+        await servers[0].videos.upload({ attributes })
       }
-      await uploadVideo(servers[0].url, servers[0].accessToken, video1Attributes)
 
-      const video2Attributes = {
-        name: 'my super name for server 2',
-        description: 'my super description for server 2'
+      {
+        const attributes = {
+          name: 'my super name for server 2',
+          description: 'my super description for server 2'
+        }
+        await servers[1].videos.upload({ attributes })
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, video2Attributes)
 
       // Wait videos propagation, server 2 has transcoding enabled
       await waitJobs(servers)
 
-      const res = await getVideosList(servers[0].url)
-      const videos = res.body.data
+      const { data } = await servers[0].videos.list()
+      expect(data.length).to.equal(2)
 
-      expect(videos.length).to.equal(2)
-
-      servers[0].video = videos.find(video => video.name === 'my super name for server 1')
-      servers[1].video = videos.find(video => video.name === 'my super name for server 2')
+      servers[0].store.videoCreated = data.find(video => video.name === 'my super name for server 1')
+      servers[1].store.videoCreated = data.find(video => video.name === 'my super name for server 2')
     })
 
     it('Should not have abuses', async function () {
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
+      const body = await commands[0].getAdminList()
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data.length).to.equal(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data.length).to.equal(0)
     })
 
     it('Should report abuse on a local video', async function () {
       this.timeout(15000)
 
       const reason = 'my super bad reason'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId: servers[0].video.id, reason })
+      await commands[0].report({ videoId: servers[0].store.videoCreated.id, reason })
 
       // We wait requests propagation, even if the server 1 is not supposed to make a request to server 2
       await waitJobs(servers)
     })
 
     it('Should have 1 video abuses on server 1 and 0 on server 2', async function () {
-      const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
+      {
+        const body = await commands[0].getAdminList()
 
-      expect(res1.body.total).to.equal(1)
-      expect(res1.body.data).to.be.an('array')
-      expect(res1.body.data.length).to.equal(1)
+        expect(body.total).to.equal(1)
+        expect(body.data).to.be.an('array')
+        expect(body.data.length).to.equal(1)
 
-      const abuse: AdminAbuse = res1.body.data[0]
-      expect(abuse.reason).to.equal('my super bad reason')
+        const abuse = body.data[0]
+        expect(abuse.reason).to.equal('my super bad reason')
 
-      expect(abuse.reporterAccount.name).to.equal('root')
-      expect(abuse.reporterAccount.host).to.equal(servers[0].host)
+        expect(abuse.reporterAccount.name).to.equal('root')
+        expect(abuse.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuse.video.id).to.equal(servers[0].video.id)
-      expect(abuse.video.channel).to.exist
+        expect(abuse.video.id).to.equal(servers[0].store.videoCreated.id)
+        expect(abuse.video.channel).to.exist
 
-      expect(abuse.comment).to.be.null
+        expect(abuse.comment).to.be.null
 
-      expect(abuse.flaggedAccount.name).to.equal('root')
-      expect(abuse.flaggedAccount.host).to.equal(servers[0].host)
+        expect(abuse.flaggedAccount.name).to.equal('root')
+        expect(abuse.flaggedAccount.host).to.equal(servers[0].host)
 
-      expect(abuse.video.countReports).to.equal(1)
-      expect(abuse.video.nthReport).to.equal(1)
+        expect(abuse.video.countReports).to.equal(1)
+        expect(abuse.video.nthReport).to.equal(1)
 
-      expect(abuse.countReportsForReporter).to.equal(1)
-      expect(abuse.countReportsForReportee).to.equal(1)
+        expect(abuse.countReportsForReporter).to.equal(1)
+        expect(abuse.countReportsForReportee).to.equal(1)
+      }
 
-      const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken })
-      expect(res2.body.total).to.equal(0)
-      expect(res2.body.data).to.be.an('array')
-      expect(res2.body.data.length).to.equal(0)
+      {
+        const body = await commands[1].getAdminList()
+        expect(body.total).to.equal(0)
+        expect(body.data).to.be.an('array')
+        expect(body.data.length).to.equal(0)
+      }
     })
 
     it('Should report abuse on a remote video', async function () {
       this.timeout(10000)
 
       const reason = 'my super bad reason 2'
-      const videoId = await getVideoIdFromUUID(servers[0].url, servers[1].video.uuid)
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId, reason })
+      const videoId = await servers[0].videos.getId({ uuid: servers[1].store.videoCreated.uuid })
+      await commands[0].report({ videoId, reason })
 
       // We wait requests propagation
       await waitJobs(servers)
     })
 
     it('Should have 2 video abuses on server 1 and 1 on server 2', async function () {
-      const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
+      {
+        const body = await commands[0].getAdminList()
 
-      expect(res1.body.total).to.equal(2)
-      expect(res1.body.data.length).to.equal(2)
+        expect(body.total).to.equal(2)
+        expect(body.data.length).to.equal(2)
 
-      const abuse1: AdminAbuse = res1.body.data[0]
-      expect(abuse1.reason).to.equal('my super bad reason')
-      expect(abuse1.reporterAccount.name).to.equal('root')
-      expect(abuse1.reporterAccount.host).to.equal(servers[0].host)
+        const abuse1 = body.data[0]
+        expect(abuse1.reason).to.equal('my super bad reason')
+        expect(abuse1.reporterAccount.name).to.equal('root')
+        expect(abuse1.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuse1.video.id).to.equal(servers[0].video.id)
-      expect(abuse1.video.countReports).to.equal(1)
-      expect(abuse1.video.nthReport).to.equal(1)
+        expect(abuse1.video.id).to.equal(servers[0].store.videoCreated.id)
+        expect(abuse1.video.countReports).to.equal(1)
+        expect(abuse1.video.nthReport).to.equal(1)
 
-      expect(abuse1.comment).to.be.null
+        expect(abuse1.comment).to.be.null
 
-      expect(abuse1.flaggedAccount.name).to.equal('root')
-      expect(abuse1.flaggedAccount.host).to.equal(servers[0].host)
+        expect(abuse1.flaggedAccount.name).to.equal('root')
+        expect(abuse1.flaggedAccount.host).to.equal(servers[0].host)
 
-      expect(abuse1.state.id).to.equal(AbuseState.PENDING)
-      expect(abuse1.state.label).to.equal('Pending')
-      expect(abuse1.moderationComment).to.be.null
+        expect(abuse1.state.id).to.equal(AbuseState.PENDING)
+        expect(abuse1.state.label).to.equal('Pending')
+        expect(abuse1.moderationComment).to.be.null
 
-      const abuse2: AdminAbuse = res1.body.data[1]
-      expect(abuse2.reason).to.equal('my super bad reason 2')
+        const abuse2 = body.data[1]
+        expect(abuse2.reason).to.equal('my super bad reason 2')
 
-      expect(abuse2.reporterAccount.name).to.equal('root')
-      expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
+        expect(abuse2.reporterAccount.name).to.equal('root')
+        expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuse2.video.id).to.equal(servers[1].video.id)
+        expect(abuse2.video.id).to.equal(servers[1].store.videoCreated.id)
 
-      expect(abuse2.comment).to.be.null
+        expect(abuse2.comment).to.be.null
 
-      expect(abuse2.flaggedAccount.name).to.equal('root')
-      expect(abuse2.flaggedAccount.host).to.equal(servers[1].host)
+        expect(abuse2.flaggedAccount.name).to.equal('root')
+        expect(abuse2.flaggedAccount.host).to.equal(servers[1].host)
 
-      expect(abuse2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuse2.state.label).to.equal('Pending')
-      expect(abuse2.moderationComment).to.be.null
+        expect(abuse2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuse2.state.label).to.equal('Pending')
+        expect(abuse2.moderationComment).to.be.null
+      }
 
-      const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken })
-      expect(res2.body.total).to.equal(1)
-      expect(res2.body.data.length).to.equal(1)
+      {
+        const body = await commands[1].getAdminList()
+        expect(body.total).to.equal(1)
+        expect(body.data.length).to.equal(1)
 
-      abuseServer2 = res2.body.data[0]
-      expect(abuseServer2.reason).to.equal('my super bad reason 2')
-      expect(abuseServer2.reporterAccount.name).to.equal('root')
-      expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
+        abuseServer2 = body.data[0]
+        expect(abuseServer2.reason).to.equal('my super bad reason 2')
+        expect(abuseServer2.reporterAccount.name).to.equal('root')
+        expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuse2.flaggedAccount.name).to.equal('root')
-      expect(abuse2.flaggedAccount.host).to.equal(servers[1].host)
+        expect(abuseServer2.flaggedAccount.name).to.equal('root')
+        expect(abuseServer2.flaggedAccount.host).to.equal(servers[1].host)
 
-      expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuseServer2.state.label).to.equal('Pending')
-      expect(abuseServer2.moderationComment).to.be.null
+        expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuseServer2.state.label).to.equal('Pending')
+        expect(abuseServer2.moderationComment).to.be.null
+      }
     })
 
     it('Should hide video abuses from blocked accounts', async function () {
       this.timeout(10000)
 
       {
-        const videoId = await getVideoIdFromUUID(servers[1].url, servers[0].video.uuid)
-        await reportAbuse({ url: servers[1].url, token: servers[1].accessToken, videoId, reason: 'will mute this' })
+        const videoId = await servers[1].videos.getId({ uuid: servers[0].store.videoCreated.uuid })
+        await commands[1].report({ videoId, reason: 'will mute this' })
         await waitJobs(servers)
 
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(3)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(3)
       }
 
       const accountToBlock = 'root@' + servers[1].host
 
       {
-        await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, accountToBlock)
+        await servers[0].blocklist.addToServerBlocklist({ account: accountToBlock })
 
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(2)
 
-        const abuse = res.body.data.find(a => a.reason === 'will mute this')
+        const abuse = body.data.find(a => a.reason === 'will mute this')
         expect(abuse).to.be.undefined
       }
 
       {
-        await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, accountToBlock)
+        await servers[0].blocklist.removeFromServerBlocklist({ account: accountToBlock })
 
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(3)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(3)
       }
     })
 
@@ -255,35 +232,35 @@ describe('Test abuses', function () {
       const serverToBlock = servers[1].host
 
       {
-        await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, servers[1].host)
+        await servers[0].blocklist.addToServerBlocklist({ server: serverToBlock })
 
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(2)
 
-        const abuse = res.body.data.find(a => a.reason === 'will mute this')
+        const abuse = body.data.find(a => a.reason === 'will mute this')
         expect(abuse).to.be.undefined
       }
 
       {
-        await removeServerFromServerBlocklist(servers[0].url, servers[0].accessToken, serverToBlock)
+        await servers[0].blocklist.removeFromServerBlocklist({ server: serverToBlock })
 
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(3)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(3)
       }
     })
 
     it('Should keep the video abuse when deleting the video', async function () {
       this.timeout(10000)
 
-      await removeVideo(servers[1].url, servers[1].accessToken, abuseServer2.video.uuid)
+      await servers[1].videos.remove({ id: abuseServer2.video.uuid })
 
       await waitJobs(servers)
 
-      const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken })
-      expect(res.body.total).to.equal(2, "wrong number of videos returned")
-      expect(res.body.data).to.have.lengthOf(2, "wrong number of videos returned")
+      const body = await commands[1].getAdminList()
+      expect(body.total).to.equal(2, "wrong number of videos returned")
+      expect(body.data).to.have.lengthOf(2, "wrong number of videos returned")
 
-      const abuse: AdminAbuse = res.body.data[0]
+      const abuse = body.data[0]
       expect(abuse.id).to.equal(abuseServer2.id, "wrong origin server id for first video")
       expect(abuse.video.id).to.equal(abuseServer2.video.id, "wrong video id")
       expect(abuse.video.channel).to.exist
@@ -295,39 +272,36 @@ describe('Test abuses', function () {
 
       // register a second user to have two reporters/reportees
       const user = { username: 'user2', password: 'password' }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, ...user })
-      const userAccessToken = await userLogin(servers[0], user)
+      await servers[0].users.create({ ...user })
+      const userAccessToken = await servers[0].login.getAccessToken(user)
 
       // upload a third video via this user
-      const video3Attributes = {
+      const attributes = {
         name: 'my second super name for server 1',
         description: 'my second super description for server 1'
       }
-      await uploadVideo(servers[0].url, userAccessToken, video3Attributes)
-
-      const res1 = await getVideosList(servers[0].url)
-      const videos = res1.body.data
-      const video3 = videos.find(video => video.name === 'my second super name for server 1')
+      const { id } = await servers[0].videos.upload({ token: userAccessToken, attributes })
+      const video3Id = id
 
       // resume with the test
       const reason3 = 'my super bad reason 3'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId: video3.id, reason: reason3 })
+      await commands[0].report({ videoId: video3Id, reason: reason3 })
 
       const reason4 = 'my super bad reason 4'
-      await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: servers[0].video.id, reason: reason4 })
+      await commands[0].report({ token: userAccessToken, videoId: servers[0].store.videoCreated.id, reason: reason4 })
 
       {
-        const res2 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        const abuses = res2.body.data as AdminAbuse[]
+        const body = await commands[0].getAdminList()
+        const abuses = body.data
 
-        const abuseVideo3 = res2.body.data.find(a => a.video.id === video3.id)
+        const abuseVideo3 = body.data.find(a => a.video.id === video3Id)
         expect(abuseVideo3).to.not.be.undefined
         expect(abuseVideo3.video.countReports).to.equal(1, "wrong reports count for video 3")
         expect(abuseVideo3.video.nthReport).to.equal(1, "wrong report position in report list for video 3")
         expect(abuseVideo3.countReportsForReportee).to.equal(1, "wrong reports count for reporter on video 3 abuse")
         expect(abuseVideo3.countReportsForReporter).to.equal(3, "wrong reports count for reportee on video 3 abuse")
 
-        const abuseServer1 = abuses.find(a => a.video.id === servers[0].video.id)
+        const abuseServer1 = abuses.find(a => a.video.id === servers[0].store.videoCreated.id)
         expect(abuseServer1.countReportsForReportee).to.equal(3, "wrong reports count for reporter on video 1 abuse")
       }
     })
@@ -337,20 +311,18 @@ describe('Test abuses', function () {
 
       const reason5 = 'my super bad reason 5'
       const predefinedReasons5: AbusePredefinedReasonsString[] = [ 'violentOrRepulsive', 'captions' ]
-      const createdAbuse = (await reportAbuse({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        videoId: servers[0].video.id,
+      const createRes = await commands[0].report({
+        videoId: servers[0].store.videoCreated.id,
         reason: reason5,
         predefinedReasons: predefinedReasons5,
         startAt: 1,
         endAt: 5
-      })).body.abuse
+      })
 
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
+      const body = await commands[0].getAdminList()
 
       {
-        const abuse = (res.body.data as AdminAbuse[]).find(a => a.id === createdAbuse.id)
+        const abuse = body.data.find(a => a.id === createRes.abuse.id)
         expect(abuse.reason).to.equals(reason5)
         expect(abuse.predefinedReasons).to.deep.equals(predefinedReasons5, "predefined reasons do not match the one reported")
         expect(abuse.video.startAt).to.equal(1, "starting timestamp doesn't match the one reported")
@@ -361,37 +333,30 @@ describe('Test abuses', function () {
     it('Should delete the video abuse', async function () {
       this.timeout(10000)
 
-      await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id)
+      await commands[1].delete({ abuseId: abuseServer2.id })
 
       await waitJobs(servers)
 
       {
-        const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken })
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data.length).to.equal(1)
-        expect(res.body.data[0].id).to.not.equal(abuseServer2.id)
+        const body = await commands[1].getAdminList()
+        expect(body.total).to.equal(1)
+        expect(body.data.length).to.equal(1)
+        expect(body.data[0].id).to.not.equal(abuseServer2.id)
       }
 
       {
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken })
-        expect(res.body.total).to.equal(6)
+        const body = await commands[0].getAdminList()
+        expect(body.total).to.equal(6)
       }
     })
 
     it('Should list and filter video abuses', async function () {
       this.timeout(10000)
 
-      async function list (query: Omit<Parameters<typeof getAdminAbusesList>[0], 'url' | 'token'>) {
-        const options = {
-          url: servers[0].url,
-          token: servers[0].accessToken
-        }
-
-        Object.assign(options, query)
+      async function list (query: Parameters<AbusesCommand['getAdminList']>[0]) {
+        const body = await commands[0].getAdminList(query)
 
-        const res = await getAdminAbusesList(options)
-
-        return res.body.data as AdminAbuse[]
+        return body.data
       }
 
       expect(await list({ id: 56 })).to.have.lengthOf(0)
@@ -424,24 +389,24 @@ describe('Test abuses', function () {
 
   describe('Comment abuses', function () {
 
-    async function getComment (url: string, videoIdArg: number | string) {
+    async function getComment (server: PeerTubeServer, videoIdArg: number | string) {
       const videoId = typeof videoIdArg === 'string'
-        ? await getVideoIdFromUUID(url, videoIdArg)
+        ? await server.videos.getId({ uuid: videoIdArg })
         : videoIdArg
 
-      const res = await getVideoCommentThreads(url, videoId, 0, 5)
+      const { data } = await server.comments.listThreads({ videoId })
 
-      return res.body.data[0] as VideoComment
+      return data[0]
     }
 
     before(async function () {
       this.timeout(50000)
 
-      servers[0].video = await uploadVideoAndGetId({ server: servers[0], videoName: 'server 1' })
-      servers[1].video = await uploadVideoAndGetId({ server: servers[1], videoName: 'server 2' })
+      servers[0].store.videoCreated = await servers[0].videos.quickUpload({ name: 'server 1' })
+      servers[1].store.videoCreated = await servers[1].videos.quickUpload({ name: 'server 2' })
 
-      await addVideoCommentThread(servers[0].url, servers[0].accessToken, servers[0].video.id, 'comment server 1')
-      await addVideoCommentThread(servers[1].url, servers[1].accessToken, servers[1].video.id, 'comment server 2')
+      await servers[0].comments.createThread({ videoId: servers[0].store.videoCreated.id, text: 'comment server 1' })
+      await servers[1].comments.createThread({ videoId: servers[1].store.videoCreated.id, text: 'comment server 2' })
 
       await waitJobs(servers)
     })
@@ -449,23 +414,23 @@ describe('Test abuses', function () {
     it('Should report abuse on a comment', async function () {
       this.timeout(15000)
 
-      const comment = await getComment(servers[0].url, servers[0].video.id)
+      const comment = await getComment(servers[0], servers[0].store.videoCreated.id)
 
       const reason = 'it is a bad comment'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, commentId: comment.id, reason })
+      await commands[0].report({ commentId: comment.id, reason })
 
       await waitJobs(servers)
     })
 
     it('Should have 1 comment abuse on server 1 and 0 on server 2', async function () {
       {
-        const comment = await getComment(servers[0].url, servers[0].video.id)
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' })
+        const comment = await getComment(servers[0], servers[0].store.videoCreated.id)
+        const body = await commands[0].getAdminList({ filter: 'comment' })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(body.total).to.equal(1)
+        expect(body.data).to.have.lengthOf(1)
 
-        const abuse: AdminAbuse = res.body.data[0]
+        const abuse = body.data[0]
         expect(abuse.reason).to.equal('it is a bad comment')
 
         expect(abuse.reporterAccount.name).to.equal('root')
@@ -477,98 +442,102 @@ describe('Test abuses', function () {
         expect(abuse.comment.id).to.equal(comment.id)
         expect(abuse.comment.text).to.equal(comment.text)
         expect(abuse.comment.video.name).to.equal('server 1')
-        expect(abuse.comment.video.id).to.equal(servers[0].video.id)
-        expect(abuse.comment.video.uuid).to.equal(servers[0].video.uuid)
+        expect(abuse.comment.video.id).to.equal(servers[0].store.videoCreated.id)
+        expect(abuse.comment.video.uuid).to.equal(servers[0].store.videoCreated.uuid)
 
         expect(abuse.countReportsForReporter).to.equal(5)
         expect(abuse.countReportsForReportee).to.equal(5)
       }
 
       {
-        const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data.length).to.equal(0)
+        const body = await commands[1].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(0)
+        expect(body.data.length).to.equal(0)
       }
     })
 
     it('Should report abuse on a remote comment', async function () {
       this.timeout(10000)
 
-      const comment = await getComment(servers[0].url, servers[1].video.uuid)
+      const comment = await getComment(servers[0], servers[1].store.videoCreated.uuid)
 
       const reason = 'it is a really bad comment'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, commentId: comment.id, reason })
+      await commands[0].report({ commentId: comment.id, reason })
 
       await waitJobs(servers)
     })
 
     it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () {
-      const commentServer2 = await getComment(servers[0].url, servers[1].video.id)
+      const commentServer2 = await getComment(servers[0], servers[1].store.videoCreated.id)
 
-      const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' })
-      expect(res1.body.total).to.equal(2)
-      expect(res1.body.data.length).to.equal(2)
+      {
+        const body = await commands[0].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(2)
+        expect(body.data.length).to.equal(2)
 
-      const abuse: AdminAbuse = res1.body.data[0]
-      expect(abuse.reason).to.equal('it is a bad comment')
-      expect(abuse.countReportsForReporter).to.equal(6)
-      expect(abuse.countReportsForReportee).to.equal(5)
+        const abuse = body.data[0]
+        expect(abuse.reason).to.equal('it is a bad comment')
+        expect(abuse.countReportsForReporter).to.equal(6)
+        expect(abuse.countReportsForReportee).to.equal(5)
 
-      const abuse2: AdminAbuse = res1.body.data[1]
+        const abuse2 = body.data[1]
 
-      expect(abuse2.reason).to.equal('it is a really bad comment')
+        expect(abuse2.reason).to.equal('it is a really bad comment')
 
-      expect(abuse2.reporterAccount.name).to.equal('root')
-      expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
+        expect(abuse2.reporterAccount.name).to.equal('root')
+        expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuse2.video).to.be.null
+        expect(abuse2.video).to.be.null
 
-      expect(abuse2.comment.deleted).to.be.false
-      expect(abuse2.comment.id).to.equal(commentServer2.id)
-      expect(abuse2.comment.text).to.equal(commentServer2.text)
-      expect(abuse2.comment.video.name).to.equal('server 2')
-      expect(abuse2.comment.video.uuid).to.equal(servers[1].video.uuid)
+        expect(abuse2.comment.deleted).to.be.false
+        expect(abuse2.comment.id).to.equal(commentServer2.id)
+        expect(abuse2.comment.text).to.equal(commentServer2.text)
+        expect(abuse2.comment.video.name).to.equal('server 2')
+        expect(abuse2.comment.video.uuid).to.equal(servers[1].store.videoCreated.uuid)
 
-      expect(abuse2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuse2.state.label).to.equal('Pending')
+        expect(abuse2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuse2.state.label).to.equal('Pending')
 
-      expect(abuse2.moderationComment).to.be.null
+        expect(abuse2.moderationComment).to.be.null
 
-      expect(abuse2.countReportsForReporter).to.equal(6)
-      expect(abuse2.countReportsForReportee).to.equal(2)
+        expect(abuse2.countReportsForReporter).to.equal(6)
+        expect(abuse2.countReportsForReportee).to.equal(2)
+      }
 
-      const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' })
-      expect(res2.body.total).to.equal(1)
-      expect(res2.body.data.length).to.equal(1)
+      {
+        const body = await commands[1].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(1)
+        expect(body.data.length).to.equal(1)
 
-      abuseServer2 = res2.body.data[0]
-      expect(abuseServer2.reason).to.equal('it is a really bad comment')
-      expect(abuseServer2.reporterAccount.name).to.equal('root')
-      expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
+        abuseServer2 = body.data[0]
+        expect(abuseServer2.reason).to.equal('it is a really bad comment')
+        expect(abuseServer2.reporterAccount.name).to.equal('root')
+        expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuseServer2.state.label).to.equal('Pending')
+        expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuseServer2.state.label).to.equal('Pending')
 
-      expect(abuseServer2.moderationComment).to.be.null
+        expect(abuseServer2.moderationComment).to.be.null
 
-      expect(abuseServer2.countReportsForReporter).to.equal(1)
-      expect(abuseServer2.countReportsForReportee).to.equal(1)
+        expect(abuseServer2.countReportsForReporter).to.equal(1)
+        expect(abuseServer2.countReportsForReportee).to.equal(1)
+      }
     })
 
     it('Should keep the comment abuse when deleting the comment', async function () {
       this.timeout(10000)
 
-      const commentServer2 = await getComment(servers[0].url, servers[1].video.id)
+      const commentServer2 = await getComment(servers[0], servers[1].store.videoCreated.id)
 
-      await deleteVideoComment(servers[0].url, servers[0].accessToken, servers[1].video.uuid, commentServer2.id)
+      await servers[0].comments.delete({ videoId: servers[1].store.videoCreated.uuid, commentId: commentServer2.id })
 
       await waitJobs(servers)
 
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' })
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      const body = await commands[0].getAdminList({ filter: 'comment' })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      const abuse = (res.body.data as AdminAbuse[]).find(a => a.comment?.id === commentServer2.id)
+      const abuse = body.data.find(a => a.comment?.id === commentServer2.id)
       expect(abuse).to.not.be.undefined
 
       expect(abuse.comment.text).to.be.empty
@@ -579,72 +548,60 @@ describe('Test abuses', function () {
     it('Should delete the comment abuse', async function () {
       this.timeout(10000)
 
-      await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id)
+      await commands[1].delete({ abuseId: abuseServer2.id })
 
       await waitJobs(servers)
 
       {
-        const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data.length).to.equal(0)
+        const body = await commands[1].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(0)
+        expect(body.data.length).to.equal(0)
       }
 
       {
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(2)
       }
     })
 
     it('Should list and filter video abuses', async function () {
       {
-        const res = await getAdminAbusesList({
-          url: servers[0].url,
-          token: servers[0].accessToken,
-          filter: 'comment',
-          searchReportee: 'foo'
-        })
-        expect(res.body.total).to.equal(0)
+        const body = await commands[0].getAdminList({ filter: 'comment', searchReportee: 'foo' })
+        expect(body.total).to.equal(0)
       }
 
       {
-        const res = await getAdminAbusesList({
-          url: servers[0].url,
-          token: servers[0].accessToken,
-          filter: 'comment',
-          searchReportee: 'ot'
-        })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getAdminList({ filter: 'comment', searchReportee: 'ot' })
+        expect(body.total).to.equal(2)
       }
 
       {
-        const baseParams = { url: servers[0].url, token: servers[0].accessToken, filter: 'comment' as AbuseFilter, start: 1, count: 1 }
-
-        const res1 = await getAdminAbusesList(immutableAssign(baseParams, { sort: 'createdAt' }))
-        expect(res1.body.data).to.have.lengthOf(1)
-        expect(res1.body.data[0].comment.text).to.be.empty
+        const body = await commands[0].getAdminList({ filter: 'comment', start: 1, count: 1, sort: 'createdAt' })
+        expect(body.data).to.have.lengthOf(1)
+        expect(body.data[0].comment.text).to.be.empty
+      }
 
-        const res2 = await getAdminAbusesList(immutableAssign(baseParams, { sort: '-createdAt' }))
-        expect(res2.body.data).to.have.lengthOf(1)
-        expect(res2.body.data[0].comment.text).to.equal('comment server 1')
+      {
+        const body = await commands[0].getAdminList({ filter: 'comment', start: 1, count: 1, sort: '-createdAt' })
+        expect(body.data).to.have.lengthOf(1)
+        expect(body.data[0].comment.text).to.equal('comment server 1')
       }
     })
   })
 
   describe('Account abuses', function () {
 
-    async function getAccountFromServer (url: string, name: string, server: ServerInfo) {
-      const res = await getAccount(url, name + '@' + server.host)
-
-      return res.body as Account
+    function getAccountFromServer (server: PeerTubeServer, targetName: string, targetServer: PeerTubeServer) {
+      return server.accounts.get({ accountName: targetName + '@' + targetServer.host })
     }
 
     before(async function () {
       this.timeout(50000)
 
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: 'user_1', password: 'donald' })
+      await servers[0].users.create({ username: 'user_1', password: 'donald' })
 
-      const token = await generateUserAccessToken(servers[1], 'user_2')
-      await uploadVideo(servers[1].url, token, { name: 'super video' })
+      const token = await servers[1].users.generateUserAndToken('user_2')
+      await servers[1].videos.upload({ token, attributes: { name: 'super video' } })
 
       await waitJobs(servers)
     })
@@ -652,22 +609,22 @@ describe('Test abuses', function () {
     it('Should report abuse on an account', async function () {
       this.timeout(15000)
 
-      const account = await getAccountFromServer(servers[0].url, 'user_1', servers[0])
+      const account = await getAccountFromServer(servers[0], 'user_1', servers[0])
 
       const reason = 'it is a bad account'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, accountId: account.id, reason })
+      await commands[0].report({ accountId: account.id, reason })
 
       await waitJobs(servers)
     })
 
     it('Should have 1 account abuse on server 1 and 0 on server 2', async function () {
       {
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' })
+        const body = await commands[0].getAdminList({ filter: 'account' })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(body.total).to.equal(1)
+        expect(body.data).to.have.lengthOf(1)
 
-        const abuse: AdminAbuse = res.body.data[0]
+        const abuse = body.data[0]
         expect(abuse.reason).to.equal('it is a bad account')
 
         expect(abuse.reporterAccount.name).to.equal('root')
@@ -681,96 +638,100 @@ describe('Test abuses', function () {
       }
 
       {
-        const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data.length).to.equal(0)
+        const body = await commands[1].getAdminList({ filter: 'comment' })
+        expect(body.total).to.equal(0)
+        expect(body.data.length).to.equal(0)
       }
     })
 
     it('Should report abuse on a remote account', async function () {
       this.timeout(10000)
 
-      const account = await getAccountFromServer(servers[0].url, 'user_2', servers[1])
+      const account = await getAccountFromServer(servers[0], 'user_2', servers[1])
 
       const reason = 'it is a really bad account'
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, accountId: account.id, reason })
+      await commands[0].report({ accountId: account.id, reason })
 
       await waitJobs(servers)
     })
 
     it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () {
-      const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' })
-      expect(res1.body.total).to.equal(2)
-      expect(res1.body.data.length).to.equal(2)
+      {
+        const body = await commands[0].getAdminList({ filter: 'account' })
+        expect(body.total).to.equal(2)
+        expect(body.data.length).to.equal(2)
 
-      const abuse: AdminAbuse = res1.body.data[0]
-      expect(abuse.reason).to.equal('it is a bad account')
+        const abuse: AdminAbuse = body.data[0]
+        expect(abuse.reason).to.equal('it is a bad account')
 
-      const abuse2: AdminAbuse = res1.body.data[1]
-      expect(abuse2.reason).to.equal('it is a really bad account')
+        const abuse2: AdminAbuse = body.data[1]
+        expect(abuse2.reason).to.equal('it is a really bad account')
 
-      expect(abuse2.reporterAccount.name).to.equal('root')
-      expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
+        expect(abuse2.reporterAccount.name).to.equal('root')
+        expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuse2.video).to.be.null
-      expect(abuse2.comment).to.be.null
+        expect(abuse2.video).to.be.null
+        expect(abuse2.comment).to.be.null
 
-      expect(abuse2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuse2.state.label).to.equal('Pending')
+        expect(abuse2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuse2.state.label).to.equal('Pending')
 
-      expect(abuse2.moderationComment).to.be.null
+        expect(abuse2.moderationComment).to.be.null
+      }
 
-      const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'account' })
-      expect(res2.body.total).to.equal(1)
-      expect(res2.body.data.length).to.equal(1)
+      {
+        const body = await commands[1].getAdminList({ filter: 'account' })
+        expect(body.total).to.equal(1)
+        expect(body.data.length).to.equal(1)
 
-      abuseServer2 = res2.body.data[0]
+        abuseServer2 = body.data[0]
 
-      expect(abuseServer2.reason).to.equal('it is a really bad account')
+        expect(abuseServer2.reason).to.equal('it is a really bad account')
 
-      expect(abuseServer2.reporterAccount.name).to.equal('root')
-      expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
+        expect(abuseServer2.reporterAccount.name).to.equal('root')
+        expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
 
-      expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
-      expect(abuseServer2.state.label).to.equal('Pending')
+        expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
+        expect(abuseServer2.state.label).to.equal('Pending')
 
-      expect(abuseServer2.moderationComment).to.be.null
+        expect(abuseServer2.moderationComment).to.be.null
+      }
     })
 
     it('Should keep the account abuse when deleting the account', async function () {
       this.timeout(10000)
 
-      const account = await getAccountFromServer(servers[1].url, 'user_2', servers[1])
-      await removeUser(servers[1].url, account.userId, servers[1].accessToken)
+      const account = await getAccountFromServer(servers[1], 'user_2', servers[1])
+      await servers[1].users.remove({ userId: account.userId })
 
       await waitJobs(servers)
 
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' })
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      const body = await commands[0].getAdminList({ filter: 'account' })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      const abuse = (res.body.data as AdminAbuse[]).find(a => a.reason === 'it is a really bad account')
+      const abuse = body.data.find(a => a.reason === 'it is a really bad account')
       expect(abuse).to.not.be.undefined
     })
 
     it('Should delete the account abuse', async function () {
       this.timeout(10000)
 
-      await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id)
+      await commands[1].delete({ abuseId: abuseServer2.id })
 
       await waitJobs(servers)
 
       {
-        const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'account' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data.length).to.equal(0)
+        const body = await commands[1].getAdminList({ filter: 'account' })
+        expect(body.total).to.equal(0)
+        expect(body.data.length).to.equal(0)
       }
 
       {
-        const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getAdminList({ filter: 'account' })
+        expect(body.total).to.equal(2)
 
-        abuseServer1 = res.body.data[0]
+        abuseServer1 = body.data[0]
       }
     })
   })
@@ -778,20 +739,18 @@ describe('Test abuses', function () {
   describe('Common actions on abuses', function () {
 
     it('Should update the state of an abuse', async function () {
-      const body = { state: AbuseState.REJECTED }
-      await updateAbuse(servers[0].url, servers[0].accessToken, abuseServer1.id, body)
+      await commands[0].update({ abuseId: abuseServer1.id, body: { state: AbuseState.REJECTED } })
 
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, id: abuseServer1.id })
-      expect(res.body.data[0].state.id).to.equal(AbuseState.REJECTED)
+      const body = await commands[0].getAdminList({ id: abuseServer1.id })
+      expect(body.data[0].state.id).to.equal(AbuseState.REJECTED)
     })
 
     it('Should add a moderation comment', async function () {
-      const body = { state: AbuseState.ACCEPTED, moderationComment: 'It is valid' }
-      await updateAbuse(servers[0].url, servers[0].accessToken, abuseServer1.id, body)
+      await commands[0].update({ abuseId: abuseServer1.id, body: { state: AbuseState.ACCEPTED, moderationComment: 'Valid' } })
 
-      const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, id: abuseServer1.id })
-      expect(res.body.data[0].state.id).to.equal(AbuseState.ACCEPTED)
-      expect(res.body.data[0].moderationComment).to.equal('It is valid')
+      const body = await commands[0].getAdminList({ id: abuseServer1.id })
+      expect(body.data[0].state.id).to.equal(AbuseState.ACCEPTED)
+      expect(body.data[0].moderationComment).to.equal('Valid')
     })
   })
 
@@ -800,20 +759,20 @@ describe('Test abuses', function () {
     let userAccessToken: string
 
     before(async function () {
-      userAccessToken = await generateUserAccessToken(servers[0], 'user_42')
+      userAccessToken = await servers[0].users.generateUserAndToken('user_42')
 
-      await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: servers[0].video.id, reason: 'user reason 1' })
+      await commands[0].report({ token: userAccessToken, videoId: servers[0].store.videoCreated.id, reason: 'user reason 1' })
 
-      const videoId = await getVideoIdFromUUID(servers[0].url, servers[1].video.uuid)
-      await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId, reason: 'user reason 2' })
+      const videoId = await servers[0].videos.getId({ uuid: servers[1].store.videoCreated.uuid })
+      await commands[0].report({ token: userAccessToken, videoId, reason: 'user reason 2' })
     })
 
     it('Should correctly list my abuses', async function () {
       {
-        const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 0, count: 5, sort: 'createdAt' })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getUserList({ token: userAccessToken, start: 0, count: 5, sort: 'createdAt' })
+        expect(body.total).to.equal(2)
 
-        const abuses: UserAbuse[] = res.body.data
+        const abuses = body.data
         expect(abuses[0].reason).to.equal('user reason 1')
         expect(abuses[1].reason).to.equal('user reason 2')
 
@@ -821,95 +780,77 @@ describe('Test abuses', function () {
       }
 
       {
-        const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 1, count: 1, sort: 'createdAt' })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getUserList({ token: userAccessToken, start: 1, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(2)
 
-        const abuses: UserAbuse[] = res.body.data
+        const abuses: UserAbuse[] = body.data
         expect(abuses[0].reason).to.equal('user reason 2')
       }
 
       {
-        const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 1, count: 1, sort: '-createdAt' })
-        expect(res.body.total).to.equal(2)
+        const body = await commands[0].getUserList({ token: userAccessToken, start: 1, count: 1, sort: '-createdAt' })
+        expect(body.total).to.equal(2)
 
-        const abuses: UserAbuse[] = res.body.data
+        const abuses: UserAbuse[] = body.data
         expect(abuses[0].reason).to.equal('user reason 1')
       }
     })
 
     it('Should correctly filter my abuses by id', async function () {
-      const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, id: abuseId1 })
+      const body = await commands[0].getUserList({ token: userAccessToken, id: abuseId1 })
+      expect(body.total).to.equal(1)
 
-      expect(res.body.total).to.equal(1)
-
-      const abuses: UserAbuse[] = res.body.data
+      const abuses: UserAbuse[] = body.data
       expect(abuses[0].reason).to.equal('user reason 1')
     })
 
     it('Should correctly filter my abuses by search', async function () {
-      const res = await getUserAbusesList({
-        url: servers[0].url,
-        token: userAccessToken,
-        search: 'server 2'
-      })
-
-      expect(res.body.total).to.equal(1)
+      const body = await commands[0].getUserList({ token: userAccessToken, search: 'server 2' })
+      expect(body.total).to.equal(1)
 
-      const abuses: UserAbuse[] = res.body.data
+      const abuses: UserAbuse[] = body.data
       expect(abuses[0].reason).to.equal('user reason 2')
     })
 
     it('Should correctly filter my abuses by state', async function () {
-      const body = { state: AbuseState.REJECTED }
-      await updateAbuse(servers[0].url, servers[0].accessToken, abuseId1, body)
+      await commands[0].update({ abuseId: abuseId1, body: { state: AbuseState.REJECTED } })
 
-      const res = await getUserAbusesList({
-        url: servers[0].url,
-        token: userAccessToken,
-        state: AbuseState.REJECTED
-      })
-
-      expect(res.body.total).to.equal(1)
+      const body = await commands[0].getUserList({ token: userAccessToken, state: AbuseState.REJECTED })
+      expect(body.total).to.equal(1)
 
-      const abuses: UserAbuse[] = res.body.data
+      const abuses: UserAbuse[] = body.data
       expect(abuses[0].reason).to.equal('user reason 1')
     })
   })
 
   describe('Abuse messages', async function () {
     let abuseId: number
-    let userAccessToken: string
+    let userToken: string
     let abuseMessageUserId: number
     let abuseMessageModerationId: number
 
     before(async function () {
-      userAccessToken = await generateUserAccessToken(servers[0], 'user_43')
+      userToken = await servers[0].users.generateUserAndToken('user_43')
 
-      const res = await reportAbuse({
-        url: servers[0].url,
-        token: userAccessToken,
-        videoId: servers[0].video.id,
-        reason: 'user 43 reason 1'
-      })
-
-      abuseId = res.body.abuse.id
+      const body = await commands[0].report({ token: userToken, videoId: servers[0].store.videoCreated.id, reason: 'user 43 reason 1' })
+      abuseId = body.abuse.id
     })
 
     it('Should create some messages on the abuse', async function () {
-      await addAbuseMessage(servers[0].url, userAccessToken, abuseId, 'message 1')
-      await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, 'message 2')
-      await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, 'message 3')
-      await addAbuseMessage(servers[0].url, userAccessToken, abuseId, 'message 4')
+      await commands[0].addMessage({ token: userToken, abuseId, message: 'message 1' })
+      await commands[0].addMessage({ abuseId, message: 'message 2' })
+      await commands[0].addMessage({ abuseId, message: 'message 3' })
+      await commands[0].addMessage({ token: userToken, abuseId, message: 'message 4' })
     })
 
     it('Should have the correct messages count when listing abuses', async function () {
       const results = await Promise.all([
-        getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, start: 0, count: 50 }),
-        getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 0, count: 50 })
+        commands[0].getAdminList({ start: 0, count: 50 }),
+        commands[0].getUserList({ token: userToken, start: 0, count: 50 })
       ])
 
-      for (const res of results) {
-        const abuses: AdminAbuse[] = res.body.data
+      for (const body of results) {
+        const abuses = body.data
         const abuse = abuses.find(a => a.id === abuseId)
         expect(abuse.countMessages).to.equal(4)
       }
@@ -917,14 +858,14 @@ describe('Test abuses', function () {
 
     it('Should correctly list messages of this abuse', async function () {
       const results = await Promise.all([
-        listAbuseMessages(servers[0].url, servers[0].accessToken, abuseId),
-        listAbuseMessages(servers[0].url, userAccessToken, abuseId)
+        commands[0].listMessages({ abuseId }),
+        commands[0].listMessages({ token: userToken, abuseId })
       ])
 
-      for (const res of results) {
-        expect(res.body.total).to.equal(4)
+      for (const body of results) {
+        expect(body.total).to.equal(4)
 
-        const abuseMessages: AbuseMessage[] = res.body.data
+        const abuseMessages: AbuseMessage[] = body.data
 
         expect(abuseMessages[0].message).to.equal('message 1')
         expect(abuseMessages[0].byModerator).to.be.false
@@ -948,19 +889,18 @@ describe('Test abuses', function () {
     })
 
     it('Should delete messages', async function () {
-      await deleteAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, abuseMessageModerationId)
-      await deleteAbuseMessage(servers[0].url, userAccessToken, abuseId, abuseMessageUserId)
+      await commands[0].deleteMessage({ abuseId, messageId: abuseMessageModerationId })
+      await commands[0].deleteMessage({ token: userToken, abuseId, messageId: abuseMessageUserId })
 
       const results = await Promise.all([
-        listAbuseMessages(servers[0].url, servers[0].accessToken, abuseId),
-        listAbuseMessages(servers[0].url, userAccessToken, abuseId)
+        commands[0].listMessages({ abuseId }),
+        commands[0].listMessages({ token: userToken, abuseId })
       ])
 
-      for (const res of results) {
-        expect(res.body.total).to.equal(2)
-
-        const abuseMessages: AbuseMessage[] = res.body.data
+      for (const body of results) {
+        expect(body.total).to.equal(2)
 
+        const abuseMessages: AbuseMessage[] = body.data
         expect(abuseMessages[0].message).to.equal('message 2')
         expect(abuseMessages[1].message).to.equal('message 4')
       }
diff --git a/server/tests/api/moderation/blocklist-notification.ts b/server/tests/api/moderation/blocklist-notification.ts
index 4fb3c95f2..75b15c298 100644
--- a/server/tests/api/moderation/blocklist-notification.ts
+++ b/server/tests/api/moderation/blocklist-notification.ts
@@ -2,47 +2,22 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { getUserNotifications, markAsReadAllNotifications } from '@shared/extra-utils/users/user-notifications'
-import { addUserSubscription, removeUserSubscription } from '@shared/extra-utils/users/user-subscriptions'
-import { UserNotification, UserNotificationType } from '@shared/models'
-import {
-  cleanupTests,
-  createUser,
-  doubleFollow,
-  flushAndRunMultipleServers,
-  ServerInfo,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils/index'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  addAccountToAccountBlocklist,
-  addAccountToServerBlocklist,
-  addServerToAccountBlocklist,
-  addServerToServerBlocklist,
-  removeAccountFromAccountBlocklist,
-  removeAccountFromServerBlocklist,
-  removeServerFromAccountBlocklist
-} from '../../../../shared/extra-utils/users/blocklist'
-import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
-import { addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments'
+import { cleanupTests, createMultipleServers, doubleFollow, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { UserNotificationType } from '@shared/models'
 
 const expect = chai.expect
 
-async function checkNotifications (url: string, token: string, expected: UserNotificationType[]) {
-  const res = await getUserNotifications(url, token, 0, 10, true)
-
-  const notifications: UserNotification[] = res.body.data
-
-  expect(notifications).to.have.lengthOf(expected.length)
+async function checkNotifications (server: PeerTubeServer, token: string, expected: UserNotificationType[]) {
+  const { data } = await server.notifications.list({ token, start: 0, count: 10, unread: true })
+  expect(data).to.have.lengthOf(expected.length)
 
   for (const type of expected) {
-    expect(notifications.find(n => n.type === type)).to.exist
+    expect(data.find(n => n.type === type)).to.exist
   }
 }
 
 describe('Test blocklist', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let videoUUID: string
 
   let userToken1: string
@@ -51,30 +26,34 @@ describe('Test blocklist', function () {
 
   async function resetState () {
     try {
-      await removeUserSubscription(servers[1].url, remoteUserToken, 'user1_channel@' + servers[0].host)
-      await removeUserSubscription(servers[1].url, remoteUserToken, 'user2_channel@' + servers[0].host)
+      await servers[1].subscriptions.remove({ token: remoteUserToken, uri: 'user1_channel@' + servers[0].host })
+      await servers[1].subscriptions.remove({ token: remoteUserToken, uri: 'user2_channel@' + servers[0].host })
     } catch {}
 
     await waitJobs(servers)
 
-    await markAsReadAllNotifications(servers[0].url, userToken1)
-    await markAsReadAllNotifications(servers[0].url, userToken2)
+    await servers[0].notifications.markAsReadAll({ token: userToken1 })
+    await servers[0].notifications.markAsReadAll({ token: userToken2 })
 
     {
-      const res = await uploadVideo(servers[0].url, userToken1, { name: 'video' })
-      videoUUID = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ token: userToken1, attributes: { name: 'video' } })
+      videoUUID = uuid
 
       await waitJobs(servers)
     }
 
     {
-      await addVideoCommentThread(servers[1].url, remoteUserToken, videoUUID, '@user2@' + servers[0].host + ' hello')
+      await servers[1].comments.createThread({
+        token: remoteUserToken,
+        videoId: videoUUID,
+        text: '@user2@' + servers[0].host + ' hello'
+      })
     }
 
     {
 
-      await addUserSubscription(servers[1].url, remoteUserToken, 'user1_channel@' + servers[0].host)
-      await addUserSubscription(servers[1].url, remoteUserToken, 'user2_channel@' + servers[0].host)
+      await servers[1].subscriptions.add({ token: remoteUserToken, targetUri: 'user1_channel@' + servers[0].host })
+      await servers[1].subscriptions.add({ token: remoteUserToken, targetUri: 'user2_channel@' + servers[0].host })
     }
 
     await waitJobs(servers)
@@ -83,36 +62,34 @@ describe('Test blocklist', function () {
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     {
       const user = { username: 'user1', password: 'password' }
-      await createUser({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
+      await servers[0].users.create({
         username: user.username,
         password: user.password,
         videoQuota: -1,
         videoQuotaDaily: -1
       })
 
-      userToken1 = await userLogin(servers[0], user)
-      await uploadVideo(servers[0].url, userToken1, { name: 'video user 1' })
+      userToken1 = await servers[0].login.getAccessToken(user)
+      await servers[0].videos.upload({ token: userToken1, attributes: { name: 'video user 1' } })
     }
 
     {
       const user = { username: 'user2', password: 'password' }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      userToken2 = await userLogin(servers[0], user)
+      userToken2 = await servers[0].login.getAccessToken(user)
     }
 
     {
       const user = { username: 'user3', password: 'password' }
-      await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
+      await servers[1].users.create({ username: user.username, password: user.password })
 
-      remoteUserToken = await userLogin(servers[1], user)
+      remoteUserToken = await servers[1].login.getAccessToken(user)
     }
 
     await doubleFollow(servers[0], servers[1])
@@ -128,26 +105,26 @@ describe('Test blocklist', function () {
 
     it('Should have appropriate notifications', async function () {
       const notifs = [ UserNotificationType.NEW_COMMENT_ON_MY_VIDEO, UserNotificationType.NEW_FOLLOW ]
-      await checkNotifications(servers[0].url, userToken1, notifs)
+      await checkNotifications(servers[0], userToken1, notifs)
     })
 
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await addAccountToAccountBlocklist(servers[0].url, userToken1, 'user3@' + servers[1].host)
+      await servers[0].blocklist.addToMyBlocklist({ token: userToken1, account: 'user3@' + servers[1].host })
       await waitJobs(servers)
     })
 
     it('Should not have notifications from this account', async function () {
-      await checkNotifications(servers[0].url, userToken1, [])
+      await checkNotifications(servers[0], userToken1, [])
     })
 
     it('Should have notifications of this account on user 2', async function () {
       const notifs = [ UserNotificationType.COMMENT_MENTION, UserNotificationType.NEW_FOLLOW ]
 
-      await checkNotifications(servers[0].url, userToken2, notifs)
+      await checkNotifications(servers[0], userToken2, notifs)
 
-      await removeAccountFromAccountBlocklist(servers[0].url, userToken1, 'user3@' + servers[1].host)
+      await servers[0].blocklist.removeFromMyBlocklist({ token: userToken1, account: 'user3@' + servers[1].host })
     })
   })
 
@@ -161,26 +138,26 @@ describe('Test blocklist', function () {
 
     it('Should have appropriate notifications', async function () {
       const notifs = [ UserNotificationType.NEW_COMMENT_ON_MY_VIDEO, UserNotificationType.NEW_FOLLOW ]
-      await checkNotifications(servers[0].url, userToken1, notifs)
+      await checkNotifications(servers[0], userToken1, notifs)
     })
 
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await addServerToAccountBlocklist(servers[0].url, userToken1, servers[1].host)
+      await servers[0].blocklist.addToMyBlocklist({ token: userToken1, server: servers[1].host })
       await waitJobs(servers)
     })
 
     it('Should not have notifications from this account', async function () {
-      await checkNotifications(servers[0].url, userToken1, [])
+      await checkNotifications(servers[0], userToken1, [])
     })
 
     it('Should have notifications of this account on user 2', async function () {
       const notifs = [ UserNotificationType.COMMENT_MENTION, UserNotificationType.NEW_FOLLOW ]
 
-      await checkNotifications(servers[0].url, userToken2, notifs)
+      await checkNotifications(servers[0], userToken2, notifs)
 
-      await removeServerFromAccountBlocklist(servers[0].url, userToken1, servers[1].host)
+      await servers[0].blocklist.removeFromMyBlocklist({ token: userToken1, server: servers[1].host })
     })
   })
 
@@ -195,27 +172,27 @@ describe('Test blocklist', function () {
     it('Should have appropriate notifications', async function () {
       {
         const notifs = [ UserNotificationType.NEW_COMMENT_ON_MY_VIDEO, UserNotificationType.NEW_FOLLOW ]
-        await checkNotifications(servers[0].url, userToken1, notifs)
+        await checkNotifications(servers[0], userToken1, notifs)
       }
 
       {
         const notifs = [ UserNotificationType.COMMENT_MENTION, UserNotificationType.NEW_FOLLOW ]
-        await checkNotifications(servers[0].url, userToken2, notifs)
+        await checkNotifications(servers[0], userToken2, notifs)
       }
     })
 
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, 'user3@' + servers[1].host)
+      await servers[0].blocklist.addToServerBlocklist({ account: 'user3@' + servers[1].host })
       await waitJobs(servers)
     })
 
     it('Should not have notifications from this account', async function () {
-      await checkNotifications(servers[0].url, userToken1, [])
-      await checkNotifications(servers[0].url, userToken2, [])
+      await checkNotifications(servers[0], userToken1, [])
+      await checkNotifications(servers[0], userToken2, [])
 
-      await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, 'user3@' + servers[1].host)
+      await servers[0].blocklist.removeFromServerBlocklist({ account: 'user3@' + servers[1].host })
     })
   })
 
@@ -230,25 +207,25 @@ describe('Test blocklist', function () {
     it('Should have appropriate notifications', async function () {
       {
         const notifs = [ UserNotificationType.NEW_COMMENT_ON_MY_VIDEO, UserNotificationType.NEW_FOLLOW ]
-        await checkNotifications(servers[0].url, userToken1, notifs)
+        await checkNotifications(servers[0], userToken1, notifs)
       }
 
       {
         const notifs = [ UserNotificationType.COMMENT_MENTION, UserNotificationType.NEW_FOLLOW ]
-        await checkNotifications(servers[0].url, userToken2, notifs)
+        await checkNotifications(servers[0], userToken2, notifs)
       }
     })
 
     it('Should block an account', async function () {
       this.timeout(10000)
 
-      await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, servers[1].host)
+      await servers[0].blocklist.addToServerBlocklist({ server: servers[1].host })
       await waitJobs(servers)
     })
 
     it('Should not have notifications from this account', async function () {
-      await checkNotifications(servers[0].url, userToken1, [])
-      await checkNotifications(servers[0].url, userToken2, [])
+      await checkNotifications(servers[0], userToken1, [])
+      await checkNotifications(servers[0], userToken2, [])
     })
   })
 
diff --git a/server/tests/api/moderation/blocklist.ts b/server/tests/api/moderation/blocklist.ts
index 793abbcb4..089af8b15 100644
--- a/server/tests/api/moderation/blocklist.ts
+++ b/server/tests/api/moderation/blocklist.ts
@@ -3,106 +3,67 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  addAccountToAccountBlocklist,
-  addAccountToServerBlocklist,
-  addServerToAccountBlocklist,
-  addServerToServerBlocklist,
-  addVideoCommentReply,
-  addVideoCommentThread,
+  BlocklistCommand,
   cleanupTests,
-  createUser,
-  deleteVideoComment,
+  CommentsCommand,
+  createMultipleServers,
   doubleFollow,
-  findCommentId,
-  flushAndRunMultipleServers,
-  follow,
-  getAccountBlocklistByAccount,
-  getAccountBlocklistByServer,
-  getServerBlocklistByAccount,
-  getServerBlocklistByServer,
-  getUserNotifications,
-  getVideoCommentThreads,
-  getVideosList,
-  getVideosListWithToken,
-  getVideoThreadComments,
-  removeAccountFromAccountBlocklist,
-  removeAccountFromServerBlocklist,
-  removeServerFromAccountBlocklist,
-  removeServerFromServerBlocklist,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  unfollow,
-  uploadVideo,
-  userLogin,
   waitJobs
 } from '@shared/extra-utils'
-import {
-  AccountBlock,
-  ServerBlock,
-  UserNotification,
-  UserNotificationType,
-  Video,
-  VideoComment,
-  VideoCommentThreadTree
-} from '@shared/models'
+import { UserNotificationType } from '@shared/models'
 
 const expect = chai.expect
 
-async function checkAllVideos (url: string, token: string) {
+async function checkAllVideos (server: PeerTubeServer, token: string) {
   {
-    const res = await getVideosListWithToken(url, token)
-
-    expect(res.body.data).to.have.lengthOf(5)
+    const { data } = await server.videos.listWithToken({ token })
+    expect(data).to.have.lengthOf(5)
   }
 
   {
-    const res = await getVideosList(url)
-
-    expect(res.body.data).to.have.lengthOf(5)
+    const { data } = await server.videos.list()
+    expect(data).to.have.lengthOf(5)
   }
 }
 
-async function checkAllComments (url: string, token: string, videoUUID: string) {
-  const resThreads = await getVideoCommentThreads(url, videoUUID, 0, 25, '-createdAt', token)
+async function checkAllComments (server: PeerTubeServer, token: string, videoUUID: string) {
+  const { data } = await server.comments.listThreads({ videoId: videoUUID, start: 0, count: 25, sort: '-createdAt', token })
 
-  const allThreads: VideoComment[] = resThreads.body.data
-  const threads = allThreads.filter(t => t.isDeleted === false)
+  const threads = data.filter(t => t.isDeleted === false)
   expect(threads).to.have.lengthOf(2)
 
   for (const thread of threads) {
-    const res = await getVideoThreadComments(url, videoUUID, thread.id, token)
-
-    const tree: VideoCommentThreadTree = res.body
+    const tree = await server.comments.getThread({ videoId: videoUUID, threadId: thread.id, token })
     expect(tree.children).to.have.lengthOf(1)
   }
 }
 
 async function checkCommentNotification (
-  mainServer: ServerInfo,
-  comment: { server: ServerInfo, token: string, videoUUID: string, text: string },
+  mainServer: PeerTubeServer,
+  comment: { server: PeerTubeServer, token: string, videoUUID: string, text: string },
   check: 'presence' | 'absence'
 ) {
-  const resComment = await addVideoCommentThread(comment.server.url, comment.token, comment.videoUUID, comment.text)
-  const created = resComment.body.comment as VideoComment
-  const threadId = created.id
-  const createdAt = created.createdAt
+  const command = comment.server.comments
+
+  const { threadId, createdAt } = await command.createThread({ token: comment.token, videoId: comment.videoUUID, text: comment.text })
 
   await waitJobs([ mainServer, comment.server ])
 
-  const res = await getUserNotifications(mainServer.url, mainServer.accessToken, 0, 30)
-  const commentNotifications = (res.body.data as UserNotification[])
-                                  .filter(n => n.comment && n.comment.video.uuid === comment.videoUUID && n.createdAt >= createdAt)
+  const { data } = await mainServer.notifications.list({ start: 0, count: 30 })
+  const commentNotifications = data.filter(n => n.comment && n.comment.video.uuid === comment.videoUUID && n.createdAt >= createdAt)
 
   if (check === 'presence') expect(commentNotifications).to.have.lengthOf(1)
   else expect(commentNotifications).to.have.lengthOf(0)
 
-  await deleteVideoComment(comment.server.url, comment.token, comment.videoUUID, threadId)
+  await command.delete({ token: comment.token, videoId: comment.videoUUID, commentId: threadId })
 
   await waitJobs([ mainServer, comment.server ])
 }
 
 describe('Test blocklist', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let videoUUID1: string
   let videoUUID2: string
   let videoUUID3: string
@@ -110,62 +71,73 @@ describe('Test blocklist', function () {
   let userModeratorToken: string
   let userToken2: string
 
+  let command: BlocklistCommand
+  let commentsCommand: CommentsCommand[]
+
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
     await setAccessTokensToServers(servers)
 
+    command = servers[0].blocklist
+    commentsCommand = servers.map(s => s.comments)
+
     {
       const user = { username: 'user1', password: 'password' }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      userToken1 = await userLogin(servers[0], user)
-      await uploadVideo(servers[0].url, userToken1, { name: 'video user 1' })
+      userToken1 = await servers[0].login.getAccessToken(user)
+      await servers[0].videos.upload({ token: userToken1, attributes: { name: 'video user 1' } })
     }
 
     {
       const user = { username: 'moderator', password: 'password' }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      userModeratorToken = await userLogin(servers[0], user)
+      userModeratorToken = await servers[0].login.getAccessToken(user)
     }
 
     {
       const user = { username: 'user2', password: 'password' }
-      await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
+      await servers[1].users.create({ username: user.username, password: user.password })
 
-      userToken2 = await userLogin(servers[1], user)
-      await uploadVideo(servers[1].url, userToken2, { name: 'video user 2' })
+      userToken2 = await servers[1].login.getAccessToken(user)
+      await servers[1].videos.upload({ token: userToken2, attributes: { name: 'video user 2' } })
     }
 
     {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video server 1' })
-      videoUUID1 = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video server 1' } })
+      videoUUID1 = uuid
     }
 
     {
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video server 2' })
-      videoUUID2 = res.body.video.uuid
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video server 2' } })
+      videoUUID2 = uuid
     }
 
     {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video 2 server 1' })
-      videoUUID3 = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video 2 server 1' } })
+      videoUUID3 = uuid
     }
 
     await doubleFollow(servers[0], servers[1])
     await doubleFollow(servers[0], servers[2])
 
     {
-      const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID1, 'comment root 1')
-      const resReply = await addVideoCommentReply(servers[0].url, userToken1, videoUUID1, resComment.body.comment.id, 'comment user 1')
-      await addVideoCommentReply(servers[0].url, servers[0].accessToken, videoUUID1, resReply.body.comment.id, 'comment root 1')
+      const created = await commentsCommand[0].createThread({ videoId: videoUUID1, text: 'comment root 1' })
+      const reply = await commentsCommand[0].addReply({
+        token: userToken1,
+        videoId: videoUUID1,
+        toCommentId: created.id,
+        text: 'comment user 1'
+      })
+      await commentsCommand[0].addReply({ videoId: videoUUID1, toCommentId: reply.id, text: 'comment root 1' })
     }
 
     {
-      const resComment = await addVideoCommentThread(servers[0].url, userToken1, videoUUID1, 'comment user 1')
-      await addVideoCommentReply(servers[0].url, servers[0].accessToken, videoUUID1, resComment.body.comment.id, 'comment root 1')
+      const created = await commentsCommand[0].createThread({ token: userToken1, videoId: videoUUID1, text: 'comment user 1' })
+      await commentsCommand[0].addReply({ videoId: videoUUID1, toCommentId: created.id, text: 'comment root 1' })
     }
 
     await waitJobs(servers)
@@ -175,55 +147,60 @@ describe('Test blocklist', function () {
 
     describe('When managing account blocklist', function () {
       it('Should list all videos', function () {
-        return checkAllVideos(servers[0].url, servers[0].accessToken)
+        return checkAllVideos(servers[0], servers[0].accessToken)
       })
 
       it('Should list the comments', function () {
-        return checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        return checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
       })
 
       it('Should block a remote account', async function () {
-        await addAccountToAccountBlocklist(servers[0].url, servers[0].accessToken, 'user2@localhost:' + servers[1].port)
+        await command.addToMyBlocklist({ account: 'user2@localhost:' + servers[1].port })
       })
 
       it('Should hide its videos', async function () {
-        const res = await getVideosListWithToken(servers[0].url, servers[0].accessToken)
+        const { data } = await servers[0].videos.listWithToken()
 
-        const videos: Video[] = res.body.data
-        expect(videos).to.have.lengthOf(4)
+        expect(data).to.have.lengthOf(4)
 
-        const v = videos.find(v => v.name === 'video user 2')
+        const v = data.find(v => v.name === 'video user 2')
         expect(v).to.be.undefined
       })
 
       it('Should block a local account', async function () {
-        await addAccountToAccountBlocklist(servers[0].url, servers[0].accessToken, 'user1')
+        await command.addToMyBlocklist({ account: 'user1' })
       })
 
       it('Should hide its videos', async function () {
-        const res = await getVideosListWithToken(servers[0].url, servers[0].accessToken)
+        const { data } = await servers[0].videos.listWithToken()
 
-        const videos: Video[] = res.body.data
-        expect(videos).to.have.lengthOf(3)
+        expect(data).to.have.lengthOf(3)
 
-        const v = videos.find(v => v.name === 'video user 1')
+        const v = data.find(v => v.name === 'video user 1')
         expect(v).to.be.undefined
       })
 
       it('Should hide its comments', async function () {
-        const resThreads = await getVideoCommentThreads(servers[0].url, videoUUID1, 0, 25, '-createdAt', servers[0].accessToken)
-
-        const threads: VideoComment[] = resThreads.body.data
-        expect(threads).to.have.lengthOf(1)
-        expect(threads[0].totalReplies).to.equal(1)
-
-        const t = threads.find(t => t.text === 'comment user 1')
+        const { data } = await commentsCommand[0].listThreads({
+          token: servers[0].accessToken,
+          videoId: videoUUID1,
+          start: 0,
+          count: 25,
+          sort: '-createdAt'
+        })
+
+        expect(data).to.have.lengthOf(1)
+        expect(data[0].totalReplies).to.equal(1)
+
+        const t = data.find(t => t.text === 'comment user 1')
         expect(t).to.be.undefined
 
-        for (const thread of threads) {
-          const res = await getVideoThreadComments(servers[0].url, videoUUID1, thread.id, servers[0].accessToken)
-
-          const tree: VideoCommentThreadTree = res.body
+        for (const thread of data) {
+          const tree = await commentsCommand[0].getThread({
+            videoId: videoUUID1,
+            threadId: thread.id,
+            token: servers[0].accessToken
+          })
           expect(tree.children).to.have.lengthOf(0)
         }
       })
@@ -248,17 +225,15 @@ describe('Test blocklist', function () {
       })
 
       it('Should list all the videos with another user', async function () {
-        return checkAllVideos(servers[0].url, userToken1)
+        return checkAllVideos(servers[0], userToken1)
       })
 
       it('Should list blocked accounts', async function () {
         {
-          const res = await getAccountBlocklistByAccount(servers[0].url, servers[0].accessToken, 0, 1, 'createdAt')
-          const blocks: AccountBlock[] = res.body.data
+          const body = await command.listMyAccountBlocklist({ start: 0, count: 1, sort: 'createdAt' })
+          expect(body.total).to.equal(2)
 
-          expect(res.body.total).to.equal(2)
-
-          const block = blocks[0]
+          const block = body.data[0]
           expect(block.byAccount.displayName).to.equal('root')
           expect(block.byAccount.name).to.equal('root')
           expect(block.blockedAccount.displayName).to.equal('user2')
@@ -267,12 +242,10 @@ describe('Test blocklist', function () {
         }
 
         {
-          const res = await getAccountBlocklistByAccount(servers[0].url, servers[0].accessToken, 1, 2, 'createdAt')
-          const blocks: AccountBlock[] = res.body.data
-
-          expect(res.body.total).to.equal(2)
+          const body = await command.listMyAccountBlocklist({ start: 1, count: 2, sort: 'createdAt' })
+          expect(body.total).to.equal(2)
 
-          const block = blocks[0]
+          const block = body.data[0]
           expect(block.byAccount.displayName).to.equal('root')
           expect(block.byAccount.name).to.equal('root')
           expect(block.blockedAccount.displayName).to.equal('user1')
@@ -285,32 +258,29 @@ describe('Test blocklist', function () {
         this.timeout(60000)
 
         {
-          await addVideoCommentThread(servers[1].url, userToken2, videoUUID3, 'comment user 2')
+          await commentsCommand[1].createThread({ token: userToken2, videoId: videoUUID3, text: 'comment user 2' })
           await waitJobs(servers)
 
-          await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID3, 'uploader')
+          await commentsCommand[0].createThread({ token: servers[0].accessToken, videoId: videoUUID3, text: 'uploader' })
           await waitJobs(servers)
 
-          const commentId = await findCommentId(servers[1].url, videoUUID3, 'uploader')
+          const commentId = await commentsCommand[1].findCommentId({ videoId: videoUUID3, text: 'uploader' })
           const message = 'reply by user 2'
-          const resReply = await addVideoCommentReply(servers[1].url, userToken2, videoUUID3, commentId, message)
-          await addVideoCommentReply(servers[1].url, servers[1].accessToken, videoUUID3, resReply.body.comment.id, 'another reply')
+          const reply = await commentsCommand[1].addReply({ token: userToken2, videoId: videoUUID3, toCommentId: commentId, text: message })
+          await commentsCommand[1].addReply({ videoId: videoUUID3, toCommentId: reply.id, text: 'another reply' })
 
           await waitJobs(servers)
         }
 
         // Server 2 has all the comments
         {
-          const resThreads = await getVideoCommentThreads(servers[1].url, videoUUID3, 0, 25, '-createdAt')
-          const threads: VideoComment[] = resThreads.body.data
-
-          expect(threads).to.have.lengthOf(2)
-          expect(threads[0].text).to.equal('uploader')
-          expect(threads[1].text).to.equal('comment user 2')
+          const { data } = await commentsCommand[1].listThreads({ videoId: videoUUID3, count: 25, sort: '-createdAt' })
 
-          const resReplies = await getVideoThreadComments(servers[1].url, videoUUID3, threads[0].id)
+          expect(data).to.have.lengthOf(2)
+          expect(data[0].text).to.equal('uploader')
+          expect(data[1].text).to.equal('comment user 2')
 
-          const tree: VideoCommentThreadTree = resReplies.body
+          const tree = await commentsCommand[1].getThread({ videoId: videoUUID3, threadId: data[0].id })
           expect(tree.children).to.have.lengthOf(1)
           expect(tree.children[0].comment.text).to.equal('reply by user 2')
           expect(tree.children[0].children).to.have.lengthOf(1)
@@ -319,55 +289,45 @@ describe('Test blocklist', function () {
 
         // Server 1 and 3 should only have uploader comments
         for (const server of [ servers[0], servers[2] ]) {
-          const resThreads = await getVideoCommentThreads(server.url, videoUUID3, 0, 25, '-createdAt')
-          const threads: VideoComment[] = resThreads.body.data
+          const { data } = await server.comments.listThreads({ videoId: videoUUID3, count: 25, sort: '-createdAt' })
 
-          expect(threads).to.have.lengthOf(1)
-          expect(threads[0].text).to.equal('uploader')
+          expect(data).to.have.lengthOf(1)
+          expect(data[0].text).to.equal('uploader')
 
-          const resReplies = await getVideoThreadComments(server.url, videoUUID3, threads[0].id)
+          const tree = await server.comments.getThread({ videoId: videoUUID3, threadId: data[0].id })
 
-          const tree: VideoCommentThreadTree = resReplies.body
-          if (server.serverNumber === 1) {
-            expect(tree.children).to.have.lengthOf(0)
-          } else {
-            expect(tree.children).to.have.lengthOf(1)
-          }
+          if (server.serverNumber === 1) expect(tree.children).to.have.lengthOf(0)
+          else expect(tree.children).to.have.lengthOf(1)
         }
       })
 
       it('Should unblock the remote account', async function () {
-        await removeAccountFromAccountBlocklist(servers[0].url, servers[0].accessToken, 'user2@localhost:' + servers[1].port)
+        await command.removeFromMyBlocklist({ account: 'user2@localhost:' + servers[1].port })
       })
 
       it('Should display its videos', async function () {
-        const res = await getVideosListWithToken(servers[0].url, servers[0].accessToken)
-
-        const videos: Video[] = res.body.data
-        expect(videos).to.have.lengthOf(4)
+        const { data } = await servers[0].videos.listWithToken()
+        expect(data).to.have.lengthOf(4)
 
-        const v = videos.find(v => v.name === 'video user 2')
+        const v = data.find(v => v.name === 'video user 2')
         expect(v).not.to.be.undefined
       })
 
       it('Should display its comments on my video', async function () {
         for (const server of servers) {
-          const resThreads = await getVideoCommentThreads(server.url, videoUUID3, 0, 25, '-createdAt')
-          const threads: VideoComment[] = resThreads.body.data
+          const { data } = await server.comments.listThreads({ videoId: videoUUID3, count: 25, sort: '-createdAt' })
 
           // Server 3 should not have 2 comment threads, because server 1 did not forward the server 2 comment
           if (server.serverNumber === 3) {
-            expect(threads).to.have.lengthOf(1)
+            expect(data).to.have.lengthOf(1)
             continue
           }
 
-          expect(threads).to.have.lengthOf(2)
-          expect(threads[0].text).to.equal('uploader')
-          expect(threads[1].text).to.equal('comment user 2')
+          expect(data).to.have.lengthOf(2)
+          expect(data[0].text).to.equal('uploader')
+          expect(data[1].text).to.equal('comment user 2')
 
-          const resReplies = await getVideoThreadComments(server.url, videoUUID3, threads[0].id)
-
-          const tree: VideoCommentThreadTree = resReplies.body
+          const tree = await server.comments.getThread({ videoId: videoUUID3, threadId: data[0].id })
           expect(tree.children).to.have.lengthOf(1)
           expect(tree.children[0].comment.text).to.equal('reply by user 2')
           expect(tree.children[0].children).to.have.lengthOf(1)
@@ -376,11 +336,11 @@ describe('Test blocklist', function () {
       })
 
       it('Should unblock the local account', async function () {
-        await removeAccountFromAccountBlocklist(servers[0].url, servers[0].accessToken, 'user1')
+        await command.removeFromMyBlocklist({ account: 'user1' })
       })
 
       it('Should display its comments', function () {
-        return checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        return checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
       })
 
       it('Should have a notification from a non blocked account', async function () {
@@ -404,46 +364,45 @@ describe('Test blocklist', function () {
     })
 
     describe('When managing server blocklist', function () {
+
       it('Should list all videos', function () {
-        return checkAllVideos(servers[0].url, servers[0].accessToken)
+        return checkAllVideos(servers[0], servers[0].accessToken)
       })
 
       it('Should list the comments', function () {
-        return checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        return checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
       })
 
       it('Should block a remote server', async function () {
-        await addServerToAccountBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.addToMyBlocklist({ server: 'localhost:' + servers[1].port })
       })
 
       it('Should hide its videos', async function () {
-        const res = await getVideosListWithToken(servers[0].url, servers[0].accessToken)
+        const { data } = await servers[0].videos.listWithToken()
 
-        const videos: Video[] = res.body.data
-        expect(videos).to.have.lengthOf(3)
+        expect(data).to.have.lengthOf(3)
 
-        const v1 = videos.find(v => v.name === 'video user 2')
-        const v2 = videos.find(v => v.name === 'video server 2')
+        const v1 = data.find(v => v.name === 'video user 2')
+        const v2 = data.find(v => v.name === 'video server 2')
 
         expect(v1).to.be.undefined
         expect(v2).to.be.undefined
       })
 
       it('Should list all the videos with another user', async function () {
-        return checkAllVideos(servers[0].url, userToken1)
+        return checkAllVideos(servers[0], userToken1)
       })
 
       it('Should hide its comments', async function () {
         this.timeout(10000)
 
-        const resThreads = await addVideoCommentThread(servers[1].url, userToken2, videoUUID1, 'hidden comment 2')
-        const threadId = resThreads.body.comment.id
+        const { id } = await commentsCommand[1].createThread({ token: userToken2, videoId: videoUUID1, text: 'hidden comment 2' })
 
         await waitJobs(servers)
 
-        await checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        await checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
 
-        await deleteVideoComment(servers[1].url, userToken2, videoUUID1, threadId)
+        await commentsCommand[1].delete({ token: userToken2, videoId: videoUUID1, commentId: id })
       })
 
       it('Should not have notifications from blocked server', async function () {
@@ -466,27 +425,25 @@ describe('Test blocklist', function () {
       })
 
       it('Should list blocked servers', async function () {
-        const res = await getServerBlocklistByAccount(servers[0].url, servers[0].accessToken, 0, 1, 'createdAt')
-        const blocks: ServerBlock[] = res.body.data
-
-        expect(res.body.total).to.equal(1)
+        const body = await command.listMyServerBlocklist({ start: 0, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(1)
 
-        const block = blocks[0]
+        const block = body.data[0]
         expect(block.byAccount.displayName).to.equal('root')
         expect(block.byAccount.name).to.equal('root')
         expect(block.blockedServer.host).to.equal('localhost:' + servers[1].port)
       })
 
       it('Should unblock the remote server', async function () {
-        await removeServerFromAccountBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.removeFromMyBlocklist({ server: 'localhost:' + servers[1].port })
       })
 
       it('Should display its videos', function () {
-        return checkAllVideos(servers[0].url, servers[0].accessToken)
+        return checkAllVideos(servers[0], servers[0].accessToken)
       })
 
       it('Should display its comments', function () {
-        return checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        return checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
       })
 
       it('Should have notification from unblocked server', async function () {
@@ -515,54 +472,50 @@ describe('Test blocklist', function () {
     describe('When managing account blocklist', function () {
       it('Should list all videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllVideos(servers[0].url, token)
+          await checkAllVideos(servers[0], token)
         }
       })
 
       it('Should list the comments', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllComments(servers[0].url, token, videoUUID1)
+          await checkAllComments(servers[0], token, videoUUID1)
         }
       })
 
       it('Should block a remote account', async function () {
-        await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, 'user2@localhost:' + servers[1].port)
+        await command.addToServerBlocklist({ account: 'user2@localhost:' + servers[1].port })
       })
 
       it('Should hide its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const res = await getVideosListWithToken(servers[0].url, token)
+          const { data } = await servers[0].videos.listWithToken({ token })
 
-          const videos: Video[] = res.body.data
-          expect(videos).to.have.lengthOf(4)
+          expect(data).to.have.lengthOf(4)
 
-          const v = videos.find(v => v.name === 'video user 2')
+          const v = data.find(v => v.name === 'video user 2')
           expect(v).to.be.undefined
         }
       })
 
       it('Should block a local account', async function () {
-        await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, 'user1')
+        await command.addToServerBlocklist({ account: 'user1' })
       })
 
       it('Should hide its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const res = await getVideosListWithToken(servers[0].url, token)
+          const { data } = await servers[0].videos.listWithToken({ token })
 
-          const videos: Video[] = res.body.data
-          expect(videos).to.have.lengthOf(3)
+          expect(data).to.have.lengthOf(3)
 
-          const v = videos.find(v => v.name === 'video user 1')
+          const v = data.find(v => v.name === 'video user 1')
           expect(v).to.be.undefined
         }
       })
 
       it('Should hide its comments', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const resThreads = await getVideoCommentThreads(servers[0].url, videoUUID1, 0, 20, '-createdAt', token)
-
-          let threads: VideoComment[] = resThreads.body.data
-          threads = threads.filter(t => t.isDeleted === false)
+          const { data } = await commentsCommand[0].listThreads({ videoId: videoUUID1, count: 20, sort: '-createdAt', token })
+          const threads = data.filter(t => t.isDeleted === false)
 
           expect(threads).to.have.lengthOf(1)
           expect(threads[0].totalReplies).to.equal(1)
@@ -571,9 +524,7 @@ describe('Test blocklist', function () {
           expect(t).to.be.undefined
 
           for (const thread of threads) {
-            const res = await getVideoThreadComments(servers[0].url, videoUUID1, thread.id, token)
-
-            const tree: VideoCommentThreadTree = res.body
+            const tree = await commentsCommand[0].getThread({ videoId: videoUUID1, threadId: thread.id, token })
             expect(tree.children).to.have.lengthOf(0)
           }
         }
@@ -600,12 +551,10 @@ describe('Test blocklist', function () {
 
       it('Should list blocked accounts', async function () {
         {
-          const res = await getAccountBlocklistByServer(servers[0].url, servers[0].accessToken, 0, 1, 'createdAt')
-          const blocks: AccountBlock[] = res.body.data
-
-          expect(res.body.total).to.equal(2)
+          const body = await command.listServerAccountBlocklist({ start: 0, count: 1, sort: 'createdAt' })
+          expect(body.total).to.equal(2)
 
-          const block = blocks[0]
+          const block = body.data[0]
           expect(block.byAccount.displayName).to.equal('peertube')
           expect(block.byAccount.name).to.equal('peertube')
           expect(block.blockedAccount.displayName).to.equal('user2')
@@ -614,12 +563,10 @@ describe('Test blocklist', function () {
         }
 
         {
-          const res = await getAccountBlocklistByServer(servers[0].url, servers[0].accessToken, 1, 2, 'createdAt')
-          const blocks: AccountBlock[] = res.body.data
+          const body = await command.listServerAccountBlocklist({ start: 1, count: 2, sort: 'createdAt' })
+          expect(body.total).to.equal(2)
 
-          expect(res.body.total).to.equal(2)
-
-          const block = blocks[0]
+          const block = body.data[0]
           expect(block.byAccount.displayName).to.equal('peertube')
           expect(block.byAccount.name).to.equal('peertube')
           expect(block.blockedAccount.displayName).to.equal('user1')
@@ -629,28 +576,26 @@ describe('Test blocklist', function () {
       })
 
       it('Should unblock the remote account', async function () {
-        await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, 'user2@localhost:' + servers[1].port)
+        await command.removeFromServerBlocklist({ account: 'user2@localhost:' + servers[1].port })
       })
 
       it('Should display its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const res = await getVideosListWithToken(servers[0].url, token)
-
-          const videos: Video[] = res.body.data
-          expect(videos).to.have.lengthOf(4)
+          const { data } = await servers[0].videos.listWithToken({ token })
+          expect(data).to.have.lengthOf(4)
 
-          const v = videos.find(v => v.name === 'video user 2')
+          const v = data.find(v => v.name === 'video user 2')
           expect(v).not.to.be.undefined
         }
       })
 
       it('Should unblock the local account', async function () {
-        await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, 'user1')
+        await command.removeFromServerBlocklist({ account: 'user1' })
       })
 
       it('Should display its comments', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllComments(servers[0].url, token, videoUUID1)
+          await checkAllComments(servers[0], token, videoUUID1)
         }
       })
 
@@ -677,31 +622,33 @@ describe('Test blocklist', function () {
     describe('When managing server blocklist', function () {
       it('Should list all videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllVideos(servers[0].url, token)
+          await checkAllVideos(servers[0], token)
         }
       })
 
       it('Should list the comments', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllComments(servers[0].url, token, videoUUID1)
+          await checkAllComments(servers[0], token, videoUUID1)
         }
       })
 
       it('Should block a remote server', async function () {
-        await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.addToServerBlocklist({ server: 'localhost:' + servers[1].port })
       })
 
       it('Should hide its videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          const res1 = await getVideosList(servers[0].url)
-          const res2 = await getVideosListWithToken(servers[0].url, token)
+          const requests = [
+            servers[0].videos.list(),
+            servers[0].videos.listWithToken({ token })
+          ]
 
-          for (const res of [ res1, res2 ]) {
-            const videos: Video[] = res.body.data
-            expect(videos).to.have.lengthOf(3)
+          for (const req of requests) {
+            const { data } = await req
+            expect(data).to.have.lengthOf(3)
 
-            const v1 = videos.find(v => v.name === 'video user 2')
-            const v2 = videos.find(v => v.name === 'video server 2')
+            const v1 = data.find(v => v.name === 'video user 2')
+            const v2 = data.find(v => v.name === 'video server 2')
 
             expect(v1).to.be.undefined
             expect(v2).to.be.undefined
@@ -712,14 +659,13 @@ describe('Test blocklist', function () {
       it('Should hide its comments', async function () {
         this.timeout(10000)
 
-        const resThreads = await addVideoCommentThread(servers[1].url, userToken2, videoUUID1, 'hidden comment 2')
-        const threadId = resThreads.body.comment.id
+        const { id } = await commentsCommand[1].createThread({ token: userToken2, videoId: videoUUID1, text: 'hidden comment 2' })
 
         await waitJobs(servers)
 
-        await checkAllComments(servers[0].url, servers[0].accessToken, videoUUID1)
+        await checkAllComments(servers[0], servers[0].accessToken, videoUUID1)
 
-        await deleteVideoComment(servers[1].url, userToken2, videoUUID1, threadId)
+        await commentsCommand[1].delete({ token: userToken2, videoId: videoUUID1, commentId: id })
       })
 
       it('Should not have notification from blocked instances by instance', async function () {
@@ -742,48 +688,44 @@ describe('Test blocklist', function () {
 
         {
           const now = new Date()
-          await unfollow(servers[1].url, servers[1].accessToken, servers[0])
+          await servers[1].follows.unfollow({ target: servers[0] })
           await waitJobs(servers)
-          await follow(servers[1].url, [ servers[0].host ], servers[1].accessToken)
+          await servers[1].follows.follow({ hosts: [ servers[0].host ] })
 
           await waitJobs(servers)
 
-          const res = await getUserNotifications(servers[0].url, servers[0].accessToken, 0, 30)
-          const commentNotifications = (res.body.data as UserNotification[])
-                                          .filter(n => {
-                                            return n.type === UserNotificationType.NEW_INSTANCE_FOLLOWER &&
-                                            n.createdAt >= now.toISOString()
-                                          })
+          const { data } = await servers[0].notifications.list({ start: 0, count: 30 })
+          const commentNotifications = data.filter(n => {
+            return n.type === UserNotificationType.NEW_INSTANCE_FOLLOWER && n.createdAt >= now.toISOString()
+          })
 
           expect(commentNotifications).to.have.lengthOf(0)
         }
       })
 
       it('Should list blocked servers', async function () {
-        const res = await getServerBlocklistByServer(servers[0].url, servers[0].accessToken, 0, 1, 'createdAt')
-        const blocks: ServerBlock[] = res.body.data
-
-        expect(res.body.total).to.equal(1)
+        const body = await command.listServerServerBlocklist({ start: 0, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(1)
 
-        const block = blocks[0]
+        const block = body.data[0]
         expect(block.byAccount.displayName).to.equal('peertube')
         expect(block.byAccount.name).to.equal('peertube')
         expect(block.blockedServer.host).to.equal('localhost:' + servers[1].port)
       })
 
       it('Should unblock the remote server', async function () {
-        await removeServerFromServerBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.removeFromServerBlocklist({ server: 'localhost:' + servers[1].port })
       })
 
       it('Should list all videos', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllVideos(servers[0].url, token)
+          await checkAllVideos(servers[0], token)
         }
       })
 
       it('Should list the comments', async function () {
         for (const token of [ userModeratorToken, servers[0].accessToken ]) {
-          await checkAllComments(servers[0].url, token, videoUUID1)
+          await checkAllComments(servers[0], token, videoUUID1)
         }
       })
 
@@ -807,18 +749,16 @@ describe('Test blocklist', function () {
 
         {
           const now = new Date()
-          await unfollow(servers[1].url, servers[1].accessToken, servers[0])
+          await servers[1].follows.unfollow({ target: servers[0] })
           await waitJobs(servers)
-          await follow(servers[1].url, [ servers[0].host ], servers[1].accessToken)
+          await servers[1].follows.follow({ hosts: [ servers[0].host ] })
 
           await waitJobs(servers)
 
-          const res = await getUserNotifications(servers[0].url, servers[0].accessToken, 0, 30)
-          const commentNotifications = (res.body.data as UserNotification[])
-                                          .filter(n => {
-                                            return n.type === UserNotificationType.NEW_INSTANCE_FOLLOWER &&
-                                            n.createdAt >= now.toISOString()
-                                          })
+          const { data } = await servers[0].notifications.list({ start: 0, count: 30 })
+          const commentNotifications = data.filter(n => {
+            return n.type === UserNotificationType.NEW_INSTANCE_FOLLOWER && n.createdAt >= now.toISOString()
+          })
 
           expect(commentNotifications).to.have.lengthOf(1)
         }
diff --git a/server/tests/api/moderation/video-blacklist.ts b/server/tests/api/moderation/video-blacklist.ts
index 52cac20d9..d5838191a 100644
--- a/server/tests/api/moderation/video-blacklist.ts
+++ b/server/tests/api/moderation/video-blacklist.ts
@@ -4,44 +4,30 @@ import 'mocha'
 import * as chai from 'chai'
 import { orderBy } from 'lodash'
 import {
-  addVideoToBlacklist,
+  BlacklistCommand,
   cleanupTests,
-  createUser,
-  flushAndRunMultipleServers,
-  getBlacklistedVideosList,
-  getMyUserInformation,
-  getMyVideos,
-  getVideosList,
+  createMultipleServers,
+  doubleFollow,
+  FIXTURE_URLS,
   killallServers,
-  removeVideoFromBlacklist,
-  reRunServer,
-  searchVideo,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateVideo,
-  updateVideoBlacklist,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils/index'
-import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { getGoodVideoUrl, getMagnetURI, importVideo } from '../../../../shared/extra-utils/videos/video-imports'
-import { User, UserRole } from '../../../../shared/models/users'
-import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
-import { VideoBlacklist, VideoBlacklistType } from '../../../../shared/models/videos'
+  waitJobs
+} from '@shared/extra-utils'
+import { UserAdminFlag, UserRole, VideoBlacklist, VideoBlacklistType } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test video blacklist', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoId: number
+  let command: BlacklistCommand
 
-  async function blacklistVideosOnServer (server: ServerInfo) {
-    const res = await getVideosList(server.url)
+  async function blacklistVideosOnServer (server: PeerTubeServer) {
+    const { data } = await server.videos.list()
 
-    const videos = res.body.data
-    for (const video of videos) {
-      await addVideoToBlacklist(server.url, server.accessToken, video.id, 'super reason')
+    for (const video of data) {
+      await server.blacklist.add({ videoId: video.id, reason: 'super reason' })
     }
   }
 
@@ -49,7 +35,7 @@ describe('Test video blacklist', function () {
     this.timeout(50000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -58,12 +44,14 @@ describe('Test video blacklist', function () {
     await doubleFollow(servers[0], servers[1])
 
     // Upload 2 videos on server 2
-    await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'My 1st video', description: 'A video on server 2' })
-    await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'My 2nd video', description: 'A video on server 2' })
+    await servers[1].videos.upload({ attributes: { name: 'My 1st video', description: 'A video on server 2' } })
+    await servers[1].videos.upload({ attributes: { name: 'My 2nd video', description: 'A video on server 2' } })
 
     // Wait videos propagation, server 2 has transcoding enabled
     await waitJobs(servers)
 
+    command = servers[0].blacklist
+
     // Blacklist the two videos on server 1
     await blacklistVideosOnServer(servers[0])
   })
@@ -72,48 +60,47 @@ describe('Test video blacklist', function () {
 
     it('Should not have the video blacklisted in videos list/search on server 1', async function () {
       {
-        const res = await getVideosList(servers[0].url)
+        const { total, data } = await servers[0].videos.list()
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data.length).to.equal(0)
+        expect(total).to.equal(0)
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(0)
       }
 
       {
-        const res = await searchVideo(servers[0].url, 'name')
+        const body = await servers[0].search.searchVideos({ search: 'video' })
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data.length).to.equal(0)
+        expect(body.total).to.equal(0)
+        expect(body.data).to.be.an('array')
+        expect(body.data.length).to.equal(0)
       }
     })
 
     it('Should have the blacklisted video in videos list/search on server 2', async function () {
       {
-        const res = await getVideosList(servers[1].url)
+        const { total, data } = await servers[1].videos.list()
 
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data.length).to.equal(2)
+        expect(total).to.equal(2)
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(2)
       }
 
       {
-        const res = await searchVideo(servers[1].url, 'video')
+        const body = await servers[1].search.searchVideos({ search: 'video' })
 
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data.length).to.equal(2)
+        expect(body.total).to.equal(2)
+        expect(body.data).to.be.an('array')
+        expect(body.data.length).to.equal(2)
       }
     })
   })
 
   describe('When listing manually blacklisted videos', function () {
     it('Should display all the blacklisted videos', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken })
-
-      expect(res.body.total).to.equal(2)
+      const body = await command.list()
+      expect(body.total).to.equal(2)
 
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(2)
 
@@ -124,79 +111,66 @@ describe('Test video blacklist', function () {
     })
 
     it('Should display all the blacklisted videos when applying manual type filter', async function () {
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        type: VideoBlacklistType.MANUAL
-      })
+      const body = await command.list({ type: VideoBlacklistType.MANUAL })
+      expect(body.total).to.equal(2)
 
-      expect(res.body.total).to.equal(2)
-
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(2)
     })
 
     it('Should display nothing when applying automatic type filter', async function () {
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
-      })
-
-      expect(res.body.total).to.equal(0)
+      const body = await command.list({ type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
+      expect(body.total).to.equal(0)
 
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(0)
     })
 
     it('Should get the correct sort when sorting by descending id', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: '-id' })
-      expect(res.body.total).to.equal(2)
+      const body = await command.list({ sort: '-id' })
+      expect(body.total).to.equal(2)
 
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(2)
 
-      const result = orderBy(res.body.data, [ 'id' ], [ 'desc' ])
-
+      const result = orderBy(body.data, [ 'id' ], [ 'desc' ])
       expect(blacklistedVideos).to.deep.equal(result)
     })
 
     it('Should get the correct sort when sorting by descending video name', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: '-name' })
-      expect(res.body.total).to.equal(2)
+      const body = await command.list({ sort: '-name' })
+      expect(body.total).to.equal(2)
 
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(2)
 
-      const result = orderBy(res.body.data, [ 'name' ], [ 'desc' ])
-
+      const result = orderBy(body.data, [ 'name' ], [ 'desc' ])
       expect(blacklistedVideos).to.deep.equal(result)
     })
 
     it('Should get the correct sort when sorting by ascending creation date', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: 'createdAt' })
-      expect(res.body.total).to.equal(2)
+      const body = await command.list({ sort: 'createdAt' })
+      expect(body.total).to.equal(2)
 
-      const blacklistedVideos = res.body.data
+      const blacklistedVideos = body.data
       expect(blacklistedVideos).to.be.an('array')
       expect(blacklistedVideos.length).to.equal(2)
 
-      const result = orderBy(res.body.data, [ 'createdAt' ])
-
+      const result = orderBy(body.data, [ 'createdAt' ])
       expect(blacklistedVideos).to.deep.equal(result)
     })
   })
 
   describe('When updating blacklisted videos', function () {
     it('Should change the reason', async function () {
-      await updateVideoBlacklist(servers[0].url, servers[0].accessToken, videoId, 'my super reason updated')
+      await command.update({ videoId, reason: 'my super reason updated' })
 
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: '-name' })
-      const video = res.body.data.find(b => b.video.id === videoId)
+      const body = await command.list({ sort: '-name' })
+      const video = body.data.find(b => b.video.id === videoId)
 
       expect(video.reason).to.equal('my super reason updated')
     })
@@ -206,12 +180,12 @@ describe('Test video blacklist', function () {
     it('Should display blacklisted videos', async function () {
       await blacklistVideosOnServer(servers[1])
 
-      const res = await getMyVideos(servers[1].url, servers[1].accessToken, 0, 5)
+      const { total, data } = await servers[1].videos.listMyVideos()
 
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      expect(total).to.equal(2)
+      expect(data).to.have.lengthOf(2)
 
-      for (const video of res.body.data) {
+      for (const video of data) {
         expect(video.blacklisted).to.be.true
         expect(video.blacklistedReason).to.equal('super reason')
       }
@@ -223,39 +197,38 @@ describe('Test video blacklist', function () {
     let blacklist = []
 
     it('Should not have any video in videos list on server 1', async function () {
-      const res = await getVideosList(servers[0].url)
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data.length).to.equal(0)
+      const { total, data } = await servers[0].videos.list()
+      expect(total).to.equal(0)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(0)
     })
 
     it('Should remove a video from the blacklist on server 1', async function () {
       // Get one video in the blacklist
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: '-name' })
-      videoToRemove = res.body.data[0]
-      blacklist = res.body.data.slice(1)
+      const body = await command.list({ sort: '-name' })
+      videoToRemove = body.data[0]
+      blacklist = body.data.slice(1)
 
       // Remove it
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoToRemove.video.id)
+      await command.remove({ videoId: videoToRemove.video.id })
     })
 
     it('Should have the ex-blacklisted video in videos list on server 1', async function () {
-      const res = await getVideosList(servers[0].url)
-      expect(res.body.total).to.equal(1)
+      const { total, data } = await servers[0].videos.list()
+      expect(total).to.equal(1)
 
-      const videos = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos.length).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(1)
 
-      expect(videos[0].name).to.equal(videoToRemove.video.name)
-      expect(videos[0].id).to.equal(videoToRemove.video.id)
+      expect(data[0].name).to.equal(videoToRemove.video.name)
+      expect(data[0].id).to.equal(videoToRemove.video.id)
     })
 
     it('Should not have the ex-blacklisted video in videos blacklist list on server 1', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: '-name' })
-      expect(res.body.total).to.equal(1)
+      const body = await command.list({ sort: '-name' })
+      expect(body.total).to.equal(1)
 
-      const videos = res.body.data
+      const videos = body.data
       expect(videos).to.be.an('array')
       expect(videos.length).to.equal(1)
       expect(videos).to.deep.equal(blacklist)
@@ -270,12 +243,12 @@ describe('Test video blacklist', function () {
       this.timeout(10000)
 
       {
-        const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'Video 3' })
-        video3UUID = res.body.video.uuid
+        const { uuid } = await servers[0].videos.upload({ attributes: { name: 'Video 3' } })
+        video3UUID = uuid
       }
       {
-        const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'Video 4' })
-        video4UUID = res.body.video.uuid
+        const { uuid } = await servers[0].videos.upload({ attributes: { name: 'Video 4' } })
+        video4UUID = uuid
       }
 
       await waitJobs(servers)
@@ -284,51 +257,51 @@ describe('Test video blacklist', function () {
     it('Should blacklist video 3 and keep it federated', async function () {
       this.timeout(10000)
 
-      await addVideoToBlacklist(servers[0].url, servers[0].accessToken, video3UUID, 'super reason', false)
+      await command.add({ videoId: video3UUID, reason: 'super reason', unfederate: false })
 
       await waitJobs(servers)
 
       {
-        const res = await getVideosList(servers[0].url)
-        expect(res.body.data.find(v => v.uuid === video3UUID)).to.be.undefined
+        const { data } = await servers[0].videos.list()
+        expect(data.find(v => v.uuid === video3UUID)).to.be.undefined
       }
 
       {
-        const res = await getVideosList(servers[1].url)
-        expect(res.body.data.find(v => v.uuid === video3UUID)).to.not.be.undefined
+        const { data } = await servers[1].videos.list()
+        expect(data.find(v => v.uuid === video3UUID)).to.not.be.undefined
       }
     })
 
     it('Should unfederate the video', async function () {
       this.timeout(10000)
 
-      await addVideoToBlacklist(servers[0].url, servers[0].accessToken, video4UUID, 'super reason', true)
+      await command.add({ videoId: video4UUID, reason: 'super reason', unfederate: true })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        expect(res.body.data.find(v => v.uuid === video4UUID)).to.be.undefined
+        const { data } = await server.videos.list()
+        expect(data.find(v => v.uuid === video4UUID)).to.be.undefined
       }
     })
 
     it('Should have the video unfederated even after an Update AP message', async function () {
       this.timeout(10000)
 
-      await updateVideo(servers[0].url, servers[0].accessToken, video4UUID, { description: 'super description' })
+      await servers[0].videos.update({ id: video4UUID, attributes: { description: 'super description' } })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        expect(res.body.data.find(v => v.uuid === video4UUID)).to.be.undefined
+        const { data } = await server.videos.list()
+        expect(data.find(v => v.uuid === video4UUID)).to.be.undefined
       }
     })
 
     it('Should have the correct video blacklist unfederate attribute', async function () {
-      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, sort: 'createdAt' })
+      const body = await command.list({ sort: 'createdAt' })
 
-      const blacklistedVideos: VideoBlacklist[] = res.body.data
+      const blacklistedVideos = body.data
       const video3Blacklisted = blacklistedVideos.find(b => b.video.uuid === video3UUID)
       const video4Blacklisted = blacklistedVideos.find(b => b.video.uuid === video4UUID)
 
@@ -339,13 +312,13 @@ describe('Test video blacklist', function () {
     it('Should remove the video from blacklist and refederate the video', async function () {
       this.timeout(10000)
 
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, video4UUID)
+      await command.remove({ videoId: video4UUID })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        expect(res.body.data.find(v => v.uuid === video4UUID)).to.not.be.undefined
+        const { data } = await server.videos.list()
+        expect(data.find(v => v.uuid === video4UUID)).to.not.be.undefined
       }
     })
 
@@ -359,7 +332,7 @@ describe('Test video blacklist', function () {
     before(async function () {
       this.timeout(20000)
 
-      killallServers([ servers[0] ])
+      await killallServers([ servers[0] ])
 
       const config = {
         auto_blacklist: {
@@ -370,106 +343,79 @@ describe('Test video blacklist', function () {
           }
         }
       }
-      await reRunServer(servers[0], config)
+      await servers[0].run(config)
 
       {
         const user = { username: 'user_without_flag', password: 'password' }
-        await createUser({
-          url: servers[0].url,
-          accessToken: servers[0].accessToken,
+        await servers[0].users.create({
           username: user.username,
           adminFlags: UserAdminFlag.NONE,
           password: user.password,
           role: UserRole.USER
         })
 
-        userWithoutFlag = await userLogin(servers[0], user)
+        userWithoutFlag = await servers[0].login.getAccessToken(user)
 
-        const res = await getMyUserInformation(servers[0].url, userWithoutFlag)
-        const body: User = res.body
-        channelOfUserWithoutFlag = body.videoChannels[0].id
+        const { videoChannels } = await servers[0].users.getMyInfo({ token: userWithoutFlag })
+        channelOfUserWithoutFlag = videoChannels[0].id
       }
 
       {
         const user = { username: 'user_with_flag', password: 'password' }
-        await createUser({
-          url: servers[0].url,
-          accessToken: servers[0].accessToken,
+        await servers[0].users.create({
           username: user.username,
           adminFlags: UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST,
           password: user.password,
           role: UserRole.USER
         })
 
-        userWithFlag = await userLogin(servers[0], user)
+        userWithFlag = await servers[0].login.getAccessToken(user)
       }
 
       await waitJobs(servers)
     })
 
     it('Should auto blacklist a video on upload', async function () {
-      await uploadVideo(servers[0].url, userWithoutFlag, { name: 'blacklisted' })
-
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
-      })
+      await servers[0].videos.upload({ token: userWithoutFlag, attributes: { name: 'blacklisted' } })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data[0].video.name).to.equal('blacklisted')
+      const body = await command.list({ type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].video.name).to.equal('blacklisted')
     })
 
     it('Should auto blacklist a video on URL import', async function () {
       this.timeout(15000)
 
       const attributes = {
-        targetUrl: getGoodVideoUrl(),
+        targetUrl: FIXTURE_URLS.goodVideo,
         name: 'URL import',
         channelId: channelOfUserWithoutFlag
       }
-      await importVideo(servers[0].url, userWithoutFlag, attributes)
+      await servers[0].imports.importVideo({ token: userWithoutFlag, attributes })
 
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        sort: 'createdAt',
-        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
-      })
-
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data[1].video.name).to.equal('URL import')
+      const body = await command.list({ sort: 'createdAt', type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
+      expect(body.total).to.equal(2)
+      expect(body.data[1].video.name).to.equal('URL import')
     })
 
     it('Should auto blacklist a video on torrent import', async function () {
       const attributes = {
-        magnetUri: getMagnetURI(),
+        magnetUri: FIXTURE_URLS.magnet,
         name: 'Torrent import',
         channelId: channelOfUserWithoutFlag
       }
-      await importVideo(servers[0].url, userWithoutFlag, attributes)
-
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        sort: 'createdAt',
-        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
-      })
+      await servers[0].imports.importVideo({ token: userWithoutFlag, attributes })
 
-      expect(res.body.total).to.equal(3)
-      expect(res.body.data[2].video.name).to.equal('Torrent import')
+      const body = await command.list({ sort: 'createdAt', type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
+      expect(body.total).to.equal(3)
+      expect(body.data[2].video.name).to.equal('Torrent import')
     })
 
     it('Should not auto blacklist a video on upload if the user has the bypass blacklist flag', async function () {
-      await uploadVideo(servers[0].url, userWithFlag, { name: 'not blacklisted' })
-
-      const res = await getBlacklistedVideosList({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
-      })
+      await servers[0].videos.upload({ token: userWithFlag, attributes: { name: 'not blacklisted' } })
 
-      expect(res.body.total).to.equal(3)
+      const body = await command.list({ type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
+      expect(body.total).to.equal(3)
     })
   })
 
diff --git a/server/tests/api/notifications/admin-notifications.ts b/server/tests/api/notifications/admin-notifications.ts
index cfe0bd2bb..c00d4e257 100644
--- a/server/tests/api/notifications/admin-notifications.ts
+++ b/server/tests/api/notifications/admin-notifications.ts
@@ -2,21 +2,21 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import { MockJoinPeerTubeVersions } from '@shared/extra-utils/mock-servers/joinpeertube-versions'
-import { PluginType } from '@shared/models'
-import { cleanupTests, installPlugin, setPluginLatestVersion, setPluginVersion, wait } from '../../../../shared/extra-utils'
-import { ServerInfo } from '../../../../shared/extra-utils/index'
-import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
 import {
   CheckerBaseParams,
   checkNewPeerTubeVersion,
   checkNewPluginVersion,
-  prepareNotificationsTest
-} from '../../../../shared/extra-utils/users/user-notifications'
-import { UserNotification, UserNotificationType } from '../../../../shared/models/users'
+  cleanupTests,
+  MockJoinPeerTubeVersions,
+  MockSmtpServer,
+  PeerTubeServer,
+  prepareNotificationsTest,
+  wait
+} from '@shared/extra-utils'
+import { PluginType, UserNotification, UserNotificationType } from '@shared/models'
 
 describe('Test admin notifications', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userNotifications: UserNotification[] = []
   let adminNotifications: UserNotification[] = []
   let emails: object[] = []
@@ -58,17 +58,8 @@ describe('Test admin notifications', function () {
       token: server.accessToken
     }
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-plugin-hello-world'
-    })
-
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-theme-background-red'
-    })
+    await server.plugins.install({ npmName: 'peertube-plugin-hello-world' })
+    await server.plugins.install({ npmName: 'peertube-theme-background-red' })
   })
 
   describe('Latest PeerTube version notification', function () {
@@ -79,7 +70,7 @@ describe('Test admin notifications', function () {
       joinPeerTubeServer.setLatestVersion('1.4.2')
 
       await wait(3000)
-      await checkNewPeerTubeVersion(baseParams, '1.4.2', 'absence')
+      await checkNewPeerTubeVersion({ ...baseParams, latestVersion: '1.4.2', checkType: 'absence' })
     })
 
     it('Should send a notification to admins on new plugin version', async function () {
@@ -88,7 +79,7 @@ describe('Test admin notifications', function () {
       joinPeerTubeServer.setLatestVersion('15.4.2')
 
       await wait(3000)
-      await checkNewPeerTubeVersion(baseParams, '15.4.2', 'presence')
+      await checkNewPeerTubeVersion({ ...baseParams, latestVersion: '15.4.2', checkType: 'presence' })
     })
 
     it('Should not send the same notification to admins', async function () {
@@ -110,7 +101,7 @@ describe('Test admin notifications', function () {
       joinPeerTubeServer.setLatestVersion('15.4.3')
 
       await wait(3000)
-      await checkNewPeerTubeVersion(baseParams, '15.4.3', 'presence')
+      await checkNewPeerTubeVersion({ ...baseParams, latestVersion: '15.4.3', checkType: 'presence' })
       expect(adminNotifications.filter(n => n.type === UserNotificationType.NEW_PEERTUBE_VERSION)).to.have.lengthOf(2)
     })
   })
@@ -121,17 +112,17 @@ describe('Test admin notifications', function () {
       this.timeout(30000)
 
       await wait(6000)
-      await checkNewPluginVersion(baseParams, PluginType.PLUGIN, 'hello-world', 'absence')
+      await checkNewPluginVersion({ ...baseParams, pluginType: PluginType.PLUGIN, pluginName: 'hello-world', checkType: 'absence' })
     })
 
     it('Should send a notification to admins on new plugin version', async function () {
       this.timeout(30000)
 
-      await setPluginVersion(server.internalServerNumber, 'hello-world', '0.0.1')
-      await setPluginLatestVersion(server.internalServerNumber, 'hello-world', '0.0.1')
+      await server.sql.setPluginVersion('hello-world', '0.0.1')
+      await server.sql.setPluginLatestVersion('hello-world', '0.0.1')
       await wait(6000)
 
-      await checkNewPluginVersion(baseParams, PluginType.PLUGIN, 'hello-world', 'presence')
+      await checkNewPluginVersion({ ...baseParams, pluginType: PluginType.PLUGIN, pluginName: 'hello-world', checkType: 'presence' })
     })
 
     it('Should not send the same notification to admins', async function () {
@@ -149,8 +140,8 @@ describe('Test admin notifications', function () {
     it('Should send a new notification after a new plugin release', async function () {
       this.timeout(30000)
 
-      await setPluginVersion(server.internalServerNumber, 'hello-world', '0.0.1')
-      await setPluginLatestVersion(server.internalServerNumber, 'hello-world', '0.0.1')
+      await server.sql.setPluginVersion('hello-world', '0.0.1')
+      await server.sql.setPluginLatestVersion('hello-world', '0.0.1')
       await wait(6000)
 
       expect(adminNotifications.filter(n => n.type === UserNotificationType.NEW_PEERTUBE_VERSION)).to.have.lengthOf(2)
diff --git a/server/tests/api/notifications/comments-notifications.ts b/server/tests/api/notifications/comments-notifications.ts
index d2badf237..7cbb21397 100644
--- a/server/tests/api/notifications/comments-notifications.ts
+++ b/server/tests/api/notifications/comments-notifications.ts
@@ -3,30 +3,22 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  addAccountToAccountBlocklist,
-  addVideoCommentReply,
-  addVideoCommentThread,
   checkCommentMention,
   CheckerBaseParams,
   checkNewCommentOnMyVideo,
   cleanupTests,
-  getVideoCommentThreads,
-  getVideoThreadComments,
   MockSmtpServer,
+  PeerTubeServer,
   prepareNotificationsTest,
-  removeAccountFromAccountBlocklist,
-  ServerInfo,
-  updateMyUser,
-  uploadVideo,
   waitJobs
 } from '@shared/extra-utils'
-import { UserNotification, VideoCommentThreadTree } from '@shared/models'
+import { UserNotification } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test comments notifications', function () {
-  let servers: ServerInfo[] = []
-  let userAccessToken: string
+  let servers: PeerTubeServer[] = []
+  let userToken: string
   let userNotifications: UserNotification[] = []
   let emails: object[] = []
 
@@ -40,7 +32,7 @@ describe('Test comments notifications', function () {
 
     const res = await prepareNotificationsTest(2)
     emails = res.emails
-    userAccessToken = res.userAccessToken
+    userToken = res.userAccessToken
     servers = res.servers
     userNotifications = res.userNotifications
   })
@@ -53,136 +45,125 @@ describe('Test comments notifications', function () {
         server: servers[0],
         emails,
         socketNotifications: userNotifications,
-        token: userAccessToken
+        token: userToken
       }
     })
 
     it('Should not send a new comment notification after a comment on another video', async function () {
       this.timeout(20000)
 
-      const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
 
-      const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
-      const commentId = resComment.body.comment.id
+      const created = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
+      const commentId = created.id
 
       await waitJobs(servers)
-      await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
+      await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'absence' })
     })
 
     it('Should not send a new comment notification if I comment my own video', async function () {
       this.timeout(20000)
 
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
 
-      const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, 'comment')
-      const commentId = resComment.body.comment.id
+      const created = await servers[0].comments.createThread({ token: userToken, videoId: uuid, text: 'comment' })
+      const commentId = created.id
 
       await waitJobs(servers)
-      await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
+      await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'absence' })
     })
 
     it('Should not send a new comment notification if the account is muted', async function () {
       this.timeout(20000)
 
-      await addAccountToAccountBlocklist(servers[0].url, userAccessToken, 'root')
+      await servers[0].blocklist.addToMyBlocklist({ token: userToken, account: 'root' })
 
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
 
-      const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
-      const commentId = resComment.body.comment.id
+      const created = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
+      const commentId = created.id
 
       await waitJobs(servers)
-      await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
+      await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'absence' })
 
-      await removeAccountFromAccountBlocklist(servers[0].url, userAccessToken, 'root')
+      await servers[0].blocklist.removeFromMyBlocklist({ token: userToken, account: 'root' })
     })
 
     it('Should send a new comment notification after a local comment on my video', async function () {
       this.timeout(20000)
 
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
 
-      const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
-      const commentId = resComment.body.comment.id
+      const created = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
+      const commentId = created.id
 
       await waitJobs(servers)
-      await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence')
+      await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'presence' })
     })
 
     it('Should send a new comment notification after a remote comment on my video', async function () {
       this.timeout(20000)
 
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
 
       await waitJobs(servers)
 
-      await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
+      await servers[1].comments.createThread({ videoId: uuid, text: 'comment' })
 
       await waitJobs(servers)
 
-      const resComment = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
-      expect(resComment.body.data).to.have.lengthOf(1)
-      const commentId = resComment.body.data[0].id
+      const { data } = await servers[0].comments.listThreads({ videoId: uuid })
+      expect(data).to.have.lengthOf(1)
 
-      await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence')
+      const commentId = data[0].id
+      await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'presence' })
     })
 
     it('Should send a new comment notification after a local reply on my video', async function () {
       this.timeout(20000)
 
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
 
-      const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
-      const threadId = resThread.body.comment.id
+      const { id: threadId } = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
 
-      const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'reply')
-      const commentId = resComment.body.comment.id
+      const { id: commentId } = await servers[0].comments.addReply({ videoId: uuid, toCommentId: threadId, text: 'reply' })
 
       await waitJobs(servers)
-      await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence')
+      await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId, commentId, checkType: 'presence' })
     })
 
     it('Should send a new comment notification after a remote reply on my video', async function () {
       this.timeout(20000)
 
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
       await waitJobs(servers)
 
       {
-        const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
-        const threadId = resThread.body.comment.id
-        await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, threadId, 'reply')
+        const created = await servers[1].comments.createThread({ videoId: uuid, text: 'comment' })
+        const threadId = created.id
+        await servers[1].comments.addReply({ videoId: uuid, toCommentId: threadId, text: 'reply' })
       }
 
       await waitJobs(servers)
 
-      const resThread = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
-      expect(resThread.body.data).to.have.lengthOf(1)
-      const threadId = resThread.body.data[0].id
+      const { data } = await servers[0].comments.listThreads({ videoId: uuid })
+      expect(data).to.have.lengthOf(1)
 
-      const resComments = await getVideoThreadComments(servers[0].url, uuid, threadId)
-      const tree = resComments.body as VideoCommentThreadTree
+      const threadId = data[0].id
+      const tree = await servers[0].comments.getThread({ videoId: uuid, threadId })
 
       expect(tree.children).to.have.lengthOf(1)
       const commentId = tree.children[0].comment.id
 
-      await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence')
+      await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId, commentId, checkType: 'presence' })
     })
 
     it('Should convert markdown in comment to html', async function () {
       this.timeout(20000)
 
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'cool video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'cool video' } })
 
-      await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, commentText)
+      await servers[0].comments.createThread({ videoId: uuid, text: commentText })
 
       await waitJobs(servers)
 
@@ -193,147 +174,127 @@ describe('Test comments notifications', function () {
 
   describe('Mention notifications', function () {
     let baseParams: CheckerBaseParams
+    const byAccountDisplayName = 'super root name'
 
     before(async () => {
       baseParams = {
         server: servers[0],
         emails,
         socketNotifications: userNotifications,
-        token: userAccessToken
+        token: userToken
       }
 
-      await updateMyUser({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        displayName: 'super root name'
-      })
-
-      await updateMyUser({
-        url: servers[1].url,
-        accessToken: servers[1].accessToken,
-        displayName: 'super root 2 name'
-      })
+      await servers[0].users.updateMe({ displayName: 'super root name' })
+      await servers[1].users.updateMe({ displayName: 'super root 2 name' })
     })
 
     it('Should not send a new mention comment notification if I mention the video owner', async function () {
       this.timeout(10000)
 
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
 
-      const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello')
-      const commentId = resComment.body.comment.id
+      const { id: commentId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hello' })
 
       await waitJobs(servers)
-      await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
+      await checkCommentMention({ ...baseParams, shortUUID, threadId: commentId, commentId, byAccountDisplayName, checkType: 'absence' })
     })
 
     it('Should not send a new mention comment notification if I mention myself', async function () {
       this.timeout(10000)
 
-      const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
 
-      const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, '@user_1 hello')
-      const commentId = resComment.body.comment.id
+      const { id: commentId } = await servers[0].comments.createThread({ token: userToken, videoId: uuid, text: '@user_1 hello' })
 
       await waitJobs(servers)
-      await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
+      await checkCommentMention({ ...baseParams, shortUUID, threadId: commentId, commentId, byAccountDisplayName, checkType: 'absence' })
     })
 
     it('Should not send a new mention notification if the account is muted', async function () {
       this.timeout(10000)
 
-      await addAccountToAccountBlocklist(servers[0].url, userAccessToken, 'root')
+      await servers[0].blocklist.addToMyBlocklist({ token: userToken, account: 'root' })
 
-      const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
 
-      const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello')
-      const commentId = resComment.body.comment.id
+      const { id: commentId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hello' })
 
       await waitJobs(servers)
-      await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
+      await checkCommentMention({ ...baseParams, shortUUID, threadId: commentId, commentId, byAccountDisplayName, checkType: 'absence' })
 
-      await removeAccountFromAccountBlocklist(servers[0].url, userAccessToken, 'root')
+      await servers[0].blocklist.removeFromMyBlocklist({ token: userToken, account: 'root' })
     })
 
     it('Should not send a new mention notification if the remote account mention a local account', async function () {
       this.timeout(20000)
 
-      const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
 
       await waitJobs(servers)
-      const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, '@user_1 hello')
-      const threadId = resThread.body.comment.id
+      const { id: threadId } = await servers[1].comments.createThread({ videoId: uuid, text: '@user_1 hello' })
 
       await waitJobs(servers)
-      await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root 2 name', 'absence')
+
+      const byAccountDisplayName = 'super root 2 name'
+      await checkCommentMention({ ...baseParams, shortUUID, threadId, commentId: threadId, byAccountDisplayName, checkType: 'absence' })
     })
 
     it('Should send a new mention notification after local comments', async function () {
       this.timeout(10000)
 
-      const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
 
-      const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello 1')
-      const threadId = resThread.body.comment.id
+      const { id: threadId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hellotext:  1' })
 
       await waitJobs(servers)
-      await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root name', 'presence')
+      await checkCommentMention({ ...baseParams, shortUUID, threadId, commentId: threadId, byAccountDisplayName, checkType: 'presence' })
 
-      const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'hello 2 @user_1')
-      const commentId = resComment.body.comment.id
+      const { id: commentId } = await servers[0].comments.addReply({ videoId: uuid, toCommentId: threadId, text: 'hello 2 @user_1' })
 
       await waitJobs(servers)
-      await checkCommentMention(baseParams, uuid, commentId, threadId, 'super root name', 'presence')
+      await checkCommentMention({ ...baseParams, shortUUID, commentId, threadId, byAccountDisplayName, checkType: 'presence' })
     })
 
     it('Should send a new mention notification after remote comments', async function () {
       this.timeout(20000)
 
-      const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
 
       await waitJobs(servers)
 
       const text1 = `hello @user_1@localhost:${servers[0].port} 1`
-      const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, text1)
-      const server2ThreadId = resThread.body.comment.id
+      const { id: server2ThreadId } = await servers[1].comments.createThread({ videoId: uuid, text: text1 })
 
       await waitJobs(servers)
 
-      const resThread2 = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
-      expect(resThread2.body.data).to.have.lengthOf(1)
-      const server1ThreadId = resThread2.body.data[0].id
-      await checkCommentMention(baseParams, uuid, server1ThreadId, server1ThreadId, 'super root 2 name', 'presence')
+      const { data } = await servers[0].comments.listThreads({ videoId: uuid })
+      expect(data).to.have.lengthOf(1)
+
+      const byAccountDisplayName = 'super root 2 name'
+      const threadId = data[0].id
+      await checkCommentMention({ ...baseParams, shortUUID, commentId: threadId, threadId, byAccountDisplayName, checkType: 'presence' })
 
       const text2 = `@user_1@localhost:${servers[0].port} hello 2 @root@localhost:${servers[0].port}`
-      await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, server2ThreadId, text2)
+      await servers[1].comments.addReply({ videoId: uuid, toCommentId: server2ThreadId, text: text2 })
 
       await waitJobs(servers)
 
-      const resComments = await getVideoThreadComments(servers[0].url, uuid, server1ThreadId)
-      const tree = resComments.body as VideoCommentThreadTree
+      const tree = await servers[0].comments.getThread({ videoId: uuid, threadId })
 
       expect(tree.children).to.have.lengthOf(1)
       const commentId = tree.children[0].comment.id
 
-      await checkCommentMention(baseParams, uuid, commentId, server1ThreadId, 'super root 2 name', 'presence')
+      await checkCommentMention({ ...baseParams, shortUUID, commentId, threadId, byAccountDisplayName, checkType: 'presence' })
     })
 
     it('Should convert markdown in comment to html', async function () {
       this.timeout(10000)
 
-      const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
-      const uuid = resVideo.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
 
-      const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello 1')
-      const threadId = resThread.body.comment.id
+      const { id: threadId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hello 1' })
 
-      await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, '@user_1 ' + commentText)
+      await servers[0].comments.addReply({ videoId: uuid, toCommentId: threadId, text: '@user_1 ' + commentText })
 
       await waitJobs(servers)
 
diff --git a/server/tests/api/notifications/moderation-notifications.ts b/server/tests/api/notifications/moderation-notifications.ts
index 3425480ae..eb3c29fe7 100644
--- a/server/tests/api/notifications/moderation-notifications.ts
+++ b/server/tests/api/notifications/moderation-notifications.ts
@@ -2,33 +2,6 @@
 
 import 'mocha'
 import { buildUUID } from '@server/helpers/uuid'
-import { AbuseState } from '@shared/models'
-import {
-  addAbuseMessage,
-  addVideoCommentThread,
-  addVideoToBlacklist,
-  cleanupTests,
-  createUser,
-  follow,
-  generateUserAccessToken,
-  getAccount,
-  getCustomConfig,
-  getVideoCommentThreads,
-  getVideoIdFromUUID,
-  immutableAssign,
-  MockInstancesIndex,
-  registerUser,
-  removeVideoFromBlacklist,
-  reportAbuse,
-  unfollow,
-  updateAbuse,
-  updateCustomConfig,
-  updateCustomSubConfig,
-  wait
-} from '../../../../shared/extra-utils'
-import { ServerInfo, uploadVideo } from '../../../../shared/extra-utils/index'
-import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import {
   checkAbuseStateChange,
   checkAutoInstanceFollowing,
@@ -43,15 +16,18 @@ import {
   checkUserRegistered,
   checkVideoAutoBlacklistForModerators,
   checkVideoIsPublished,
-  prepareNotificationsTest
-} from '../../../../shared/extra-utils/users/user-notifications'
-import { addUserSubscription, removeUserSubscription } from '../../../../shared/extra-utils/users/user-subscriptions'
-import { CustomConfig } from '../../../../shared/models/server'
-import { UserNotification } from '../../../../shared/models/users'
-import { VideoPrivacy } from '../../../../shared/models/videos'
+  cleanupTests,
+  MockInstancesIndex,
+  MockSmtpServer,
+  PeerTubeServer,
+  prepareNotificationsTest,
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { AbuseState, CustomConfig, UserNotification, VideoPrivacy } from '@shared/models'
 
 describe('Test moderation notifications', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let userAccessToken: string
   let userNotifications: UserNotification[] = []
   let adminNotifications: UserNotification[] = []
@@ -86,93 +62,97 @@ describe('Test moderation notifications', function () {
       this.timeout(20000)
 
       const name = 'video for abuse ' + buildUUID()
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
-      const video = resVideo.body.video
+      const video = await servers[0].videos.upload({ token: userAccessToken, attributes: { name } })
 
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId: video.id, reason: 'super reason' })
+      await servers[0].abuses.report({ videoId: video.id, reason: 'super reason' })
 
       await waitJobs(servers)
-      await checkNewVideoAbuseForModerators(baseParams, video.uuid, name, 'presence')
+      await checkNewVideoAbuseForModerators({ ...baseParams, shortUUID: video.shortUUID, videoName: name, checkType: 'presence' })
     })
 
     it('Should send a notification to moderators on remote video abuse', async function () {
       this.timeout(20000)
 
       const name = 'video for abuse ' + buildUUID()
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
-      const video = resVideo.body.video
+      const video = await servers[0].videos.upload({ token: userAccessToken, attributes: { name } })
 
       await waitJobs(servers)
 
-      const videoId = await getVideoIdFromUUID(servers[1].url, video.uuid)
-      await reportAbuse({ url: servers[1].url, token: servers[1].accessToken, videoId, reason: 'super reason' })
+      const videoId = await servers[1].videos.getId({ uuid: video.uuid })
+      await servers[1].abuses.report({ videoId, reason: 'super reason' })
 
       await waitJobs(servers)
-      await checkNewVideoAbuseForModerators(baseParams, video.uuid, name, 'presence')
+      await checkNewVideoAbuseForModerators({ ...baseParams, shortUUID: video.shortUUID, videoName: name, checkType: 'presence' })
     })
 
     it('Should send a notification to moderators on local comment abuse', async function () {
       this.timeout(20000)
 
       const name = 'video for abuse ' + buildUUID()
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
-      const video = resVideo.body.video
-      const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, video.id, 'comment abuse ' + buildUUID())
-      const comment = resComment.body.comment
+      const video = await servers[0].videos.upload({ token: userAccessToken, attributes: { name } })
+      const comment = await servers[0].comments.createThread({
+        token: userAccessToken,
+        videoId: video.id,
+        text: 'comment abuse ' + buildUUID()
+      })
 
       await waitJobs(servers)
 
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, commentId: comment.id, reason: 'super reason' })
+      await servers[0].abuses.report({ commentId: comment.id, reason: 'super reason' })
 
       await waitJobs(servers)
-      await checkNewCommentAbuseForModerators(baseParams, video.uuid, name, 'presence')
+      await checkNewCommentAbuseForModerators({ ...baseParams, shortUUID: video.shortUUID, videoName: name, checkType: 'presence' })
     })
 
     it('Should send a notification to moderators on remote comment abuse', async function () {
       this.timeout(20000)
 
       const name = 'video for abuse ' + buildUUID()
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
-      const video = resVideo.body.video
-      await addVideoCommentThread(servers[0].url, userAccessToken, video.id, 'comment abuse ' + buildUUID())
+      const video = await servers[0].videos.upload({ token: userAccessToken, attributes: { name } })
+
+      await servers[0].comments.createThread({
+        token: userAccessToken,
+        videoId: video.id,
+        text: 'comment abuse ' + buildUUID()
+      })
 
       await waitJobs(servers)
 
-      const resComments = await getVideoCommentThreads(servers[1].url, video.uuid, 0, 5)
-      const commentId = resComments.body.data[0].id
-      await reportAbuse({ url: servers[1].url, token: servers[1].accessToken, commentId, reason: 'super reason' })
+      const { data } = await servers[1].comments.listThreads({ videoId: video.uuid })
+      const commentId = data[0].id
+      await servers[1].abuses.report({ commentId, reason: 'super reason' })
 
       await waitJobs(servers)
-      await checkNewCommentAbuseForModerators(baseParams, video.uuid, name, 'presence')
+      await checkNewCommentAbuseForModerators({ ...baseParams, shortUUID: video.shortUUID, videoName: name, checkType: 'presence' })
     })
 
     it('Should send a notification to moderators on local account abuse', async function () {
       this.timeout(20000)
 
       const username = 'user' + new Date().getTime()
-      const resUser = await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username, password: 'donald' })
-      const accountId = resUser.body.user.account.id
+      const { account } = await servers[0].users.create({ username, password: 'donald' })
+      const accountId = account.id
 
-      await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, accountId, reason: 'super reason' })
+      await servers[0].abuses.report({ accountId, reason: 'super reason' })
 
       await waitJobs(servers)
-      await checkNewAccountAbuseForModerators(baseParams, username, 'presence')
+      await checkNewAccountAbuseForModerators({ ...baseParams, displayName: username, checkType: 'presence' })
     })
 
     it('Should send a notification to moderators on remote account abuse', async function () {
       this.timeout(20000)
 
       const username = 'user' + new Date().getTime()
-      const tmpToken = await generateUserAccessToken(servers[0], username)
-      await uploadVideo(servers[0].url, tmpToken, { name: 'super video' })
+      const tmpToken = await servers[0].users.generateUserAndToken(username)
+      await servers[0].videos.upload({ token: tmpToken, attributes: { name: 'super video' } })
 
       await waitJobs(servers)
 
-      const resAccount = await getAccount(servers[1].url, username + '@' + servers[0].host)
-      await reportAbuse({ url: servers[1].url, token: servers[1].accessToken, accountId: resAccount.body.id, reason: 'super reason' })
+      const account = await servers[1].accounts.get({ accountName: username + '@' + servers[0].host })
+      await servers[1].abuses.report({ accountId: account.id, reason: 'super reason' })
 
       await waitJobs(servers)
-      await checkNewAccountAbuseForModerators(baseParams, username, 'presence')
+      await checkNewAccountAbuseForModerators({ ...baseParams, displayName: username, checkType: 'presence' })
     })
   })
 
@@ -189,29 +169,28 @@ describe('Test moderation notifications', function () {
       }
 
       const name = 'abuse ' + buildUUID()
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
-      const video = resVideo.body.video
+      const video = await servers[0].videos.upload({ token: userAccessToken, attributes: { name } })
 
-      const res = await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: video.id, reason: 'super reason' })
-      abuseId = res.body.abuse.id
+      const body = await servers[0].abuses.report({ token: userAccessToken, videoId: video.id, reason: 'super reason' })
+      abuseId = body.abuse.id
     })
 
     it('Should send a notification to reporter if the abuse has been accepted', async function () {
       this.timeout(10000)
 
-      await updateAbuse(servers[0].url, servers[0].accessToken, abuseId, { state: AbuseState.ACCEPTED })
+      await servers[0].abuses.update({ abuseId, body: { state: AbuseState.ACCEPTED } })
       await waitJobs(servers)
 
-      await checkAbuseStateChange(baseParams, abuseId, AbuseState.ACCEPTED, 'presence')
+      await checkAbuseStateChange({ ...baseParams, abuseId, state: AbuseState.ACCEPTED, checkType: 'presence' })
     })
 
     it('Should send a notification to reporter if the abuse has been rejected', async function () {
       this.timeout(10000)
 
-      await updateAbuse(servers[0].url, servers[0].accessToken, abuseId, { state: AbuseState.REJECTED })
+      await servers[0].abuses.update({ abuseId, body: { state: AbuseState.REJECTED } })
       await waitJobs(servers)
 
-      await checkAbuseStateChange(baseParams, abuseId, AbuseState.REJECTED, 'presence')
+      await checkAbuseStateChange({ ...baseParams, abuseId, state: AbuseState.REJECTED, checkType: 'presence' })
     })
   })
 
@@ -237,17 +216,16 @@ describe('Test moderation notifications', function () {
       }
 
       const name = 'abuse ' + buildUUID()
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
-      const video = resVideo.body.video
+      const video = await servers[0].videos.upload({ token: userAccessToken, attributes: { name } })
 
       {
-        const res = await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: video.id, reason: 'super reason' })
-        abuseId = res.body.abuse.id
+        const body = await servers[0].abuses.report({ token: userAccessToken, videoId: video.id, reason: 'super reason' })
+        abuseId = body.abuse.id
       }
 
       {
-        const res = await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: video.id, reason: 'super reason 2' })
-        abuseId2 = res.body.abuse.id
+        const body = await servers[0].abuses.report({ token: userAccessToken, videoId: video.id, reason: 'super reason 2' })
+        abuseId2 = body.abuse.id
       }
     })
 
@@ -255,40 +233,43 @@ describe('Test moderation notifications', function () {
       this.timeout(10000)
 
       const message = 'my super message to users'
-      await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, message)
+      await servers[0].abuses.addMessage({ abuseId, message })
       await waitJobs(servers)
 
-      await checkNewAbuseMessage(baseParamsUser, abuseId, message, 'user_1@example.com', 'presence')
+      await checkNewAbuseMessage({ ...baseParamsUser, abuseId, message, toEmail: 'user_1@example.com', checkType: 'presence' })
     })
 
     it('Should not send a notification to the admin if sent by the admin', async function () {
       this.timeout(10000)
 
       const message = 'my super message that should not be sent to the admin'
-      await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, message)
+      await servers[0].abuses.addMessage({ abuseId, message })
       await waitJobs(servers)
 
-      await checkNewAbuseMessage(baseParamsAdmin, abuseId, message, 'admin' + servers[0].internalServerNumber + '@example.com', 'absence')
+      const toEmail = 'admin' + servers[0].internalServerNumber + '@example.com'
+      await checkNewAbuseMessage({ ...baseParamsAdmin, abuseId, message, toEmail, checkType: 'absence' })
     })
 
     it('Should send a notification to moderators', async function () {
       this.timeout(10000)
 
       const message = 'my super message to moderators'
-      await addAbuseMessage(servers[0].url, userAccessToken, abuseId2, message)
+      await servers[0].abuses.addMessage({ token: userAccessToken, abuseId: abuseId2, message })
       await waitJobs(servers)
 
-      await checkNewAbuseMessage(baseParamsAdmin, abuseId2, message, 'admin' + servers[0].internalServerNumber + '@example.com', 'presence')
+      const toEmail = 'admin' + servers[0].internalServerNumber + '@example.com'
+      await checkNewAbuseMessage({ ...baseParamsAdmin, abuseId: abuseId2, message, toEmail, checkType: 'presence' })
     })
 
     it('Should not send a notification to reporter if sent by the reporter', async function () {
       this.timeout(10000)
 
       const message = 'my super message that should not be sent to reporter'
-      await addAbuseMessage(servers[0].url, userAccessToken, abuseId2, message)
+      await servers[0].abuses.addMessage({ token: userAccessToken, abuseId: abuseId2, message })
       await waitJobs(servers)
 
-      await checkNewAbuseMessage(baseParamsUser, abuseId2, message, 'user_1@example.com', 'absence')
+      const toEmail = 'user_1@example.com'
+      await checkNewAbuseMessage({ ...baseParamsUser, abuseId: abuseId2, message, toEmail, checkType: 'absence' })
     })
   })
 
@@ -308,30 +289,28 @@ describe('Test moderation notifications', function () {
       this.timeout(10000)
 
       const name = 'video for abuse ' + buildUUID()
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ token: userAccessToken, attributes: { name } })
 
-      await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid)
+      await servers[0].blacklist.add({ videoId: uuid })
 
       await waitJobs(servers)
-      await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'blacklist')
+      await checkNewBlacklistOnMyVideo({ ...baseParams, shortUUID, videoName: name, blacklistType: 'blacklist' })
     })
 
     it('Should send a notification to video owner on unblacklist', async function () {
       this.timeout(10000)
 
       const name = 'video for abuse ' + buildUUID()
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
-      const uuid = resVideo.body.video.uuid
+      const { uuid, shortUUID } = await servers[0].videos.upload({ token: userAccessToken, attributes: { name } })
 
-      await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid)
+      await servers[0].blacklist.add({ videoId: uuid })
 
       await waitJobs(servers)
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, uuid)
+      await servers[0].blacklist.remove({ videoId: uuid })
       await waitJobs(servers)
 
       await wait(500)
-      await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'unblacklist')
+      await checkNewBlacklistOnMyVideo({ ...baseParams, shortUUID, videoName: name, blacklistType: 'unblacklist' })
     })
   })
 
@@ -350,14 +329,14 @@ describe('Test moderation notifications', function () {
     it('Should send a notification only to moderators when a user registers on the instance', async function () {
       this.timeout(10000)
 
-      await registerUser(servers[0].url, 'user_45', 'password')
+      await servers[0].users.register({ username: 'user_45' })
 
       await waitJobs(servers)
 
-      await checkUserRegistered(baseParams, 'user_45', 'presence')
+      await checkUserRegistered({ ...baseParams, username: 'user_45', checkType: 'presence' })
 
       const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } }
-      await checkUserRegistered(immutableAssign(baseParams, userOverride), 'user_45', 'absence')
+      await checkUserRegistered({ ...baseParams, ...userOverride, username: 'user_45', checkType: 'absence' })
     })
   })
 
@@ -392,20 +371,20 @@ describe('Test moderation notifications', function () {
     it('Should send a notification only to admin when there is a new instance follower', async function () {
       this.timeout(20000)
 
-      await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken)
+      await servers[2].follows.follow({ hosts: [ servers[0].url ] })
 
       await waitJobs(servers)
 
-      await checkNewInstanceFollower(baseParams, 'localhost:' + servers[2].port, 'presence')
+      await checkNewInstanceFollower({ ...baseParams, followerHost: 'localhost:' + servers[2].port, checkType: 'presence' })
 
       const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } }
-      await checkNewInstanceFollower(immutableAssign(baseParams, userOverride), 'localhost:' + servers[2].port, 'absence')
+      await checkNewInstanceFollower({ ...baseParams, ...userOverride, followerHost: 'localhost:' + servers[2].port, checkType: 'absence' })
     })
 
     it('Should send a notification on auto follow back', async function () {
       this.timeout(40000)
 
-      await unfollow(servers[2].url, servers[2].accessToken, servers[0])
+      await servers[2].follows.unfollow({ target: servers[0] })
       await waitJobs(servers)
 
       const config = {
@@ -415,41 +394,41 @@ describe('Test moderation notifications', function () {
           }
         }
       }
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
+      await servers[0].config.updateCustomSubConfig({ newConfig: config })
 
-      await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken)
+      await servers[2].follows.follow({ hosts: [ servers[0].url ] })
 
       await waitJobs(servers)
 
       const followerHost = servers[0].host
       const followingHost = servers[2].host
-      await checkAutoInstanceFollowing(baseParams, followerHost, followingHost, 'presence')
+      await checkAutoInstanceFollowing({ ...baseParams, followerHost, followingHost, checkType: 'presence' })
 
       const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } }
-      await checkAutoInstanceFollowing(immutableAssign(baseParams, userOverride), followerHost, followingHost, 'absence')
+      await checkAutoInstanceFollowing({ ...baseParams, ...userOverride, followerHost, followingHost, checkType: 'absence' })
 
       config.followings.instance.autoFollowBack.enabled = false
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
-      await unfollow(servers[0].url, servers[0].accessToken, servers[2])
-      await unfollow(servers[2].url, servers[2].accessToken, servers[0])
+      await servers[0].config.updateCustomSubConfig({ newConfig: config })
+      await servers[0].follows.unfollow({ target: servers[2] })
+      await servers[2].follows.unfollow({ target: servers[0] })
     })
 
     it('Should send a notification on auto instances index follow', async function () {
       this.timeout(30000)
-      await unfollow(servers[0].url, servers[0].accessToken, servers[1])
+      await servers[0].follows.unfollow({ target: servers[1] })
 
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
+      await servers[0].config.updateCustomSubConfig({ newConfig: config })
 
       await wait(5000)
       await waitJobs(servers)
 
       const followerHost = servers[0].host
       const followingHost = servers[1].host
-      await checkAutoInstanceFollowing(baseParams, followerHost, followingHost, 'presence')
+      await checkAutoInstanceFollowing({ ...baseParams, followerHost, followingHost, checkType: 'presence' })
 
       config.followings.instance.autoFollowIndex.enabled = false
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
-      await unfollow(servers[0].url, servers[0].accessToken, servers[1])
+      await servers[0].config.updateCustomSubConfig({ newConfig: config })
+      await servers[0].follows.unfollow({ target: servers[1] })
     })
   })
 
@@ -457,7 +436,8 @@ describe('Test moderation notifications', function () {
     let userBaseParams: CheckerBaseParams
     let adminBaseParamsServer1: CheckerBaseParams
     let adminBaseParamsServer2: CheckerBaseParams
-    let videoUUID: string
+    let uuid: string
+    let shortUUID: string
     let videoName: string
     let currentCustomConfig: CustomConfig
 
@@ -484,9 +464,11 @@ describe('Test moderation notifications', function () {
         token: userAccessToken
       }
 
-      const resCustomConfig = await getCustomConfig(servers[0].url, servers[0].accessToken)
-      currentCustomConfig = resCustomConfig.body
-      const autoBlacklistTestsCustomConfig = immutableAssign(currentCustomConfig, {
+      currentCustomConfig = await servers[0].config.getCustomConfig()
+
+      const autoBlacklistTestsCustomConfig = {
+        ...currentCustomConfig,
+
         autoBlacklist: {
           videos: {
             ofUsers: {
@@ -494,43 +476,44 @@ describe('Test moderation notifications', function () {
             }
           }
         }
-      })
+      }
+
       // enable transcoding otherwise own publish notification after transcoding not expected
       autoBlacklistTestsCustomConfig.transcoding.enabled = true
-      await updateCustomConfig(servers[0].url, servers[0].accessToken, autoBlacklistTestsCustomConfig)
-
-      await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port)
-      await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port)
+      await servers[0].config.updateCustomConfig({ newCustomConfig: autoBlacklistTestsCustomConfig })
 
+      await servers[0].subscriptions.add({ targetUri: 'user_1_channel@localhost:' + servers[0].port })
+      await servers[1].subscriptions.add({ targetUri: 'user_1_channel@localhost:' + servers[0].port })
     })
 
     it('Should send notification to moderators on new video with auto-blacklist', async function () {
       this.timeout(40000)
 
       videoName = 'video with auto-blacklist ' + buildUUID()
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: videoName })
-      videoUUID = resVideo.body.video.uuid
+      const video = await servers[0].videos.upload({ token: userAccessToken, attributes: { name: videoName } })
+      shortUUID = video.shortUUID
+      uuid = video.uuid
 
       await waitJobs(servers)
-      await checkVideoAutoBlacklistForModerators(adminBaseParamsServer1, videoUUID, videoName, 'presence')
+      await checkVideoAutoBlacklistForModerators({ ...adminBaseParamsServer1, shortUUID, videoName, checkType: 'presence' })
     })
 
     it('Should not send video publish notification if auto-blacklisted', async function () {
-      await checkVideoIsPublished(userBaseParams, videoName, videoUUID, 'absence')
+      await checkVideoIsPublished({ ...userBaseParams, videoName, shortUUID, checkType: 'absence' })
     })
 
     it('Should not send a local user subscription notification if auto-blacklisted', async function () {
-      await checkNewVideoFromSubscription(adminBaseParamsServer1, videoName, videoUUID, 'absence')
+      await checkNewVideoFromSubscription({ ...adminBaseParamsServer1, videoName, shortUUID, checkType: 'absence' })
     })
 
     it('Should not send a remote user subscription notification if auto-blacklisted', async function () {
-      await checkNewVideoFromSubscription(adminBaseParamsServer2, videoName, videoUUID, 'absence')
+      await checkNewVideoFromSubscription({ ...adminBaseParamsServer2, videoName, shortUUID, checkType: 'absence' })
     })
 
     it('Should send video published and unblacklist after video unblacklisted', async function () {
       this.timeout(40000)
 
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoUUID)
+      await servers[0].blacklist.remove({ videoId: uuid })
 
       await waitJobs(servers)
 
@@ -541,11 +524,11 @@ describe('Test moderation notifications', function () {
     })
 
     it('Should send a local user subscription notification after removed from blacklist', async function () {
-      await checkNewVideoFromSubscription(adminBaseParamsServer1, videoName, videoUUID, 'presence')
+      await checkNewVideoFromSubscription({ ...adminBaseParamsServer1, videoName, shortUUID, checkType: 'presence' })
     })
 
     it('Should send a remote user subscription notification after removed from blacklist', async function () {
-      await checkNewVideoFromSubscription(adminBaseParamsServer2, videoName, videoUUID, 'presence')
+      await checkNewVideoFromSubscription({ ...adminBaseParamsServer2, videoName, shortUUID, checkType: 'presence' })
     })
 
     it('Should send unblacklist but not published/subscription notes after unblacklisted if scheduled update pending', async function () {
@@ -555,29 +538,28 @@ describe('Test moderation notifications', function () {
 
       const name = 'video with auto-blacklist and future schedule ' + buildUUID()
 
-      const data = {
+      const attributes = {
         name,
         privacy: VideoPrivacy.PRIVATE,
         scheduleUpdate: {
           updateAt: updateAt.toISOString(),
-          privacy: VideoPrivacy.PUBLIC
+          privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
         }
       }
 
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, data)
-      const uuid = resVideo.body.video.uuid
+      const { shortUUID, uuid } = await servers[0].videos.upload({ token: userAccessToken, attributes })
 
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, uuid)
+      await servers[0].blacklist.remove({ videoId: uuid })
 
       await waitJobs(servers)
-      await checkNewBlacklistOnMyVideo(userBaseParams, uuid, name, 'unblacklist')
+      await checkNewBlacklistOnMyVideo({ ...userBaseParams, shortUUID, videoName: name, blacklistType: 'unblacklist' })
 
       // FIXME: Can't test absence as two notifications sent to same user and util only checks last one
       // One notification might be better anyways
       // await checkVideoIsPublished(userBaseParams, name, uuid, 'absence')
 
-      await checkNewVideoFromSubscription(adminBaseParamsServer1, name, uuid, 'absence')
-      await checkNewVideoFromSubscription(adminBaseParamsServer2, name, uuid, 'absence')
+      await checkNewVideoFromSubscription({ ...adminBaseParamsServer1, videoName: name, shortUUID, checkType: 'absence' })
+      await checkNewVideoFromSubscription({ ...adminBaseParamsServer2, videoName: name, shortUUID, checkType: 'absence' })
     })
 
     it('Should not send publish/subscription notifications after scheduled update if video still auto-blacklisted', async function () {
@@ -588,22 +570,21 @@ describe('Test moderation notifications', function () {
 
       const name = 'video with schedule done and still auto-blacklisted ' + buildUUID()
 
-      const data = {
+      const attributes = {
         name,
         privacy: VideoPrivacy.PRIVATE,
         scheduleUpdate: {
           updateAt: updateAt.toISOString(),
-          privacy: VideoPrivacy.PUBLIC
+          privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
         }
       }
 
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, data)
-      const uuid = resVideo.body.video.uuid
+      const { shortUUID } = await servers[0].videos.upload({ token: userAccessToken, attributes })
 
       await wait(6000)
-      await checkVideoIsPublished(userBaseParams, name, uuid, 'absence')
-      await checkNewVideoFromSubscription(adminBaseParamsServer1, name, uuid, 'absence')
-      await checkNewVideoFromSubscription(adminBaseParamsServer2, name, uuid, 'absence')
+      await checkVideoIsPublished({ ...userBaseParams, videoName: name, shortUUID, checkType: 'absence' })
+      await checkNewVideoFromSubscription({ ...adminBaseParamsServer1, videoName: name, shortUUID, checkType: 'absence' })
+      await checkNewVideoFromSubscription({ ...adminBaseParamsServer2, videoName: name, shortUUID, checkType: 'absence' })
     })
 
     it('Should not send a notification to moderators on new video without auto-blacklist', async function () {
@@ -612,18 +593,17 @@ describe('Test moderation notifications', function () {
       const name = 'video without auto-blacklist ' + buildUUID()
 
       // admin with blacklist right will not be auto-blacklisted
-      const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name })
-      const uuid = resVideo.body.video.uuid
+      const { shortUUID } = await servers[0].videos.upload({ attributes: { name } })
 
       await waitJobs(servers)
-      await checkVideoAutoBlacklistForModerators(adminBaseParamsServer1, uuid, name, 'absence')
+      await checkVideoAutoBlacklistForModerators({ ...adminBaseParamsServer1, shortUUID, videoName: name, checkType: 'absence' })
     })
 
     after(async () => {
-      await updateCustomConfig(servers[0].url, servers[0].accessToken, currentCustomConfig)
+      await servers[0].config.updateCustomConfig({ newCustomConfig: currentCustomConfig })
 
-      await removeUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port)
-      await removeUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port)
+      await servers[0].subscriptions.remove({ uri: 'user_1_channel@localhost:' + servers[0].port })
+      await servers[1].subscriptions.remove({ uri: 'user_1_channel@localhost:' + servers[0].port })
     })
   })
 
diff --git a/server/tests/api/notifications/notifications-api.ts b/server/tests/api/notifications/notifications-api.ts
index b81995449..a529a9bf7 100644
--- a/server/tests/api/notifications/notifications-api.ts
+++ b/server/tests/api/notifications/notifications-api.ts
@@ -2,28 +2,24 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { addUserSubscription } from '@shared/extra-utils/users/user-subscriptions'
-import { cleanupTests, getMyUserInformation, immutableAssign, uploadRandomVideo, waitJobs } from '../../../../shared/extra-utils'
-import { ServerInfo } from '../../../../shared/extra-utils/index'
-import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
 import {
   CheckerBaseParams,
   checkNewVideoFromSubscription,
+  cleanupTests,
   getAllNotificationsSettings,
-  getUserNotifications,
-  markAsReadAllNotifications,
-  markAsReadNotifications,
+  MockSmtpServer,
+  PeerTubeServer,
   prepareNotificationsTest,
-  updateMyNotificationSettings
-} from '../../../../shared/extra-utils/users/user-notifications'
-import { User, UserNotification, UserNotificationSettingValue } from '../../../../shared/models/users'
+  waitJobs
+} from '@shared/extra-utils'
+import { UserNotification, UserNotificationSettingValue } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test notifications API', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userNotifications: UserNotification[] = []
-  let userAccessToken: string
+  let userToken: string
   let emails: object[] = []
 
   before(async function () {
@@ -31,14 +27,14 @@ describe('Test notifications API', function () {
 
     const res = await prepareNotificationsTest(1)
     emails = res.emails
-    userAccessToken = res.userAccessToken
+    userToken = res.userAccessToken
     userNotifications = res.userNotifications
     server = res.servers[0]
 
-    await addUserSubscription(server.url, userAccessToken, 'root_channel@localhost:' + server.port)
+    await server.subscriptions.add({ token: userToken, targetUri: 'root_channel@localhost:' + server.port })
 
     for (let i = 0; i < 10; i++) {
-      await uploadRandomVideo(server, false)
+      await server.videos.randomUpload({ wait: false })
     }
 
     await waitJobs([ server ])
@@ -47,49 +43,46 @@ describe('Test notifications API', function () {
   describe('Mark as read', function () {
 
     it('Should mark as read some notifications', async function () {
-      const res = await getUserNotifications(server.url, userAccessToken, 2, 3)
-      const ids = res.body.data.map(n => n.id)
+      const { data } = await server.notifications.list({ token: userToken, start: 2, count: 3 })
+      const ids = data.map(n => n.id)
 
-      await markAsReadNotifications(server.url, userAccessToken, ids)
+      await server.notifications.markAsRead({ token: userToken, ids })
     })
 
     it('Should have the notifications marked as read', async function () {
-      const res = await getUserNotifications(server.url, userAccessToken, 0, 10)
-
-      const notifications = res.body.data as UserNotification[]
-      expect(notifications[0].read).to.be.false
-      expect(notifications[1].read).to.be.false
-      expect(notifications[2].read).to.be.true
-      expect(notifications[3].read).to.be.true
-      expect(notifications[4].read).to.be.true
-      expect(notifications[5].read).to.be.false
+      const { data } = await server.notifications.list({ token: userToken, start: 0, count: 10 })
+
+      expect(data[0].read).to.be.false
+      expect(data[1].read).to.be.false
+      expect(data[2].read).to.be.true
+      expect(data[3].read).to.be.true
+      expect(data[4].read).to.be.true
+      expect(data[5].read).to.be.false
     })
 
     it('Should only list read notifications', async function () {
-      const res = await getUserNotifications(server.url, userAccessToken, 0, 10, false)
+      const { data } = await server.notifications.list({ token: userToken, start: 0, count: 10, unread: false })
 
-      const notifications = res.body.data as UserNotification[]
-      for (const notification of notifications) {
+      for (const notification of data) {
         expect(notification.read).to.be.true
       }
     })
 
     it('Should only list unread notifications', async function () {
-      const res = await getUserNotifications(server.url, userAccessToken, 0, 10, true)
+      const { data } = await server.notifications.list({ token: userToken, start: 0, count: 10, unread: true })
 
-      const notifications = res.body.data as UserNotification[]
-      for (const notification of notifications) {
+      for (const notification of data) {
         expect(notification.read).to.be.false
       }
     })
 
     it('Should mark as read all notifications', async function () {
-      await markAsReadAllNotifications(server.url, userAccessToken)
+      await server.notifications.markAsReadAll({ token: userToken })
 
-      const res = await getUserNotifications(server.url, userAccessToken, 0, 10, true)
+      const body = await server.notifications.list({ token: userToken, start: 0, count: 10, unread: true })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
     })
   })
 
@@ -101,99 +94,102 @@ describe('Test notifications API', function () {
         server: server,
         emails,
         socketNotifications: userNotifications,
-        token: userAccessToken
+        token: userToken
       }
     })
 
     it('Should not have notifications', async function () {
       this.timeout(20000)
 
-      await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
-        newVideoFromSubscription: UserNotificationSettingValue.NONE
-      }))
+      await server.notifications.updateMySettings({
+        token: userToken,
+        settings: { ...getAllNotificationsSettings(), newVideoFromSubscription: UserNotificationSettingValue.NONE }
+      })
 
       {
-        const res = await getMyUserInformation(server.url, userAccessToken)
-        const info = res.body as User
+        const info = await server.users.getMyInfo({ token: userToken })
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.NONE)
       }
 
-      const { name, uuid } = await uploadRandomVideo(server)
+      const { name, shortUUID } = await server.videos.randomUpload()
 
       const check = { web: true, mail: true }
-      await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
+      await checkNewVideoFromSubscription({ ...baseParams, check, videoName: name, shortUUID, checkType: 'absence' })
     })
 
     it('Should only have web notifications', async function () {
       this.timeout(20000)
 
-      await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
-        newVideoFromSubscription: UserNotificationSettingValue.WEB
-      }))
+      await server.notifications.updateMySettings({
+        token: userToken,
+        settings: { ...getAllNotificationsSettings(), newVideoFromSubscription: UserNotificationSettingValue.WEB }
+      })
 
       {
-        const res = await getMyUserInformation(server.url, userAccessToken)
-        const info = res.body as User
+        const info = await server.users.getMyInfo({ token: userToken })
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB)
       }
 
-      const { name, uuid } = await uploadRandomVideo(server)
+      const { name, shortUUID } = await server.videos.randomUpload()
 
       {
         const check = { mail: true, web: false }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
+        await checkNewVideoFromSubscription({ ...baseParams, check, videoName: name, shortUUID, checkType: 'absence' })
       }
 
       {
         const check = { mail: false, web: true }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
+        await checkNewVideoFromSubscription({ ...baseParams, check, videoName: name, shortUUID, checkType: 'presence' })
       }
     })
 
     it('Should only have mail notifications', async function () {
       this.timeout(20000)
 
-      await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
-        newVideoFromSubscription: UserNotificationSettingValue.EMAIL
-      }))
+      await server.notifications.updateMySettings({
+        token: userToken,
+        settings: { ...getAllNotificationsSettings(), newVideoFromSubscription: UserNotificationSettingValue.EMAIL }
+      })
 
       {
-        const res = await getMyUserInformation(server.url, userAccessToken)
-        const info = res.body as User
+        const info = await server.users.getMyInfo({ token: userToken })
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.EMAIL)
       }
 
-      const { name, uuid } = await uploadRandomVideo(server)
+      const { name, shortUUID } = await server.videos.randomUpload()
 
       {
         const check = { mail: false, web: true }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
+        await checkNewVideoFromSubscription({ ...baseParams, check, videoName: name, shortUUID, checkType: 'absence' })
       }
 
       {
         const check = { mail: true, web: false }
-        await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
+        await checkNewVideoFromSubscription({ ...baseParams, check, videoName: name, shortUUID, checkType: 'presence' })
       }
     })
 
     it('Should have email and web notifications', async function () {
       this.timeout(20000)
 
-      await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
-        newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
-      }))
+      await server.notifications.updateMySettings({
+        token: userToken,
+        settings: {
+          ...getAllNotificationsSettings(),
+          newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
+        }
+      })
 
       {
-        const res = await getMyUserInformation(server.url, userAccessToken)
-        const info = res.body as User
+        const info = await server.users.getMyInfo({ token: userToken })
         expect(info.notificationSettings.newVideoFromSubscription).to.equal(
           UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
         )
       }
 
-      const { name, uuid } = await uploadRandomVideo(server)
+      const { name, shortUUID } = await server.videos.randomUpload()
 
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
     })
   })
 
diff --git a/server/tests/api/notifications/user-notifications.ts b/server/tests/api/notifications/user-notifications.ts
index e981c1718..e53ab2aa5 100644
--- a/server/tests/api/notifications/user-notifications.ts
+++ b/server/tests/api/notifications/user-notifications.ts
@@ -4,34 +4,26 @@ import 'mocha'
 import * as chai from 'chai'
 import { buildUUID } from '@server/helpers/uuid'
 import {
-  cleanupTests,
-  updateMyUser,
-  updateVideo,
-  updateVideoChannel,
-  uploadRandomVideoOnServers,
-  wait
-} from '../../../../shared/extra-utils'
-import { ServerInfo } from '../../../../shared/extra-utils/index'
-import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
   CheckerBaseParams,
   checkMyVideoImportIsFinished,
   checkNewActorFollow,
   checkNewVideoFromSubscription,
   checkVideoIsPublished,
-  getLastNotification,
-  prepareNotificationsTest
-} from '../../../../shared/extra-utils/users/user-notifications'
-import { addUserSubscription, removeUserSubscription } from '../../../../shared/extra-utils/users/user-subscriptions'
-import { getBadVideoUrl, getGoodVideoUrl, importVideo } from '../../../../shared/extra-utils/videos/video-imports'
-import { UserNotification, UserNotificationType } from '../../../../shared/models/users'
-import { VideoPrivacy } from '../../../../shared/models/videos'
+  cleanupTests,
+  FIXTURE_URLS,
+  MockSmtpServer,
+  PeerTubeServer,
+  prepareNotificationsTest,
+  uploadRandomVideoOnServers,
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { UserNotification, UserNotificationType, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test user notifications', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let userAccessToken: string
   let userNotifications: UserNotification[] = []
   let adminNotifications: UserNotification[] = []
@@ -69,7 +61,7 @@ describe('Test user notifications', function () {
 
       await uploadRandomVideoOnServers(servers, 1)
 
-      const notification = await getLastNotification(servers[0].url, userAccessToken)
+      const notification = await servers[0].notifications.getLastest({ token: userAccessToken })
       expect(notification).to.be.undefined
 
       expect(emails).to.have.lengthOf(0)
@@ -79,21 +71,21 @@ describe('Test user notifications', function () {
     it('Should send a new video notification if the user follows the local video publisher', async function () {
       this.timeout(15000)
 
-      await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:' + servers[0].port)
+      await servers[0].subscriptions.add({ token: userAccessToken, targetUri: 'root_channel@localhost:' + servers[0].port })
       await waitJobs(servers)
 
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 1)
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
+      const { name, shortUUID } = await uploadRandomVideoOnServers(servers, 1)
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
     })
 
     it('Should send a new video notification from a remote account', async function () {
       this.timeout(150000) // Server 2 has transcoding enabled
 
-      await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:' + servers[1].port)
+      await servers[0].subscriptions.add({ token: userAccessToken, targetUri: 'root_channel@localhost:' + servers[1].port })
       await waitJobs(servers)
 
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 2)
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
+      const { name, shortUUID } = await uploadRandomVideoOnServers(servers, 2)
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
     })
 
     it('Should send a new video notification on a scheduled publication', async function () {
@@ -106,13 +98,13 @@ describe('Test user notifications', function () {
         privacy: VideoPrivacy.PRIVATE,
         scheduleUpdate: {
           updateAt: updateAt.toISOString(),
-          privacy: VideoPrivacy.PUBLIC
+          privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
         }
       }
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 1, data)
+      const { name, shortUUID } = await uploadRandomVideoOnServers(servers, 1, data)
 
       await wait(6000)
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
     })
 
     it('Should send a new video notification on a remote scheduled publication', async function () {
@@ -125,14 +117,14 @@ describe('Test user notifications', function () {
         privacy: VideoPrivacy.PRIVATE,
         scheduleUpdate: {
           updateAt: updateAt.toISOString(),
-          privacy: VideoPrivacy.PUBLIC
+          privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
         }
       }
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, data)
+      const { name, shortUUID } = await uploadRandomVideoOnServers(servers, 2, data)
       await waitJobs(servers)
 
       await wait(6000)
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
     })
 
     it('Should not send a notification before the video is published', async function () {
@@ -144,64 +136,64 @@ describe('Test user notifications', function () {
         privacy: VideoPrivacy.PRIVATE,
         scheduleUpdate: {
           updateAt: updateAt.toISOString(),
-          privacy: VideoPrivacy.PUBLIC
+          privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
         }
       }
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 1, data)
+      const { name, shortUUID } = await uploadRandomVideoOnServers(servers, 1, data)
 
       await wait(6000)
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'absence' })
     })
 
     it('Should send a new video notification when a video becomes public', async function () {
       this.timeout(50000)
 
       const data = { privacy: VideoPrivacy.PRIVATE }
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 1, data)
+      const { name, uuid, shortUUID } = await uploadRandomVideoOnServers(servers, 1, data)
 
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'absence' })
 
-      await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.PUBLIC })
+      await servers[0].videos.update({ id: uuid, attributes: { privacy: VideoPrivacy.PUBLIC } })
 
       await waitJobs(servers)
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
     })
 
     it('Should send a new video notification when a remote video becomes public', async function () {
       this.timeout(50000)
 
       const data = { privacy: VideoPrivacy.PRIVATE }
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, data)
+      const { name, uuid, shortUUID } = await uploadRandomVideoOnServers(servers, 2, data)
 
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'absence' })
 
-      await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.PUBLIC })
+      await servers[1].videos.update({ id: uuid, attributes: { privacy: VideoPrivacy.PUBLIC } })
 
       await waitJobs(servers)
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
     })
 
     it('Should not send a new video notification when a video becomes unlisted', async function () {
       this.timeout(50000)
 
       const data = { privacy: VideoPrivacy.PRIVATE }
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 1, data)
+      const { name, uuid, shortUUID } = await uploadRandomVideoOnServers(servers, 1, data)
 
-      await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED })
+      await servers[0].videos.update({ id: uuid, attributes: { privacy: VideoPrivacy.UNLISTED } })
 
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'absence' })
     })
 
     it('Should not send a new video notification when a remote video becomes unlisted', async function () {
       this.timeout(50000)
 
       const data = { privacy: VideoPrivacy.PRIVATE }
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, data)
+      const { name, uuid, shortUUID } = await uploadRandomVideoOnServers(servers, 2, data)
 
-      await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED })
+      await servers[1].videos.update({ id: uuid, attributes: { privacy: VideoPrivacy.UNLISTED } })
 
       await waitJobs(servers)
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID, checkType: 'absence' })
     })
 
     it('Should send a new video notification after a video import', async function () {
@@ -213,14 +205,13 @@ describe('Test user notifications', function () {
         name,
         channelId,
         privacy: VideoPrivacy.PUBLIC,
-        targetUrl: getGoodVideoUrl()
+        targetUrl: FIXTURE_URLS.goodVideo
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      const uuid = res.body.video.uuid
+      const { video } = await servers[0].imports.importVideo({ attributes })
 
       await waitJobs(servers)
 
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
+      await checkNewVideoFromSubscription({ ...baseParams, videoName: name, shortUUID: video.shortUUID, checkType: 'presence' })
     })
   })
 
@@ -239,10 +230,10 @@ describe('Test user notifications', function () {
     it('Should not send a notification if transcoding is not enabled', async function () {
       this.timeout(50000)
 
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 1)
+      const { name, shortUUID } = await uploadRandomVideoOnServers(servers, 1)
       await waitJobs(servers)
 
-      await checkVideoIsPublished(baseParams, name, uuid, 'absence')
+      await checkVideoIsPublished({ ...baseParams, videoName: name, shortUUID, checkType: 'absence' })
     })
 
     it('Should not send a notification if the wait transcoding is false', async function () {
@@ -251,7 +242,7 @@ describe('Test user notifications', function () {
       await uploadRandomVideoOnServers(servers, 2, { waitTranscoding: false })
       await waitJobs(servers)
 
-      const notification = await getLastNotification(servers[0].url, userAccessToken)
+      const notification = await servers[0].notifications.getLastest({ token: userAccessToken })
       if (notification) {
         expect(notification.type).to.not.equal(UserNotificationType.MY_VIDEO_PUBLISHED)
       }
@@ -260,19 +251,19 @@ describe('Test user notifications', function () {
     it('Should send a notification even if the video is not transcoded in other resolutions', async function () {
       this.timeout(50000)
 
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, { waitTranscoding: true, fixture: 'video_short_240p.mp4' })
+      const { name, shortUUID } = await uploadRandomVideoOnServers(servers, 2, { waitTranscoding: true, fixture: 'video_short_240p.mp4' })
       await waitJobs(servers)
 
-      await checkVideoIsPublished(baseParams, name, uuid, 'presence')
+      await checkVideoIsPublished({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
     })
 
     it('Should send a notification with a transcoded video', async function () {
       this.timeout(50000)
 
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, { waitTranscoding: true })
+      const { name, shortUUID } = await uploadRandomVideoOnServers(servers, 2, { waitTranscoding: true })
       await waitJobs(servers)
 
-      await checkVideoIsPublished(baseParams, name, uuid, 'presence')
+      await checkVideoIsPublished({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
     })
 
     it('Should send a notification when an imported video is transcoded', async function () {
@@ -284,14 +275,13 @@ describe('Test user notifications', function () {
         name,
         channelId,
         privacy: VideoPrivacy.PUBLIC,
-        targetUrl: getGoodVideoUrl(),
+        targetUrl: FIXTURE_URLS.goodVideo,
         waitTranscoding: true
       }
-      const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
-      const uuid = res.body.video.uuid
+      const { video } = await servers[1].imports.importVideo({ attributes })
 
       await waitJobs(servers)
-      await checkVideoIsPublished(baseParams, name, uuid, 'presence')
+      await checkVideoIsPublished({ ...baseParams, videoName: name, shortUUID: video.shortUUID, checkType: 'presence' })
     })
 
     it('Should send a notification when the scheduled update has been proceeded', async function () {
@@ -304,13 +294,13 @@ describe('Test user notifications', function () {
         privacy: VideoPrivacy.PRIVATE,
         scheduleUpdate: {
           updateAt: updateAt.toISOString(),
-          privacy: VideoPrivacy.PUBLIC
+          privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
         }
       }
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, data)
+      const { name, shortUUID } = await uploadRandomVideoOnServers(servers, 2, data)
 
       await wait(6000)
-      await checkVideoIsPublished(baseParams, name, uuid, 'presence')
+      await checkVideoIsPublished({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
     })
 
     it('Should not send a notification before the video is published', async function () {
@@ -322,13 +312,13 @@ describe('Test user notifications', function () {
         privacy: VideoPrivacy.PRIVATE,
         scheduleUpdate: {
           updateAt: updateAt.toISOString(),
-          privacy: VideoPrivacy.PUBLIC
+          privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
         }
       }
-      const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, data)
+      const { name, shortUUID } = await uploadRandomVideoOnServers(servers, 2, data)
 
       await wait(6000)
-      await checkVideoIsPublished(baseParams, name, uuid, 'absence')
+      await checkVideoIsPublished({ ...baseParams, videoName: name, shortUUID, checkType: 'absence' })
     })
   })
 
@@ -353,13 +343,14 @@ describe('Test user notifications', function () {
         name,
         channelId,
         privacy: VideoPrivacy.PRIVATE,
-        targetUrl: getBadVideoUrl()
+        targetUrl: FIXTURE_URLS.badVideo
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      const uuid = res.body.video.uuid
+      const { video: { shortUUID } } = await servers[0].imports.importVideo({ attributes })
 
       await waitJobs(servers)
-      await checkMyVideoImportIsFinished(baseParams, name, uuid, getBadVideoUrl(), false, 'presence')
+
+      const url = FIXTURE_URLS.badVideo
+      await checkMyVideoImportIsFinished({ ...baseParams, videoName: name, shortUUID, url, success: false, checkType: 'presence' })
     })
 
     it('Should send a notification when the video import succeeded', async function () {
@@ -371,13 +362,14 @@ describe('Test user notifications', function () {
         name,
         channelId,
         privacy: VideoPrivacy.PRIVATE,
-        targetUrl: getGoodVideoUrl()
+        targetUrl: FIXTURE_URLS.goodVideo
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      const uuid = res.body.video.uuid
+      const { video: { shortUUID } } = await servers[0].imports.importVideo({ attributes })
 
       await waitJobs(servers)
-      await checkMyVideoImportIsFinished(baseParams, name, uuid, getGoodVideoUrl(), true, 'presence')
+
+      const url = FIXTURE_URLS.goodVideo
+      await checkMyVideoImportIsFinished({ ...baseParams, videoName: name, shortUUID, url, success: true, checkType: 'presence' })
     })
   })
 
@@ -394,47 +386,56 @@ describe('Test user notifications', function () {
         token: userAccessToken
       }
 
-      await updateMyUser({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        displayName: 'super root name'
-      })
+      await servers[0].users.updateMe({ displayName: 'super root name' })
 
-      await updateMyUser({
-        url: servers[0].url,
-        accessToken: userAccessToken,
+      await servers[0].users.updateMe({
+        token: userAccessToken,
         displayName: myUserName
       })
 
-      await updateMyUser({
-        url: servers[1].url,
-        accessToken: servers[1].accessToken,
-        displayName: 'super root 2 name'
-      })
+      await servers[1].users.updateMe({ displayName: 'super root 2 name' })
 
-      await updateVideoChannel(servers[0].url, userAccessToken, 'user_1_channel', { displayName: myChannelName })
+      await servers[0].channels.update({
+        token: userAccessToken,
+        channelName: 'user_1_channel',
+        attributes: { displayName: myChannelName }
+      })
     })
 
     it('Should notify when a local channel is following one of our channel', async function () {
       this.timeout(50000)
 
-      await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port)
+      await servers[0].subscriptions.add({ targetUri: 'user_1_channel@localhost:' + servers[0].port })
       await waitJobs(servers)
 
-      await checkNewActorFollow(baseParams, 'channel', 'root', 'super root name', myChannelName, 'presence')
+      await checkNewActorFollow({
+        ...baseParams,
+        followType: 'channel',
+        followerName: 'root',
+        followerDisplayName: 'super root name',
+        followingDisplayName: myChannelName,
+        checkType: 'presence'
+      })
 
-      await removeUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port)
+      await servers[0].subscriptions.remove({ uri: 'user_1_channel@localhost:' + servers[0].port })
     })
 
     it('Should notify when a remote channel is following one of our channel', async function () {
       this.timeout(50000)
 
-      await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port)
+      await servers[1].subscriptions.add({ targetUri: 'user_1_channel@localhost:' + servers[0].port })
       await waitJobs(servers)
 
-      await checkNewActorFollow(baseParams, 'channel', 'root', 'super root 2 name', myChannelName, 'presence')
+      await checkNewActorFollow({
+        ...baseParams,
+        followType: 'channel',
+        followerName: 'root',
+        followerDisplayName: 'super root 2 name',
+        followingDisplayName: myChannelName,
+        checkType: 'presence'
+      })
 
-      await removeUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port)
+      await servers[1].subscriptions.remove({ uri: 'user_1_channel@localhost:' + servers[0].port })
     })
 
     // PeerTube does not support accout -> account follows
diff --git a/server/tests/api/redundancy/manage-redundancy.ts b/server/tests/api/redundancy/manage-redundancy.ts
index 4253124c8..5fd464ded 100644
--- a/server/tests/api/redundancy/manage-redundancy.ts
+++ b/server/tests/api/redundancy/manage-redundancy.ts
@@ -1,32 +1,30 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getLocalIdByUUID,
-  ServerInfo,
+  PeerTubeServer,
+  RedundancyCommand,
   setAccessTokensToServers,
-  uploadVideo,
-  uploadVideoAndGetId,
-  waitUntilLog
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { addVideoRedundancy, listVideoRedundancies, removeVideoRedundancy, updateRedundancy } from '@shared/extra-utils/server/redundancy'
-import { VideoPrivacy, VideoRedundanciesTarget, VideoRedundancy } from '@shared/models'
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoPrivacy, VideoRedundanciesTarget } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test manage videos redundancy', function () {
   const targets: VideoRedundanciesTarget[] = [ 'my-videos', 'remote-videos' ]
 
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let video1Server2UUID: string
   let video2Server2UUID: string
   let redundanciesToRemove: number[] = []
 
+  let commands: RedundancyCommand[]
+
   before(async function () {
     this.timeout(120000)
 
@@ -50,40 +48,38 @@ describe('Test manage videos redundancy', function () {
         }
       }
     }
-    servers = await flushAndRunMultipleServers(3, config)
+    servers = await createMultipleServers(3, config)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
 
+    commands = servers.map(s => s.redundancy)
+
     {
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video 1 server 2' })
-      video1Server2UUID = res.body.video.uuid
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video 1 server 2' } })
+      video1Server2UUID = uuid
     }
 
     {
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video 2 server 2' })
-      video2Server2UUID = res.body.video.uuid
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video 2 server 2' } })
+      video2Server2UUID = uuid
     }
 
     await waitJobs(servers)
 
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
-    await updateRedundancy(servers[0].url, servers[0].accessToken, servers[1].host, true)
+    await commands[0].updateRedundancy({ host: servers[1].host, redundancyAllowed: true })
 
     await waitJobs(servers)
   })
 
   it('Should not have redundancies on server 3', async function () {
     for (const target of targets) {
-      const res = await listVideoRedundancies({
-        url: servers[2].url,
-        accessToken: servers[2].accessToken,
-        target
-      })
+      const body = await commands[2].listVideos({ target })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
     }
   })
 
@@ -91,31 +87,22 @@ describe('Test manage videos redundancy', function () {
     this.timeout(120000)
 
     await waitJobs(servers)
-    await waitUntilLog(servers[0], 'Duplicated ', 10)
+    await servers[0].servers.waitUntilLog('Duplicated ', 10)
     await waitJobs(servers)
 
-    const res = await listVideoRedundancies({
-      url: servers[1].url,
-      accessToken: servers[1].accessToken,
-      target: 'remote-videos'
-    })
+    const body = await commands[1].listVideos({ target: 'remote-videos' })
 
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   it('Should have "my-videos" redundancies on server 2', async function () {
     this.timeout(120000)
 
-    const res = await listVideoRedundancies({
-      url: servers[1].url,
-      accessToken: servers[1].accessToken,
-      target: 'my-videos'
-    })
-
-    expect(res.body.total).to.equal(2)
+    const body = await commands[1].listVideos({ target: 'my-videos' })
+    expect(body.total).to.equal(2)
 
-    const videos = res.body.data as VideoRedundancy[]
+    const videos = body.data
     expect(videos).to.have.lengthOf(2)
 
     const videos1 = videos.find(v => v.uuid === video1Server2UUID)
@@ -139,28 +126,19 @@ describe('Test manage videos redundancy', function () {
   })
 
   it('Should not have "my-videos" redundancies on server 1', async function () {
-    const res = await listVideoRedundancies({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      target: 'my-videos'
-    })
+    const body = await commands[0].listVideos({ target: 'my-videos' })
 
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   it('Should have "remote-videos" redundancies on server 1', async function () {
     this.timeout(120000)
 
-    const res = await listVideoRedundancies({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      target: 'remote-videos'
-    })
+    const body = await commands[0].listVideos({ target: 'remote-videos' })
+    expect(body.total).to.equal(2)
 
-    expect(res.body.total).to.equal(2)
-
-    const videos = res.body.data as VideoRedundancy[]
+    const videos = body.data
     expect(videos).to.have.lengthOf(2)
 
     const videos1 = videos.find(v => v.uuid === video1Server2UUID)
@@ -185,81 +163,67 @@ describe('Test manage videos redundancy', function () {
 
   it('Should correctly paginate and sort results', async function () {
     {
-      const res = await listVideoRedundancies({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
+      const body = await commands[0].listVideos({
         target: 'remote-videos',
         sort: 'name',
         start: 0,
         count: 2
       })
 
-      const videos = res.body.data
+      const videos = body.data
       expect(videos[0].name).to.equal('video 1 server 2')
       expect(videos[1].name).to.equal('video 2 server 2')
     }
 
     {
-      const res = await listVideoRedundancies({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
+      const body = await commands[0].listVideos({
         target: 'remote-videos',
         sort: '-name',
         start: 0,
         count: 2
       })
 
-      const videos = res.body.data
+      const videos = body.data
       expect(videos[0].name).to.equal('video 2 server 2')
       expect(videos[1].name).to.equal('video 1 server 2')
     }
 
     {
-      const res = await listVideoRedundancies({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
+      const body = await commands[0].listVideos({
         target: 'remote-videos',
         sort: '-name',
         start: 1,
         count: 1
       })
 
-      const videos = res.body.data
-      expect(videos[0].name).to.equal('video 1 server 2')
+      expect(body.data[0].name).to.equal('video 1 server 2')
     }
   })
 
   it('Should manually add a redundancy and list it', async function () {
     this.timeout(120000)
 
-    const uuid = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video 3 server 2', privacy: VideoPrivacy.UNLISTED })).uuid
+    const uuid = (await servers[1].videos.quickUpload({ name: 'video 3 server 2', privacy: VideoPrivacy.UNLISTED })).uuid
     await waitJobs(servers)
-    const videoId = await getLocalIdByUUID(servers[0].url, uuid)
+    const videoId = await servers[0].videos.getId({ uuid })
 
-    await addVideoRedundancy({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      videoId
-    })
+    await commands[0].addVideo({ videoId })
 
     await waitJobs(servers)
-    await waitUntilLog(servers[0], 'Duplicated ', 15)
+    await servers[0].servers.waitUntilLog('Duplicated ', 15)
     await waitJobs(servers)
 
     {
-      const res = await listVideoRedundancies({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
+      const body = await commands[0].listVideos({
         target: 'remote-videos',
         sort: '-name',
         start: 0,
         count: 5
       })
 
-      const videos = res.body.data
-      expect(videos[0].name).to.equal('video 3 server 2')
+      const video = body.data[0]
 
-      const video = videos[0]
+      expect(video.name).to.equal('video 3 server 2')
       expect(video.redundancies.files).to.have.lengthOf(4)
       expect(video.redundancies.streamingPlaylists).to.have.lengthOf(1)
 
@@ -276,19 +240,15 @@ describe('Test manage videos redundancy', function () {
       }
     }
 
-    const res = await listVideoRedundancies({
-      url: servers[1].url,
-      accessToken: servers[1].accessToken,
+    const body = await commands[1].listVideos({
       target: 'my-videos',
       sort: '-name',
       start: 0,
       count: 5
     })
 
-    const videos = res.body.data
-    expect(videos[0].name).to.equal('video 3 server 2')
-
-    const video = videos[0]
+    const video = body.data[0]
+    expect(video.name).to.equal('video 3 server 2')
     expect(video.redundancies.files).to.have.lengthOf(4)
     expect(video.redundancies.streamingPlaylists).to.have.lengthOf(1)
 
@@ -307,64 +267,47 @@ describe('Test manage videos redundancy', function () {
     this.timeout(120000)
 
     for (const redundancyId of redundanciesToRemove) {
-      await removeVideoRedundancy({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        redundancyId
-      })
+      await commands[0].removeVideo({ redundancyId })
     }
 
     {
-      const res = await listVideoRedundancies({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
+      const body = await commands[0].listVideos({
         target: 'remote-videos',
         sort: '-name',
         start: 0,
         count: 5
       })
 
-      const videos = res.body.data
-      expect(videos).to.have.lengthOf(2)
+      const videos = body.data
 
-      expect(videos[0].name).to.equal('video 2 server 2')
+      expect(videos).to.have.lengthOf(2)
 
-      redundanciesToRemove = []
       const video = videos[0]
+      expect(video.name).to.equal('video 2 server 2')
       expect(video.redundancies.files).to.have.lengthOf(4)
       expect(video.redundancies.streamingPlaylists).to.have.lengthOf(1)
 
       const redundancies = video.redundancies.files.concat(video.redundancies.streamingPlaylists)
 
-      for (const r of redundancies) {
-        redundanciesToRemove.push(r.id)
-      }
+      redundanciesToRemove = redundancies.map(r => r.id)
     }
   })
 
   it('Should remove another (auto) redundancy', async function () {
-    {
-      for (const redundancyId of redundanciesToRemove) {
-        await removeVideoRedundancy({
-          url: servers[0].url,
-          accessToken: servers[0].accessToken,
-          redundancyId
-        })
-      }
+    for (const redundancyId of redundanciesToRemove) {
+      await commands[0].removeVideo({ redundancyId })
+    }
 
-      const res = await listVideoRedundancies({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        target: 'remote-videos',
-        sort: '-name',
-        start: 0,
-        count: 5
-      })
+    const body = await commands[0].listVideos({
+      target: 'remote-videos',
+      sort: '-name',
+      start: 0,
+      count: 5
+    })
 
-      const videos = res.body.data
-      expect(videos[0].name).to.equal('video 1 server 2')
-      expect(videos).to.have.lengthOf(1)
-    }
+    const videos = body.data
+    expect(videos).to.have.lengthOf(1)
+    expect(videos[0].name).to.equal('video 1 server 2')
   })
 
   after(async function () {
diff --git a/server/tests/api/redundancy/redundancy-constraints.ts b/server/tests/api/redundancy/redundancy-constraints.ts
index 1cb1603bc..933a2c776 100644
--- a/server/tests/api/redundancy/redundancy-constraints.ts
+++ b/server/tests/api/redundancy/redundancy-constraints.ts
@@ -1,29 +1,14 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import * as chai from 'chai'
-import { listVideoRedundancies, updateRedundancy } from '@shared/extra-utils/server/redundancy'
+import { expect } from 'chai'
+import { cleanupTests, createSingleServer, killallServers, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
 import { VideoPrivacy } from '@shared/models'
-import {
-  cleanupTests,
-  flushAndRunServer,
-  follow,
-  killallServers,
-  reRunServer,
-  ServerInfo,
-  setAccessTokensToServers,
-  updateVideo,
-  uploadVideo,
-  waitUntilLog
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-
-const expect = chai.expect
 
 describe('Test redundancy constraints', function () {
-  let remoteServer: ServerInfo
-  let localServer: ServerInfo
-  let servers: ServerInfo[]
+  let remoteServer: PeerTubeServer
+  let localServer: PeerTubeServer
+  let servers: PeerTubeServer[]
 
   const remoteServerConfig = {
     redundancy: {
@@ -43,38 +28,30 @@ describe('Test redundancy constraints', function () {
 
   async function uploadWrapper (videoName: string) {
     // Wait for transcoding
-    const res = await uploadVideo(localServer.url, localServer.accessToken, { name: 'to transcode', privacy: VideoPrivacy.PRIVATE })
+    const { id } = await localServer.videos.upload({ attributes: { name: 'to transcode', privacy: VideoPrivacy.PRIVATE } })
     await waitJobs([ localServer ])
 
     // Update video to schedule a federation
-    await updateVideo(localServer.url, localServer.accessToken, res.body.video.id, { name: videoName, privacy: VideoPrivacy.PUBLIC })
+    await localServer.videos.update({ id, attributes: { name: videoName, privacy: VideoPrivacy.PUBLIC } })
   }
 
   async function getTotalRedundanciesLocalServer () {
-    const res = await listVideoRedundancies({
-      url: localServer.url,
-      accessToken: localServer.accessToken,
-      target: 'my-videos'
-    })
+    const body = await localServer.redundancy.listVideos({ target: 'my-videos' })
 
-    return res.body.total
+    return body.total
   }
 
   async function getTotalRedundanciesRemoteServer () {
-    const res = await listVideoRedundancies({
-      url: remoteServer.url,
-      accessToken: remoteServer.accessToken,
-      target: 'remote-videos'
-    })
+    const body = await remoteServer.redundancy.listVideos({ target: 'remote-videos' })
 
-    return res.body.total
+    return body.total
   }
 
   before(async function () {
     this.timeout(120000)
 
     {
-      remoteServer = await flushAndRunServer(1, remoteServerConfig)
+      remoteServer = await createSingleServer(1, remoteServerConfig)
     }
 
     {
@@ -85,7 +62,7 @@ describe('Test redundancy constraints', function () {
           }
         }
       }
-      localServer = await flushAndRunServer(2, config)
+      localServer = await createSingleServer(2, config)
     }
 
     servers = [ remoteServer, localServer ]
@@ -93,14 +70,14 @@ describe('Test redundancy constraints', function () {
     // Get the access tokens
     await setAccessTokensToServers(servers)
 
-    await uploadVideo(localServer.url, localServer.accessToken, { name: 'video 1 server 2' })
+    await localServer.videos.upload({ attributes: { name: 'video 1 server 2' } })
 
     await waitJobs(servers)
 
     // Server 1 and server 2 follow each other
-    await follow(remoteServer.url, [ localServer.url ], remoteServer.accessToken)
+    await remoteServer.follows.follow({ hosts: [ localServer.url ] })
     await waitJobs(servers)
-    await updateRedundancy(remoteServer.url, remoteServer.accessToken, localServer.host, true)
+    await remoteServer.redundancy.updateRedundancy({ host: localServer.host, redundancyAllowed: true })
 
     await waitJobs(servers)
   })
@@ -109,7 +86,7 @@ describe('Test redundancy constraints', function () {
     this.timeout(120000)
 
     await waitJobs(servers)
-    await waitUntilLog(remoteServer, 'Duplicated ', 5)
+    await remoteServer.servers.waitUntilLog('Duplicated ', 5)
     await waitJobs(servers)
 
     {
@@ -134,11 +111,11 @@ describe('Test redundancy constraints', function () {
       }
     }
     await killallServers([ localServer ])
-    await reRunServer(localServer, config)
+    await localServer.run(config)
 
     await uploadWrapper('video 2 server 2')
 
-    await waitUntilLog(remoteServer, 'Duplicated ', 10)
+    await remoteServer.servers.waitUntilLog('Duplicated ', 10)
     await waitJobs(servers)
 
     {
@@ -163,11 +140,11 @@ describe('Test redundancy constraints', function () {
       }
     }
     await killallServers([ localServer ])
-    await reRunServer(localServer, config)
+    await localServer.run(config)
 
     await uploadWrapper('video 3 server 2')
 
-    await waitUntilLog(remoteServer, 'Duplicated ', 15)
+    await remoteServer.servers.waitUntilLog('Duplicated ', 15)
     await waitJobs(servers)
 
     {
@@ -184,11 +161,11 @@ describe('Test redundancy constraints', function () {
   it('Should have redundancy on server 1 and on server 2 with followings filter now server 2 follows server 1', async function () {
     this.timeout(120000)
 
-    await follow(localServer.url, [ remoteServer.url ], localServer.accessToken)
+    await localServer.follows.follow({ hosts: [ remoteServer.url ] })
     await waitJobs(servers)
 
     await uploadWrapper('video 4 server 2')
-    await waitUntilLog(remoteServer, 'Duplicated ', 20)
+    await remoteServer.servers.waitUntilLog('Duplicated ', 20)
     await waitJobs(servers)
 
     {
diff --git a/server/tests/api/redundancy/redundancy.ts b/server/tests/api/redundancy/redundancy.ts
index 0e0a73b9d..e1a12f5f8 100644
--- a/server/tests/api/redundancy/redundancy.ts
+++ b/server/tests/api/redundancy/redundancy.ts
@@ -4,72 +4,63 @@ import 'mocha'
 import * as chai from 'chai'
 import { readdir } from 'fs-extra'
 import * as magnetUtil from 'magnet-uri'
-import { join } from 'path'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { basename, join } from 'path'
 import {
   checkSegmentHash,
   checkVideoFilesWereRemoved,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getFollowingListPaginationAndSort,
-  getVideo,
-  getVideoWithToken,
-  immutableAssign,
   killallServers,
-  makeGetRequest,
-  removeVideo,
-  reRunServer,
+  makeRawRequest,
+  PeerTubeServer,
   root,
-  ServerInfo,
+  saveVideoInServers,
   setAccessTokensToServers,
-  unfollow,
-  updateVideo,
-  uploadVideo,
-  viewVideo,
   wait,
-  waitUntilLog
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+  waitJobs
+} from '@shared/extra-utils'
 import {
-  addVideoRedundancy,
-  listVideoRedundancies,
-  removeVideoRedundancy,
-  updateRedundancy
-} from '../../../../shared/extra-utils/server/redundancy'
-import { getStats } from '../../../../shared/extra-utils/server/stats'
-import { ActorFollow } from '../../../../shared/models/actors'
-import { VideoRedundancy, VideoRedundancyStrategy, VideoRedundancyStrategyWithManual } from '../../../../shared/models/redundancy'
-import { ServerStats } from '../../../../shared/models/server/server-stats.model'
-import { VideoDetails, VideoPrivacy } from '../../../../shared/models/videos'
+  HttpStatusCode,
+  VideoDetails,
+  VideoFile,
+  VideoPrivacy,
+  VideoRedundancyStrategy,
+  VideoRedundancyStrategyWithManual
+} from '@shared/models'
 
 const expect = chai.expect
 
-let servers: ServerInfo[] = []
-let video1Server2UUID: string
-let video1Server2Id: number
+let servers: PeerTubeServer[] = []
+let video1Server2: VideoDetails
 
-function checkMagnetWebseeds (file: { magnetUri: string, resolution: { id: number } }, baseWebseeds: string[], server: ServerInfo) {
+async function checkMagnetWebseeds (file: VideoFile, baseWebseeds: string[], server: PeerTubeServer) {
   const parsed = magnetUtil.decode(file.magnetUri)
 
   for (const ws of baseWebseeds) {
-    const found = parsed.urlList.find(url => url === `${ws}-${file.resolution.id}.mp4`)
+    const found = parsed.urlList.find(url => url === `${ws}${basename(file.fileUrl)}`)
     expect(found, `Webseed ${ws} not found in ${file.magnetUri} on server ${server.url}`).to.not.be.undefined
   }
 
   expect(parsed.urlList).to.have.lengthOf(baseWebseeds.length)
+
+  for (const url of parsed.urlList) {
+    await makeRawRequest(url, HttpStatusCode.OK_200)
+  }
 }
 
-async function flushAndRunServers (strategy: VideoRedundancyStrategy | null, additionalParams: any = {}, withWebtorrent = true) {
+async function createSingleServers (strategy: VideoRedundancyStrategy | null, additionalParams: any = {}, withWebtorrent = true) {
   const strategies: any[] = []
 
   if (strategy !== null) {
     strategies.push(
-      immutableAssign({
+      {
         min_lifetime: '1 hour',
         strategy: strategy,
-        size: '400KB'
-      }, additionalParams)
+        size: '400KB',
+
+        ...additionalParams
+      }
     )
   }
 
@@ -90,17 +81,16 @@ async function flushAndRunServers (strategy: VideoRedundancyStrategy | null, add
     }
   }
 
-  servers = await flushAndRunMultipleServers(3, config)
+  servers = await createMultipleServers(3, config)
 
   // Get the access tokens
   await setAccessTokensToServers(servers)
 
   {
-    const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video 1 server 2' })
-    video1Server2UUID = res.body.video.uuid
-    video1Server2Id = res.body.video.id
+    const { id } = await servers[1].videos.upload({ attributes: { name: 'video 1 server 2' } })
+    video1Server2 = await servers[1].videos.get({ id })
 
-    await viewVideo(servers[1].url, video1Server2UUID)
+    await servers[1].videos.view({ id })
   }
 
   await waitJobs(servers)
@@ -115,55 +105,65 @@ async function flushAndRunServers (strategy: VideoRedundancyStrategy | null, add
   await waitJobs(servers)
 }
 
+async function ensureSameFilenames (videoUUID: string) {
+  let webtorrentFilenames: string[]
+  let hlsFilenames: string[]
+
+  for (const server of servers) {
+    const video = await server.videos.getWithToken({ id: videoUUID })
+
+    // Ensure we use the same filenames that the origin
+
+    const localWebtorrentFilenames = video.files.map(f => basename(f.fileUrl)).sort()
+    const localHLSFilenames = video.streamingPlaylists[0].files.map(f => basename(f.fileUrl)).sort()
+
+    if (webtorrentFilenames) expect(webtorrentFilenames).to.deep.equal(localWebtorrentFilenames)
+    else webtorrentFilenames = localWebtorrentFilenames
+
+    if (hlsFilenames) expect(hlsFilenames).to.deep.equal(localHLSFilenames)
+    else hlsFilenames = localHLSFilenames
+  }
+
+  return { webtorrentFilenames, hlsFilenames }
+}
+
 async function check1WebSeed (videoUUID?: string) {
-  if (!videoUUID) videoUUID = video1Server2UUID
+  if (!videoUUID) videoUUID = video1Server2.uuid
 
   const webseeds = [
-    `http://localhost:${servers[1].port}/static/webseed/${videoUUID}`
+    `http://localhost:${servers[1].port}/static/webseed/`
   ]
 
   for (const server of servers) {
     // With token to avoid issues with video follow constraints
-    const res = await getVideoWithToken(server.url, server.accessToken, videoUUID)
+    const video = await server.videos.getWithToken({ id: videoUUID })
 
-    const video: VideoDetails = res.body
     for (const f of video.files) {
-      checkMagnetWebseeds(f, webseeds, server)
+      await checkMagnetWebseeds(f, webseeds, server)
     }
   }
+
+  await ensureSameFilenames(videoUUID)
 }
 
 async function check2Webseeds (videoUUID?: string) {
-  if (!videoUUID) videoUUID = video1Server2UUID
+  if (!videoUUID) videoUUID = video1Server2.uuid
 
   const webseeds = [
-    `http://localhost:${servers[0].port}/static/redundancy/${videoUUID}`,
-    `http://localhost:${servers[1].port}/static/webseed/${videoUUID}`
+    `http://localhost:${servers[0].port}/static/redundancy/`,
+    `http://localhost:${servers[1].port}/static/webseed/`
   ]
 
   for (const server of servers) {
-    const res = await getVideo(server.url, videoUUID)
-
-    const video: VideoDetails = res.body
+    const video = await server.videos.get({ id: videoUUID })
 
     for (const file of video.files) {
-      checkMagnetWebseeds(file, webseeds, server)
-
-      await makeGetRequest({
-        url: servers[0].url,
-        statusCodeExpected: HttpStatusCode.OK_200,
-        path: '/static/redundancy/' + `${videoUUID}-${file.resolution.id}.mp4`,
-        contentType: null
-      })
-      await makeGetRequest({
-        url: servers[1].url,
-        statusCodeExpected: HttpStatusCode.OK_200,
-        path: `/static/webseed/${videoUUID}-${file.resolution.id}.mp4`,
-        contentType: null
-      })
+      await checkMagnetWebseeds(file, webseeds, server)
     }
   }
 
+  const { webtorrentFilenames } = await ensureSameFilenames(videoUUID)
+
   const directories = [
     'test' + servers[0].internalServerNumber + '/redundancy',
     'test' + servers[1].internalServerNumber + '/videos'
@@ -173,32 +173,31 @@ async function check2Webseeds (videoUUID?: string) {
     const files = await readdir(join(root(), directory))
     expect(files).to.have.length.at.least(4)
 
-    for (const resolution of [ 240, 360, 480, 720 ]) {
-      expect(files.find(f => f === `${videoUUID}-${resolution}.mp4`)).to.not.be.undefined
-    }
+    // Ensure we files exist on disk
+    expect(files.find(f => webtorrentFilenames.includes(f))).to.exist
   }
 }
 
 async function check0PlaylistRedundancies (videoUUID?: string) {
-  if (!videoUUID) videoUUID = video1Server2UUID
+  if (!videoUUID) videoUUID = video1Server2.uuid
 
   for (const server of servers) {
     // With token to avoid issues with video follow constraints
-    const res = await getVideoWithToken(server.url, server.accessToken, videoUUID)
-    const video: VideoDetails = res.body
+    const video = await server.videos.getWithToken({ id: videoUUID })
 
     expect(video.streamingPlaylists).to.be.an('array')
     expect(video.streamingPlaylists).to.have.lengthOf(1)
     expect(video.streamingPlaylists[0].redundancies).to.have.lengthOf(0)
   }
+
+  await ensureSameFilenames(videoUUID)
 }
 
 async function check1PlaylistRedundancies (videoUUID?: string) {
-  if (!videoUUID) videoUUID = video1Server2UUID
+  if (!videoUUID) videoUUID = video1Server2.uuid
 
   for (const server of servers) {
-    const res = await getVideo(server.url, videoUUID)
-    const video: VideoDetails = res.body
+    const video = await server.videos.get({ id: videoUUID })
 
     expect(video.streamingPlaylists).to.have.lengthOf(1)
     expect(video.streamingPlaylists[0].redundancies).to.have.lengthOf(1)
@@ -211,13 +210,15 @@ async function check1PlaylistRedundancies (videoUUID?: string) {
   const baseUrlPlaylist = servers[1].url + '/static/streaming-playlists/hls'
   const baseUrlSegment = servers[0].url + '/static/redundancy/hls'
 
-  const res = await getVideo(servers[0].url, videoUUID)
-  const hlsPlaylist = (res.body as VideoDetails).streamingPlaylists[0]
+  const video = await servers[0].videos.get({ id: videoUUID })
+  const hlsPlaylist = video.streamingPlaylists[0]
 
   for (const resolution of [ 240, 360, 480, 720 ]) {
-    await checkSegmentHash(baseUrlPlaylist, baseUrlSegment, videoUUID, resolution, hlsPlaylist)
+    await checkSegmentHash({ server: servers[1], baseUrlPlaylist, baseUrlSegment, videoUUID, resolution, hlsPlaylist })
   }
 
+  const { hlsFilenames } = await ensureSameFilenames(videoUUID)
+
   const directories = [
     'test' + servers[0].internalServerNumber + '/redundancy/hls',
     'test' + servers[1].internalServerNumber + '/streaming-playlists/hls'
@@ -227,11 +228,8 @@ async function check1PlaylistRedundancies (videoUUID?: string) {
     const files = await readdir(join(root(), directory, videoUUID))
     expect(files).to.have.length.at.least(4)
 
-    for (const resolution of [ 240, 360, 480, 720 ]) {
-      const filename = `${videoUUID}-${resolution}-fragmented.mp4`
-
-      expect(files.find(f => f === filename)).to.not.be.undefined
-    }
+    // Ensure we files exist on disk
+    expect(files.find(f => hlsFilenames.includes(f))).to.exist
   }
 }
 
@@ -244,9 +242,7 @@ async function checkStatsGlobal (strategy: VideoRedundancyStrategyWithManual) {
     statsLength = 2
   }
 
-  const res = await getStats(servers[0].url)
-  const data: ServerStats = res.body
-
+  const data = await servers[0].stats.get()
   expect(data.videosRedundancy).to.have.lengthOf(statsLength)
 
   const stat = data.videosRedundancy[0]
@@ -272,14 +268,20 @@ async function checkStatsWithoutRedundancy (strategy: VideoRedundancyStrategyWit
   expect(stat.totalVideos).to.equal(0)
 }
 
-async function enableRedundancyOnServer1 () {
-  await updateRedundancy(servers[0].url, servers[0].accessToken, servers[1].host, true)
-
-  const res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 5, sort: '-createdAt' })
-  const follows: ActorFollow[] = res.body.data
+async function findServerFollows () {
+  const body = await servers[0].follows.getFollowings({ start: 0, count: 5, sort: '-createdAt' })
+  const follows = body.data
   const server2 = follows.find(f => f.following.host === `localhost:${servers[1].port}`)
   const server3 = follows.find(f => f.following.host === `localhost:${servers[2].port}`)
 
+  return { server2, server3 }
+}
+
+async function enableRedundancyOnServer1 () {
+  await servers[0].redundancy.updateRedundancy({ host: servers[1].host, redundancyAllowed: true })
+
+  const { server2, server3 } = await findServerFollows()
+
   expect(server3).to.not.be.undefined
   expect(server3.following.hostRedundancyAllowed).to.be.false
 
@@ -288,12 +290,9 @@ async function enableRedundancyOnServer1 () {
 }
 
 async function disableRedundancyOnServer1 () {
-  await updateRedundancy(servers[0].url, servers[0].accessToken, servers[1].host, false)
+  await servers[0].redundancy.updateRedundancy({ host: servers[1].host, redundancyAllowed: false })
 
-  const res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 5, sort: '-createdAt' })
-  const follows: ActorFollow[] = res.body.data
-  const server2 = follows.find(f => f.following.host === `localhost:${servers[1].port}`)
-  const server3 = follows.find(f => f.following.host === `localhost:${servers[2].port}`)
+  const { server2, server3 } = await findServerFollows()
 
   expect(server3).to.not.be.undefined
   expect(server3.following.hostRedundancyAllowed).to.be.false
@@ -310,7 +309,7 @@ describe('Test videos redundancy', function () {
     before(function () {
       this.timeout(120000)
 
-      return flushAndRunServers(strategy)
+      return createSingleServers(strategy)
     })
 
     it('Should have 1 webseed on the first video', async function () {
@@ -327,7 +326,7 @@ describe('Test videos redundancy', function () {
       this.timeout(80000)
 
       await waitJobs(servers)
-      await waitUntilLog(servers[0], 'Duplicated ', 5)
+      await servers[0].servers.waitUntilLog('Duplicated ', 5)
       await waitJobs(servers)
 
       await check2Webseeds()
@@ -346,7 +345,7 @@ describe('Test videos redundancy', function () {
       await check1WebSeed()
       await check0PlaylistRedundancies()
 
-      await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].internalServerNumber, [ 'videos', join('playlists', 'hls') ])
+      await checkVideoFilesWereRemoved({ server: servers[0], video: video1Server2, onlyVideoFiles: true })
     })
 
     after(async function () {
@@ -360,7 +359,7 @@ describe('Test videos redundancy', function () {
     before(function () {
       this.timeout(120000)
 
-      return flushAndRunServers(strategy)
+      return createSingleServers(strategy)
     })
 
     it('Should have 1 webseed on the first video', async function () {
@@ -377,7 +376,7 @@ describe('Test videos redundancy', function () {
       this.timeout(80000)
 
       await waitJobs(servers)
-      await waitUntilLog(servers[0], 'Duplicated ', 5)
+      await servers[0].servers.waitUntilLog('Duplicated ', 5)
       await waitJobs(servers)
 
       await check2Webseeds()
@@ -388,7 +387,7 @@ describe('Test videos redundancy', function () {
     it('Should unfollow on server 1 and remove duplicated videos', async function () {
       this.timeout(80000)
 
-      await unfollow(servers[0].url, servers[0].accessToken, servers[1])
+      await servers[0].follows.unfollow({ target: servers[1] })
 
       await waitJobs(servers)
       await wait(5000)
@@ -396,7 +395,7 @@ describe('Test videos redundancy', function () {
       await check1WebSeed()
       await check0PlaylistRedundancies()
 
-      await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].internalServerNumber, [ 'videos' ])
+      await checkVideoFilesWereRemoved({ server: servers[0], video: video1Server2, onlyVideoFiles: true })
     })
 
     after(async function () {
@@ -410,7 +409,7 @@ describe('Test videos redundancy', function () {
     before(function () {
       this.timeout(120000)
 
-      return flushAndRunServers(strategy, { min_views: 3 })
+      return createSingleServers(strategy, { min_views: 3 })
     })
 
     it('Should have 1 webseed on the first video', async function () {
@@ -438,8 +437,8 @@ describe('Test videos redundancy', function () {
     it('Should view 2 times the first video to have > min_views config', async function () {
       this.timeout(80000)
 
-      await viewVideo(servers[0].url, video1Server2UUID)
-      await viewVideo(servers[2].url, video1Server2UUID)
+      await servers[0].videos.view({ id: video1Server2.uuid })
+      await servers[2].videos.view({ id: video1Server2.uuid })
 
       await wait(10000)
       await waitJobs(servers)
@@ -449,7 +448,7 @@ describe('Test videos redundancy', function () {
       this.timeout(80000)
 
       await waitJobs(servers)
-      await waitUntilLog(servers[0], 'Duplicated ', 5)
+      await servers[0].servers.waitUntilLog('Duplicated ', 5)
       await waitJobs(servers)
 
       await check2Webseeds()
@@ -460,12 +459,13 @@ describe('Test videos redundancy', function () {
     it('Should remove the video and the redundancy files', async function () {
       this.timeout(20000)
 
-      await removeVideo(servers[1].url, servers[1].accessToken, video1Server2UUID)
+      await saveVideoInServers(servers, video1Server2.uuid)
+      await servers[1].videos.remove({ id: video1Server2.uuid })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        await checkVideoFilesWereRemoved(video1Server2UUID, server.internalServerNumber)
+        await checkVideoFilesWereRemoved({ server, video: server.store.videoDetails })
       }
     })
 
@@ -480,7 +480,7 @@ describe('Test videos redundancy', function () {
     before(async function () {
       this.timeout(120000)
 
-      await flushAndRunServers(strategy, { min_views: 3 }, false)
+      await createSingleServers(strategy, { min_views: 3 }, false)
     })
 
     it('Should have 0 playlist redundancy on the first video', async function () {
@@ -506,14 +506,14 @@ describe('Test videos redundancy', function () {
     it('Should have 1 redundancy on the first video', async function () {
       this.timeout(160000)
 
-      await viewVideo(servers[0].url, video1Server2UUID)
-      await viewVideo(servers[2].url, video1Server2UUID)
+      await servers[0].videos.view({ id: video1Server2.uuid })
+      await servers[2].videos.view({ id: video1Server2.uuid })
 
       await wait(10000)
       await waitJobs(servers)
 
       await waitJobs(servers)
-      await waitUntilLog(servers[0], 'Duplicated ', 1)
+      await servers[0].servers.waitUntilLog('Duplicated ', 1)
       await waitJobs(servers)
 
       await check1PlaylistRedundancies()
@@ -523,12 +523,13 @@ describe('Test videos redundancy', function () {
     it('Should remove the video and the redundancy files', async function () {
       this.timeout(20000)
 
-      await removeVideo(servers[1].url, servers[1].accessToken, video1Server2UUID)
+      await saveVideoInServers(servers, video1Server2.uuid)
+      await servers[1].videos.remove({ id: video1Server2.uuid })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        await checkVideoFilesWereRemoved(video1Server2UUID, server.internalServerNumber)
+        await checkVideoFilesWereRemoved({ server, video: server.store.videoDetails })
       }
     })
 
@@ -541,7 +542,7 @@ describe('Test videos redundancy', function () {
     before(function () {
       this.timeout(120000)
 
-      return flushAndRunServers(null)
+      return createSingleServers(null)
     })
 
     it('Should have 1 webseed on the first video', async function () {
@@ -551,18 +552,14 @@ describe('Test videos redundancy', function () {
     })
 
     it('Should create a redundancy on first video', async function () {
-      await addVideoRedundancy({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        videoId: video1Server2Id
-      })
+      await servers[0].redundancy.addVideo({ videoId: video1Server2.id })
     })
 
     it('Should have 2 webseeds on the first video', async function () {
       this.timeout(80000)
 
       await waitJobs(servers)
-      await waitUntilLog(servers[0], 'Duplicated ', 5)
+      await servers[0].servers.waitUntilLog('Duplicated ', 5)
       await waitJobs(servers)
 
       await check2Webseeds()
@@ -573,22 +570,15 @@ describe('Test videos redundancy', function () {
     it('Should manually remove redundancies on server 1 and remove duplicated videos', async function () {
       this.timeout(80000)
 
-      const res = await listVideoRedundancies({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        target: 'remote-videos'
-      })
+      const body = await servers[0].redundancy.listVideos({ target: 'remote-videos' })
 
-      const videos = res.body.data as VideoRedundancy[]
+      const videos = body.data
       expect(videos).to.have.lengthOf(1)
 
       const video = videos[0]
+
       for (const r of video.redundancies.files.concat(video.redundancies.streamingPlaylists)) {
-        await removeVideoRedundancy({
-          url: servers[0].url,
-          accessToken: servers[0].accessToken,
-          redundancyId: r.id
-        })
+        await servers[0].redundancy.removeVideo({ redundancyId: r.id })
       }
 
       await waitJobs(servers)
@@ -597,7 +587,7 @@ describe('Test videos redundancy', function () {
       await check1WebSeed()
       await check0PlaylistRedundancies()
 
-      await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].serverNumber, [ 'videos' ])
+      await checkVideoFilesWereRemoved({ server: servers[0], video: video1Server2, onlyVideoFiles: true })
     })
 
     after(async function () {
@@ -608,10 +598,9 @@ describe('Test videos redundancy', function () {
   describe('Test expiration', function () {
     const strategy = 'recently-added'
 
-    async function checkContains (servers: ServerInfo[], str: string) {
+    async function checkContains (servers: PeerTubeServer[], str: string) {
       for (const server of servers) {
-        const res = await getVideo(server.url, video1Server2UUID)
-        const video: VideoDetails = res.body
+        const video = await server.videos.get({ id: video1Server2.uuid })
 
         for (const f of video.files) {
           expect(f.magnetUri).to.contain(str)
@@ -619,10 +608,9 @@ describe('Test videos redundancy', function () {
       }
     }
 
-    async function checkNotContains (servers: ServerInfo[], str: string) {
+    async function checkNotContains (servers: PeerTubeServer[], str: string) {
       for (const server of servers) {
-        const res = await getVideo(server.url, video1Server2UUID)
-        const video: VideoDetails = res.body
+        const video = await server.videos.get({ id: video1Server2.uuid })
 
         for (const f of video.files) {
           expect(f.magnetUri).to.not.contain(str)
@@ -633,7 +621,7 @@ describe('Test videos redundancy', function () {
     before(async function () {
       this.timeout(120000)
 
-      await flushAndRunServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
+      await createSingleServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
 
       await enableRedundancyOnServer1()
     })
@@ -656,7 +644,7 @@ describe('Test videos redundancy', function () {
     it('Should stop server 1 and expire video redundancy', async function () {
       this.timeout(80000)
 
-      killallServers([ servers[0] ])
+      await killallServers([ servers[0] ])
 
       await wait(15000)
 
@@ -675,25 +663,25 @@ describe('Test videos redundancy', function () {
     before(async function () {
       this.timeout(120000)
 
-      await flushAndRunServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
+      await createSingleServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
 
       await enableRedundancyOnServer1()
 
       await waitJobs(servers)
-      await waitUntilLog(servers[0], 'Duplicated ', 5)
+      await servers[0].servers.waitUntilLog('Duplicated ', 5)
       await waitJobs(servers)
 
-      await check2Webseeds(video1Server2UUID)
-      await check1PlaylistRedundancies(video1Server2UUID)
+      await check2Webseeds()
+      await check1PlaylistRedundancies()
       await checkStatsWith1Redundancy(strategy)
 
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video 2 server 2', privacy: VideoPrivacy.PRIVATE })
-      video2Server2UUID = res.body.video.uuid
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video 2 server 2', privacy: VideoPrivacy.PRIVATE } })
+      video2Server2UUID = uuid
 
       // Wait transcoding before federation
       await waitJobs(servers)
 
-      await updateVideo(servers[1].url, servers[1].accessToken, video2Server2UUID, { privacy: VideoPrivacy.PUBLIC })
+      await servers[1].videos.update({ id: video2Server2UUID, attributes: { privacy: VideoPrivacy.PUBLIC } })
     })
 
     it('Should cache video 2 webseeds on the first video', async function () {
@@ -707,8 +695,8 @@ describe('Test videos redundancy', function () {
         await wait(1000)
 
         try {
-          await check1WebSeed(video1Server2UUID)
-          await check0PlaylistRedundancies(video1Server2UUID)
+          await check1WebSeed()
+          await check0PlaylistRedundancies()
 
           await check2Webseeds(video2Server2UUID)
           await check1PlaylistRedundancies(video2Server2UUID)
@@ -725,8 +713,8 @@ describe('Test videos redundancy', function () {
 
       await waitJobs(servers)
 
-      killallServers([ servers[0] ])
-      await reRunServer(servers[0], {
+      await killallServers([ servers[0] ])
+      await servers[0].run({
         redundancy: {
           videos: {
             check_interval: '1 second',
@@ -737,7 +725,7 @@ describe('Test videos redundancy', function () {
 
       await waitJobs(servers)
 
-      await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].internalServerNumber, [ join('redundancy', 'hls') ])
+      await checkVideoFilesWereRemoved({ server: servers[0], video: video1Server2, onlyVideoFiles: true })
     })
 
     after(async function () {
diff --git a/server/tests/api/search/search-activitypub-video-channels.ts b/server/tests/api/search/search-activitypub-video-channels.ts
index e83eb7171..426cbc8e1 100644
--- a/server/tests/api/search/search-activitypub-video-channels.ts
+++ b/server/tests/api/search/search-activitypub-video-channels.ts
@@ -1,69 +1,63 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
-  addVideoChannel,
   cleanupTests,
-  createUser,
-  deleteVideoChannel,
-  flushAndRunMultipleServers,
-  getVideoChannelsList,
-  getVideoChannelVideos,
-  ServerInfo,
+  createMultipleServers,
+  PeerTubeServer,
+  SearchCommand,
   setAccessTokensToServers,
-  updateMyUser,
-  updateVideo,
-  updateVideoChannel,
-  uploadVideo,
-  userLogin,
-  wait
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { VideoChannel } from '../../../../shared/models/videos'
-import { searchVideoChannel } from '../../../../shared/extra-utils/search/video-channels'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoChannel } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test ActivityPub video channels search', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let userServer2Token: string
   let videoServer2UUID: string
   let channelIdServer2: number
+  let command: SearchCommand
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
     {
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: 'user1_server1', password: 'password' })
+      await servers[0].users.create({ username: 'user1_server1', password: 'password' })
       const channel = {
         name: 'channel1_server1',
         displayName: 'Channel 1 server 1'
       }
-      await addVideoChannel(servers[0].url, servers[0].accessToken, channel)
+      await servers[0].channels.create({ attributes: channel })
     }
 
     {
       const user = { username: 'user1_server2', password: 'password' }
-      await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
-      userServer2Token = await userLogin(servers[1], user)
+      await servers[1].users.create({ username: user.username, password: user.password })
+      userServer2Token = await servers[1].login.getAccessToken(user)
 
       const channel = {
         name: 'channel1_server2',
         displayName: 'Channel 1 server 2'
       }
-      const resChannel = await addVideoChannel(servers[1].url, userServer2Token, channel)
-      channelIdServer2 = resChannel.body.videoChannel.id
+      const created = await servers[1].channels.create({ token: userServer2Token, attributes: channel })
+      channelIdServer2 = created.id
 
-      const res = await uploadVideo(servers[1].url, userServer2Token, { name: 'video 1 server 2', channelId: channelIdServer2 })
-      videoServer2UUID = res.body.video.uuid
+      const attributes = { name: 'video 1 server 2', channelId: channelIdServer2 }
+      const { uuid } = await servers[1].videos.upload({ token: userServer2Token, attributes })
+      videoServer2UUID = uuid
     }
 
     await waitJobs(servers)
+
+    command = servers[0].search
   })
 
   it('Should not find a remote video channel', async function () {
@@ -71,21 +65,21 @@ describe('Test ActivityPub video channels search', function () {
 
     {
       const search = 'http://localhost:' + servers[1].port + '/video-channels/channel1_server3'
-      const res = await searchVideoChannel(servers[0].url, search, servers[0].accessToken)
+      const body = await command.searchChannels({ search, token: servers[0].accessToken })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     }
 
     {
       // Without token
       const search = 'http://localhost:' + servers[1].port + '/video-channels/channel1_server2'
-      const res = await searchVideoChannel(servers[0].url, search)
+      const body = await command.searchChannels({ search })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     }
   })
 
@@ -96,13 +90,13 @@ describe('Test ActivityPub video channels search', function () {
     ]
 
     for (const search of searches) {
-      const res = await searchVideoChannel(servers[0].url, search)
+      const body = await command.searchChannels({ search })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].name).to.equal('channel1_server1')
-      expect(res.body.data[0].displayName).to.equal('Channel 1 server 1')
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('channel1_server1')
+      expect(body.data[0].displayName).to.equal('Channel 1 server 1')
     }
   })
 
@@ -110,13 +104,13 @@ describe('Test ActivityPub video channels search', function () {
     const search = 'http://localhost:' + servers[0].port + '/c/channel1_server1'
 
     for (const token of [ undefined, servers[0].accessToken ]) {
-      const res = await searchVideoChannel(servers[0].url, search, token)
+      const body = await command.searchChannels({ search, token })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].name).to.equal('channel1_server1')
-      expect(res.body.data[0].displayName).to.equal('Channel 1 server 1')
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('channel1_server1')
+      expect(body.data[0].displayName).to.equal('Channel 1 server 1')
     }
   })
 
@@ -129,23 +123,23 @@ describe('Test ActivityPub video channels search', function () {
     ]
 
     for (const search of searches) {
-      const res = await searchVideoChannel(servers[0].url, search, servers[0].accessToken)
+      const body = await command.searchChannels({ search, token: servers[0].accessToken })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].name).to.equal('channel1_server2')
-      expect(res.body.data[0].displayName).to.equal('Channel 1 server 2')
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('channel1_server2')
+      expect(body.data[0].displayName).to.equal('Channel 1 server 2')
     }
   })
 
   it('Should not list this remote video channel', async function () {
-    const res = await getVideoChannelsList(servers[0].url, 0, 5)
-    expect(res.body.total).to.equal(3)
-    expect(res.body.data).to.have.lengthOf(3)
-    expect(res.body.data[0].name).to.equal('channel1_server1')
-    expect(res.body.data[1].name).to.equal('user1_server1_channel')
-    expect(res.body.data[2].name).to.equal('root_channel')
+    const body = await servers[0].channels.list()
+    expect(body.total).to.equal(3)
+    expect(body.data).to.have.lengthOf(3)
+    expect(body.data[0].name).to.equal('channel1_server1')
+    expect(body.data[1].name).to.equal('user1_server1_channel')
+    expect(body.data[2].name).to.equal('root_channel')
   })
 
   it('Should list video channel videos of server 2 without token', async function () {
@@ -153,34 +147,43 @@ describe('Test ActivityPub video channels search', function () {
 
     await waitJobs(servers)
 
-    const res = await getVideoChannelVideos(servers[0].url, null, 'channel1_server2@localhost:' + servers[1].port, 0, 5)
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    const { total, data } = await servers[0].videos.listByChannel({
+      token: null,
+      handle: 'channel1_server2@localhost:' + servers[1].port
+    })
+    expect(total).to.equal(0)
+    expect(data).to.have.lengthOf(0)
   })
 
   it('Should list video channel videos of server 2 with token', async function () {
-    const res = await getVideoChannelVideos(servers[0].url, servers[0].accessToken, 'channel1_server2@localhost:' + servers[1].port, 0, 5)
+    const { total, data } = await servers[0].videos.listByChannel({
+      handle: 'channel1_server2@localhost:' + servers[1].port
+    })
 
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data[0].name).to.equal('video 1 server 2')
+    expect(total).to.equal(1)
+    expect(data[0].name).to.equal('video 1 server 2')
   })
 
   it('Should update video channel of server 2, and refresh it on server 1', async function () {
     this.timeout(60000)
 
-    await updateVideoChannel(servers[1].url, userServer2Token, 'channel1_server2', { displayName: 'channel updated' })
-    await updateMyUser({ url: servers[1].url, accessToken: userServer2Token, displayName: 'user updated' })
+    await servers[1].channels.update({
+      token: userServer2Token,
+      channelName: 'channel1_server2',
+      attributes: { displayName: 'channel updated' }
+    })
+    await servers[1].users.updateMe({ token: userServer2Token, displayName: 'user updated' })
 
     await waitJobs(servers)
     // Expire video channel
     await wait(10000)
 
     const search = 'http://localhost:' + servers[1].port + '/video-channels/channel1_server2'
-    const res = await searchVideoChannel(servers[0].url, search, servers[0].accessToken)
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.have.lengthOf(1)
+    const body = await command.searchChannels({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.have.lengthOf(1)
 
-    const videoChannel: VideoChannel = res.body.data[0]
+    const videoChannel: VideoChannel = body.data[0]
     expect(videoChannel.displayName).to.equal('channel updated')
 
     // We don't return the owner account for now
@@ -190,8 +193,8 @@ describe('Test ActivityPub video channels search', function () {
   it('Should update and add a video on server 2, and update it on server 1 after a search', async function () {
     this.timeout(60000)
 
-    await updateVideo(servers[1].url, userServer2Token, videoServer2UUID, { name: 'video 1 updated' })
-    await uploadVideo(servers[1].url, userServer2Token, { name: 'video 2 server 2', channelId: channelIdServer2 })
+    await servers[1].videos.update({ token: userServer2Token, id: videoServer2UUID, attributes: { name: 'video 1 updated' } })
+    await servers[1].videos.upload({ token: userServer2Token, attributes: { name: 'video 2 server 2', channelId: channelIdServer2 } })
 
     await waitJobs(servers)
 
@@ -199,31 +202,31 @@ describe('Test ActivityPub video channels search', function () {
     await wait(10000)
 
     const search = 'http://localhost:' + servers[1].port + '/video-channels/channel1_server2'
-    await searchVideoChannel(servers[0].url, search, servers[0].accessToken)
+    await command.searchChannels({ search, token: servers[0].accessToken })
 
     await waitJobs(servers)
 
-    const videoChannelName = 'channel1_server2@localhost:' + servers[1].port
-    const res = await getVideoChannelVideos(servers[0].url, servers[0].accessToken, videoChannelName, 0, 5, '-createdAt')
+    const handle = 'channel1_server2@localhost:' + servers[1].port
+    const { total, data } = await servers[0].videos.listByChannel({ handle, sort: '-createdAt' })
 
-    expect(res.body.total).to.equal(2)
-    expect(res.body.data[0].name).to.equal('video 2 server 2')
-    expect(res.body.data[1].name).to.equal('video 1 updated')
+    expect(total).to.equal(2)
+    expect(data[0].name).to.equal('video 2 server 2')
+    expect(data[1].name).to.equal('video 1 updated')
   })
 
   it('Should delete video channel of server 2, and delete it on server 1', async function () {
     this.timeout(60000)
 
-    await deleteVideoChannel(servers[1].url, userServer2Token, 'channel1_server2')
+    await servers[1].channels.delete({ token: userServer2Token, channelName: 'channel1_server2' })
 
     await waitJobs(servers)
     // Expire video
     await wait(10000)
 
     const search = 'http://localhost:' + servers[1].port + '/video-channels/channel1_server2'
-    const res = await searchVideoChannel(servers[0].url, search, servers[0].accessToken)
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    const body = await command.searchChannels({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   after(async function () {
diff --git a/server/tests/api/search/search-activitypub-video-playlists.ts b/server/tests/api/search/search-activitypub-video-playlists.ts
index 4c08e9548..33ca7be12 100644
--- a/server/tests/api/search/search-activitypub-video-playlists.ts
+++ b/server/tests/api/search/search-activitypub-video-playlists.ts
@@ -3,113 +3,102 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  addVideoInPlaylist,
   cleanupTests,
-  createVideoPlaylist,
-  deleteVideoPlaylist,
-  flushAndRunMultipleServers,
-  getVideoPlaylistsList,
-  searchVideoPlaylists,
-  ServerInfo,
+  createMultipleServers,
+  PeerTubeServer,
+  SearchCommand,
   setAccessTokensToServers,
   setDefaultVideoChannel,
-  uploadVideoAndGetId,
-  wait
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { VideoPlaylist, VideoPlaylistPrivacy } from '../../../../shared/models/videos'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoPlaylistPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test ActivityPub playlists search', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let playlistServer1UUID: string
   let playlistServer2UUID: string
   let video2Server2: string
 
+  let command: SearchCommand
+
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
     {
-      const video1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 1' })).uuid
-      const video2 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 2' })).uuid
+      const video1 = (await servers[0].videos.quickUpload({ name: 'video 1' })).uuid
+      const video2 = (await servers[0].videos.quickUpload({ name: 'video 2' })).uuid
 
       const attributes = {
         displayName: 'playlist 1 on server 1',
         privacy: VideoPlaylistPrivacy.PUBLIC,
-        videoChannelId: servers[0].videoChannel.id
+        videoChannelId: servers[0].store.channel.id
       }
-      const res = await createVideoPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistAttrs: attributes })
-      playlistServer1UUID = res.body.videoPlaylist.uuid
+      const created = await servers[0].playlists.create({ attributes })
+      playlistServer1UUID = created.uuid
 
       for (const videoId of [ video1, video2 ]) {
-        await addVideoInPlaylist({
-          url: servers[0].url,
-          token: servers[0].accessToken,
-          playlistId: playlistServer1UUID,
-          elementAttrs: { videoId }
-        })
+        await servers[0].playlists.addElement({ playlistId: playlistServer1UUID, attributes: { videoId } })
       }
     }
 
     {
-      const videoId = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video 1' })).uuid
-      video2Server2 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video 2' })).uuid
+      const videoId = (await servers[1].videos.quickUpload({ name: 'video 1' })).uuid
+      video2Server2 = (await servers[1].videos.quickUpload({ name: 'video 2' })).uuid
 
       const attributes = {
         displayName: 'playlist 1 on server 2',
         privacy: VideoPlaylistPrivacy.PUBLIC,
-        videoChannelId: servers[1].videoChannel.id
+        videoChannelId: servers[1].store.channel.id
       }
-      const res = await createVideoPlaylist({ url: servers[1].url, token: servers[1].accessToken, playlistAttrs: attributes })
-      playlistServer2UUID = res.body.videoPlaylist.uuid
-
-      await addVideoInPlaylist({
-        url: servers[1].url,
-        token: servers[1].accessToken,
-        playlistId: playlistServer2UUID,
-        elementAttrs: { videoId }
-      })
+      const created = await servers[1].playlists.create({ attributes })
+      playlistServer2UUID = created.uuid
+
+      await servers[1].playlists.addElement({ playlistId: playlistServer2UUID, attributes: { videoId } })
     }
 
     await waitJobs(servers)
+
+    command = servers[0].search
   })
 
   it('Should not find a remote playlist', async function () {
     {
       const search = 'http://localhost:' + servers[1].port + '/video-playlists/43'
-      const res = await searchVideoPlaylists(servers[0].url, search, servers[0].accessToken)
+      const body = await command.searchPlaylists({ search, token: servers[0].accessToken })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     }
 
     {
       // Without token
       const search = 'http://localhost:' + servers[1].port + '/video-playlists/' + playlistServer2UUID
-      const res = await searchVideoPlaylists(servers[0].url, search)
+      const body = await command.searchPlaylists({ search })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     }
   })
 
   it('Should search a local playlist', async function () {
     const search = 'http://localhost:' + servers[0].port + '/video-playlists/' + playlistServer1UUID
-    const res = await searchVideoPlaylists(servers[0].url, search)
+    const body = await command.searchPlaylists({ search })
 
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
-    expect(res.body.data[0].displayName).to.equal('playlist 1 on server 1')
-    expect(res.body.data[0].videosLength).to.equal(2)
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].displayName).to.equal('playlist 1 on server 1')
+    expect(body.data[0].videosLength).to.equal(2)
   })
 
   it('Should search a local playlist with an alternative URL', async function () {
@@ -120,13 +109,13 @@ describe('Test ActivityPub playlists search', function () {
 
     for (const search of searches) {
       for (const token of [ undefined, servers[0].accessToken ]) {
-        const res = await searchVideoPlaylists(servers[0].url, search, token)
+        const body = await command.searchPlaylists({ search, token })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data).to.have.lengthOf(1)
-        expect(res.body.data[0].displayName).to.equal('playlist 1 on server 1')
-        expect(res.body.data[0].videosLength).to.equal(2)
+        expect(body.total).to.equal(1)
+        expect(body.data).to.be.an('array')
+        expect(body.data).to.have.lengthOf(1)
+        expect(body.data[0].displayName).to.equal('playlist 1 on server 1')
+        expect(body.data[0].videosLength).to.equal(2)
       }
     }
   })
@@ -139,32 +128,27 @@ describe('Test ActivityPub playlists search', function () {
     ]
 
     for (const search of searches) {
-      const res = await searchVideoPlaylists(servers[0].url, search, servers[0].accessToken)
+      const body = await command.searchPlaylists({ search, token: servers[0].accessToken })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].displayName).to.equal('playlist 1 on server 2')
-      expect(res.body.data[0].videosLength).to.equal(1)
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].displayName).to.equal('playlist 1 on server 2')
+      expect(body.data[0].videosLength).to.equal(1)
     }
   })
 
   it('Should not list this remote playlist', async function () {
-    const res = await getVideoPlaylistsList(servers[0].url, 0, 10)
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.have.lengthOf(1)
-    expect(res.body.data[0].displayName).to.equal('playlist 1 on server 1')
+    const body = await servers[0].playlists.list({ start: 0, count: 10 })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].displayName).to.equal('playlist 1 on server 1')
   })
 
   it('Should update the playlist of server 2, and refresh it on server 1', async function () {
     this.timeout(60000)
 
-    await addVideoInPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistServer2UUID,
-      elementAttrs: { videoId: video2Server2 }
-    })
+    await servers[1].playlists.addElement({ playlistId: playlistServer2UUID, attributes: { videoId: video2Server2 } })
 
     await waitJobs(servers)
     // Expire playlist
@@ -172,23 +156,23 @@ describe('Test ActivityPub playlists search', function () {
 
     // Will run refresh async
     const search = 'http://localhost:' + servers[1].port + '/video-playlists/' + playlistServer2UUID
-    await searchVideoPlaylists(servers[0].url, search, servers[0].accessToken)
+    await command.searchPlaylists({ search, token: servers[0].accessToken })
 
     // Wait refresh
     await wait(5000)
 
-    const res = await searchVideoPlaylists(servers[0].url, search, servers[0].accessToken)
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.have.lengthOf(1)
+    const body = await command.searchPlaylists({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.have.lengthOf(1)
 
-    const playlist: VideoPlaylist = res.body.data[0]
+    const playlist = body.data[0]
     expect(playlist.videosLength).to.equal(2)
   })
 
   it('Should delete playlist of server 2, and delete it on server 1', async function () {
     this.timeout(60000)
 
-    await deleteVideoPlaylist(servers[1].url, servers[1].accessToken, playlistServer2UUID)
+    await servers[1].playlists.delete({ playlistId: playlistServer2UUID })
 
     await waitJobs(servers)
     // Expiration
@@ -196,14 +180,14 @@ describe('Test ActivityPub playlists search', function () {
 
     // Will run refresh async
     const search = 'http://localhost:' + servers[1].port + '/video-playlists/' + playlistServer2UUID
-    await searchVideoPlaylists(servers[0].url, search, servers[0].accessToken)
+    await command.searchPlaylists({ search, token: servers[0].accessToken })
 
     // Wait refresh
     await wait(5000)
 
-    const res = await searchVideoPlaylists(servers[0].url, search, servers[0].accessToken)
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    const body = await command.searchPlaylists({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   after(async function () {
diff --git a/server/tests/api/search/search-activitypub-videos.ts b/server/tests/api/search/search-activitypub-videos.ts
index e9b4978da..b3cfcacca 100644
--- a/server/tests/api/search/search-activitypub-videos.ts
+++ b/server/tests/api/search/search-activitypub-videos.ts
@@ -1,92 +1,90 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
-  addVideoChannel,
   cleanupTests,
-  flushAndRunMultipleServers,
-  getVideosList,
-  removeVideo,
-  searchVideo,
-  searchVideoWithToken,
-  ServerInfo,
+  createMultipleServers,
+  PeerTubeServer,
+  SearchCommand,
   setAccessTokensToServers,
-  updateVideo,
-  uploadVideo,
-  wait
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { Video, VideoPrivacy } from '../../../../shared/models/videos'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test ActivityPub videos search', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let videoServer1UUID: string
   let videoServer2UUID: string
 
+  let command: SearchCommand
+
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
     {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video 1 on server 1' })
-      videoServer1UUID = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video 1 on server 1' } })
+      videoServer1UUID = uuid
     }
 
     {
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video 1 on server 2' })
-      videoServer2UUID = res.body.video.uuid
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video 1 on server 2' } })
+      videoServer2UUID = uuid
     }
 
     await waitJobs(servers)
+
+    command = servers[0].search
   })
 
   it('Should not find a remote video', async function () {
     {
       const search = 'http://localhost:' + servers[1].port + '/videos/watch/43'
-      const res = await searchVideoWithToken(servers[0].url, search, servers[0].accessToken)
+      const body = await command.searchVideos({ search, token: servers[0].accessToken })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     }
 
     {
       // Without token
       const search = 'http://localhost:' + servers[1].port + '/videos/watch/' + videoServer2UUID
-      const res = await searchVideo(servers[0].url, search)
+      const body = await command.searchVideos({ search })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     }
   })
 
   it('Should search a local video', async function () {
     const search = 'http://localhost:' + servers[0].port + '/videos/watch/' + videoServer1UUID
-    const res = await searchVideo(servers[0].url, search)
+    const body = await command.searchVideos({ search })
 
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
-    expect(res.body.data[0].name).to.equal('video 1 on server 1')
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].name).to.equal('video 1 on server 1')
   })
 
   it('Should search a local video with an alternative URL', async function () {
     const search = 'http://localhost:' + servers[0].port + '/w/' + videoServer1UUID
-    const res1 = await searchVideo(servers[0].url, search)
-    const res2 = await searchVideoWithToken(servers[0].url, search, servers[0].accessToken)
-
-    for (const res of [ res1, res2 ]) {
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].name).to.equal('video 1 on server 1')
+    const body1 = await command.searchVideos({ search })
+    const body2 = await command.searchVideos({ search, token: servers[0].accessToken })
+
+    for (const body of [ body1, body2 ]) {
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('video 1 on server 1')
     }
   })
 
@@ -97,20 +95,20 @@ describe('Test ActivityPub videos search', function () {
     ]
 
     for (const search of searches) {
-      const res = await searchVideoWithToken(servers[0].url, search, servers[0].accessToken)
+      const body = await command.searchVideos({ search, token: servers[0].accessToken })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].name).to.equal('video 1 on server 2')
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('video 1 on server 2')
     }
   })
 
   it('Should not list this remote video', async function () {
-    const res = await getVideosList(servers[0].url)
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.have.lengthOf(1)
-    expect(res.body.data[0].name).to.equal('video 1 on server 1')
+    const { total, data } = await servers[0].videos.list()
+    expect(total).to.equal(1)
+    expect(data).to.have.lengthOf(1)
+    expect(data[0].name).to.equal('video 1 on server 1')
   })
 
   it('Should update video of server 2, and refresh it on server 1', async function () {
@@ -120,8 +118,8 @@ describe('Test ActivityPub videos search', function () {
       name: 'super_channel',
       displayName: 'super channel'
     }
-    const resChannel = await addVideoChannel(servers[1].url, servers[1].accessToken, channelAttributes)
-    const videoChannelId = resChannel.body.videoChannel.id
+    const created = await servers[1].channels.create({ attributes: channelAttributes })
+    const videoChannelId = created.id
 
     const attributes = {
       name: 'updated',
@@ -129,7 +127,7 @@ describe('Test ActivityPub videos search', function () {
       privacy: VideoPrivacy.UNLISTED,
       channelId: videoChannelId
     }
-    await updateVideo(servers[1].url, servers[1].accessToken, videoServer2UUID, attributes)
+    await servers[1].videos.update({ id: videoServer2UUID, attributes })
 
     await waitJobs(servers)
     // Expire video
@@ -137,16 +135,16 @@ describe('Test ActivityPub videos search', function () {
 
     // Will run refresh async
     const search = 'http://localhost:' + servers[1].port + '/videos/watch/' + videoServer2UUID
-    await searchVideoWithToken(servers[0].url, search, servers[0].accessToken)
+    await command.searchVideos({ search, token: servers[0].accessToken })
 
     // Wait refresh
     await wait(5000)
 
-    const res = await searchVideoWithToken(servers[0].url, search, servers[0].accessToken)
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.have.lengthOf(1)
+    const body = await command.searchVideos({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.have.lengthOf(1)
 
-    const video: Video = res.body.data[0]
+    const video = body.data[0]
     expect(video.name).to.equal('updated')
     expect(video.channel.name).to.equal('super_channel')
     expect(video.privacy.id).to.equal(VideoPrivacy.UNLISTED)
@@ -155,7 +153,7 @@ describe('Test ActivityPub videos search', function () {
   it('Should delete video of server 2, and delete it on server 1', async function () {
     this.timeout(120000)
 
-    await removeVideo(servers[1].url, servers[1].accessToken, videoServer2UUID)
+    await servers[1].videos.remove({ id: videoServer2UUID })
 
     await waitJobs(servers)
     // Expire video
@@ -163,14 +161,14 @@ describe('Test ActivityPub videos search', function () {
 
     // Will run refresh async
     const search = 'http://localhost:' + servers[1].port + '/videos/watch/' + videoServer2UUID
-    await searchVideoWithToken(servers[0].url, search, servers[0].accessToken)
+    await command.searchVideos({ search, token: servers[0].accessToken })
 
     // Wait refresh
     await wait(5000)
 
-    const res = await searchVideoWithToken(servers[0].url, search, servers[0].accessToken)
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    const body = await command.searchVideos({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   after(async function () {
diff --git a/server/tests/api/search/search-channels.ts b/server/tests/api/search/search-channels.ts
index daca2aebe..8a01aff90 100644
--- a/server/tests/api/search/search-channels.ts
+++ b/server/tests/api/search/search-channels.ts
@@ -2,44 +2,65 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { searchVideoChannel, advancedVideoChannelSearch } from '@shared/extra-utils/search/video-channels'
 import {
-  addVideoChannel,
   cleanupTests,
-  createUser,
-  flushAndRunServer,
-  ServerInfo,
+  createSingleServer,
+  doubleFollow,
+  PeerTubeServer,
+  SearchCommand,
   setAccessTokensToServers
-} from '../../../../shared/extra-utils'
+} from '@shared/extra-utils'
 import { VideoChannel } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test channels search', function () {
-  let server: ServerInfo = null
+  let server: PeerTubeServer
+  let remoteServer: PeerTubeServer
+  let command: SearchCommand
 
   before(async function () {
-    this.timeout(30000)
+    this.timeout(120000)
 
-    server = await flushAndRunServer(1)
+    const servers = await Promise.all([
+      createSingleServer(1),
+      createSingleServer(2, { transcoding: { enabled: false } })
+    ])
+    server = servers[0]
+    remoteServer = servers[1]
 
-    await setAccessTokensToServers([ server ])
+    await setAccessTokensToServers([ server, remoteServer ])
 
     {
-      await createUser({ url: server.url, accessToken: server.accessToken, username: 'user1', password: 'password' })
+      await server.users.create({ username: 'user1' })
       const channel = {
         name: 'squall_channel',
         displayName: 'Squall channel'
       }
-      await addVideoChannel(server.url, server.accessToken, channel)
+      await server.channels.create({ attributes: channel })
     }
+
+    {
+      await remoteServer.users.create({ username: 'user1' })
+      const channel = {
+        name: 'zell_channel',
+        displayName: 'Zell channel'
+      }
+      const { id } = await remoteServer.channels.create({ attributes: channel })
+
+      await remoteServer.videos.upload({ attributes: { channelId: id } })
+    }
+
+    await doubleFollow(server, remoteServer)
+
+    command = server.search
   })
 
   it('Should make a simple search and not have results', async function () {
-    const res = await searchVideoChannel(server.url, 'abc')
+    const body = await command.searchChannels({ search: 'abc' })
 
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   it('Should make a search and have results', async function () {
@@ -49,11 +70,11 @@ describe('Test channels search', function () {
         start: 0,
         count: 1
       }
-      const res = await advancedVideoChannelSearch(server.url, search)
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      const body = await command.advancedChannelSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
 
-      const channel: VideoChannel = res.body.data[0]
+      const channel: VideoChannel = body.data[0]
       expect(channel.name).to.equal('squall_channel')
       expect(channel.displayName).to.equal('Squall channel')
     }
@@ -65,15 +86,64 @@ describe('Test channels search', function () {
         count: 1
       }
 
-      const res = await advancedVideoChannelSearch(server.url, search)
+      const body = await command.advancedChannelSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(0)
+    }
+  })
+
+  it('Should filter by host', async function () {
+    {
+      const search = { search: 'channel', host: remoteServer.host }
 
-      expect(res.body.total).to.equal(1)
+      const body = await command.advancedChannelSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].displayName).to.equal('Zell channel')
+    }
+
+    {
+      const search = { search: 'Sq', host: server.host }
 
-      expect(res.body.data).to.have.lengthOf(0)
+      const body = await command.advancedChannelSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].displayName).to.equal('Squall channel')
+    }
+
+    {
+      const search = { search: 'Squall', host: 'example.com' }
+
+      const body = await command.advancedChannelSearch({ search })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+  })
+
+  it('Should filter by names', async function () {
+    {
+      const body = await command.advancedChannelSearch({ search: { handles: [ 'squall_channel', 'zell_channel' ] } })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].displayName).to.equal('Squall channel')
+    }
+
+    {
+      const body = await command.advancedChannelSearch({ search: { handles: [ 'chocobozzz_channel' ] } })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+
+    {
+      const body = await command.advancedChannelSearch({ search: { handles: [ 'squall_channel', 'zell_channel@' + remoteServer.host ] } })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
+      expect(body.data[0].displayName).to.equal('Squall channel')
+      expect(body.data[1].displayName).to.equal('Zell channel')
     }
   })
 
   after(async function () {
-    await cleanupTests([ server ])
+    await cleanupTests([ server, remoteServer ])
   })
 })
diff --git a/server/tests/api/search/search-index.ts b/server/tests/api/search/search-index.ts
index 00f79232a..4c8b1f608 100644
--- a/server/tests/api/search/search-index.ts
+++ b/server/tests/api/search/search-index.ts
@@ -2,36 +2,34 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { advancedVideoChannelSearch, searchVideoChannel } from '@shared/extra-utils/search/video-channels'
-import { Video, VideoChannel, VideoPlaylist, VideoPlaylistPrivacy, VideoPlaylistType, VideosSearchQuery } from '@shared/models'
+import { cleanupTests, createSingleServer, PeerTubeServer, SearchCommand, setAccessTokensToServers } from '@shared/extra-utils'
 import {
-  advancedVideoPlaylistSearch,
-  advancedVideosSearch,
-  cleanupTests,
-  flushAndRunServer,
-  immutableAssign,
-  searchVideo,
-  searchVideoPlaylists,
-  ServerInfo,
-  setAccessTokensToServers,
-  updateCustomSubConfig,
-  uploadVideo
-} from '../../../../shared/extra-utils'
+  BooleanBothQuery,
+  VideoChannelsSearchQuery,
+  VideoPlaylistPrivacy,
+  VideoPlaylistsSearchQuery,
+  VideoPlaylistType,
+  VideosSearchQuery
+} from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test videos search', function () {
-  let server: ServerInfo = null
   const localVideoName = 'local video' + new Date().toISOString()
 
+  let server: PeerTubeServer = null
+  let command: SearchCommand
+
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
-    await uploadVideo(server.url, server.accessToken, { name: localVideoName })
+    await server.videos.upload({ attributes: { name: localVideoName } })
+
+    command = server.search
   })
 
   describe('Default search', async function () {
@@ -39,163 +37,213 @@ describe('Test videos search', function () {
     it('Should make a local videos search by default', async function () {
       this.timeout(10000)
 
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        search: {
-          searchIndex: {
-            enabled: true,
-            isDefaultSearch: false,
-            disableLocalSearch: false
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          search: {
+            searchIndex: {
+              enabled: true,
+              isDefaultSearch: false,
+              disableLocalSearch: false
+            }
           }
         }
       })
 
-      const res = await searchVideo(server.url, 'local video')
+      const body = await command.searchVideos({ search: 'local video' })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data[0].name).to.equal(localVideoName)
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal(localVideoName)
     })
 
     it('Should make a local channels search by default', async function () {
-      const res = await searchVideoChannel(server.url, 'root')
+      const body = await command.searchChannels({ search: 'root' })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data[0].name).to.equal('root_channel')
-      expect(res.body.data[0].host).to.equal('localhost:' + server.port)
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('root_channel')
+      expect(body.data[0].host).to.equal('localhost:' + server.port)
     })
 
     it('Should make an index videos search by default', async function () {
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        search: {
-          searchIndex: {
-            enabled: true,
-            isDefaultSearch: true,
-            disableLocalSearch: false
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          search: {
+            searchIndex: {
+              enabled: true,
+              isDefaultSearch: true,
+              disableLocalSearch: false
+            }
           }
         }
       })
 
-      const res = await searchVideo(server.url, 'local video')
-      expect(res.body.total).to.be.greaterThan(2)
+      const body = await command.searchVideos({ search: 'local video' })
+      expect(body.total).to.be.greaterThan(2)
     })
 
     it('Should make an index channels search by default', async function () {
-      const res = await searchVideoChannel(server.url, 'root')
-      expect(res.body.total).to.be.greaterThan(2)
+      const body = await command.searchChannels({ search: 'root' })
+      expect(body.total).to.be.greaterThan(2)
     })
 
     it('Should make an index videos search if local search is disabled', async function () {
-      await updateCustomSubConfig(server.url, server.accessToken, {
-        search: {
-          searchIndex: {
-            enabled: true,
-            isDefaultSearch: false,
-            disableLocalSearch: true
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          search: {
+            searchIndex: {
+              enabled: true,
+              isDefaultSearch: false,
+              disableLocalSearch: true
+            }
           }
         }
       })
 
-      const res = await searchVideo(server.url, 'local video')
-      expect(res.body.total).to.be.greaterThan(2)
+      const body = await command.searchVideos({ search: 'local video' })
+      expect(body.total).to.be.greaterThan(2)
     })
 
     it('Should make an index channels search if local search is disabled', async function () {
-      const res = await searchVideoChannel(server.url, 'root')
-      expect(res.body.total).to.be.greaterThan(2)
+      const body = await command.searchChannels({ search: 'root' })
+      expect(body.total).to.be.greaterThan(2)
     })
   })
 
   describe('Videos search', async function () {
 
+    async function check (search: VideosSearchQuery, exists = true) {
+      const body = await command.advancedVideoSearch({ search })
+
+      if (exists === false) {
+        expect(body.total).to.equal(0)
+        expect(body.data).to.have.lengthOf(0)
+        return
+      }
+
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+
+      const video = body.data[0]
+
+      expect(video.name).to.equal('What is PeerTube?')
+      expect(video.category.label).to.equal('Science & Technology')
+      expect(video.licence.label).to.equal('Attribution - Share Alike')
+      expect(video.privacy.label).to.equal('Public')
+      expect(video.duration).to.equal(113)
+      expect(video.thumbnailUrl.startsWith('https://framatube.org/static/thumbnails')).to.be.true
+
+      expect(video.account.host).to.equal('framatube.org')
+      expect(video.account.name).to.equal('framasoft')
+      expect(video.account.url).to.equal('https://framatube.org/accounts/framasoft')
+      expect(video.account.avatar).to.exist
+
+      expect(video.channel.host).to.equal('framatube.org')
+      expect(video.channel.name).to.equal('bf54d359-cfad-4935-9d45-9d6be93f63e8')
+      expect(video.channel.url).to.equal('https://framatube.org/video-channels/bf54d359-cfad-4935-9d45-9d6be93f63e8')
+      expect(video.channel.avatar).to.exist
+    }
+
+    const baseSearch: VideosSearchQuery = {
+      search: 'what is peertube',
+      start: 0,
+      count: 2,
+      categoryOneOf: [ 15 ],
+      licenceOneOf: [ 2 ],
+      tagsAllOf: [ 'framasoft', 'peertube' ],
+      startDate: '2018-10-01T10:50:46.396Z',
+      endDate: '2018-10-01T10:55:46.396Z'
+    }
+
     it('Should make a simple search and not have results', async function () {
-      const res = await searchVideo(server.url, 'djidane'.repeat(50))
+      const body = await command.searchVideos({ search: 'djidane'.repeat(50) })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
     })
 
     it('Should make a simple search and have results', async function () {
-      const res = await searchVideo(server.url, 'What is PeerTube')
+      const body = await command.searchVideos({ search: 'What is PeerTube' })
 
-      expect(res.body.total).to.be.greaterThan(1)
+      expect(body.total).to.be.greaterThan(1)
     })
 
-    it('Should make a complex search', async function () {
-
-      async function check (search: VideosSearchQuery, exists = true) {
-        const res = await advancedVideosSearch(server.url, search)
-
-        if (exists === false) {
-          expect(res.body.total).to.equal(0)
-          expect(res.body.data).to.have.lengthOf(0)
-          return
-        }
-
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
-
-        const video: Video = res.body.data[0]
-
-        expect(video.name).to.equal('What is PeerTube?')
-        expect(video.category.label).to.equal('Science & Technology')
-        expect(video.licence.label).to.equal('Attribution - Share Alike')
-        expect(video.privacy.label).to.equal('Public')
-        expect(video.duration).to.equal(113)
-        expect(video.thumbnailUrl.startsWith('https://framatube.org/static/thumbnails')).to.be.true
+    it('Should make a simple search', async function () {
+      await check(baseSearch)
+    })
 
-        expect(video.account.host).to.equal('framatube.org')
-        expect(video.account.name).to.equal('framasoft')
-        expect(video.account.url).to.equal('https://framatube.org/accounts/framasoft')
-        expect(video.account.avatar).to.exist
+    it('Should search by start date', async function () {
+      const search = { ...baseSearch, startDate: '2018-10-01T10:54:46.396Z' }
+      await check(search, false)
+    })
 
-        expect(video.channel.host).to.equal('framatube.org')
-        expect(video.channel.name).to.equal('bf54d359-cfad-4935-9d45-9d6be93f63e8')
-        expect(video.channel.url).to.equal('https://framatube.org/video-channels/bf54d359-cfad-4935-9d45-9d6be93f63e8')
-        expect(video.channel.avatar).to.exist
-      }
+    it('Should search by tags', async function () {
+      const search = { ...baseSearch, tagsAllOf: [ 'toto', 'framasoft' ] }
+      await check(search, false)
+    })
 
-      const baseSearch: VideosSearchQuery = {
-        search: 'what is peertube',
-        start: 0,
-        count: 2,
-        categoryOneOf: [ 15 ],
-        licenceOneOf: [ 2 ],
-        tagsAllOf: [ 'framasoft', 'peertube' ],
-        startDate: '2018-10-01T10:50:46.396Z',
-        endDate: '2018-10-01T10:55:46.396Z'
-      }
+    it('Should search by duration', async function () {
+      const search = { ...baseSearch, durationMin: 2000 }
+      await check(search, false)
+    })
 
+    it('Should search by nsfw attribute', async function () {
       {
-        await check(baseSearch)
+        const search = { ...baseSearch, nsfw: 'true' as BooleanBothQuery }
+        await check(search, false)
       }
 
       {
-        const search = immutableAssign(baseSearch, { startDate: '2018-10-01T10:54:46.396Z' })
-        await check(search, false)
+        const search = { ...baseSearch, nsfw: 'false' as BooleanBothQuery }
+        await check(search, true)
       }
 
       {
-        const search = immutableAssign(baseSearch, { tagsAllOf: [ 'toto', 'framasoft' ] })
-        await check(search, false)
+        const search = { ...baseSearch, nsfw: 'both' as BooleanBothQuery }
+        await check(search, true)
       }
+    })
 
+    it('Should search by host', async function () {
       {
-        const search = immutableAssign(baseSearch, { durationMin: 2000 })
+        const search = { ...baseSearch, host: 'example.com' }
         await check(search, false)
       }
 
       {
-        const search = immutableAssign(baseSearch, { nsfw: 'true' })
-        await check(search, false)
+        const search = { ...baseSearch, host: 'framatube.org' }
+        await check(search, true)
       }
+    })
+
+    it('Should search by uuids', async function () {
+      const goodUUID = '9c9de5e8-0a1e-484a-b099-e80766180a6d'
+      const goodShortUUID = 'kkGMgK9ZtnKfYAgnEtQxbv'
+      const badUUID = 'c29c5b77-4a04-493d-96a9-2e9267e308f0'
+      const badShortUUID = 'rP5RgUeX9XwTSrspCdkDej'
 
       {
-        const search = immutableAssign(baseSearch, { nsfw: 'false' })
-        await check(search, true)
+        const uuidsMatrix = [
+          [ goodUUID ],
+          [ goodUUID, badShortUUID ],
+          [ badShortUUID, goodShortUUID ],
+          [ goodUUID, goodShortUUID ]
+        ]
+
+        for (const uuids of uuidsMatrix) {
+          const search = { ...baseSearch, uuids }
+          await check(search, true)
+        }
       }
 
       {
-        const search = immutableAssign(baseSearch, { nsfw: 'both' })
-        await check(search, true)
+        const uuidsMatrix = [
+          [ badUUID ],
+          [ badShortUUID ]
+        ]
+
+        for (const uuids of uuidsMatrix) {
+          const search = { ...baseSearch, uuids }
+          await check(search, false)
+        }
       }
     })
 
@@ -206,37 +254,44 @@ describe('Test videos search', function () {
         count: 5
       }
 
-      const res = await advancedVideosSearch(server.url, search)
+      const body = await command.advancedVideoSearch({ search })
 
-      expect(res.body.total).to.be.greaterThan(5)
-      expect(res.body.data).to.have.lengthOf(5)
+      expect(body.total).to.be.greaterThan(5)
+      expect(body.data).to.have.lengthOf(5)
     })
 
     it('Should use the nsfw instance policy as default', async function () {
       let nsfwUUID: string
 
       {
-        await updateCustomSubConfig(server.url, server.accessToken, { instance: { defaultNSFWPolicy: 'display' } })
+        await server.config.updateCustomSubConfig({
+          newConfig: {
+            instance: { defaultNSFWPolicy: 'display' }
+          }
+        })
 
-        const res = await searchVideo(server.url, 'NSFW search index', '-match')
-        const video = res.body.data[0] as Video
+        const body = await command.searchVideos({ search: 'NSFW search index', sort: '-match' })
+        expect(body.data).to.have.length.greaterThan(0)
 
-        expect(res.body.data).to.have.length.greaterThan(0)
+        const video = body.data[0]
         expect(video.nsfw).to.be.true
 
         nsfwUUID = video.uuid
       }
 
       {
-        await updateCustomSubConfig(server.url, server.accessToken, { instance: { defaultNSFWPolicy: 'do_not_list' } })
+        await server.config.updateCustomSubConfig({
+          newConfig: {
+            instance: { defaultNSFWPolicy: 'do_not_list' }
+          }
+        })
 
-        const res = await searchVideo(server.url, 'NSFW search index', '-match')
+        const body = await command.searchVideos({ search: 'NSFW search index', sort: '-match' })
 
         try {
-          expect(res.body.data).to.have.lengthOf(0)
-        } catch (err) {
-          //
-          const video = res.body.data[0] as Video
+          expect(body.data).to.have.lengthOf(0)
+        } catch {
+          const video = body.data[0]
 
           expect(video.uuid).not.equal(nsfwUUID)
         }
@@ -246,20 +301,19 @@ describe('Test videos search', function () {
 
   describe('Channels search', async function () {
 
-    it('Should make a simple search and not have results', async function () {
-      const res = await searchVideoChannel(server.url, 'a'.repeat(500))
+    async function check (search: VideoChannelsSearchQuery, exists = true) {
+      const body = await command.advancedChannelSearch({ search })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
-    })
-
-    it('Should make a search and have results', async function () {
-      const res = await advancedVideoChannelSearch(server.url, { search: 'Framasoft', sort: 'createdAt' })
+      if (exists === false) {
+        expect(body.total).to.equal(0)
+        expect(body.data).to.have.lengthOf(0)
+        return
+      }
 
-      expect(res.body.total).to.be.greaterThan(0)
-      expect(res.body.data).to.have.length.greaterThan(0)
+      expect(body.total).to.be.greaterThan(0)
+      expect(body.data).to.have.length.greaterThan(0)
 
-      const videoChannel: VideoChannel = res.body.data[0]
+      const videoChannel = body.data[0]
       expect(videoChannel.url).to.equal('https://framatube.org/video-channels/bf54d359-cfad-4935-9d45-9d6be93f63e8')
       expect(videoChannel.host).to.equal('framatube.org')
       expect(videoChannel.avatar).to.exist
@@ -269,32 +323,53 @@ describe('Test videos search', function () {
       expect(videoChannel.ownerAccount.name).to.equal('framasoft')
       expect(videoChannel.ownerAccount.host).to.equal('framatube.org')
       expect(videoChannel.ownerAccount.avatar).to.exist
+    }
+
+    it('Should make a simple search and not have results', async function () {
+      const body = await command.searchChannels({ search: 'a'.repeat(500) })
+
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    })
+
+    it('Should make a search and have results', async function () {
+      await check({ search: 'Framasoft', sort: 'createdAt' }, true)
+    })
+
+    it('Should make host search and have appropriate results', async function () {
+      await check({ search: 'Framasoft', host: 'example.com' }, false)
+      await check({ search: 'Framasoft', host: 'framatube.org' }, true)
+    })
+
+    it('Should make handles search and have appropriate results', async function () {
+      await check({ handles: [ 'bf54d359-cfad-4935-9d45-9d6be93f63e8@framatube.org' ] }, true)
+      await check({ handles: [ 'jeanine', 'bf54d359-cfad-4935-9d45-9d6be93f63e8@framatube.org' ] }, true)
+      await check({ handles: [ 'jeanine', 'chocobozzz_channel2@peertube2.cpy.re' ] }, false)
     })
 
     it('Should have a correct pagination', async function () {
-      const res = await advancedVideoChannelSearch(server.url, { search: 'root', start: 0, count: 2 })
+      const body = await command.advancedChannelSearch({ search: { search: 'root', start: 0, count: 2 } })
 
-      expect(res.body.total).to.be.greaterThan(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      expect(body.total).to.be.greaterThan(2)
+      expect(body.data).to.have.lengthOf(2)
     })
   })
 
   describe('Playlists search', async function () {
 
-    it('Should make a simple search and not have results', async function () {
-      const res = await searchVideoPlaylists(server.url, 'a'.repeat(500))
+    async function check (search: VideoPlaylistsSearchQuery, exists = true) {
+      const body = await command.advancedPlaylistSearch({ search })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
-    })
-
-    it('Should make a search and have results', async function () {
-      const res = await advancedVideoPlaylistSearch(server.url, { search: 'E2E playlist', sort: '-match' })
+      if (exists === false) {
+        expect(body.total).to.equal(0)
+        expect(body.data).to.have.lengthOf(0)
+        return
+      }
 
-      expect(res.body.total).to.be.greaterThan(0)
-      expect(res.body.data).to.have.length.greaterThan(0)
+      expect(body.total).to.be.greaterThan(0)
+      expect(body.data).to.have.length.greaterThan(0)
 
-      const videoPlaylist: VideoPlaylist = res.body.data[0]
+      const videoPlaylist = body.data[0]
 
       expect(videoPlaylist.url).to.equal('https://peertube2.cpy.re/videos/watch/playlist/73804a40-da9a-40c2-b1eb-2c6d9eec8f0a')
       expect(videoPlaylist.thumbnailUrl).to.exist
@@ -319,13 +394,62 @@ describe('Test videos search', function () {
       expect(videoPlaylist.videoChannel.name).to.equal('chocobozzz_channel')
       expect(videoPlaylist.videoChannel.host).to.equal('peertube2.cpy.re')
       expect(videoPlaylist.videoChannel.avatar).to.exist
+    }
+
+    it('Should make a simple search and not have results', async function () {
+      const body = await command.searchPlaylists({ search: 'a'.repeat(500) })
+
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    })
+
+    it('Should make a search and have results', async function () {
+      await check({ search: 'E2E playlist', sort: '-match' }, true)
+    })
+
+    it('Should make host search and have appropriate results', async function () {
+      await check({ search: 'E2E playlist', host: 'example.com' }, false)
+      await check({ search: 'E2E playlist', host: 'peertube2.cpy.re', sort: '-match' }, true)
+    })
+
+    it('Should make a search by uuids and have appropriate results', async function () {
+      const goodUUID = '73804a40-da9a-40c2-b1eb-2c6d9eec8f0a'
+      const goodShortUUID = 'fgei1ws1oa6FCaJ2qZPG29'
+      const badUUID = 'c29c5b77-4a04-493d-96a9-2e9267e308f0'
+      const badShortUUID = 'rP5RgUeX9XwTSrspCdkDej'
+
+      {
+        const uuidsMatrix = [
+          [ goodUUID ],
+          [ goodUUID, badShortUUID ],
+          [ badShortUUID, goodShortUUID ],
+          [ goodUUID, goodShortUUID ]
+        ]
+
+        for (const uuids of uuidsMatrix) {
+          const search = { search: 'E2E playlist', sort: '-match', uuids }
+          await check(search, true)
+        }
+      }
+
+      {
+        const uuidsMatrix = [
+          [ badUUID ],
+          [ badShortUUID ]
+        ]
+
+        for (const uuids of uuidsMatrix) {
+          const search = { search: 'E2E playlist', sort: '-match', uuids }
+          await check(search, false)
+        }
+      }
     })
 
     it('Should have a correct pagination', async function () {
-      const res = await advancedVideoChannelSearch(server.url, { search: 'root', start: 0, count: 2 })
+      const body = await command.advancedChannelSearch({ search: { search: 'root', start: 0, count: 2 } })
 
-      expect(res.body.total).to.be.greaterThan(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      expect(body.total).to.be.greaterThan(2)
+      expect(body.data).to.have.lengthOf(2)
     })
   })
 
diff --git a/server/tests/api/search/search-playlists.ts b/server/tests/api/search/search-playlists.ts
index ab17d55e9..15aac029a 100644
--- a/server/tests/api/search/search-playlists.ts
+++ b/server/tests/api/search/search-playlists.ts
@@ -2,82 +2,86 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { VideoPlaylist, VideoPlaylistPrivacy } from '@shared/models'
 import {
-  addVideoInPlaylist,
-  advancedVideoPlaylistSearch,
   cleanupTests,
-  createVideoPlaylist,
-  flushAndRunServer,
-  searchVideoPlaylists,
-  ServerInfo,
+  createSingleServer,
+  doubleFollow,
+  PeerTubeServer,
+  SearchCommand,
   setAccessTokensToServers,
-  setDefaultVideoChannel,
-  uploadVideoAndGetId
-} from '../../../../shared/extra-utils'
+  setDefaultVideoChannel
+} from '@shared/extra-utils'
+import { VideoPlaylistPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test playlists search', function () {
-  let server: ServerInfo = null
+  let server: PeerTubeServer
+  let remoteServer: PeerTubeServer
+  let command: SearchCommand
+  let playlistUUID: string
+  let playlistShortUUID: string
 
   before(async function () {
-    this.timeout(30000)
+    this.timeout(120000)
 
-    server = await flushAndRunServer(1)
+    const servers = await Promise.all([
+      createSingleServer(1),
+      createSingleServer(2, { transcoding: { enabled: false } })
+    ])
+    server = servers[0]
+    remoteServer = servers[1]
 
-    await setAccessTokensToServers([ server ])
-    await setDefaultVideoChannel([ server ])
-
-    const videoId = (await uploadVideoAndGetId({ server: server, videoName: 'video' })).uuid
+    await setAccessTokensToServers([ remoteServer, server ])
+    await setDefaultVideoChannel([ remoteServer, server ])
 
     {
+      const videoId = (await server.videos.upload()).uuid
+
       const attributes = {
         displayName: 'Dr. Kenzo Tenma hospital videos',
         privacy: VideoPlaylistPrivacy.PUBLIC,
-        videoChannelId: server.videoChannel.id
+        videoChannelId: server.store.channel.id
       }
-      const res = await createVideoPlaylist({ url: server.url, token: server.accessToken, playlistAttrs: attributes })
-
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: res.body.videoPlaylist.id,
-        elementAttrs: { videoId }
-      })
+      const created = await server.playlists.create({ attributes })
+      playlistUUID = created.uuid
+      playlistShortUUID = created.shortUUID
+
+      await server.playlists.addElement({ playlistId: created.id, attributes: { videoId } })
     }
 
     {
+      const videoId = (await remoteServer.videos.upload()).uuid
+
       const attributes = {
-        displayName: 'Johan & Anna Libert musics',
+        displayName: 'Johan & Anna Libert music videos',
         privacy: VideoPlaylistPrivacy.PUBLIC,
-        videoChannelId: server.videoChannel.id
+        videoChannelId: remoteServer.store.channel.id
       }
-      const res = await createVideoPlaylist({ url: server.url, token: server.accessToken, playlistAttrs: attributes })
-
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: res.body.videoPlaylist.id,
-        elementAttrs: { videoId }
-      })
+      const created = await remoteServer.playlists.create({ attributes })
+
+      await remoteServer.playlists.addElement({ playlistId: created.id, attributes: { videoId } })
     }
 
     {
       const attributes = {
         displayName: 'Inspector Lunge playlist',
         privacy: VideoPlaylistPrivacy.PUBLIC,
-        videoChannelId: server.videoChannel.id
+        videoChannelId: server.store.channel.id
       }
-      await createVideoPlaylist({ url: server.url, token: server.accessToken, playlistAttrs: attributes })
+      await server.playlists.create({ attributes })
     }
+
+    await doubleFollow(server, remoteServer)
+
+    command = server.search
   })
 
   it('Should make a simple search and not have results', async function () {
-    const res = await searchVideoPlaylists(server.url, 'abc')
+    const body = await command.searchPlaylists({ search: 'abc' })
 
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   it('Should make a search and have results', async function () {
@@ -87,27 +91,72 @@ describe('Test playlists search', function () {
         start: 0,
         count: 1
       }
-      const res = await advancedVideoPlaylistSearch(server.url, search)
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      const body = await command.advancedPlaylistSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
 
-      const playlist: VideoPlaylist = res.body.data[0]
+      const playlist = body.data[0]
       expect(playlist.displayName).to.equal('Dr. Kenzo Tenma hospital videos')
       expect(playlist.url).to.equal(server.url + '/video-playlists/' + playlist.uuid)
     }
 
     {
       const search = {
-        search: 'Anna Livert',
+        search: 'Anna Livert music',
         start: 0,
         count: 1
       }
-      const res = await advancedVideoPlaylistSearch(server.url, search)
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      const body = await command.advancedPlaylistSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+
+      const playlist = body.data[0]
+      expect(playlist.displayName).to.equal('Johan & Anna Libert music videos')
+    }
+  })
+
+  it('Should filter by host', async function () {
+    {
+      const search = { search: 'tenma', host: server.host }
+      const body = await command.advancedPlaylistSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+
+      const playlist = body.data[0]
+      expect(playlist.displayName).to.equal('Dr. Kenzo Tenma hospital videos')
+    }
+
+    {
+      const search = { search: 'Anna', host: 'example.com' }
+      const body = await command.advancedPlaylistSearch({ search })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+
+    {
+      const search = { search: 'video', host: remoteServer.host }
+      const body = await command.advancedPlaylistSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+
+      const playlist = body.data[0]
+      expect(playlist.displayName).to.equal('Johan & Anna Libert music videos')
+    }
+  })
+
+  it('Should filter by UUIDs', async function () {
+    for (const uuid of [ playlistUUID, playlistShortUUID ]) {
+      const body = await command.advancedPlaylistSearch({ search: { uuids: [ uuid ] } })
+
+      expect(body.total).to.equal(1)
+      expect(body.data[0].displayName).to.equal('Dr. Kenzo Tenma hospital videos')
+    }
+
+    {
+      const body = await command.advancedPlaylistSearch({ search: { uuids: [ 'dfd70b83-639f-4980-94af-304a56ab4b35' ] } })
 
-      const playlist: VideoPlaylist = res.body.data[0]
-      expect(playlist.displayName).to.equal('Johan & Anna Libert musics')
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
     }
   })
 
@@ -117,12 +166,12 @@ describe('Test playlists search', function () {
       start: 0,
       count: 1
     }
-    const res = await advancedVideoPlaylistSearch(server.url, search)
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    const body = await command.advancedPlaylistSearch({ search })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   after(async function () {
-    await cleanupTests([ server ])
+    await cleanupTests([ server, remoteServer ])
   })
 })
diff --git a/server/tests/api/search/search-videos.ts b/server/tests/api/search/search-videos.ts
index 5b8907961..bd1e4d266 100644
--- a/server/tests/api/search/search-videos.ts
+++ b/server/tests/api/search/search-videos.ts
@@ -2,40 +2,42 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { VideoPrivacy } from '@shared/models'
 import {
-  advancedVideosSearch,
   cleanupTests,
-  createLive,
-  flushAndRunServer,
-  immutableAssign,
-  searchVideo,
-  sendRTMPStreamInVideo,
-  ServerInfo,
+  createSingleServer,
+  doubleFollow,
+  PeerTubeServer,
+  SearchCommand,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   stopFfmpeg,
-  updateCustomSubConfig,
-  uploadVideo,
-  wait,
-  waitUntilLivePublished
-} from '../../../../shared/extra-utils'
-import { createVideoCaption } from '../../../../shared/extra-utils/videos/video-captions'
+  wait
+} from '@shared/extra-utils'
+import { VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test videos search', function () {
-  let server: ServerInfo = null
+  let server: PeerTubeServer
+  let remoteServer: PeerTubeServer
   let startDate: string
   let videoUUID: string
+  let videoShortUUID: string
+
+  let command: SearchCommand
 
   before(async function () {
-    this.timeout(60000)
+    this.timeout(120000)
 
-    server = await flushAndRunServer(1)
+    const servers = await Promise.all([
+      createSingleServer(1),
+      createSingleServer(2)
+    ])
+    server = servers[0]
+    remoteServer = servers[1]
 
-    await setAccessTokensToServers([ server ])
-    await setDefaultVideoChannel([ server ])
+    await setAccessTokensToServers([ server, remoteServer ])
+    await setDefaultVideoChannel([ server, remoteServer ])
 
     {
       const attributes1 = {
@@ -46,57 +48,50 @@ describe('Test videos search', function () {
         nsfw: false,
         language: 'fr'
       }
-      await uploadVideo(server.url, server.accessToken, attributes1)
+      await server.videos.upload({ attributes: attributes1 })
 
-      const attributes2 = immutableAssign(attributes1, { name: attributes1.name + ' - 2', fixture: 'video_short.mp4' })
-      await uploadVideo(server.url, server.accessToken, attributes2)
+      const attributes2 = { ...attributes1, name: attributes1.name + ' - 2', fixture: 'video_short.mp4' }
+      await server.videos.upload({ attributes: attributes2 })
 
       {
-        const attributes3 = immutableAssign(attributes1, { name: attributes1.name + ' - 3', language: undefined })
-        const res = await uploadVideo(server.url, server.accessToken, attributes3)
-        const videoId = res.body.video.id
-        videoUUID = res.body.video.uuid
-
-        await createVideoCaption({
-          url: server.url,
-          accessToken: server.accessToken,
+        const attributes3 = { ...attributes1, name: attributes1.name + ' - 3', language: undefined }
+        const { id, uuid, shortUUID } = await server.videos.upload({ attributes: attributes3 })
+        videoUUID = uuid
+        videoShortUUID = shortUUID
+
+        await server.captions.add({
           language: 'en',
-          videoId,
+          videoId: id,
           fixture: 'subtitle-good2.vtt',
           mimeType: 'application/octet-stream'
         })
 
-        await createVideoCaption({
-          url: server.url,
-          accessToken: server.accessToken,
+        await server.captions.add({
           language: 'aa',
-          videoId,
+          videoId: id,
           fixture: 'subtitle-good2.vtt',
           mimeType: 'application/octet-stream'
         })
       }
 
-      const attributes4 = immutableAssign(attributes1, { name: attributes1.name + ' - 4', language: 'pl', nsfw: true })
-      await uploadVideo(server.url, server.accessToken, attributes4)
+      const attributes4 = { ...attributes1, name: attributes1.name + ' - 4', language: 'pl', nsfw: true }
+      await server.videos.upload({ attributes: attributes4 })
 
       await wait(1000)
 
       startDate = new Date().toISOString()
 
-      const attributes5 = immutableAssign(attributes1, { name: attributes1.name + ' - 5', licence: 2, language: undefined })
-      await uploadVideo(server.url, server.accessToken, attributes5)
+      const attributes5 = { ...attributes1, name: attributes1.name + ' - 5', licence: 2, language: undefined }
+      await server.videos.upload({ attributes: attributes5 })
 
-      const attributes6 = immutableAssign(attributes1, { name: attributes1.name + ' - 6', tags: [ 't1', 't2' ] })
-      await uploadVideo(server.url, server.accessToken, attributes6)
+      const attributes6 = { ...attributes1, name: attributes1.name + ' - 6', tags: [ 't1', 't2' ] }
+      await server.videos.upload({ attributes: attributes6 })
 
-      const attributes7 = immutableAssign(attributes1, {
-        name: attributes1.name + ' - 7',
-        originallyPublishedAt: '2019-02-12T09:58:08.286Z'
-      })
-      await uploadVideo(server.url, server.accessToken, attributes7)
+      const attributes7 = { ...attributes1, name: attributes1.name + ' - 7', originallyPublishedAt: '2019-02-12T09:58:08.286Z' }
+      await server.videos.upload({ attributes: attributes7 })
 
-      const attributes8 = immutableAssign(attributes1, { name: attributes1.name + ' - 8', licence: 4 })
-      await uploadVideo(server.url, server.accessToken, attributes8)
+      const attributes8 = { ...attributes1, name: attributes1.name + ' - 8', licence: 4 }
+      await server.videos.upload({ attributes: attributes8 })
     }
 
     {
@@ -107,9 +102,9 @@ describe('Test videos search', function () {
         licence: 2,
         language: 'en'
       }
-      await uploadVideo(server.url, server.accessToken, attributes)
+      await server.videos.upload({ attributes: attributes })
 
-      await uploadVideo(server.url, server.accessToken, immutableAssign(attributes, { name: attributes.name + ' duplicate' }))
+      await server.videos.upload({ attributes: { ...attributes, name: attributes.name + ' duplicate' } })
     }
 
     {
@@ -120,7 +115,7 @@ describe('Test videos search', function () {
         licence: 3,
         language: 'pl'
       }
-      await uploadVideo(server.url, server.accessToken, attributes)
+      await server.videos.upload({ attributes: attributes })
     }
 
     {
@@ -129,11 +124,11 @@ describe('Test videos search', function () {
         tags: [ 'aaaa', 'bbbb', 'cccc' ],
         category: 1
       }
-      await uploadVideo(server.url, server.accessToken, attributes1)
-      await uploadVideo(server.url, server.accessToken, immutableAssign(attributes1, { category: 2 }))
+      await server.videos.upload({ attributes: attributes1 })
+      await server.videos.upload({ attributes: { ...attributes1, category: 2 } })
 
-      await uploadVideo(server.url, server.accessToken, immutableAssign(attributes1, { tags: [ 'cccc', 'dddd' ] }))
-      await uploadVideo(server.url, server.accessToken, immutableAssign(attributes1, { tags: [ 'eeee', 'ffff' ] }))
+      await server.videos.upload({ attributes: { ...attributes1, tags: [ 'cccc', 'dddd' ] } })
+      await server.videos.upload({ attributes: { ...attributes1, tags: [ 'eeee', 'ffff' ] } })
     }
 
     {
@@ -141,24 +136,33 @@ describe('Test videos search', function () {
         name: 'aaaa 2',
         category: 1
       }
-      await uploadVideo(server.url, server.accessToken, attributes1)
-      await uploadVideo(server.url, server.accessToken, immutableAssign(attributes1, { category: 2 }))
+      await server.videos.upload({ attributes: attributes1 })
+      await server.videos.upload({ attributes: { ...attributes1, category: 2 } })
+    }
+
+    {
+      await remoteServer.videos.upload({ attributes: { name: 'remote video 1' } })
+      await remoteServer.videos.upload({ attributes: { name: 'remote video 2' } })
     }
+
+    await doubleFollow(server, remoteServer)
+
+    command = server.search
   })
 
   it('Should make a simple search and not have results', async function () {
-    const res = await searchVideo(server.url, 'abc')
+    const body = await command.searchVideos({ search: 'abc' })
 
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   it('Should make a simple search and have results', async function () {
-    const res = await searchVideo(server.url, '4444 5555 duplicate')
+    const body = await command.searchVideos({ search: '4444 5555 duplicate' })
 
-    expect(res.body.total).to.equal(2)
+    expect(body.total).to.equal(2)
 
-    const videos = res.body.data
+    const videos = body.data
     expect(videos).to.have.lengthOf(2)
 
     // bestmatch
@@ -167,15 +171,15 @@ describe('Test videos search', function () {
   })
 
   it('Should make a search on tags too, and have results', async function () {
-    const query = {
+    const search = {
       search: 'aaaa',
       categoryOneOf: [ 1 ]
     }
-    const res = await advancedVideosSearch(server.url, query)
+    const body = await command.advancedVideoSearch({ search })
 
-    expect(res.body.total).to.equal(2)
+    expect(body.total).to.equal(2)
 
-    const videos = res.body.data
+    const videos = body.data
     expect(videos).to.have.lengthOf(2)
 
     // bestmatch
@@ -184,14 +188,14 @@ describe('Test videos search', function () {
   })
 
   it('Should filter on tags without a search', async function () {
-    const query = {
+    const search = {
       tagsAllOf: [ 'bbbb' ]
     }
-    const res = await advancedVideosSearch(server.url, query)
+    const body = await command.advancedVideoSearch({ search })
 
-    expect(res.body.total).to.equal(2)
+    expect(body.total).to.equal(2)
 
-    const videos = res.body.data
+    const videos = body.data
     expect(videos).to.have.lengthOf(2)
 
     expect(videos[0].name).to.equal('9999')
@@ -199,14 +203,14 @@ describe('Test videos search', function () {
   })
 
   it('Should filter on category without a search', async function () {
-    const query = {
+    const search = {
       categoryOneOf: [ 3 ]
     }
-    const res = await advancedVideosSearch(server.url, query)
+    const body = await command.advancedVideoSearch({ search: search })
 
-    expect(res.body.total).to.equal(1)
+    expect(body.total).to.equal(1)
 
-    const videos = res.body.data
+    const videos = body.data
     expect(videos).to.have.lengthOf(1)
 
     expect(videos[0].name).to.equal('6666 7777 8888')
@@ -218,11 +222,16 @@ describe('Test videos search', function () {
       categoryOneOf: [ 1 ],
       tagsOneOf: [ 'aAaa', 'ffff' ]
     }
-    const res1 = await advancedVideosSearch(server.url, query)
-    expect(res1.body.total).to.equal(2)
 
-    const res2 = await advancedVideosSearch(server.url, immutableAssign(query, { tagsOneOf: [ 'blabla' ] }))
-    expect(res2.body.total).to.equal(0)
+    {
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(2)
+    }
+
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, tagsOneOf: [ 'blabla' ] } })
+      expect(body.total).to.equal(0)
+    }
   })
 
   it('Should search by tags (all of)', async function () {
@@ -231,14 +240,21 @@ describe('Test videos search', function () {
       categoryOneOf: [ 1 ],
       tagsAllOf: [ 'CCcc' ]
     }
-    const res1 = await advancedVideosSearch(server.url, query)
-    expect(res1.body.total).to.equal(2)
 
-    const res2 = await advancedVideosSearch(server.url, immutableAssign(query, { tagsAllOf: [ 'blAbla' ] }))
-    expect(res2.body.total).to.equal(0)
+    {
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(2)
+    }
+
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, tagsAllOf: [ 'blAbla' ] } })
+      expect(body.total).to.equal(0)
+    }
 
-    const res3 = await advancedVideosSearch(server.url, immutableAssign(query, { tagsAllOf: [ 'bbbb', 'CCCC' ] }))
-    expect(res3.body.total).to.equal(1)
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, tagsAllOf: [ 'bbbb', 'CCCC' ] } })
+      expect(body.total).to.equal(1)
+    }
   })
 
   it('Should search by category', async function () {
@@ -246,12 +262,17 @@ describe('Test videos search', function () {
       search: '6666',
       categoryOneOf: [ 3 ]
     }
-    const res1 = await advancedVideosSearch(server.url, query)
-    expect(res1.body.total).to.equal(1)
-    expect(res1.body.data[0].name).to.equal('6666 7777 8888')
 
-    const res2 = await advancedVideosSearch(server.url, immutableAssign(query, { categoryOneOf: [ 2 ] }))
-    expect(res2.body.total).to.equal(0)
+    {
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('6666 7777 8888')
+    }
+
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, categoryOneOf: [ 2 ] } })
+      expect(body.total).to.equal(0)
+    }
   })
 
   it('Should search by licence', async function () {
@@ -259,13 +280,18 @@ describe('Test videos search', function () {
       search: '4444 5555',
       licenceOneOf: [ 2 ]
     }
-    const res1 = await advancedVideosSearch(server.url, query)
-    expect(res1.body.total).to.equal(2)
-    expect(res1.body.data[0].name).to.equal('3333 4444 5555')
-    expect(res1.body.data[1].name).to.equal('3333 4444 5555 duplicate')
 
-    const res2 = await advancedVideosSearch(server.url, immutableAssign(query, { licenceOneOf: [ 3 ] }))
-    expect(res2.body.total).to.equal(0)
+    {
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(2)
+      expect(body.data[0].name).to.equal('3333 4444 5555')
+      expect(body.data[1].name).to.equal('3333 4444 5555 duplicate')
+    }
+
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, licenceOneOf: [ 3 ] } })
+      expect(body.total).to.equal(0)
+    }
   })
 
   it('Should search by languages', async function () {
@@ -275,23 +301,23 @@ describe('Test videos search', function () {
     }
 
     {
-      const res = await advancedVideosSearch(server.url, query)
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data[0].name).to.equal('1111 2222 3333 - 3')
-      expect(res.body.data[1].name).to.equal('1111 2222 3333 - 4')
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(2)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 3')
+      expect(body.data[1].name).to.equal('1111 2222 3333 - 4')
     }
 
     {
-      const res = await advancedVideosSearch(server.url, immutableAssign(query, { languageOneOf: [ 'pl', 'en', '_unknown' ] }))
-      expect(res.body.total).to.equal(3)
-      expect(res.body.data[0].name).to.equal('1111 2222 3333 - 3')
-      expect(res.body.data[1].name).to.equal('1111 2222 3333 - 4')
-      expect(res.body.data[2].name).to.equal('1111 2222 3333 - 5')
+      const body = await command.advancedVideoSearch({ search: { ...query, languageOneOf: [ 'pl', 'en', '_unknown' ] } })
+      expect(body.total).to.equal(3)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 3')
+      expect(body.data[1].name).to.equal('1111 2222 3333 - 4')
+      expect(body.data[2].name).to.equal('1111 2222 3333 - 5')
     }
 
     {
-      const res = await advancedVideosSearch(server.url, immutableAssign(query, { languageOneOf: [ 'eo' ] }))
-      expect(res.body.total).to.equal(0)
+      const body = await command.advancedVideoSearch({ search: { ...query, languageOneOf: [ 'eo' ] } })
+      expect(body.total).to.equal(0)
     }
   })
 
@@ -301,10 +327,10 @@ describe('Test videos search', function () {
       startDate
     }
 
-    const res = await advancedVideosSearch(server.url, query)
-    expect(res.body.total).to.equal(4)
+    const body = await command.advancedVideoSearch({ search: query })
+    expect(body.total).to.equal(4)
 
-    const videos = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('1111 2222 3333 - 5')
     expect(videos[1].name).to.equal('1111 2222 3333 - 6')
     expect(videos[2].name).to.equal('1111 2222 3333 - 7')
@@ -320,10 +346,10 @@ describe('Test videos search', function () {
       licenceOneOf: [ 1, 4 ]
     }
 
-    const res = await advancedVideosSearch(server.url, query)
-    expect(res.body.total).to.equal(4)
+    const body = await command.advancedVideoSearch({ search: query })
+    expect(body.total).to.equal(4)
 
-    const videos = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('1111 2222 3333')
     expect(videos[1].name).to.equal('1111 2222 3333 - 6')
     expect(videos[2].name).to.equal('1111 2222 3333 - 7')
@@ -340,10 +366,10 @@ describe('Test videos search', function () {
       sort: '-name'
     }
 
-    const res = await advancedVideosSearch(server.url, query)
-    expect(res.body.total).to.equal(4)
+    const body = await command.advancedVideoSearch({ search: query })
+    expect(body.total).to.equal(4)
 
-    const videos = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('1111 2222 3333 - 8')
     expect(videos[1].name).to.equal('1111 2222 3333 - 7')
     expect(videos[2].name).to.equal('1111 2222 3333 - 6')
@@ -362,10 +388,10 @@ describe('Test videos search', function () {
       count: 1
     }
 
-    const res = await advancedVideosSearch(server.url, query)
-    expect(res.body.total).to.equal(4)
+    const body = await command.advancedVideoSearch({ search: query })
+    expect(body.total).to.equal(4)
 
-    const videos = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('1111 2222 3333 - 8')
   })
 
@@ -381,10 +407,10 @@ describe('Test videos search', function () {
       count: 1
     }
 
-    const res = await advancedVideosSearch(server.url, query)
-    expect(res.body.total).to.equal(4)
+    const body = await command.advancedVideoSearch({ search: query })
+    expect(body.total).to.equal(4)
 
-    const videos = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('1111 2222 3333')
   })
 
@@ -398,99 +424,140 @@ describe('Test videos search', function () {
     }
 
     {
-      const query = immutableAssign(baseQuery, { originallyPublishedStartDate: '2019-02-11T09:58:08.286Z' })
-      const res = await advancedVideosSearch(server.url, query)
+      const query = { ...baseQuery, originallyPublishedStartDate: '2019-02-11T09:58:08.286Z' }
+      const body = await command.advancedVideoSearch({ search: query })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data[0].name).to.equal('1111 2222 3333 - 7')
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 7')
     }
 
     {
-      const query = immutableAssign(baseQuery, { originallyPublishedEndDate: '2019-03-11T09:58:08.286Z' })
-      const res = await advancedVideosSearch(server.url, query)
+      const query = { ...baseQuery, originallyPublishedEndDate: '2019-03-11T09:58:08.286Z' }
+      const body = await command.advancedVideoSearch({ search: query })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data[0].name).to.equal('1111 2222 3333 - 7')
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 7')
     }
 
     {
-      const query = immutableAssign(baseQuery, { originallyPublishedEndDate: '2019-01-11T09:58:08.286Z' })
-      const res = await advancedVideosSearch(server.url, query)
+      const query = { ...baseQuery, originallyPublishedEndDate: '2019-01-11T09:58:08.286Z' }
+      const body = await command.advancedVideoSearch({ search: query })
 
-      expect(res.body.total).to.equal(0)
+      expect(body.total).to.equal(0)
     }
 
     {
-      const query = immutableAssign(baseQuery, { originallyPublishedStartDate: '2019-03-11T09:58:08.286Z' })
-      const res = await advancedVideosSearch(server.url, query)
+      const query = { ...baseQuery, originallyPublishedStartDate: '2019-03-11T09:58:08.286Z' }
+      const body = await command.advancedVideoSearch({ search: query })
 
-      expect(res.body.total).to.equal(0)
+      expect(body.total).to.equal(0)
     }
 
     {
-      const query = immutableAssign(baseQuery, {
+      const query = {
+        ...baseQuery,
         originallyPublishedStartDate: '2019-01-11T09:58:08.286Z',
         originallyPublishedEndDate: '2019-01-10T09:58:08.286Z'
-      })
-      const res = await advancedVideosSearch(server.url, query)
+      }
+      const body = await command.advancedVideoSearch({ search: query })
 
-      expect(res.body.total).to.equal(0)
+      expect(body.total).to.equal(0)
     }
 
     {
-      const query = immutableAssign(baseQuery, {
+      const query = {
+        ...baseQuery,
         originallyPublishedStartDate: '2019-01-11T09:58:08.286Z',
         originallyPublishedEndDate: '2019-04-11T09:58:08.286Z'
-      })
-      const res = await advancedVideosSearch(server.url, query)
+      }
+      const body = await command.advancedVideoSearch({ search: query })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data[0].name).to.equal('1111 2222 3333 - 7')
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 7')
     }
   })
 
   it('Should search by UUID', async function () {
     const search = videoUUID
-    const res = await advancedVideosSearch(server.url, { search })
+    const body = await command.advancedVideoSearch({ search: { search } })
+
+    expect(body.total).to.equal(1)
+    expect(body.data[0].name).to.equal('1111 2222 3333 - 3')
+  })
+
+  it('Should filter by UUIDs', async function () {
+    for (const uuid of [ videoUUID, videoShortUUID ]) {
+      const body = await command.advancedVideoSearch({ search: { uuids: [ uuid ] } })
+
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 3')
+    }
+
+    {
+      const body = await command.advancedVideoSearch({ search: { uuids: [ 'dfd70b83-639f-4980-94af-304a56ab4b35' ] } })
+
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+  })
+
+  it('Should search by host', async function () {
+    {
+      const body = await command.advancedVideoSearch({ search: { search: '6666 7777 8888', host: server.host } })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('6666 7777 8888')
+    }
 
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data[0].name).to.equal('1111 2222 3333 - 3')
+    {
+      const body = await command.advancedVideoSearch({ search: { search: '1111', host: 'example.com' } })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+
+    {
+      const body = await command.advancedVideoSearch({ search: { search: 'remote', host: remoteServer.host } })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
+      expect(body.data[0].name).to.equal('remote video 1')
+      expect(body.data[1].name).to.equal('remote video 2')
+    }
   })
 
   it('Should search by live', async function () {
-    this.timeout(30000)
+    this.timeout(60000)
 
     {
-      const options = {
+      const newConfig = {
         search: {
           searchIndex: { enabled: false }
         },
         live: { enabled: true }
       }
-      await updateCustomSubConfig(server.url, server.accessToken, options)
+      await server.config.updateCustomSubConfig({ newConfig })
     }
 
     {
-      const res = await advancedVideosSearch(server.url, { isLive: true })
+      const body = await command.advancedVideoSearch({ search: { isLive: true } })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
     }
 
     {
-      const liveOptions = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: server.videoChannel.id }
-      const resLive = await createLive(server.url, server.accessToken, liveOptions)
-      const liveVideoId = resLive.body.video.uuid
+      const liveCommand = server.live
+
+      const liveAttributes = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: server.store.channel.id }
+      const live = await liveCommand.create({ fields: liveAttributes })
 
-      const command = await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId)
-      await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
+      const ffmpegCommand = await liveCommand.sendRTMPStreamInVideo({ videoId: live.id })
+      await liveCommand.waitUntilPublished({ videoId: live.id })
 
-      const res = await advancedVideosSearch(server.url, { isLive: true })
+      const body = await command.advancedVideoSearch({ search: { isLive: true } })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data[0].name).to.equal('live')
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('live')
 
-      await stopFfmpeg(command)
+      await stopFfmpeg(ffmpegCommand)
     }
   })
 
diff --git a/server/tests/api/server/auto-follows.ts b/server/tests/api/server/auto-follows.ts
index 1519b263f..ce7b51925 100644
--- a/server/tests/api/server/auto-follows.ts
+++ b/server/tests/api/server/auto-follows.ts
@@ -3,64 +3,45 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  acceptFollower,
   cleanupTests,
-  flushAndRunMultipleServers,
+  createMultipleServers,
   MockInstancesIndex,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  unfollow,
-  updateCustomSubConfig,
-  wait
-} from '../../../../shared/extra-utils/index'
-import { follow, getFollowersListPaginationAndSort, getFollowingListPaginationAndSort } from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { ActorFollow } from '../../../../shared/models/actors'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
-async function checkFollow (follower: ServerInfo, following: ServerInfo, exists: boolean) {
+async function checkFollow (follower: PeerTubeServer, following: PeerTubeServer, exists: boolean) {
   {
-    const res = await getFollowersListPaginationAndSort({ url: following.url, start: 0, count: 5, sort: '-createdAt' })
-    const follows = res.body.data as ActorFollow[]
+    const body = await following.follows.getFollowers({ start: 0, count: 5, sort: '-createdAt' })
+    const follow = body.data.find(f => f.follower.host === follower.host && f.state === 'accepted')
 
-    const follow = follows.find(f => {
-      return f.follower.host === follower.host && f.state === 'accepted'
-    })
-
-    if (exists === true) {
-      expect(follow).to.exist
-    } else {
-      expect(follow).to.be.undefined
-    }
+    if (exists === true) expect(follow).to.exist
+    else expect(follow).to.be.undefined
   }
 
   {
-    const res = await getFollowingListPaginationAndSort({ url: follower.url, start: 0, count: 5, sort: '-createdAt' })
-    const follows = res.body.data as ActorFollow[]
-
-    const follow = follows.find(f => {
-      return f.following.host === following.host && f.state === 'accepted'
-    })
+    const body = await follower.follows.getFollowings({ start: 0, count: 5, sort: '-createdAt' })
+    const follow = body.data.find(f => f.following.host === following.host && f.state === 'accepted')
 
-    if (exists === true) {
-      expect(follow).to.exist
-    } else {
-      expect(follow).to.be.undefined
-    }
+    if (exists === true) expect(follow).to.exist
+    else expect(follow).to.be.undefined
   }
 }
 
-async function server1Follows2 (servers: ServerInfo[]) {
-  await follow(servers[0].url, [ servers[1].host ], servers[0].accessToken)
+async function server1Follows2 (servers: PeerTubeServer[]) {
+  await servers[0].follows.follow({ hosts: [ servers[1].host ] })
 
   await waitJobs(servers)
 }
 
-async function resetFollows (servers: ServerInfo[]) {
+async function resetFollows (servers: PeerTubeServer[]) {
   try {
-    await unfollow(servers[0].url, servers[0].accessToken, servers[1])
-    await unfollow(servers[1].url, servers[1].accessToken, servers[0])
+    await servers[0].follows.unfollow({ target: servers[1] })
+    await servers[1].follows.unfollow({ target: servers[0] })
   } catch { /* empty */
   }
 
@@ -71,12 +52,12 @@ async function resetFollows (servers: ServerInfo[]) {
 }
 
 describe('Test auto follows', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
 
   before(async function () {
     this.timeout(30000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -105,7 +86,7 @@ describe('Test auto follows', function () {
           }
         }
       }
-      await updateCustomSubConfig(servers[1].url, servers[1].accessToken, config)
+      await servers[1].config.updateCustomSubConfig({ newConfig: config })
 
       await server1Follows2(servers)
 
@@ -130,14 +111,14 @@ describe('Test auto follows', function () {
           }
         }
       }
-      await updateCustomSubConfig(servers[1].url, servers[1].accessToken, config)
+      await servers[1].config.updateCustomSubConfig({ newConfig: config })
 
       await server1Follows2(servers)
 
       await checkFollow(servers[0], servers[1], false)
       await checkFollow(servers[1], servers[0], false)
 
-      await acceptFollower(servers[1].url, servers[1].accessToken, 'peertube@' + servers[0].host)
+      await servers[1].follows.acceptFollower({ follower: 'peertube@' + servers[0].host })
       await waitJobs(servers)
 
       await checkFollow(servers[0], servers[1], true)
@@ -147,7 +128,7 @@ describe('Test auto follows', function () {
 
       config.followings.instance.autoFollowBack.enabled = false
       config.followers.instance.manualApproval = false
-      await updateCustomSubConfig(servers[1].url, servers[1].accessToken, config)
+      await servers[1].config.updateCustomSubConfig({ newConfig: config })
     })
   })
 
@@ -184,7 +165,7 @@ describe('Test auto follows', function () {
           }
         }
       }
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
+      await servers[0].config.updateCustomSubConfig({ newConfig: config })
 
       await wait(5000)
       await waitJobs(servers)
diff --git a/server/tests/api/server/bulk.ts b/server/tests/api/server/bulk.ts
index 80fa7fce6..16cbcd5c3 100644
--- a/server/tests/api/server/bulk.ts
+++ b/server/tests/api/server/bulk.ts
@@ -2,91 +2,83 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { Video, VideoComment } from '@shared/models'
 import {
-  addVideoCommentReply,
-  addVideoCommentThread,
-  bulkRemoveCommentsOf,
+  BulkCommand,
   cleanupTests,
-  createUser,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getVideoCommentThreads,
-  getVideosList,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  uploadVideo,
-  userLogin,
   waitJobs
-} from '../../../../shared/extra-utils/index'
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test bulk actions', function () {
   const commentsUser3: { videoId: number, commentId: number }[] = []
 
-  let servers: ServerInfo[] = []
-  let user1AccessToken: string
-  let user2AccessToken: string
-  let user3AccessToken: string
+  let servers: PeerTubeServer[] = []
+  let user1Token: string
+  let user2Token: string
+  let user3Token: string
+
+  let bulkCommand: BulkCommand
 
   before(async function () {
     this.timeout(30000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
 
     {
       const user = { username: 'user1', password: 'password' }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      user1AccessToken = await userLogin(servers[0], user)
+      user1Token = await servers[0].login.getAccessToken(user)
     }
 
     {
       const user = { username: 'user2', password: 'password' }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
 
-      user2AccessToken = await userLogin(servers[0], user)
+      user2Token = await servers[0].login.getAccessToken(user)
     }
 
     {
       const user = { username: 'user3', password: 'password' }
-      await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
+      await servers[1].users.create({ username: user.username, password: user.password })
 
-      user3AccessToken = await userLogin(servers[1], user)
+      user3Token = await servers[1].login.getAccessToken(user)
     }
 
     await doubleFollow(servers[0], servers[1])
+
+    bulkCommand = new BulkCommand(servers[0])
   })
 
   describe('Bulk remove comments', function () {
     async function checkInstanceCommentsRemoved () {
       {
-        const res = await getVideosList(servers[0].url)
-        const videos = res.body.data as Video[]
+        const { data } = await servers[0].videos.list()
 
         // Server 1 should not have these comments anymore
-        for (const video of videos) {
-          const resThreads = await getVideoCommentThreads(servers[0].url, video.id, 0, 10)
-          const comments = resThreads.body.data as VideoComment[]
-          const comment = comments.find(c => c.text === 'comment by user 3')
+        for (const video of data) {
+          const { data } = await servers[0].comments.listThreads({ videoId: video.id })
+          const comment = data.find(c => c.text === 'comment by user 3')
 
           expect(comment).to.not.exist
         }
       }
 
       {
-        const res = await getVideosList(servers[1].url)
-        const videos = res.body.data as Video[]
+        const { data } = await servers[1].videos.list()
 
         // Server 1 should not have these comments on videos of server 1
-        for (const video of videos) {
-          const resThreads = await getVideoCommentThreads(servers[1].url, video.id, 0, 10)
-          const comments = resThreads.body.data as VideoComment[]
-          const comment = comments.find(c => c.text === 'comment by user 3')
+        for (const video of data) {
+          const { data } = await servers[1].comments.listThreads({ videoId: video.id })
+          const comment = data.find(c => c.text === 'comment by user 3')
 
           if (video.account.host === 'localhost:' + servers[0].port) {
             expect(comment).to.not.exist
@@ -100,30 +92,31 @@ describe('Test bulk actions', function () {
     before(async function () {
       this.timeout(120000)
 
-      await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video 1 server 1' })
-      await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video 2 server 1' })
-      await uploadVideo(servers[0].url, user1AccessToken, { name: 'video 3 server 1' })
+      await servers[0].videos.upload({ attributes: { name: 'video 1 server 1' } })
+      await servers[0].videos.upload({ attributes: { name: 'video 2 server 1' } })
+      await servers[0].videos.upload({ token: user1Token, attributes: { name: 'video 3 server 1' } })
 
-      await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video 1 server 2' })
+      await servers[1].videos.upload({ attributes: { name: 'video 1 server 2' } })
 
       await waitJobs(servers)
 
       {
-        const res = await getVideosList(servers[0].url)
-        for (const video of res.body.data) {
-          await addVideoCommentThread(servers[0].url, servers[0].accessToken, video.id, 'comment by root server 1')
-          await addVideoCommentThread(servers[0].url, user1AccessToken, video.id, 'comment by user 1')
-          await addVideoCommentThread(servers[0].url, user2AccessToken, video.id, 'comment by user 2')
+        const { data } = await servers[0].videos.list()
+        for (const video of data) {
+          await servers[0].comments.createThread({ videoId: video.id, text: 'comment by root server 1' })
+          await servers[0].comments.createThread({ token: user1Token, videoId: video.id, text: 'comment by user 1' })
+          await servers[0].comments.createThread({ token: user2Token, videoId: video.id, text: 'comment by user 2' })
         }
       }
 
       {
-        const res = await getVideosList(servers[1].url)
-        for (const video of res.body.data) {
-          await addVideoCommentThread(servers[1].url, servers[1].accessToken, video.id, 'comment by root server 2')
+        const { data } = await servers[1].videos.list()
 
-          const res = await addVideoCommentThread(servers[1].url, user3AccessToken, video.id, 'comment by user 3')
-          commentsUser3.push({ videoId: video.id, commentId: res.body.comment.id })
+        for (const video of data) {
+          await servers[1].comments.createThread({ videoId: video.id, text: 'comment by root server 2' })
+
+          const comment = await servers[1].comments.createThread({ token: user3Token, videoId: video.id, text: 'comment by user 3' })
+          commentsUser3.push({ videoId: video.id, commentId: comment.id })
         }
       }
 
@@ -133,9 +126,8 @@ describe('Test bulk actions', function () {
     it('Should delete comments of an account on my videos', async function () {
       this.timeout(60000)
 
-      await bulkRemoveCommentsOf({
-        url: servers[0].url,
-        token: user1AccessToken,
+      await bulkCommand.removeCommentsOf({
+        token: user1Token,
         attributes: {
           accountName: 'user2',
           scope: 'my-videos'
@@ -145,18 +137,14 @@ describe('Test bulk actions', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        for (const video of res.body.data) {
-          const resThreads = await getVideoCommentThreads(server.url, video.id, 0, 10)
-          const comments = resThreads.body.data as VideoComment[]
-          const comment = comments.find(c => c.text === 'comment by user 2')
+        for (const video of data) {
+          const { data } = await server.comments.listThreads({ videoId: video.id })
+          const comment = data.find(c => c.text === 'comment by user 2')
 
-          if (video.name === 'video 3 server 1') {
-            expect(comment).to.not.exist
-          } else {
-            expect(comment).to.exist
-          }
+          if (video.name === 'video 3 server 1') expect(comment).to.not.exist
+          else expect(comment).to.exist
         }
       }
     })
@@ -164,9 +152,7 @@ describe('Test bulk actions', function () {
     it('Should delete comments of an account on the instance', async function () {
       this.timeout(60000)
 
-      await bulkRemoveCommentsOf({
-        url: servers[0].url,
-        token: servers[0].accessToken,
+      await bulkCommand.removeCommentsOf({
         attributes: {
           accountName: 'user3@localhost:' + servers[1].port,
           scope: 'instance'
@@ -182,7 +168,12 @@ describe('Test bulk actions', function () {
       this.timeout(60000)
 
       for (const obj of commentsUser3) {
-        await addVideoCommentReply(servers[1].url, user3AccessToken, obj.videoId, obj.commentId, 'comment by user 3 bis')
+        await servers[1].comments.addReply({
+          token: user3Token,
+          videoId: obj.videoId,
+          toCommentId: obj.commentId,
+          text: 'comment by user 3 bis'
+        })
       }
 
       await waitJobs(servers)
diff --git a/server/tests/api/server/config.ts b/server/tests/api/server/config.ts
index 19bf9582c..fd61e95df 100644
--- a/server/tests/api/server/config.ts
+++ b/server/tests/api/server/config.ts
@@ -2,31 +2,20 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { About } from '../../../../shared/models/server/about.model'
-import { CustomConfig } from '../../../../shared/models/server/custom-config.model'
 import {
   cleanupTests,
-  deleteCustomConfig,
-  flushAndRunServer,
-  getAbout,
-  getConfig,
-  getCustomConfig,
+  createSingleServer,
   killallServers,
   makeGetRequest,
   parallelTests,
-  registerUser,
-  reRunServer,
-  ServerInfo,
-  setAccessTokensToServers,
-  updateCustomConfig,
-  uploadVideo
-} from '../../../../shared/extra-utils'
-import { ServerConfig } from '../../../../shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { CustomConfig, HttpStatusCode } from '@shared/models'
 
 const expect = chai.expect
 
-function checkInitialConfig (server: ServerInfo, data: CustomConfig) {
+function checkInitialConfig (server: PeerTubeServer, data: CustomConfig) {
   expect(data.instance.name).to.equal('PeerTube')
   expect(data.instance.shortDescription).to.equal(
     'PeerTube, an ActivityPub-federated video streaming platform using P2P directly in your web browser.'
@@ -213,18 +202,17 @@ function checkUpdatedConfig (data: CustomConfig) {
 }
 
 describe('Test config', function () {
-  let server = null
+  let server: PeerTubeServer = null
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
   })
 
   it('Should have a correct config on a server with registration enabled', async function () {
-    const res = await getConfig(server.url)
-    const data: ServerConfig = res.body
+    const data = await server.config.getConfig()
 
     expect(data.signup.allowed).to.be.true
   })
@@ -233,35 +221,32 @@ describe('Test config', function () {
     this.timeout(5000)
 
     await Promise.all([
-      registerUser(server.url, 'user1', 'super password'),
-      registerUser(server.url, 'user2', 'super password'),
-      registerUser(server.url, 'user3', 'super password')
+      server.users.register({ username: 'user1' }),
+      server.users.register({ username: 'user2' }),
+      server.users.register({ username: 'user3' })
     ])
 
-    const res = await getConfig(server.url)
-    const data: ServerConfig = res.body
+    const data = await server.config.getConfig()
 
     expect(data.signup.allowed).to.be.false
   })
 
   it('Should have the correct video allowed extensions', async function () {
-    const res = await getConfig(server.url)
-    const data: ServerConfig = res.body
+    const data = await server.config.getConfig()
 
     expect(data.video.file.extensions).to.have.lengthOf(3)
     expect(data.video.file.extensions).to.contain('.mp4')
     expect(data.video.file.extensions).to.contain('.webm')
     expect(data.video.file.extensions).to.contain('.ogv')
 
-    await uploadVideo(server.url, server.accessToken, { fixture: 'video_short.mkv' }, HttpStatusCode.UNSUPPORTED_MEDIA_TYPE_415)
-    await uploadVideo(server.url, server.accessToken, { fixture: 'sample.ogg' }, HttpStatusCode.UNSUPPORTED_MEDIA_TYPE_415)
+    await server.videos.upload({ attributes: { fixture: 'video_short.mkv' }, expectedStatus: HttpStatusCode.UNSUPPORTED_MEDIA_TYPE_415 })
+    await server.videos.upload({ attributes: { fixture: 'sample.ogg' }, expectedStatus: HttpStatusCode.UNSUPPORTED_MEDIA_TYPE_415 })
 
     expect(data.contactForm.enabled).to.be.true
   })
 
   it('Should get the customized configuration', async function () {
-    const res = await getCustomConfig(server.url, server.accessToken)
-    const data = res.body as CustomConfig
+    const data = await server.config.getCustomConfig()
 
     checkInitialConfig(server, data)
   })
@@ -438,19 +423,16 @@ describe('Test config', function () {
         }
       }
     }
-    await updateCustomConfig(server.url, server.accessToken, newCustomConfig)
-
-    const res = await getCustomConfig(server.url, server.accessToken)
-    const data = res.body
+    await server.config.updateCustomConfig({ newCustomConfig })
 
+    const data = await server.config.getCustomConfig()
     checkUpdatedConfig(data)
   })
 
   it('Should have the correct updated video allowed extensions', async function () {
     this.timeout(10000)
 
-    const res = await getConfig(server.url)
-    const data: ServerConfig = res.body
+    const data = await server.config.getConfig()
 
     expect(data.video.file.extensions).to.have.length.above(4)
     expect(data.video.file.extensions).to.contain('.mp4')
@@ -463,26 +445,24 @@ describe('Test config', function () {
     expect(data.video.file.extensions).to.contain('.ogg')
     expect(data.video.file.extensions).to.contain('.flac')
 
-    await uploadVideo(server.url, server.accessToken, { fixture: 'video_short.mkv' }, HttpStatusCode.OK_200)
-    await uploadVideo(server.url, server.accessToken, { fixture: 'sample.ogg' }, HttpStatusCode.OK_200)
+    await server.videos.upload({ attributes: { fixture: 'video_short.mkv' }, expectedStatus: HttpStatusCode.OK_200 })
+    await server.videos.upload({ attributes: { fixture: 'sample.ogg' }, expectedStatus: HttpStatusCode.OK_200 })
   })
 
   it('Should have the configuration updated after a restart', async function () {
     this.timeout(10000)
 
-    killallServers([ server ])
+    await killallServers([ server ])
 
-    await reRunServer(server)
+    await server.run()
 
-    const res = await getCustomConfig(server.url, server.accessToken)
-    const data = res.body
+    const data = await server.config.getCustomConfig()
 
     checkUpdatedConfig(data)
   })
 
   it('Should fetch the about information', async function () {
-    const res = await getAbout(server.url)
-    const data: About = res.body
+    const data = await server.config.getAbout()
 
     expect(data.instance.name).to.equal('PeerTube updated')
     expect(data.instance.shortDescription).to.equal('my short description')
@@ -504,11 +484,9 @@ describe('Test config', function () {
   it('Should remove the custom configuration', async function () {
     this.timeout(10000)
 
-    await deleteCustomConfig(server.url, server.accessToken)
-
-    const res = await getCustomConfig(server.url, server.accessToken)
-    const data = res.body
+    await server.config.deleteCustomConfig()
 
+    const data = await server.config.getCustomConfig()
     checkInitialConfig(server, data)
   })
 
@@ -519,26 +497,26 @@ describe('Test config', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/api/v1/config',
-        statusCodeExpected: 200
+        expectedStatus: 200
       })
 
       expect(res.headers['x-frame-options']).to.exist
     }
 
-    killallServers([ server ])
+    await killallServers([ server ])
 
     const config = {
       security: {
         frameguard: { enabled: false }
       }
     }
-    server = await reRunServer(server, config)
+    await server.run(config)
 
     {
       const res = await makeGetRequest({
         url: server.url,
         path: '/api/v1/config',
-        statusCodeExpected: 200
+        expectedStatus: 200
       })
 
       expect(res.headers['x-frame-options']).to.not.exist
diff --git a/server/tests/api/server/contact-form.ts b/server/tests/api/server/contact-form.ts
index 8851ad55e..c555661ad 100644
--- a/server/tests/api/server/contact-form.ts
+++ b/server/tests/api/server/contact-form.ts
@@ -1,18 +1,25 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import { cleanupTests, flushAndRunServer, ServerInfo, setAccessTokensToServers, wait } from '../../../../shared/extra-utils'
-import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { sendContactForm } from '../../../../shared/extra-utils/server/contact-form'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import * as chai from 'chai'
+import {
+  cleanupTests,
+  ContactFormCommand,
+  createSingleServer,
+  MockSmtpServer,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test contact form', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   const emails: object[] = []
+  let command: ContactFormCommand
 
   before(async function () {
     this.timeout(30000)
@@ -25,15 +32,16 @@ describe('Test contact form', function () {
         port
       }
     }
-    server = await flushAndRunServer(1, overrideConfig)
+    server = await createSingleServer(1, overrideConfig)
     await setAccessTokensToServers([ server ])
+
+    command = server.contactForm
   })
 
   it('Should send a contact form', async function () {
     this.timeout(10000)
 
-    await sendContactForm({
-      url: server.url,
+    await command.send({
       fromEmail: 'toto@example.com',
       body: 'my super message',
       subject: 'my subject',
@@ -58,16 +66,14 @@ describe('Test contact form', function () {
 
     await wait(1000)
 
-    await sendContactForm({
-      url: server.url,
+    await command.send({
       fromEmail: 'toto@example.com',
       body: 'my super message',
       subject: 'my subject',
       fromName: 'Super toto'
     })
 
-    await sendContactForm({
-      url: server.url,
+    await command.send({
       fromEmail: 'toto@example.com',
       body: 'my super message',
       fromName: 'Super toto',
@@ -79,8 +85,7 @@ describe('Test contact form', function () {
   it('Should be able to send another contact form after a while', async function () {
     await wait(1000)
 
-    await sendContactForm({
-      url: server.url,
+    await command.send({
       fromEmail: 'toto@example.com',
       fromName: 'Super toto',
       subject: 'my subject',
diff --git a/server/tests/api/server/email.ts b/server/tests/api/server/email.ts
index 92768d9df..5f97edbc2 100644
--- a/server/tests/api/server/email.ts
+++ b/server/tests/api/server/email.ts
@@ -2,37 +2,18 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import {
-  addVideoToBlacklist,
-  askResetPassword,
-  askSendVerifyEmail,
-  blockUser,
-  cleanupTests,
-  createUser,
-  flushAndRunServer,
-  removeVideoFromBlacklist,
-  reportAbuse,
-  resetPassword,
-  ServerInfo,
-  setAccessTokensToServers,
-  unblockUser,
-  uploadVideo,
-  userLogin,
-  verifyEmail
-} from '../../../../shared/extra-utils'
-import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { cleanupTests, createSingleServer, MockSmtpServer, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test emails', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userId: number
   let userId2: number
   let userAccessToken: string
 
-  let videoUUID: string
+  let videoShortUUID: string
   let videoId: number
 
   let videoUserUUID: string
@@ -58,31 +39,29 @@ describe('Test emails', function () {
         port: emailPort
       }
     }
-    server = await flushAndRunServer(1, overrideConfig)
+    server = await createSingleServer(1, overrideConfig)
     await setAccessTokensToServers([ server ])
 
     {
-      const res = await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-      userId = res.body.user.id
+      const created = await server.users.create({ username: user.username, password: user.password })
+      userId = created.id
 
-      userAccessToken = await userLogin(server, user)
+      userAccessToken = await server.login.getAccessToken(user)
     }
 
     {
-      const attributes = {
-        name: 'my super user video'
-      }
-      const res = await uploadVideo(server.url, userAccessToken, attributes)
-      videoUserUUID = res.body.video.uuid
+      const attributes = { name: 'my super user video' }
+      const { uuid } = await server.videos.upload({ token: userAccessToken, attributes })
+      videoUserUUID = uuid
     }
 
     {
       const attributes = {
         name: 'my super name'
       }
-      const res = await uploadVideo(server.url, server.accessToken, attributes)
-      videoUUID = res.body.video.uuid
-      videoId = res.body.video.id
+      const { shortUUID, id } = await server.videos.upload({ attributes })
+      videoShortUUID = shortUUID
+      videoId = id
     }
   })
 
@@ -91,7 +70,7 @@ describe('Test emails', function () {
     it('Should ask to reset the password', async function () {
       this.timeout(10000)
 
-      await askResetPassword(server.url, 'user_1@example.com')
+      await server.users.askResetPassword({ email: 'user_1@example.com' })
 
       await waitJobs(server)
       expect(emails).to.have.lengthOf(1)
@@ -117,34 +96,40 @@ describe('Test emails', function () {
     })
 
     it('Should not reset the password with an invalid verification string', async function () {
-      await resetPassword(server.url, userId, verificationString + 'b', 'super_password2', HttpStatusCode.FORBIDDEN_403)
+      await server.users.resetPassword({
+        userId,
+        verificationString: verificationString + 'b',
+        password: 'super_password2',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
     })
 
     it('Should reset the password', async function () {
-      await resetPassword(server.url, userId, verificationString, 'super_password2')
+      await server.users.resetPassword({ userId, verificationString, password: 'super_password2' })
     })
 
     it('Should not reset the password with the same verification string', async function () {
-      await resetPassword(server.url, userId, verificationString, 'super_password3', HttpStatusCode.FORBIDDEN_403)
+      await server.users.resetPassword({
+        userId,
+        verificationString,
+        password: 'super_password3',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
     })
 
     it('Should login with this new password', async function () {
       user.password = 'super_password2'
 
-      await userLogin(server, user)
+      await server.login.getAccessToken(user)
     })
   })
 
   describe('When creating a user without password', function () {
+
     it('Should send a create password email', async function () {
       this.timeout(10000)
 
-      await createUser({
-        url: server.url,
-        accessToken: server.accessToken,
-        username: 'create_password',
-        password: ''
-      })
+      await server.users.create({ username: 'create_password', password: '' })
 
       await waitJobs(server)
       expect(emails).to.have.lengthOf(2)
@@ -170,15 +155,24 @@ describe('Test emails', function () {
     })
 
     it('Should not reset the password with an invalid verification string', async function () {
-      await resetPassword(server.url, userId2, verificationString2 + 'c', 'newly_created_password', HttpStatusCode.FORBIDDEN_403)
+      await server.users.resetPassword({
+        userId: userId2,
+        verificationString: verificationString2 + 'c',
+        password: 'newly_created_password',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
     })
 
     it('Should reset the password', async function () {
-      await resetPassword(server.url, userId2, verificationString2, 'newly_created_password')
+      await server.users.resetPassword({
+        userId: userId2,
+        verificationString: verificationString2,
+        password: 'newly_created_password'
+      })
     })
 
     it('Should login with this new password', async function () {
-      await userLogin(server, {
+      await server.login.getAccessToken({
         username: 'create_password',
         password: 'newly_created_password'
       })
@@ -186,11 +180,12 @@ describe('Test emails', function () {
   })
 
   describe('When creating an abuse', function () {
+
     it('Should send the notification email', async function () {
       this.timeout(10000)
 
       const reason = 'my super bad reason'
-      await reportAbuse({ url: server.url, token: server.accessToken, videoId, reason })
+      await server.abuses.report({ videoId, reason })
 
       await waitJobs(server)
       expect(emails).to.have.lengthOf(3)
@@ -201,7 +196,7 @@ describe('Test emails', function () {
       expect(email['from'][0]['address']).equal('test-admin@localhost')
       expect(email['to'][0]['address']).equal('admin' + server.internalServerNumber + '@example.com')
       expect(email['subject']).contains('abuse')
-      expect(email['text']).contains(videoUUID)
+      expect(email['text']).contains(videoShortUUID)
     })
   })
 
@@ -211,7 +206,7 @@ describe('Test emails', function () {
       this.timeout(10000)
 
       const reason = 'my super bad reason'
-      await blockUser(server.url, userId, server.accessToken, HttpStatusCode.NO_CONTENT_204, reason)
+      await server.users.banUser({ userId, reason })
 
       await waitJobs(server)
       expect(emails).to.have.lengthOf(4)
@@ -229,7 +224,7 @@ describe('Test emails', function () {
     it('Should send the notification email when unblocking a user', async function () {
       this.timeout(10000)
 
-      await unblockUser(server.url, userId, server.accessToken, HttpStatusCode.NO_CONTENT_204)
+      await server.users.unbanUser({ userId })
 
       await waitJobs(server)
       expect(emails).to.have.lengthOf(5)
@@ -249,7 +244,7 @@ describe('Test emails', function () {
       this.timeout(10000)
 
       const reason = 'my super reason'
-      await addVideoToBlacklist(server.url, server.accessToken, videoUserUUID, reason)
+      await server.blacklist.add({ videoId: videoUserUUID, reason })
 
       await waitJobs(server)
       expect(emails).to.have.lengthOf(6)
@@ -267,7 +262,7 @@ describe('Test emails', function () {
     it('Should send the notification email', async function () {
       this.timeout(10000)
 
-      await removeVideoFromBlacklist(server.url, server.accessToken, videoUserUUID)
+      await server.blacklist.remove({ videoId: videoUserUUID })
 
       await waitJobs(server)
       expect(emails).to.have.lengthOf(7)
@@ -292,7 +287,7 @@ describe('Test emails', function () {
     it('Should ask to send the verification email', async function () {
       this.timeout(10000)
 
-      await askSendVerifyEmail(server.url, 'user_1@example.com')
+      await server.users.askSendVerifyEmail({ email: 'user_1@example.com' })
 
       await waitJobs(server)
       expect(emails).to.have.lengthOf(8)
@@ -318,11 +313,16 @@ describe('Test emails', function () {
     })
 
     it('Should not verify the email with an invalid verification string', async function () {
-      await verifyEmail(server.url, userId, verificationString + 'b', false, HttpStatusCode.FORBIDDEN_403)
+      await server.users.verifyEmail({
+        userId,
+        verificationString: verificationString + 'b',
+        isPendingEmail: false,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
     })
 
     it('Should verify the email', async function () {
-      await verifyEmail(server.url, userId, verificationString)
+      await server.users.verifyEmail({ userId, verificationString })
     })
   })
 
diff --git a/server/tests/api/server/follow-constraints.ts b/server/tests/api/server/follow-constraints.ts
index 3f2f71f46..471f5d8d0 100644
--- a/server/tests/api/server/follow-constraints.ts
+++ b/server/tests/api/server/follow-constraints.ts
@@ -1,56 +1,41 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import {
-  cleanupTests,
-  doubleFollow,
-  flushAndRunMultipleServers,
-  getAccountVideos,
-  getVideo,
-  getVideoChannelVideos,
-  getVideoWithToken,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo
-} from '../../../../shared/extra-utils'
-import { unfollow } from '../../../../shared/extra-utils/server/follows'
-import { userLogin } from '../../../../shared/extra-utils/users/login'
-import { createUser } from '../../../../shared/extra-utils/users/users'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-import { PeerTubeProblemDocument, ServerErrorCode } from '@shared/models'
+import * as chai from 'chai'
+import { cleanupTests, createMultipleServers, doubleFollow, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
+import { HttpStatusCode, PeerTubeProblemDocument, ServerErrorCode } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test follow constraints', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let video1UUID: string
   let video2UUID: string
-  let userAccessToken: string
+  let userToken: string
 
   before(async function () {
     this.timeout(90000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
 
     {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video server 1' })
-      video1UUID = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video server 1' } })
+      video1UUID = uuid
     }
     {
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video server 2' })
-      video2UUID = res.body.video.uuid
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video server 2' } })
+      video2UUID = uuid
     }
 
     const user = {
       username: 'user1',
       password: 'super_password'
     }
-    await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(servers[0], user)
+    await servers[0].users.create({ username: user.username, password: user.password })
+    userToken = await servers[0].login.getAccessToken(user)
 
     await doubleFollow(servers[0], servers[1])
   })
@@ -60,81 +45,81 @@ describe('Test follow constraints', function () {
     describe('With an unlogged user', function () {
 
       it('Should get the local video', async function () {
-        await getVideo(servers[0].url, video1UUID, HttpStatusCode.OK_200)
+        await servers[0].videos.get({ id: video1UUID })
       })
 
       it('Should get the remote video', async function () {
-        await getVideo(servers[0].url, video2UUID, HttpStatusCode.OK_200)
+        await servers[0].videos.get({ id: video2UUID })
       })
 
       it('Should list local account videos', async function () {
-        const res = await getAccountVideos(servers[0].url, undefined, 'root@localhost:' + servers[0].port, 0, 5)
+        const { total, data } = await servers[0].videos.listByAccount({ handle: 'root@localhost:' + servers[0].port })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should list remote account videos', async function () {
-        const res = await getAccountVideos(servers[0].url, undefined, 'root@localhost:' + servers[1].port, 0, 5)
+        const { total, data } = await servers[0].videos.listByAccount({ handle: 'root@localhost:' + servers[1].port })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should list local channel videos', async function () {
-        const videoChannelName = 'root_channel@localhost:' + servers[0].port
-        const res = await getVideoChannelVideos(servers[0].url, undefined, videoChannelName, 0, 5)
+        const handle = 'root_channel@localhost:' + servers[0].port
+        const { total, data } = await servers[0].videos.listByChannel({ handle })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should list remote channel videos', async function () {
-        const videoChannelName = 'root_channel@localhost:' + servers[1].port
-        const res = await getVideoChannelVideos(servers[0].url, undefined, videoChannelName, 0, 5)
+        const handle = 'root_channel@localhost:' + servers[1].port
+        const { total, data } = await servers[0].videos.listByChannel({ handle })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
     })
 
     describe('With a logged user', function () {
       it('Should get the local video', async function () {
-        await getVideoWithToken(servers[0].url, userAccessToken, video1UUID, HttpStatusCode.OK_200)
+        await servers[0].videos.getWithToken({ token: userToken, id: video1UUID })
       })
 
       it('Should get the remote video', async function () {
-        await getVideoWithToken(servers[0].url, userAccessToken, video2UUID, HttpStatusCode.OK_200)
+        await servers[0].videos.getWithToken({ token: userToken, id: video2UUID })
       })
 
       it('Should list local account videos', async function () {
-        const res = await getAccountVideos(servers[0].url, userAccessToken, 'root@localhost:' + servers[0].port, 0, 5)
+        const { total, data } = await servers[0].videos.listByAccount({ token: userToken, handle: 'root@localhost:' + servers[0].port })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should list remote account videos', async function () {
-        const res = await getAccountVideos(servers[0].url, userAccessToken, 'root@localhost:' + servers[1].port, 0, 5)
+        const { total, data } = await servers[0].videos.listByAccount({ token: userToken, handle: 'root@localhost:' + servers[1].port })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should list local channel videos', async function () {
-        const videoChannelName = 'root_channel@localhost:' + servers[0].port
-        const res = await getVideoChannelVideos(servers[0].url, userAccessToken, videoChannelName, 0, 5)
+        const handle = 'root_channel@localhost:' + servers[0].port
+        const { total, data } = await servers[0].videos.listByChannel({ token: userToken, handle })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should list remote channel videos', async function () {
-        const videoChannelName = 'root_channel@localhost:' + servers[1].port
-        const res = await getVideoChannelVideos(servers[0].url, userAccessToken, videoChannelName, 0, 5)
+        const handle = 'root_channel@localhost:' + servers[1].port
+        const { total, data } = await servers[0].videos.listByChannel({ token: userToken, handle })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
     })
   })
@@ -144,19 +129,18 @@ describe('Test follow constraints', function () {
     before(async function () {
       this.timeout(30000)
 
-      await unfollow(servers[0].url, servers[0].accessToken, servers[1])
+      await servers[0].follows.unfollow({ target: servers[1] })
     })
 
     describe('With an unlogged user', function () {
 
       it('Should get the local video', async function () {
-        await getVideo(servers[0].url, video1UUID, HttpStatusCode.OK_200)
+        await servers[0].videos.get({ id: video1UUID })
       })
 
       it('Should not get the remote video', async function () {
-        const res = await getVideo(servers[0].url, video2UUID, HttpStatusCode.FORBIDDEN_403)
-
-        const error = res.body as PeerTubeProblemDocument
+        const body = await servers[0].videos.get({ id: video2UUID, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+        const error = body as unknown as PeerTubeProblemDocument
 
         const doc = 'https://docs.joinpeertube.org/api-rest-reference.html#section/Errors/does_not_respect_follow_constraints'
         expect(error.type).to.equal(doc)
@@ -171,73 +155,79 @@ describe('Test follow constraints', function () {
       })
 
       it('Should list local account videos', async function () {
-        const res = await getAccountVideos(servers[0].url, undefined, 'root@localhost:' + servers[0].port, 0, 5)
+        const { total, data } = await servers[0].videos.listByAccount({
+          token: null,
+          handle: 'root@localhost:' + servers[0].port
+        })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should not list remote account videos', async function () {
-        const res = await getAccountVideos(servers[0].url, undefined, 'root@localhost:' + servers[1].port, 0, 5)
+        const { total, data } = await servers[0].videos.listByAccount({
+          token: null,
+          handle: 'root@localhost:' + servers[1].port
+        })
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
       })
 
       it('Should list local channel videos', async function () {
-        const videoChannelName = 'root_channel@localhost:' + servers[0].port
-        const res = await getVideoChannelVideos(servers[0].url, undefined, videoChannelName, 0, 5)
+        const handle = 'root_channel@localhost:' + servers[0].port
+        const { total, data } = await servers[0].videos.listByChannel({ token: null, handle })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should not list remote channel videos', async function () {
-        const videoChannelName = 'root_channel@localhost:' + servers[1].port
-        const res = await getVideoChannelVideos(servers[0].url, undefined, videoChannelName, 0, 5)
+        const handle = 'root_channel@localhost:' + servers[1].port
+        const { total, data } = await servers[0].videos.listByChannel({ token: null, handle })
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
       })
     })
 
     describe('With a logged user', function () {
       it('Should get the local video', async function () {
-        await getVideoWithToken(servers[0].url, userAccessToken, video1UUID, HttpStatusCode.OK_200)
+        await servers[0].videos.getWithToken({ token: userToken, id: video1UUID })
       })
 
       it('Should get the remote video', async function () {
-        await getVideoWithToken(servers[0].url, userAccessToken, video2UUID, HttpStatusCode.OK_200)
+        await servers[0].videos.getWithToken({ token: userToken, id: video2UUID })
       })
 
       it('Should list local account videos', async function () {
-        const res = await getAccountVideos(servers[0].url, userAccessToken, 'root@localhost:' + servers[0].port, 0, 5)
+        const { total, data } = await servers[0].videos.listByAccount({ token: userToken, handle: 'root@localhost:' + servers[0].port })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should list remote account videos', async function () {
-        const res = await getAccountVideos(servers[0].url, userAccessToken, 'root@localhost:' + servers[1].port, 0, 5)
+        const { total, data } = await servers[0].videos.listByAccount({ token: userToken, handle: 'root@localhost:' + servers[1].port })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should list local channel videos', async function () {
-        const videoChannelName = 'root_channel@localhost:' + servers[0].port
-        const res = await getVideoChannelVideos(servers[0].url, userAccessToken, videoChannelName, 0, 5)
+        const handle = 'root_channel@localhost:' + servers[0].port
+        const { total, data } = await servers[0].videos.listByChannel({ token: userToken, handle })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
 
       it('Should list remote channel videos', async function () {
-        const videoChannelName = 'root_channel@localhost:' + servers[1].port
-        const res = await getVideoChannelVideos(servers[0].url, userAccessToken, videoChannelName, 0, 5)
+        const handle = 'root_channel@localhost:' + servers[1].port
+        const { total, data } = await servers[0].videos.listByChannel({ token: userToken, handle })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       })
     })
   })
diff --git a/server/tests/api/server/follows-moderation.ts b/server/tests/api/server/follows-moderation.ts
index 73c212a32..921f51043 100644
--- a/server/tests/api/server/follows-moderation.ts
+++ b/server/tests/api/server/follows-moderation.ts
@@ -1,77 +1,66 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
-  acceptFollower,
   cleanupTests,
-  flushAndRunMultipleServers,
-  ServerInfo,
+  createMultipleServers,
+  FollowsCommand,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateCustomSubConfig
-} from '../../../../shared/extra-utils/index'
-import {
-  follow,
-  getFollowersListPaginationAndSort,
-  getFollowingListPaginationAndSort,
-  rejectFollower,
-  removeFollower
-} from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { ActorFollow } from '../../../../shared/models/actors'
+  waitJobs
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
-async function checkServer1And2HasFollowers (servers: ServerInfo[], state = 'accepted') {
-  {
-    const res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 5, sort: 'createdAt' })
-    expect(res.body.total).to.equal(1)
-
-    const follow = res.body.data[0] as ActorFollow
-    expect(follow.state).to.equal(state)
-    expect(follow.follower.url).to.equal('http://localhost:' + servers[0].port + '/accounts/peertube')
-    expect(follow.following.url).to.equal('http://localhost:' + servers[1].port + '/accounts/peertube')
-  }
+async function checkServer1And2HasFollowers (servers: PeerTubeServer[], state = 'accepted') {
+  const fns = [
+    servers[0].follows.getFollowings.bind(servers[0].follows),
+    servers[1].follows.getFollowers.bind(servers[1].follows)
+  ]
 
-  {
-    const res = await getFollowersListPaginationAndSort({ url: servers[1].url, start: 0, count: 5, sort: 'createdAt' })
-    expect(res.body.total).to.equal(1)
+  for (const fn of fns) {
+    const body = await fn({ start: 0, count: 5, sort: 'createdAt' })
+    expect(body.total).to.equal(1)
 
-    const follow = res.body.data[0] as ActorFollow
+    const follow = body.data[0]
     expect(follow.state).to.equal(state)
     expect(follow.follower.url).to.equal('http://localhost:' + servers[0].port + '/accounts/peertube')
     expect(follow.following.url).to.equal('http://localhost:' + servers[1].port + '/accounts/peertube')
   }
 }
 
-async function checkNoFollowers (servers: ServerInfo[]) {
-  {
-    const res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 5, sort: 'createdAt' })
-    expect(res.body.total).to.equal(0)
-  }
+async function checkNoFollowers (servers: PeerTubeServer[]) {
+  const fns = [
+    servers[0].follows.getFollowings.bind(servers[0].follows),
+    servers[1].follows.getFollowers.bind(servers[1].follows)
+  ]
 
-  {
-    const res = await getFollowersListPaginationAndSort({ url: servers[1].url, start: 0, count: 5, sort: 'createdAt' })
-    expect(res.body.total).to.equal(0)
+  for (const fn of fns) {
+    const body = await fn({ start: 0, count: 5, sort: 'createdAt' })
+    expect(body.total).to.equal(0)
   }
 }
 
 describe('Test follows moderation', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
+  let commands: FollowsCommand[]
 
   before(async function () {
     this.timeout(30000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
+
+    commands = servers.map(s => s.follows)
   })
 
   it('Should have server 1 following server 2', async function () {
     this.timeout(30000)
 
-    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
+    await commands[0].follow({ hosts: [ servers[1].url ] })
 
     await waitJobs(servers)
   })
@@ -83,7 +72,7 @@ describe('Test follows moderation', function () {
   it('Should remove follower on server 2', async function () {
     this.timeout(10000)
 
-    await removeFollower(servers[1].url, servers[1].accessToken, servers[0])
+    await commands[1].removeFollower({ follower: servers[0] })
 
     await waitJobs(servers)
   })
@@ -104,9 +93,9 @@ describe('Test follows moderation', function () {
       }
     }
 
-    await updateCustomSubConfig(servers[1].url, servers[1].accessToken, subConfig)
+    await servers[1].config.updateCustomSubConfig({ newConfig: subConfig })
 
-    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
+    await commands[0].follow({ hosts: [ servers[1].url ] })
     await waitJobs(servers)
 
     await checkNoFollowers(servers)
@@ -124,9 +113,9 @@ describe('Test follows moderation', function () {
       }
     }
 
-    await updateCustomSubConfig(servers[1].url, servers[1].accessToken, subConfig)
+    await servers[1].config.updateCustomSubConfig({ newConfig: subConfig })
 
-    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
+    await commands[0].follow({ hosts: [ servers[1].url ] })
     await waitJobs(servers)
 
     await checkServer1And2HasFollowers(servers)
@@ -135,7 +124,7 @@ describe('Test follows moderation', function () {
   it('Should manually approve followers', async function () {
     this.timeout(20000)
 
-    await removeFollower(servers[1].url, servers[1].accessToken, servers[0])
+    await commands[1].removeFollower({ follower: servers[0] })
     await waitJobs(servers)
 
     const subConfig = {
@@ -147,10 +136,10 @@ describe('Test follows moderation', function () {
       }
     }
 
-    await updateCustomSubConfig(servers[1].url, servers[1].accessToken, subConfig)
-    await updateCustomSubConfig(servers[2].url, servers[2].accessToken, subConfig)
+    await servers[1].config.updateCustomSubConfig({ newConfig: subConfig })
+    await servers[2].config.updateCustomSubConfig({ newConfig: subConfig })
 
-    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
+    await commands[0].follow({ hosts: [ servers[1].url ] })
     await waitJobs(servers)
 
     await checkServer1And2HasFollowers(servers, 'pending')
@@ -159,7 +148,7 @@ describe('Test follows moderation', function () {
   it('Should accept a follower', async function () {
     this.timeout(10000)
 
-    await acceptFollower(servers[1].url, servers[1].accessToken, 'peertube@localhost:' + servers[0].port)
+    await commands[1].acceptFollower({ follower: 'peertube@localhost:' + servers[0].port })
     await waitJobs(servers)
 
     await checkServer1And2HasFollowers(servers)
@@ -168,32 +157,32 @@ describe('Test follows moderation', function () {
   it('Should reject another follower', async function () {
     this.timeout(20000)
 
-    await follow(servers[0].url, [ servers[2].url ], servers[0].accessToken)
+    await commands[0].follow({ hosts: [ servers[2].url ] })
     await waitJobs(servers)
 
     {
-      const res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 5, sort: 'createdAt' })
-      expect(res.body.total).to.equal(2)
+      const body = await commands[0].getFollowings({ start: 0, count: 5, sort: 'createdAt' })
+      expect(body.total).to.equal(2)
     }
 
     {
-      const res = await getFollowersListPaginationAndSort({ url: servers[1].url, start: 0, count: 5, sort: 'createdAt' })
-      expect(res.body.total).to.equal(1)
+      const body = await commands[1].getFollowers({ start: 0, count: 5, sort: 'createdAt' })
+      expect(body.total).to.equal(1)
     }
 
     {
-      const res = await getFollowersListPaginationAndSort({ url: servers[2].url, start: 0, count: 5, sort: 'createdAt' })
-      expect(res.body.total).to.equal(1)
+      const body = await commands[2].getFollowers({ start: 0, count: 5, sort: 'createdAt' })
+      expect(body.total).to.equal(1)
     }
 
-    await rejectFollower(servers[2].url, servers[2].accessToken, 'peertube@localhost:' + servers[0].port)
+    await commands[2].rejectFollower({ follower: 'peertube@localhost:' + servers[0].port })
     await waitJobs(servers)
 
     await checkServer1And2HasFollowers(servers)
 
     {
-      const res = await getFollowersListPaginationAndSort({ url: servers[2].url, start: 0, count: 5, sort: 'createdAt' })
-      expect(res.body.total).to.equal(0)
+      const body = await commands[2].getFollowers({ start: 0, count: 5, sort: 'createdAt' })
+      expect(body.total).to.equal(0)
     }
   })
 
diff --git a/server/tests/api/server/follows.ts b/server/tests/api/server/follows.ts
index 9e5aa00c7..832ba561a 100644
--- a/server/tests/api/server/follows.ts
+++ b/server/tests/api/server/follows.ts
@@ -3,325 +3,374 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  addVideoCommentReply,
-  addVideoCommentThread,
   cleanupTests,
   completeVideoCheck,
-  createUser,
-  createVideoCaption,
+  createMultipleServers,
   dateIsValid,
-  deleteVideoComment,
   expectAccountFollows,
-  flushAndRunMultipleServers,
-  follow,
-  getFollowersListPaginationAndSort,
-  getFollowingListPaginationAndSort,
-  getVideoCommentThreads,
-  getVideosList,
-  getVideoThreadComments,
-  listVideoCaptions,
-  rateVideo,
-  ServerInfo,
+  expectChannelsFollows,
+  PeerTubeServer,
   setAccessTokensToServers,
   testCaptionFile,
-  unfollow,
-  uploadVideo,
-  userLogin,
   waitJobs
 } from '@shared/extra-utils'
-import { Video, VideoCaption, VideoComment, VideoCommentThreadTree, VideoPrivacy } from '@shared/models'
+import { VideoCreateResult, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test follows', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
 
   before(async function () {
     this.timeout(30000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
   })
 
-  it('Should not have followers', async function () {
-    for (const server of servers) {
-      const res = await getFollowersListPaginationAndSort({ url: server.url, start: 0, count: 5, sort: 'createdAt' })
-      const follows = res.body.data
+  describe('Data propagation after follow', function () {
 
-      expect(res.body.total).to.equal(0)
-      expect(follows).to.be.an('array')
-      expect(follows.length).to.equal(0)
-    }
-  })
-
-  it('Should not have following', async function () {
-    for (const server of servers) {
-      const res = await getFollowingListPaginationAndSort({ url: server.url, start: 0, count: 5, sort: 'createdAt' })
-      const follows = res.body.data
+    it('Should not have followers/followings', async function () {
+      for (const server of servers) {
+        const bodies = await Promise.all([
+          server.follows.getFollowers({ start: 0, count: 5, sort: 'createdAt' }),
+          server.follows.getFollowings({ start: 0, count: 5, sort: 'createdAt' })
+        ])
 
-      expect(res.body.total).to.equal(0)
-      expect(follows).to.be.an('array')
-      expect(follows.length).to.equal(0)
-    }
-  })
+        for (const body of bodies) {
+          expect(body.total).to.equal(0)
 
-  it('Should have server 1 following server 2 and 3', async function () {
-    this.timeout(30000)
+          const follows = body.data
+          expect(follows).to.be.an('array')
+          expect(follows).to.have.lengthOf(0)
+        }
+      }
+    })
 
-    await follow(servers[0].url, [ servers[1].url, servers[2].url ], servers[0].accessToken)
+    it('Should have server 1 following root account of server 2 and server 3', async function () {
+      this.timeout(30000)
 
-    await waitJobs(servers)
-  })
+      await servers[0].follows.follow({
+        hosts: [ servers[2].url ],
+        handles: [ 'root@' + servers[1].host ]
+      })
 
-  it('Should have 2 followings on server 1', async function () {
-    let res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 1, sort: 'createdAt' })
-    let follows = res.body.data
+      await waitJobs(servers)
+    })
 
-    expect(res.body.total).to.equal(2)
-    expect(follows).to.be.an('array')
-    expect(follows.length).to.equal(1)
+    it('Should have 2 followings on server 1', async function () {
+      const body = await servers[0].follows.getFollowings({ start: 0, count: 1, sort: 'createdAt' })
+      expect(body.total).to.equal(2)
 
-    res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 1, count: 1, sort: 'createdAt' })
-    follows = follows.concat(res.body.data)
+      let follows = body.data
+      expect(follows).to.be.an('array')
+      expect(follows).to.have.lengthOf(1)
 
-    const server2Follow = follows.find(f => f.following.host === 'localhost:' + servers[1].port)
-    const server3Follow = follows.find(f => f.following.host === 'localhost:' + servers[2].port)
+      const body2 = await servers[0].follows.getFollowings({ start: 1, count: 1, sort: 'createdAt' })
+      follows = follows.concat(body2.data)
 
-    expect(server2Follow).to.not.be.undefined
-    expect(server3Follow).to.not.be.undefined
-    expect(server2Follow.state).to.equal('accepted')
-    expect(server3Follow.state).to.equal('accepted')
-  })
+      const server2Follow = follows.find(f => f.following.host === servers[1].host)
+      const server3Follow = follows.find(f => f.following.host === servers[2].host)
 
-  it('Should search/filter followings on server 1', async function () {
-    const sort = 'createdAt'
-    const start = 0
-    const count = 1
-    const url = servers[0].url
+      expect(server2Follow).to.not.be.undefined
+      expect(server2Follow.following.name).to.equal('root')
+      expect(server2Follow.state).to.equal('accepted')
 
-    {
-      const search = ':' + servers[1].port
+      expect(server3Follow).to.not.be.undefined
+      expect(server3Follow.following.name).to.equal('peertube')
+      expect(server3Follow.state).to.equal('accepted')
+    })
 
-      {
-        const res = await getFollowingListPaginationAndSort({ url, start, count, sort, search })
-        const follows = res.body.data
+    it('Should have 0 followings on server 2 and 3', async function () {
+      for (const server of [ servers[1], servers[2] ]) {
+        const body = await server.follows.getFollowings({ start: 0, count: 5, sort: 'createdAt' })
+        expect(body.total).to.equal(0)
 
-        expect(res.body.total).to.equal(1)
-        expect(follows.length).to.equal(1)
-        expect(follows[0].following.host).to.equal('localhost:' + servers[1].port)
+        const follows = body.data
+        expect(follows).to.be.an('array')
+        expect(follows).to.have.lengthOf(0)
       }
+    })
 
-      {
-        const res = await getFollowingListPaginationAndSort({ url, start, count, sort, search, state: 'accepted' })
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+    it('Should have 1 followers on server 3', async function () {
+      const body = await servers[2].follows.getFollowers({ start: 0, count: 1, sort: 'createdAt' })
+      expect(body.total).to.equal(1)
+
+      const follows = body.data
+      expect(follows).to.be.an('array')
+      expect(follows).to.have.lengthOf(1)
+      expect(follows[0].follower.host).to.equal('localhost:' + servers[0].port)
+    })
+
+    it('Should have 0 followers on server 1 and 2', async function () {
+      for (const server of [ servers[0], servers[1] ]) {
+        const body = await server.follows.getFollowers({ start: 0, count: 5, sort: 'createdAt' })
+        expect(body.total).to.equal(0)
+
+        const follows = body.data
+        expect(follows).to.be.an('array')
+        expect(follows).to.have.lengthOf(0)
       }
+    })
+
+    it('Should search/filter followings on server 1', async function () {
+      const sort = 'createdAt'
+      const start = 0
+      const count = 1
 
       {
-        const res = await getFollowingListPaginationAndSort({ url, start, count, sort, search, state: 'accepted', actorType: 'Person' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        const search = ':' + servers[1].port
+
+        {
+          const body = await servers[0].follows.getFollowings({ start, count, sort, search })
+          expect(body.total).to.equal(1)
+
+          const follows = body.data
+          expect(follows).to.have.lengthOf(1)
+          expect(follows[0].following.host).to.equal(servers[1].host)
+        }
+
+        {
+          const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'accepted' })
+          expect(body.total).to.equal(1)
+          expect(body.data).to.have.lengthOf(1)
+        }
+
+        {
+          const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'accepted', actorType: 'Person' })
+          expect(body.total).to.equal(1)
+          expect(body.data).to.have.lengthOf(1)
+        }
+
+        {
+          const body = await servers[0].follows.getFollowings({
+            start,
+            count,
+            sort,
+            search,
+            state: 'accepted',
+            actorType: 'Application'
+          })
+          expect(body.total).to.equal(0)
+          expect(body.data).to.have.lengthOf(0)
+        }
+
+        {
+          const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'pending' })
+          expect(body.total).to.equal(0)
+          expect(body.data).to.have.lengthOf(0)
+        }
       }
 
       {
-        const res = await getFollowingListPaginationAndSort({
-          url,
-          start,
-          count,
-          sort,
-          search,
-          state: 'accepted',
-          actorType: 'Application'
-        })
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        const body = await servers[0].follows.getFollowings({ start, count, sort, search: 'root' })
+        expect(body.total).to.equal(1)
+        expect(body.data).to.have.lengthOf(1)
       }
 
       {
-        const res = await getFollowingListPaginationAndSort({ url, start, count, sort, search, state: 'pending' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        const body = await servers[0].follows.getFollowings({ start, count, sort, search: 'bla' })
+        expect(body.total).to.equal(0)
+
+        expect(body.data).to.have.lengthOf(0)
       }
-    }
+    })
 
-    {
-      const res = await getFollowingListPaginationAndSort({ url, start, count, sort, search: 'bla' })
-      const follows = res.body.data
+    it('Should search/filter followers on server 2', async function () {
+      const start = 0
+      const count = 5
+      const sort = 'createdAt'
 
-      expect(res.body.total).to.equal(0)
-      expect(follows.length).to.equal(0)
-    }
-  })
+      {
+        const search = servers[0].port + ''
 
-  it('Should have 0 followings on server 2 and 3', async function () {
-    for (const server of [ servers[1], servers[2] ]) {
-      const res = await getFollowingListPaginationAndSort({ url: server.url, start: 0, count: 5, sort: 'createdAt' })
-      const follows = res.body.data
+        {
+          const body = await servers[2].follows.getFollowers({ start, count, sort, search })
+          expect(body.total).to.equal(1)
 
-      expect(res.body.total).to.equal(0)
-      expect(follows).to.be.an('array')
-      expect(follows.length).to.equal(0)
-    }
-  })
+          const follows = body.data
+          expect(follows).to.have.lengthOf(1)
+          expect(follows[0].following.host).to.equal(servers[2].host)
+        }
 
-  it('Should have 1 followers on server 2 and 3', async function () {
-    for (const server of [ servers[1], servers[2] ]) {
-      const res = await getFollowersListPaginationAndSort({ url: server.url, start: 0, count: 1, sort: 'createdAt' })
+        {
+          const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'accepted' })
+          expect(body.total).to.equal(1)
+          expect(body.data).to.have.lengthOf(1)
+        }
 
-      const follows = res.body.data
-      expect(res.body.total).to.equal(1)
-      expect(follows).to.be.an('array')
-      expect(follows.length).to.equal(1)
-      expect(follows[0].follower.host).to.equal('localhost:' + servers[0].port)
-    }
-  })
+        {
+          const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'accepted', actorType: 'Person' })
+          expect(body.total).to.equal(0)
+          expect(body.data).to.have.lengthOf(0)
+        }
 
-  it('Should search/filter followers on server 2', async function () {
-    const url = servers[2].url
-    const start = 0
-    const count = 5
-    const sort = 'createdAt'
+        {
+          const body = await servers[2].follows.getFollowers({
+            start,
+            count,
+            sort,
+            search,
+            state: 'accepted',
+            actorType: 'Application'
+          })
+          expect(body.total).to.equal(1)
+          expect(body.data).to.have.lengthOf(1)
+        }
 
-    {
-      const search = servers[0].port + ''
+        {
+          const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'pending' })
+          expect(body.total).to.equal(0)
+          expect(body.data).to.have.lengthOf(0)
+        }
+      }
 
       {
-        const res = await getFollowersListPaginationAndSort({ url, start, count, sort, search })
-        const follows = res.body.data
+        const body = await servers[2].follows.getFollowers({ start, count, sort, search: 'bla' })
+        expect(body.total).to.equal(0)
 
-        expect(res.body.total).to.equal(1)
-        expect(follows.length).to.equal(1)
-        expect(follows[0].following.host).to.equal('localhost:' + servers[2].port)
+        const follows = body.data
+        expect(follows).to.have.lengthOf(0)
       }
+    })
 
-      {
-        const res = await getFollowersListPaginationAndSort({ url, start, count, sort, search, state: 'accepted' })
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
-      }
+    it('Should have the correct follows counts', async function () {
+      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 2 })
+      await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
 
-      {
-        const res = await getFollowersListPaginationAndSort({ url, start, count, sort, search, state: 'accepted', actorType: 'Person' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
-      }
+      // Server 2 and 3 does not know server 1 follow another server (there was not a refresh)
+      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+      await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
 
-      {
-        const res = await getFollowersListPaginationAndSort({
-          url,
-          start,
-          count,
-          sort,
-          search,
-          state: 'accepted',
-          actorType: 'Application'
-        })
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
-      }
+      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
+    })
 
-      {
-        const res = await getFollowersListPaginationAndSort({ url, start, count, sort, search, state: 'pending' })
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
-      }
-    }
+    it('Should unfollow server 3 on server 1', async function () {
+      this.timeout(15000)
 
-    {
-      const res = await getFollowersListPaginationAndSort({ url, start, count, sort, search: 'bla' })
-      const follows = res.body.data
+      await servers[0].follows.unfollow({ target: servers[2] })
 
-      expect(res.body.total).to.equal(0)
-      expect(follows.length).to.equal(0)
-    }
-  })
+      await waitJobs(servers)
+    })
 
-  it('Should have 0 followers on server 1', async function () {
-    const res = await getFollowersListPaginationAndSort({ url: servers[0].url, start: 0, count: 5, sort: 'createdAt' })
-    const follows = res.body.data
+    it('Should not follow server 3 on server 1 anymore', async function () {
+      const body = await servers[0].follows.getFollowings({ start: 0, count: 2, sort: 'createdAt' })
+      expect(body.total).to.equal(1)
 
-    expect(res.body.total).to.equal(0)
-    expect(follows).to.be.an('array')
-    expect(follows.length).to.equal(0)
-  })
+      const follows = body.data
+      expect(follows).to.be.an('array')
+      expect(follows).to.have.lengthOf(1)
 
-  it('Should have the correct follows counts', async function () {
-    await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[0].port, 0, 2)
-    await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[1].port, 1, 0)
-    await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[2].port, 1, 0)
+      expect(follows[0].following.host).to.equal(servers[1].host)
+    })
 
-    // Server 2 and 3 does not know server 1 follow another server (there was not a refresh)
-    await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[0].port, 0, 1)
-    await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[1].port, 1, 0)
+    it('Should not have server 1 as follower on server 3 anymore', async function () {
+      const body = await servers[2].follows.getFollowers({ start: 0, count: 1, sort: 'createdAt' })
+      expect(body.total).to.equal(0)
 
-    await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[0].port, 0, 1)
-    await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[2].port, 1, 0)
-  })
+      const follows = body.data
+      expect(follows).to.be.an('array')
+      expect(follows).to.have.lengthOf(0)
+    })
 
-  it('Should unfollow server 3 on server 1', async function () {
-    this.timeout(5000)
+    it('Should have the correct follows counts after the unfollow', async function () {
+      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+      await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 0, following: 0 })
 
-    await unfollow(servers[0].url, servers[0].accessToken, servers[2])
+      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+      await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
 
-    await waitJobs(servers)
-  })
+      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 0 })
+      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 0, following: 0 })
+    })
 
-  it('Should not follow server 3 on server 1 anymore', async function () {
-    const res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 2, sort: 'createdAt' })
-    const follows = res.body.data
+    it('Should upload a video on server 2 and 3 and propagate only the video of server 2', async function () {
+      this.timeout(60000)
 
-    expect(res.body.total).to.equal(1)
-    expect(follows).to.be.an('array')
-    expect(follows.length).to.equal(1)
+      await servers[1].videos.upload({ attributes: { name: 'server2' } })
+      await servers[2].videos.upload({ attributes: { name: 'server3' } })
 
-    expect(follows[0].following.host).to.equal('localhost:' + servers[1].port)
-  })
+      await waitJobs(servers)
 
-  it('Should not have server 1 as follower on server 3 anymore', async function () {
-    const res = await getFollowersListPaginationAndSort({ url: servers[2].url, start: 0, count: 1, sort: 'createdAt' })
+      {
+        const { total, data } = await servers[0].videos.list()
+        expect(total).to.equal(1)
+        expect(data[0].name).to.equal('server2')
+      }
 
-    const follows = res.body.data
-    expect(res.body.total).to.equal(0)
-    expect(follows).to.be.an('array')
-    expect(follows.length).to.equal(0)
-  })
+      {
+        const { total, data } = await servers[1].videos.list()
+        expect(total).to.equal(1)
+        expect(data[0].name).to.equal('server2')
+      }
+
+      {
+        const { total, data } = await servers[2].videos.list()
+        expect(total).to.equal(1)
+        expect(data[0].name).to.equal('server3')
+      }
+    })
 
-  it('Should have the correct follows counts 2', async function () {
-    await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[0].port, 0, 1)
-    await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[1].port, 1, 0)
+    it('Should remove account follow', async function () {
+      this.timeout(15000)
 
-    await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[0].port, 0, 1)
-    await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[1].port, 1, 0)
+      await servers[0].follows.unfollow({ target: 'root@' + servers[1].host })
 
-    await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[0].port, 0, 0)
-    await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[2].port, 0, 0)
-  })
+      await waitJobs(servers)
+    })
 
-  it('Should upload a video on server 2 and 3 and propagate only the video of server 2', async function () {
-    this.timeout(60000)
+    it('Should have removed the account follow', async function () {
+      await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+      await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
 
-    await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'server2' })
-    await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3' })
+      {
+        const { total, data } = await servers[0].follows.getFollowings()
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
+      }
 
-    await waitJobs(servers)
+      {
+        const { total, data } = await servers[0].videos.list()
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
+      }
+    })
 
-    let res = await getVideosList(servers[0].url)
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data[0].name).to.equal('server2')
+    it('Should follow a channel', async function () {
+      this.timeout(15000)
 
-    res = await getVideosList(servers[1].url)
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data[0].name).to.equal('server2')
+      await servers[0].follows.follow({
+        handles: [ 'root_channel@' + servers[1].host ]
+      })
 
-    res = await getVideosList(servers[2].url)
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data[0].name).to.equal('server3')
+      await waitJobs(servers)
+
+      await expectChannelsFollows({ server: servers[0], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+      await expectChannelsFollows({ server: servers[1], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+
+      {
+        const { total, data } = await servers[0].follows.getFollowings()
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      }
+
+      {
+        const { total, data } = await servers[0].videos.list()
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      }
+    })
   })
 
-  describe('Should propagate data on a new following', function () {
-    let video4: Video
+  describe('Should propagate data on a new server follow', function () {
+    let video4: VideoCreateResult
 
     before(async function () {
       this.timeout(50000)
@@ -334,100 +383,75 @@ describe('Test follows', function () {
         tags: [ 'tag1', 'tag2', 'tag3' ]
       }
 
-      await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-2' })
-      await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-3' })
-      await uploadVideo(servers[2].url, servers[2].accessToken, video4Attributes)
-      await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-5' })
-      await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-6' })
+      await servers[2].videos.upload({ attributes: { name: 'server3-2' } })
+      await servers[2].videos.upload({ attributes: { name: 'server3-3' } })
+      video4 = await servers[2].videos.upload({ attributes: video4Attributes })
+      await servers[2].videos.upload({ attributes: { name: 'server3-5' } })
+      await servers[2].videos.upload({ attributes: { name: 'server3-6' } })
 
       {
-        const user = { username: 'captain', password: 'password' }
-        await createUser({ url: servers[2].url, accessToken: servers[2].accessToken, username: user.username, password: user.password })
-        const userAccessToken = await userLogin(servers[2], user)
-
-        const resVideos = await getVideosList(servers[2].url)
-        video4 = resVideos.body.data.find(v => v.name === 'server3-4')
+        const userAccessToken = await servers[2].users.generateUserAndToken('captain')
 
-        {
-          await rateVideo(servers[2].url, servers[2].accessToken, video4.id, 'like')
-          await rateVideo(servers[2].url, userAccessToken, video4.id, 'dislike')
-        }
-
-        {
-          {
-            const text = 'my super first comment'
-            const res = await addVideoCommentThread(servers[2].url, servers[2].accessToken, video4.id, text)
-            const threadId = res.body.comment.id
-
-            const text1 = 'my super answer to thread 1'
-            const childCommentRes = await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, threadId, text1)
-            const childCommentId = childCommentRes.body.comment.id
-
-            const text2 = 'my super answer to answer of thread 1'
-            await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, childCommentId, text2)
-
-            const text3 = 'my second answer to thread 1'
-            await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, threadId, text3)
-          }
+        await servers[2].videos.rate({ id: video4.id, rating: 'like' })
+        await servers[2].videos.rate({ token: userAccessToken, id: video4.id, rating: 'dislike' })
+      }
 
-          {
-            const text = 'will be deleted'
-            const res = await addVideoCommentThread(servers[2].url, servers[2].accessToken, video4.id, text)
-            const threadId = res.body.comment.id
+      {
+        await servers[2].comments.createThread({ videoId: video4.id, text: 'my super first comment' })
 
-            const text1 = 'answer to deleted'
-            await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, threadId, text1)
+        await servers[2].comments.addReplyToLastThread({ text: 'my super answer to thread 1' })
+        await servers[2].comments.addReplyToLastReply({ text: 'my super answer to answer of thread 1' })
+        await servers[2].comments.addReplyToLastThread({ text: 'my second answer to thread 1' })
+      }
 
-            const text2 = 'will also be deleted'
-            const childCommentRes = await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, threadId, text2)
-            const childCommentId = childCommentRes.body.comment.id
+      {
+        const { id: threadId } = await servers[2].comments.createThread({ videoId: video4.id, text: 'will be deleted' })
+        await servers[2].comments.addReplyToLastThread({ text: 'answer to deleted' })
 
-            const text3 = 'my second answer to deleted'
-            await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, childCommentId, text3)
+        const { id: replyId } = await servers[2].comments.addReplyToLastThread({ text: 'will also be deleted' })
 
-            await deleteVideoComment(servers[2].url, servers[2].accessToken, video4.id, threadId)
-            await deleteVideoComment(servers[2].url, servers[2].accessToken, video4.id, childCommentId)
-          }
-        }
+        await servers[2].comments.addReplyToLastReply({ text: 'my second answer to deleted' })
 
-        {
-          await createVideoCaption({
-            url: servers[2].url,
-            accessToken: servers[2].accessToken,
-            language: 'ar',
-            videoId: video4.id,
-            fixture: 'subtitle-good2.vtt'
-          })
-        }
+        await servers[2].comments.delete({ videoId: video4.id, commentId: threadId })
+        await servers[2].comments.delete({ videoId: video4.id, commentId: replyId })
       }
 
+      await servers[2].captions.add({
+        language: 'ar',
+        videoId: video4.id,
+        fixture: 'subtitle-good2.vtt'
+      })
+
       await waitJobs(servers)
 
       // Server 1 follows server 3
-      await follow(servers[0].url, [ servers[2].url ], servers[0].accessToken)
+      await servers[0].follows.follow({ hosts: [ servers[2].url ] })
 
       await waitJobs(servers)
     })
 
-    it('Should have the correct follows counts 3', async function () {
-      await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[0].port, 0, 2)
-      await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[1].port, 1, 0)
-      await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[2].port, 1, 0)
+    it('Should have the correct follows counts', async function () {
+      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 2 })
+      await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+      await expectChannelsFollows({ server: servers[0], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
 
-      await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[0].port, 0, 1)
-      await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[1].port, 1, 0)
+      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
+      await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+      await expectChannelsFollows({ server: servers[1], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
 
-      await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[0].port, 0, 1)
-      await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[2].port, 1, 0)
+      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
     })
 
     it('Should have propagated videos', async function () {
-      const res = await getVideosList(servers[0].url)
-      expect(res.body.total).to.equal(7)
+      const { total, data } = await servers[0].videos.list()
+      expect(total).to.equal(7)
 
-      const video2 = res.body.data.find(v => v.name === 'server3-2')
-      video4 = res.body.data.find(v => v.name === 'server3-4')
-      const video6 = res.body.data.find(v => v.name === 'server3-6')
+      const video2 = data.find(v => v.name === 'server3-2')
+      video4 = data.find(v => v.name === 'server3-4')
+      const video6 = data.find(v => v.name === 'server3-6')
 
       expect(video2).to.not.be.undefined
       expect(video4).to.not.be.undefined
@@ -444,7 +468,7 @@ describe('Test follows', function () {
         support: 'my super support text',
         account: {
           name: 'root',
-          host: 'localhost:' + servers[2].port
+          host: servers[2].host
         },
         isLocal,
         commentsEnabled: true,
@@ -468,33 +492,31 @@ describe('Test follows', function () {
           }
         ]
       }
-      await completeVideoCheck(servers[0].url, video4, checkAttributes)
+      await completeVideoCheck(servers[0], video4, checkAttributes)
     })
 
     it('Should have propagated comments', async function () {
-      const res1 = await getVideoCommentThreads(servers[0].url, video4.id, 0, 5, 'createdAt')
+      const { total, data } = await servers[0].comments.listThreads({ videoId: video4.id, sort: 'createdAt' })
 
-      expect(res1.body.total).to.equal(2)
-      expect(res1.body.data).to.be.an('array')
-      expect(res1.body.data).to.have.lengthOf(2)
+      expect(total).to.equal(2)
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(2)
 
       {
-        const comment: VideoComment = res1.body.data[0]
+        const comment = data[0]
         expect(comment.inReplyToCommentId).to.be.null
         expect(comment.text).equal('my super first comment')
         expect(comment.videoId).to.equal(video4.id)
         expect(comment.id).to.equal(comment.threadId)
         expect(comment.account.name).to.equal('root')
-        expect(comment.account.host).to.equal('localhost:' + servers[2].port)
+        expect(comment.account.host).to.equal(servers[2].host)
         expect(comment.totalReplies).to.equal(3)
         expect(dateIsValid(comment.createdAt as string)).to.be.true
         expect(dateIsValid(comment.updatedAt as string)).to.be.true
 
         const threadId = comment.threadId
 
-        const res2 = await getVideoThreadComments(servers[0].url, video4.id, threadId)
-
-        const tree: VideoCommentThreadTree = res2.body
+        const tree = await servers[0].comments.getThread({ videoId: video4.id, threadId })
         expect(tree.comment.text).equal('my super first comment')
         expect(tree.children).to.have.lengthOf(2)
 
@@ -512,7 +534,7 @@ describe('Test follows', function () {
       }
 
       {
-        const deletedComment: VideoComment = res1.body.data[1]
+        const deletedComment = data[1]
         expect(deletedComment).to.not.be.undefined
         expect(deletedComment.isDeleted).to.be.true
         expect(deletedComment.deletedAt).to.not.be.null
@@ -522,9 +544,7 @@ describe('Test follows', function () {
         expect(deletedComment.totalReplies).to.equal(2)
         expect(dateIsValid(deletedComment.deletedAt as string)).to.be.true
 
-        const res2 = await getVideoThreadComments(servers[0].url, video4.id, deletedComment.threadId)
-
-        const tree: VideoCommentThreadTree = res2.body
+        const tree = await servers[0].comments.getThread({ videoId: video4.id, threadId: deletedComment.threadId })
         const [ commentRoot, deletedChildRoot ] = tree.children
 
         expect(deletedChildRoot).to.not.be.undefined
@@ -549,11 +569,11 @@ describe('Test follows', function () {
     })
 
     it('Should have propagated captions', async function () {
-      const res = await listVideoCaptions(servers[0].url, video4.id)
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      const body = await servers[0].captions.list({ videoId: video4.id })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
 
-      const caption1: VideoCaption = res.body.data[0]
+      const caption1 = body.data[0]
       expect(caption1.language.id).to.equal('ar')
       expect(caption1.language.label).to.equal('Arabic')
       expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/.+-ar.vtt$'))
@@ -563,14 +583,39 @@ describe('Test follows', function () {
     it('Should unfollow server 3 on server 1 and does not list server 3 videos', async function () {
       this.timeout(5000)
 
-      await unfollow(servers[0].url, servers[0].accessToken, servers[2])
+      await servers[0].follows.unfollow({ target: servers[2] })
+
+      await waitJobs(servers)
+
+      const { total } = await servers[0].videos.list()
+      expect(total).to.equal(1)
+    })
+  })
+
+  describe('Should propagate data on a new channel follow', function () {
+
+    before(async function () {
+      this.timeout(60000)
+
+      await servers[2].videos.upload({ attributes: { name: 'server3-7' } })
 
       await waitJobs(servers)
 
-      const res = await getVideosList(servers[0].url)
-      expect(res.body.total).to.equal(1)
+      const video = await servers[0].videos.find({ name: 'server3-7' })
+      expect(video).to.not.exist
     })
 
+    it('Should have propagated channel video', async function () {
+      this.timeout(60000)
+
+      await servers[0].follows.follow({ handles: [ 'root_channel@' + servers[2].host ] })
+
+      await waitJobs(servers)
+
+      const video = await servers[0].videos.find({ name: 'server3-7' })
+
+      expect(video).to.exist
+    })
   })
 
   after(async function () {
diff --git a/server/tests/api/server/handle-down.ts b/server/tests/api/server/handle-down.ts
index d57d72f5e..2f3950354 100644
--- a/server/tests/api/server/handle-down.ts
+++ b/server/tests/api/server/handle-down.ts
@@ -1,51 +1,31 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import { JobState, Video } from '../../../../shared/models'
-import { VideoPrivacy } from '../../../../shared/models/videos'
-import { VideoCommentThreadTree } from '../../../../shared/models/videos/comment/video-comment.model'
-
+import * as chai from 'chai'
 import {
   cleanupTests,
-  closeAllSequelize,
+  CommentsCommand,
   completeVideoCheck,
-  flushAndRunMultipleServers,
-  getVideo,
-  getVideosList,
-  immutableAssign,
+  createMultipleServers,
   killallServers,
-  reRunServer,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  setActorFollowScores,
-  unfollow,
-  updateVideo,
-  uploadVideo,
-  uploadVideoAndGetId,
-  wait
-} from '../../../../shared/extra-utils'
-import { follow, getFollowersListPaginationAndSort } from '../../../../shared/extra-utils/server/follows'
-import { getJobsListPaginationAndSort, waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  addVideoCommentReply,
-  addVideoCommentThread,
-  getVideoCommentThreads,
-  getVideoThreadComments
-} from '../../../../shared/extra-utils/videos/video-comments'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { HttpStatusCode, JobState, VideoCreateResult, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test handle downs', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let threadIdServer1: number
   let threadIdServer2: number
   let commentIdServer1: number
   let commentIdServer2: number
-  let missedVideo1: Video
-  let missedVideo2: Video
-  let unlistedVideo: Video
+  let missedVideo1: VideoCreateResult
+  let missedVideo2: VideoCreateResult
+  let unlistedVideo: VideoCreateResult
 
   const videoIdsServer1: string[] = []
 
@@ -62,17 +42,18 @@ describe('Test handle downs', function () {
     fixture: 'video_short1.webm'
   }
 
-  const unlistedVideoAttributes = immutableAssign(videoAttributes, {
-    privacy: VideoPrivacy.UNLISTED
-  })
+  const unlistedVideoAttributes = { ...videoAttributes, privacy: VideoPrivacy.UNLISTED }
 
   let checkAttributes: any
   let unlistedCheckAttributes: any
 
+  let commentCommands: CommentsCommand[]
+
   before(async function () {
     this.timeout(30000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
+    commentCommands = servers.map(s => s.comments)
 
     checkAttributes = {
       name: 'my super name for server 1',
@@ -106,9 +87,7 @@ describe('Test handle downs', function () {
         }
       ]
     }
-    unlistedCheckAttributes = immutableAssign(checkAttributes, {
-      privacy: VideoPrivacy.UNLISTED
-    })
+    unlistedCheckAttributes = { ...checkAttributes, privacy: VideoPrivacy.UNLISTED }
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -118,58 +97,53 @@ describe('Test handle downs', function () {
     this.timeout(240000)
 
     // Server 2 and 3 follow server 1
-    await follow(servers[1].url, [ servers[0].url ], servers[1].accessToken)
-    await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken)
+    await servers[1].follows.follow({ hosts: [ servers[0].url ] })
+    await servers[2].follows.follow({ hosts: [ servers[0].url ] })
 
     await waitJobs(servers)
 
     // Upload a video to server 1
-    await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+    await servers[0].videos.upload({ attributes: videoAttributes })
 
     await waitJobs(servers)
 
     // And check all servers have this video
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
+      const { data } = await server.videos.list()
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(1)
     }
 
     // Kill server 2
-    killallServers([ servers[1] ])
+    await killallServers([ servers[1] ])
 
     // Remove server 2 follower
     for (let i = 0; i < 10; i++) {
-      await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+      await servers[0].videos.upload({ attributes: videoAttributes })
     }
 
     await waitJobs([ servers[0], servers[2] ])
 
     // Kill server 3
-    killallServers([ servers[2] ])
+    await killallServers([ servers[2] ])
 
-    const resLastVideo1 = await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
-    missedVideo1 = resLastVideo1.body.video
+    missedVideo1 = await servers[0].videos.upload({ attributes: videoAttributes })
 
-    const resLastVideo2 = await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
-    missedVideo2 = resLastVideo2.body.video
+    missedVideo2 = await servers[0].videos.upload({ attributes: videoAttributes })
 
     // Unlisted video
-    const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, unlistedVideoAttributes)
-    unlistedVideo = resVideo.body.video
+    unlistedVideo = await servers[0].videos.upload({ attributes: unlistedVideoAttributes })
 
     // Add comments to video 2
     {
       const text = 'thread 1'
-      let resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, missedVideo2.uuid, text)
-      let comment = resComment.body.comment
+      let comment = await commentCommands[0].createThread({ videoId: missedVideo2.uuid, text })
       threadIdServer1 = comment.id
 
-      resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, missedVideo2.uuid, comment.id, 'comment 1-1')
-      comment = resComment.body.comment
+      comment = await commentCommands[0].addReply({ videoId: missedVideo2.uuid, toCommentId: comment.id, text: 'comment 1-1' })
 
-      resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, missedVideo2.uuid, comment.id, 'comment 1-2')
-      commentIdServer1 = resComment.body.comment.id
+      const created = await commentCommands[0].addReply({ videoId: missedVideo2.uuid, toCommentId: comment.id, text: 'comment 1-2' })
+      commentIdServer1 = created.id
     }
 
     await waitJobs(servers[0])
@@ -177,90 +151,87 @@ describe('Test handle downs', function () {
     await wait(11000)
 
     // Only server 3 is still a follower of server 1
-    const res = await getFollowersListPaginationAndSort({ url: servers[0].url, start: 0, count: 2, sort: 'createdAt' })
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
-    expect(res.body.data[0].follower.host).to.equal('localhost:' + servers[2].port)
+    const body = await servers[0].follows.getFollowers({ start: 0, count: 2, sort: 'createdAt' })
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].follower.host).to.equal('localhost:' + servers[2].port)
   })
 
   it('Should not have pending/processing jobs anymore', async function () {
     const states: JobState[] = [ 'waiting', 'active' ]
 
     for (const state of states) {
-      const res = await getJobsListPaginationAndSort({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
+      const body = await servers[0].jobs.getJobsList({
         state: state,
         start: 0,
         count: 50,
         sort: '-createdAt'
       })
-      expect(res.body.data).to.have.length(0)
+      expect(body.data).to.have.length(0)
     }
   })
 
   it('Should re-follow server 1', async function () {
     this.timeout(35000)
 
-    await reRunServer(servers[1])
-    await reRunServer(servers[2])
+    await servers[1].run()
+    await servers[2].run()
 
-    await unfollow(servers[1].url, servers[1].accessToken, servers[0])
+    await servers[1].follows.unfollow({ target: servers[0] })
     await waitJobs(servers)
 
-    await follow(servers[1].url, [ servers[0].url ], servers[1].accessToken)
+    await servers[1].follows.follow({ hosts: [ servers[0].url ] })
 
     await waitJobs(servers)
 
-    const res = await getFollowersListPaginationAndSort({ url: servers[0].url, start: 0, count: 2, sort: 'createdAt' })
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(2)
+    const body = await servers[0].follows.getFollowers({ start: 0, count: 2, sort: 'createdAt' })
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(2)
   })
 
   it('Should send an update to server 3, and automatically fetch the video', async function () {
     this.timeout(15000)
 
-    const res1 = await getVideosList(servers[2].url)
-    expect(res1.body.data).to.be.an('array')
-    expect(res1.body.data).to.have.lengthOf(11)
+    {
+      const { data } = await servers[2].videos.list()
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(11)
+    }
 
-    await updateVideo(servers[0].url, servers[0].accessToken, missedVideo1.uuid, {})
-    await updateVideo(servers[0].url, servers[0].accessToken, unlistedVideo.uuid, {})
+    await servers[0].videos.update({ id: missedVideo1.uuid })
+    await servers[0].videos.update({ id: unlistedVideo.uuid })
 
     await waitJobs(servers)
 
-    const res = await getVideosList(servers[2].url)
-    expect(res.body.data).to.be.an('array')
-    // 1 video is unlisted
-    expect(res.body.data).to.have.lengthOf(12)
+    {
+      const { data } = await servers[2].videos.list()
+      expect(data).to.be.an('array')
+      // 1 video is unlisted
+      expect(data).to.have.lengthOf(12)
+    }
 
     // Check unlisted video
-    const resVideo = await getVideo(servers[2].url, unlistedVideo.uuid)
-    expect(resVideo.body).not.to.be.undefined
-
-    await completeVideoCheck(servers[2].url, resVideo.body, unlistedCheckAttributes)
+    const video = await servers[2].videos.get({ id: unlistedVideo.uuid })
+    await completeVideoCheck(servers[2], video, unlistedCheckAttributes)
   })
 
   it('Should send comments on a video to server 3, and automatically fetch the video', async function () {
     this.timeout(25000)
 
-    await addVideoCommentReply(servers[0].url, servers[0].accessToken, missedVideo2.uuid, commentIdServer1, 'comment 1-3')
+    await commentCommands[0].addReply({ videoId: missedVideo2.uuid, toCommentId: commentIdServer1, text: 'comment 1-3' })
 
     await waitJobs(servers)
 
-    const resVideo = await getVideo(servers[2].url, missedVideo2.uuid)
-    expect(resVideo.body).not.to.be.undefined
+    await servers[2].videos.get({ id: missedVideo2.uuid })
 
     {
-      let resComment = await getVideoCommentThreads(servers[2].url, missedVideo2.uuid, 0, 5)
-      expect(resComment.body.data).to.be.an('array')
-      expect(resComment.body.data).to.have.lengthOf(1)
-
-      threadIdServer2 = resComment.body.data[0].id
+      const { data } = await servers[2].comments.listThreads({ videoId: missedVideo2.uuid })
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(1)
 
-      resComment = await getVideoThreadComments(servers[2].url, missedVideo2.uuid, threadIdServer2)
+      threadIdServer2 = data[0].id
 
-      const tree: VideoCommentThreadTree = resComment.body
+      const tree = await servers[2].comments.getThread({ videoId: missedVideo2.uuid, threadId: threadIdServer2 })
       expect(tree.comment.text).equal('thread 1')
       expect(tree.children).to.have.lengthOf(1)
 
@@ -283,57 +254,54 @@ describe('Test handle downs', function () {
   it('Should correctly reply to the comment', async function () {
     this.timeout(15000)
 
-    await addVideoCommentReply(servers[2].url, servers[2].accessToken, missedVideo2.uuid, commentIdServer2, 'comment 1-4')
+    await servers[2].comments.addReply({ videoId: missedVideo2.uuid, toCommentId: commentIdServer2, text: 'comment 1-4' })
 
     await waitJobs(servers)
 
-    {
-      const resComment = await getVideoThreadComments(servers[0].url, missedVideo2.uuid, threadIdServer1)
+    const tree = await commentCommands[0].getThread({ videoId: missedVideo2.uuid, threadId: threadIdServer1 })
 
-      const tree: VideoCommentThreadTree = resComment.body
-      expect(tree.comment.text).equal('thread 1')
-      expect(tree.children).to.have.lengthOf(1)
+    expect(tree.comment.text).equal('thread 1')
+    expect(tree.children).to.have.lengthOf(1)
 
-      const firstChild = tree.children[0]
-      expect(firstChild.comment.text).to.equal('comment 1-1')
-      expect(firstChild.children).to.have.lengthOf(1)
+    const firstChild = tree.children[0]
+    expect(firstChild.comment.text).to.equal('comment 1-1')
+    expect(firstChild.children).to.have.lengthOf(1)
 
-      const childOfFirstChild = firstChild.children[0]
-      expect(childOfFirstChild.comment.text).to.equal('comment 1-2')
-      expect(childOfFirstChild.children).to.have.lengthOf(1)
+    const childOfFirstChild = firstChild.children[0]
+    expect(childOfFirstChild.comment.text).to.equal('comment 1-2')
+    expect(childOfFirstChild.children).to.have.lengthOf(1)
 
-      const childOfChildFirstChild = childOfFirstChild.children[0]
-      expect(childOfChildFirstChild.comment.text).to.equal('comment 1-3')
-      expect(childOfChildFirstChild.children).to.have.lengthOf(1)
+    const childOfChildFirstChild = childOfFirstChild.children[0]
+    expect(childOfChildFirstChild.comment.text).to.equal('comment 1-3')
+    expect(childOfChildFirstChild.children).to.have.lengthOf(1)
 
-      const childOfChildOfChildOfFirstChild = childOfChildFirstChild.children[0]
-      expect(childOfChildOfChildOfFirstChild.comment.text).to.equal('comment 1-4')
-      expect(childOfChildOfChildOfFirstChild.children).to.have.lengthOf(0)
-    }
+    const childOfChildOfChildOfFirstChild = childOfChildFirstChild.children[0]
+    expect(childOfChildOfChildOfFirstChild.comment.text).to.equal('comment 1-4')
+    expect(childOfChildOfChildOfFirstChild.children).to.have.lengthOf(0)
   })
 
   it('Should upload many videos on server 1', async function () {
     this.timeout(120000)
 
     for (let i = 0; i < 10; i++) {
-      const uuid = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video ' + i })).uuid
+      const uuid = (await servers[0].videos.quickUpload({ name: 'video ' + i })).uuid
       videoIdsServer1.push(uuid)
     }
 
     await waitJobs(servers)
 
     for (const id of videoIdsServer1) {
-      await getVideo(servers[1].url, id)
+      await servers[1].videos.get({ id })
     }
 
     await waitJobs(servers)
-    await setActorFollowScores(servers[1].internalServerNumber, 20)
+    await servers[1].sql.setActorFollowScores(20)
 
     // Wait video expiration
     await wait(11000)
 
     // Refresh video -> score + 10 = 30
-    await getVideo(servers[1].url, videoIdsServer1[0])
+    await servers[1].videos.get({ id: videoIdsServer1[0] })
 
     await waitJobs(servers)
   })
@@ -341,27 +309,25 @@ describe('Test handle downs', function () {
   it('Should remove followings that are down', async function () {
     this.timeout(120000)
 
-    killallServers([ servers[0] ])
+    await killallServers([ servers[0] ])
 
     // Wait video expiration
     await wait(11000)
 
     for (let i = 0; i < 5; i++) {
       try {
-        await getVideo(servers[1].url, videoIdsServer1[i])
+        await servers[1].videos.get({ id: videoIdsServer1[i] })
         await waitJobs([ servers[1] ])
         await wait(1500)
       } catch {}
     }
 
     for (const id of videoIdsServer1) {
-      await getVideo(servers[1].url, id, HttpStatusCode.FORBIDDEN_403)
+      await servers[1].videos.get({ id, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     }
   })
 
   after(async function () {
-    await closeAllSequelize([ servers[1] ])
-
     await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/server/homepage.ts b/server/tests/api/server/homepage.ts
index e8ba89ca6..cb3ba5677 100644
--- a/server/tests/api/server/homepage.ts
+++ b/server/tests/api/server/homepage.ts
@@ -2,51 +2,48 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { HttpStatusCode } from '@shared/core-utils'
-import { CustomPage, ServerConfig } from '@shared/models'
+import { HttpStatusCode } from '@shared/models'
 import {
   cleanupTests,
-  flushAndRunServer,
-  getConfig,
-  getInstanceHomepage,
+  createSingleServer,
+  CustomPagesCommand,
   killallServers,
-  reRunServer,
-  ServerInfo,
-  setAccessTokensToServers,
-  updateInstanceHomepage
+  PeerTubeServer,
+  setAccessTokensToServers
 } from '../../../../shared/extra-utils/index'
 
 const expect = chai.expect
 
-async function getHomepageState (server: ServerInfo) {
-  const res = await getConfig(server.url)
+async function getHomepageState (server: PeerTubeServer) {
+  const config = await server.config.getConfig()
 
-  const config = res.body as ServerConfig
   return config.homepage.enabled
 }
 
 describe('Test instance homepage actions', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
+  let command: CustomPagesCommand
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
+
+    command = server.customPage
   })
 
   it('Should not have a homepage', async function () {
     const state = await getHomepageState(server)
     expect(state).to.be.false
 
-    await getInstanceHomepage(server.url, HttpStatusCode.NOT_FOUND_404)
+    await command.getInstanceHomepage({ expectedStatus: HttpStatusCode.NOT_FOUND_404 })
   })
 
   it('Should set a homepage', async function () {
-    await updateInstanceHomepage(server.url, server.accessToken, '<picsou-magazine></picsou-magazine>')
+    await command.updateInstanceHomepage({ content: '<picsou-magazine></picsou-magazine>' })
 
-    const res = await getInstanceHomepage(server.url)
-    const page: CustomPage = res.body
+    const page = await command.getInstanceHomepage()
     expect(page.content).to.equal('<picsou-magazine></picsou-magazine>')
 
     const state = await getHomepageState(server)
@@ -56,12 +53,11 @@ describe('Test instance homepage actions', function () {
   it('Should have the same homepage after a restart', async function () {
     this.timeout(30000)
 
-    killallServers([ server ])
+    await killallServers([ server ])
 
-    await reRunServer(server)
+    await server.run()
 
-    const res = await getInstanceHomepage(server.url)
-    const page: CustomPage = res.body
+    const page = await command.getInstanceHomepage()
     expect(page.content).to.equal('<picsou-magazine></picsou-magazine>')
 
     const state = await getHomepageState(server)
@@ -69,10 +65,9 @@ describe('Test instance homepage actions', function () {
   })
 
   it('Should empty the homepage', async function () {
-    await updateInstanceHomepage(server.url, server.accessToken, '')
+    await command.updateInstanceHomepage({ content: '' })
 
-    const res = await getInstanceHomepage(server.url)
-    const page: CustomPage = res.body
+    const page = await command.getInstanceHomepage()
     expect(page.content).to.be.empty
 
     const state = await getHomepageState(server)
diff --git a/server/tests/api/server/jobs.ts b/server/tests/api/server/jobs.ts
index d0e222997..c10c154c2 100644
--- a/server/tests/api/server/jobs.ts
+++ b/server/tests/api/server/jobs.ts
@@ -1,24 +1,26 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import { cleanupTests, ServerInfo, setAccessTokensToServers } from '../../../../shared/extra-utils/index'
-import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
-import { getJobsList, getJobsListPaginationAndSort, waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { flushAndRunMultipleServers } from '../../../../shared/extra-utils/server/servers'
-import { uploadVideo } from '../../../../shared/extra-utils/videos/videos'
-import { dateIsValid } from '../../../../shared/extra-utils/miscs/miscs'
-import { Job } from '../../../../shared/models/server'
+import * as chai from 'chai'
+import {
+  cleanupTests,
+  createMultipleServers,
+  dateIsValid,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test jobs', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
 
   before(async function () {
     this.timeout(30000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
@@ -27,36 +29,34 @@ describe('Test jobs', function () {
   })
 
   it('Should create some jobs', async function () {
-    this.timeout(60000)
+    this.timeout(120000)
 
-    await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video1' })
-    await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video2' })
+    await servers[1].videos.upload({ attributes: { name: 'video1' } })
+    await servers[1].videos.upload({ attributes: { name: 'video2' } })
 
     await waitJobs(servers)
   })
 
   it('Should list jobs', async function () {
-    const res = await getJobsList(servers[1].url, servers[1].accessToken, 'completed')
-    expect(res.body.total).to.be.above(2)
-    expect(res.body.data).to.have.length.above(2)
+    const body = await servers[1].jobs.getJobsList({ state: 'completed' })
+    expect(body.total).to.be.above(2)
+    expect(body.data).to.have.length.above(2)
   })
 
   it('Should list jobs with sort, pagination and job type', async function () {
     {
-      const res = await getJobsListPaginationAndSort({
-        url: servers[1].url,
-        accessToken: servers[1].accessToken,
+      const body = await servers[1].jobs.getJobsList({
         state: 'completed',
         start: 1,
         count: 2,
         sort: 'createdAt'
       })
-      expect(res.body.total).to.be.above(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      expect(body.total).to.be.above(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      let job: Job = res.body.data[0]
+      let job = body.data[0]
       // Skip repeat jobs
-      if (job.type === 'videos-views') job = res.body.data[1]
+      if (job.type === 'videos-views') job = body.data[1]
 
       expect(job.state).to.equal('completed')
       expect(job.type.startsWith('activitypub-')).to.be.true
@@ -66,29 +66,26 @@ describe('Test jobs', function () {
     }
 
     {
-      const res = await getJobsListPaginationAndSort({
-        url: servers[1].url,
-        accessToken: servers[1].accessToken,
+      const body = await servers[1].jobs.getJobsList({
         state: 'completed',
         start: 0,
         count: 100,
         sort: 'createdAt',
         jobType: 'activitypub-http-broadcast'
       })
-      expect(res.body.total).to.be.above(2)
+      expect(body.total).to.be.above(2)
 
-      for (const j of res.body.data as Job[]) {
+      for (const j of body.data) {
         expect(j.type).to.equal('activitypub-http-broadcast')
       }
     }
   })
 
   it('Should list all jobs', async function () {
-    const res = await getJobsList(servers[1].url, servers[1].accessToken)
-
-    const jobs = res.body.data as Job[]
+    const body = await servers[1].jobs.getJobsList()
+    expect(body.total).to.be.above(2)
 
-    expect(res.body.total).to.be.above(2)
+    const jobs = body.data
     expect(jobs).to.have.length.above(2)
 
     // We know there are a least 1 delayed job (video views) and 1 completed job (broadcast)
diff --git a/server/tests/api/server/logs.ts b/server/tests/api/server/logs.ts
index bc398ea73..bcd94dda3 100644
--- a/server/tests/api/server/logs.ts
+++ b/server/tests/api/server/logs.ts
@@ -4,27 +4,27 @@ import 'mocha'
 import * as chai from 'chai'
 import {
   cleanupTests,
-  flushAndRunServer,
+  createSingleServer,
   killallServers,
-  makePingRequest,
-  reRunServer,
-  ServerInfo,
-  setAccessTokensToServers
-} from '../../../../shared/extra-utils/index'
-import { getAuditLogs, getLogs } from '../../../../shared/extra-utils/logs/logs'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { uploadVideo } from '../../../../shared/extra-utils/videos/videos'
+  LogsCommand,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test logs', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
+  let logsCommand: LogsCommand
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
+
+    logsCommand = server.logs
   })
 
   describe('With the standard log file', function () {
@@ -32,16 +32,16 @@ describe('Test logs', function () {
     it('Should get logs with a start date', async function () {
       this.timeout(20000)
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 1' })
+      await server.videos.upload({ attributes: { name: 'video 1' } })
       await waitJobs([ server ])
 
       const now = new Date()
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
+      await server.videos.upload({ attributes: { name: 'video 2' } })
       await waitJobs([ server ])
 
-      const res = await getLogs(server.url, server.accessToken, now)
-      const logsString = JSON.stringify(res.body)
+      const body = await logsCommand.getLogs({ startDate: now })
+      const logsString = JSON.stringify(body)
 
       expect(logsString.includes('video 1')).to.be.false
       expect(logsString.includes('video 2')).to.be.true
@@ -50,21 +50,21 @@ describe('Test logs', function () {
     it('Should get logs with an end date', async function () {
       this.timeout(30000)
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 3' })
+      await server.videos.upload({ attributes: { name: 'video 3' } })
       await waitJobs([ server ])
 
       const now1 = new Date()
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 4' })
+      await server.videos.upload({ attributes: { name: 'video 4' } })
       await waitJobs([ server ])
 
       const now2 = new Date()
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 5' })
+      await server.videos.upload({ attributes: { name: 'video 5' } })
       await waitJobs([ server ])
 
-      const res = await getLogs(server.url, server.accessToken, now1, now2)
-      const logsString = JSON.stringify(res.body)
+      const body = await logsCommand.getLogs({ startDate: now1, endDate: now2 })
+      const logsString = JSON.stringify(body)
 
       expect(logsString.includes('video 3')).to.be.false
       expect(logsString.includes('video 4')).to.be.true
@@ -76,19 +76,19 @@ describe('Test logs', function () {
 
       const now = new Date()
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 6' })
+      await server.videos.upload({ attributes: { name: 'video 6' } })
       await waitJobs([ server ])
 
       {
-        const res = await getLogs(server.url, server.accessToken, now, undefined, 'info')
-        const logsString = JSON.stringify(res.body)
+        const body = await logsCommand.getLogs({ startDate: now, level: 'info' })
+        const logsString = JSON.stringify(body)
 
         expect(logsString.includes('video 6')).to.be.true
       }
 
       {
-        const res = await getLogs(server.url, server.accessToken, now, undefined, 'warn')
-        const logsString = JSON.stringify(res.body)
+        const body = await logsCommand.getLogs({ startDate: now, level: 'warn' })
+        const logsString = JSON.stringify(body)
 
         expect(logsString.includes('video 6')).to.be.false
       }
@@ -99,10 +99,10 @@ describe('Test logs', function () {
 
       const now = new Date()
 
-      await makePingRequest(server)
+      await server.servers.ping()
 
-      const res = await getLogs(server.url, server.accessToken, now, undefined, 'info')
-      const logsString = JSON.stringify(res.body)
+      const body = await logsCommand.getLogs({ startDate: now, level: 'info' })
+      const logsString = JSON.stringify(body)
 
       expect(logsString.includes('/api/v1/ping')).to.be.true
     })
@@ -110,16 +110,16 @@ describe('Test logs', function () {
     it('Should not log ping requests', async function () {
       this.timeout(30000)
 
-      killallServers([ server ])
+      await killallServers([ server ])
 
-      await reRunServer(server, { log: { log_ping_requests: false } })
+      await server.run({ log: { log_ping_requests: false } })
 
       const now = new Date()
 
-      await makePingRequest(server)
+      await server.servers.ping()
 
-      const res = await getLogs(server.url, server.accessToken, now, undefined, 'info')
-      const logsString = JSON.stringify(res.body)
+      const body = await logsCommand.getLogs({ startDate: now, level: 'info' })
+      const logsString = JSON.stringify(body)
 
       expect(logsString.includes('/api/v1/ping')).to.be.false
     })
@@ -129,23 +129,23 @@ describe('Test logs', function () {
     it('Should get logs with a start date', async function () {
       this.timeout(20000)
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 7' })
+      await server.videos.upload({ attributes: { name: 'video 7' } })
       await waitJobs([ server ])
 
       const now = new Date()
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 8' })
+      await server.videos.upload({ attributes: { name: 'video 8' } })
       await waitJobs([ server ])
 
-      const res = await getAuditLogs(server.url, server.accessToken, now)
-      const logsString = JSON.stringify(res.body)
+      const body = await logsCommand.getAuditLogs({ startDate: now })
+      const logsString = JSON.stringify(body)
 
       expect(logsString.includes('video 7')).to.be.false
       expect(logsString.includes('video 8')).to.be.true
 
-      expect(res.body).to.have.lengthOf(1)
+      expect(body).to.have.lengthOf(1)
 
-      const item = res.body[0]
+      const item = body[0]
 
       const message = JSON.parse(item.message)
       expect(message.domain).to.equal('videos')
@@ -155,21 +155,21 @@ describe('Test logs', function () {
     it('Should get logs with an end date', async function () {
       this.timeout(30000)
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 9' })
+      await server.videos.upload({ attributes: { name: 'video 9' } })
       await waitJobs([ server ])
 
       const now1 = new Date()
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 10' })
+      await server.videos.upload({ attributes: { name: 'video 10' } })
       await waitJobs([ server ])
 
       const now2 = new Date()
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 11' })
+      await server.videos.upload({ attributes: { name: 'video 11' } })
       await waitJobs([ server ])
 
-      const res = await getAuditLogs(server.url, server.accessToken, now1, now2)
-      const logsString = JSON.stringify(res.body)
+      const body = await logsCommand.getAuditLogs({ startDate: now1, endDate: now2 })
+      const logsString = JSON.stringify(body)
 
       expect(logsString.includes('video 9')).to.be.false
       expect(logsString.includes('video 10')).to.be.true
diff --git a/server/tests/api/server/no-client.ts b/server/tests/api/server/no-client.ts
index d589f51f3..719813ae9 100644
--- a/server/tests/api/server/no-client.ts
+++ b/server/tests/api/server/no-client.ts
@@ -1,16 +1,15 @@
 import 'mocha'
 import * as request from 'supertest'
-import { ServerInfo } from '../../../../shared/extra-utils'
-import { cleanupTests, flushAndRunServer } from '../../../../shared/extra-utils/server/servers'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { cleanupTests, createSingleServer, PeerTubeServer } from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Start and stop server without web client routes', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1, {}, [ '--no-client' ])
+    server = await createSingleServer(1, {}, { peertubeArgs: [ '--no-client' ] })
   })
 
   it('Should fail getting the client', function () {
diff --git a/server/tests/api/server/plugins.ts b/server/tests/api/server/plugins.ts
index 6b61c7c33..5f9f4ffdd 100644
--- a/server/tests/api/server/plugins.ts
+++ b/server/tests/api/server/plugins.ts
@@ -2,41 +2,23 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { HttpStatusCode } from '@shared/core-utils'
 import {
   cleanupTests,
-  closeAllSequelize,
-  flushAndRunServer,
-  getConfig,
-  getMyUserInformation,
-  getPlugin,
-  getPluginPackageJSON,
-  getPluginTestPath,
-  getPublicSettings,
-  installPlugin,
+  createSingleServer,
   killallServers,
-  listAvailablePlugins,
-  listPlugins,
-  reRunServer,
-  ServerInfo,
+  PeerTubeServer,
+  PluginsCommand,
   setAccessTokensToServers,
-  setPluginVersion,
   testHelloWorldRegisteredSettings,
-  uninstallPlugin,
-  updateCustomSubConfig,
-  updateMyUser,
-  updatePlugin,
-  updatePluginPackageJSON,
-  updatePluginSettings,
-  wait,
-  waitUntilLog
+  wait
 } from '@shared/extra-utils'
-import { PeerTubePlugin, PeerTubePluginIndex, PluginPackageJson, PluginType, PublicServerSetting, ServerConfig, User } from '@shared/models'
+import { HttpStatusCode, PluginType } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test plugins', function () {
-  let server: ServerInfo = null
+  let server: PeerTubeServer = null
+  let command: PluginsCommand
 
   before(async function () {
     this.timeout(30000)
@@ -46,68 +28,61 @@ describe('Test plugins', function () {
         index: { check_latest_versions_interval: '5 seconds' }
       }
     }
-    server = await flushAndRunServer(1, configOverride)
+    server = await createSingleServer(1, configOverride)
     await setAccessTokensToServers([ server ])
+
+    command = server.plugins
   })
 
   it('Should list and search available plugins and themes', async function () {
     this.timeout(30000)
 
     {
-      const res = await listAvailablePlugins({
-        url: server.url,
-        accessToken: server.accessToken,
+      const body = await command.listAvailable({
         count: 1,
         start: 0,
         pluginType: PluginType.THEME,
         search: 'background-red'
       })
 
-      expect(res.body.total).to.be.at.least(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      expect(body.total).to.be.at.least(1)
+      expect(body.data).to.have.lengthOf(1)
     }
 
     {
-      const res1 = await listAvailablePlugins({
-        url: server.url,
-        accessToken: server.accessToken,
+      const body1 = await command.listAvailable({
         count: 2,
         start: 0,
         sort: 'npmName'
       })
-      const data1: PeerTubePluginIndex[] = res1.body.data
+      expect(body1.total).to.be.at.least(2)
 
-      expect(res1.body.total).to.be.at.least(2)
+      const data1 = body1.data
       expect(data1).to.have.lengthOf(2)
 
-      const res2 = await listAvailablePlugins({
-        url: server.url,
-        accessToken: server.accessToken,
+      const body2 = await command.listAvailable({
         count: 2,
         start: 0,
         sort: '-npmName'
       })
-      const data2: PeerTubePluginIndex[] = res2.body.data
+      expect(body2.total).to.be.at.least(2)
 
-      expect(res2.body.total).to.be.at.least(2)
+      const data2 = body2.data
       expect(data2).to.have.lengthOf(2)
 
       expect(data1[0].npmName).to.not.equal(data2[0].npmName)
     }
 
     {
-      const res = await listAvailablePlugins({
-        url: server.url,
-        accessToken: server.accessToken,
+      const body = await command.listAvailable({
         count: 10,
         start: 0,
         pluginType: PluginType.THEME,
         search: 'background-red',
         currentPeerTubeEngine: '1.0.0'
       })
-      const data: PeerTubePluginIndex[] = res.body.data
 
-      const p = data.find(p => p.npmName === 'peertube-theme-background-red')
+      const p = body.data.find(p => p.npmName === 'peertube-theme-background-red')
       expect(p).to.be.undefined
     }
   })
@@ -115,22 +90,12 @@ describe('Test plugins', function () {
   it('Should install a plugin and a theme', async function () {
     this.timeout(30000)
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-plugin-hello-world'
-    })
-
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-theme-background-red'
-    })
+    await command.install({ npmName: 'peertube-plugin-hello-world' })
+    await command.install({ npmName: 'peertube-theme-background-red' })
   })
 
   it('Should have the plugin loaded in the configuration', async function () {
-    const res = await getConfig(server.url)
-    const config: ServerConfig = res.body
+    const config = await server.config.getConfig()
 
     const theme = config.theme.registered.find(r => r.name === 'background-red')
     expect(theme).to.not.be.undefined
@@ -140,66 +105,56 @@ describe('Test plugins', function () {
   })
 
   it('Should update the default theme in the configuration', async function () {
-    await updateCustomSubConfig(server.url, server.accessToken, { theme: { default: 'background-red' } })
-
-    const res = await getConfig(server.url)
-    const config: ServerConfig = res.body
+    await server.config.updateCustomSubConfig({
+      newConfig: {
+        theme: { default: 'background-red' }
+      }
+    })
 
+    const config = await server.config.getConfig()
     expect(config.theme.default).to.equal('background-red')
   })
 
   it('Should update my default theme', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: server.accessToken,
-      theme: 'background-red'
-    })
+    await server.users.updateMe({ theme: 'background-red' })
 
-    const res = await getMyUserInformation(server.url, server.accessToken)
-    expect((res.body as User).theme).to.equal('background-red')
+    const user = await server.users.getMyInfo()
+    expect(user.theme).to.equal('background-red')
   })
 
   it('Should list plugins and themes', async function () {
     {
-      const res = await listPlugins({
-        url: server.url,
-        accessToken: server.accessToken,
+      const body = await command.list({
         count: 1,
         start: 0,
         pluginType: PluginType.THEME
       })
-      const data: PeerTubePlugin[] = res.body.data
+      expect(body.total).to.be.at.least(1)
 
-      expect(res.body.total).to.be.at.least(1)
+      const data = body.data
       expect(data).to.have.lengthOf(1)
       expect(data[0].name).to.equal('background-red')
     }
 
     {
-      const res = await listPlugins({
-        url: server.url,
-        accessToken: server.accessToken,
+      const { data } = await command.list({
         count: 2,
         start: 0,
         sort: 'name'
       })
-      const data: PeerTubePlugin[] = res.body.data
 
       expect(data[0].name).to.equal('background-red')
       expect(data[1].name).to.equal('hello-world')
     }
 
     {
-      const res = await listPlugins({
-        url: server.url,
-        accessToken: server.accessToken,
+      const body = await command.list({
         count: 2,
         start: 1,
         sort: 'name'
       })
-      const data: PeerTubePlugin[] = res.body.data
 
-      expect(data[0].name).to.equal('hello-world')
+      expect(body.data[0].name).to.equal('hello-world')
     }
   })
 
@@ -208,9 +163,8 @@ describe('Test plugins', function () {
   })
 
   it('Should get public settings', async function () {
-    const res = await getPublicSettings({ url: server.url, npmName: 'peertube-plugin-hello-world' })
-
-    const publicSettings = (res.body as PublicServerSetting).publicSettings
+    const body = await command.getPublicSettings({ npmName: 'peertube-plugin-hello-world' })
+    const publicSettings = body.publicSettings
 
     expect(Object.keys(publicSettings)).to.have.lengthOf(1)
     expect(Object.keys(publicSettings)).to.deep.equal([ 'user-name' ])
@@ -222,9 +176,7 @@ describe('Test plugins', function () {
       'admin-name': 'Cid'
     }
 
-    await updatePluginSettings({
-      url: server.url,
-      accessToken: server.accessToken,
+    await command.updateSettings({
       npmName: 'peertube-plugin-hello-world',
       settings
     })
@@ -233,18 +185,12 @@ describe('Test plugins', function () {
   it('Should have watched settings changes', async function () {
     this.timeout(10000)
 
-    await waitUntilLog(server, 'Settings changed!')
+    await server.servers.waitUntilLog('Settings changed!')
   })
 
   it('Should get a plugin and a theme', async function () {
     {
-      const res = await getPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        npmName: 'peertube-plugin-hello-world'
-      })
-
-      const plugin: PeerTubePlugin = res.body
+      const plugin = await command.get({ npmName: 'peertube-plugin-hello-world' })
 
       expect(plugin.type).to.equal(PluginType.PLUGIN)
       expect(plugin.name).to.equal('hello-world')
@@ -262,13 +208,7 @@ describe('Test plugins', function () {
     }
 
     {
-      const res = await getPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        npmName: 'peertube-theme-background-red'
-      })
-
-      const plugin: PeerTubePlugin = res.body
+      const plugin = await command.get({ npmName: 'peertube-theme-background-red' })
 
       expect(plugin.type).to.equal(PluginType.THEME)
       expect(plugin.name).to.equal('background-red')
@@ -292,101 +232,66 @@ describe('Test plugins', function () {
     await wait(6000)
 
     // Fake update our plugin version
-    await setPluginVersion(server.internalServerNumber, 'hello-world', '0.0.1')
+    await server.sql.setPluginVersion('hello-world', '0.0.1')
 
     // Fake update package.json
-    const packageJSON: PluginPackageJson = await getPluginPackageJSON(server, 'peertube-plugin-hello-world')
+    const packageJSON = await command.getPackageJSON('peertube-plugin-hello-world')
     const oldVersion = packageJSON.version
 
     packageJSON.version = '0.0.1'
-    await updatePluginPackageJSON(server, 'peertube-plugin-hello-world', packageJSON)
+    await command.updatePackageJSON('peertube-plugin-hello-world', packageJSON)
 
     // Restart the server to take into account this change
-    killallServers([ server ])
-    await reRunServer(server)
+    await killallServers([ server ])
+    await server.run()
 
     {
-      const res = await listPlugins({
-        url: server.url,
-        accessToken: server.accessToken,
-        pluginType: PluginType.PLUGIN
-      })
-
-      const plugin: PeerTubePlugin = res.body.data[0]
+      const body = await command.list({ pluginType: PluginType.PLUGIN })
 
+      const plugin = body.data[0]
       expect(plugin.version).to.equal('0.0.1')
       expect(plugin.latestVersion).to.exist
       expect(plugin.latestVersion).to.not.equal('0.0.1')
     }
 
     {
-      await updatePlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        npmName: 'peertube-plugin-hello-world'
-      })
-
-      const res = await listPlugins({
-        url: server.url,
-        accessToken: server.accessToken,
-        pluginType: PluginType.PLUGIN
-      })
+      await command.update({ npmName: 'peertube-plugin-hello-world' })
 
-      const plugin: PeerTubePlugin = res.body.data[0]
+      const body = await command.list({ pluginType: PluginType.PLUGIN })
 
+      const plugin = body.data[0]
       expect(plugin.version).to.equal(oldVersion)
 
-      const updatedPackageJSON: PluginPackageJson = await getPluginPackageJSON(server, 'peertube-plugin-hello-world')
+      const updatedPackageJSON = await command.getPackageJSON('peertube-plugin-hello-world')
       expect(updatedPackageJSON.version).to.equal(oldVersion)
     }
   })
 
   it('Should uninstall the plugin', async function () {
-    await uninstallPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-plugin-hello-world'
-    })
-
-    const res = await listPlugins({
-      url: server.url,
-      accessToken: server.accessToken,
-      pluginType: PluginType.PLUGIN
-    })
+    await command.uninstall({ npmName: 'peertube-plugin-hello-world' })
 
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    const body = await command.list({ pluginType: PluginType.PLUGIN })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   it('Should list uninstalled plugins', async function () {
-    const res = await listPlugins({
-      url: server.url,
-      accessToken: server.accessToken,
-      pluginType: PluginType.PLUGIN,
-      uninstalled: true
-    })
-
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.have.lengthOf(1)
+    const body = await command.list({ pluginType: PluginType.PLUGIN, uninstalled: true })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.have.lengthOf(1)
 
-    const plugin: PeerTubePlugin = res.body.data[0]
+    const plugin = body.data[0]
     expect(plugin.name).to.equal('hello-world')
     expect(plugin.enabled).to.be.false
     expect(plugin.uninstalled).to.be.true
   })
 
   it('Should uninstall the theme', async function () {
-    await uninstallPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-theme-background-red'
-    })
+    await command.uninstall({ npmName: 'peertube-theme-background-red' })
   })
 
   it('Should have updated the configuration', async function () {
-    // get /config (default theme + registered themes + registered plugins)
-    const res = await getConfig(server.url)
-    const config: ServerConfig = res.body
+    const config = await server.config.getConfig()
 
     expect(config.theme.default).to.equal('default')
 
@@ -398,42 +303,33 @@ describe('Test plugins', function () {
   })
 
   it('Should have updated the user theme', async function () {
-    const res = await getMyUserInformation(server.url, server.accessToken)
-    expect((res.body as User).theme).to.equal('instance-default')
+    const user = await server.users.getMyInfo()
+    expect(user.theme).to.equal('instance-default')
   })
 
   it('Should not install a broken plugin', async function () {
     this.timeout(60000)
 
     async function check () {
-      const res = await listPlugins({
-        url: server.url,
-        accessToken: server.accessToken,
-        pluginType: PluginType.PLUGIN
-      })
-
-      const plugins: PeerTubePlugin[] = res.body.data
-
+      const body = await command.list({ pluginType: PluginType.PLUGIN })
+      const plugins = body.data
       expect(plugins.find(p => p.name === 'test-broken')).to.not.exist
     }
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      path: getPluginTestPath('-broken'),
+    await command.install({
+      path: PluginsCommand.getPluginTestPath('-broken'),
       expectedStatus: HttpStatusCode.BAD_REQUEST_400
     })
 
     await check()
 
-    killallServers([ server ])
-    await reRunServer(server)
+    await killallServers([ server ])
+    await server.run()
 
     await check()
   })
 
   after(async function () {
-    await closeAllSequelize([ server ])
     await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/server/reverse-proxy.ts b/server/tests/api/server/reverse-proxy.ts
index 17d1ee4a5..484f88d67 100644
--- a/server/tests/api/server/reverse-proxy.ts
+++ b/server/tests/api/server/reverse-proxy.ts
@@ -1,16 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import 'mocha'
-import * as chai from 'chai'
-import { cleanupTests, getVideo, registerUser, uploadVideo, userLogin, viewVideo, wait } from '../../../../shared/extra-utils'
-import { flushAndRunServer, setAccessTokensToServers } from '../../../../shared/extra-utils/index'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-
-const expect = chai.expect
+import { expect } from 'chai'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers, wait } from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test application behind a reverse proxy', function () {
-  let server = null
-  let videoId
+  let server: PeerTubeServer
+  let videoId: string
 
   before(async function () {
     this.timeout(30000)
@@ -34,85 +30,85 @@ describe('Test application behind a reverse proxy', function () {
       }
     }
 
-    server = await flushAndRunServer(1, config)
+    server = await createSingleServer(1, config)
     await setAccessTokensToServers([ server ])
 
-    const { body } = await uploadVideo(server.url, server.accessToken, {})
-    videoId = body.video.uuid
+    const { uuid } = await server.videos.upload()
+    videoId = uuid
   })
 
   it('Should view a video only once with the same IP by default', async function () {
     this.timeout(20000)
 
-    await viewVideo(server.url, videoId)
-    await viewVideo(server.url, videoId)
+    await server.videos.view({ id: videoId })
+    await server.videos.view({ id: videoId })
 
     // Wait the repeatable job
     await wait(8000)
 
-    const { body } = await getVideo(server.url, videoId)
-    expect(body.views).to.equal(1)
+    const video = await server.videos.get({ id: videoId })
+    expect(video.views).to.equal(1)
   })
 
   it('Should view a video 2 times with the X-Forwarded-For header set', async function () {
     this.timeout(20000)
 
-    await viewVideo(server.url, videoId, HttpStatusCode.NO_CONTENT_204, '0.0.0.1,127.0.0.1')
-    await viewVideo(server.url, videoId, HttpStatusCode.NO_CONTENT_204, '0.0.0.2,127.0.0.1')
+    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.1,127.0.0.1' })
+    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.2,127.0.0.1' })
 
     // Wait the repeatable job
     await wait(8000)
 
-    const { body } = await getVideo(server.url, videoId)
-    expect(body.views).to.equal(3)
+    const video = await server.videos.get({ id: videoId })
+    expect(video.views).to.equal(3)
   })
 
   it('Should view a video only once with the same client IP in the X-Forwarded-For header', async function () {
     this.timeout(20000)
 
-    await viewVideo(server.url, videoId, HttpStatusCode.NO_CONTENT_204, '0.0.0.4,0.0.0.3,::ffff:127.0.0.1')
-    await viewVideo(server.url, videoId, HttpStatusCode.NO_CONTENT_204, '0.0.0.5,0.0.0.3,127.0.0.1')
+    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.4,0.0.0.3,::ffff:127.0.0.1' })
+    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.5,0.0.0.3,127.0.0.1' })
 
     // Wait the repeatable job
     await wait(8000)
 
-    const { body } = await getVideo(server.url, videoId)
-    expect(body.views).to.equal(4)
+    const video = await server.videos.get({ id: videoId })
+    expect(video.views).to.equal(4)
   })
 
   it('Should view a video two times with a different client IP in the X-Forwarded-For header', async function () {
     this.timeout(20000)
 
-    await viewVideo(server.url, videoId, HttpStatusCode.NO_CONTENT_204, '0.0.0.8,0.0.0.6,127.0.0.1')
-    await viewVideo(server.url, videoId, HttpStatusCode.NO_CONTENT_204, '0.0.0.8,0.0.0.7,127.0.0.1')
+    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.8,0.0.0.6,127.0.0.1' })
+    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.8,0.0.0.7,127.0.0.1' })
 
     // Wait the repeatable job
     await wait(8000)
 
-    const { body } = await getVideo(server.url, videoId)
-    expect(body.views).to.equal(6)
+    const video = await server.videos.get({ id: videoId })
+    expect(video.views).to.equal(6)
   })
 
   it('Should rate limit logins', async function () {
     const user = { username: 'root', password: 'fail' }
 
     for (let i = 0; i < 19; i++) {
-      await userLogin(server, user, HttpStatusCode.BAD_REQUEST_400)
+      await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     }
 
-    await userLogin(server, user, HttpStatusCode.TOO_MANY_REQUESTS_429)
+    await server.login.login({ user, expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
   })
 
   it('Should rate limit signup', async function () {
     for (let i = 0; i < 10; i++) {
       try {
-        await registerUser(server.url, 'test' + i, 'password')
+        await server.users.register({ username: 'test' + i })
       } catch {
         // empty
       }
     }
 
-    await registerUser(server.url, 'test42', 'password', HttpStatusCode.TOO_MANY_REQUESTS_429)
+    await server.users.register({ username: 'test42', expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
   })
 
   it('Should not rate limit failed signup', async function () {
@@ -121,10 +117,10 @@ describe('Test application behind a reverse proxy', function () {
     await wait(7000)
 
     for (let i = 0; i < 3; i++) {
-      await registerUser(server.url, 'test' + i, 'password', HttpStatusCode.CONFLICT_409)
+      await server.users.register({ username: 'test' + i, expectedStatus: HttpStatusCode.CONFLICT_409 })
     }
 
-    await registerUser(server.url, 'test43', 'password', HttpStatusCode.NO_CONTENT_204)
+    await server.users.register({ username: 'test43', expectedStatus: HttpStatusCode.NO_CONTENT_204 })
 
   })
 
@@ -135,13 +131,13 @@ describe('Test application behind a reverse proxy', function () {
 
     for (let i = 0; i < 100; i++) {
       try {
-        await getVideo(server.url, videoId)
+        await server.videos.get({ id: videoId })
       } catch {
         // don't care if it fails
       }
     }
 
-    await getVideo(server.url, videoId, HttpStatusCode.TOO_MANY_REQUESTS_429)
+    await server.videos.get({ id: videoId, expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
   })
 
   after(async function () {
diff --git a/server/tests/api/server/services.ts b/server/tests/api/server/services.ts
index ea64e4040..69d030dbb 100644
--- a/server/tests/api/server/services.ts
+++ b/server/tests/api/server/services.ts
@@ -2,23 +2,13 @@
 
 import 'mocha'
 import * as chai from 'chai'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers, setDefaultVideoChannel } from '@shared/extra-utils'
 import { Video, VideoPlaylistPrivacy } from '@shared/models'
-import {
-  addVideoInPlaylist,
-  createVideoPlaylist,
-  getOEmbed,
-  getVideosList,
-  ServerInfo,
-  setAccessTokensToServers,
-  setDefaultVideoChannel,
-  uploadVideo
-} from '../../../../shared/extra-utils'
-import { cleanupTests, flushAndRunServer } from '../../../../shared/extra-utils/server/servers'
 
 const expect = chai.expect
 
 describe('Test services', function () {
-  let server: ServerInfo = null
+  let server: PeerTubeServer = null
   let playlistUUID: string
   let playlistDisplayName: string
   let video: Video
@@ -26,40 +16,34 @@ describe('Test services', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
     await setDefaultVideoChannel([ server ])
 
     {
-      const videoAttributes = {
-        name: 'my super name'
-      }
-      await uploadVideo(server.url, server.accessToken, videoAttributes)
+      const attributes = { name: 'my super name' }
+      await server.videos.upload({ attributes })
 
-      const res = await getVideosList(server.url)
-      video = res.body.data[0]
+      const { data } = await server.videos.list()
+      video = data[0]
     }
 
     {
-      const res = await createVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
+      const created = await server.playlists.create({
+        attributes: {
           displayName: 'The Life and Times of Scrooge McDuck',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: server.videoChannel.id
+          videoChannelId: server.store.channel.id
         }
       })
 
-      playlistUUID = res.body.videoPlaylist.uuid
+      playlistUUID = created.uuid
       playlistDisplayName = 'The Life and Times of Scrooge McDuck'
 
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: res.body.videoPlaylist.id,
-        elementAttrs: {
+      await server.playlists.addElement({
+        playlistId: created.id,
+        attributes: {
           videoId: video.id
         }
       })
@@ -70,7 +54,7 @@ describe('Test services', function () {
     for (const basePath of [ '/videos/watch/', '/w/' ]) {
       const oembedUrl = 'http://localhost:' + server.port + basePath + video.uuid
 
-      const res = await getOEmbed(server.url, oembedUrl)
+      const res = await server.services.getOEmbed({ oembedUrl })
       const expectedHtml = '<iframe width="560" height="315" sandbox="allow-same-origin allow-scripts" ' +
         `title="${video.name}" src="http://localhost:${server.port}/videos/embed/${video.uuid}" ` +
         'frameborder="0" allowfullscreen></iframe>'
@@ -78,7 +62,7 @@ describe('Test services', function () {
 
       expect(res.body.html).to.equal(expectedHtml)
       expect(res.body.title).to.equal(video.name)
-      expect(res.body.author_name).to.equal(server.videoChannel.displayName)
+      expect(res.body.author_name).to.equal(server.store.channel.displayName)
       expect(res.body.width).to.equal(560)
       expect(res.body.height).to.equal(315)
       expect(res.body.thumbnail_url).to.equal(expectedThumbnailUrl)
@@ -91,14 +75,14 @@ describe('Test services', function () {
     for (const basePath of [ '/videos/watch/playlist/', '/w/p/' ]) {
       const oembedUrl = 'http://localhost:' + server.port + basePath + playlistUUID
 
-      const res = await getOEmbed(server.url, oembedUrl)
+      const res = await server.services.getOEmbed({ oembedUrl })
       const expectedHtml = '<iframe width="560" height="315" sandbox="allow-same-origin allow-scripts" ' +
         `title="${playlistDisplayName}" src="http://localhost:${server.port}/video-playlists/embed/${playlistUUID}" ` +
         'frameborder="0" allowfullscreen></iframe>'
 
       expect(res.body.html).to.equal(expectedHtml)
       expect(res.body.title).to.equal('The Life and Times of Scrooge McDuck')
-      expect(res.body.author_name).to.equal(server.videoChannel.displayName)
+      expect(res.body.author_name).to.equal(server.store.channel.displayName)
       expect(res.body.width).to.equal(560)
       expect(res.body.height).to.equal(315)
       expect(res.body.thumbnail_url).exist
@@ -114,14 +98,14 @@ describe('Test services', function () {
       const maxHeight = 50
       const maxWidth = 50
 
-      const res = await getOEmbed(server.url, oembedUrl, format, maxHeight, maxWidth)
+      const res = await server.services.getOEmbed({ oembedUrl, format, maxHeight, maxWidth })
       const expectedHtml = '<iframe width="50" height="50" sandbox="allow-same-origin allow-scripts" ' +
         `title="${video.name}" src="http://localhost:${server.port}/videos/embed/${video.uuid}" ` +
         'frameborder="0" allowfullscreen></iframe>'
 
       expect(res.body.html).to.equal(expectedHtml)
       expect(res.body.title).to.equal(video.name)
-      expect(res.body.author_name).to.equal(server.videoChannel.displayName)
+      expect(res.body.author_name).to.equal(server.store.channel.displayName)
       expect(res.body.height).to.equal(50)
       expect(res.body.width).to.equal(50)
       expect(res.body).to.not.have.property('thumbnail_url')
diff --git a/server/tests/api/server/stats.ts b/server/tests/api/server/stats.ts
index 304181a6d..5ec771429 100644
--- a/server/tests/api/server/stats.ts
+++ b/server/tests/api/server/stats.ts
@@ -3,33 +3,20 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  addVideoChannel,
   cleanupTests,
-  createUser,
-  createVideoPlaylist,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  follow,
-  ServerInfo,
-  unfollow,
-  updateCustomSubConfig,
-  uploadVideo,
-  userLogin,
-  viewVideo,
-  wait
-} from '../../../../shared/extra-utils'
-import { setAccessTokensToServers } from '../../../../shared/extra-utils/index'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { getStats } from '../../../../shared/extra-utils/server/stats'
-import { addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments'
-import { ServerStats } from '../../../../shared/models/server/server-stats.model'
-import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
-import { ActivityType } from '@shared/models'
+  PeerTubeServer,
+  setAccessTokensToServers,
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { ActivityType, VideoPlaylistPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test stats (excluding redundancy)', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let channelId
   const user = {
     username: 'user1',
@@ -39,31 +26,29 @@ describe('Test stats (excluding redundancy)', function () {
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     await setAccessTokensToServers(servers)
 
     await doubleFollow(servers[0], servers[1])
 
-    await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+    await servers[0].users.create({ username: user.username, password: user.password })
 
-    const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { fixture: 'video_short.webm' })
-    const videoUUID = resVideo.body.video.uuid
+    const { uuid } = await servers[0].videos.upload({ attributes: { fixture: 'video_short.webm' } })
 
-    await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, 'comment')
+    await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
 
-    await viewVideo(servers[0].url, videoUUID)
+    await servers[0].videos.view({ id: uuid })
 
     // Wait the video views repeatable job
     await wait(8000)
 
-    await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken)
+    await servers[2].follows.follow({ hosts: [ servers[0].url ] })
     await waitJobs(servers)
   })
 
   it('Should have the correct stats on instance 1', async function () {
-    const res = await getStats(servers[0].url)
-    const data: ServerStats = res.body
+    const data = await servers[0].stats.get()
 
     expect(data.totalLocalVideoComments).to.equal(1)
     expect(data.totalLocalVideos).to.equal(1)
@@ -78,8 +63,7 @@ describe('Test stats (excluding redundancy)', function () {
   })
 
   it('Should have the correct stats on instance 2', async function () {
-    const res = await getStats(servers[1].url)
-    const data: ServerStats = res.body
+    const data = await servers[1].stats.get()
 
     expect(data.totalLocalVideoComments).to.equal(0)
     expect(data.totalLocalVideos).to.equal(0)
@@ -94,8 +78,7 @@ describe('Test stats (excluding redundancy)', function () {
   })
 
   it('Should have the correct stats on instance 3', async function () {
-    const res = await getStats(servers[2].url)
-    const data: ServerStats = res.body
+    const data = await servers[2].stats.get()
 
     expect(data.totalLocalVideoComments).to.equal(0)
     expect(data.totalLocalVideos).to.equal(0)
@@ -111,11 +94,10 @@ describe('Test stats (excluding redundancy)', function () {
   it('Should have the correct total videos stats after an unfollow', async function () {
     this.timeout(15000)
 
-    await unfollow(servers[2].url, servers[2].accessToken, servers[0])
+    await servers[2].follows.unfollow({ target: servers[0] })
     await waitJobs(servers)
 
-    const res = await getStats(servers[2].url)
-    const data: ServerStats = res.body
+    const data = await servers[2].stats.get()
 
     expect(data.totalVideos).to.equal(0)
   })
@@ -124,18 +106,18 @@ describe('Test stats (excluding redundancy)', function () {
     const server = servers[0]
 
     {
-      const res = await getStats(server.url)
-      const data: ServerStats = res.body
+      const data = await server.stats.get()
+
       expect(data.totalDailyActiveUsers).to.equal(1)
       expect(data.totalWeeklyActiveUsers).to.equal(1)
       expect(data.totalMonthlyActiveUsers).to.equal(1)
     }
 
     {
-      await userLogin(server, user)
+      await server.login.getAccessToken(user)
+
+      const data = await server.stats.get()
 
-      const res = await getStats(server.url)
-      const data: ServerStats = res.body
       expect(data.totalDailyActiveUsers).to.equal(2)
       expect(data.totalWeeklyActiveUsers).to.equal(2)
       expect(data.totalMonthlyActiveUsers).to.equal(2)
@@ -146,33 +128,33 @@ describe('Test stats (excluding redundancy)', function () {
     const server = servers[0]
 
     {
-      const res = await getStats(server.url)
-      const data: ServerStats = res.body
+      const data = await server.stats.get()
+
       expect(data.totalLocalDailyActiveVideoChannels).to.equal(1)
       expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(1)
       expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(1)
     }
 
     {
-      const channelAttributes = {
+      const attributes = {
         name: 'stats_channel',
         displayName: 'My stats channel'
       }
-      const resChannel = await addVideoChannel(server.url, server.accessToken, channelAttributes)
-      channelId = resChannel.body.videoChannel.id
+      const created = await server.channels.create({ attributes })
+      channelId = created.id
+
+      const data = await server.stats.get()
 
-      const res = await getStats(server.url)
-      const data: ServerStats = res.body
       expect(data.totalLocalDailyActiveVideoChannels).to.equal(1)
       expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(1)
       expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(1)
     }
 
     {
-      await uploadVideo(server.url, server.accessToken, { fixture: 'video_short.webm', channelId })
+      await server.videos.upload({ attributes: { fixture: 'video_short.webm', channelId } })
+
+      const data = await server.stats.get()
 
-      const res = await getStats(server.url)
-      const data: ServerStats = res.body
       expect(data.totalLocalDailyActiveVideoChannels).to.equal(2)
       expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(2)
       expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(2)
@@ -183,66 +165,62 @@ describe('Test stats (excluding redundancy)', function () {
     const server = servers[0]
 
     {
-      const resStats = await getStats(server.url)
-      const dataStats: ServerStats = resStats.body
-      expect(dataStats.totalLocalPlaylists).to.equal(0)
+      const data = await server.stats.get()
+      expect(data.totalLocalPlaylists).to.equal(0)
     }
 
     {
-      await createVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
+      await server.playlists.create({
+        attributes: {
           displayName: 'playlist for count',
           privacy: VideoPlaylistPrivacy.PUBLIC,
           videoChannelId: channelId
         }
       })
 
-      const resStats = await getStats(server.url)
-      const dataStats: ServerStats = resStats.body
-      expect(dataStats.totalLocalPlaylists).to.equal(1)
+      const data = await server.stats.get()
+      expect(data.totalLocalPlaylists).to.equal(1)
     }
   })
 
   it('Should correctly count video file sizes if transcoding is enabled', async function () {
     this.timeout(60000)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      transcoding: {
-        enabled: true,
-        webtorrent: {
-          enabled: true
-        },
-        hls: {
-          enabled: true
-        },
-        resolutions: {
-          '0p': false,
-          '240p': false,
-          '360p': false,
-          '480p': false,
-          '720p': false,
-          '1080p': false,
-          '1440p': false,
-          '2160p': false
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        transcoding: {
+          enabled: true,
+          webtorrent: {
+            enabled: true
+          },
+          hls: {
+            enabled: true
+          },
+          resolutions: {
+            '0p': false,
+            '240p': false,
+            '360p': false,
+            '480p': false,
+            '720p': false,
+            '1080p': false,
+            '1440p': false,
+            '2160p': false
+          }
         }
       }
     })
 
-    await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video', fixture: 'video_short.webm' })
+    await servers[0].videos.upload({ attributes: { name: 'video', fixture: 'video_short.webm' } })
 
     await waitJobs(servers)
 
     {
-      const res = await getStats(servers[1].url)
-      const data: ServerStats = res.body
+      const data = await servers[1].stats.get()
       expect(data.totalLocalVideoFilesSize).to.equal(0)
     }
 
     {
-      const res = await getStats(servers[0].url)
-      const data: ServerStats = res.body
+      const data = await servers[0].stats.get()
       expect(data.totalLocalVideoFilesSize).to.be.greaterThan(500000)
       expect(data.totalLocalVideoFilesSize).to.be.lessThan(600000)
     }
@@ -251,27 +229,27 @@ describe('Test stats (excluding redundancy)', function () {
   it('Should have the correct AP stats', async function () {
     this.timeout(60000)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      transcoding: {
-        enabled: false
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        transcoding: {
+          enabled: false
+        }
       }
     })
 
-    const res1 = await getStats(servers[1].url)
-    const first = res1.body as ServerStats
+    const first = await servers[1].stats.get()
 
     for (let i = 0; i < 10; i++) {
-      await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video' })
+      await servers[0].videos.upload({ attributes: { name: 'video' } })
     }
 
     await waitJobs(servers)
 
     await wait(6000)
 
-    const res2 = await getStats(servers[1].url)
-    const second: ServerStats = res2.body
-
+    const second = await servers[1].stats.get()
     expect(second.totalActivityPubMessagesProcessed).to.be.greaterThan(first.totalActivityPubMessagesProcessed)
+
     const apTypes: ActivityType[] = [
       'Create', 'Update', 'Delete', 'Follow', 'Accept', 'Announce', 'Undo', 'Like', 'Reject', 'View', 'Dislike', 'Flag'
     ]
@@ -291,9 +269,7 @@ describe('Test stats (excluding redundancy)', function () {
 
     await wait(6000)
 
-    const res3 = await getStats(servers[1].url)
-    const third: ServerStats = res3.body
-
+    const third = await servers[1].stats.get()
     expect(third.totalActivityPubMessagesWaiting).to.equal(0)
     expect(third.activityPubMessagesProcessedPerSecond).to.be.lessThan(second.activityPubMessagesProcessedPerSecond)
   })
diff --git a/server/tests/api/server/tracker.ts b/server/tests/api/server/tracker.ts
index 4b86e0b90..f597ac60c 100644
--- a/server/tests/api/server/tracker.ts
+++ b/server/tests/api/server/tracker.ts
@@ -1,36 +1,23 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await,@typescript-eslint/no-floating-promises */
 
-import * as magnetUtil from 'magnet-uri'
 import 'mocha'
-import {
-  cleanupTests,
-  flushAndRunServer,
-  getVideo,
-  killallServers,
-  reRunServer,
-  ServerInfo,
-  uploadVideo
-} from '../../../../shared/extra-utils'
-import { setAccessTokensToServers } from '../../../../shared/extra-utils/index'
-import { VideoDetails } from '../../../../shared/models/videos'
+import * as magnetUtil from 'magnet-uri'
 import * as WebTorrent from 'webtorrent'
+import { cleanupTests, createSingleServer, killallServers, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
 
 describe('Test tracker', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let badMagnet: string
   let goodMagnet: string
 
   before(async function () {
     this.timeout(60000)
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
     {
-      const res = await uploadVideo(server.url, server.accessToken, {})
-      const videoUUID = res.body.video.uuid
-
-      const resGet = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = resGet.body
+      const { uuid } = await server.videos.upload()
+      const video = await server.videos.get({ id: uuid })
       goodMagnet = video.files[0].magnetUri
 
       const parsed = magnetUtil.decode(goodMagnet)
@@ -61,8 +48,7 @@ describe('Test tracker', function () {
     const errCb = () => done(new Error('Tracker is enabled'))
 
     killallServers([ server ])
-
-    reRunServer(server, { tracker: { enabled: false } })
+      .then(() => server.run({ tracker: { enabled: false } }))
       .then(() => {
         const webtorrent = new WebTorrent()
 
@@ -86,8 +72,7 @@ describe('Test tracker', function () {
     this.timeout(20000)
 
     killallServers([ server ])
-
-    reRunServer(server)
+      .then(() => server.run())
       .then(() => {
         const webtorrent = new WebTorrent()
 
diff --git a/server/tests/api/users/user-subscriptions.ts b/server/tests/api/users/user-subscriptions.ts
index 60676a37b..77b99886d 100644
--- a/server/tests/api/users/user-subscriptions.ts
+++ b/server/tests/api/users/user-subscriptions.ts
@@ -1,42 +1,30 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
   cleanupTests,
-  createUser,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  follow,
-  getVideosList,
-  unfollow,
-  updateVideo,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { ServerInfo, uploadVideo } from '../../../../shared/extra-utils/index'
-import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
-import { Video, VideoChannel } from '../../../../shared/models/videos'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  addUserSubscription,
-  areSubscriptionsExist,
-  getUserSubscription,
-  listUserSubscriptions,
-  listUserSubscriptionVideos,
-  removeUserSubscription
-} from '../../../../shared/extra-utils/users/user-subscriptions'
+  PeerTubeServer,
+  setAccessTokensToServers,
+  SubscriptionsCommand,
+  waitJobs
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test users subscriptions', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   const users: { accessToken: string }[] = []
   let video3UUID: string
 
+  let command: SubscriptionsCommand
+
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -47,47 +35,50 @@ describe('Test users subscriptions', function () {
     {
       for (const server of servers) {
         const user = { username: 'user' + server.serverNumber, password: 'password' }
-        await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+        await server.users.create({ username: user.username, password: user.password })
 
-        const accessToken = await userLogin(server, user)
+        const accessToken = await server.login.getAccessToken(user)
         users.push({ accessToken })
 
         const videoName1 = 'video 1-' + server.serverNumber
-        await uploadVideo(server.url, accessToken, { name: videoName1 })
+        await server.videos.upload({ token: accessToken, attributes: { name: videoName1 } })
 
         const videoName2 = 'video 2-' + server.serverNumber
-        await uploadVideo(server.url, accessToken, { name: videoName2 })
+        await server.videos.upload({ token: accessToken, attributes: { name: videoName2 } })
       }
     }
 
     await waitJobs(servers)
+
+    command = servers[0].subscriptions
   })
 
   it('Should display videos of server 2 on server 1', async function () {
-    const res = await getVideosList(servers[0].url)
+    const { total } = await servers[0].videos.list()
 
-    expect(res.body.total).to.equal(4)
+    expect(total).to.equal(4)
   })
 
   it('User of server 1 should follow user of server 3 and root of server 1', async function () {
     this.timeout(60000)
 
-    await addUserSubscription(servers[0].url, users[0].accessToken, 'user3_channel@localhost:' + servers[2].port)
-    await addUserSubscription(servers[0].url, users[0].accessToken, 'root_channel@localhost:' + servers[0].port)
+    await command.add({ token: users[0].accessToken, targetUri: 'user3_channel@localhost:' + servers[2].port })
+    await command.add({ token: users[0].accessToken, targetUri: 'root_channel@localhost:' + servers[0].port })
 
     await waitJobs(servers)
 
-    const res = await uploadVideo(servers[2].url, users[2].accessToken, { name: 'video server 3 added after follow' })
-    video3UUID = res.body.video.uuid
+    const attributes = { name: 'video server 3 added after follow' }
+    const { uuid } = await servers[2].videos.upload({ token: users[2].accessToken, attributes })
+    video3UUID = uuid
 
     await waitJobs(servers)
   })
 
   it('Should not display videos of server 3 on server 1', async function () {
-    const res = await getVideosList(servers[0].url)
+    const { total, data } = await servers[0].videos.list()
+    expect(total).to.equal(4)
 
-    expect(res.body.total).to.equal(4)
-    for (const video of res.body.data) {
+    for (const video of data) {
       expect(video.name).to.not.contain('1-3')
       expect(video.name).to.not.contain('2-3')
       expect(video.name).to.not.contain('video server 3 added after follow')
@@ -96,17 +87,17 @@ describe('Test users subscriptions', function () {
 
   it('Should list subscriptions', async function () {
     {
-      const res = await listUserSubscriptions({ url: servers[0].url, token: servers[0].accessToken })
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      const body = await command.list()
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     }
 
     {
-      const res = await listUserSubscriptions({ url: servers[0].url, token: users[0].accessToken, sort: 'createdAt' })
-      expect(res.body.total).to.equal(2)
+      const body = await command.list({ token: users[0].accessToken, sort: 'createdAt' })
+      expect(body.total).to.equal(2)
 
-      const subscriptions: VideoChannel[] = res.body.data
+      const subscriptions = body.data
       expect(subscriptions).to.be.an('array')
       expect(subscriptions).to.have.lengthOf(2)
 
@@ -117,8 +108,7 @@ describe('Test users subscriptions', function () {
 
   it('Should get subscription', async function () {
     {
-      const res = await getUserSubscription(servers[0].url, users[0].accessToken, 'user3_channel@localhost:' + servers[2].port)
-      const videoChannel: VideoChannel = res.body
+      const videoChannel = await command.get({ token: users[0].accessToken, uri: 'user3_channel@localhost:' + servers[2].port })
 
       expect(videoChannel.name).to.equal('user3_channel')
       expect(videoChannel.host).to.equal('localhost:' + servers[2].port)
@@ -128,8 +118,7 @@ describe('Test users subscriptions', function () {
     }
 
     {
-      const res = await getUserSubscription(servers[0].url, users[0].accessToken, 'root_channel@localhost:' + servers[0].port)
-      const videoChannel: VideoChannel = res.body
+      const videoChannel = await command.get({ token: users[0].accessToken, uri: 'root_channel@localhost:' + servers[0].port })
 
       expect(videoChannel.name).to.equal('root_channel')
       expect(videoChannel.host).to.equal('localhost:' + servers[0].port)
@@ -147,8 +136,7 @@ describe('Test users subscriptions', function () {
       'user3_channel@localhost:' + servers[0].port
     ]
 
-    const res = await areSubscriptionsExist(servers[0].url, users[0].accessToken, uris)
-    const body = res.body
+    const body = await command.exist({ token: users[0].accessToken, uris })
 
     expect(body['user3_channel@localhost:' + servers[2].port]).to.be.true
     expect(body['root2_channel@localhost:' + servers[0].port]).to.be.false
@@ -158,45 +146,31 @@ describe('Test users subscriptions', function () {
 
   it('Should search among subscriptions', async function () {
     {
-      const res = await listUserSubscriptions({
-        url: servers[0].url,
-        token: users[0].accessToken,
-        sort: '-createdAt',
-        search: 'user3_channel'
-      })
-      expect(res.body.total).to.equal(1)
-
-      const subscriptions = res.body.data
-      expect(subscriptions).to.have.lengthOf(1)
+      const body = await command.list({ token: users[0].accessToken, sort: '-createdAt', search: 'user3_channel' })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
     }
 
     {
-      const res = await listUserSubscriptions({
-        url: servers[0].url,
-        token: users[0].accessToken,
-        sort: '-createdAt',
-        search: 'toto'
-      })
-      expect(res.body.total).to.equal(0)
-
-      const subscriptions = res.body.data
-      expect(subscriptions).to.have.lengthOf(0)
+      const body = await command.list({ token: users[0].accessToken, sort: '-createdAt', search: 'toto' })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
     }
   })
 
   it('Should list subscription videos', async function () {
     {
-      const res = await listUserSubscriptionVideos(servers[0].url, servers[0].accessToken)
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      const body = await command.listVideos()
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     }
 
     {
-      const res = await listUserSubscriptionVideos(servers[0].url, users[0].accessToken, 'createdAt')
-      expect(res.body.total).to.equal(3)
+      const body = await command.listVideos({ token: users[0].accessToken, sort: 'createdAt' })
+      expect(body.total).to.equal(3)
 
-      const videos: Video[] = res.body.data
+      const videos = body.data
       expect(videos).to.be.an('array')
       expect(videos).to.have.lengthOf(3)
 
@@ -210,22 +184,22 @@ describe('Test users subscriptions', function () {
     this.timeout(60000)
 
     const videoName = 'video server 1 added after follow'
-    await uploadVideo(servers[0].url, servers[0].accessToken, { name: videoName })
+    await servers[0].videos.upload({ attributes: { name: videoName } })
 
     await waitJobs(servers)
 
     {
-      const res = await listUserSubscriptionVideos(servers[0].url, servers[0].accessToken)
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      const body = await command.listVideos()
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     }
 
     {
-      const res = await listUserSubscriptionVideos(servers[0].url, users[0].accessToken, 'createdAt')
-      expect(res.body.total).to.equal(4)
+      const body = await command.listVideos({ token: users[0].accessToken, sort: 'createdAt' })
+      expect(body.total).to.equal(4)
 
-      const videos: Video[] = res.body.data
+      const videos = body.data
       expect(videos).to.be.an('array')
       expect(videos).to.have.lengthOf(4)
 
@@ -236,10 +210,10 @@ describe('Test users subscriptions', function () {
     }
 
     {
-      const res = await getVideosList(servers[0].url)
+      const { data, total } = await servers[0].videos.list()
+      expect(total).to.equal(5)
 
-      expect(res.body.total).to.equal(5)
-      for (const video of res.body.data) {
+      for (const video of data) {
         expect(video.name).to.not.contain('1-3')
         expect(video.name).to.not.contain('2-3')
         expect(video.name).to.not.contain('video server 3 added after follow')
@@ -250,17 +224,16 @@ describe('Test users subscriptions', function () {
   it('Should have server 1 follow server 3 and display server 3 videos', async function () {
     this.timeout(60000)
 
-    await follow(servers[0].url, [ servers[2].url ], servers[0].accessToken)
+    await servers[0].follows.follow({ hosts: [ servers[2].url ] })
 
     await waitJobs(servers)
 
-    const res = await getVideosList(servers[0].url)
-
-    expect(res.body.total).to.equal(8)
+    const { data, total } = await servers[0].videos.list()
+    expect(total).to.equal(8)
 
     const names = [ '1-3', '2-3', 'video server 3 added after follow' ]
     for (const name of names) {
-      const video = res.body.data.find(v => v.name.indexOf(name) === -1)
+      const video = data.find(v => v.name.includes(name))
       expect(video).to.not.be.undefined
     }
   })
@@ -268,14 +241,14 @@ describe('Test users subscriptions', function () {
   it('Should remove follow server 1 -> server 3 and hide server 3 videos', async function () {
     this.timeout(60000)
 
-    await unfollow(servers[0].url, servers[0].accessToken, servers[2])
+    await servers[0].follows.unfollow({ target: servers[2] })
 
     await waitJobs(servers)
 
-    const res = await getVideosList(servers[0].url)
+    const { total, data } = await servers[0].videos.list()
+    expect(total).to.equal(5)
 
-    expect(res.body.total).to.equal(5)
-    for (const video of res.body.data) {
+    for (const video of data) {
       expect(video.name).to.not.contain('1-3')
       expect(video.name).to.not.contain('2-3')
       expect(video.name).to.not.contain('video server 3 added after follow')
@@ -284,17 +257,17 @@ describe('Test users subscriptions', function () {
 
   it('Should still list subscription videos', async function () {
     {
-      const res = await listUserSubscriptionVideos(servers[0].url, servers[0].accessToken)
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      const body = await command.listVideos()
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     }
 
     {
-      const res = await listUserSubscriptionVideos(servers[0].url, users[0].accessToken, 'createdAt')
-      expect(res.body.total).to.equal(4)
+      const body = await command.listVideos({ token: users[0].accessToken, sort: 'createdAt' })
+      expect(body.total).to.equal(4)
 
-      const videos: Video[] = res.body.data
+      const videos = body.data
       expect(videos).to.be.an('array')
       expect(videos).to.have.lengthOf(4)
 
@@ -308,58 +281,55 @@ describe('Test users subscriptions', function () {
   it('Should update a video of server 3 and see the updated video on server 1', async function () {
     this.timeout(30000)
 
-    await updateVideo(servers[2].url, users[2].accessToken, video3UUID, { name: 'video server 3 added after follow updated' })
+    await servers[2].videos.update({ id: video3UUID, attributes: { name: 'video server 3 added after follow updated' } })
 
     await waitJobs(servers)
 
-    const res = await listUserSubscriptionVideos(servers[0].url, users[0].accessToken, 'createdAt')
-    const videos: Video[] = res.body.data
-    expect(videos[2].name).to.equal('video server 3 added after follow updated')
+    const body = await command.listVideos({ token: users[0].accessToken, sort: 'createdAt' })
+    expect(body.data[2].name).to.equal('video server 3 added after follow updated')
   })
 
   it('Should remove user of server 3 subscription', async function () {
     this.timeout(30000)
 
-    await removeUserSubscription(servers[0].url, users[0].accessToken, 'user3_channel@localhost:' + servers[2].port)
+    await command.remove({ token: users[0].accessToken, uri: 'user3_channel@localhost:' + servers[2].port })
 
     await waitJobs(servers)
   })
 
   it('Should not display its videos anymore', async function () {
-    {
-      const res = await listUserSubscriptionVideos(servers[0].url, users[0].accessToken, 'createdAt')
-      expect(res.body.total).to.equal(1)
+    const body = await command.listVideos({ token: users[0].accessToken, sort: 'createdAt' })
+    expect(body.total).to.equal(1)
 
-      const videos: Video[] = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos).to.have.lengthOf(1)
+    const videos = body.data
+    expect(videos).to.be.an('array')
+    expect(videos).to.have.lengthOf(1)
 
-      expect(videos[0].name).to.equal('video server 1 added after follow')
-    }
+    expect(videos[0].name).to.equal('video server 1 added after follow')
   })
 
   it('Should remove the root subscription and not display the videos anymore', async function () {
     this.timeout(30000)
 
-    await removeUserSubscription(servers[0].url, users[0].accessToken, 'root_channel@localhost:' + servers[0].port)
+    await command.remove({ token: users[0].accessToken, uri: 'root_channel@localhost:' + servers[0].port })
 
     await waitJobs(servers)
 
     {
-      const res = await listUserSubscriptionVideos(servers[0].url, users[0].accessToken, 'createdAt')
-      expect(res.body.total).to.equal(0)
+      const body = await command.list({ token: users[0].accessToken, sort: 'createdAt' })
+      expect(body.total).to.equal(0)
 
-      const videos: Video[] = res.body.data
+      const videos = body.data
       expect(videos).to.be.an('array')
       expect(videos).to.have.lengthOf(0)
     }
   })
 
   it('Should correctly display public videos on server 1', async function () {
-    const res = await getVideosList(servers[0].url)
+    const { total, data } = await servers[0].videos.list()
+    expect(total).to.equal(5)
 
-    expect(res.body.total).to.equal(5)
-    for (const video of res.body.data) {
+    for (const video of data) {
       expect(video.name).to.not.contain('1-3')
       expect(video.name).to.not.contain('2-3')
       expect(video.name).to.not.contain('video server 3 added after follow updated')
@@ -369,15 +339,15 @@ describe('Test users subscriptions', function () {
   it('Should follow user of server 3 again', async function () {
     this.timeout(60000)
 
-    await addUserSubscription(servers[0].url, users[0].accessToken, 'user3_channel@localhost:' + servers[2].port)
+    await command.add({ token: users[0].accessToken, targetUri: 'user3_channel@localhost:' + servers[2].port })
 
     await waitJobs(servers)
 
     {
-      const res = await listUserSubscriptionVideos(servers[0].url, users[0].accessToken, 'createdAt')
-      expect(res.body.total).to.equal(3)
+      const body = await command.listVideos({ token: users[0].accessToken, sort: 'createdAt' })
+      expect(body.total).to.equal(3)
 
-      const videos: Video[] = res.body.data
+      const videos = body.data
       expect(videos).to.be.an('array')
       expect(videos).to.have.lengthOf(3)
 
@@ -387,10 +357,10 @@ describe('Test users subscriptions', function () {
     }
 
     {
-      const res = await getVideosList(servers[0].url)
+      const { total, data } = await servers[0].videos.list()
+      expect(total).to.equal(5)
 
-      expect(res.body.total).to.equal(5)
-      for (const video of res.body.data) {
+      for (const video of data) {
         expect(video.name).to.not.contain('1-3')
         expect(video.name).to.not.contain('2-3')
         expect(video.name).to.not.contain('video server 3 added after follow updated')
diff --git a/server/tests/api/users/users-multiple-servers.ts b/server/tests/api/users/users-multiple-servers.ts
index f60c66e4b..d0ca82b07 100644
--- a/server/tests/api/users/users-multiple-servers.ts
+++ b/server/tests/api/users/users-multiple-servers.ts
@@ -1,34 +1,30 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import { Account } from '../../../../shared/models/actors'
+import * as chai from 'chai'
 import {
+  checkActorFilesWereRemoved,
   checkTmpIsEmpty,
   checkVideoFilesWereRemoved,
   cleanupTests,
-  createUser,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getAccountVideos,
-  getVideoChannelsList,
-  removeUser,
-  updateMyUser,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { getMyUserInformation, ServerInfo, testImage, updateMyAvatar, uploadVideo } from '../../../../shared/extra-utils/index'
-import { checkActorFilesWereRemoved, getAccount, getAccountsList } from '../../../../shared/extra-utils/users/accounts'
-import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
-import { User } from '../../../../shared/models/users'
-import { VideoChannel } from '../../../../shared/models/videos'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+  PeerTubeServer,
+  saveVideoInServers,
+  setAccessTokensToServers,
+  testImage,
+  waitJobs
+} from '@shared/extra-utils'
+import { MyUser } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test users with multiple servers', function () {
-  let servers: ServerInfo[] = []
-  let user: User
+  let servers: PeerTubeServer[] = []
+
+  let user: MyUser
   let userId: number
+
   let videoUUID: string
   let userAccessToken: string
   let userAvatarFilename: string
@@ -36,7 +32,7 @@ describe('Test users with multiple servers', function () {
   before(async function () {
     this.timeout(120_000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -49,43 +45,31 @@ describe('Test users with multiple servers', function () {
     await doubleFollow(servers[1], servers[2])
 
     // The root user of server 1 is propagated to servers 2 and 3
-    await uploadVideo(servers[0].url, servers[0].accessToken, {})
+    await servers[0].videos.upload()
 
     {
-      const user = {
-        username: 'user1',
-        password: 'password'
-      }
-      const res = await createUser({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        username: user.username,
-        password: user.password
-      })
-      userId = res.body.user.id
-      userAccessToken = await userLogin(servers[0], user)
+      const username = 'user1'
+      const created = await servers[0].users.create({ username })
+      userId = created.id
+      userAccessToken = await servers[0].login.getAccessToken(username)
     }
 
     {
-      const resVideo = await uploadVideo(servers[0].url, userAccessToken, {})
-      videoUUID = resVideo.body.video.uuid
-    }
+      const { uuid } = await servers[0].videos.upload({ token: userAccessToken })
+      videoUUID = uuid
 
-    await waitJobs(servers)
+      await waitJobs(servers)
+
+      await saveVideoInServers(servers, videoUUID)
+    }
   })
 
   it('Should be able to update my display name', async function () {
     this.timeout(10000)
 
-    await updateMyUser({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      displayName: 'my super display name'
-    })
-
-    const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
-    user = res.body
+    await servers[0].users.updateMe({ displayName: 'my super display name' })
 
+    user = await servers[0].users.getMyInfo()
     expect(user.account.displayName).to.equal('my super display name')
 
     await waitJobs(servers)
@@ -94,14 +78,9 @@ describe('Test users with multiple servers', function () {
   it('Should be able to update my description', async function () {
     this.timeout(10_000)
 
-    await updateMyUser({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      description: 'my super description updated'
-    })
+    await servers[0].users.updateMe({ description: 'my super description updated' })
 
-    const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
-    user = res.body
+    user = await servers[0].users.getMyInfo()
     expect(user.account.displayName).to.equal('my super display name')
     expect(user.account.description).to.equal('my super description updated')
 
@@ -113,15 +92,9 @@ describe('Test users with multiple servers', function () {
 
     const fixture = 'avatar2.png'
 
-    await updateMyAvatar({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      fixture
-    })
-
-    const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
-    user = res.body
+    await servers[0].users.updateMyAvatar({ fixture })
 
+    user = await servers[0].users.getMyInfo()
     userAvatarFilename = user.account.avatar.path
 
     await testImage(servers[0].url, 'avatar2-resized', userAvatarFilename, '.png')
@@ -133,13 +106,12 @@ describe('Test users with multiple servers', function () {
     let createdAt: string | Date
 
     for (const server of servers) {
-      const resAccounts = await getAccountsList(server.url, '-createdAt')
+      const body = await server.accounts.list({ sort: '-createdAt' })
 
-      const resList = resAccounts.body.data.find(a => a.name === 'root' && a.host === 'localhost:' + servers[0].port) as Account
+      const resList = body.data.find(a => a.name === 'root' && a.host === 'localhost:' + servers[0].port)
       expect(resList).not.to.be.undefined
 
-      const resAccount = await getAccount(server.url, resList.name + '@' + resList.host)
-      const account = resAccount.body as Account
+      const account = await server.accounts.get({ accountName: resList.name + '@' + resList.host })
 
       if (!createdAt) createdAt = account.createdAt
 
@@ -161,31 +133,29 @@ describe('Test users with multiple servers', function () {
 
   it('Should list account videos', async function () {
     for (const server of servers) {
-      const res = await getAccountVideos(server.url, server.accessToken, 'user1@localhost:' + servers[0].port, 0, 5)
+      const { total, data } = await server.videos.listByAccount({ handle: 'user1@localhost:' + servers[0].port })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].uuid).to.equal(videoUUID)
+      expect(total).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].uuid).to.equal(videoUUID)
     }
   })
 
   it('Should search through account videos', async function () {
     this.timeout(10_000)
 
-    const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'Kami no chikara' })
+    const created = await servers[0].videos.upload({ token: userAccessToken, attributes: { name: 'Kami no chikara' } })
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getAccountVideos(server.url, server.accessToken, 'user1@localhost:' + servers[0].port, 0, 5, undefined, {
-        search: 'Kami'
-      })
-
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].uuid).to.equal(resVideo.body.video.uuid)
+      const { total, data } = await server.videos.listByAccount({ handle: 'user1@localhost:' + servers[0].port, search: 'Kami' })
+
+      expect(total).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].uuid).to.equal(created.uuid)
     }
   })
 
@@ -193,32 +163,28 @@ describe('Test users with multiple servers', function () {
     this.timeout(10_000)
 
     for (const server of servers) {
-      const resAccounts = await getAccountsList(server.url, '-createdAt')
+      const body = await server.accounts.list({ sort: '-createdAt' })
 
-      const accountDeleted = resAccounts.body.data.find(a => a.name === 'user1' && a.host === 'localhost:' + servers[0].port) as Account
+      const accountDeleted = body.data.find(a => a.name === 'user1' && a.host === 'localhost:' + servers[0].port)
       expect(accountDeleted).not.to.be.undefined
 
-      const resVideoChannels = await getVideoChannelsList(server.url, 0, 10)
-      const videoChannelDeleted = resVideoChannels.body.data.find(a => {
-        return a.displayName === 'Main user1 channel' && a.host === 'localhost:' + servers[0].port
-      }) as VideoChannel
+      const { data } = await server.channels.list()
+      const videoChannelDeleted = data.find(a => a.displayName === 'Main user1 channel' && a.host === 'localhost:' + servers[0].port)
       expect(videoChannelDeleted).not.to.be.undefined
     }
 
-    await removeUser(servers[0].url, userId, servers[0].accessToken)
+    await servers[0].users.remove({ userId })
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const resAccounts = await getAccountsList(server.url, '-createdAt')
+      const body = await server.accounts.list({ sort: '-createdAt' })
 
-      const accountDeleted = resAccounts.body.data.find(a => a.name === 'user1' && a.host === 'localhost:' + servers[0].port) as Account
+      const accountDeleted = body.data.find(a => a.name === 'user1' && a.host === 'localhost:' + servers[0].port)
       expect(accountDeleted).to.be.undefined
 
-      const resVideoChannels = await getVideoChannelsList(server.url, 0, 10)
-      const videoChannelDeleted = resVideoChannels.body.data.find(a => {
-        return a.name === 'Main user1 channel' && a.host === 'localhost:' + servers[0].port
-      }) as VideoChannel
+      const { data } = await server.channels.list()
+      const videoChannelDeleted = data.find(a => a.name === 'Main user1 channel' && a.host === 'localhost:' + servers[0].port)
       expect(videoChannelDeleted).to.be.undefined
     }
   })
@@ -231,7 +197,7 @@ describe('Test users with multiple servers', function () {
 
   it('Should not have video files', async () => {
     for (const server of servers) {
-      await checkVideoFilesWereRemoved(videoUUID, server.internalServerNumber)
+      await checkVideoFilesWereRemoved({ server, video: server.store.videoDetails })
     }
   })
 
diff --git a/server/tests/api/users/users-verification.ts b/server/tests/api/users/users-verification.ts
index e0f2f2112..f54463359 100644
--- a/server/tests/api/users/users-verification.ts
+++ b/server/tests/api/users/users-verification.ts
@@ -1,30 +1,14 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import {
-  cleanupTests,
-  flushAndRunServer,
-  getMyUserInformation,
-  getUserInformation,
-  login,
-  registerUser,
-  ServerInfo,
-  updateCustomSubConfig,
-  updateMyUser,
-  userLogin,
-  verifyEmail
-} from '../../../../shared/extra-utils'
-import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
-import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { User } from '../../../../shared/models/users'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import * as chai from 'chai'
+import { cleanupTests, createSingleServer, MockSmtpServer, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test users account verification', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userId: number
   let userAccessToken: string
   let verificationString: string
@@ -50,7 +34,7 @@ describe('Test users account verification', function () {
         port
       }
     }
-    server = await flushAndRunServer(1, overrideConfig)
+    server = await createSingleServer(1, overrideConfig)
 
     await setAccessTokensToServers([ server ])
   })
@@ -58,15 +42,17 @@ describe('Test users account verification', function () {
   it('Should register user and send verification email if verification required', async function () {
     this.timeout(30000)
 
-    await updateCustomSubConfig(server.url, server.accessToken, {
-      signup: {
-        enabled: true,
-        requiresEmailVerification: true,
-        limit: 10
+    await server.config.updateCustomSubConfig({
+      newConfig: {
+        signup: {
+          enabled: true,
+          requiresEmailVerification: true,
+          limit: 10
+        }
       }
     })
 
-    await registerUser(server.url, user1.username, user1.password)
+    await server.users.register(user1)
 
     await waitJobs(server)
     expectedEmailsLength++
@@ -85,23 +71,23 @@ describe('Test users account verification', function () {
 
     userId = parseInt(userIdMatches[1], 10)
 
-    const resUserInfo = await getUserInformation(server.url, server.accessToken, userId)
-    expect(resUserInfo.body.emailVerified).to.be.false
+    const body = await server.users.get({ userId })
+    expect(body.emailVerified).to.be.false
   })
 
   it('Should not allow login for user with unverified email', async function () {
-    const resLogin = await login(server.url, server.client, user1, HttpStatusCode.BAD_REQUEST_400)
-    expect(resLogin.body.detail).to.contain('User email is not verified.')
+    const { detail } = await server.login.login({ user: user1, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    expect(detail).to.contain('User email is not verified.')
   })
 
   it('Should verify the user via email and allow login', async function () {
-    await verifyEmail(server.url, userId, verificationString)
+    await server.users.verifyEmail({ userId, verificationString })
 
-    const res = await login(server.url, server.client, user1)
-    userAccessToken = res.body.access_token
+    const body = await server.login.login({ user: user1 })
+    userAccessToken = body.access_token
 
-    const resUserVerified = await getUserInformation(server.url, server.accessToken, userId)
-    expect(resUserVerified.body.emailVerified).to.be.true
+    const user = await server.users.get({ userId })
+    expect(user.emailVerified).to.be.true
   })
 
   it('Should be able to change the user email', async function () {
@@ -110,9 +96,8 @@ describe('Test users account verification', function () {
     let updateVerificationString: string
 
     {
-      await updateMyUser({
-        url: server.url,
-        accessToken: userAccessToken,
+      await server.users.updateMe({
+        token: userAccessToken,
         email: 'updated@example.com',
         currentPassword: user1.password
       })
@@ -128,19 +113,15 @@ describe('Test users account verification', function () {
     }
 
     {
-      const res = await getMyUserInformation(server.url, userAccessToken)
-      const me: User = res.body
-
+      const me = await server.users.getMyInfo({ token: userAccessToken })
       expect(me.email).to.equal('user_1@example.com')
       expect(me.pendingEmail).to.equal('updated@example.com')
     }
 
     {
-      await verifyEmail(server.url, userId, updateVerificationString, true)
-
-      const res = await getMyUserInformation(server.url, userAccessToken)
-      const me: User = res.body
+      await server.users.verifyEmail({ userId, verificationString: updateVerificationString, isPendingEmail: true })
 
+      const me = await server.users.getMyInfo({ token: userAccessToken })
       expect(me.email).to.equal('updated@example.com')
       expect(me.pendingEmail).to.be.null
     }
@@ -148,35 +129,39 @@ describe('Test users account verification', function () {
 
   it('Should register user not requiring email verification if setting not enabled', async function () {
     this.timeout(5000)
-    await updateCustomSubConfig(server.url, server.accessToken, {
-      signup: {
-        enabled: true,
-        requiresEmailVerification: false,
-        limit: 10
+    await server.config.updateCustomSubConfig({
+      newConfig: {
+        signup: {
+          enabled: true,
+          requiresEmailVerification: false,
+          limit: 10
+        }
       }
     })
 
-    await registerUser(server.url, user2.username, user2.password)
+    await server.users.register(user2)
 
     await waitJobs(server)
     expect(emails).to.have.lengthOf(expectedEmailsLength)
 
-    const accessToken = await userLogin(server, user2)
+    const accessToken = await server.login.getAccessToken(user2)
 
-    const resMyUserInfo = await getMyUserInformation(server.url, accessToken)
-    expect(resMyUserInfo.body.emailVerified).to.be.null
+    const user = await server.users.getMyInfo({ token: accessToken })
+    expect(user.emailVerified).to.be.null
   })
 
   it('Should allow login for user with unverified email when setting later enabled', async function () {
-    await updateCustomSubConfig(server.url, server.accessToken, {
-      signup: {
-        enabled: true,
-        requiresEmailVerification: true,
-        limit: 10
+    await server.config.updateCustomSubConfig({
+      newConfig: {
+        signup: {
+          enabled: true,
+          requiresEmailVerification: true,
+          limit: 10
+        }
       }
     })
 
-    await userLogin(server, user2)
+    await server.login.getAccessToken(user2)
   })
 
   after(async function () {
diff --git a/server/tests/api/users/users.ts b/server/tests/api/users/users.ts
index 87ba775f6..1419ae820 100644
--- a/server/tests/api/users/users.ts
+++ b/server/tests/api/users/users.ts
@@ -2,63 +2,24 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { AbuseState, AbuseUpdate, MyUser, User, UserRole, Video, VideoPlaylistType } from '@shared/models'
-import { CustomConfig, OAuth2ErrorCode } from '@shared/models/server'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoCommentThread,
-  blockUser,
   cleanupTests,
-  closeAllSequelize,
-  createUser,
-  deleteMe,
-  flushAndRunServer,
-  getAccountRatings,
-  getAdminAbusesList,
-  getBlacklistedVideosList,
-  getCustomConfig,
-  getMyUserInformation,
-  getMyUserVideoQuotaUsed,
-  getMyUserVideoRating,
-  getUserInformation,
-  getUsersList,
-  getUsersListPaginationAndSort,
-  getVideoChannel,
-  getVideosList,
-  installPlugin,
+  createSingleServer,
   killallServers,
-  login,
   makePutBodyRequest,
-  rateVideo,
-  registerUserWithChannel,
-  removeUser,
-  removeVideo,
-  reportAbuse,
-  reRunServer,
-  ServerInfo,
-  setTokenField,
+  PeerTubeServer,
+  setAccessTokensToServers,
   testImage,
-  unblockUser,
-  updateAbuse,
-  updateCustomSubConfig,
-  updateMyAvatar,
-  updateMyUser,
-  updateUser,
-  uploadVideo,
-  userLogin,
   waitJobs
-} from '../../../../shared/extra-utils'
-import { follow } from '../../../../shared/extra-utils/server/follows'
-import { logout, refreshToken, setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
-import { getMyVideos } from '../../../../shared/extra-utils/videos/videos'
-import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
+} from '@shared/extra-utils'
+import { AbuseState, HttpStatusCode, OAuth2ErrorCode, UserAdminFlag, UserRole, Video, VideoPlaylistType } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test users', function () {
-  let server: ServerInfo
-  let accessToken: string
-  let accessTokenUser: string
+  let server: PeerTubeServer
+  let token: string
+  let userToken: string
   let videoId: number
   let userId: number
   const user = {
@@ -69,7 +30,7 @@ describe('Test users', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1, {
+    server = await createSingleServer(1, {
       rates_limit: {
         login: {
           max: 30
@@ -79,7 +40,7 @@ describe('Test users', function () {
 
     await setAccessTokensToServers([ server ])
 
-    await installPlugin({ url: server.url, accessToken: server.accessToken, npmName: 'peertube-theme-background-red' })
+    await server.plugins.install({ npmName: 'peertube-theme-background-red' })
   })
 
   describe('OAuth client', function () {
@@ -90,158 +51,156 @@ describe('Test users', function () {
     it('Should remove the last client')
 
     it('Should not login with an invalid client id', async function () {
-      const client = { id: 'client', secret: server.client.secret }
-      const res = await login(server.url, client, server.user, HttpStatusCode.BAD_REQUEST_400)
+      const client = { id: 'client', secret: server.store.client.secret }
+      const body = await server.login.login({ client, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
-      expect(res.body.code).to.equal(OAuth2ErrorCode.INVALID_CLIENT)
-      expect(res.body.error).to.contain('client is invalid')
-      expect(res.body.type.startsWith('https://')).to.be.true
-      expect(res.body.type).to.contain(OAuth2ErrorCode.INVALID_CLIENT)
+      expect(body.code).to.equal(OAuth2ErrorCode.INVALID_CLIENT)
+      expect(body.error).to.contain('client is invalid')
+      expect(body.type.startsWith('https://')).to.be.true
+      expect(body.type).to.contain(OAuth2ErrorCode.INVALID_CLIENT)
     })
 
     it('Should not login with an invalid client secret', async function () {
-      const client = { id: server.client.id, secret: 'coucou' }
-      const res = await login(server.url, client, server.user, HttpStatusCode.BAD_REQUEST_400)
+      const client = { id: server.store.client.id, secret: 'coucou' }
+      const body = await server.login.login({ client, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
-      expect(res.body.code).to.equal(OAuth2ErrorCode.INVALID_CLIENT)
-      expect(res.body.error).to.contain('client is invalid')
-      expect(res.body.type.startsWith('https://')).to.be.true
-      expect(res.body.type).to.contain(OAuth2ErrorCode.INVALID_CLIENT)
+      expect(body.code).to.equal(OAuth2ErrorCode.INVALID_CLIENT)
+      expect(body.error).to.contain('client is invalid')
+      expect(body.type.startsWith('https://')).to.be.true
+      expect(body.type).to.contain(OAuth2ErrorCode.INVALID_CLIENT)
     })
   })
 
   describe('Login', function () {
 
     it('Should not login with an invalid username', async function () {
-      const user = { username: 'captain crochet', password: server.user.password }
-      const res = await login(server.url, server.client, user, HttpStatusCode.BAD_REQUEST_400)
+      const user = { username: 'captain crochet', password: server.store.user.password }
+      const body = await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
-      expect(res.body.code).to.equal(OAuth2ErrorCode.INVALID_GRANT)
-      expect(res.body.error).to.contain('credentials are invalid')
-      expect(res.body.type.startsWith('https://')).to.be.true
-      expect(res.body.type).to.contain(OAuth2ErrorCode.INVALID_GRANT)
+      expect(body.code).to.equal(OAuth2ErrorCode.INVALID_GRANT)
+      expect(body.error).to.contain('credentials are invalid')
+      expect(body.type.startsWith('https://')).to.be.true
+      expect(body.type).to.contain(OAuth2ErrorCode.INVALID_GRANT)
     })
 
     it('Should not login with an invalid password', async function () {
-      const user = { username: server.user.username, password: 'mew_three' }
-      const res = await login(server.url, server.client, user, HttpStatusCode.BAD_REQUEST_400)
+      const user = { username: server.store.user.username, password: 'mew_three' }
+      const body = await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
-      expect(res.body.code).to.equal(OAuth2ErrorCode.INVALID_GRANT)
-      expect(res.body.error).to.contain('credentials are invalid')
-      expect(res.body.type.startsWith('https://')).to.be.true
-      expect(res.body.type).to.contain(OAuth2ErrorCode.INVALID_GRANT)
+      expect(body.code).to.equal(OAuth2ErrorCode.INVALID_GRANT)
+      expect(body.error).to.contain('credentials are invalid')
+      expect(body.type.startsWith('https://')).to.be.true
+      expect(body.type).to.contain(OAuth2ErrorCode.INVALID_GRANT)
     })
 
     it('Should not be able to upload a video', async function () {
-      accessToken = 'my_super_token'
+      token = 'my_super_token'
 
-      const videoAttributes = {}
-      await uploadVideo(server.url, accessToken, videoAttributes, HttpStatusCode.UNAUTHORIZED_401)
+      await server.videos.upload({ token, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should not be able to follow', async function () {
-      accessToken = 'my_super_token'
-      await follow(server.url, [ 'http://example.com' ], accessToken, HttpStatusCode.UNAUTHORIZED_401)
+      token = 'my_super_token'
+
+      await server.follows.follow({
+        hosts: [ 'http://example.com' ],
+        token,
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
+      })
     })
 
     it('Should not be able to unfollow')
 
     it('Should be able to login', async function () {
-      const res = await login(server.url, server.client, server.user, HttpStatusCode.OK_200)
+      const body = await server.login.login({ expectedStatus: HttpStatusCode.OK_200 })
 
-      accessToken = res.body.access_token
+      token = body.access_token
     })
 
     it('Should be able to login with an insensitive username', async function () {
-      const user = { username: 'RoOt', password: server.user.password }
-      await login(server.url, server.client, user, HttpStatusCode.OK_200)
+      const user = { username: 'RoOt', password: server.store.user.password }
+      await server.login.login({ user, expectedStatus: HttpStatusCode.OK_200 })
 
-      const user2 = { username: 'rOoT', password: server.user.password }
-      await login(server.url, server.client, user2, HttpStatusCode.OK_200)
+      const user2 = { username: 'rOoT', password: server.store.user.password }
+      await server.login.login({ user: user2, expectedStatus: HttpStatusCode.OK_200 })
 
-      const user3 = { username: 'ROOt', password: server.user.password }
-      await login(server.url, server.client, user3, HttpStatusCode.OK_200)
+      const user3 = { username: 'ROOt', password: server.store.user.password }
+      await server.login.login({ user: user3, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
   describe('Upload', function () {
 
     it('Should upload the video with the correct token', async function () {
-      const videoAttributes = {}
-      await uploadVideo(server.url, accessToken, videoAttributes)
-      const res = await getVideosList(server.url)
-      const video = res.body.data[0]
+      await server.videos.upload({ token })
+      const { data } = await server.videos.list()
+      const video = data[0]
 
       expect(video.account.name).to.equal('root')
       videoId = video.id
     })
 
     it('Should upload the video again with the correct token', async function () {
-      const videoAttributes = {}
-      await uploadVideo(server.url, accessToken, videoAttributes)
+      await server.videos.upload({ token })
     })
   })
 
   describe('Ratings', function () {
 
     it('Should retrieve a video rating', async function () {
-      await rateVideo(server.url, accessToken, videoId, 'like')
-      const res = await getMyUserVideoRating(server.url, accessToken, videoId)
-      const rating = res.body
+      await server.videos.rate({ id: videoId, rating: 'like' })
+      const rating = await server.users.getMyRating({ token, videoId })
 
       expect(rating.videoId).to.equal(videoId)
       expect(rating.rating).to.equal('like')
     })
 
     it('Should retrieve ratings list', async function () {
-      await rateVideo(server.url, accessToken, videoId, 'like')
+      await server.videos.rate({ id: videoId, rating: 'like' })
 
-      const res = await getAccountRatings(server.url, server.user.username, server.accessToken, null, HttpStatusCode.OK_200)
-      const ratings = res.body
+      const body = await server.accounts.listRatings({ accountName: server.store.user.username })
 
-      expect(ratings.total).to.equal(1)
-      expect(ratings.data[0].video.id).to.equal(videoId)
-      expect(ratings.data[0].rating).to.equal('like')
+      expect(body.total).to.equal(1)
+      expect(body.data[0].video.id).to.equal(videoId)
+      expect(body.data[0].rating).to.equal('like')
     })
 
     it('Should retrieve ratings list by rating type', async function () {
       {
-        const res = await getAccountRatings(server.url, server.user.username, server.accessToken, 'like')
-        const ratings = res.body
-        expect(ratings.data.length).to.equal(1)
+        const body = await server.accounts.listRatings({ accountName: server.store.user.username, rating: 'like' })
+        expect(body.data.length).to.equal(1)
       }
 
       {
-        const res = await getAccountRatings(server.url, server.user.username, server.accessToken, 'dislike')
-        const ratings = res.body
-        expect(ratings.data.length).to.equal(0)
+        const body = await server.accounts.listRatings({ accountName: server.store.user.username, rating: 'dislike' })
+        expect(body.data.length).to.equal(0)
       }
     })
   })
 
   describe('Remove video', function () {
     it('Should not be able to remove the video with an incorrect token', async function () {
-      await removeVideo(server.url, 'bad_token', videoId, HttpStatusCode.UNAUTHORIZED_401)
+      await server.videos.remove({ token: 'bad_token', id: videoId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should not be able to remove the video with the token of another account')
 
     it('Should be able to remove the video with the correct token', async function () {
-      await removeVideo(server.url, accessToken, videoId)
+      await server.videos.remove({ token, id: videoId })
     })
   })
 
   describe('Logout', function () {
     it('Should logout (revoke token)', async function () {
-      await logout(server.url, server.accessToken)
+      await server.login.logout({ token: server.accessToken })
     })
 
     it('Should not be able to get the user information', async function () {
-      await getMyUserInformation(server.url, server.accessToken, HttpStatusCode.UNAUTHORIZED_401)
+      await server.users.getMyInfo({ expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should not be able to upload a video', async function () {
-      await uploadVideo(server.url, server.accessToken, { name: 'video' }, HttpStatusCode.UNAUTHORIZED_401)
+      await server.videos.upload({ attributes: { name: 'video' }, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should not be able to rate a video', async function () {
@@ -255,79 +214,70 @@ describe('Test users', function () {
         path: path + videoId,
         token: 'wrong token',
         fields: data,
-        statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
       }
       await makePutBodyRequest(options)
     })
 
     it('Should be able to login again', async function () {
-      const res = await login(server.url, server.client, server.user)
-      server.accessToken = res.body.access_token
-      server.refreshToken = res.body.refresh_token
+      const body = await server.login.login()
+      server.accessToken = body.access_token
+      server.refreshToken = body.refresh_token
     })
 
     it('Should be able to get my user information again', async function () {
-      await getMyUserInformation(server.url, server.accessToken)
+      await server.users.getMyInfo()
     })
 
     it('Should have an expired access token', async function () {
       this.timeout(15000)
 
-      await setTokenField(server.internalServerNumber, server.accessToken, 'accessTokenExpiresAt', new Date().toISOString())
-      await setTokenField(server.internalServerNumber, server.accessToken, 'refreshTokenExpiresAt', new Date().toISOString())
+      await server.sql.setTokenField(server.accessToken, 'accessTokenExpiresAt', new Date().toISOString())
+      await server.sql.setTokenField(server.accessToken, 'refreshTokenExpiresAt', new Date().toISOString())
 
-      killallServers([ server ])
-      await reRunServer(server)
+      await killallServers([ server ])
+      await server.run()
 
-      await getMyUserInformation(server.url, server.accessToken, 401)
+      await server.users.getMyInfo({ expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should not be able to refresh an access token with an expired refresh token', async function () {
-      await refreshToken(server, server.refreshToken, 400)
+      await server.login.refreshToken({ refreshToken: server.refreshToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should refresh the token', async function () {
       this.timeout(15000)
 
       const futureDate = new Date(new Date().getTime() + 1000 * 60).toISOString()
-      await setTokenField(server.internalServerNumber, server.accessToken, 'refreshTokenExpiresAt', futureDate)
+      await server.sql.setTokenField(server.accessToken, 'refreshTokenExpiresAt', futureDate)
 
-      killallServers([ server ])
-      await reRunServer(server)
+      await killallServers([ server ])
+      await server.run()
 
-      const res = await refreshToken(server, server.refreshToken)
+      const res = await server.login.refreshToken({ refreshToken: server.refreshToken })
       server.accessToken = res.body.access_token
       server.refreshToken = res.body.refresh_token
     })
 
     it('Should be able to get my user information again', async function () {
-      await getMyUserInformation(server.url, server.accessToken)
+      await server.users.getMyInfo()
     })
   })
 
   describe('Creating a user', function () {
 
     it('Should be able to create a new user', async function () {
-      await createUser({
-        url: server.url,
-        accessToken: accessToken,
-        username: user.username,
-        password: user.password,
-        videoQuota: 2 * 1024 * 1024,
-        adminFlags: UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST
-      })
+      await server.users.create({ ...user, videoQuota: 2 * 1024 * 1024, adminFlags: UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST })
     })
 
     it('Should be able to login with this user', async function () {
-      accessTokenUser = await userLogin(server, user)
+      userToken = await server.login.getAccessToken(user)
     })
 
     it('Should be able to get user information', async function () {
-      const res1 = await getMyUserInformation(server.url, accessTokenUser)
-      const userMe: MyUser = res1.body
+      const userMe = await server.users.getMyInfo({ token: userToken })
 
-      const res2 = await getUserInformation(server.url, server.accessToken, userMe.id, true)
-      const userGet: User = res2.body
+      const userGet = await server.users.get({ userId: userMe.id, withStats: true })
 
       for (const user of [ userMe, userGet ]) {
         expect(user.username).to.equal('user_1')
@@ -363,34 +313,28 @@ describe('Test users', function () {
     it('Should be able to upload a video with this user', async function () {
       this.timeout(10000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'super user video',
         fixture: 'video_short.webm'
       }
-      await uploadVideo(server.url, accessTokenUser, videoAttributes)
+      await server.videos.upload({ token: userToken, attributes })
     })
 
     it('Should have video quota updated', async function () {
-      const res = await getMyUserVideoQuotaUsed(server.url, accessTokenUser)
-      const data = res.body
-
-      expect(data.videoQuotaUsed).to.equal(218910)
-
-      const resUsers = await getUsersList(server.url, server.accessToken)
+      const quota = await server.users.getMyQuotaUsed({ token: userToken })
+      expect(quota.videoQuotaUsed).to.equal(218910)
 
-      const users: User[] = resUsers.body.data
-      const tmpUser = users.find(u => u.username === user.username)
+      const { data } = await server.users.list()
+      const tmpUser = data.find(u => u.username === user.username)
       expect(tmpUser.videoQuotaUsed).to.equal(218910)
     })
 
     it('Should be able to list my videos', async function () {
-      const res = await getMyVideos(server.url, accessTokenUser, 0, 5)
-      expect(res.body.total).to.equal(1)
+      const { total, data } = await server.videos.listMyVideos({ token: userToken })
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
 
-      const videos = res.body.data
-      expect(videos).to.have.lengthOf(1)
-
-      const video: Video = videos[0]
+      const video: Video = data[0]
       expect(video.name).to.equal('super user video')
       expect(video.thumbnailPath).to.not.be.null
       expect(video.previewPath).to.not.be.null
@@ -398,19 +342,15 @@ describe('Test users', function () {
 
     it('Should be able to search in my videos', async function () {
       {
-        const res = await getMyVideos(server.url, accessTokenUser, 0, 5, '-createdAt', 'user video')
-        expect(res.body.total).to.equal(1)
-
-        const videos = res.body.data
-        expect(videos).to.have.lengthOf(1)
+        const { total, data } = await server.videos.listMyVideos({ token: userToken, sort: '-createdAt', search: 'user video' })
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
       }
 
       {
-        const res = await getMyVideos(server.url, accessTokenUser, 0, 5, '-createdAt', 'toto')
-        expect(res.body.total).to.equal(0)
-
-        const videos = res.body.data
-        expect(videos).to.have.lengthOf(0)
+        const { total, data } = await server.videos.listMyVideos({ token: userToken, sort: '-createdAt', search: 'toto' })
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
       }
     })
 
@@ -418,28 +358,25 @@ describe('Test users', function () {
       this.timeout(60000)
 
       {
-        const res = await getCustomConfig(server.url, server.accessToken)
-        const config = res.body as CustomConfig
+        const config = await server.config.getCustomConfig()
         config.transcoding.webtorrent.enabled = false
         config.transcoding.hls.enabled = true
         config.transcoding.enabled = true
-        await updateCustomSubConfig(server.url, server.accessToken, config)
+        await server.config.updateCustomSubConfig({ newConfig: config })
       }
 
       {
-        const videoAttributes = {
+        const attributes = {
           name: 'super user video 2',
           fixture: 'video_short.webm'
         }
-        await uploadVideo(server.url, accessTokenUser, videoAttributes)
+        await server.videos.upload({ token: userToken, attributes })
 
         await waitJobs([ server ])
       }
 
       {
-        const res = await getMyUserVideoQuotaUsed(server.url, accessTokenUser)
-        const data = res.body
-
+        const data = await server.users.getMyQuotaUsed({ token: userToken })
         expect(data.videoQuotaUsed).to.be.greaterThan(220000)
       }
     })
@@ -448,21 +385,18 @@ describe('Test users', function () {
   describe('Users listing', function () {
 
     it('Should list all the users', async function () {
-      const res = await getUsersList(server.url, server.accessToken)
-      const result = res.body
-      const total = result.total
-      const users = result.data
+      const { data, total } = await server.users.list()
 
       expect(total).to.equal(2)
-      expect(users).to.be.an('array')
-      expect(users.length).to.equal(2)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(2)
 
-      const user = users[0]
+      const user = data[0]
       expect(user.username).to.equal('user_1')
       expect(user.email).to.equal('user_1@example.com')
       expect(user.nsfwPolicy).to.equal('display')
 
-      const rootUser = users[1]
+      const rootUser = data[1]
       expect(rootUser.username).to.equal('root')
       expect(rootUser.email).to.equal('admin' + server.internalServerNumber + '@example.com')
       expect(user.nsfwPolicy).to.equal('display')
@@ -474,16 +408,12 @@ describe('Test users', function () {
     })
 
     it('Should list only the first user by username asc', async function () {
-      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, 'username')
-
-      const result = res.body
-      const total = result.total
-      const users = result.data
+      const { total, data } = await server.users.list({ start: 0, count: 1, sort: 'username' })
 
       expect(total).to.equal(2)
-      expect(users.length).to.equal(1)
+      expect(data.length).to.equal(1)
 
-      const user = users[0]
+      const user = data[0]
       expect(user.username).to.equal('root')
       expect(user.email).to.equal('admin' + server.internalServerNumber + '@example.com')
       expect(user.roleLabel).to.equal('Administrator')
@@ -491,111 +421,90 @@ describe('Test users', function () {
     })
 
     it('Should list only the first user by username desc', async function () {
-      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, '-username')
-      const result = res.body
-      const total = result.total
-      const users = result.data
+      const { total, data } = await server.users.list({ start: 0, count: 1, sort: '-username' })
 
       expect(total).to.equal(2)
-      expect(users.length).to.equal(1)
+      expect(data.length).to.equal(1)
 
-      const user = users[0]
+      const user = data[0]
       expect(user.username).to.equal('user_1')
       expect(user.email).to.equal('user_1@example.com')
       expect(user.nsfwPolicy).to.equal('display')
     })
 
     it('Should list only the second user by createdAt desc', async function () {
-      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, '-createdAt')
-      const result = res.body
-      const total = result.total
-      const users = result.data
-
+      const { data, total } = await server.users.list({ start: 0, count: 1, sort: '-createdAt' })
       expect(total).to.equal(2)
-      expect(users.length).to.equal(1)
 
-      const user = users[0]
+      expect(data.length).to.equal(1)
+
+      const user = data[0]
       expect(user.username).to.equal('user_1')
       expect(user.email).to.equal('user_1@example.com')
       expect(user.nsfwPolicy).to.equal('display')
     })
 
     it('Should list all the users by createdAt asc', async function () {
-      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt')
-      const result = res.body
-      const total = result.total
-      const users = result.data
+      const { data, total } = await server.users.list({ start: 0, count: 2, sort: 'createdAt' })
 
       expect(total).to.equal(2)
-      expect(users.length).to.equal(2)
+      expect(data.length).to.equal(2)
 
-      expect(users[0].username).to.equal('root')
-      expect(users[0].email).to.equal('admin' + server.internalServerNumber + '@example.com')
-      expect(users[0].nsfwPolicy).to.equal('display')
+      expect(data[0].username).to.equal('root')
+      expect(data[0].email).to.equal('admin' + server.internalServerNumber + '@example.com')
+      expect(data[0].nsfwPolicy).to.equal('display')
 
-      expect(users[1].username).to.equal('user_1')
-      expect(users[1].email).to.equal('user_1@example.com')
-      expect(users[1].nsfwPolicy).to.equal('display')
+      expect(data[1].username).to.equal('user_1')
+      expect(data[1].email).to.equal('user_1@example.com')
+      expect(data[1].nsfwPolicy).to.equal('display')
     })
 
     it('Should search user by username', async function () {
-      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'oot')
-      const users = res.body.data as User[]
-
-      expect(res.body.total).to.equal(1)
-      expect(users.length).to.equal(1)
-
-      expect(users[0].username).to.equal('root')
+      const { data, total } = await server.users.list({ start: 0, count: 2, sort: 'createdAt', search: 'oot' })
+      expect(total).to.equal(1)
+      expect(data.length).to.equal(1)
+      expect(data[0].username).to.equal('root')
     })
 
     it('Should search user by email', async function () {
       {
-        const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'r_1@exam')
-        const users = res.body.data as User[]
-
-        expect(res.body.total).to.equal(1)
-        expect(users.length).to.equal(1)
-
-        expect(users[0].username).to.equal('user_1')
-        expect(users[0].email).to.equal('user_1@example.com')
+        const { total, data } = await server.users.list({ start: 0, count: 2, sort: 'createdAt', search: 'r_1@exam' })
+        expect(total).to.equal(1)
+        expect(data.length).to.equal(1)
+        expect(data[0].username).to.equal('user_1')
+        expect(data[0].email).to.equal('user_1@example.com')
       }
 
       {
-        const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'example')
-        const users = res.body.data as User[]
-
-        expect(res.body.total).to.equal(2)
-        expect(users.length).to.equal(2)
-
-        expect(users[0].username).to.equal('root')
-        expect(users[1].username).to.equal('user_1')
+        const { total, data } = await server.users.list({ start: 0, count: 2, sort: 'createdAt', search: 'example' })
+        expect(total).to.equal(2)
+        expect(data.length).to.equal(2)
+        expect(data[0].username).to.equal('root')
+        expect(data[1].username).to.equal('user_1')
       }
     })
   })
 
   describe('Update my account', function () {
+
     it('Should update my password', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: accessTokenUser,
+      await server.users.updateMe({
+        token: userToken,
         currentPassword: 'super password',
         password: 'new password'
       })
       user.password = 'new password'
 
-      await userLogin(server, user, HttpStatusCode.OK_200)
+      await server.login.login({ user })
     })
 
     it('Should be able to change the NSFW display attribute', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: accessTokenUser,
+      await server.users.updateMe({
+        token: userToken,
         nsfwPolicy: 'do_not_list'
       })
 
-      const res = await getMyUserInformation(server.url, accessTokenUser)
-      const user = res.body
-
+      const user = await server.users.getMyInfo({ token: userToken })
       expect(user.username).to.equal('user_1')
       expect(user.email).to.equal('user_1@example.com')
       expect(user.nsfwPolicy).to.equal('do_not_list')
@@ -606,42 +515,33 @@ describe('Test users', function () {
     })
 
     it('Should be able to change the autoPlayVideo attribute', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: accessTokenUser,
+      await server.users.updateMe({
+        token: userToken,
         autoPlayVideo: false
       })
 
-      const res = await getMyUserInformation(server.url, accessTokenUser)
-      const user = res.body
-
+      const user = await server.users.getMyInfo({ token: userToken })
       expect(user.autoPlayVideo).to.be.false
     })
 
     it('Should be able to change the autoPlayNextVideo attribute', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: accessTokenUser,
+      await server.users.updateMe({
+        token: userToken,
         autoPlayNextVideo: true
       })
 
-      const res = await getMyUserInformation(server.url, accessTokenUser)
-      const user = res.body
-
+      const user = await server.users.getMyInfo({ token: userToken })
       expect(user.autoPlayNextVideo).to.be.true
     })
 
     it('Should be able to change the email attribute', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: accessTokenUser,
+      await server.users.updateMe({
+        token: userToken,
         currentPassword: 'new password',
         email: 'updated@example.com'
       })
 
-      const res = await getMyUserInformation(server.url, accessTokenUser)
-      const user = res.body
-
+      const user = await server.users.getMyInfo({ token: userToken })
       expect(user.username).to.equal('user_1')
       expect(user.email).to.equal('updated@example.com')
       expect(user.nsfwPolicy).to.equal('do_not_list')
@@ -654,15 +554,9 @@ describe('Test users', function () {
     it('Should be able to update my avatar with a gif', async function () {
       const fixture = 'avatar.gif'
 
-      await updateMyAvatar({
-        url: server.url,
-        accessToken: accessTokenUser,
-        fixture
-      })
-
-      const res = await getMyUserInformation(server.url, accessTokenUser)
-      const user = res.body
+      await server.users.updateMyAvatar({ token: userToken, fixture })
 
+      const user = await server.users.getMyInfo({ token: userToken })
       await testImage(server.url, 'avatar-resized', user.account.avatar.path, '.gif')
     })
 
@@ -670,29 +564,17 @@ describe('Test users', function () {
       for (const extension of [ '.png', '.gif' ]) {
         const fixture = 'avatar' + extension
 
-        await updateMyAvatar({
-          url: server.url,
-          accessToken: accessTokenUser,
-          fixture
-        })
-
-        const res = await getMyUserInformation(server.url, accessTokenUser)
-        const user = res.body
+        await server.users.updateMyAvatar({ token: userToken, fixture })
 
+        const user = await server.users.getMyInfo({ token: userToken })
         await testImage(server.url, 'avatar-resized', user.account.avatar.path, extension)
       }
     })
 
     it('Should be able to update my display name', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: accessTokenUser,
-        displayName: 'new display name'
-      })
-
-      const res = await getMyUserInformation(server.url, accessTokenUser)
-      const user = res.body
+      await server.users.updateMe({ token: userToken, displayName: 'new display name' })
 
+      const user = await server.users.getMyInfo({ token: userToken })
       expect(user.username).to.equal('user_1')
       expect(user.email).to.equal('updated@example.com')
       expect(user.nsfwPolicy).to.equal('do_not_list')
@@ -703,15 +585,9 @@ describe('Test users', function () {
     })
 
     it('Should be able to update my description', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: accessTokenUser,
-        description: 'my super description updated'
-      })
-
-      const res = await getMyUserInformation(server.url, accessTokenUser)
-      const user: User = res.body
+      await server.users.updateMe({ token: userToken, description: 'my super description updated' })
 
+      const user = await server.users.getMyInfo({ token: userToken })
       expect(user.username).to.equal('user_1')
       expect(user.email).to.equal('updated@example.com')
       expect(user.nsfwPolicy).to.equal('do_not_list')
@@ -725,30 +601,21 @@ describe('Test users', function () {
 
     it('Should be able to update my theme', async function () {
       for (const theme of [ 'background-red', 'default', 'instance-default' ]) {
-        await updateMyUser({
-          url: server.url,
-          accessToken: accessTokenUser,
-          theme
-        })
+        await server.users.updateMe({ token: userToken, theme })
 
-        const res = await getMyUserInformation(server.url, accessTokenUser)
-        const body: User = res.body
-
-        expect(body.theme).to.equal(theme)
+        const user = await server.users.getMyInfo({ token: userToken })
+        expect(user.theme).to.equal(theme)
       }
     })
 
     it('Should be able to update my modal preferences', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: accessTokenUser,
+      await server.users.updateMe({
+        token: userToken,
         noInstanceConfigWarningModal: true,
         noWelcomeModal: true
       })
 
-      const res = await getMyUserInformation(server.url, accessTokenUser)
-      const user: User = res.body
-
+      const user = await server.users.getMyInfo({ token: userToken })
       expect(user.noWelcomeModal).to.be.true
       expect(user.noInstanceConfigWarningModal).to.be.true
     })
@@ -756,10 +623,9 @@ describe('Test users', function () {
 
   describe('Updating another user', function () {
     it('Should be able to update another user', async function () {
-      await updateUser({
-        url: server.url,
+      await server.users.update({
         userId,
-        accessToken,
+        token,
         email: 'updated2@example.com',
         emailVerified: true,
         videoQuota: 42,
@@ -768,8 +634,7 @@ describe('Test users', function () {
         pluginAuth: 'toto'
       })
 
-      const res = await getUserInformation(server.url, accessToken, userId)
-      const user = res.body as User
+      const user = await server.users.get({ token, userId })
 
       expect(user.username).to.equal('user_1')
       expect(user.email).to.equal('updated2@example.com')
@@ -783,57 +648,50 @@ describe('Test users', function () {
     })
 
     it('Should reset the auth plugin', async function () {
-      await updateUser({ url: server.url, userId, accessToken, pluginAuth: null })
+      await server.users.update({ userId, token, pluginAuth: null })
 
-      const res = await getUserInformation(server.url, accessToken, userId)
-      const user = res.body as User
+      const user = await server.users.get({ token, userId })
       expect(user.pluginAuth).to.be.null
     })
 
     it('Should have removed the user token', async function () {
-      await getMyUserVideoQuotaUsed(server.url, accessTokenUser, HttpStatusCode.UNAUTHORIZED_401)
+      await server.users.getMyQuotaUsed({ token: userToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 
-      accessTokenUser = await userLogin(server, user)
+      userToken = await server.login.getAccessToken(user)
     })
 
     it('Should be able to update another user password', async function () {
-      await updateUser({
-        url: server.url,
-        userId,
-        accessToken,
-        password: 'password updated'
-      })
+      await server.users.update({ userId, token, password: 'password updated' })
 
-      await getMyUserVideoQuotaUsed(server.url, accessTokenUser, HttpStatusCode.UNAUTHORIZED_401)
+      await server.users.getMyQuotaUsed({ token: userToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 
-      await userLogin(server, user, HttpStatusCode.BAD_REQUEST_400)
+      await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
       user.password = 'password updated'
-      accessTokenUser = await userLogin(server, user)
+      userToken = await server.login.getAccessToken(user)
     })
   })
 
   describe('Video blacklists', function () {
     it('Should be able to list video blacklist by a moderator', async function () {
-      await getBlacklistedVideosList({ url: server.url, token: accessTokenUser })
+      await server.blacklist.list({ token: userToken })
     })
   })
 
   describe('Remove a user', function () {
     it('Should be able to remove this user', async function () {
-      await removeUser(server.url, userId, accessToken)
+      await server.users.remove({ userId, token })
     })
 
     it('Should not be able to login with this user', async function () {
-      await userLogin(server, user, HttpStatusCode.BAD_REQUEST_400)
+      await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should not have videos of this user', async function () {
-      const res = await getVideosList(server.url)
-
-      expect(res.body.total).to.equal(1)
+      const { data, total } = await server.videos.list()
+      expect(total).to.equal(1)
 
-      const video = res.body.data[0]
+      const video = data[0]
       expect(video.account.name).to.equal('root')
     })
   })
@@ -845,7 +703,7 @@ describe('Test users', function () {
       const user = { displayName: 'super user 15', username: 'user_15', password: 'my super password' }
       const channel = { name: 'my_user_15_channel', displayName: 'my channel rocks' }
 
-      await registerUserWithChannel({ url: server.url, user, channel })
+      await server.users.register({ ...user, channel })
     })
 
     it('Should be able to login with this registered user', async function () {
@@ -854,40 +712,36 @@ describe('Test users', function () {
         password: 'my super password'
       }
 
-      user15AccessToken = await userLogin(server, user15)
+      user15AccessToken = await server.login.getAccessToken(user15)
     })
 
     it('Should have the correct display name', async function () {
-      const res = await getMyUserInformation(server.url, user15AccessToken)
-      const user: User = res.body
-
+      const user = await server.users.getMyInfo({ token: user15AccessToken })
       expect(user.account.displayName).to.equal('super user 15')
     })
 
     it('Should have the correct video quota', async function () {
-      const res = await getMyUserInformation(server.url, user15AccessToken)
-      const user = res.body
-
+      const user = await server.users.getMyInfo({ token: user15AccessToken })
       expect(user.videoQuota).to.equal(5 * 1024 * 1024)
     })
 
     it('Should have created the channel', async function () {
-      const res = await getVideoChannel(server.url, 'my_user_15_channel')
+      const { displayName } = await server.channels.get({ channelName: 'my_user_15_channel' })
 
-      expect(res.body.displayName).to.equal('my channel rocks')
+      expect(displayName).to.equal('my channel rocks')
     })
 
     it('Should remove me', async function () {
       {
-        const res = await getUsersList(server.url, server.accessToken)
-        expect(res.body.data.find(u => u.username === 'user_15')).to.not.be.undefined
+        const { data } = await server.users.list()
+        expect(data.find(u => u.username === 'user_15')).to.not.be.undefined
       }
 
-      await deleteMe(server.url, user15AccessToken)
+      await server.users.deleteMe({ token: user15AccessToken })
 
       {
-        const res = await getUsersList(server.url, server.accessToken)
-        expect(res.body.data.find(u => u.username === 'user_15')).to.be.undefined
+        const { data } = await server.users.list()
+        expect(data.find(u => u.username === 'user_15')).to.be.undefined
       }
     })
   })
@@ -901,49 +755,40 @@ describe('Test users', function () {
     }
 
     it('Should block a user', async function () {
-      const resUser = await createUser({
-        url: server.url,
-        accessToken: server.accessToken,
-        username: user16.username,
-        password: user16.password
-      })
-      user16Id = resUser.body.user.id
+      const user = await server.users.create({ ...user16 })
+      user16Id = user.id
 
-      user16AccessToken = await userLogin(server, user16)
+      user16AccessToken = await server.login.getAccessToken(user16)
 
-      await getMyUserInformation(server.url, user16AccessToken, HttpStatusCode.OK_200)
-      await blockUser(server.url, user16Id, server.accessToken)
+      await server.users.getMyInfo({ token: user16AccessToken, expectedStatus: HttpStatusCode.OK_200 })
+      await server.users.banUser({ userId: user16Id })
 
-      await getMyUserInformation(server.url, user16AccessToken, HttpStatusCode.UNAUTHORIZED_401)
-      await userLogin(server, user16, HttpStatusCode.BAD_REQUEST_400)
+      await server.users.getMyInfo({ token: user16AccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+      await server.login.login({ user: user16, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should search user by banned status', async function () {
       {
-        const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', undefined, true)
-        const users = res.body.data as User[]
+        const { data, total } = await server.users.list({ start: 0, count: 2, sort: 'createdAt', blocked: true })
+        expect(total).to.equal(1)
+        expect(data.length).to.equal(1)
 
-        expect(res.body.total).to.equal(1)
-        expect(users.length).to.equal(1)
-
-        expect(users[0].username).to.equal(user16.username)
+        expect(data[0].username).to.equal(user16.username)
       }
 
       {
-        const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', undefined, false)
-        const users = res.body.data as User[]
-
-        expect(res.body.total).to.equal(1)
-        expect(users.length).to.equal(1)
+        const { data, total } = await server.users.list({ start: 0, count: 2, sort: 'createdAt', blocked: false })
+        expect(total).to.equal(1)
+        expect(data.length).to.equal(1)
 
-        expect(users[0].username).to.not.equal(user16.username)
+        expect(data[0].username).to.not.equal(user16.username)
       }
     })
 
     it('Should unblock a user', async function () {
-      await unblockUser(server.url, user16Id, server.accessToken)
-      user16AccessToken = await userLogin(server, user16)
-      await getMyUserInformation(server.url, user16AccessToken, HttpStatusCode.OK_200)
+      await server.users.unbanUser({ userId: user16Id })
+      user16AccessToken = await server.login.getAccessToken(user16)
+      await server.users.getMyInfo({ token: user16AccessToken, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -956,19 +801,12 @@ describe('Test users', function () {
         username: 'user_17',
         password: 'my super password'
       }
-      const resUser = await createUser({
-        url: server.url,
-        accessToken: server.accessToken,
-        username: user17.username,
-        password: user17.password
-      })
+      const created = await server.users.create({ ...user17 })
 
-      user17Id = resUser.body.user.id
-      user17AccessToken = await userLogin(server, user17)
-
-      const res = await getUserInformation(server.url, server.accessToken, user17Id, true)
-      const user: User = res.body
+      user17Id = created.id
+      user17AccessToken = await server.login.getAccessToken(user17)
 
+      const user = await server.users.get({ userId: user17Id, withStats: true })
       expect(user.videosCount).to.equal(0)
       expect(user.videoCommentsCount).to.equal(0)
       expect(user.abusesCount).to.equal(0)
@@ -977,54 +815,43 @@ describe('Test users', function () {
     })
 
     it('Should report correct videos count', async function () {
-      const videoAttributes = {
-        name: 'video to test user stats'
-      }
-      await uploadVideo(server.url, user17AccessToken, videoAttributes)
-      const res1 = await getVideosList(server.url)
-      videoId = res1.body.data.find(video => video.name === videoAttributes.name).id
+      const attributes = { name: 'video to test user stats' }
+      await server.videos.upload({ token: user17AccessToken, attributes })
 
-      const res2 = await getUserInformation(server.url, server.accessToken, user17Id, true)
-      const user: User = res2.body
+      const { data } = await server.videos.list()
+      videoId = data.find(video => video.name === attributes.name).id
 
+      const user = await server.users.get({ userId: user17Id, withStats: true })
       expect(user.videosCount).to.equal(1)
     })
 
     it('Should report correct video comments for user', async function () {
       const text = 'super comment'
-      await addVideoCommentThread(server.url, user17AccessToken, videoId, text)
-
-      const res = await getUserInformation(server.url, server.accessToken, user17Id, true)
-      const user: User = res.body
+      await server.comments.createThread({ token: user17AccessToken, videoId, text })
 
+      const user = await server.users.get({ userId: user17Id, withStats: true })
       expect(user.videoCommentsCount).to.equal(1)
     })
 
     it('Should report correct abuses counts', async function () {
       const reason = 'my super bad reason'
-      await reportAbuse({ url: server.url, token: user17AccessToken, videoId, reason })
-
-      const res1 = await getAdminAbusesList({ url: server.url, token: server.accessToken })
-      const abuseId = res1.body.data[0].id
+      await server.abuses.report({ token: user17AccessToken, videoId, reason })
 
-      const res2 = await getUserInformation(server.url, server.accessToken, user17Id, true)
-      const user2: User = res2.body
+      const body1 = await server.abuses.getAdminList()
+      const abuseId = body1.data[0].id
 
+      const user2 = await server.users.get({ userId: user17Id, withStats: true })
       expect(user2.abusesCount).to.equal(1) // number of incriminations
       expect(user2.abusesCreatedCount).to.equal(1) // number of reports created
 
-      const body: AbuseUpdate = { state: AbuseState.ACCEPTED }
-      await updateAbuse(server.url, server.accessToken, abuseId, body)
-
-      const res3 = await getUserInformation(server.url, server.accessToken, user17Id, true)
-      const user3: User = res3.body
+      await server.abuses.update({ abuseId, body: { state: AbuseState.ACCEPTED } })
 
+      const user3 = await server.users.get({ userId: user17Id, withStats: true })
       expect(user3.abusesAcceptedCount).to.equal(1) // number of reports created accepted
     })
   })
 
   after(async function () {
-    await closeAllSequelize([ server ])
     await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/videos/audio-only.ts b/server/tests/api/videos/audio-only.ts
index 7ddbd5cd9..7fac6e738 100644
--- a/server/tests/api/videos/audio-only.ts
+++ b/server/tests/api/videos/audio-only.ts
@@ -2,26 +2,16 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { join } from 'path'
 import { getAudioStream, getVideoStreamSize } from '@server/helpers/ffprobe-utils'
-import {
-  buildServerDirectory,
-  cleanupTests,
-  doubleFollow,
-  flushAndRunMultipleServers,
-  getVideo,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo,
-  waitJobs
-} from '../../../../shared/extra-utils'
-import { VideoDetails } from '../../../../shared/models/videos'
+import { cleanupTests, createMultipleServers, doubleFollow, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test audio only video transcoding', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoUUID: string
+  let webtorrentAudioFileUrl: string
+  let fragmentedAudioFileUrl: string
 
   before(async function () {
     this.timeout(120000)
@@ -47,7 +37,7 @@ describe('Test audio only video transcoding', function () {
         }
       }
     }
-    servers = await flushAndRunMultipleServers(2, configOverride)
+    servers = await createMultipleServers(2, configOverride)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -59,15 +49,13 @@ describe('Test audio only video transcoding', function () {
   it('Should upload a video and transcode it', async function () {
     this.timeout(120000)
 
-    const resUpload = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'audio only' })
-    videoUUID = resUpload.body.video.uuid
+    const { uuid } = await servers[0].videos.upload({ attributes: { name: 'audio only' } })
+    videoUUID = uuid
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = res.body
-
+      const video = await server.videos.get({ id: videoUUID })
       expect(video.streamingPlaylists).to.have.lengthOf(1)
 
       for (const files of [ video.files, video.streamingPlaylists[0].files ]) {
@@ -76,13 +64,18 @@ describe('Test audio only video transcoding', function () {
         expect(files[1].resolution.id).to.equal(240)
         expect(files[2].resolution.id).to.equal(0)
       }
+
+      if (server.serverNumber === 1) {
+        webtorrentAudioFileUrl = video.files[2].fileUrl
+        fragmentedAudioFileUrl = video.streamingPlaylists[0].files[2].fileUrl
+      }
     }
   })
 
   it('0p transcoded video should not have video', async function () {
     const paths = [
-      buildServerDirectory(servers[0], join('videos', videoUUID + '-0.mp4')),
-      buildServerDirectory(servers[0], join('streaming-playlists', 'hls', videoUUID, videoUUID + '-0-fragmented.mp4'))
+      servers[0].servers.buildWebTorrentFilePath(webtorrentAudioFileUrl),
+      servers[0].servers.buildFragmentedFilePath(videoUUID, fragmentedAudioFileUrl)
     ]
 
     for (const path of paths) {
diff --git a/server/tests/api/videos/multiple-servers.ts b/server/tests/api/videos/multiple-servers.ts
index a8c8a889b..f9220e4b3 100644
--- a/server/tests/api/videos/multiple-servers.ts
+++ b/server/tests/api/videos/multiple-servers.ts
@@ -3,49 +3,29 @@
 import 'mocha'
 import * as chai from 'chai'
 import * as request from 'supertest'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoChannel,
   buildAbsoluteFixturePath,
   checkTmpIsEmpty,
   checkVideoFilesWereRemoved,
   cleanupTests,
   completeVideoCheck,
-  createUser,
+  createMultipleServers,
   dateIsValid,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getLocalVideos,
-  getVideo,
-  getVideoChannelsList,
-  getVideosList,
-  rateVideo,
-  removeVideo,
-  ServerInfo,
+  PeerTubeServer,
+  saveVideoInServers,
   setAccessTokensToServers,
   testImage,
-  updateVideo,
-  uploadVideo,
-  userLogin,
-  viewVideo,
   wait,
+  waitJobs,
   webtorrentAdd
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  addVideoCommentReply,
-  addVideoCommentThread,
-  deleteVideoComment,
-  findCommentId,
-  getVideoCommentThreads,
-  getVideoThreadComments
-} from '../../../../shared/extra-utils/videos/video-comments'
-import { VideoComment, VideoCommentThreadTree, VideoPrivacy } from '../../../../shared/models/videos'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoCommentThreadTree, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test multiple servers', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   const toRemove = []
   let videoUUID = ''
   let videoChannelId: number
@@ -53,7 +33,7 @@ describe('Test multiple servers', function () {
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -64,9 +44,9 @@ describe('Test multiple servers', function () {
         displayName: 'my channel',
         description: 'super channel'
       }
-      await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
-      const channelRes = await getVideoChannelsList(servers[0].url, 0, 1)
-      videoChannelId = channelRes.body.data[0].id
+      await servers[0].channels.create({ attributes: videoChannel })
+      const { data } = await servers[0].channels.list({ start: 0, count: 1 })
+      videoChannelId = data[0].id
     }
 
     // Server 1 and server 2 follow each other
@@ -79,10 +59,9 @@ describe('Test multiple servers', function () {
 
   it('Should not have videos for all servers', async function () {
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      const videos = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos.length).to.equal(0)
+      const { data } = await server.videos.list()
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(0)
     }
   })
 
@@ -90,7 +69,7 @@ describe('Test multiple servers', function () {
     it('Should upload the video on server 1 and propagate on each server', async function () {
       this.timeout(25000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name for server 1',
         category: 5,
         licence: 4,
@@ -103,7 +82,7 @@ describe('Test multiple servers', function () {
         channelId: videoChannelId,
         fixture: 'video_short1.webm'
       }
-      await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+      await servers[0].videos.upload({ attributes })
 
       await waitJobs(servers)
 
@@ -146,14 +125,13 @@ describe('Test multiple servers', function () {
           ]
         }
 
-        const res = await getVideosList(server.url)
-        const videos = res.body.data
-        expect(videos).to.be.an('array')
-        expect(videos.length).to.equal(1)
-        const video = videos[0]
+        const { data } = await server.videos.list()
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(1)
+        const video = data[0]
 
-        await completeVideoCheck(server.url, video, checkAttributes)
-        publishedAt = video.publishedAt
+        await completeVideoCheck(server, video, checkAttributes)
+        publishedAt = video.publishedAt as string
       }
     })
 
@@ -164,10 +142,10 @@ describe('Test multiple servers', function () {
         username: 'user1',
         password: 'super_password'
       }
-      await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
-      const userAccessToken = await userLogin(servers[1], user)
+      await servers[1].users.create({ username: user.username, password: user.password })
+      const userAccessToken = await servers[1].login.getAccessToken(user)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name for server 2',
         category: 4,
         licence: 3,
@@ -180,7 +158,7 @@ describe('Test multiple servers', function () {
         thumbnailfile: 'thumbnail.jpg',
         previewfile: 'preview.jpg'
       }
-      await uploadVideo(servers[1].url, userAccessToken, videoAttributes, HttpStatusCode.OK_200, 'resumable')
+      await servers[1].videos.upload({ token: userAccessToken, attributes, mode: 'resumable' })
 
       // Transcoding
       await waitJobs(servers)
@@ -235,65 +213,67 @@ describe('Test multiple servers', function () {
           previewfile: 'preview'
         }
 
-        const res = await getVideosList(server.url)
-        const videos = res.body.data
-        expect(videos).to.be.an('array')
-        expect(videos.length).to.equal(2)
-        const video = videos[1]
+        const { data } = await server.videos.list()
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(2)
+        const video = data[1]
 
-        await completeVideoCheck(server.url, video, checkAttributes)
+        await completeVideoCheck(server, video, checkAttributes)
       }
     })
 
     it('Should upload two videos on server 3 and propagate on each server', async function () {
       this.timeout(45000)
 
-      const videoAttributes1 = {
-        name: 'my super name for server 3',
-        category: 6,
-        licence: 5,
-        language: 'de',
-        nsfw: true,
-        description: 'my super description for server 3',
-        support: 'my super support text for server 3',
-        tags: [ 'tag1p3' ],
-        fixture: 'video_short3.webm'
+      {
+        const attributes = {
+          name: 'my super name for server 3',
+          category: 6,
+          licence: 5,
+          language: 'de',
+          nsfw: true,
+          description: 'my super description for server 3',
+          support: 'my super support text for server 3',
+          tags: [ 'tag1p3' ],
+          fixture: 'video_short3.webm'
+        }
+        await servers[2].videos.upload({ attributes })
       }
-      await uploadVideo(servers[2].url, servers[2].accessToken, videoAttributes1)
-
-      const videoAttributes2 = {
-        name: 'my super name for server 3-2',
-        category: 7,
-        licence: 6,
-        language: 'ko',
-        nsfw: false,
-        description: 'my super description for server 3-2',
-        support: 'my super support text for server 3-2',
-        tags: [ 'tag2p3', 'tag3p3', 'tag4p3' ],
-        fixture: 'video_short.webm'
+
+      {
+        const attributes = {
+          name: 'my super name for server 3-2',
+          category: 7,
+          licence: 6,
+          language: 'ko',
+          nsfw: false,
+          description: 'my super description for server 3-2',
+          support: 'my super support text for server 3-2',
+          tags: [ 'tag2p3', 'tag3p3', 'tag4p3' ],
+          fixture: 'video_short.webm'
+        }
+        await servers[2].videos.upload({ attributes })
       }
-      await uploadVideo(servers[2].url, servers[2].accessToken, videoAttributes2)
 
       await waitJobs(servers)
 
       // All servers should have this video
       for (const server of servers) {
         const isLocal = server.url === 'http://localhost:' + servers[2].port
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const videos = res.body.data
-        expect(videos).to.be.an('array')
-        expect(videos.length).to.equal(4)
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(4)
 
         // We not sure about the order of the two last uploads
         let video1 = null
         let video2 = null
-        if (videos[2].name === 'my super name for server 3') {
-          video1 = videos[2]
-          video2 = videos[3]
+        if (data[2].name === 'my super name for server 3') {
+          video1 = data[2]
+          video2 = data[3]
         } else {
-          video1 = videos[3]
-          video2 = videos[2]
+          video1 = data[3]
+          video2 = data[2]
         }
 
         const checkAttributesVideo1 = {
@@ -328,7 +308,7 @@ describe('Test multiple servers', function () {
             }
           ]
         }
-        await completeVideoCheck(server.url, video1, checkAttributesVideo1)
+        await completeVideoCheck(server, video1, checkAttributesVideo1)
 
         const checkAttributesVideo2 = {
           name: 'my super name for server 3-2',
@@ -362,38 +342,38 @@ describe('Test multiple servers', function () {
             }
           ]
         }
-        await completeVideoCheck(server.url, video2, checkAttributesVideo2)
+        await completeVideoCheck(server, video2, checkAttributesVideo2)
       }
     })
   })
 
   describe('It should list local videos', function () {
     it('Should list only local videos on server 1', async function () {
-      const { body } = await getLocalVideos(servers[0].url)
+      const { data, total } = await servers[0].videos.list({ filter: 'local' })
 
-      expect(body.total).to.equal(1)
-      expect(body.data).to.be.an('array')
-      expect(body.data.length).to.equal(1)
-      expect(body.data[0].name).to.equal('my super name for server 1')
+      expect(total).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(1)
+      expect(data[0].name).to.equal('my super name for server 1')
     })
 
     it('Should list only local videos on server 2', async function () {
-      const { body } = await getLocalVideos(servers[1].url)
+      const { data, total } = await servers[1].videos.list({ filter: 'local' })
 
-      expect(body.total).to.equal(1)
-      expect(body.data).to.be.an('array')
-      expect(body.data.length).to.equal(1)
-      expect(body.data[0].name).to.equal('my super name for server 2')
+      expect(total).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(1)
+      expect(data[0].name).to.equal('my super name for server 2')
     })
 
     it('Should list only local videos on server 3', async function () {
-      const { body } = await getLocalVideos(servers[2].url)
+      const { data, total } = await servers[2].videos.list({ filter: 'local' })
 
-      expect(body.total).to.equal(2)
-      expect(body.data).to.be.an('array')
-      expect(body.data.length).to.equal(2)
-      expect(body.data[0].name).to.equal('my super name for server 3')
-      expect(body.data[1].name).to.equal('my super name for server 3-2')
+      expect(total).to.equal(2)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(2)
+      expect(data[0].name).to.equal('my super name for server 3')
+      expect(data[1].name).to.equal('my super name for server 3-2')
     })
   })
 
@@ -401,15 +381,13 @@ describe('Test multiple servers', function () {
     it('Should add the file 1 by asking server 3', async function () {
       this.timeout(10000)
 
-      const res = await getVideosList(servers[2].url)
-
-      const video = res.body.data[0]
-      toRemove.push(res.body.data[2])
-      toRemove.push(res.body.data[3])
+      const { data } = await servers[2].videos.list()
 
-      const res2 = await getVideo(servers[2].url, video.id)
-      const videoDetails = res2.body
+      const video = data[0]
+      toRemove.push(data[2])
+      toRemove.push(data[3])
 
+      const videoDetails = await servers[2].videos.get({ id: video.id })
       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
       expect(torrent.files).to.be.an('array')
       expect(torrent.files.length).to.equal(1)
@@ -419,11 +397,10 @@ describe('Test multiple servers', function () {
     it('Should add the file 2 by asking server 1', async function () {
       this.timeout(10000)
 
-      const res = await getVideosList(servers[0].url)
+      const { data } = await servers[0].videos.list()
 
-      const video = res.body.data[1]
-      const res2 = await getVideo(servers[0].url, video.id)
-      const videoDetails = res2.body
+      const video = data[1]
+      const videoDetails = await servers[0].videos.get({ id: video.id })
 
       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
       expect(torrent.files).to.be.an('array')
@@ -434,11 +411,10 @@ describe('Test multiple servers', function () {
     it('Should add the file 3 by asking server 2', async function () {
       this.timeout(10000)
 
-      const res = await getVideosList(servers[1].url)
+      const { data } = await servers[1].videos.list()
 
-      const video = res.body.data[2]
-      const res2 = await getVideo(servers[1].url, video.id)
-      const videoDetails = res2.body
+      const video = data[2]
+      const videoDetails = await servers[1].videos.get({ id: video.id })
 
       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
       expect(torrent.files).to.be.an('array')
@@ -449,11 +425,10 @@ describe('Test multiple servers', function () {
     it('Should add the file 3-2 by asking server 1', async function () {
       this.timeout(10000)
 
-      const res = await getVideosList(servers[0].url)
+      const { data } = await servers[0].videos.list()
 
-      const video = res.body.data[3]
-      const res2 = await getVideo(servers[0].url, video.id)
-      const videoDetails = res2.body
+      const video = data[3]
+      const videoDetails = await servers[0].videos.get({ id: video.id })
 
       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
       expect(torrent.files).to.be.an('array')
@@ -464,11 +439,10 @@ describe('Test multiple servers', function () {
     it('Should add the file 2 in 360p by asking server 1', async function () {
       this.timeout(10000)
 
-      const res = await getVideosList(servers[0].url)
+      const { data } = await servers[0].videos.list()
 
-      const video = res.body.data.find(v => v.name === 'my super name for server 2')
-      const res2 = await getVideo(servers[0].url, video.id)
-      const videoDetails = res2.body
+      const video = data.find(v => v.name === 'my super name for server 2')
+      const videoDetails = await servers[0].videos.get({ id: video.id })
 
       const file = videoDetails.files.find(f => f.resolution.id === 360)
       expect(file).not.to.be.undefined
@@ -487,30 +461,36 @@ describe('Test multiple servers', function () {
     let remoteVideosServer3 = []
 
     before(async function () {
-      const res1 = await getVideosList(servers[0].url)
-      remoteVideosServer1 = res1.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
+      {
+        const { data } = await servers[0].videos.list()
+        remoteVideosServer1 = data.filter(video => video.isLocal === false).map(video => video.uuid)
+      }
 
-      const res2 = await getVideosList(servers[1].url)
-      remoteVideosServer2 = res2.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
+      {
+        const { data } = await servers[1].videos.list()
+        remoteVideosServer2 = data.filter(video => video.isLocal === false).map(video => video.uuid)
+      }
 
-      const res3 = await getVideosList(servers[2].url)
-      localVideosServer3 = res3.body.data.filter(video => video.isLocal === true).map(video => video.uuid)
-      remoteVideosServer3 = res3.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
+      {
+        const { data } = await servers[2].videos.list()
+        localVideosServer3 = data.filter(video => video.isLocal === true).map(video => video.uuid)
+        remoteVideosServer3 = data.filter(video => video.isLocal === false).map(video => video.uuid)
+      }
     })
 
     it('Should view multiple videos on owned servers', async function () {
       this.timeout(30000)
 
-      await viewVideo(servers[2].url, localVideosServer3[0])
+      await servers[2].videos.view({ id: localVideosServer3[0] })
       await wait(1000)
 
-      await viewVideo(servers[2].url, localVideosServer3[0])
-      await viewVideo(servers[2].url, localVideosServer3[1])
+      await servers[2].videos.view({ id: localVideosServer3[0] })
+      await servers[2].videos.view({ id: localVideosServer3[1] })
 
       await wait(1000)
 
-      await viewVideo(servers[2].url, localVideosServer3[0])
-      await viewVideo(servers[2].url, localVideosServer3[0])
+      await servers[2].videos.view({ id: localVideosServer3[0] })
+      await servers[2].videos.view({ id: localVideosServer3[0] })
 
       await waitJobs(servers)
 
@@ -520,11 +500,10 @@ describe('Test multiple servers', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const videos = res.body.data
-        const video0 = videos.find(v => v.uuid === localVideosServer3[0])
-        const video1 = videos.find(v => v.uuid === localVideosServer3[1])
+        const video0 = data.find(v => v.uuid === localVideosServer3[0])
+        const video1 = data.find(v => v.uuid === localVideosServer3[1])
 
         expect(video0.views).to.equal(3)
         expect(video1.views).to.equal(1)
@@ -535,16 +514,16 @@ describe('Test multiple servers', function () {
       this.timeout(45000)
 
       const tasks: Promise<any>[] = []
-      tasks.push(viewVideo(servers[0].url, remoteVideosServer1[0]))
-      tasks.push(viewVideo(servers[1].url, remoteVideosServer2[0]))
-      tasks.push(viewVideo(servers[1].url, remoteVideosServer2[0]))
-      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[0]))
-      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[1]))
-      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[1]))
-      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[1]))
-      tasks.push(viewVideo(servers[2].url, localVideosServer3[1]))
-      tasks.push(viewVideo(servers[2].url, localVideosServer3[1]))
-      tasks.push(viewVideo(servers[2].url, localVideosServer3[1]))
+      tasks.push(servers[0].videos.view({ id: remoteVideosServer1[0] }))
+      tasks.push(servers[1].videos.view({ id: remoteVideosServer2[0] }))
+      tasks.push(servers[1].videos.view({ id: remoteVideosServer2[0] }))
+      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[0] }))
+      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
+      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
+      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
+      tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
+      tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
+      tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
 
       await Promise.all(tasks)
 
@@ -558,18 +537,16 @@ describe('Test multiple servers', function () {
       let baseVideos = null
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-
-        const videos = res.body.data
+        const { data } = await server.videos.list()
 
         // Initialize base videos for future comparisons
         if (baseVideos === null) {
-          baseVideos = videos
+          baseVideos = data
           continue
         }
 
         for (const baseVideo of baseVideos) {
-          const sameVideo = videos.find(video => video.name === baseVideo.name)
+          const sameVideo = data.find(video => video.name === baseVideo.name)
           expect(baseVideo.views).to.equal(sameVideo.views)
         }
       }
@@ -578,35 +555,34 @@ describe('Test multiple servers', function () {
     it('Should like and dislikes videos on different services', async function () {
       this.timeout(50000)
 
-      await rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'like')
+      await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'like' })
       await wait(500)
-      await rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'dislike')
+      await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'dislike' })
       await wait(500)
-      await rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'like')
-      await rateVideo(servers[2].url, servers[2].accessToken, localVideosServer3[1], 'like')
+      await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'like' })
+      await servers[2].videos.rate({ id: localVideosServer3[1], rating: 'like' })
       await wait(500)
-      await rateVideo(servers[2].url, servers[2].accessToken, localVideosServer3[1], 'dislike')
-      await rateVideo(servers[2].url, servers[2].accessToken, remoteVideosServer3[1], 'dislike')
+      await servers[2].videos.rate({ id: localVideosServer3[1], rating: 'dislike' })
+      await servers[2].videos.rate({ id: remoteVideosServer3[1], rating: 'dislike' })
       await wait(500)
-      await rateVideo(servers[2].url, servers[2].accessToken, remoteVideosServer3[0], 'like')
+      await servers[2].videos.rate({ id: remoteVideosServer3[0], rating: 'like' })
 
       await waitJobs(servers)
       await wait(5000)
+      await waitJobs(servers)
 
       let baseVideos = null
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-
-        const videos = res.body.data
+        const { data } = await server.videos.list()
 
         // Initialize base videos for future comparisons
         if (baseVideos === null) {
-          baseVideos = videos
+          baseVideos = data
           continue
         }
 
         for (const baseVideo of baseVideos) {
-          const sameVideo = videos.find(video => video.name === baseVideo.name)
+          const sameVideo = data.find(video => video.name === baseVideo.name)
           expect(baseVideo.likes).to.equal(sameVideo.likes)
           expect(baseVideo.dislikes).to.equal(sameVideo.dislikes)
         }
@@ -632,7 +608,7 @@ describe('Test multiple servers', function () {
         previewfile: 'preview.jpg'
       }
 
-      await updateVideo(servers[2].url, servers[2].accessToken, toRemove[0].id, attributes)
+      await servers[2].videos.update({ id: toRemove[0].id, attributes })
 
       await waitJobs(servers)
     })
@@ -641,10 +617,9 @@ describe('Test multiple servers', function () {
       this.timeout(10000)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const videos = res.body.data
-        const videoUpdated = videos.find(video => video.name === 'my super video updated')
+        const videoUpdated = data.find(video => video.name === 'my super video updated')
         expect(!!videoUpdated).to.be.true
 
         const isLocal = server.url === 'http://localhost:' + servers[2].port
@@ -683,49 +658,46 @@ describe('Test multiple servers', function () {
           thumbnailfile: 'thumbnail',
           previewfile: 'preview'
         }
-        await completeVideoCheck(server.url, videoUpdated, checkAttributes)
+        await completeVideoCheck(server, videoUpdated, checkAttributes)
       }
     })
 
-    it('Should remove the videos 3 and 3-2 by asking server 3', async function () {
-      this.timeout(10000)
+    it('Should remove the videos 3 and 3-2 by asking server 3 and correctly delete files', async function () {
+      this.timeout(30000)
 
-      await removeVideo(servers[2].url, servers[2].accessToken, toRemove[0].id)
-      await removeVideo(servers[2].url, servers[2].accessToken, toRemove[1].id)
+      for (const id of [ toRemove[0].id, toRemove[1].id ]) {
+        await saveVideoInServers(servers, id)
 
-      await waitJobs(servers)
-    })
+        await servers[2].videos.remove({ id })
 
-    it('Should not have files of videos 3 and 3-2 on each server', async function () {
-      for (const server of servers) {
-        await checkVideoFilesWereRemoved(toRemove[0].uuid, server.internalServerNumber)
-        await checkVideoFilesWereRemoved(toRemove[1].uuid, server.internalServerNumber)
+        await waitJobs(servers)
+
+        for (const server of servers) {
+          await checkVideoFilesWereRemoved({ server, video: server.store.videoDetails })
+        }
       }
     })
 
     it('Should have videos 1 and 3 on each server', async function () {
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-
-        const videos = res.body.data
-        expect(videos).to.be.an('array')
-        expect(videos.length).to.equal(2)
-        expect(videos[0].name).not.to.equal(videos[1].name)
-        expect(videos[0].name).not.to.equal(toRemove[0].name)
-        expect(videos[1].name).not.to.equal(toRemove[0].name)
-        expect(videos[0].name).not.to.equal(toRemove[1].name)
-        expect(videos[1].name).not.to.equal(toRemove[1].name)
-
-        videoUUID = videos.find(video => video.name === 'my super name for server 1').uuid
+        const { data } = await server.videos.list()
+
+        expect(data).to.be.an('array')
+        expect(data.length).to.equal(2)
+        expect(data[0].name).not.to.equal(data[1].name)
+        expect(data[0].name).not.to.equal(toRemove[0].name)
+        expect(data[1].name).not.to.equal(toRemove[0].name)
+        expect(data[0].name).not.to.equal(toRemove[1].name)
+        expect(data[1].name).not.to.equal(toRemove[1].name)
+
+        videoUUID = data.find(video => video.name === 'my super name for server 1').uuid
       }
     })
 
     it('Should get the same video by UUID on each server', async function () {
       let baseVideo = null
       for (const server of servers) {
-        const res = await getVideo(server.url, videoUUID)
-
-        const video = res.body
+        const video = await server.videos.get({ id: videoUUID })
 
         if (baseVideo === null) {
           baseVideo = video
@@ -748,8 +720,7 @@ describe('Test multiple servers', function () {
 
     it('Should get the preview from each server', async function () {
       for (const server of servers) {
-        const res = await getVideo(server.url, videoUUID)
-        const video = res.body
+        const video = await server.videos.get({ id: videoUUID })
 
         await testImage(server.url, 'video_short1-preview.webm', video.previewPath)
       }
@@ -764,36 +735,36 @@ describe('Test multiple servers', function () {
 
       {
         const text = 'my super first comment'
-        await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, text)
+        await servers[0].comments.createThread({ videoId: videoUUID, text })
       }
 
       {
         const text = 'my super second comment'
-        await addVideoCommentThread(servers[2].url, servers[2].accessToken, videoUUID, text)
+        await servers[2].comments.createThread({ videoId: videoUUID, text })
       }
 
       await waitJobs(servers)
 
       {
-        const threadId = await findCommentId(servers[1].url, videoUUID, 'my super first comment')
+        const threadId = await servers[1].comments.findCommentId({ videoId: videoUUID, text: 'my super first comment' })
 
         const text = 'my super answer to thread 1'
-        await addVideoCommentReply(servers[1].url, servers[1].accessToken, videoUUID, threadId, text)
+        await servers[1].comments.addReply({ videoId: videoUUID, toCommentId: threadId, text })
       }
 
       await waitJobs(servers)
 
       {
-        const threadId = await findCommentId(servers[2].url, videoUUID, 'my super first comment')
+        const threadId = await servers[2].comments.findCommentId({ videoId: videoUUID, text: 'my super first comment' })
 
-        const res2 = await getVideoThreadComments(servers[2].url, videoUUID, threadId)
-        const childCommentId = res2.body.children[0].comment.id
+        const body = await servers[2].comments.getThread({ videoId: videoUUID, threadId })
+        const childCommentId = body.children[0].comment.id
 
         const text3 = 'my second answer to thread 1'
-        await addVideoCommentReply(servers[2].url, servers[2].accessToken, videoUUID, threadId, text3)
+        await servers[2].comments.addReply({ videoId: videoUUID, toCommentId: threadId, text: text3 })
 
         const text2 = 'my super answer to answer of thread 1'
-        await addVideoCommentReply(servers[2].url, servers[2].accessToken, videoUUID, childCommentId, text2)
+        await servers[2].comments.addReply({ videoId: videoUUID, toCommentId: childCommentId, text: text2 })
       }
 
       await waitJobs(servers)
@@ -801,14 +772,14 @@ describe('Test multiple servers', function () {
 
     it('Should have these threads', async function () {
       for (const server of servers) {
-        const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+        const body = await server.comments.listThreads({ videoId: videoUUID })
 
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data).to.have.lengthOf(2)
+        expect(body.total).to.equal(2)
+        expect(body.data).to.be.an('array')
+        expect(body.data).to.have.lengthOf(2)
 
         {
-          const comment: VideoComment = res.body.data.find(c => c.text === 'my super first comment')
+          const comment = body.data.find(c => c.text === 'my super first comment')
           expect(comment).to.not.be.undefined
           expect(comment.inReplyToCommentId).to.be.null
           expect(comment.account.name).to.equal('root')
@@ -819,7 +790,7 @@ describe('Test multiple servers', function () {
         }
 
         {
-          const comment: VideoComment = res.body.data.find(c => c.text === 'my super second comment')
+          const comment = body.data.find(c => c.text === 'my super second comment')
           expect(comment).to.not.be.undefined
           expect(comment.inReplyToCommentId).to.be.null
           expect(comment.account.name).to.equal('root')
@@ -833,12 +804,11 @@ describe('Test multiple servers', function () {
 
     it('Should have these comments', async function () {
       for (const server of servers) {
-        const res1 = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
-        const threadId = res1.body.data.find(c => c.text === 'my super first comment').id
+        const body = await server.comments.listThreads({ videoId: videoUUID })
+        const threadId = body.data.find(c => c.text === 'my super first comment').id
 
-        const res2 = await getVideoThreadComments(server.url, videoUUID, threadId)
+        const tree = await server.comments.getThread({ videoId: videoUUID, threadId })
 
-        const tree: VideoCommentThreadTree = res2.body
         expect(tree.comment.text).equal('my super first comment')
         expect(tree.comment.account.name).equal('root')
         expect(tree.comment.account.host).equal('localhost:' + servers[0].port)
@@ -867,19 +837,17 @@ describe('Test multiple servers', function () {
     it('Should delete a reply', async function () {
       this.timeout(10000)
 
-      await deleteVideoComment(servers[2].url, servers[2].accessToken, videoUUID, childOfFirstChild.comment.id)
+      await servers[2].comments.delete({ videoId: videoUUID, commentId: childOfFirstChild.comment.id })
 
       await waitJobs(servers)
     })
 
     it('Should have this comment marked as deleted', async function () {
       for (const server of servers) {
-        const res1 = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
-        const threadId = res1.body.data.find(c => c.text === 'my super first comment').id
-
-        const res2 = await getVideoThreadComments(server.url, videoUUID, threadId)
+        const { data } = await server.comments.listThreads({ videoId: videoUUID })
+        const threadId = data.find(c => c.text === 'my super first comment').id
 
-        const tree: VideoCommentThreadTree = res2.body
+        const tree = await server.comments.getThread({ videoId: videoUUID, threadId })
         expect(tree.comment.text).equal('my super first comment')
 
         const firstChild = tree.children[0]
@@ -900,23 +868,23 @@ describe('Test multiple servers', function () {
     it('Should delete the thread comments', async function () {
       this.timeout(10000)
 
-      const res = await getVideoCommentThreads(servers[0].url, videoUUID, 0, 5)
-      const threadId = res.body.data.find(c => c.text === 'my super first comment').id
-      await deleteVideoComment(servers[0].url, servers[0].accessToken, videoUUID, threadId)
+      const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
+      const commentId = data.find(c => c.text === 'my super first comment').id
+      await servers[0].comments.delete({ videoId: videoUUID, commentId })
 
       await waitJobs(servers)
     })
 
     it('Should have the threads marked as deleted on other servers too', async function () {
       for (const server of servers) {
-        const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+        const body = await server.comments.listThreads({ videoId: videoUUID })
 
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.be.an('array')
-        expect(res.body.data).to.have.lengthOf(2)
+        expect(body.total).to.equal(2)
+        expect(body.data).to.be.an('array')
+        expect(body.data).to.have.lengthOf(2)
 
         {
-          const comment: VideoComment = res.body.data[0]
+          const comment = body.data[0]
           expect(comment).to.not.be.undefined
           expect(comment.inReplyToCommentId).to.be.null
           expect(comment.account.name).to.equal('root')
@@ -927,7 +895,7 @@ describe('Test multiple servers', function () {
         }
 
         {
-          const deletedComment: VideoComment = res.body.data[1]
+          const deletedComment = body.data[1]
           expect(deletedComment).to.not.be.undefined
           expect(deletedComment.isDeleted).to.be.true
           expect(deletedComment.deletedAt).to.not.be.null
@@ -945,22 +913,22 @@ describe('Test multiple servers', function () {
     it('Should delete a remote thread by the origin server', async function () {
       this.timeout(5000)
 
-      const res = await getVideoCommentThreads(servers[0].url, videoUUID, 0, 5)
-      const threadId = res.body.data.find(c => c.text === 'my super second comment').id
-      await deleteVideoComment(servers[0].url, servers[0].accessToken, videoUUID, threadId)
+      const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
+      const commentId = data.find(c => c.text === 'my super second comment').id
+      await servers[0].comments.delete({ videoId: videoUUID, commentId })
 
       await waitJobs(servers)
     })
 
     it('Should have the threads marked as deleted on other servers too', async function () {
       for (const server of servers) {
-        const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+        const body = await server.comments.listThreads({ videoId: videoUUID })
 
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.have.lengthOf(2)
+        expect(body.total).to.equal(2)
+        expect(body.data).to.have.lengthOf(2)
 
         {
-          const comment: VideoComment = res.body.data[0]
+          const comment = body.data[0]
           expect(comment.text).to.equal('')
           expect(comment.isDeleted).to.be.true
           expect(comment.createdAt).to.not.be.null
@@ -970,7 +938,7 @@ describe('Test multiple servers', function () {
         }
 
         {
-          const comment: VideoComment = res.body.data[1]
+          const comment = body.data[1]
           expect(comment.text).to.equal('')
           expect(comment.isDeleted).to.be.true
           expect(comment.createdAt).to.not.be.null
@@ -989,17 +957,17 @@ describe('Test multiple servers', function () {
         downloadEnabled: false
       }
 
-      await updateVideo(servers[0].url, servers[0].accessToken, videoUUID, attributes)
+      await servers[0].videos.update({ id: videoUUID, attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideo(server.url, videoUUID)
-        expect(res.body.commentsEnabled).to.be.false
-        expect(res.body.downloadEnabled).to.be.false
+        const video = await server.videos.get({ id: videoUUID })
+        expect(video.commentsEnabled).to.be.false
+        expect(video.downloadEnabled).to.be.false
 
         const text = 'my super forbidden comment'
-        await addVideoCommentThread(server.url, server.accessToken, videoUUID, text, HttpStatusCode.CONFLICT_409)
+        await server.comments.createThread({ videoId: videoUUID, text, expectedStatus: HttpStatusCode.CONFLICT_409 })
       }
     })
   })
@@ -1024,8 +992,8 @@ describe('Test multiple servers', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        const video = res.body.data.find(v => v.name === 'minimum parameters')
+        const { data } = await server.videos.list()
+        const video = data.find(v => v.name === 'minimum parameters')
 
         const isLocal = server.url === 'http://localhost:' + servers[1].port
         const checkAttributes = {
@@ -1072,7 +1040,7 @@ describe('Test multiple servers', function () {
             }
           ]
         }
-        await completeVideoCheck(server.url, video, checkAttributes)
+        await completeVideoCheck(server, video, checkAttributes)
       }
     })
   })
diff --git a/server/tests/api/videos/resumable-upload.ts b/server/tests/api/videos/resumable-upload.ts
index 4fc3317df..857859fd3 100644
--- a/server/tests/api/videos/resumable-upload.ts
+++ b/server/tests/api/videos/resumable-upload.ts
@@ -4,22 +4,15 @@ import 'mocha'
 import * as chai from 'chai'
 import { pathExists, readdir, stat } from 'fs-extra'
 import { join } from 'path'
-import { HttpStatusCode } from '@shared/core-utils'
 import {
   buildAbsoluteFixturePath,
-  buildServerDirectory,
   cleanupTests,
-  flushAndRunServer,
-  getMyUserInformation,
-  prepareResumableUpload,
-  sendDebugCommand,
-  sendResumableChunks,
-  ServerInfo,
+  createSingleServer,
+  PeerTubeServer,
   setAccessTokensToServers,
-  setDefaultVideoChannel,
-  updateUser
+  setDefaultVideoChannel
 } from '@shared/extra-utils'
-import { MyUser, VideoPrivacy } from '@shared/models'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
@@ -27,7 +20,7 @@ const expect = chai.expect
 
 describe('Test resumable upload', function () {
   const defaultFixture = 'video_short.mp4'
-  let server: ServerInfo
+  let server: PeerTubeServer
   let rootId: number
 
   async function buildSize (fixture: string, size?: number) {
@@ -42,14 +35,14 @@ describe('Test resumable upload', function () {
 
     const attributes = {
       name: 'video',
-      channelId: server.videoChannel.id,
+      channelId: server.store.channel.id,
       privacy: VideoPrivacy.PUBLIC,
       fixture: defaultFixture
     }
 
     const mimetype = 'video/mp4'
 
-    const res = await prepareResumableUpload({ url: server.url, token: server.accessToken, attributes, size, mimetype })
+    const res = await server.videos.prepareResumableUpload({ attributes, size, mimetype })
 
     return res.header['location'].split('?')[1]
   }
@@ -67,15 +60,13 @@ describe('Test resumable upload', function () {
     const size = await buildSize(defaultFixture, options.size)
     const absoluteFilePath = buildAbsoluteFixturePath(defaultFixture)
 
-    return sendResumableChunks({
-      url: server.url,
-      token: server.accessToken,
+    return server.videos.sendResumableChunks({
       pathUploadId,
       videoFilePath: absoluteFilePath,
       size,
       contentLength,
       contentRangeBuilder,
-      specialStatus: expectedStatus
+      expectedStatus
     })
   }
 
@@ -83,7 +74,7 @@ describe('Test resumable upload', function () {
     const uploadId = uploadIdArg.replace(/^upload_id=/, '')
 
     const subPath = join('tmp', 'resumable-uploads', uploadId)
-    const filePath = buildServerDirectory(server, subPath)
+    const filePath = server.servers.buildDirectory(subPath)
     const exists = await pathExists(filePath)
 
     if (expectedSize === null) {
@@ -98,7 +89,7 @@ describe('Test resumable upload', function () {
 
   async function countResumableUploads () {
     const subPath = join('tmp', 'resumable-uploads')
-    const filePath = buildServerDirectory(server, subPath)
+    const filePath = server.servers.buildDirectory(subPath)
 
     const files = await readdir(filePath)
     return files.length
@@ -107,19 +98,14 @@ describe('Test resumable upload', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
     await setDefaultVideoChannel([ server ])
 
-    const res = await getMyUserInformation(server.url, server.accessToken)
-    rootId = (res.body as MyUser).id
+    const body = await server.users.getMyInfo()
+    rootId = body.id
 
-    await updateUser({
-      url: server.url,
-      userId: rootId,
-      accessToken: server.accessToken,
-      videoQuota: 10_000_000
-    })
+    await server.users.update({ userId: rootId, videoQuota: 10_000_000 })
   })
 
   describe('Directory cleaning', function () {
@@ -138,13 +124,13 @@ describe('Test resumable upload', function () {
     })
 
     it('Should not delete recent uploads', async function () {
-      await sendDebugCommand(server.url, server.accessToken, { command: 'remove-dandling-resumable-uploads' })
+      await server.debug.sendCommand({ body: { command: 'remove-dandling-resumable-uploads' } })
 
       expect(await countResumableUploads()).to.equal(2)
     })
 
     it('Should delete old uploads', async function () {
-      await sendDebugCommand(server.url, server.accessToken, { command: 'remove-dandling-resumable-uploads' })
+      await server.debug.sendCommand({ body: { command: 'remove-dandling-resumable-uploads' } })
 
       expect(await countResumableUploads()).to.equal(0)
     })
@@ -160,8 +146,7 @@ describe('Test resumable upload', function () {
     })
 
     it('Should not accept more chunks than expected', async function () {
-      const size = 100
-      const uploadId = await prepareUpload(size)
+      const uploadId = await prepareUpload(100)
 
       await sendChunks({ pathUploadId: uploadId, expectedStatus: HttpStatusCode.CONFLICT_409 })
       await checkFileSize(uploadId, 0)
@@ -170,8 +155,14 @@ describe('Test resumable upload', function () {
     it('Should not accept more chunks than expected with an invalid content length/content range', async function () {
       const uploadId = await prepareUpload(1500)
 
-      await sendChunks({ pathUploadId: uploadId, expectedStatus: HttpStatusCode.BAD_REQUEST_400, contentLength: 1000 })
-      await checkFileSize(uploadId, 0)
+      // Content length check seems to have changed in v16
+      if (process.version.startsWith('v16')) {
+        await sendChunks({ pathUploadId: uploadId, expectedStatus: HttpStatusCode.CONFLICT_409, contentLength: 1000 })
+        await checkFileSize(uploadId, 1000)
+      } else {
+        await sendChunks({ pathUploadId: uploadId, expectedStatus: HttpStatusCode.BAD_REQUEST_400, contentLength: 1000 })
+        await checkFileSize(uploadId, 0)
+      }
     })
 
     it('Should not accept more chunks than expected with an invalid content length', async function () {
@@ -179,8 +170,13 @@ describe('Test resumable upload', function () {
 
       const size = 1000
 
-      const contentRangeBuilder = start => `bytes ${start}-${start + size - 1}/${size}`
-      await sendChunks({ pathUploadId: uploadId, expectedStatus: HttpStatusCode.BAD_REQUEST_400, contentRangeBuilder, contentLength: size })
+      // Content length check seems to have changed in v16
+      const expectedStatus = process.version.startsWith('v16')
+        ? HttpStatusCode.CONFLICT_409
+        : HttpStatusCode.BAD_REQUEST_400
+
+      const contentRangeBuilder = (start: number) => `bytes ${start}-${start + size - 1}/${size}`
+      await sendChunks({ pathUploadId: uploadId, expectedStatus, contentRangeBuilder, contentLength: size })
       await checkFileSize(uploadId, 0)
     })
   })
diff --git a/server/tests/api/videos/single-server.ts b/server/tests/api/videos/single-server.ts
index 1058a1e9c..29dac6ec1 100644
--- a/server/tests/api/videos/single-server.ts
+++ b/server/tests/api/videos/single-server.ts
@@ -2,43 +2,26 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { keyBy } from 'lodash'
-
 import {
   checkVideoFilesWereRemoved,
   cleanupTests,
   completeVideoCheck,
-  flushAndRunServer,
-  getVideo,
-  getVideoCategories,
-  getVideoLanguages,
-  getVideoLicences,
-  getVideoPrivacies,
-  getVideosList,
-  getVideosListPagination,
-  getVideosListSort,
-  getVideosWithFilters,
-  rateVideo,
-  removeVideo,
-  ServerInfo,
+  createSingleServer,
+  PeerTubeServer,
   setAccessTokensToServers,
   testImage,
-  updateVideo,
-  uploadVideo,
-  viewVideo,
   wait
-} from '../../../../shared/extra-utils'
-import { VideoPrivacy } from '../../../../shared/models/videos'
-import { HttpStatusCode } from '@shared/core-utils'
+} from '@shared/extra-utils'
+import { Video, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test a single server', function () {
 
   function runSuite (mode: 'legacy' | 'resumable') {
-    let server: ServerInfo = null
-    let videoId = -1
-    let videoId2 = -1
+    let server: PeerTubeServer = null
+    let videoId: number | string
+    let videoId2: string
     let videoUUID = ''
     let videosListBase: any[] = null
 
@@ -111,134 +94,123 @@ describe('Test a single server', function () {
     before(async function () {
       this.timeout(30000)
 
-      server = await flushAndRunServer(1)
+      server = await createSingleServer(1)
 
       await setAccessTokensToServers([ server ])
     })
 
     it('Should list video categories', async function () {
-      const res = await getVideoCategories(server.url)
-
-      const categories = res.body
+      const categories = await server.videos.getCategories()
       expect(Object.keys(categories)).to.have.length.above(10)
 
       expect(categories[11]).to.equal('News & Politics')
     })
 
     it('Should list video licences', async function () {
-      const res = await getVideoLicences(server.url)
-
-      const licences = res.body
+      const licences = await server.videos.getLicences()
       expect(Object.keys(licences)).to.have.length.above(5)
 
       expect(licences[3]).to.equal('Attribution - No Derivatives')
     })
 
     it('Should list video languages', async function () {
-      const res = await getVideoLanguages(server.url)
-
-      const languages = res.body
+      const languages = await server.videos.getLanguages()
       expect(Object.keys(languages)).to.have.length.above(5)
 
       expect(languages['ru']).to.equal('Russian')
     })
 
     it('Should list video privacies', async function () {
-      const res = await getVideoPrivacies(server.url)
-
-      const privacies = res.body
+      const privacies = await server.videos.getPrivacies()
       expect(Object.keys(privacies)).to.have.length.at.least(3)
 
       expect(privacies[3]).to.equal('Private')
     })
 
     it('Should not have videos', async function () {
-      const res = await getVideosList(server.url)
+      const { data, total } = await server.videos.list()
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data.length).to.equal(0)
+      expect(total).to.equal(0)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(0)
     })
 
     it('Should upload the video', async function () {
       this.timeout(10000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name',
         category: 2,
         nsfw: true,
         licence: 6,
         tags: [ 'tag1', 'tag2', 'tag3' ]
       }
-      const res = await uploadVideo(server.url, server.accessToken, videoAttributes, HttpStatusCode.OK_200, mode)
-      expect(res.body.video).to.not.be.undefined
-      expect(res.body.video.id).to.equal(1)
-      expect(res.body.video.uuid).to.have.length.above(5)
+      const video = await server.videos.upload({ attributes, mode })
+      expect(video).to.not.be.undefined
+      expect(video.id).to.equal(1)
+      expect(video.uuid).to.have.length.above(5)
 
-      videoId = res.body.video.id
-      videoUUID = res.body.video.uuid
+      videoId = video.id
+      videoUUID = video.uuid
     })
 
     it('Should get and seed the uploaded video', async function () {
       this.timeout(5000)
 
-      const res = await getVideosList(server.url)
+      const { data, total } = await server.videos.list()
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data.length).to.equal(1)
+      expect(total).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data.length).to.equal(1)
 
-      const video = res.body.data[0]
-      await completeVideoCheck(server.url, video, getCheckAttributes())
+      const video = data[0]
+      await completeVideoCheck(server, video, getCheckAttributes())
     })
 
     it('Should get the video by UUID', async function () {
       this.timeout(5000)
 
-      const res = await getVideo(server.url, videoUUID)
-
-      const video = res.body
-      await completeVideoCheck(server.url, video, getCheckAttributes())
+      const video = await server.videos.get({ id: videoUUID })
+      await completeVideoCheck(server, video, getCheckAttributes())
     })
 
     it('Should have the views updated', async function () {
       this.timeout(20000)
 
-      await viewVideo(server.url, videoId)
-      await viewVideo(server.url, videoId)
-      await viewVideo(server.url, videoId)
+      await server.videos.view({ id: videoId })
+      await server.videos.view({ id: videoId })
+      await server.videos.view({ id: videoId })
 
       await wait(1500)
 
-      await viewVideo(server.url, videoId)
-      await viewVideo(server.url, videoId)
+      await server.videos.view({ id: videoId })
+      await server.videos.view({ id: videoId })
 
       await wait(1500)
 
-      await viewVideo(server.url, videoId)
-      await viewVideo(server.url, videoId)
+      await server.videos.view({ id: videoId })
+      await server.videos.view({ id: videoId })
 
       // Wait the repeatable job
       await wait(8000)
 
-      const res = await getVideo(server.url, videoId)
-
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
       expect(video.views).to.equal(3)
     })
 
     it('Should remove the video', async function () {
-      await removeVideo(server.url, server.accessToken, videoId)
+      const video = await server.videos.get({ id: videoId })
+      await server.videos.remove({ id: videoId })
 
-      await checkVideoFilesWereRemoved(videoUUID, 1)
+      await checkVideoFilesWereRemoved({ video, server })
     })
 
     it('Should not have videos', async function () {
-      const res = await getVideosList(server.url)
+      const { total, data } = await server.videos.list()
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(total).to.equal(0)
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(0)
     })
 
     it('Should upload 6 videos', async function () {
@@ -250,7 +222,7 @@ describe('Test a single server', function () {
       ])
 
       for (const video of videos) {
-        const videoAttributes = {
+        const attributes = {
           name: video + ' name',
           description: video + ' description',
           category: 2,
@@ -261,19 +233,20 @@ describe('Test a single server', function () {
           fixture: video
         }
 
-        await uploadVideo(server.url, server.accessToken, videoAttributes, HttpStatusCode.OK_200, mode)
+        await server.videos.upload({ attributes, mode })
       }
     })
 
     it('Should have the correct durations', async function () {
-      const res = await getVideosList(server.url)
+      const { total, data } = await server.videos.list()
+
+      expect(total).to.equal(6)
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(6)
 
-      expect(res.body.total).to.equal(6)
-      const videos = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos).to.have.lengthOf(6)
+      const videosByName: { [ name: string ]: Video } = {}
+      data.forEach(v => { videosByName[v.name] = v })
 
-      const videosByName = keyBy<{ duration: number }>(videos, 'name')
       expect(videosByName['video_short.mp4 name'].duration).to.equal(5)
       expect(videosByName['video_short.ogv name'].duration).to.equal(5)
       expect(videosByName['video_short.webm name'].duration).to.equal(5)
@@ -283,96 +256,87 @@ describe('Test a single server', function () {
     })
 
     it('Should have the correct thumbnails', async function () {
-      const res = await getVideosList(server.url)
+      const { data } = await server.videos.list()
 
-      const videos = res.body.data
       // For the next test
-      videosListBase = videos
+      videosListBase = data
 
-      for (const video of videos) {
+      for (const video of data) {
         const videoName = video.name.replace(' name', '')
         await testImage(server.url, videoName, video.thumbnailPath)
       }
     })
 
     it('Should list only the two first videos', async function () {
-      const res = await getVideosListPagination(server.url, 0, 2, 'name')
+      const { total, data } = await server.videos.list({ start: 0, count: 2, sort: 'name' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(2)
-      expect(videos[0].name).to.equal(videosListBase[0].name)
-      expect(videos[1].name).to.equal(videosListBase[1].name)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(2)
+      expect(data[0].name).to.equal(videosListBase[0].name)
+      expect(data[1].name).to.equal(videosListBase[1].name)
     })
 
     it('Should list only the next three videos', async function () {
-      const res = await getVideosListPagination(server.url, 2, 3, 'name')
+      const { total, data } = await server.videos.list({ start: 2, count: 3, sort: 'name' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(3)
-      expect(videos[0].name).to.equal(videosListBase[2].name)
-      expect(videos[1].name).to.equal(videosListBase[3].name)
-      expect(videos[2].name).to.equal(videosListBase[4].name)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(3)
+      expect(data[0].name).to.equal(videosListBase[2].name)
+      expect(data[1].name).to.equal(videosListBase[3].name)
+      expect(data[2].name).to.equal(videosListBase[4].name)
     })
 
     it('Should list the last video', async function () {
-      const res = await getVideosListPagination(server.url, 5, 6, 'name')
+      const { total, data } = await server.videos.list({ start: 5, count: 6, sort: 'name' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(1)
-      expect(videos[0].name).to.equal(videosListBase[5].name)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(1)
+      expect(data[0].name).to.equal(videosListBase[5].name)
     })
 
     it('Should not have the total field', async function () {
-      const res = await getVideosListPagination(server.url, 5, 6, 'name', true)
+      const { total, data } = await server.videos.list({ start: 5, count: 6, sort: 'name', skipCount: true })
 
-      const videos = res.body.data
-      expect(res.body.total).to.not.exist
-      expect(videos.length).to.equal(1)
-      expect(videos[0].name).to.equal(videosListBase[5].name)
+      expect(total).to.not.exist
+      expect(data.length).to.equal(1)
+      expect(data[0].name).to.equal(videosListBase[5].name)
     })
 
     it('Should list and sort by name in descending order', async function () {
-      const res = await getVideosListSort(server.url, '-name')
+      const { total, data } = await server.videos.list({ sort: '-name' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(6)
-      expect(videos[0].name).to.equal('video_short.webm name')
-      expect(videos[1].name).to.equal('video_short.ogv name')
-      expect(videos[2].name).to.equal('video_short.mp4 name')
-      expect(videos[3].name).to.equal('video_short3.webm name')
-      expect(videos[4].name).to.equal('video_short2.webm name')
-      expect(videos[5].name).to.equal('video_short1.webm name')
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(6)
+      expect(data[0].name).to.equal('video_short.webm name')
+      expect(data[1].name).to.equal('video_short.ogv name')
+      expect(data[2].name).to.equal('video_short.mp4 name')
+      expect(data[3].name).to.equal('video_short3.webm name')
+      expect(data[4].name).to.equal('video_short2.webm name')
+      expect(data[5].name).to.equal('video_short1.webm name')
 
-      videoId = videos[3].uuid
-      videoId2 = videos[5].uuid
+      videoId = data[3].uuid
+      videoId2 = data[5].uuid
     })
 
     it('Should list and sort by trending in descending order', async function () {
-      const res = await getVideosListPagination(server.url, 0, 2, '-trending')
+      const { total, data } = await server.videos.list({ start: 0, count: 2, sort: '-trending' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(2)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(2)
     })
 
     it('Should list and sort by hotness in descending order', async function () {
-      const res = await getVideosListPagination(server.url, 0, 2, '-hot')
+      const { total, data } = await server.videos.list({ start: 0, count: 2, sort: '-hot' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(2)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(2)
     })
 
     it('Should list and sort by best in descending order', async function () {
-      const res = await getVideosListPagination(server.url, 0, 2, '-best')
+      const { total, data } = await server.videos.list({ start: 0, count: 2, sort: '-best' })
 
-      const videos = res.body.data
-      expect(res.body.total).to.equal(6)
-      expect(videos.length).to.equal(2)
+      expect(total).to.equal(6)
+      expect(data.length).to.equal(2)
     })
 
     it('Should update a video', async function () {
@@ -387,67 +351,66 @@ describe('Test a single server', function () {
         downloadEnabled: false,
         tags: [ 'tagup1', 'tagup2' ]
       }
-      await updateVideo(server.url, server.accessToken, videoId, attributes)
+      await server.videos.update({ id: videoId, attributes })
     })
 
     it('Should filter by tags and category', async function () {
-      const res1 = await getVideosWithFilters(server.url, { tagsAllOf: [ 'tagup1', 'tagup2' ], categoryOneOf: [ 4 ] })
-      expect(res1.body.total).to.equal(1)
-      expect(res1.body.data[0].name).to.equal('my super video updated')
+      {
+        const { data, total } = await server.videos.list({ tagsAllOf: [ 'tagup1', 'tagup2' ], categoryOneOf: [ 4 ] })
+        expect(total).to.equal(1)
+        expect(data[0].name).to.equal('my super video updated')
+      }
 
-      const res2 = await getVideosWithFilters(server.url, { tagsAllOf: [ 'tagup1', 'tagup2' ], categoryOneOf: [ 3 ] })
-      expect(res2.body.total).to.equal(0)
+      {
+        const { total } = await server.videos.list({ tagsAllOf: [ 'tagup1', 'tagup2' ], categoryOneOf: [ 3 ] })
+        expect(total).to.equal(0)
+      }
     })
 
     it('Should have the video updated', async function () {
       this.timeout(60000)
 
-      const res = await getVideo(server.url, videoId)
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
 
-      await completeVideoCheck(server.url, video, updateCheckAttributes())
+      await completeVideoCheck(server, video, updateCheckAttributes())
     })
 
     it('Should update only the tags of a video', async function () {
       const attributes = {
         tags: [ 'supertag', 'tag1', 'tag2' ]
       }
-      await updateVideo(server.url, server.accessToken, videoId, attributes)
+      await server.videos.update({ id: videoId, attributes })
 
-      const res = await getVideo(server.url, videoId)
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
 
-      await completeVideoCheck(server.url, video, Object.assign(updateCheckAttributes(), attributes))
+      await completeVideoCheck(server, video, Object.assign(updateCheckAttributes(), attributes))
     })
 
     it('Should update only the description of a video', async function () {
       const attributes = {
         description: 'hello everybody'
       }
-      await updateVideo(server.url, server.accessToken, videoId, attributes)
+      await server.videos.update({ id: videoId, attributes })
 
-      const res = await getVideo(server.url, videoId)
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
 
       const expectedAttributes = Object.assign(updateCheckAttributes(), { tags: [ 'supertag', 'tag1', 'tag2' ] }, attributes)
-      await completeVideoCheck(server.url, video, expectedAttributes)
+      await completeVideoCheck(server, video, expectedAttributes)
     })
 
     it('Should like a video', async function () {
-      await rateVideo(server.url, server.accessToken, videoId, 'like')
+      await server.videos.rate({ id: videoId, rating: 'like' })
 
-      const res = await getVideo(server.url, videoId)
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
 
       expect(video.likes).to.equal(1)
       expect(video.dislikes).to.equal(0)
     })
 
     it('Should dislike the same video', async function () {
-      await rateVideo(server.url, server.accessToken, videoId, 'dislike')
+      await server.videos.rate({ id: videoId, rating: 'dislike' })
 
-      const res = await getVideo(server.url, videoId)
-      const video = res.body
+      const video = await server.videos.get({ id: videoId })
 
       expect(video.likes).to.equal(0)
       expect(video.dislikes).to.equal(1)
@@ -457,10 +420,10 @@ describe('Test a single server', function () {
       {
         const now = new Date()
         const attributes = { originallyPublishedAt: now.toISOString() }
-        await updateVideo(server.url, server.accessToken, videoId, attributes)
+        await server.videos.update({ id: videoId, attributes })
 
-        const res = await getVideosListSort(server.url, '-originallyPublishedAt')
-        const names = res.body.data.map(v => v.name)
+        const { data } = await server.videos.list({ sort: '-originallyPublishedAt' })
+        const names = data.map(v => v.name)
 
         expect(names[0]).to.equal('my super video updated')
         expect(names[1]).to.equal('video_short2.webm name')
@@ -473,10 +436,10 @@ describe('Test a single server', function () {
       {
         const now = new Date()
         const attributes = { originallyPublishedAt: now.toISOString() }
-        await updateVideo(server.url, server.accessToken, videoId2, attributes)
+        await server.videos.update({ id: videoId2, attributes })
 
-        const res = await getVideosListSort(server.url, '-originallyPublishedAt')
-        const names = res.body.data.map(v => v.name)
+        const { data } = await server.videos.list({ sort: '-originallyPublishedAt' })
+        const names = data.map(v => v.name)
 
         expect(names[0]).to.equal('video_short1.webm name')
         expect(names[1]).to.equal('my super video updated')
diff --git a/server/tests/api/videos/video-captions.ts b/server/tests/api/videos/video-captions.ts
index 14ecedfa6..3bb0d131c 100644
--- a/server/tests/api/videos/video-captions.ts
+++ b/server/tests/api/videos/video-captions.ts
@@ -1,72 +1,61 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
   checkVideoFilesWereRemoved,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  removeVideo,
-  uploadVideo,
-  wait
-} from '../../../../shared/extra-utils'
-import { ServerInfo, setAccessTokensToServers } from '../../../../shared/extra-utils/index'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  createVideoCaption,
-  deleteVideoCaption,
-  listVideoCaptions,
-  testCaptionFile
-} from '../../../../shared/extra-utils/videos/video-captions'
-import { VideoCaption } from '../../../../shared/models/videos/caption/video-caption.model'
+  PeerTubeServer,
+  setAccessTokensToServers,
+  testCaptionFile,
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test video captions', function () {
   const uuidRegex = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
 
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let videoUUID: string
 
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
     await doubleFollow(servers[0], servers[1])
 
     await waitJobs(servers)
 
-    const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'my video name' })
-    videoUUID = res.body.video.uuid
+    const { uuid } = await servers[0].videos.upload({ attributes: { name: 'my video name' } })
+    videoUUID = uuid
 
     await waitJobs(servers)
   })
 
   it('Should list the captions and return an empty list', async function () {
     for (const server of servers) {
-      const res = await listVideoCaptions(server.url, videoUUID)
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
+      const body = await server.captions.list({ videoId: videoUUID })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
     }
   })
 
   it('Should create two new captions', async function () {
     this.timeout(30000)
 
-    await createVideoCaption({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].captions.add({
       language: 'ar',
       videoId: videoUUID,
       fixture: 'subtitle-good1.vtt'
     })
 
-    await createVideoCaption({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].captions.add({
       language: 'zh',
       videoId: videoUUID,
       fixture: 'subtitle-good2.vtt',
@@ -78,17 +67,17 @@ describe('Test video captions', function () {
 
   it('Should list these uploaded captions', async function () {
     for (const server of servers) {
-      const res = await listVideoCaptions(server.url, videoUUID)
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      const body = await server.captions.list({ videoId: videoUUID })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      const caption1: VideoCaption = res.body.data[0]
+      const caption1 = body.data[0]
       expect(caption1.language.id).to.equal('ar')
       expect(caption1.language.label).to.equal('Arabic')
       expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/' + uuidRegex + '-ar.vtt$'))
       await testCaptionFile(server.url, caption1.captionPath, 'Subtitle good 1.')
 
-      const caption2: VideoCaption = res.body.data[1]
+      const caption2 = body.data[1]
       expect(caption2.language.id).to.equal('zh')
       expect(caption2.language.label).to.equal('Chinese')
       expect(caption2.captionPath).to.match(new RegExp('^/lazy-static/video-captions/' + uuidRegex + '-zh.vtt$'))
@@ -99,9 +88,7 @@ describe('Test video captions', function () {
   it('Should replace an existing caption', async function () {
     this.timeout(30000)
 
-    await createVideoCaption({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].captions.add({
       language: 'ar',
       videoId: videoUUID,
       fixture: 'subtitle-good2.vtt'
@@ -112,11 +99,11 @@ describe('Test video captions', function () {
 
   it('Should have this caption updated', async function () {
     for (const server of servers) {
-      const res = await listVideoCaptions(server.url, videoUUID)
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      const body = await server.captions.list({ videoId: videoUUID })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      const caption1: VideoCaption = res.body.data[0]
+      const caption1 = body.data[0]
       expect(caption1.language.id).to.equal('ar')
       expect(caption1.language.label).to.equal('Arabic')
       expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/' + uuidRegex + '-ar.vtt$'))
@@ -127,9 +114,7 @@ describe('Test video captions', function () {
   it('Should replace an existing caption with a srt file and convert it', async function () {
     this.timeout(30000)
 
-    await createVideoCaption({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].captions.add({
       language: 'ar',
       videoId: videoUUID,
       fixture: 'subtitle-good.srt'
@@ -143,11 +128,11 @@ describe('Test video captions', function () {
 
   it('Should have this caption updated and converted', async function () {
     for (const server of servers) {
-      const res = await listVideoCaptions(server.url, videoUUID)
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      const body = await server.captions.list({ videoId: videoUUID })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
 
-      const caption1: VideoCaption = res.body.data[0]
+      const caption1 = body.data[0]
       expect(caption1.language.id).to.equal('ar')
       expect(caption1.language.label).to.equal('Arabic')
       expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/' + uuidRegex + '-ar.vtt$'))
@@ -172,18 +157,18 @@ describe('Test video captions', function () {
   it('Should remove one caption', async function () {
     this.timeout(30000)
 
-    await deleteVideoCaption(servers[0].url, servers[0].accessToken, videoUUID, 'ar')
+    await servers[0].captions.delete({ videoId: videoUUID, language: 'ar' })
 
     await waitJobs(servers)
   })
 
   it('Should only list the caption that was not deleted', async function () {
     for (const server of servers) {
-      const res = await listVideoCaptions(server.url, videoUUID)
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      const body = await server.captions.list({ videoId: videoUUID })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
 
-      const caption: VideoCaption = res.body.data[0]
+      const caption = body.data[0]
 
       expect(caption.language.id).to.equal('zh')
       expect(caption.language.label).to.equal('Chinese')
@@ -193,9 +178,12 @@ describe('Test video captions', function () {
   })
 
   it('Should remove the video, and thus all video captions', async function () {
-    await removeVideo(servers[0].url, servers[0].accessToken, videoUUID)
+    const video = await servers[0].videos.get({ id: videoUUID })
+    const { data: captions } = await servers[0].captions.list({ videoId: videoUUID })
+
+    await servers[0].videos.remove({ id: videoUUID })
 
-    await checkVideoFilesWereRemoved(videoUUID, 1)
+    await checkVideoFilesWereRemoved({ server: servers[0], video, captions })
   })
 
   after(async function () {
diff --git a/server/tests/api/videos/video-change-ownership.ts b/server/tests/api/videos/video-change-ownership.ts
index a3384851b..d6665fe4e 100644
--- a/server/tests/api/videos/video-change-ownership.ts
+++ b/server/tests/api/videos/video-change-ownership.ts
@@ -2,234 +2,212 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  acceptChangeOwnership,
-  changeVideoOwnership,
+  ChangeOwnershipCommand,
   cleanupTests,
-  createLive,
-  createUser,
+  createMultipleServers,
+  createSingleServer,
   doubleFollow,
-  flushAndRunMultipleServers,
-  flushAndRunServer,
-  getMyUserInformation,
-  getVideo,
-  getVideoChangeOwnershipList,
-  getVideosList,
-  refuseChangeOwnership,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
-  updateCustomSubConfig,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { User } from '../../../../shared/models/users'
-import { VideoDetails, VideoPrivacy } from '../../../../shared/models/videos'
+  waitJobs
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test video change ownership - nominal', function () {
-  let servers: ServerInfo[] = []
-  const firstUser = {
-    username: 'first',
-    password: 'My great password'
-  }
-  const secondUser = {
-    username: 'second',
-    password: 'My other password'
-  }
-
-  let firstUserAccessToken = ''
+  let servers: PeerTubeServer[] = []
+
+  const firstUser = 'first'
+  const secondUser = 'second'
+
+  let firstUserToken = ''
   let firstUserChannelId: number
 
-  let secondUserAccessToken = ''
+  let secondUserToken = ''
   let secondUserChannelId: number
 
-  let lastRequestChangeOwnershipId = ''
+  let lastRequestId: number
 
   let liveId: number
 
+  let command: ChangeOwnershipCommand
+
   before(async function () {
     this.timeout(50000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      transcoding: {
-        enabled: false
-      },
-      live: {
-        enabled: true
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        transcoding: {
+          enabled: false
+        },
+        live: {
+          enabled: true
+        }
       }
     })
 
-    const videoQuota = 42000000
-    await createUser({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      username: firstUser.username,
-      password: firstUser.password,
-      videoQuota: videoQuota
-    })
-    await createUser({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      username: secondUser.username,
-      password: secondUser.password,
-      videoQuota: videoQuota
-    })
-
-    firstUserAccessToken = await userLogin(servers[0], firstUser)
-    secondUserAccessToken = await userLogin(servers[0], secondUser)
+    firstUserToken = await servers[0].users.generateUserAndToken(firstUser)
+    secondUserToken = await servers[0].users.generateUserAndToken(secondUser)
 
     {
-      const res = await getMyUserInformation(servers[0].url, firstUserAccessToken)
-      const firstUserInformation: User = res.body
-      firstUserChannelId = firstUserInformation.videoChannels[0].id
+      const { videoChannels } = await servers[0].users.getMyInfo({ token: firstUserToken })
+      firstUserChannelId = videoChannels[0].id
     }
 
     {
-      const res = await getMyUserInformation(servers[0].url, secondUserAccessToken)
-      const secondUserInformation: User = res.body
-      secondUserChannelId = secondUserInformation.videoChannels[0].id
+      const { videoChannels } = await servers[0].users.getMyInfo({ token: secondUserToken })
+      secondUserChannelId = videoChannels[0].id
     }
 
     {
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name',
         description: 'my super description'
       }
-      const res = await uploadVideo(servers[0].url, firstUserAccessToken, videoAttributes)
+      const { id } = await servers[0].videos.upload({ token: firstUserToken, attributes })
 
-      const resVideo = await getVideo(servers[0].url, res.body.video.id)
-      servers[0].video = resVideo.body
+      servers[0].store.videoCreated = await servers[0].videos.get({ id })
     }
 
     {
       const attributes = { name: 'live', channelId: firstUserChannelId, privacy: VideoPrivacy.PUBLIC }
-      const res = await createLive(servers[0].url, firstUserAccessToken, attributes)
+      const video = await servers[0].live.create({ token: firstUserToken, fields: attributes })
 
-      liveId = res.body.video.id
+      liveId = video.id
     }
 
+    command = servers[0].changeOwnership
+
     await doubleFollow(servers[0], servers[1])
   })
 
   it('Should not have video change ownership', async function () {
-    const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken)
+    {
+      const body = await command.list({ token: firstUserToken })
 
-    expect(resFirstUser.body.total).to.equal(0)
-    expect(resFirstUser.body.data).to.be.an('array')
-    expect(resFirstUser.body.data.length).to.equal(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data.length).to.equal(0)
+    }
 
-    const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
+    {
+      const body = await command.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(0)
-    expect(resSecondUser.body.data).to.be.an('array')
-    expect(resSecondUser.body.data.length).to.equal(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data.length).to.equal(0)
+    }
   })
 
   it('Should send a request to change ownership of a video', async function () {
     this.timeout(15000)
 
-    await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username)
+    await command.create({ token: firstUserToken, videoId: servers[0].store.videoCreated.id, username: secondUser })
   })
 
   it('Should only return a request to change ownership for the second user', async function () {
-    const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken)
+    {
+      const body = await command.list({ token: firstUserToken })
 
-    expect(resFirstUser.body.total).to.equal(0)
-    expect(resFirstUser.body.data).to.be.an('array')
-    expect(resFirstUser.body.data.length).to.equal(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data.length).to.equal(0)
+    }
 
-    const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
+    {
+      const body = await command.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(1)
-    expect(resSecondUser.body.data).to.be.an('array')
-    expect(resSecondUser.body.data.length).to.equal(1)
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data.length).to.equal(1)
 
-    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
+      lastRequestId = body.data[0].id
+    }
   })
 
   it('Should accept the same change ownership request without crashing', async function () {
     this.timeout(10000)
 
-    await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username)
+    await command.create({ token: firstUserToken, videoId: servers[0].store.videoCreated.id, username: secondUser })
   })
 
   it('Should not create multiple change ownership requests while one is waiting', async function () {
     this.timeout(10000)
 
-    const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
+    const body = await command.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(1)
-    expect(resSecondUser.body.data).to.be.an('array')
-    expect(resSecondUser.body.data.length).to.equal(1)
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data.length).to.equal(1)
   })
 
   it('Should not be possible to refuse the change of ownership from first user', async function () {
     this.timeout(10000)
 
-    await refuseChangeOwnership(servers[0].url, firstUserAccessToken, lastRequestChangeOwnershipId, HttpStatusCode.FORBIDDEN_403)
+    await command.refuse({ token: firstUserToken, ownershipId: lastRequestId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should be possible to refuse the change of ownership from second user', async function () {
     this.timeout(10000)
 
-    await refuseChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId)
+    await command.refuse({ token: secondUserToken, ownershipId: lastRequestId })
   })
 
   it('Should send a new request to change ownership of a video', async function () {
     this.timeout(15000)
 
-    await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username)
+    await command.create({ token: firstUserToken, videoId: servers[0].store.videoCreated.id, username: secondUser })
   })
 
   it('Should return two requests to change ownership for the second user', async function () {
-    const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken)
+    {
+      const body = await command.list({ token: firstUserToken })
 
-    expect(resFirstUser.body.total).to.equal(0)
-    expect(resFirstUser.body.data).to.be.an('array')
-    expect(resFirstUser.body.data.length).to.equal(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data.length).to.equal(0)
+    }
 
-    const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
+    {
+      const body = await command.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(2)
-    expect(resSecondUser.body.data).to.be.an('array')
-    expect(resSecondUser.body.data.length).to.equal(2)
+      expect(body.total).to.equal(2)
+      expect(body.data).to.be.an('array')
+      expect(body.data.length).to.equal(2)
 
-    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
+      lastRequestId = body.data[0].id
+    }
   })
 
   it('Should not be possible to accept the change of ownership from first user', async function () {
     this.timeout(10000)
 
-    await acceptChangeOwnership(
-      servers[0].url,
-      firstUserAccessToken,
-      lastRequestChangeOwnershipId,
-      secondUserChannelId,
-      HttpStatusCode.FORBIDDEN_403
-    )
+    await command.accept({
+      token: firstUserToken,
+      ownershipId: lastRequestId,
+      channelId: secondUserChannelId,
+      expectedStatus: HttpStatusCode.FORBIDDEN_403
+    })
   })
 
   it('Should be possible to accept the change of ownership from second user', async function () {
     this.timeout(10000)
 
-    await acceptChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId, secondUserChannelId)
+    await command.accept({ token: secondUserToken, ownershipId: lastRequestId, channelId: secondUserChannelId })
 
     await waitJobs(servers)
   })
 
   it('Should have the channel of the video updated', async function () {
     for (const server of servers) {
-      const res = await getVideo(server.url, servers[0].video.uuid)
-
-      const video: VideoDetails = res.body
+      const video = await server.videos.get({ id: servers[0].store.videoCreated.uuid })
 
       expect(video.name).to.equal('my super name')
       expect(video.channel.displayName).to.equal('Main second channel')
@@ -240,27 +218,25 @@ describe('Test video change ownership - nominal', function () {
   it('Should send a request to change ownership of a live', async function () {
     this.timeout(15000)
 
-    await changeVideoOwnership(servers[0].url, firstUserAccessToken, liveId, secondUser.username)
+    await command.create({ token: firstUserToken, videoId: liveId, username: secondUser })
 
-    const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
+    const body = await command.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(3)
-    expect(resSecondUser.body.data.length).to.equal(3)
+    expect(body.total).to.equal(3)
+    expect(body.data.length).to.equal(3)
 
-    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
+    lastRequestId = body.data[0].id
   })
 
   it('Should accept a live ownership change', async function () {
     this.timeout(20000)
 
-    await acceptChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId, secondUserChannelId)
+    await command.accept({ token: secondUserToken, ownershipId: lastRequestId, channelId: secondUserChannelId })
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, servers[0].video.uuid)
-
-      const video: VideoDetails = res.body
+      const video = await server.videos.get({ id: servers[0].store.videoCreated.uuid })
 
       expect(video.name).to.equal('my super name')
       expect(video.channel.displayName).to.equal('Main second channel')
@@ -274,99 +250,79 @@ describe('Test video change ownership - nominal', function () {
 })
 
 describe('Test video change ownership - quota too small', function () {
-  let server: ServerInfo
-  const firstUser = {
-    username: 'first',
-    password: 'My great password'
-  }
-  const secondUser = {
-    username: 'second',
-    password: 'My other password'
-  }
-  let firstUserAccessToken = ''
-  let secondUserAccessToken = ''
-  let lastRequestChangeOwnershipId = ''
+  let server: PeerTubeServer
+  const firstUser = 'first'
+  const secondUser = 'second'
+
+  let firstUserToken = ''
+  let secondUserToken = ''
+  let lastRequestId: number
 
   before(async function () {
     this.timeout(50000)
 
     // Run one server
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
-    const videoQuota = 42000000
-    const limitedVideoQuota = 10
-    await createUser({
-      url: server.url,
-      accessToken: server.accessToken,
-      username: firstUser.username,
-      password: firstUser.password,
-      videoQuota: videoQuota
-    })
-    await createUser({
-      url: server.url,
-      accessToken: server.accessToken,
-      username: secondUser.username,
-      password: secondUser.password,
-      videoQuota: limitedVideoQuota
-    })
+    await server.users.create({ username: secondUser, videoQuota: 10 })
 
-    firstUserAccessToken = await userLogin(server, firstUser)
-    secondUserAccessToken = await userLogin(server, secondUser)
+    firstUserToken = await server.users.generateUserAndToken(firstUser)
+    secondUserToken = await server.login.getAccessToken(secondUser)
 
     // Upload some videos on the server
-    const video1Attributes = {
+    const attributes = {
       name: 'my super name',
       description: 'my super description'
     }
-    await uploadVideo(server.url, firstUserAccessToken, video1Attributes)
+    await server.videos.upload({ token: firstUserToken, attributes })
 
     await waitJobs(server)
 
-    const res = await getVideosList(server.url)
-    const videos = res.body.data
-
-    expect(videos.length).to.equal(1)
+    const { data } = await server.videos.list()
+    expect(data.length).to.equal(1)
 
-    server.video = videos.find(video => video.name === 'my super name')
+    server.store.videoCreated = data.find(video => video.name === 'my super name')
   })
 
   it('Should send a request to change ownership of a video', async function () {
     this.timeout(15000)
 
-    await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
+    await server.changeOwnership.create({ token: firstUserToken, videoId: server.store.videoCreated.id, username: secondUser })
   })
 
   it('Should only return a request to change ownership for the second user', async function () {
-    const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)
+    {
+      const body = await server.changeOwnership.list({ token: firstUserToken })
 
-    expect(resFirstUser.body.total).to.equal(0)
-    expect(resFirstUser.body.data).to.be.an('array')
-    expect(resFirstUser.body.data.length).to.equal(0)
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data.length).to.equal(0)
+    }
 
-    const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)
+    {
+      const body = await server.changeOwnership.list({ token: secondUserToken })
 
-    expect(resSecondUser.body.total).to.equal(1)
-    expect(resSecondUser.body.data).to.be.an('array')
-    expect(resSecondUser.body.data.length).to.equal(1)
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data.length).to.equal(1)
 
-    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
+      lastRequestId = body.data[0].id
+    }
   })
 
   it('Should not be possible to accept the change of ownership from second user because of exceeded quota', async function () {
     this.timeout(10000)
 
-    const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserAccessToken)
-    const secondUserInformation: User = secondUserInformationResponse.body
-    const channelId = secondUserInformation.videoChannels[0].id
+    const { videoChannels } = await server.users.getMyInfo({ token: secondUserToken })
+    const channelId = videoChannels[0].id
 
-    await acceptChangeOwnership(
-      server.url,
-      secondUserAccessToken,
-      lastRequestChangeOwnershipId,
+    await server.changeOwnership.accept({
+      token: secondUserToken,
+      ownershipId: lastRequestId,
       channelId,
-      HttpStatusCode.PAYLOAD_TOO_LARGE_413
-    )
+      expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413
+    })
   })
 
   after(async function () {
diff --git a/server/tests/api/videos/video-channels.ts b/server/tests/api/videos/video-channels.ts
index 865098777..c25754eb6 100644
--- a/server/tests/api/videos/video-channels.ts
+++ b/server/tests/api/videos/video-channels.ts
@@ -6,48 +6,28 @@ import { basename } from 'path'
 import { ACTOR_IMAGES_SIZE } from '@server/initializers/constants'
 import {
   cleanupTests,
-  createUser,
-  deleteVideoChannelImage,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getActorImage,
-  getVideo,
-  getVideoChannel,
-  getVideoChannelVideos,
+  PeerTubeServer,
+  setAccessTokensToServers,
   setDefaultVideoChannel,
   testFileExistsOrNot,
   testImage,
-  updateVideo,
-  updateVideoChannelImage,
-  uploadVideo,
-  userLogin,
-  wait
-} from '../../../../shared/extra-utils'
-import {
-  addVideoChannel,
-  deleteVideoChannel,
-  getAccountVideoChannelsList,
-  getMyUserInformation,
-  getVideoChannelsList,
-  ServerInfo,
-  setAccessTokensToServers,
-  updateVideoChannel,
-  viewVideo
-} from '../../../../shared/extra-utils/index'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { User, Video, VideoChannel, VideoDetails } from '../../../../shared/index'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { User, VideoChannel } from '@shared/models'
 
 const expect = chai.expect
 
-async function findChannel (server: ServerInfo, channelId: number) {
-  const res = await getVideoChannelsList(server.url, 0, 5, '-name')
-  const videoChannel = res.body.data.find(c => c.id === channelId)
+async function findChannel (server: PeerTubeServer, channelId: number) {
+  const body = await server.channels.list({ sort: '-name' })
 
-  return videoChannel as VideoChannel
+  return body.data.find(c => c.id === channelId)
 }
 
 describe('Test video channels', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let userInfo: User
   let secondVideoChannelId: number
   let totoChannel: number
@@ -60,7 +40,7 @@ describe('Test video channels', function () {
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
@@ -69,11 +49,11 @@ describe('Test video channels', function () {
   })
 
   it('Should have one video channel (created with root)', async () => {
-    const res = await getVideoChannelsList(servers[0].url, 0, 2)
+    const body = await servers[0].channels.list({ start: 0, count: 2 })
 
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
   })
 
   it('Should create another video channel', async function () {
@@ -86,23 +66,22 @@ describe('Test video channels', function () {
         description: 'super video channel description',
         support: 'super video channel support text'
       }
-      const res = await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
-      secondVideoChannelId = res.body.videoChannel.id
+      const created = await servers[0].channels.create({ attributes: videoChannel })
+      secondVideoChannelId = created.id
     }
 
     // The channel is 1 is propagated to servers 2
     {
-      const videoAttributesArg = { name: 'my video name', channelId: secondVideoChannelId, support: 'video support field' }
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributesArg)
-      videoUUID = res.body.video.uuid
+      const attributes = { name: 'my video name', channelId: secondVideoChannelId, support: 'video support field' }
+      const { uuid } = await servers[0].videos.upload({ attributes })
+      videoUUID = uuid
     }
 
     await waitJobs(servers)
   })
 
   it('Should have two video channels when getting my information', async () => {
-    const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
-    userInfo = res.body
+    userInfo = await servers[0].users.getMyInfo()
 
     expect(userInfo.videoChannels).to.be.an('array')
     expect(userInfo.videoChannels).to.have.lengthOf(2)
@@ -120,16 +99,14 @@ describe('Test video channels', function () {
   })
 
   it('Should have two video channels when getting account channels on server 1', async function () {
-    const res = await getAccountVideoChannelsList({
-      url: servers[0].url,
-      accountName
-    })
+    const body = await servers[0].channels.listByAccount({ accountName })
+    expect(body.total).to.equal(2)
+
+    const videoChannels = body.data
 
-    expect(res.body.total).to.equal(2)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(2)
+    expect(videoChannels).to.be.an('array')
+    expect(videoChannels).to.have.lengthOf(2)
 
-    const videoChannels = res.body.data
     expect(videoChannels[0].name).to.equal('root_channel')
     expect(videoChannels[0].displayName).to.equal('Main root channel')
 
@@ -141,79 +118,69 @@ describe('Test video channels', function () {
 
   it('Should paginate and sort account channels', async function () {
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
+      const body = await servers[0].channels.listByAccount({
         accountName,
         start: 0,
         count: 1,
         sort: 'createdAt'
       })
 
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(1)
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(1)
 
-      const videoChannel: VideoChannel = res.body.data[0]
+      const videoChannel: VideoChannel = body.data[0]
       expect(videoChannel.name).to.equal('root_channel')
     }
 
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
+      const body = await servers[0].channels.listByAccount({
         accountName,
         start: 0,
         count: 1,
         sort: '-createdAt'
       })
 
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(1)
-
-      const videoChannel: VideoChannel = res.body.data[0]
-      expect(videoChannel.name).to.equal('second_video_channel')
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('second_video_channel')
     }
 
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
+      const body = await servers[0].channels.listByAccount({
         accountName,
         start: 1,
         count: 1,
         sort: '-createdAt'
       })
 
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(1)
-
-      const videoChannel: VideoChannel = res.body.data[0]
-      expect(videoChannel.name).to.equal('root_channel')
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('root_channel')
     }
   })
 
   it('Should have one video channel when getting account channels on server 2', async function () {
-    const res = await getAccountVideoChannelsList({
-      url: servers[1].url,
-      accountName
-    })
+    const body = await servers[1].channels.listByAccount({ accountName })
 
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
 
-    const videoChannels = res.body.data
-    expect(videoChannels[0].name).to.equal('second_video_channel')
-    expect(videoChannels[0].displayName).to.equal('second video channel')
-    expect(videoChannels[0].description).to.equal('super video channel description')
-    expect(videoChannels[0].support).to.equal('super video channel support text')
+    const videoChannel = body.data[0]
+    expect(videoChannel.name).to.equal('second_video_channel')
+    expect(videoChannel.displayName).to.equal('second video channel')
+    expect(videoChannel.description).to.equal('super video channel description')
+    expect(videoChannel.support).to.equal('super video channel support text')
   })
 
   it('Should list video channels', async function () {
-    const res = await getVideoChannelsList(servers[0].url, 1, 1, '-name')
+    const body = await servers[0].channels.list({ start: 1, count: 1, sort: '-name' })
 
-    expect(res.body.total).to.equal(2)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
-    expect(res.body.data[0].name).to.equal('root_channel')
-    expect(res.body.data[0].displayName).to.equal('Main root channel')
+    expect(body.total).to.equal(2)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].name).to.equal('root_channel')
+    expect(body.data[0].displayName).to.equal('Main root channel')
   })
 
   it('Should update video channel', async function () {
@@ -225,30 +192,29 @@ describe('Test video channels', function () {
       support: 'support updated'
     }
 
-    await updateVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel', videoChannelAttributes)
+    await servers[0].channels.update({ channelName: 'second_video_channel', attributes: videoChannelAttributes })
 
     await waitJobs(servers)
   })
 
   it('Should have video channel updated', async function () {
     for (const server of servers) {
-      const res = await getVideoChannelsList(server.url, 0, 1, '-name')
-
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
-      expect(res.body.data[0].name).to.equal('second_video_channel')
-      expect(res.body.data[0].displayName).to.equal('video channel updated')
-      expect(res.body.data[0].description).to.equal('video channel description updated')
-      expect(res.body.data[0].support).to.equal('support updated')
+      const body = await server.channels.list({ start: 0, count: 1, sort: '-name' })
+
+      expect(body.total).to.equal(2)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+
+      expect(body.data[0].name).to.equal('second_video_channel')
+      expect(body.data[0].displayName).to.equal('video channel updated')
+      expect(body.data[0].description).to.equal('video channel description updated')
+      expect(body.data[0].support).to.equal('support updated')
     }
   })
 
   it('Should not have updated the video support field', async function () {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = res.body
-
+      const video = await server.videos.get({ id: videoUUID })
       expect(video.support).to.equal('video support field')
     }
   })
@@ -261,14 +227,12 @@ describe('Test video channels', function () {
       bulkVideosSupportUpdate: true
     }
 
-    await updateVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel', videoChannelAttributes)
+    await servers[0].channels.update({ channelName: 'second_video_channel', attributes: videoChannelAttributes })
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = res.body
-
+      const video = await server.videos.get({ id: videoUUID })
       expect(video.support).to.equal(videoChannelAttributes.support)
     }
   })
@@ -278,10 +242,8 @@ describe('Test video channels', function () {
 
     const fixture = 'avatar.png'
 
-    await updateVideoChannelImage({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      videoChannelName: 'second_video_channel',
+    await servers[0].channels.updateImage({
+      channelName: 'second_video_channel',
       fixture,
       type: 'avatar'
     })
@@ -295,7 +257,7 @@ describe('Test video channels', function () {
       await testImage(server.url, 'avatar-resized', avatarPaths[server.port], '.png')
       await testFileExistsOrNot(server, 'avatars', basename(avatarPaths[server.port]), true)
 
-      const row = await getActorImage(server.internalServerNumber, basename(avatarPaths[server.port]))
+      const row = await server.sql.getActorImage(basename(avatarPaths[server.port]))
       expect(row.height).to.equal(ACTOR_IMAGES_SIZE.AVATARS.height)
       expect(row.width).to.equal(ACTOR_IMAGES_SIZE.AVATARS.width)
     }
@@ -306,10 +268,8 @@ describe('Test video channels', function () {
 
     const fixture = 'banner.jpg'
 
-    await updateVideoChannelImage({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      videoChannelName: 'second_video_channel',
+    await servers[0].channels.updateImage({
+      channelName: 'second_video_channel',
       fixture,
       type: 'banner'
     })
@@ -317,14 +277,13 @@ describe('Test video channels', function () {
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideoChannel(server.url, 'second_video_channel@' + servers[0].host)
-      const videoChannel = res.body
+      const videoChannel = await server.channels.get({ channelName: 'second_video_channel@' + servers[0].host })
 
       bannerPaths[server.port] = videoChannel.banner.path
       await testImage(server.url, 'banner-resized', bannerPaths[server.port])
       await testFileExistsOrNot(server, 'avatars', basename(bannerPaths[server.port]), true)
 
-      const row = await getActorImage(server.internalServerNumber, basename(bannerPaths[server.port]))
+      const row = await server.sql.getActorImage(basename(bannerPaths[server.port]))
       expect(row.height).to.equal(ACTOR_IMAGES_SIZE.BANNERS.height)
       expect(row.width).to.equal(ACTOR_IMAGES_SIZE.BANNERS.width)
     }
@@ -333,12 +292,7 @@ describe('Test video channels', function () {
   it('Should delete the video channel avatar', async function () {
     this.timeout(15000)
 
-    await deleteVideoChannelImage({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      videoChannelName: 'second_video_channel',
-      type: 'avatar'
-    })
+    await servers[0].channels.deleteImage({ channelName: 'second_video_channel', type: 'avatar' })
 
     await waitJobs(servers)
 
@@ -353,12 +307,7 @@ describe('Test video channels', function () {
   it('Should delete the video channel banner', async function () {
     this.timeout(15000)
 
-    await deleteVideoChannelImage({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      videoChannelName: 'second_video_channel',
-      type: 'banner'
-    })
+    await servers[0].channels.deleteImage({ channelName: 'second_video_channel', type: 'banner' })
 
     await waitJobs(servers)
 
@@ -375,18 +324,19 @@ describe('Test video channels', function () {
 
     for (const server of servers) {
       const channelURI = 'second_video_channel@localhost:' + servers[0].port
-      const res1 = await getVideoChannelVideos(server.url, server.accessToken, channelURI, 0, 5)
-      expect(res1.body.total).to.equal(1)
-      expect(res1.body.data).to.be.an('array')
-      expect(res1.body.data).to.have.lengthOf(1)
-      expect(res1.body.data[0].name).to.equal('my video name')
+      const { total, data } = await server.videos.listByChannel({ handle: channelURI })
+
+      expect(total).to.equal(1)
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].name).to.equal('my video name')
     }
   })
 
   it('Should change the video channel of a video', async function () {
     this.timeout(10000)
 
-    await updateVideo(servers[0].url, servers[0].accessToken, videoUUID, { channelId: servers[0].videoChannel.id })
+    await servers[0].videos.update({ id: videoUUID, attributes: { channelId: servers[0].store.channel.id } })
 
     await waitJobs(servers)
   })
@@ -395,47 +345,50 @@ describe('Test video channels', function () {
     this.timeout(10000)
 
     for (const server of servers) {
-      const secondChannelURI = 'second_video_channel@localhost:' + servers[0].port
-      const res1 = await getVideoChannelVideos(server.url, server.accessToken, secondChannelURI, 0, 5)
-      expect(res1.body.total).to.equal(0)
-
-      const channelURI = 'root_channel@localhost:' + servers[0].port
-      const res2 = await getVideoChannelVideos(server.url, server.accessToken, channelURI, 0, 5)
-      expect(res2.body.total).to.equal(1)
-
-      const videos: Video[] = res2.body.data
-      expect(videos).to.be.an('array')
-      expect(videos).to.have.lengthOf(1)
-      expect(videos[0].name).to.equal('my video name')
+      {
+        const secondChannelURI = 'second_video_channel@localhost:' + servers[0].port
+        const { total } = await server.videos.listByChannel({ handle: secondChannelURI })
+        expect(total).to.equal(0)
+      }
+
+      {
+        const channelURI = 'root_channel@localhost:' + servers[0].port
+        const { total, data } = await server.videos.listByChannel({ handle: channelURI })
+        expect(total).to.equal(1)
+
+        expect(data).to.be.an('array')
+        expect(data).to.have.lengthOf(1)
+        expect(data[0].name).to.equal('my video name')
+      }
     }
   })
 
   it('Should delete video channel', async function () {
-    await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel')
+    await servers[0].channels.delete({ channelName: 'second_video_channel' })
   })
 
   it('Should have video channel deleted', async function () {
-    const res = await getVideoChannelsList(servers[0].url, 0, 10)
+    const body = await servers[0].channels.list({ start: 0, count: 10 })
 
-    expect(res.body.total).to.equal(1)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(1)
-    expect(res.body.data[0].displayName).to.equal('Main root channel')
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].displayName).to.equal('Main root channel')
   })
 
   it('Should create the main channel with an uuid if there is a conflict', async function () {
     {
       const videoChannel = { name: 'toto_channel', displayName: 'My toto channel' }
-      const res = await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
-      totoChannel = res.body.videoChannel.id
+      const created = await servers[0].channels.create({ attributes: videoChannel })
+      totoChannel = created.id
     }
 
     {
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: 'toto', password: 'password' })
-      const accessToken = await userLogin(servers[0], { username: 'toto', password: 'password' })
+      await servers[0].users.create({ username: 'toto', password: 'password' })
+      const accessToken = await servers[0].login.getAccessToken({ username: 'toto', password: 'password' })
 
-      const res = await getMyUserInformation(servers[0].url, accessToken)
-      const videoChannel = res.body.videoChannels[0]
+      const { videoChannels } = await servers[0].users.getMyInfo({ token: accessToken })
+      const videoChannel = videoChannels[0]
       expect(videoChannel.name).to.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/)
     }
   })
@@ -444,15 +397,9 @@ describe('Test video channels', function () {
     this.timeout(10000)
 
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
-        accountName,
-        withStats: true
-      })
-
-      const channels: VideoChannel[] = res.body.data
+      const { data } = await servers[0].channels.listByAccount({ accountName, withStats: true })
 
-      for (const channel of channels) {
+      for (const channel of data) {
         expect(channel).to.haveOwnProperty('viewsPerDay')
         expect(channel.viewsPerDay).to.have.length(30 + 1) // daysPrior + today
 
@@ -464,33 +411,24 @@ describe('Test video channels', function () {
     }
 
     {
-      // video has been posted on channel servers[0].videoChannel.id since last update
-      await viewVideo(servers[0].url, videoUUID, 204, '0.0.0.1,127.0.0.1')
-      await viewVideo(servers[0].url, videoUUID, 204, '0.0.0.2,127.0.0.1')
+      // video has been posted on channel servers[0].store.videoChannel.id since last update
+      await servers[0].videos.view({ id: videoUUID, xForwardedFor: '0.0.0.1,127.0.0.1' })
+      await servers[0].videos.view({ id: videoUUID, xForwardedFor: '0.0.0.2,127.0.0.1' })
 
       // Wait the repeatable job
       await wait(8000)
 
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
-        accountName,
-        withStats: true
-      })
-      const channelWithView = res.body.data.find((channel: VideoChannel) => channel.id === servers[0].videoChannel.id)
+      const { data } = await servers[0].channels.listByAccount({ accountName, withStats: true })
+      const channelWithView = data.find(channel => channel.id === servers[0].store.channel.id)
       expect(channelWithView.viewsPerDay.slice(-1)[0].views).to.equal(2)
     }
   })
 
   it('Should report correct videos count', async function () {
-    const res = await getAccountVideoChannelsList({
-      url: servers[0].url,
-      accountName,
-      withStats: true
-    })
-    const channels: VideoChannel[] = res.body.data
+    const { data } = await servers[0].channels.listByAccount({ accountName, withStats: true })
 
-    const totoChannel = channels.find(c => c.name === 'toto_channel')
-    const rootChannel = channels.find(c => c.name === 'root_channel')
+    const totoChannel = data.find(c => c.name === 'toto_channel')
+    const rootChannel = data.find(c => c.name === 'root_channel')
 
     expect(rootChannel.videosCount).to.equal(1)
     expect(totoChannel.videosCount).to.equal(0)
@@ -498,26 +436,18 @@ describe('Test video channels', function () {
 
   it('Should search among account video channels', async function () {
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
-        accountName,
-        search: 'root'
-      })
-      expect(res.body.total).to.equal(1)
+      const body = await servers[0].channels.listByAccount({ accountName, search: 'root' })
+      expect(body.total).to.equal(1)
 
-      const channels = res.body.data
+      const channels = body.data
       expect(channels).to.have.lengthOf(1)
     }
 
     {
-      const res = await getAccountVideoChannelsList({
-        url: servers[0].url,
-        accountName,
-        search: 'does not exist'
-      })
-      expect(res.body.total).to.equal(0)
+      const body = await servers[0].channels.listByAccount({ accountName, search: 'does not exist' })
+      expect(body.total).to.equal(0)
 
-      const channels = res.body.data
+      const channels = body.data
       expect(channels).to.have.lengthOf(0)
     }
   })
@@ -525,34 +455,24 @@ describe('Test video channels', function () {
   it('Should list channels by updatedAt desc if a video has been uploaded', async function () {
     this.timeout(30000)
 
-    await uploadVideo(servers[0].url, servers[0].accessToken, { channelId: totoChannel })
+    await servers[0].videos.upload({ attributes: { channelId: totoChannel } })
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getAccountVideoChannelsList({
-        url: server.url,
-        accountName,
-        sort: '-updatedAt'
-      })
+      const { data } = await server.channels.listByAccount({ accountName, sort: '-updatedAt' })
 
-      const channels: VideoChannel[] = res.body.data
-      expect(channels[0].name).to.equal('toto_channel')
-      expect(channels[1].name).to.equal('root_channel')
+      expect(data[0].name).to.equal('toto_channel')
+      expect(data[1].name).to.equal('root_channel')
     }
 
-    await uploadVideo(servers[0].url, servers[0].accessToken, { channelId: servers[0].videoChannel.id })
+    await servers[0].videos.upload({ attributes: { channelId: servers[0].store.channel.id } })
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getAccountVideoChannelsList({
-        url: server.url,
-        accountName,
-        sort: '-updatedAt'
-      })
+      const { data } = await server.channels.listByAccount({ accountName, sort: '-updatedAt' })
 
-      const channels: VideoChannel[] = res.body.data
-      expect(channels[0].name).to.equal('root_channel')
-      expect(channels[1].name).to.equal('toto_channel')
+      expect(data[0].name).to.equal('root_channel')
+      expect(data[1].name).to.equal('toto_channel')
     }
   })
 
diff --git a/server/tests/api/videos/video-comments.ts b/server/tests/api/videos/video-comments.ts
index b6b002307..61ee54540 100644
--- a/server/tests/api/videos/video-comments.ts
+++ b/server/tests/api/videos/video-comments.ts
@@ -2,80 +2,62 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { VideoComment, VideoCommentAdmin, VideoCommentThreadTree } from '@shared/models'
-import { cleanupTests, testImage } from '../../../../shared/extra-utils'
 import {
-  createUser,
+  cleanupTests,
+  CommentsCommand,
+  createSingleServer,
   dateIsValid,
-  flushAndRunServer,
-  getAccessToken,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateMyAvatar,
-  uploadVideo
-} from '../../../../shared/extra-utils/index'
-import {
-  addVideoCommentReply,
-  addVideoCommentThread,
-  deleteVideoComment,
-  getAdminVideoComments,
-  getVideoCommentThreads,
-  getVideoThreadComments
-} from '../../../../shared/extra-utils/videos/video-comments'
+  testImage
+} from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test video comments', function () {
-  let server: ServerInfo
-  let videoId
-  let videoUUID
-  let threadId
+  let server: PeerTubeServer
+  let videoId: number
+  let videoUUID: string
+  let threadId: number
   let replyToDeleteId: number
 
   let userAccessTokenServer1: string
 
+  let command: CommentsCommand
+
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
-    const res = await uploadVideo(server.url, server.accessToken, {})
-    videoUUID = res.body.video.uuid
-    videoId = res.body.video.id
+    const { id, uuid } = await server.videos.upload()
+    videoUUID = uuid
+    videoId = id
 
-    await updateMyAvatar({
-      url: server.url,
-      accessToken: server.accessToken,
-      fixture: 'avatar.png'
-    })
+    await server.users.updateMyAvatar({ fixture: 'avatar.png' })
 
-    await createUser({
-      url: server.url,
-      accessToken: server.accessToken,
-      username: 'user1',
-      password: 'password'
-    })
-    userAccessTokenServer1 = await getAccessToken(server.url, 'user1', 'password')
+    userAccessTokenServer1 = await server.users.generateUserAndToken('user1')
+
+    command = server.comments
   })
 
   describe('User comments', function () {
 
     it('Should not have threads on this video', async function () {
-      const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+      const body = await command.listThreads({ videoId: videoUUID })
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.totalNotDeletedComments).to.equal(0)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(body.total).to.equal(0)
+      expect(body.totalNotDeletedComments).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
     })
 
     it('Should create a thread in this video', async function () {
       const text = 'my super first comment'
 
-      const res = await addVideoCommentThread(server.url, server.accessToken, videoUUID, text)
-      const comment = res.body.comment
+      const comment = await command.createThread({ videoId: videoUUID, text })
 
       expect(comment.inReplyToCommentId).to.be.null
       expect(comment.text).equal('my super first comment')
@@ -91,14 +73,14 @@ describe('Test video comments', function () {
     })
 
     it('Should list threads of this video', async function () {
-      const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+      const body = await command.listThreads({ videoId: videoUUID })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.totalNotDeletedComments).to.equal(1)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(1)
+      expect(body.total).to.equal(1)
+      expect(body.totalNotDeletedComments).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
 
-      const comment: VideoComment = res.body.data[0]
+      const comment = body.data[0]
       expect(comment.inReplyToCommentId).to.be.null
       expect(comment.text).equal('my super first comment')
       expect(comment.videoId).to.equal(videoId)
@@ -117,9 +99,9 @@ describe('Test video comments', function () {
     })
 
     it('Should get all the thread created', async function () {
-      const res = await getVideoThreadComments(server.url, videoUUID, threadId)
+      const body = await command.getThread({ videoId: videoUUID, threadId })
 
-      const rootComment = res.body.comment
+      const rootComment = body.comment
       expect(rootComment.inReplyToCommentId).to.be.null
       expect(rootComment.text).equal('my super first comment')
       expect(rootComment.videoId).to.equal(videoId)
@@ -129,20 +111,19 @@ describe('Test video comments', function () {
 
     it('Should create multiple replies in this thread', async function () {
       const text1 = 'my super answer to thread 1'
-      const childCommentRes = await addVideoCommentReply(server.url, server.accessToken, videoId, threadId, text1)
-      const childCommentId = childCommentRes.body.comment.id
+      const created = await command.addReply({ videoId, toCommentId: threadId, text: text1 })
+      const childCommentId = created.id
 
       const text2 = 'my super answer to answer of thread 1'
-      await addVideoCommentReply(server.url, server.accessToken, videoId, childCommentId, text2)
+      await command.addReply({ videoId, toCommentId: childCommentId, text: text2 })
 
       const text3 = 'my second answer to thread 1'
-      await addVideoCommentReply(server.url, server.accessToken, videoId, threadId, text3)
+      await command.addReply({ videoId, toCommentId: threadId, text: text3 })
     })
 
     it('Should get correctly the replies', async function () {
-      const res = await getVideoThreadComments(server.url, videoUUID, threadId)
+      const tree = await command.getThread({ videoId: videoUUID, threadId })
 
-      const tree: VideoCommentThreadTree = res.body
       expect(tree.comment.text).equal('my super first comment')
       expect(tree.children).to.have.lengthOf(2)
 
@@ -163,42 +144,41 @@ describe('Test video comments', function () {
 
     it('Should create other threads', async function () {
       const text1 = 'super thread 2'
-      await addVideoCommentThread(server.url, server.accessToken, videoUUID, text1)
+      await command.createThread({ videoId: videoUUID, text: text1 })
 
       const text2 = 'super thread 3'
-      await addVideoCommentThread(server.url, server.accessToken, videoUUID, text2)
+      await command.createThread({ videoId: videoUUID, text: text2 })
     })
 
     it('Should list the threads', async function () {
-      const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
-
-      expect(res.body.total).to.equal(3)
-      expect(res.body.totalNotDeletedComments).to.equal(6)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(3)
-
-      expect(res.body.data[0].text).to.equal('my super first comment')
-      expect(res.body.data[0].totalReplies).to.equal(3)
-      expect(res.body.data[1].text).to.equal('super thread 2')
-      expect(res.body.data[1].totalReplies).to.equal(0)
-      expect(res.body.data[2].text).to.equal('super thread 3')
-      expect(res.body.data[2].totalReplies).to.equal(0)
+      const body = await command.listThreads({ videoId: videoUUID, sort: 'createdAt' })
+
+      expect(body.total).to.equal(3)
+      expect(body.totalNotDeletedComments).to.equal(6)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(3)
+
+      expect(body.data[0].text).to.equal('my super first comment')
+      expect(body.data[0].totalReplies).to.equal(3)
+      expect(body.data[1].text).to.equal('super thread 2')
+      expect(body.data[1].totalReplies).to.equal(0)
+      expect(body.data[2].text).to.equal('super thread 3')
+      expect(body.data[2].totalReplies).to.equal(0)
     })
 
     it('Should delete a reply', async function () {
-      await deleteVideoComment(server.url, server.accessToken, videoId, replyToDeleteId)
+      await command.delete({ videoId, commentId: replyToDeleteId })
 
       {
-        const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
+        const body = await command.listThreads({ videoId: videoUUID, sort: 'createdAt' })
 
-        expect(res.body.total).to.equal(3)
-        expect(res.body.totalNotDeletedComments).to.equal(5)
+        expect(body.total).to.equal(3)
+        expect(body.totalNotDeletedComments).to.equal(5)
       }
 
       {
-        const res = await getVideoThreadComments(server.url, videoUUID, threadId)
+        const tree = await command.getThread({ videoId: videoUUID, threadId })
 
-        const tree: VideoCommentThreadTree = res.body
         expect(tree.comment.text).equal('my super first comment')
         expect(tree.children).to.have.lengthOf(2)
 
@@ -220,99 +200,88 @@ describe('Test video comments', function () {
     })
 
     it('Should delete a complete thread', async function () {
-      await deleteVideoComment(server.url, server.accessToken, videoId, threadId)
-
-      const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
-      expect(res.body.total).to.equal(3)
-      expect(res.body.data).to.be.an('array')
-      expect(res.body.data).to.have.lengthOf(3)
-
-      expect(res.body.data[0].text).to.equal('')
-      expect(res.body.data[0].isDeleted).to.be.true
-      expect(res.body.data[0].deletedAt).to.not.be.null
-      expect(res.body.data[0].account).to.be.null
-      expect(res.body.data[0].totalReplies).to.equal(2)
-      expect(res.body.data[1].text).to.equal('super thread 2')
-      expect(res.body.data[1].totalReplies).to.equal(0)
-      expect(res.body.data[2].text).to.equal('super thread 3')
-      expect(res.body.data[2].totalReplies).to.equal(0)
+      await command.delete({ videoId, commentId: threadId })
+
+      const body = await command.listThreads({ videoId: videoUUID, sort: 'createdAt' })
+      expect(body.total).to.equal(3)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(3)
+
+      expect(body.data[0].text).to.equal('')
+      expect(body.data[0].isDeleted).to.be.true
+      expect(body.data[0].deletedAt).to.not.be.null
+      expect(body.data[0].account).to.be.null
+      expect(body.data[0].totalReplies).to.equal(2)
+      expect(body.data[1].text).to.equal('super thread 2')
+      expect(body.data[1].totalReplies).to.equal(0)
+      expect(body.data[2].text).to.equal('super thread 3')
+      expect(body.data[2].totalReplies).to.equal(0)
     })
 
     it('Should count replies from the video author correctly', async function () {
-      const text = 'my super first comment'
-      await addVideoCommentThread(server.url, server.accessToken, videoUUID, text)
-      let res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
-      const comment: VideoComment = res.body.data[0]
-      const threadId2 = comment.threadId
+      await command.createThread({ videoId: videoUUID, text: 'my super first comment' })
+
+      const { data } = await command.listThreads({ videoId: videoUUID })
+      const threadId2 = data[0].threadId
 
       const text2 = 'a first answer to thread 4 by a third party'
-      await addVideoCommentReply(server.url, userAccessTokenServer1, videoId, threadId2, text2)
+      await command.addReply({ token: userAccessTokenServer1, videoId, toCommentId: threadId2, text: text2 })
 
       const text3 = 'my second answer to thread 4'
-      await addVideoCommentReply(server.url, server.accessToken, videoId, threadId2, text3)
+      await command.addReply({ videoId, toCommentId: threadId2, text: text3 })
 
-      res = await getVideoThreadComments(server.url, videoUUID, threadId2)
-      const tree: VideoCommentThreadTree = res.body
+      const tree = await command.getThread({ videoId: videoUUID, threadId: threadId2 })
       expect(tree.comment.totalReplies).to.equal(tree.comment.totalRepliesFromVideoAuthor + 1)
     })
   })
 
   describe('All instance comments', function () {
-    async function getComments (options: any = {}) {
-      const res = await getAdminVideoComments(Object.assign({
-        url: server.url,
-        token: server.accessToken,
-        start: 0,
-        count: 10
-      }, options))
-
-      return { comments: res.body.data as VideoCommentAdmin[], total: res.body.total as number }
-    }
 
     it('Should list instance comments as admin', async function () {
-      const { comments } = await getComments({ start: 0, count: 1 })
+      const { data } = await command.listForAdmin({ start: 0, count: 1 })
 
-      expect(comments[0].text).to.equal('my second answer to thread 4')
+      expect(data[0].text).to.equal('my second answer to thread 4')
     })
 
     it('Should filter instance comments by isLocal', async function () {
-      const { total, comments } = await getComments({ isLocal: false })
+      const { total, data } = await command.listForAdmin({ isLocal: false })
 
-      expect(comments).to.have.lengthOf(0)
+      expect(data).to.have.lengthOf(0)
       expect(total).to.equal(0)
     })
 
     it('Should search instance comments by account', async function () {
-      const { total, comments } = await getComments({ searchAccount: 'user' })
+      const { total, data } = await command.listForAdmin({ searchAccount: 'user' })
 
-      expect(comments).to.have.lengthOf(1)
+      expect(data).to.have.lengthOf(1)
       expect(total).to.equal(1)
 
-      expect(comments[0].text).to.equal('a first answer to thread 4 by a third party')
+      expect(data[0].text).to.equal('a first answer to thread 4 by a third party')
     })
 
     it('Should search instance comments by video', async function () {
       {
-        const { total, comments } = await getComments({ searchVideo: 'video' })
+        const { total, data } = await command.listForAdmin({ searchVideo: 'video' })
 
-        expect(comments).to.have.lengthOf(7)
+        expect(data).to.have.lengthOf(7)
         expect(total).to.equal(7)
       }
 
       {
-        const { total, comments } = await getComments({ searchVideo: 'hello' })
+        const { total, data } = await command.listForAdmin({ searchVideo: 'hello' })
 
-        expect(comments).to.have.lengthOf(0)
+        expect(data).to.have.lengthOf(0)
         expect(total).to.equal(0)
       }
     })
 
     it('Should search instance comments', async function () {
-      const { total, comments } = await getComments({ search: 'super thread 3' })
+      const { total, data } = await command.listForAdmin({ search: 'super thread 3' })
 
-      expect(comments).to.have.lengthOf(1)
       expect(total).to.equal(1)
-      expect(comments[0].text).to.equal('super thread 3')
+
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].text).to.equal('super thread 3')
     })
   })
 
diff --git a/server/tests/api/videos/video-description.ts b/server/tests/api/videos/video-description.ts
index b8e98e45f..d22b4ed96 100644
--- a/server/tests/api/videos/video-description.ts
+++ b/server/tests/api/videos/video-description.ts
@@ -1,25 +1,13 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import {
-  cleanupTests,
-  flushAndRunMultipleServers,
-  getVideo,
-  getVideoDescription,
-  getVideosList,
-  ServerInfo,
-  setAccessTokensToServers,
-  updateVideo,
-  uploadVideo
-} from '../../../../shared/extra-utils/index'
-import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import * as chai from 'chai'
+import { cleanupTests, createMultipleServers, doubleFollow, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test video description', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoUUID = ''
   let videoId: number
   const longDescription = 'my super description for server 1'.repeat(50)
@@ -28,7 +16,7 @@ describe('Test video description', function () {
     this.timeout(40000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -43,20 +31,19 @@ describe('Test video description', function () {
     const attributes = {
       description: longDescription
     }
-    await uploadVideo(servers[0].url, servers[0].accessToken, attributes)
+    await servers[0].videos.upload({ attributes })
 
     await waitJobs(servers)
 
-    const res = await getVideosList(servers[0].url)
+    const { data } = await servers[0].videos.list()
 
-    videoId = res.body.data[0].id
-    videoUUID = res.body.data[0].uuid
+    videoId = data[0].id
+    videoUUID = data[0].uuid
   })
 
   it('Should have a truncated description on each server', async function () {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video = res.body
+      const video = await server.videos.get({ id: videoUUID })
 
       // 30 characters * 6 -> 240 characters
       const truncatedDescription = 'my super description for server 1'.repeat(7) +
@@ -68,11 +55,10 @@ describe('Test video description', function () {
 
   it('Should fetch long description on each server', async function () {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video = res.body
+      const video = await server.videos.get({ id: videoUUID })
 
-      const res2 = await getVideoDescription(server.url, video.descriptionPath)
-      expect(res2.body.description).to.equal(longDescription)
+      const { description } = await server.videos.getDescription({ descriptionPath: video.descriptionPath })
+      expect(description).to.equal(longDescription)
     }
   })
 
@@ -82,20 +68,19 @@ describe('Test video description', function () {
     const attributes = {
       description: 'short description'
     }
-    await updateVideo(servers[0].url, servers[0].accessToken, videoId, attributes)
+    await servers[0].videos.update({ id: videoId, attributes })
 
     await waitJobs(servers)
   })
 
   it('Should have a small description on each server', async function () {
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video = res.body
+      const video = await server.videos.get({ id: videoUUID })
 
       expect(video.description).to.equal('short description')
 
-      const res2 = await getVideoDescription(server.url, video.descriptionPath)
-      expect(res2.body.description).to.equal('short description')
+      const { description } = await server.videos.getDescription({ descriptionPath: video.descriptionPath })
+      expect(description).to.equal('short description')
     }
   })
 
diff --git a/server/tests/api/videos/video-hls.ts b/server/tests/api/videos/video-hls.ts
index 03ac3f321..961f0e617 100644
--- a/server/tests/api/videos/video-hls.ts
+++ b/server/tests/api/videos/video-hls.ts
@@ -2,38 +2,30 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { join } from 'path'
+import { basename, join } from 'path'
+import { removeFragmentedMP4Ext, uuidRegex } from '@shared/core-utils'
 import {
   checkDirectoryIsEmpty,
   checkResolutionsInMasterPlaylist,
   checkSegmentHash,
   checkTmpIsEmpty,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getPlaylist,
-  getVideo,
   makeRawRequest,
-  removeVideo,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateCustomSubConfig,
-  updateVideo,
-  uploadVideo,
   waitJobs,
   webtorrentAdd
-} from '../../../../shared/extra-utils'
-import { VideoDetails } from '../../../../shared/models/videos'
-import { VideoStreamingPlaylistType } from '../../../../shared/models/videos/video-streaming-playlist.type'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoStreamingPlaylistType } from '@shared/models'
 import { DEFAULT_AUDIO_RESOLUTION } from '../../../initializers/constants'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 const expect = chai.expect
 
-async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOnly: boolean, resolutions = [ 240, 360, 480, 720 ]) {
+async function checkHlsPlaylist (servers: PeerTubeServer[], videoUUID: string, hlsOnly: boolean, resolutions = [ 240, 360, 480, 720 ]) {
   for (const server of servers) {
-    const resVideoDetails = await getVideo(server.url, videoUUID)
-    const videoDetails: VideoDetails = resVideoDetails.body
+    const videoDetails = await server.videos.get({ id: videoUUID })
     const baseUrl = `http://${videoDetails.account.host}`
 
     expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
@@ -47,14 +39,17 @@ async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOn
     if (hlsOnly) expect(videoDetails.files).to.have.lengthOf(0)
     else expect(videoDetails.files).to.have.lengthOf(resolutions.length)
 
+    // Check JSON files
     for (const resolution of resolutions) {
       const file = hlsFiles.find(f => f.resolution.id === resolution)
       expect(file).to.not.be.undefined
 
       expect(file.magnetUri).to.have.lengthOf.above(2)
-      expect(file.torrentUrl).to.equal(`http://${server.host}/lazy-static/torrents/${videoDetails.uuid}-${file.resolution.id}-hls.torrent`)
-      expect(file.fileUrl).to.equal(
-        `${baseUrl}/static/streaming-playlists/hls/${videoDetails.uuid}/${videoDetails.uuid}-${file.resolution.id}-fragmented.mp4`
+      expect(file.torrentUrl).to.match(
+        new RegExp(`http://${server.host}/lazy-static/torrents/${uuidRegex}-${file.resolution.id}-hls.torrent`)
+      )
+      expect(file.fileUrl).to.match(
+        new RegExp(`${baseUrl}/static/streaming-playlists/hls/${videoDetails.uuid}/${uuidRegex}-${file.resolution.id}-fragmented.mp4`)
       )
       expect(file.resolution.label).to.equal(resolution + 'p')
 
@@ -67,11 +62,11 @@ async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOn
       expect(torrent.files[0].path).to.exist.and.to.not.equal('')
     }
 
+    // Check master playlist
     {
-      await checkResolutionsInMasterPlaylist(hlsPlaylist.playlistUrl, resolutions)
+      await checkResolutionsInMasterPlaylist({ server, playlistUrl: hlsPlaylist.playlistUrl, resolutions })
 
-      const res = await getPlaylist(hlsPlaylist.playlistUrl)
-      const masterPlaylist = res.text
+      const masterPlaylist = await server.streamingPlaylists.get({ url: hlsPlaylist.playlistUrl })
 
       for (const resolution of resolutions) {
         expect(masterPlaylist).to.contain(`${resolution}.m3u8`)
@@ -79,12 +74,18 @@ async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOn
       }
     }
 
+    // Check resolution playlists
     {
       for (const resolution of resolutions) {
-        const res = await getPlaylist(`${baseUrl}/static/streaming-playlists/hls/${videoUUID}/${resolution}.m3u8`)
+        const file = hlsFiles.find(f => f.resolution.id === resolution)
+        const playlistName = removeFragmentedMP4Ext(basename(file.fileUrl)) + '.m3u8'
+
+        const subPlaylist = await server.streamingPlaylists.get({
+          url: `${baseUrl}/static/streaming-playlists/hls/${videoUUID}/${playlistName}`
+        })
 
-        const subPlaylist = res.text
-        expect(subPlaylist).to.contain(`${videoUUID}-${resolution}-fragmented.mp4`)
+        expect(subPlaylist).to.match(new RegExp(`${uuidRegex}-${resolution}-fragmented.mp4`))
+        expect(subPlaylist).to.contain(basename(file.fileUrl))
       }
     }
 
@@ -92,23 +93,31 @@ async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOn
       const baseUrlAndPath = baseUrl + '/static/streaming-playlists/hls'
 
       for (const resolution of resolutions) {
-        await checkSegmentHash(baseUrlAndPath, baseUrlAndPath, videoUUID, resolution, hlsPlaylist)
+        await checkSegmentHash({
+          server,
+          baseUrlPlaylist: baseUrlAndPath,
+          baseUrlSegment: baseUrlAndPath,
+          videoUUID,
+          resolution,
+          hlsPlaylist
+        })
       }
     }
   }
 }
 
 describe('Test HLS videos', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let videoUUID = ''
   let videoAudioUUID = ''
 
   function runTestSuite (hlsOnly: boolean) {
+
     it('Should upload a video and transcode it to HLS', async function () {
       this.timeout(120000)
 
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video 1', fixture: 'video_short.webm' })
-      videoUUID = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video 1', fixture: 'video_short.webm' } })
+      videoUUID = uuid
 
       await waitJobs(servers)
 
@@ -118,8 +127,8 @@ describe('Test HLS videos', function () {
     it('Should upload an audio file and transcode it to HLS', async function () {
       this.timeout(120000)
 
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video audio', fixture: 'sample.ogg' })
-      videoAudioUUID = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video audio', fixture: 'sample.ogg' } })
+      videoAudioUUID = uuid
 
       await waitJobs(servers)
 
@@ -129,7 +138,7 @@ describe('Test HLS videos', function () {
     it('Should update the video', async function () {
       this.timeout(10000)
 
-      await updateVideo(servers[0].url, servers[0].accessToken, videoUUID, { name: 'video 1 updated' })
+      await servers[0].videos.update({ id: videoUUID, attributes: { name: 'video 1 updated' } })
 
       await waitJobs(servers)
 
@@ -139,14 +148,14 @@ describe('Test HLS videos', function () {
     it('Should delete videos', async function () {
       this.timeout(10000)
 
-      await removeVideo(servers[0].url, servers[0].accessToken, videoUUID)
-      await removeVideo(servers[0].url, servers[0].accessToken, videoAudioUUID)
+      await servers[0].videos.remove({ id: videoUUID })
+      await servers[0].videos.remove({ id: videoAudioUUID })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        await getVideo(server.url, videoUUID, HttpStatusCode.NOT_FOUND_404)
-        await getVideo(server.url, videoAudioUUID, HttpStatusCode.NOT_FOUND_404)
+        await server.videos.get({ id: videoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+        await server.videos.get({ id: videoAudioUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
     })
 
@@ -176,7 +185,7 @@ describe('Test HLS videos', function () {
         }
       }
     }
-    servers = await flushAndRunMultipleServers(2, configOverride)
+    servers = await createMultipleServers(2, configOverride)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -192,24 +201,26 @@ describe('Test HLS videos', function () {
   describe('With only HLS enabled', function () {
 
     before(async function () {
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-        transcoding: {
-          enabled: true,
-          allowAudioFiles: true,
-          resolutions: {
-            '240p': true,
-            '360p': true,
-            '480p': true,
-            '720p': true,
-            '1080p': true,
-            '1440p': true,
-            '2160p': true
-          },
-          hls: {
-            enabled: true
-          },
-          webtorrent: {
-            enabled: false
+      await servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          transcoding: {
+            enabled: true,
+            allowAudioFiles: true,
+            resolutions: {
+              '240p': true,
+              '360p': true,
+              '480p': true,
+              '720p': true,
+              '1080p': true,
+              '1440p': true,
+              '2160p': true
+            },
+            hls: {
+              enabled: true
+            },
+            webtorrent: {
+              enabled: false
+            }
           }
         }
       })
diff --git a/server/tests/api/videos/video-imports.ts b/server/tests/api/videos/video-imports.ts
index 80834ca86..2eac130d2 100644
--- a/server/tests/api/videos/video-imports.ts
+++ b/server/tests/api/videos/video-imports.ts
@@ -3,43 +3,30 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
+  areHttpImportTestsDisabled,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getMyUserInformation,
-  getMyVideos,
-  getVideo,
-  getVideosList,
-  immutableAssign,
-  listVideoCaptions,
-  ServerInfo,
+  FIXTURE_URLS,
+  PeerTubeServer,
   setAccessTokensToServers,
   testCaptionFile,
-  updateCustomSubConfig
-} from '../../../../shared/extra-utils'
-import { areHttpImportTestsDisabled, testImage } from '../../../../shared/extra-utils/miscs/miscs'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import {
-  getMagnetURI,
-  getMyVideoImports,
-  getYoutubeHDRVideoUrl,
-  getYoutubeVideoUrl,
-  importVideo
-} from '../../../../shared/extra-utils/videos/video-imports'
-import { VideoCaption, VideoDetails, VideoImport, VideoPrivacy, VideoResolution } from '../../../../shared/models/videos'
+  testImage,
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoPrivacy, VideoResolution } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test video imports', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let channelIdServer1: number
   let channelIdServer2: number
 
   if (areHttpImportTestsDisabled()) return
 
-  async function checkVideosServer1 (url: string, idHttp: string, idMagnet: string, idTorrent: string) {
-    const resHttp = await getVideo(url, idHttp)
-    const videoHttp: VideoDetails = resHttp.body
+  async function checkVideosServer1 (server: PeerTubeServer, idHttp: string, idMagnet: string, idTorrent: string) {
+    const videoHttp = await server.videos.get({ id: idHttp })
 
     expect(videoHttp.name).to.equal('small video - youtube')
     // FIXME: youtube-dl seems broken
@@ -56,10 +43,8 @@ describe('Test video imports', function () {
     expect(originallyPublishedAt.getMonth()).to.equal(0)
     expect(originallyPublishedAt.getFullYear()).to.equal(2019)
 
-    const resMagnet = await getVideo(url, idMagnet)
-    const videoMagnet: VideoDetails = resMagnet.body
-    const resTorrent = await getVideo(url, idTorrent)
-    const videoTorrent: VideoDetails = resTorrent.body
+    const videoMagnet = await server.videos.get({ id: idMagnet })
+    const videoTorrent = await server.videos.get({ id: idTorrent })
 
     for (const video of [ videoMagnet, videoTorrent ]) {
       expect(video.category.label).to.equal('Misc')
@@ -74,13 +59,12 @@ describe('Test video imports', function () {
     expect(videoTorrent.name).to.contain('你好 世界 720p.mp4')
     expect(videoMagnet.name).to.contain('super peertube2 video')
 
-    const resCaptions = await listVideoCaptions(url, idHttp)
-    expect(resCaptions.body.total).to.equal(2)
+    const bodyCaptions = await server.captions.list({ videoId: idHttp })
+    expect(bodyCaptions.total).to.equal(2)
   }
 
-  async function checkVideoServer2 (url: string, id: number | string) {
-    const res = await getVideo(url, id)
-    const video: VideoDetails = res.body
+  async function checkVideoServer2 (server: PeerTubeServer, id: number | string) {
+    const video = await server.videos.get({ id })
 
     expect(video.name).to.equal('my super name')
     expect(video.category.label).to.equal('Entertainment')
@@ -92,26 +76,26 @@ describe('Test video imports', function () {
 
     expect(video.files).to.have.lengthOf(1)
 
-    const resCaptions = await listVideoCaptions(url, id)
-    expect(resCaptions.body.total).to.equal(2)
+    const bodyCaptions = await server.captions.list({ videoId: id })
+    expect(bodyCaptions.total).to.equal(2)
   }
 
   before(async function () {
     this.timeout(30_000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
     {
-      const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
-      channelIdServer1 = res.body.videoChannels[0].id
+      const { videoChannels } = await servers[0].users.getMyInfo()
+      channelIdServer1 = videoChannels[0].id
     }
 
     {
-      const res = await getMyUserInformation(servers[1].url, servers[1].accessToken)
-      channelIdServer2 = res.body.videoChannels[0].id
+      const { videoChannels } = await servers[1].users.getMyInfo()
+      channelIdServer2 = videoChannels[0].id
     }
 
     await doubleFollow(servers[0], servers[1])
@@ -126,18 +110,18 @@ describe('Test video imports', function () {
     }
 
     {
-      const attributes = immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() })
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      expect(res.body.video.name).to.equal('small video - youtube')
+      const attributes = { ...baseAttributes, targetUrl: FIXTURE_URLS.youtube }
+      const { video } = await servers[0].imports.importVideo({ attributes })
+      expect(video.name).to.equal('small video - youtube')
 
-      expect(res.body.video.thumbnailPath).to.match(new RegExp(`^/static/thumbnails/.+.jpg$`))
-      expect(res.body.video.previewPath).to.match(new RegExp(`^/lazy-static/previews/.+.jpg$`))
+      expect(video.thumbnailPath).to.match(new RegExp(`^/static/thumbnails/.+.jpg$`))
+      expect(video.previewPath).to.match(new RegExp(`^/lazy-static/previews/.+.jpg$`))
 
-      await testImage(servers[0].url, 'video_import_thumbnail', res.body.video.thumbnailPath)
-      await testImage(servers[0].url, 'video_import_preview', res.body.video.previewPath)
+      await testImage(servers[0].url, 'video_import_thumbnail', video.thumbnailPath)
+      await testImage(servers[0].url, 'video_import_preview', video.previewPath)
 
-      const resCaptions = await listVideoCaptions(servers[0].url, res.body.video.id)
-      const videoCaptions: VideoCaption[] = resCaptions.body.data
+      const bodyCaptions = await servers[0].captions.list({ videoId: video.id })
+      const videoCaptions = bodyCaptions.data
       expect(videoCaptions).to.have.lengthOf(2)
 
       const enCaption = videoCaptions.find(caption => caption.language.id === 'en')
@@ -176,52 +160,52 @@ Ajouter un sous-titre est vraiment facile`)
     }
 
     {
-      const attributes = immutableAssign(baseAttributes, {
-        magnetUri: getMagnetURI(),
+      const attributes = {
+        ...baseAttributes,
+        magnetUri: FIXTURE_URLS.magnet,
         description: 'this is a super torrent description',
         tags: [ 'tag_torrent1', 'tag_torrent2' ]
-      })
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      expect(res.body.video.name).to.equal('super peertube2 video')
+      }
+      const { video } = await servers[0].imports.importVideo({ attributes })
+      expect(video.name).to.equal('super peertube2 video')
     }
 
     {
-      const attributes = immutableAssign(baseAttributes, {
+      const attributes = {
+        ...baseAttributes,
         torrentfile: 'video-720p.torrent' as any,
         description: 'this is a super torrent description',
         tags: [ 'tag_torrent1', 'tag_torrent2' ]
-      })
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      expect(res.body.video.name).to.equal('你好 世界 720p.mp4')
+      }
+      const { video } = await servers[0].imports.importVideo({ attributes })
+      expect(video.name).to.equal('你好 世界 720p.mp4')
     }
   })
 
   it('Should list the videos to import in my videos on server 1', async function () {
-    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5, 'createdAt')
+    const { total, data } = await servers[0].videos.listMyVideos({ sort: 'createdAt' })
 
-    expect(res.body.total).to.equal(3)
+    expect(total).to.equal(3)
 
-    const videos = res.body.data
-    expect(videos).to.have.lengthOf(3)
-    expect(videos[0].name).to.equal('small video - youtube')
-    expect(videos[1].name).to.equal('super peertube2 video')
-    expect(videos[2].name).to.equal('你好 世界 720p.mp4')
+    expect(data).to.have.lengthOf(3)
+    expect(data[0].name).to.equal('small video - youtube')
+    expect(data[1].name).to.equal('super peertube2 video')
+    expect(data[2].name).to.equal('你好 世界 720p.mp4')
   })
 
   it('Should list the videos to import in my imports on server 1', async function () {
-    const res = await getMyVideoImports(servers[0].url, servers[0].accessToken, '-createdAt')
+    const { total, data: videoImports } = await servers[0].imports.getMyVideoImports({ sort: '-createdAt' })
+    expect(total).to.equal(3)
 
-    expect(res.body.total).to.equal(3)
-    const videoImports: VideoImport[] = res.body.data
     expect(videoImports).to.have.lengthOf(3)
 
-    expect(videoImports[2].targetUrl).to.equal(getYoutubeVideoUrl())
+    expect(videoImports[2].targetUrl).to.equal(FIXTURE_URLS.youtube)
     expect(videoImports[2].magnetUri).to.be.null
     expect(videoImports[2].torrentName).to.be.null
     expect(videoImports[2].video.name).to.equal('small video - youtube')
 
     expect(videoImports[1].targetUrl).to.be.null
-    expect(videoImports[1].magnetUri).to.equal(getMagnetURI())
+    expect(videoImports[1].magnetUri).to.equal(FIXTURE_URLS.magnet)
     expect(videoImports[1].torrentName).to.be.null
     expect(videoImports[1].video.name).to.equal('super peertube2 video')
 
@@ -237,12 +221,12 @@ Ajouter un sous-titre est vraiment facile`)
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      expect(res.body.total).to.equal(3)
-      expect(res.body.data).to.have.lengthOf(3)
+      const { total, data } = await server.videos.list()
+      expect(total).to.equal(3)
+      expect(data).to.have.lengthOf(3)
 
-      const [ videoHttp, videoMagnet, videoTorrent ] = res.body.data
-      await checkVideosServer1(server.url, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
+      const [ videoHttp, videoMagnet, videoTorrent ] = data
+      await checkVideosServer1(server, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
     }
   })
 
@@ -250,7 +234,7 @@ Ajouter un sous-titre est vraiment facile`)
     this.timeout(60_000)
 
     const attributes = {
-      targetUrl: getYoutubeVideoUrl(),
+      targetUrl: FIXTURE_URLS.youtube,
       channelId: channelIdServer2,
       privacy: VideoPrivacy.PUBLIC,
       category: 10,
@@ -260,8 +244,8 @@ Ajouter un sous-titre est vraiment facile`)
       description: 'my super description',
       tags: [ 'supertag1', 'supertag2' ]
     }
-    const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
-    expect(res.body.video.name).to.equal('my super name')
+    const { video } = await servers[1].imports.importVideo({ attributes })
+    expect(video.name).to.equal('my super name')
   })
 
   it('Should have the videos listed on the two instances', async function () {
@@ -270,14 +254,14 @@ Ajouter un sous-titre est vraiment facile`)
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      expect(res.body.total).to.equal(4)
-      expect(res.body.data).to.have.lengthOf(4)
+      const { total, data } = await server.videos.list()
+      expect(total).to.equal(4)
+      expect(data).to.have.lengthOf(4)
 
-      await checkVideoServer2(server.url, res.body.data[0].uuid)
+      await checkVideoServer2(server, data[0].uuid)
 
-      const [ , videoHttp, videoMagnet, videoTorrent ] = res.body.data
-      await checkVideosServer1(server.url, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
+      const [ , videoHttp, videoMagnet, videoTorrent ] = data
+      await checkVideosServer1(server, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
     }
   })
 
@@ -286,18 +270,17 @@ Ajouter un sous-titre est vraiment facile`)
 
     const attributes = {
       name: 'transcoded video',
-      magnetUri: getMagnetURI(),
+      magnetUri: FIXTURE_URLS.magnet,
       channelId: channelIdServer2,
       privacy: VideoPrivacy.PUBLIC
     }
-    const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
-    const videoUUID = res.body.video.uuid
+    const { video } = await servers[1].imports.importVideo({ attributes })
+    const videoUUID = video.uuid
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = res.body
+      const video = await server.videos.get({ id: videoUUID })
 
       expect(video.name).to.equal('transcoded video')
       expect(video.files).to.have.lengthOf(4)
@@ -333,22 +316,21 @@ Ajouter un sous-titre est vraiment facile`)
         }
       }
     }
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
+    await servers[0].config.updateCustomSubConfig({ newConfig: config })
 
     const attributes = {
       name: 'hdr video',
-      targetUrl: getYoutubeHDRVideoUrl(),
+      targetUrl: FIXTURE_URLS.youtubeHDR,
       channelId: channelIdServer1,
       privacy: VideoPrivacy.PUBLIC
     }
-    const res1 = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-    const videoUUID = res1.body.video.uuid
+    const { video: videoImported } = await servers[0].imports.importVideo({ attributes })
+    const videoUUID = videoImported.uuid
 
     await waitJobs(servers)
 
     // test resolution
-    const res2 = await getVideo(servers[0].url, videoUUID)
-    const video: VideoDetails = res2.body
+    const video = await servers[0].videos.get({ id: videoUUID })
     expect(video.name).to.equal('hdr video')
     const maxResolution = Math.max.apply(Math, video.files.map(function (o) { return o.resolution.id }))
     expect(maxResolution, 'expected max resolution not met').to.equals(VideoResolution.H_1080P)
diff --git a/server/tests/api/videos/video-nsfw.ts b/server/tests/api/videos/video-nsfw.ts
index b16b484b9..b5d183d62 100644
--- a/server/tests/api/videos/video-nsfw.ts
+++ b/server/tests/api/videos/video-nsfw.ts
@@ -1,117 +1,96 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import { cleanupTests, getVideosList, ServerInfo, setAccessTokensToServers, uploadVideo } from '../../../../shared/extra-utils/index'
-import { userLogin } from '../../../../shared/extra-utils/users/login'
-import { createUser } from '../../../../shared/extra-utils/users/users'
-import { getMyVideos } from '../../../../shared/extra-utils/videos/videos'
-import {
-  flushAndRunServer,
-  getAccountVideos,
-  getConfig,
-  getCustomConfig,
-  getMyUserInformation,
-  getVideoChannelVideos,
-  getVideosListWithToken,
-  searchVideo,
-  searchVideoWithToken,
-  updateCustomConfig,
-  updateMyUser
-} from '../../../../shared/extra-utils'
-import { ServerConfig, VideosOverview } from '../../../../shared/models'
-import { CustomConfig } from '../../../../shared/models/server/custom-config.model'
-import { User } from '../../../../shared/models/users'
-import { getVideosOverview, getVideosOverviewWithToken } from '@shared/extra-utils/overviews/overviews'
+import * as chai from 'chai'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
+import { BooleanBothQuery, CustomConfig, ResultList, Video, VideosOverview } from '@shared/models'
 
 const expect = chai.expect
 
-function createOverviewRes (res: any) {
-  const overview = res.body as VideosOverview
-
+function createOverviewRes (overview: VideosOverview) {
   const videos = overview.categories[0].videos
-  return { body: { data: videos, total: videos.length } }
+  return { data: videos, total: videos.length }
 }
 
 describe('Test video NSFW policy', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken: string
   let customConfig: CustomConfig
 
-  function getVideosFunctions (token?: string, query = {}) {
-    return getMyUserInformation(server.url, server.accessToken)
-      .then(res => {
-        const user: User = res.body
-        const videoChannelName = user.videoChannels[0].name
-        const accountName = user.account.name + '@' + user.account.host
-        const hasQuery = Object.keys(query).length !== 0
-        let promises: Promise<any>[]
-
-        if (token) {
-          promises = [
-            getVideosListWithToken(server.url, token, query),
-            searchVideoWithToken(server.url, 'n', token, query),
-            getAccountVideos(server.url, token, accountName, 0, 5, undefined, query),
-            getVideoChannelVideos(server.url, token, videoChannelName, 0, 5, undefined, query)
-          ]
-
-          // Overviews do not support video filters
-          if (!hasQuery) {
-            promises.push(getVideosOverviewWithToken(server.url, 1, token).then(res => createOverviewRes(res)))
-          }
-
-          return Promise.all(promises)
-        }
-
-        promises = [
-          getVideosList(server.url),
-          searchVideo(server.url, 'n'),
-          getAccountVideos(server.url, undefined, accountName, 0, 5),
-          getVideoChannelVideos(server.url, undefined, videoChannelName, 0, 5)
-        ]
-
-        // Overviews do not support video filters
-        if (!hasQuery) {
-          promises.push(getVideosOverview(server.url, 1).then(res => createOverviewRes(res)))
-        }
-
-        return Promise.all(promises)
-      })
+  async function getVideosFunctions (token?: string, query: { nsfw?: BooleanBothQuery } = {}) {
+    const user = await server.users.getMyInfo()
+
+    const channelName = user.videoChannels[0].name
+    const accountName = user.account.name + '@' + user.account.host
+
+    const hasQuery = Object.keys(query).length !== 0
+    let promises: Promise<ResultList<Video>>[]
+
+    if (token) {
+      promises = [
+        server.search.advancedVideoSearch({ token, search: { search: 'n', sort: '-publishedAt', ...query } }),
+        server.videos.listWithToken({ token, ...query }),
+        server.videos.listByAccount({ token, handle: accountName, ...query }),
+        server.videos.listByChannel({ token, handle: channelName, ...query })
+      ]
+
+      // Overviews do not support video filters
+      if (!hasQuery) {
+        const p = server.overviews.getVideos({ page: 1, token })
+                                         .then(res => createOverviewRes(res))
+        promises.push(p)
+      }
+
+      return Promise.all(promises)
+    }
+
+    promises = [
+      server.search.searchVideos({ search: 'n', sort: '-publishedAt' }),
+      server.videos.list(),
+      server.videos.listByAccount({ token: null, handle: accountName }),
+      server.videos.listByChannel({ token: null, handle: channelName })
+    ]
+
+    // Overviews do not support video filters
+    if (!hasQuery) {
+      const p = server.overviews.getVideos({ page: 1 })
+                                       .then(res => createOverviewRes(res))
+      promises.push(p)
+    }
+
+    return Promise.all(promises)
   }
 
   before(async function () {
     this.timeout(50000)
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     // Get the access tokens
     await setAccessTokensToServers([ server ])
 
     {
       const attributes = { name: 'nsfw', nsfw: true, category: 1 }
-      await uploadVideo(server.url, server.accessToken, attributes)
+      await server.videos.upload({ attributes })
     }
 
     {
       const attributes = { name: 'normal', nsfw: false, category: 1 }
-      await uploadVideo(server.url, server.accessToken, attributes)
+      await server.videos.upload({ attributes })
     }
 
-    {
-      const res = await getCustomConfig(server.url, server.accessToken)
-      customConfig = res.body
-    }
+    customConfig = await server.config.getCustomConfig()
   })
 
   describe('Instance default NSFW policy', function () {
+
     it('Should display NSFW videos with display default NSFW policy', async function () {
-      const resConfig = await getConfig(server.url)
-      const serverConfig: ServerConfig = resConfig.body
+      const serverConfig = await server.config.getConfig()
       expect(serverConfig.instance.defaultNSFWPolicy).to.equal('display')
 
-      for (const res of await getVideosFunctions()) {
-        expect(res.body.total).to.equal(2)
+      for (const body of await getVideosFunctions()) {
+        expect(body.total).to.equal(2)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(2)
         expect(videos[0].name).to.equal('normal')
         expect(videos[1].name).to.equal('nsfw')
@@ -120,16 +99,15 @@ describe('Test video NSFW policy', function () {
 
     it('Should not display NSFW videos with do_not_list default NSFW policy', async function () {
       customConfig.instance.defaultNSFWPolicy = 'do_not_list'
-      await updateCustomConfig(server.url, server.accessToken, customConfig)
+      await server.config.updateCustomConfig({ newCustomConfig: customConfig })
 
-      const resConfig = await getConfig(server.url)
-      const serverConfig: ServerConfig = resConfig.body
+      const serverConfig = await server.config.getConfig()
       expect(serverConfig.instance.defaultNSFWPolicy).to.equal('do_not_list')
 
-      for (const res of await getVideosFunctions()) {
-        expect(res.body.total).to.equal(1)
+      for (const body of await getVideosFunctions()) {
+        expect(body.total).to.equal(1)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(1)
         expect(videos[0].name).to.equal('normal')
       }
@@ -137,16 +115,15 @@ describe('Test video NSFW policy', function () {
 
     it('Should display NSFW videos with blur default NSFW policy', async function () {
       customConfig.instance.defaultNSFWPolicy = 'blur'
-      await updateCustomConfig(server.url, server.accessToken, customConfig)
+      await server.config.updateCustomConfig({ newCustomConfig: customConfig })
 
-      const resConfig = await getConfig(server.url)
-      const serverConfig: ServerConfig = resConfig.body
+      const serverConfig = await server.config.getConfig()
       expect(serverConfig.instance.defaultNSFWPolicy).to.equal('blur')
 
-      for (const res of await getVideosFunctions()) {
-        expect(res.body.total).to.equal(2)
+      for (const body of await getVideosFunctions()) {
+        expect(body.total).to.equal(2)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(2)
         expect(videos[0].name).to.equal('normal')
         expect(videos[1].name).to.equal('nsfw')
@@ -159,24 +136,22 @@ describe('Test video NSFW policy', function () {
     it('Should create a user having the default nsfw policy', async function () {
       const username = 'user1'
       const password = 'my super password'
-      await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
-
-      userAccessToken = await userLogin(server, { username, password })
+      await server.users.create({ username: username, password: password })
 
-      const res = await getMyUserInformation(server.url, userAccessToken)
-      const user = res.body
+      userAccessToken = await server.login.getAccessToken({ username, password })
 
+      const user = await server.users.getMyInfo({ token: userAccessToken })
       expect(user.nsfwPolicy).to.equal('blur')
     })
 
     it('Should display NSFW videos with blur user NSFW policy', async function () {
       customConfig.instance.defaultNSFWPolicy = 'do_not_list'
-      await updateCustomConfig(server.url, server.accessToken, customConfig)
+      await server.config.updateCustomConfig({ newCustomConfig: customConfig })
 
-      for (const res of await getVideosFunctions(userAccessToken)) {
-        expect(res.body.total).to.equal(2)
+      for (const body of await getVideosFunctions(userAccessToken)) {
+        expect(body.total).to.equal(2)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(2)
         expect(videos[0].name).to.equal('normal')
         expect(videos[1].name).to.equal('nsfw')
@@ -184,16 +159,12 @@ describe('Test video NSFW policy', function () {
     })
 
     it('Should display NSFW videos with display user NSFW policy', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: server.accessToken,
-        nsfwPolicy: 'display'
-      })
+      await server.users.updateMe({ nsfwPolicy: 'display' })
 
-      for (const res of await getVideosFunctions(server.accessToken)) {
-        expect(res.body.total).to.equal(2)
+      for (const body of await getVideosFunctions(server.accessToken)) {
+        expect(body.total).to.equal(2)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(2)
         expect(videos[0].name).to.equal('normal')
         expect(videos[1].name).to.equal('nsfw')
@@ -201,56 +172,51 @@ describe('Test video NSFW policy', function () {
     })
 
     it('Should not display NSFW videos with do_not_list user NSFW policy', async function () {
-      await updateMyUser({
-        url: server.url,
-        accessToken: server.accessToken,
-        nsfwPolicy: 'do_not_list'
-      })
+      await server.users.updateMe({ nsfwPolicy: 'do_not_list' })
 
-      for (const res of await getVideosFunctions(server.accessToken)) {
-        expect(res.body.total).to.equal(1)
+      for (const body of await getVideosFunctions(server.accessToken)) {
+        expect(body.total).to.equal(1)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(1)
         expect(videos[0].name).to.equal('normal')
       }
     })
 
     it('Should be able to see my NSFW videos even with do_not_list user NSFW policy', async function () {
-      const res = await getMyVideos(server.url, server.accessToken, 0, 5)
-      expect(res.body.total).to.equal(2)
+      const { total, data } = await server.videos.listMyVideos()
+      expect(total).to.equal(2)
 
-      const videos = res.body.data
-      expect(videos).to.have.lengthOf(2)
-      expect(videos[0].name).to.equal('normal')
-      expect(videos[1].name).to.equal('nsfw')
+      expect(data).to.have.lengthOf(2)
+      expect(data[0].name).to.equal('normal')
+      expect(data[1].name).to.equal('nsfw')
     })
 
     it('Should display NSFW videos when the nsfw param === true', async function () {
-      for (const res of await getVideosFunctions(server.accessToken, { nsfw: true })) {
-        expect(res.body.total).to.equal(1)
+      for (const body of await getVideosFunctions(server.accessToken, { nsfw: 'true' })) {
+        expect(body.total).to.equal(1)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(1)
         expect(videos[0].name).to.equal('nsfw')
       }
     })
 
     it('Should hide NSFW videos when the nsfw param === true', async function () {
-      for (const res of await getVideosFunctions(server.accessToken, { nsfw: false })) {
-        expect(res.body.total).to.equal(1)
+      for (const body of await getVideosFunctions(server.accessToken, { nsfw: 'false' })) {
+        expect(body.total).to.equal(1)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(1)
         expect(videos[0].name).to.equal('normal')
       }
     })
 
     it('Should display both videos when the nsfw param === both', async function () {
-      for (const res of await getVideosFunctions(server.accessToken, { nsfw: 'both' })) {
-        expect(res.body.total).to.equal(2)
+      for (const body of await getVideosFunctions(server.accessToken, { nsfw: 'both' })) {
+        expect(body.total).to.equal(2)
 
-        const videos = res.body.data
+        const videos = body.data
         expect(videos).to.have.lengthOf(2)
         expect(videos[0].name).to.equal('normal')
         expect(videos[1].name).to.equal('nsfw')
diff --git a/server/tests/api/videos/video-playlist-thumbnails.ts b/server/tests/api/videos/video-playlist-thumbnails.ts
index a93a0b7de..f0b2ca169 100644
--- a/server/tests/api/videos/video-playlist-thumbnails.ts
+++ b/server/tests/api/videos/video-playlist-thumbnails.ts
@@ -1,21 +1,15 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
-  addVideoInPlaylist,
   cleanupTests,
-  createVideoPlaylist,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getVideoPlaylistsList,
-  removeVideoFromPlaylist,
-  reorderVideosPlaylist,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   testImage,
-  uploadVideoAndGetId,
   waitJobs
 } from '../../../../shared/extra-utils'
 import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
@@ -23,10 +17,10 @@ import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/
 const expect = chai.expect
 
 describe('Playlist thumbnail', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
 
-  let playlistWithoutThumbnail: number
-  let playlistWithThumbnail: number
+  let playlistWithoutThumbnailId: number
+  let playlistWithThumbnailId: number
 
   let withThumbnailE1: number
   let withThumbnailE2: number
@@ -36,22 +30,22 @@ describe('Playlist thumbnail', function () {
   let video1: number
   let video2: number
 
-  async function getPlaylistWithoutThumbnail (server: ServerInfo) {
-    const res = await getVideoPlaylistsList(server.url, 0, 10)
+  async function getPlaylistWithoutThumbnail (server: PeerTubeServer) {
+    const body = await server.playlists.list({ start: 0, count: 10 })
 
-    return res.body.data.find(p => p.displayName === 'playlist without thumbnail')
+    return body.data.find(p => p.displayName === 'playlist without thumbnail')
   }
 
-  async function getPlaylistWithThumbnail (server: ServerInfo) {
-    const res = await getVideoPlaylistsList(server.url, 0, 10)
+  async function getPlaylistWithThumbnail (server: PeerTubeServer) {
+    const body = await server.playlists.list({ start: 0, count: 10 })
 
-    return res.body.data.find(p => p.displayName === 'playlist with thumbnail')
+    return body.data.find(p => p.displayName === 'playlist with thumbnail')
   }
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2, { transcoding: { enabled: false } })
+    servers = await createMultipleServers(2, { transcoding: { enabled: false } })
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -60,8 +54,8 @@ describe('Playlist thumbnail', function () {
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
 
-    video1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 1' })).id
-    video2 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 2' })).id
+    video1 = (await servers[0].videos.quickUpload({ name: 'video 1' })).id
+    video2 = (await servers[0].videos.quickUpload({ name: 'video 2' })).id
 
     await waitJobs(servers)
   })
@@ -69,24 +63,20 @@ describe('Playlist thumbnail', function () {
   it('Should automatically update the thumbnail when adding an element', async function () {
     this.timeout(30000)
 
-    const res = await createVideoPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistAttrs: {
+    const created = await servers[1].playlists.create({
+      attributes: {
         displayName: 'playlist without thumbnail',
         privacy: VideoPlaylistPrivacy.PUBLIC,
-        videoChannelId: servers[1].videoChannel.id
+        videoChannelId: servers[1].store.channel.id
       }
     })
-    playlistWithoutThumbnail = res.body.videoPlaylist.id
+    playlistWithoutThumbnailId = created.id
 
-    const res2 = await addVideoInPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithoutThumbnail,
-      elementAttrs: { videoId: video1 }
+    const added = await servers[1].playlists.addElement({
+      playlistId: playlistWithoutThumbnailId,
+      attributes: { videoId: video1 }
     })
-    withoutThumbnailE1 = res2.body.videoPlaylistElement.id
+    withoutThumbnailE1 = added.id
 
     await waitJobs(servers)
 
@@ -99,25 +89,21 @@ describe('Playlist thumbnail', function () {
   it('Should not update the thumbnail if we explicitly uploaded a thumbnail', async function () {
     this.timeout(30000)
 
-    const res = await createVideoPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistAttrs: {
+    const created = await servers[1].playlists.create({
+      attributes: {
         displayName: 'playlist with thumbnail',
         privacy: VideoPlaylistPrivacy.PUBLIC,
-        videoChannelId: servers[1].videoChannel.id,
+        videoChannelId: servers[1].store.channel.id,
         thumbnailfile: 'thumbnail.jpg'
       }
     })
-    playlistWithThumbnail = res.body.videoPlaylist.id
+    playlistWithThumbnailId = created.id
 
-    const res2 = await addVideoInPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithThumbnail,
-      elementAttrs: { videoId: video1 }
+    const added = await servers[1].playlists.addElement({
+      playlistId: playlistWithThumbnailId,
+      attributes: { videoId: video1 }
     })
-    withThumbnailE1 = res2.body.videoPlaylistElement.id
+    withThumbnailE1 = added.id
 
     await waitJobs(servers)
 
@@ -130,19 +116,15 @@ describe('Playlist thumbnail', function () {
   it('Should automatically update the thumbnail when moving the first element', async function () {
     this.timeout(30000)
 
-    const res = await addVideoInPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithoutThumbnail,
-      elementAttrs: { videoId: video2 }
+    const added = await servers[1].playlists.addElement({
+      playlistId: playlistWithoutThumbnailId,
+      attributes: { videoId: video2 }
     })
-    withoutThumbnailE2 = res.body.videoPlaylistElement.id
+    withoutThumbnailE2 = added.id
 
-    await reorderVideosPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithoutThumbnail,
-      elementAttrs: {
+    await servers[1].playlists.reorderElements({
+      playlistId: playlistWithoutThumbnailId,
+      attributes: {
         startPosition: 1,
         insertAfterPosition: 2
       }
@@ -159,19 +141,15 @@ describe('Playlist thumbnail', function () {
   it('Should not update the thumbnail when moving the first element if we explicitly uploaded a thumbnail', async function () {
     this.timeout(30000)
 
-    const res = await addVideoInPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithThumbnail,
-      elementAttrs: { videoId: video2 }
+    const added = await servers[1].playlists.addElement({
+      playlistId: playlistWithThumbnailId,
+      attributes: { videoId: video2 }
     })
-    withThumbnailE2 = res.body.videoPlaylistElement.id
+    withThumbnailE2 = added.id
 
-    await reorderVideosPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithThumbnail,
-      elementAttrs: {
+    await servers[1].playlists.reorderElements({
+      playlistId: playlistWithThumbnailId,
+      attributes: {
         startPosition: 1,
         insertAfterPosition: 2
       }
@@ -188,11 +166,9 @@ describe('Playlist thumbnail', function () {
   it('Should automatically update the thumbnail when deleting the first element', async function () {
     this.timeout(30000)
 
-    await removeVideoFromPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithoutThumbnail,
-      playlistElementId: withoutThumbnailE1
+    await servers[1].playlists.removeElement({
+      playlistId: playlistWithoutThumbnailId,
+      elementId: withoutThumbnailE1
     })
 
     await waitJobs(servers)
@@ -206,11 +182,9 @@ describe('Playlist thumbnail', function () {
   it('Should not update the thumbnail when deleting the first element if we explicitly uploaded a thumbnail', async function () {
     this.timeout(30000)
 
-    await removeVideoFromPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithThumbnail,
-      playlistElementId: withThumbnailE1
+    await servers[1].playlists.removeElement({
+      playlistId: playlistWithThumbnailId,
+      elementId: withThumbnailE1
     })
 
     await waitJobs(servers)
@@ -224,11 +198,9 @@ describe('Playlist thumbnail', function () {
   it('Should the thumbnail when we delete the last element', async function () {
     this.timeout(30000)
 
-    await removeVideoFromPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithoutThumbnail,
-      playlistElementId: withoutThumbnailE2
+    await servers[1].playlists.removeElement({
+      playlistId: playlistWithoutThumbnailId,
+      elementId: withoutThumbnailE2
     })
 
     await waitJobs(servers)
@@ -242,11 +214,9 @@ describe('Playlist thumbnail', function () {
   it('Should not update the thumbnail when we delete the last element if we explicitly uploaded a thumbnail', async function () {
     this.timeout(30000)
 
-    await removeVideoFromPlaylist({
-      url: servers[1].url,
-      token: servers[1].accessToken,
-      playlistId: playlistWithThumbnail,
-      playlistElementId: withThumbnailE2
+    await servers[1].playlists.removeElement({
+      playlistId: playlistWithThumbnailId,
+      elementId: withThumbnailE2
     })
 
     await waitJobs(servers)
diff --git a/server/tests/api/videos/video-playlists.ts b/server/tests/api/videos/video-playlists.ts
index da8de054b..f42aee2ff 100644
--- a/server/tests/api/videos/video-playlists.ts
+++ b/server/tests/api/videos/video-playlists.ts
@@ -2,71 +2,33 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoChannel,
-  addVideoInPlaylist,
-  addVideoToBlacklist,
   checkPlaylistFilesWereRemoved,
   cleanupTests,
-  createUser,
-  createVideoPlaylist,
-  deleteVideoChannel,
-  deleteVideoPlaylist,
+  createMultipleServers,
   doubleFollow,
-  doVideosExistInMyPlaylist,
-  flushAndRunMultipleServers,
-  generateUserAccessToken,
-  getAccessToken,
-  getAccountPlaylistsList,
-  getAccountPlaylistsListWithToken,
-  getMyUserInformation,
-  getPlaylistVideos,
-  getVideoChannelPlaylistsList,
-  getVideoPlaylist,
-  getVideoPlaylistPrivacies,
-  getVideoPlaylistsList,
-  getVideoPlaylistWithToken,
-  removeUser,
-  removeVideoFromBlacklist,
-  removeVideoFromPlaylist,
-  reorderVideosPlaylist,
-  ServerInfo,
+  PeerTubeServer,
+  PlaylistsCommand,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   testImage,
-  unfollow,
-  updateVideo,
-  updateVideoPlaylist,
-  updateVideoPlaylistElement,
-  uploadVideo,
-  uploadVideoAndGetId,
-  userLogin,
   wait,
   waitJobs
-} from '../../../../shared/extra-utils'
+} from '@shared/extra-utils'
 import {
-  addAccountToAccountBlocklist,
-  addAccountToServerBlocklist,
-  addServerToAccountBlocklist,
-  addServerToServerBlocklist,
-  removeAccountFromAccountBlocklist,
-  removeAccountFromServerBlocklist,
-  removeServerFromAccountBlocklist,
-  removeServerFromServerBlocklist
-} from '../../../../shared/extra-utils/users/blocklist'
-import { User } from '../../../../shared/models/users'
-import { VideoPlaylistCreateResult, VideoPrivacy } from '../../../../shared/models/videos'
-import { VideoExistInPlaylist } from '../../../../shared/models/videos/playlist/video-exist-in-playlist.model'
-import { VideoPlaylistElement, VideoPlaylistElementType } from '../../../../shared/models/videos/playlist/video-playlist-element.model'
-import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
-import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
-import { VideoPlaylist } from '../../../../shared/models/videos/playlist/video-playlist.model'
+  HttpStatusCode,
+  VideoPlaylist,
+  VideoPlaylistCreateResult,
+  VideoPlaylistElementType,
+  VideoPlaylistPrivacy,
+  VideoPlaylistType,
+  VideoPrivacy
+} from '@shared/models'
 
 const expect = chai.expect
 
 async function checkPlaylistElementType (
-  servers: ServerInfo[],
+  servers: PeerTubeServer[],
   playlistId: string,
   type: VideoPlaylistElementType,
   position: number,
@@ -74,10 +36,10 @@ async function checkPlaylistElementType (
   total: number
 ) {
   for (const server of servers) {
-    const res = await getPlaylistVideos(server.url, server.accessToken, playlistId, 0, 10)
-    expect(res.body.total).to.equal(total)
+    const body = await server.playlists.listVideos({ token: server.accessToken, playlistId, start: 0, count: 10 })
+    expect(body.total).to.equal(total)
 
-    const videoElement: VideoPlaylistElement = res.body.data.find((e: VideoPlaylistElement) => e.position === position)
+    const videoElement = body.data.find(e => e.position === position)
     expect(videoElement.type).to.equal(type, 'On server ' + server.url)
 
     if (type === VideoPlaylistElementType.REGULAR) {
@@ -90,11 +52,11 @@ async function checkPlaylistElementType (
 }
 
 describe('Test video playlists', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
 
   let playlistServer2Id1: number
   let playlistServer2Id2: number
-  let playlistServer2UUID2: number
+  let playlistServer2UUID2: string
 
   let playlistServer1Id: number
   let playlistServer1UUID: string
@@ -106,12 +68,14 @@ describe('Test video playlists', function () {
 
   let nsfwVideoServer1: number
 
-  let userAccessTokenServer1: string
+  let userTokenServer1: string
+
+  let commands: PlaylistsCommand[]
 
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(3, { transcoding: { enabled: false } })
+    servers = await createMultipleServers(3, { transcoding: { enabled: false } })
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -122,86 +86,78 @@ describe('Test video playlists', function () {
     // Server 1 and server 3 follow each other
     await doubleFollow(servers[0], servers[2])
 
+    commands = servers.map(s => s.playlists)
+
     {
-      servers[0].videos = []
-      servers[1].videos = []
-      servers[2].videos = []
+      servers[0].store.videos = []
+      servers[1].store.videos = []
+      servers[2].store.videos = []
 
       for (const server of servers) {
         for (let i = 0; i < 7; i++) {
           const name = `video ${i} server ${server.serverNumber}`
-          const resVideo = await uploadVideo(server.url, server.accessToken, { name, nsfw: false })
+          const video = await server.videos.upload({ attributes: { name, nsfw: false } })
 
-          server.videos.push(resVideo.body.video)
+          server.store.videos.push(video)
         }
       }
     }
 
-    nsfwVideoServer1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'NSFW video', nsfw: true })).id
+    nsfwVideoServer1 = (await servers[0].videos.quickUpload({ name: 'NSFW video', nsfw: true })).id
 
-    {
-      await createUser({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        username: 'user1',
-        password: 'password'
-      })
-      userAccessTokenServer1 = await getAccessToken(servers[0].url, 'user1', 'password')
-    }
+    userTokenServer1 = await servers[0].users.generateUserAndToken('user1')
 
     await waitJobs(servers)
   })
 
   describe('Get default playlists', function () {
+
     it('Should list video playlist privacies', async function () {
-      const res = await getVideoPlaylistPrivacies(servers[0].url)
+      const privacies = await commands[0].getPrivacies()
 
-      const privacies = res.body
       expect(Object.keys(privacies)).to.have.length.at.least(3)
-
       expect(privacies[3]).to.equal('Private')
     })
 
     it('Should list watch later playlist', async function () {
-      const url = servers[0].url
-      const accessToken = servers[0].accessToken
+      const token = servers[0].accessToken
 
       {
-        const res = await getAccountPlaylistsListWithToken(url, accessToken, 'root', 0, 5, VideoPlaylistType.WATCH_LATER)
+        const body = await commands[0].listByAccount({ token, handle: 'root', playlistType: VideoPlaylistType.WATCH_LATER })
 
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        expect(body.total).to.equal(1)
+        expect(body.data).to.have.lengthOf(1)
 
-        const playlist: VideoPlaylist = res.body.data[0]
+        const playlist = body.data[0]
         expect(playlist.displayName).to.equal('Watch later')
         expect(playlist.type.id).to.equal(VideoPlaylistType.WATCH_LATER)
         expect(playlist.type.label).to.equal('Watch later')
       }
 
       {
-        const res = await getAccountPlaylistsListWithToken(url, accessToken, 'root', 0, 5, VideoPlaylistType.REGULAR)
+        const body = await commands[0].listByAccount({ token, handle: 'root', playlistType: VideoPlaylistType.REGULAR })
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        expect(body.total).to.equal(0)
+        expect(body.data).to.have.lengthOf(0)
       }
 
       {
-        const res = await getAccountPlaylistsList(url, 'root', 0, 5)
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        const body = await commands[0].listByAccount({ handle: 'root' })
+        expect(body.total).to.equal(0)
+        expect(body.data).to.have.lengthOf(0)
       }
     })
 
     it('Should get private playlist for a classic user', async function () {
-      const token = await generateUserAccessToken(servers[0], 'toto')
+      const token = await servers[0].users.generateUserAndToken('toto')
 
-      const res = await getAccountPlaylistsListWithToken(servers[0].url, token, 'toto', 0, 5)
+      const body = await commands[0].listByAccount({ token, handle: 'toto' })
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
 
-      const playlistId = res.body.data[0].id
-      await getPlaylistVideos(servers[0].url, token, playlistId, 0, 5)
+      const playlistId = body.data[0].id
+      await commands[0].listVideos({ token, playlistId })
     })
   })
 
@@ -210,15 +166,13 @@ describe('Test video playlists', function () {
     it('Should create a playlist on server 1 and have the playlist on server 2 and 3', async function () {
       this.timeout(30000)
 
-      await createVideoPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistAttrs: {
+      await commands[0].create({
+        attributes: {
           displayName: 'my super playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
           description: 'my super description',
           thumbnailfile: 'thumbnail.jpg',
-          videoChannelId: servers[0].videoChannel.id
+          videoChannelId: servers[0].store.channel.id
         }
       })
 
@@ -227,14 +181,13 @@ describe('Test video playlists', function () {
       await wait(3000)
 
       for (const server of servers) {
-        const res = await getVideoPlaylistsList(server.url, 0, 5)
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data).to.have.lengthOf(1)
+        const body = await server.playlists.list({ start: 0, count: 5 })
+        expect(body.total).to.equal(1)
+        expect(body.data).to.have.lengthOf(1)
 
-        const playlistFromList = res.body.data[0] as VideoPlaylist
+        const playlistFromList = body.data[0]
 
-        const res2 = await getVideoPlaylist(server.url, playlistFromList.uuid)
-        const playlistFromGet = res2.body as VideoPlaylist
+        const playlistFromGet = await server.playlists.get({ playlistId: playlistFromList.uuid })
 
         for (const playlist of [ playlistFromGet, playlistFromList ]) {
           expect(playlist.id).to.be.a('number')
@@ -264,46 +217,38 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        const res = await createVideoPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
-          playlistAttrs: {
+        const playlist = await servers[1].playlists.create({
+          attributes: {
             displayName: 'playlist 2',
             privacy: VideoPlaylistPrivacy.PUBLIC,
-            videoChannelId: servers[1].videoChannel.id
+            videoChannelId: servers[1].store.channel.id
           }
         })
-        playlistServer2Id1 = res.body.videoPlaylist.id
+        playlistServer2Id1 = playlist.id
       }
 
       {
-        const res = await createVideoPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
-          playlistAttrs: {
+        const playlist = await servers[1].playlists.create({
+          attributes: {
             displayName: 'playlist 3',
             privacy: VideoPlaylistPrivacy.PUBLIC,
             thumbnailfile: 'thumbnail.jpg',
-            videoChannelId: servers[1].videoChannel.id
+            videoChannelId: servers[1].store.channel.id
           }
         })
 
-        playlistServer2Id2 = res.body.videoPlaylist.id
-        playlistServer2UUID2 = res.body.videoPlaylist.uuid
+        playlistServer2Id2 = playlist.id
+        playlistServer2UUID2 = playlist.uuid
       }
 
       for (const id of [ playlistServer2Id1, playlistServer2Id2 ]) {
-        await addVideoInPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
+        await servers[1].playlists.addElement({
           playlistId: id,
-          elementAttrs: { videoId: servers[1].videos[0].id, startTimestamp: 1, stopTimestamp: 2 }
+          attributes: { videoId: servers[1].store.videos[0].id, startTimestamp: 1, stopTimestamp: 2 }
         })
-        await addVideoInPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
+        await servers[1].playlists.addElement({
           playlistId: id,
-          elementAttrs: { videoId: servers[1].videos[1].id }
+          attributes: { videoId: servers[1].store.videos[1].id }
         })
       }
 
@@ -311,20 +256,20 @@ describe('Test video playlists', function () {
       await wait(3000)
 
       for (const server of [ servers[0], servers[1] ]) {
-        const res = await getVideoPlaylistsList(server.url, 0, 5)
+        const body = await server.playlists.list({ start: 0, count: 5 })
 
-        const playlist2 = res.body.data.find(p => p.displayName === 'playlist 2')
+        const playlist2 = body.data.find(p => p.displayName === 'playlist 2')
         expect(playlist2).to.not.be.undefined
         await testImage(server.url, 'thumbnail-playlist', playlist2.thumbnailPath)
 
-        const playlist3 = res.body.data.find(p => p.displayName === 'playlist 3')
+        const playlist3 = body.data.find(p => p.displayName === 'playlist 3')
         expect(playlist3).to.not.be.undefined
         await testImage(server.url, 'thumbnail', playlist3.thumbnailPath)
       }
 
-      const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
-      expect(res.body.data.find(p => p.displayName === 'playlist 2')).to.be.undefined
-      expect(res.body.data.find(p => p.displayName === 'playlist 3')).to.be.undefined
+      const body = await servers[2].playlists.list({ start: 0, count: 5 })
+      expect(body.data.find(p => p.displayName === 'playlist 2')).to.be.undefined
+      expect(body.data.find(p => p.displayName === 'playlist 3')).to.be.undefined
     })
 
     it('Should have the playlist on server 3 after a new follow', async function () {
@@ -333,13 +278,13 @@ describe('Test video playlists', function () {
       // Server 2 and server 3 follow each other
       await doubleFollow(servers[1], servers[2])
 
-      const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
+      const body = await servers[2].playlists.list({ start: 0, count: 5 })
 
-      const playlist2 = res.body.data.find(p => p.displayName === 'playlist 2')
+      const playlist2 = body.data.find(p => p.displayName === 'playlist 2')
       expect(playlist2).to.not.be.undefined
       await testImage(servers[2].url, 'thumbnail-playlist', playlist2.thumbnailPath)
 
-      expect(res.body.data.find(p => p.displayName === 'playlist 3')).to.not.be.undefined
+      expect(body.data.find(p => p.displayName === 'playlist 3')).to.not.be.undefined
     })
   })
 
@@ -349,22 +294,20 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        const res = await getVideoPlaylistsList(servers[2].url, 1, 2, 'createdAt')
-
-        expect(res.body.total).to.equal(3)
+        const body = await servers[2].playlists.list({ start: 1, count: 2, sort: 'createdAt' })
+        expect(body.total).to.equal(3)
 
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(2)
         expect(data[0].displayName).to.equal('playlist 2')
         expect(data[1].displayName).to.equal('playlist 3')
       }
 
       {
-        const res = await getVideoPlaylistsList(servers[2].url, 1, 2, '-createdAt')
+        const body = await servers[2].playlists.list({ start: 1, count: 2, sort: '-createdAt' })
+        expect(body.total).to.equal(3)
 
-        expect(res.body.total).to.equal(3)
-
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(2)
         expect(data[0].displayName).to.equal('playlist 2')
         expect(data[1].displayName).to.equal('my super playlist')
@@ -375,11 +318,10 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        const res = await getVideoChannelPlaylistsList(servers[0].url, 'root_channel', 0, 2, '-createdAt')
-
-        expect(res.body.total).to.equal(1)
+        const body = await commands[0].listByChannel({ handle: 'root_channel', start: 0, count: 2, sort: '-createdAt' })
+        expect(body.total).to.equal(1)
 
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(1)
         expect(data[0].displayName).to.equal('my super playlist')
       }
@@ -389,41 +331,37 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        const res = await getAccountPlaylistsList(servers[1].url, 'root', 1, 2, '-createdAt')
+        const body = await servers[1].playlists.listByAccount({ handle: 'root', start: 1, count: 2, sort: '-createdAt' })
+        expect(body.total).to.equal(2)
 
-        expect(res.body.total).to.equal(2)
-
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(1)
         expect(data[0].displayName).to.equal('playlist 2')
       }
 
       {
-        const res = await getAccountPlaylistsList(servers[1].url, 'root', 1, 2, 'createdAt')
-
-        expect(res.body.total).to.equal(2)
+        const body = await servers[1].playlists.listByAccount({ handle: 'root', start: 1, count: 2, sort: 'createdAt' })
+        expect(body.total).to.equal(2)
 
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(1)
         expect(data[0].displayName).to.equal('playlist 3')
       }
 
       {
-        const res = await getAccountPlaylistsList(servers[1].url, 'root', 0, 10, 'createdAt', '3')
+        const body = await servers[1].playlists.listByAccount({ handle: 'root', sort: 'createdAt', search: '3' })
+        expect(body.total).to.equal(1)
 
-        expect(res.body.total).to.equal(1)
-
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(1)
         expect(data[0].displayName).to.equal('playlist 3')
       }
 
       {
-        const res = await getAccountPlaylistsList(servers[1].url, 'root', 0, 10, 'createdAt', '4')
-
-        expect(res.body.total).to.equal(0)
+        const body = await servers[1].playlists.listByAccount({ handle: 'root', sort: 'createdAt', search: '4' })
+        expect(body.total).to.equal(0)
 
-        const data: VideoPlaylist[] = res.body.data
+        const data = body.data
         expect(data).to.have.lengthOf(0)
       }
     })
@@ -437,28 +375,22 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        const res = await createVideoPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
-          playlistAttrs: {
+        unlistedPlaylist = await servers[1].playlists.create({
+          attributes: {
             displayName: 'playlist unlisted',
             privacy: VideoPlaylistPrivacy.UNLISTED,
-            videoChannelId: servers[1].videoChannel.id
+            videoChannelId: servers[1].store.channel.id
           }
         })
-        unlistedPlaylist = res.body.videoPlaylist
       }
 
       {
-        const res = await createVideoPlaylist({
-          url: servers[1].url,
-          token: servers[1].accessToken,
-          playlistAttrs: {
+        privatePlaylist = await servers[1].playlists.create({
+          attributes: {
             displayName: 'playlist private',
             privacy: VideoPlaylistPrivacy.PRIVATE
           }
         })
-        privatePlaylist = res.body.videoPlaylist
       }
 
       await waitJobs(servers)
@@ -468,15 +400,15 @@ describe('Test video playlists', function () {
     it('Should not list unlisted or private playlists', async function () {
       for (const server of servers) {
         const results = [
-          await getAccountPlaylistsList(server.url, 'root@localhost:' + servers[1].port, 0, 5, '-createdAt'),
-          await getVideoPlaylistsList(server.url, 0, 2, '-createdAt')
+          await server.playlists.listByAccount({ handle: 'root@localhost:' + servers[1].port, sort: '-createdAt' }),
+          await server.playlists.list({ start: 0, count: 2, sort: '-createdAt' })
         ]
 
-        expect(results[0].body.total).to.equal(2)
-        expect(results[1].body.total).to.equal(3)
+        expect(results[0].total).to.equal(2)
+        expect(results[1].total).to.equal(3)
 
-        for (const res of results) {
-          const data: VideoPlaylist[] = res.body.data
+        for (const body of results) {
+          const data = body.data
           expect(data).to.have.lengthOf(2)
           expect(data[0].displayName).to.equal('playlist 3')
           expect(data[1].displayName).to.equal('playlist 2')
@@ -485,23 +417,23 @@ describe('Test video playlists', function () {
     })
 
     it('Should not get unlisted playlist using only the id', async function () {
-      await getVideoPlaylist(servers[1].url, unlistedPlaylist.id, 404)
+      await servers[1].playlists.get({ playlistId: unlistedPlaylist.id, expectedStatus: 404 })
     })
 
     it('Should get unlisted plyaylist using uuid or shortUUID', async function () {
-      await getVideoPlaylist(servers[1].url, unlistedPlaylist.uuid)
-      await getVideoPlaylist(servers[1].url, unlistedPlaylist.shortUUID)
+      await servers[1].playlists.get({ playlistId: unlistedPlaylist.uuid })
+      await servers[1].playlists.get({ playlistId: unlistedPlaylist.shortUUID })
     })
 
     it('Should not get private playlist without token', async function () {
       for (const id of [ privatePlaylist.id, privatePlaylist.uuid, privatePlaylist.shortUUID ]) {
-        await getVideoPlaylist(servers[1].url, id, 401)
+        await servers[1].playlists.get({ playlistId: id, expectedStatus: 401 })
       }
     })
 
     it('Should get private playlist with a token', async function () {
       for (const id of [ privatePlaylist.id, privatePlaylist.uuid, privatePlaylist.shortUUID ]) {
-        await getVideoPlaylistWithToken(servers[1].url, servers[1].accessToken, id)
+        await servers[1].playlists.get({ token: servers[1].accessToken, playlistId: id })
       }
     })
   })
@@ -511,15 +443,13 @@ describe('Test video playlists', function () {
     it('Should update a playlist', async function () {
       this.timeout(30000)
 
-      await updateVideoPlaylist({
-        url: servers[1].url,
-        token: servers[1].accessToken,
-        playlistAttrs: {
+      await servers[1].playlists.update({
+        attributes: {
           displayName: 'playlist 3 updated',
           description: 'description updated',
           privacy: VideoPlaylistPrivacy.UNLISTED,
           thumbnailfile: 'thumbnail.jpg',
-          videoChannelId: servers[1].videoChannel.id
+          videoChannelId: servers[1].store.channel.id
         },
         playlistId: playlistServer2Id2
       })
@@ -527,8 +457,7 @@ describe('Test video playlists', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideoPlaylist(server.url, playlistServer2UUID2)
-        const playlist: VideoPlaylist = res.body
+        const playlist = await server.playlists.get({ playlistId: playlistServer2UUID2 })
 
         expect(playlist.displayName).to.equal('playlist 3 updated')
         expect(playlist.description).to.equal('description updated')
@@ -554,39 +483,37 @@ describe('Test video playlists', function () {
     it('Should create a playlist containing different startTimestamp/endTimestamp videos', async function () {
       this.timeout(30000)
 
-      const addVideo = (elementAttrs: any) => {
-        return addVideoInPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistId: playlistServer1Id, elementAttrs })
+      const addVideo = (attributes: any) => {
+        return commands[0].addElement({ playlistId: playlistServer1Id, attributes })
       }
 
-      const res = await createVideoPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistAttrs: {
+      const playlist = await commands[0].create({
+        attributes: {
           displayName: 'playlist 4',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: servers[0].videoChannel.id
+          videoChannelId: servers[0].store.channel.id
         }
       })
 
-      playlistServer1Id = res.body.videoPlaylist.id
-      playlistServer1UUID = res.body.videoPlaylist.uuid
+      playlistServer1Id = playlist.id
+      playlistServer1UUID = playlist.uuid
 
-      await addVideo({ videoId: servers[0].videos[0].uuid, startTimestamp: 15, stopTimestamp: 28 })
-      await addVideo({ videoId: servers[2].videos[1].uuid, startTimestamp: 35 })
-      await addVideo({ videoId: servers[2].videos[2].uuid })
+      await addVideo({ videoId: servers[0].store.videos[0].uuid, startTimestamp: 15, stopTimestamp: 28 })
+      await addVideo({ videoId: servers[2].store.videos[1].uuid, startTimestamp: 35 })
+      await addVideo({ videoId: servers[2].store.videos[2].uuid })
       {
-        const res = await addVideo({ videoId: servers[0].videos[3].uuid, stopTimestamp: 35 })
-        playlistElementServer1Video4 = res.body.videoPlaylistElement.id
+        const element = await addVideo({ videoId: servers[0].store.videos[3].uuid, stopTimestamp: 35 })
+        playlistElementServer1Video4 = element.id
       }
 
       {
-        const res = await addVideo({ videoId: servers[0].videos[4].uuid, startTimestamp: 45, stopTimestamp: 60 })
-        playlistElementServer1Video5 = res.body.videoPlaylistElement.id
+        const element = await addVideo({ videoId: servers[0].store.videos[4].uuid, startTimestamp: 45, stopTimestamp: 60 })
+        playlistElementServer1Video5 = element.id
       }
 
       {
-        const res = await addVideo({ videoId: nsfwVideoServer1, startTimestamp: 5 })
-        playlistElementNSFW = res.body.videoPlaylistElement.id
+        const element = await addVideo({ videoId: nsfwVideoServer1, startTimestamp: 5 })
+        playlistElementNSFW = element.id
 
         await addVideo({ videoId: nsfwVideoServer1, startTimestamp: 4 })
         await addVideo({ videoId: nsfwVideoServer1 })
@@ -599,64 +526,68 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       for (const server of servers) {
-        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
-
-        expect(res.body.total).to.equal(8)
-
-        const videoElements: VideoPlaylistElement[] = res.body.data
-        expect(videoElements).to.have.lengthOf(8)
-
-        expect(videoElements[0].video.name).to.equal('video 0 server 1')
-        expect(videoElements[0].position).to.equal(1)
-        expect(videoElements[0].startTimestamp).to.equal(15)
-        expect(videoElements[0].stopTimestamp).to.equal(28)
-
-        expect(videoElements[1].video.name).to.equal('video 1 server 3')
-        expect(videoElements[1].position).to.equal(2)
-        expect(videoElements[1].startTimestamp).to.equal(35)
-        expect(videoElements[1].stopTimestamp).to.be.null
-
-        expect(videoElements[2].video.name).to.equal('video 2 server 3')
-        expect(videoElements[2].position).to.equal(3)
-        expect(videoElements[2].startTimestamp).to.be.null
-        expect(videoElements[2].stopTimestamp).to.be.null
-
-        expect(videoElements[3].video.name).to.equal('video 3 server 1')
-        expect(videoElements[3].position).to.equal(4)
-        expect(videoElements[3].startTimestamp).to.be.null
-        expect(videoElements[3].stopTimestamp).to.equal(35)
-
-        expect(videoElements[4].video.name).to.equal('video 4 server 1')
-        expect(videoElements[4].position).to.equal(5)
-        expect(videoElements[4].startTimestamp).to.equal(45)
-        expect(videoElements[4].stopTimestamp).to.equal(60)
-
-        expect(videoElements[5].video.name).to.equal('NSFW video')
-        expect(videoElements[5].position).to.equal(6)
-        expect(videoElements[5].startTimestamp).to.equal(5)
-        expect(videoElements[5].stopTimestamp).to.be.null
-
-        expect(videoElements[6].video.name).to.equal('NSFW video')
-        expect(videoElements[6].position).to.equal(7)
-        expect(videoElements[6].startTimestamp).to.equal(4)
-        expect(videoElements[6].stopTimestamp).to.be.null
-
-        expect(videoElements[7].video.name).to.equal('NSFW video')
-        expect(videoElements[7].position).to.equal(8)
-        expect(videoElements[7].startTimestamp).to.be.null
-        expect(videoElements[7].stopTimestamp).to.be.null
-
-        const res3 = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 2)
-        expect(res3.body.data).to.have.lengthOf(2)
+        {
+          const body = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
+
+          expect(body.total).to.equal(8)
+
+          const videoElements = body.data
+          expect(videoElements).to.have.lengthOf(8)
+
+          expect(videoElements[0].video.name).to.equal('video 0 server 1')
+          expect(videoElements[0].position).to.equal(1)
+          expect(videoElements[0].startTimestamp).to.equal(15)
+          expect(videoElements[0].stopTimestamp).to.equal(28)
+
+          expect(videoElements[1].video.name).to.equal('video 1 server 3')
+          expect(videoElements[1].position).to.equal(2)
+          expect(videoElements[1].startTimestamp).to.equal(35)
+          expect(videoElements[1].stopTimestamp).to.be.null
+
+          expect(videoElements[2].video.name).to.equal('video 2 server 3')
+          expect(videoElements[2].position).to.equal(3)
+          expect(videoElements[2].startTimestamp).to.be.null
+          expect(videoElements[2].stopTimestamp).to.be.null
+
+          expect(videoElements[3].video.name).to.equal('video 3 server 1')
+          expect(videoElements[3].position).to.equal(4)
+          expect(videoElements[3].startTimestamp).to.be.null
+          expect(videoElements[3].stopTimestamp).to.equal(35)
+
+          expect(videoElements[4].video.name).to.equal('video 4 server 1')
+          expect(videoElements[4].position).to.equal(5)
+          expect(videoElements[4].startTimestamp).to.equal(45)
+          expect(videoElements[4].stopTimestamp).to.equal(60)
+
+          expect(videoElements[5].video.name).to.equal('NSFW video')
+          expect(videoElements[5].position).to.equal(6)
+          expect(videoElements[5].startTimestamp).to.equal(5)
+          expect(videoElements[5].stopTimestamp).to.be.null
+
+          expect(videoElements[6].video.name).to.equal('NSFW video')
+          expect(videoElements[6].position).to.equal(7)
+          expect(videoElements[6].startTimestamp).to.equal(4)
+          expect(videoElements[6].stopTimestamp).to.be.null
+
+          expect(videoElements[7].video.name).to.equal('NSFW video')
+          expect(videoElements[7].position).to.equal(8)
+          expect(videoElements[7].startTimestamp).to.be.null
+          expect(videoElements[7].stopTimestamp).to.be.null
+        }
+
+        {
+          const body = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 2 })
+          expect(body.data).to.have.lengthOf(2)
+        }
       }
     })
   })
 
   describe('Element type', function () {
-    let groupUser1: ServerInfo[]
-    let groupWithoutToken1: ServerInfo[]
-    let group1: ServerInfo[]
-    let group2: ServerInfo[]
+    let groupUser1: PeerTubeServer[]
+    let groupWithoutToken1: PeerTubeServer[]
+    let group1: PeerTubeServer[]
+    let group2: PeerTubeServer[]
 
     let video1: string
     let video2: string
@@ -665,31 +596,30 @@ describe('Test video playlists', function () {
     before(async function () {
       this.timeout(60000)
 
-      groupUser1 = [ Object.assign({}, servers[0], { accessToken: userAccessTokenServer1 }) ]
+      groupUser1 = [ Object.assign({}, servers[0], { accessToken: userTokenServer1 }) ]
       groupWithoutToken1 = [ Object.assign({}, servers[0], { accessToken: undefined }) ]
       group1 = [ servers[0] ]
       group2 = [ servers[1], servers[2] ]
 
-      const res = await createVideoPlaylist({
-        url: servers[0].url,
-        token: userAccessTokenServer1,
-        playlistAttrs: {
+      const playlist = await commands[0].create({
+        token: userTokenServer1,
+        attributes: {
           displayName: 'playlist 56',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: servers[0].videoChannel.id
+          videoChannelId: servers[0].store.channel.id
         }
       })
 
-      const playlistServer1Id2 = res.body.videoPlaylist.id
-      playlistServer1UUID2 = res.body.videoPlaylist.uuid
+      const playlistServer1Id2 = playlist.id
+      playlistServer1UUID2 = playlist.uuid
 
-      const addVideo = (elementAttrs: any) => {
-        return addVideoInPlaylist({ url: servers[0].url, token: userAccessTokenServer1, playlistId: playlistServer1Id2, elementAttrs })
+      const addVideo = (attributes: any) => {
+        return commands[0].addElement({ token: userTokenServer1, playlistId: playlistServer1Id2, attributes })
       }
 
-      video1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 89', token: userAccessTokenServer1 })).uuid
-      video2 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video 90' })).uuid
-      video3 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 91', nsfw: true })).uuid
+      video1 = (await servers[0].videos.quickUpload({ name: 'video 89', token: userTokenServer1 })).uuid
+      video2 = (await servers[1].videos.quickUpload({ name: 'video 90' })).uuid
+      video3 = (await servers[0].videos.quickUpload({ name: 'video 91', nsfw: true })).uuid
 
       await waitJobs(servers)
 
@@ -707,7 +637,7 @@ describe('Test video playlists', function () {
       const position = 1
 
       {
-        await updateVideo(servers[0].url, servers[0].accessToken, video1, { privacy: VideoPrivacy.PRIVATE })
+        await servers[0].videos.update({ id: video1, attributes: { privacy: VideoPrivacy.PRIVATE } })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
@@ -717,7 +647,7 @@ describe('Test video playlists', function () {
       }
 
       {
-        await updateVideo(servers[0].url, servers[0].accessToken, video1, { privacy: VideoPrivacy.PUBLIC })
+        await servers[0].videos.update({ id: video1, attributes: { privacy: VideoPrivacy.PUBLIC } })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
@@ -735,7 +665,7 @@ describe('Test video playlists', function () {
       const position = 1
 
       {
-        await addVideoToBlacklist(servers[0].url, servers[0].accessToken, video1, 'reason', true)
+        await servers[0].blacklist.add({ videoId: video1, reason: 'reason', unfederate: true })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
@@ -745,7 +675,7 @@ describe('Test video playlists', function () {
       }
 
       {
-        await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, video1)
+        await servers[0].blacklist.remove({ videoId: video1 })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
@@ -759,56 +689,58 @@ describe('Test video playlists', function () {
     it('Should update the element type if the account or server of the video is blocked', async function () {
       this.timeout(90000)
 
+      const command = servers[0].blocklist
+
       const name = 'video 90'
       const position = 2
 
       {
-        await addAccountToAccountBlocklist(servers[0].url, userAccessTokenServer1, 'root@localhost:' + servers[1].port)
+        await command.addToMyBlocklist({ token: userTokenServer1, account: 'root@localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 
-        await removeAccountFromAccountBlocklist(servers[0].url, userAccessTokenServer1, 'root@localhost:' + servers[1].port)
+        await command.removeFromMyBlocklist({ token: userTokenServer1, account: 'root@localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
       }
 
       {
-        await addServerToAccountBlocklist(servers[0].url, userAccessTokenServer1, 'localhost:' + servers[1].port)
+        await command.addToMyBlocklist({ token: userTokenServer1, server: 'localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 
-        await removeServerFromAccountBlocklist(servers[0].url, userAccessTokenServer1, 'localhost:' + servers[1].port)
+        await command.removeFromMyBlocklist({ token: userTokenServer1, server: 'localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
       }
 
       {
-        await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, 'root@localhost:' + servers[1].port)
+        await command.addToServerBlocklist({ account: 'root@localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 
-        await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, 'root@localhost:' + servers[1].port)
+        await command.removeFromServerBlocklist({ account: 'root@localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
       }
 
       {
-        await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.addToServerBlocklist({ server: 'localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 
-        await removeServerFromServerBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+        await command.removeFromServerBlocklist({ server: 'localhost:' + servers[1].port })
         await waitJobs(servers)
 
         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
@@ -816,10 +748,10 @@ describe('Test video playlists', function () {
     })
 
     it('Should hide the video if it is NSFW', async function () {
-      const res = await getPlaylistVideos(servers[0].url, userAccessTokenServer1, playlistServer1UUID2, 0, 10, { nsfw: false })
-      expect(res.body.total).to.equal(3)
+      const body = await commands[0].listVideos({ token: userTokenServer1, playlistId: playlistServer1UUID2, query: { nsfw: 'false' } })
+      expect(body.total).to.equal(3)
 
-      const elements: VideoPlaylistElement[] = res.body.data
+      const elements = body.data
       const element = elements.find(e => e.position === 3)
 
       expect(element).to.exist
@@ -835,11 +767,9 @@ describe('Test video playlists', function () {
       this.timeout(30000)
 
       {
-        await reorderVideosPlaylist({
-          url: servers[0].url,
-          token: servers[0].accessToken,
+        await commands[0].reorderElements({
           playlistId: playlistServer1Id,
-          elementAttrs: {
+          attributes: {
             startPosition: 2,
             insertAfterPosition: 3
           }
@@ -848,8 +778,8 @@ describe('Test video playlists', function () {
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
-          const names = (res.body.data as VideoPlaylistElement[]).map(v => v.video.name)
+          const body = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
+          const names = body.data.map(v => v.video.name)
 
           expect(names).to.deep.equal([
             'video 0 server 1',
@@ -865,11 +795,9 @@ describe('Test video playlists', function () {
       }
 
       {
-        await reorderVideosPlaylist({
-          url: servers[0].url,
-          token: servers[0].accessToken,
+        await commands[0].reorderElements({
           playlistId: playlistServer1Id,
-          elementAttrs: {
+          attributes: {
             startPosition: 1,
             reorderLength: 3,
             insertAfterPosition: 4
@@ -879,8 +807,8 @@ describe('Test video playlists', function () {
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
-          const names = (res.body.data as VideoPlaylistElement[]).map(v => v.video.name)
+          const body = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
+          const names = body.data.map(v => v.video.name)
 
           expect(names).to.deep.equal([
             'video 3 server 1',
@@ -896,11 +824,9 @@ describe('Test video playlists', function () {
       }
 
       {
-        await reorderVideosPlaylist({
-          url: servers[0].url,
-          token: servers[0].accessToken,
+        await commands[0].reorderElements({
           playlistId: playlistServer1Id,
-          elementAttrs: {
+          attributes: {
             startPosition: 6,
             insertAfterPosition: 3
           }
@@ -909,8 +835,7 @@ describe('Test video playlists', function () {
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
-          const elements: VideoPlaylistElement[] = res.body.data
+          const { data: elements } = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
           const names = elements.map(v => v.video.name)
 
           expect(names).to.deep.equal([
@@ -934,22 +859,18 @@ describe('Test video playlists', function () {
     it('Should update startTimestamp/endTimestamp of some elements', async function () {
       this.timeout(30000)
 
-      await updateVideoPlaylistElement({
-        url: servers[0].url,
-        token: servers[0].accessToken,
+      await commands[0].updateElement({
         playlistId: playlistServer1Id,
-        playlistElementId: playlistElementServer1Video4,
-        elementAttrs: {
+        elementId: playlistElementServer1Video4,
+        attributes: {
           startTimestamp: 1
         }
       })
 
-      await updateVideoPlaylistElement({
-        url: servers[0].url,
-        token: servers[0].accessToken,
+      await commands[0].updateElement({
         playlistId: playlistServer1Id,
-        playlistElementId: playlistElementServer1Video5,
-        elementAttrs: {
+        elementId: playlistElementServer1Video5,
+        attributes: {
           stopTimestamp: null
         }
       })
@@ -957,8 +878,7 @@ describe('Test video playlists', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
-        const elements: VideoPlaylistElement[] = res.body.data
+        const { data: elements } = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
 
         expect(elements[0].video.name).to.equal('video 3 server 1')
         expect(elements[0].position).to.equal(1)
@@ -974,17 +894,16 @@ describe('Test video playlists', function () {
 
     it('Should check videos existence in my playlist', async function () {
       const videoIds = [
-        servers[0].videos[0].id,
+        servers[0].store.videos[0].id,
         42000,
-        servers[0].videos[3].id,
+        servers[0].store.videos[3].id,
         43000,
-        servers[0].videos[4].id
+        servers[0].store.videos[4].id
       ]
-      const res = await doVideosExistInMyPlaylist(servers[0].url, servers[0].accessToken, videoIds)
-      const obj = res.body as VideoExistInPlaylist
+      const obj = await commands[0].videosExist({ videoIds })
 
       {
-        const elem = obj[servers[0].videos[0].id]
+        const elem = obj[servers[0].store.videos[0].id]
         expect(elem).to.have.lengthOf(1)
         expect(elem[0].playlistElementId).to.exist
         expect(elem[0].playlistId).to.equal(playlistServer1Id)
@@ -993,7 +912,7 @@ describe('Test video playlists', function () {
       }
 
       {
-        const elem = obj[servers[0].videos[3].id]
+        const elem = obj[servers[0].store.videos[3].id]
         expect(elem).to.have.lengthOf(1)
         expect(elem[0].playlistElementId).to.equal(playlistElementServer1Video4)
         expect(elem[0].playlistId).to.equal(playlistServer1Id)
@@ -1002,7 +921,7 @@ describe('Test video playlists', function () {
       }
 
       {
-        const elem = obj[servers[0].videos[4].id]
+        const elem = obj[servers[0].store.videos[4].id]
         expect(elem).to.have.lengthOf(1)
         expect(elem[0].playlistId).to.equal(playlistServer1Id)
         expect(elem[0].startTimestamp).to.equal(45)
@@ -1015,42 +934,29 @@ describe('Test video playlists', function () {
 
     it('Should automatically update updatedAt field of playlists', async function () {
       const server = servers[1]
-      const videoId = servers[1].videos[5].id
+      const videoId = servers[1].store.videos[5].id
 
       async function getPlaylistNames () {
-        const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root', 0, 5, undefined, '-updatedAt')
+        const { data } = await server.playlists.listByAccount({ token: server.accessToken, handle: 'root', sort: '-updatedAt' })
 
-        return (res.body.data as VideoPlaylist[]).map(p => p.displayName)
+        return data.map(p => p.displayName)
       }
 
-      const elementAttrs = { videoId }
-      const res1 = await addVideoInPlaylist({ url: server.url, token: server.accessToken, playlistId: playlistServer2Id1, elementAttrs })
-      const res2 = await addVideoInPlaylist({ url: server.url, token: server.accessToken, playlistId: playlistServer2Id2, elementAttrs })
-
-      const element1 = res1.body.videoPlaylistElement.id
-      const element2 = res2.body.videoPlaylistElement.id
+      const attributes = { videoId }
+      const element1 = await server.playlists.addElement({ playlistId: playlistServer2Id1, attributes })
+      const element2 = await server.playlists.addElement({ playlistId: playlistServer2Id2, attributes })
 
       const names1 = await getPlaylistNames()
       expect(names1[0]).to.equal('playlist 3 updated')
       expect(names1[1]).to.equal('playlist 2')
 
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlistServer2Id1,
-        playlistElementId: element1
-      })
+      await server.playlists.removeElement({ playlistId: playlistServer2Id1, elementId: element1.id })
 
       const names2 = await getPlaylistNames()
       expect(names2[0]).to.equal('playlist 2')
       expect(names2[1]).to.equal('playlist 3 updated')
 
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlistServer2Id2,
-        playlistElementId: element2
-      })
+      await server.playlists.removeElement({ playlistId: playlistServer2Id2, elementId: element2.id })
 
       const names3 = await getPlaylistNames()
       expect(names3[0]).to.equal('playlist 3 updated')
@@ -1060,28 +966,16 @@ describe('Test video playlists', function () {
     it('Should delete some elements', async function () {
       this.timeout(30000)
 
-      await removeVideoFromPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistId: playlistServer1Id,
-        playlistElementId: playlistElementServer1Video4
-      })
-
-      await removeVideoFromPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistId: playlistServer1Id,
-        playlistElementId: playlistElementNSFW
-      })
+      await commands[0].removeElement({ playlistId: playlistServer1Id, elementId: playlistElementServer1Video4 })
+      await commands[0].removeElement({ playlistId: playlistServer1Id, elementId: playlistElementNSFW })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+        const body = await server.playlists.listVideos({ playlistId: playlistServer1UUID, start: 0, count: 10 })
+        expect(body.total).to.equal(6)
 
-        expect(res.body.total).to.equal(6)
-
-        const elements: VideoPlaylistElement[] = res.body.data
+        const elements = body.data
         expect(elements).to.have.lengthOf(6)
 
         expect(elements[0].video.name).to.equal('video 0 server 1')
@@ -1107,34 +1001,31 @@ describe('Test video playlists', function () {
     it('Should be able to create a public playlist, and set it to private', async function () {
       this.timeout(30000)
 
-      const res = await createVideoPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistAttrs: {
+      const videoPlaylistIds = await commands[0].create({
+        attributes: {
           displayName: 'my super public playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: servers[0].videoChannel.id
+          videoChannelId: servers[0].store.channel.id
         }
       })
-      const videoPlaylistIds = res.body.videoPlaylist
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        await getVideoPlaylist(server.url, videoPlaylistIds.uuid, HttpStatusCode.OK_200)
+        await server.playlists.get({ playlistId: videoPlaylistIds.uuid, expectedStatus: HttpStatusCode.OK_200 })
       }
 
-      const playlistAttrs = { privacy: VideoPlaylistPrivacy.PRIVATE }
-      await updateVideoPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistId: videoPlaylistIds.id, playlistAttrs })
+      const attributes = { privacy: VideoPlaylistPrivacy.PRIVATE }
+      await commands[0].update({ playlistId: videoPlaylistIds.id, attributes })
 
       await waitJobs(servers)
 
       for (const server of [ servers[1], servers[2] ]) {
-        await getVideoPlaylist(server.url, videoPlaylistIds.uuid, HttpStatusCode.NOT_FOUND_404)
+        await server.playlists.get({ playlistId: videoPlaylistIds.uuid, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
-      await getVideoPlaylist(servers[0].url, videoPlaylistIds.uuid, HttpStatusCode.UNAUTHORIZED_401)
 
-      await getVideoPlaylistWithToken(servers[0].url, servers[0].accessToken, videoPlaylistIds.uuid, HttpStatusCode.OK_200)
+      await commands[0].get({ playlistId: videoPlaylistIds.uuid, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+      await commands[0].get({ token: servers[0].accessToken, playlistId: videoPlaylistIds.uuid, expectedStatus: HttpStatusCode.OK_200 })
     })
   })
 
@@ -1143,12 +1034,12 @@ describe('Test video playlists', function () {
     it('Should delete the playlist on server 1 and delete on server 2 and 3', async function () {
       this.timeout(30000)
 
-      await deleteVideoPlaylist(servers[0].url, servers[0].accessToken, playlistServer1Id)
+      await commands[0].delete({ playlistId: playlistServer1Id })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        await getVideoPlaylist(server.url, playlistServer1UUID, HttpStatusCode.NOT_FOUND_404)
+        await server.playlists.get({ playlistId: playlistServer1UUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
     })
 
@@ -1163,75 +1054,61 @@ describe('Test video playlists', function () {
     it('Should unfollow servers 1 and 2 and hide their playlists', async function () {
       this.timeout(30000)
 
-      const finder = data => data.find(p => p.displayName === 'my super playlist')
+      const finder = (data: VideoPlaylist[]) => data.find(p => p.displayName === 'my super playlist')
 
       {
-        const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
-        expect(res.body.total).to.equal(3)
-        expect(finder(res.body.data)).to.not.be.undefined
+        const body = await servers[2].playlists.list({ start: 0, count: 5 })
+        expect(body.total).to.equal(3)
+
+        expect(finder(body.data)).to.not.be.undefined
       }
 
-      await unfollow(servers[2].url, servers[2].accessToken, servers[0])
+      await servers[2].follows.unfollow({ target: servers[0] })
 
       {
-        const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
-        expect(res.body.total).to.equal(1)
+        const body = await servers[2].playlists.list({ start: 0, count: 5 })
+        expect(body.total).to.equal(1)
 
-        expect(finder(res.body.data)).to.be.undefined
+        expect(finder(body.data)).to.be.undefined
       }
     })
 
     it('Should delete a channel and put the associated playlist in private mode', async function () {
       this.timeout(30000)
 
-      const res = await addVideoChannel(servers[0].url, servers[0].accessToken, { name: 'super_channel', displayName: 'super channel' })
-      const videoChannelId = res.body.videoChannel.id
+      const channel = await servers[0].channels.create({ attributes: { name: 'super_channel', displayName: 'super channel' } })
 
-      const res2 = await createVideoPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistAttrs: {
+      const playlistCreated = await commands[0].create({
+        attributes: {
           displayName: 'channel playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId
+          videoChannelId: channel.id
         }
       })
-      const videoPlaylistUUID = res2.body.videoPlaylist.uuid
 
       await waitJobs(servers)
 
-      await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'super_channel')
+      await servers[0].channels.delete({ channelName: 'super_channel' })
 
       await waitJobs(servers)
 
-      const res3 = await getVideoPlaylistWithToken(servers[0].url, servers[0].accessToken, videoPlaylistUUID)
-      expect(res3.body.displayName).to.equal('channel playlist')
-      expect(res3.body.privacy.id).to.equal(VideoPlaylistPrivacy.PRIVATE)
+      const body = await commands[0].get({ token: servers[0].accessToken, playlistId: playlistCreated.uuid })
+      expect(body.displayName).to.equal('channel playlist')
+      expect(body.privacy.id).to.equal(VideoPlaylistPrivacy.PRIVATE)
 
-      await getVideoPlaylist(servers[1].url, videoPlaylistUUID, HttpStatusCode.NOT_FOUND_404)
+      await servers[1].playlists.get({ playlistId: playlistCreated.uuid, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should delete an account and delete its playlists', async function () {
       this.timeout(30000)
 
-      const user = { username: 'user_1', password: 'password' }
-      const res = await createUser({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        username: user.username,
-        password: user.password
-      })
-
-      const userId = res.body.user.id
-      const userAccessToken = await userLogin(servers[0], user)
+      const { userId, token } = await servers[0].users.generate('user_1')
 
-      const resChannel = await getMyUserInformation(servers[0].url, userAccessToken)
-      const userChannel = (resChannel.body as User).videoChannels[0]
+      const { videoChannels } = await servers[0].users.getMyInfo({ token })
+      const userChannel = videoChannels[0]
 
-      await createVideoPlaylist({
-        url: servers[0].url,
-        token: userAccessToken,
-        playlistAttrs: {
+      await commands[0].create({
+        attributes: {
           displayName: 'playlist to be deleted',
           privacy: VideoPlaylistPrivacy.PUBLIC,
           videoChannelId: userChannel.id
@@ -1240,22 +1117,24 @@ describe('Test video playlists', function () {
 
       await waitJobs(servers)
 
-      const finder = data => data.find(p => p.displayName === 'playlist to be deleted')
+      const finder = (data: VideoPlaylist[]) => data.find(p => p.displayName === 'playlist to be deleted')
 
       {
         for (const server of [ servers[0], servers[1] ]) {
-          const res = await getVideoPlaylistsList(server.url, 0, 15)
-          expect(finder(res.body.data)).to.not.be.undefined
+          const body = await server.playlists.list({ start: 0, count: 15 })
+
+          expect(finder(body.data)).to.not.be.undefined
         }
       }
 
-      await removeUser(servers[0].url, userId, servers[0].accessToken)
+      await servers[0].users.remove({ userId })
       await waitJobs(servers)
 
       {
         for (const server of [ servers[0], servers[1] ]) {
-          const res = await getVideoPlaylistsList(server.url, 0, 15)
-          expect(finder(res.body.data)).to.be.undefined
+          const body = await server.playlists.list({ start: 0, count: 15 })
+
+          expect(finder(body.data)).to.be.undefined
         }
       }
     })
diff --git a/server/tests/api/videos/video-privacy.ts b/server/tests/api/videos/video-privacy.ts
index 950aeb7cf..b51b3bcdd 100644
--- a/server/tests/api/videos/video-privacy.ts
+++ b/server/tests/api/videos/video-privacy.ts
@@ -2,28 +2,13 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
-import { Video, VideoCreateResult } from '@shared/models'
-import {
-  cleanupTests,
-  flushAndRunServer,
-  getVideosList,
-  getVideosListWithToken,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo
-} from '../../../../shared/extra-utils/index'
-import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { userLogin } from '../../../../shared/extra-utils/users/login'
-import { createUser } from '../../../../shared/extra-utils/users/users'
-import { getMyVideos, getVideo, getVideoWithToken, updateVideo } from '../../../../shared/extra-utils/videos/videos'
-import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
+import { cleanupTests, createSingleServer, doubleFollow, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { HttpStatusCode, VideoCreateResult, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test video privacy', function () {
-  const servers: ServerInfo[] = []
+  const servers: PeerTubeServer[] = []
   let anotherUserToken: string
 
   let privateVideoId: number
@@ -49,8 +34,8 @@ describe('Test video privacy', function () {
     this.timeout(50000)
 
     // Run servers
-    servers.push(await flushAndRunServer(1, dontFederateUnlistedConfig))
-    servers.push(await flushAndRunServer(2))
+    servers.push(await createSingleServer(1, dontFederateUnlistedConfig))
+    servers.push(await createSingleServer(2))
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -66,55 +51,53 @@ describe('Test video privacy', function () {
 
       for (const privacy of [ VideoPrivacy.PRIVATE, VideoPrivacy.INTERNAL ]) {
         const attributes = { privacy }
-        await uploadVideo(servers[0].url, servers[0].accessToken, attributes)
+        await servers[0].videos.upload({ attributes })
       }
 
       await waitJobs(servers)
     })
 
     it('Should not have these private and internal videos on server 2', async function () {
-      const res = await getVideosList(servers[1].url)
+      const { total, data } = await servers[1].videos.list()
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(total).to.equal(0)
+      expect(data).to.have.lengthOf(0)
     })
 
     it('Should not list the private and internal videos for an unauthenticated user on server 1', async function () {
-      const res = await getVideosList(servers[0].url)
+      const { total, data } = await servers[0].videos.list()
 
-      expect(res.body.total).to.equal(0)
-      expect(res.body.data).to.have.lengthOf(0)
+      expect(total).to.equal(0)
+      expect(data).to.have.lengthOf(0)
     })
 
     it('Should not list the private video and list the internal video for an authenticated user on server 1', async function () {
-      const res = await getVideosListWithToken(servers[0].url, servers[0].accessToken)
+      const { total, data } = await servers[0].videos.listWithToken()
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
 
-      expect(res.body.data[0].privacy.id).to.equal(VideoPrivacy.INTERNAL)
+      expect(data[0].privacy.id).to.equal(VideoPrivacy.INTERNAL)
     })
 
     it('Should list my (private and internal) videos', async function () {
-      const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 10)
+      const { total, data } = await servers[0].videos.listMyVideos()
 
-      expect(res.body.total).to.equal(2)
-      expect(res.body.data).to.have.lengthOf(2)
+      expect(total).to.equal(2)
+      expect(data).to.have.lengthOf(2)
 
-      const videos: Video[] = res.body.data
-
-      const privateVideo = videos.find(v => v.privacy.id === VideoPrivacy.PRIVATE)
+      const privateVideo = data.find(v => v.privacy.id === VideoPrivacy.PRIVATE)
       privateVideoId = privateVideo.id
       privateVideoUUID = privateVideo.uuid
 
-      const internalVideo = videos.find(v => v.privacy.id === VideoPrivacy.INTERNAL)
+      const internalVideo = data.find(v => v.privacy.id === VideoPrivacy.INTERNAL)
       internalVideoId = internalVideo.id
       internalVideoUUID = internalVideo.uuid
     })
 
     it('Should not be able to watch the private/internal video with non authenticated user', async function () {
-      await getVideo(servers[0].url, privateVideoUUID, HttpStatusCode.UNAUTHORIZED_401)
-      await getVideo(servers[0].url, internalVideoUUID, HttpStatusCode.UNAUTHORIZED_401)
+      await servers[0].videos.get({ id: privateVideoUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+      await servers[0].videos.get({ id: internalVideoUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should not be able to watch the private video with another user', async function () {
@@ -124,18 +107,23 @@ describe('Test video privacy', function () {
         username: 'hello',
         password: 'super password'
       }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+      await servers[0].users.create({ username: user.username, password: user.password })
+
+      anotherUserToken = await servers[0].login.getAccessToken(user)
 
-      anotherUserToken = await userLogin(servers[0], user)
-      await getVideoWithToken(servers[0].url, anotherUserToken, privateVideoUUID, HttpStatusCode.FORBIDDEN_403)
+      await servers[0].videos.getWithToken({
+        token: anotherUserToken,
+        id: privateVideoUUID,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
     })
 
     it('Should be able to watch the internal video with another user', async function () {
-      await getVideoWithToken(servers[0].url, anotherUserToken, internalVideoUUID, HttpStatusCode.OK_200)
+      await servers[0].videos.getWithToken({ token: anotherUserToken, id: internalVideoUUID })
     })
 
     it('Should be able to watch the private video with the correct user', async function () {
-      await getVideoWithToken(servers[0].url, servers[0].accessToken, privateVideoUUID, HttpStatusCode.OK_200)
+      await servers[0].videos.getWithToken({ id: privateVideoUUID })
     })
   })
 
@@ -148,7 +136,7 @@ describe('Test video privacy', function () {
         name: 'unlisted video',
         privacy: VideoPrivacy.UNLISTED
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, attributes)
+      await servers[1].videos.upload({ attributes })
 
       // Server 2 has transcoding enabled
       await waitJobs(servers)
@@ -156,32 +144,32 @@ describe('Test video privacy', function () {
 
     it('Should not have this unlisted video listed on server 1 and 2', async function () {
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { total, data } = await server.videos.list()
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
       }
     })
 
     it('Should list my (unlisted) videos', async function () {
-      const res = await getMyVideos(servers[1].url, servers[1].accessToken, 0, 1)
+      const { total, data } = await servers[1].videos.listMyVideos()
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data).to.have.lengthOf(1)
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
 
-      unlistedVideo = res.body.data[0]
+      unlistedVideo = data[0]
     })
 
     it('Should not be able to get this unlisted video using its id', async function () {
-      await getVideo(servers[1].url, unlistedVideo.id, 404)
+      await servers[1].videos.get({ id: unlistedVideo.id, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should be able to get this unlisted video using its uuid/shortUUID', async function () {
       for (const server of servers) {
         for (const id of [ unlistedVideo.uuid, unlistedVideo.shortUUID ]) {
-          const res = await getVideo(server.url, id)
+          const video = await server.videos.get({ id })
 
-          expect(res.body.name).to.equal('unlisted video')
+          expect(video.name).to.equal('unlisted video')
         }
       }
     })
@@ -193,28 +181,28 @@ describe('Test video privacy', function () {
         name: 'unlisted video',
         privacy: VideoPrivacy.UNLISTED
       }
-      await uploadVideo(servers[0].url, servers[0].accessToken, attributes)
+      await servers[0].videos.upload({ attributes })
 
       await waitJobs(servers)
     })
 
     it('Should list my new unlisted video', async function () {
-      const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 3)
+      const { total, data } = await servers[0].videos.listMyVideos()
 
-      expect(res.body.total).to.equal(3)
-      expect(res.body.data).to.have.lengthOf(3)
+      expect(total).to.equal(3)
+      expect(data).to.have.lengthOf(3)
 
-      nonFederatedUnlistedVideoUUID = res.body.data[0].uuid
+      nonFederatedUnlistedVideoUUID = data[0].uuid
     })
 
     it('Should be able to get non-federated unlisted video from origin', async function () {
-      const res = await getVideo(servers[0].url, nonFederatedUnlistedVideoUUID)
+      const video = await servers[0].videos.get({ id: nonFederatedUnlistedVideoUUID })
 
-      expect(res.body.name).to.equal('unlisted video')
+      expect(video.name).to.equal('unlisted video')
     })
 
     it('Should not be able to get non-federated unlisted video from federated server', async function () {
-      await getVideo(servers[1].url, nonFederatedUnlistedVideoUUID, HttpStatusCode.NOT_FOUND_404)
+      await servers[1].videos.get({ id: nonFederatedUnlistedVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
   })
 
@@ -226,20 +214,20 @@ describe('Test video privacy', function () {
       now = Date.now()
 
       {
-        const attribute = {
+        const attributes = {
           name: 'private video becomes public',
           privacy: VideoPrivacy.PUBLIC
         }
 
-        await updateVideo(servers[0].url, servers[0].accessToken, privateVideoId, attribute)
+        await servers[0].videos.update({ id: privateVideoId, attributes })
       }
 
       {
-        const attribute = {
+        const attributes = {
           name: 'internal video becomes public',
           privacy: VideoPrivacy.PUBLIC
         }
-        await updateVideo(servers[0].url, servers[0].accessToken, internalVideoId, attribute)
+        await servers[0].videos.update({ id: internalVideoId, attributes })
       }
 
       await waitJobs(servers)
@@ -247,13 +235,12 @@ describe('Test video privacy', function () {
 
     it('Should have this new public video listed on server 1 and 2', async function () {
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        expect(res.body.total).to.equal(2)
-        expect(res.body.data).to.have.lengthOf(2)
+        const { total, data } = await server.videos.list()
+        expect(total).to.equal(2)
+        expect(data).to.have.lengthOf(2)
 
-        const videos: Video[] = res.body.data
-        const privateVideo = videos.find(v => v.name === 'private video becomes public')
-        const internalVideo = videos.find(v => v.name === 'internal video becomes public')
+        const privateVideo = data.find(v => v.name === 'private video becomes public')
+        const internalVideo = data.find(v => v.name === 'internal video becomes public')
 
         expect(privateVideo).to.not.be.undefined
         expect(internalVideo).to.not.be.undefined
@@ -270,27 +257,25 @@ describe('Test video privacy', function () {
     it('Should set these videos as private and internal', async function () {
       this.timeout(10000)
 
-      await updateVideo(servers[0].url, servers[0].accessToken, internalVideoId, { privacy: VideoPrivacy.PRIVATE })
-      await updateVideo(servers[0].url, servers[0].accessToken, privateVideoId, { privacy: VideoPrivacy.INTERNAL })
+      await servers[0].videos.update({ id: internalVideoId, attributes: { privacy: VideoPrivacy.PRIVATE } })
+      await servers[0].videos.update({ id: privateVideoId, attributes: { privacy: VideoPrivacy.INTERNAL } })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { total, data } = await server.videos.list()
 
-        expect(res.body.total).to.equal(0)
-        expect(res.body.data).to.have.lengthOf(0)
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
       }
 
       {
-        const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5)
-        const videos = res.body.data
-
-        expect(res.body.total).to.equal(3)
-        expect(videos).to.have.lengthOf(3)
+        const { total, data } = await servers[0].videos.listMyVideos()
+        expect(total).to.equal(3)
+        expect(data).to.have.lengthOf(3)
 
-        const privateVideo = videos.find(v => v.name === 'private video becomes public')
-        const internalVideo = videos.find(v => v.name === 'internal video becomes public')
+        const privateVideo = data.find(v => v.name === 'private video becomes public')
+        const internalVideo = data.find(v => v.name === 'internal video becomes public')
 
         expect(privateVideo).to.not.be.undefined
         expect(internalVideo).to.not.be.undefined
diff --git a/server/tests/api/videos/video-schedule-update.ts b/server/tests/api/videos/video-schedule-update.ts
index 204f43611..3f7738784 100644
--- a/server/tests/api/videos/video-schedule-update.ts
+++ b/server/tests/api/videos/video-schedule-update.ts
@@ -1,22 +1,17 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import { VideoPrivacy } from '../../../../shared/models/videos'
+import * as chai from 'chai'
 import {
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getMyVideos,
-  getVideosList,
-  getVideoWithToken,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateVideo,
-  uploadVideo,
-  wait
-} from '../../../../shared/extra-utils'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
@@ -28,14 +23,14 @@ function in10Seconds () {
 }
 
 describe('Test video update scheduler', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let video2UUID: string
 
   before(async function () {
     this.timeout(30000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
@@ -45,35 +40,34 @@ describe('Test video update scheduler', function () {
   it('Should upload a video and schedule an update in 10 seconds', async function () {
     this.timeout(10000)
 
-    const videoAttributes = {
+    const attributes = {
       name: 'video 1',
       privacy: VideoPrivacy.PRIVATE,
       scheduleUpdate: {
         updateAt: in10Seconds().toISOString(),
-        privacy: VideoPrivacy.PUBLIC
+        privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
       }
     }
 
-    await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+    await servers[0].videos.upload({ attributes })
 
     await waitJobs(servers)
   })
 
   it('Should not list the video (in privacy mode)', async function () {
     for (const server of servers) {
-      const res = await getVideosList(server.url)
+      const { total } = await server.videos.list()
 
-      expect(res.body.total).to.equal(0)
+      expect(total).to.equal(0)
     }
   })
 
   it('Should have my scheduled video in my account videos', async function () {
-    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5)
-    expect(res.body.total).to.equal(1)
+    const { total, data } = await servers[0].videos.listMyVideos()
+    expect(total).to.equal(1)
 
-    const videoFromList = res.body.data[0]
-    const res2 = await getVideoWithToken(servers[0].url, servers[0].accessToken, videoFromList.uuid)
-    const videoFromGet = res2.body
+    const videoFromList = data[0]
+    const videoFromGet = await servers[0].videos.getWithToken({ id: videoFromList.uuid })
 
     for (const video of [ videoFromList, videoFromGet ]) {
       expect(video.name).to.equal('video 1')
@@ -90,23 +84,23 @@ describe('Test video update scheduler', function () {
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
+      const { total, data } = await server.videos.list()
 
-      expect(res.body.total).to.equal(1)
-      expect(res.body.data[0].name).to.equal('video 1')
+      expect(total).to.equal(1)
+      expect(data[0].name).to.equal('video 1')
     }
   })
 
   it('Should upload a video without scheduling an update', async function () {
     this.timeout(10000)
 
-    const videoAttributes = {
+    const attributes = {
       name: 'video 2',
       privacy: VideoPrivacy.PRIVATE
     }
 
-    const res = await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
-    video2UUID = res.body.video.uuid
+    const { uuid } = await servers[0].videos.upload({ attributes })
+    video2UUID = uuid
 
     await waitJobs(servers)
   })
@@ -114,31 +108,31 @@ describe('Test video update scheduler', function () {
   it('Should update a video by scheduling an update', async function () {
     this.timeout(10000)
 
-    const videoAttributes = {
+    const attributes = {
       name: 'video 2 updated',
       scheduleUpdate: {
         updateAt: in10Seconds().toISOString(),
-        privacy: VideoPrivacy.PUBLIC
+        privacy: VideoPrivacy.PUBLIC as VideoPrivacy.PUBLIC
       }
     }
 
-    await updateVideo(servers[0].url, servers[0].accessToken, video2UUID, videoAttributes)
+    await servers[0].videos.update({ id: video2UUID, attributes })
     await waitJobs(servers)
   })
 
   it('Should not display the updated video', async function () {
     for (const server of servers) {
-      const res = await getVideosList(server.url)
+      const { total } = await server.videos.list()
 
-      expect(res.body.total).to.equal(1)
+      expect(total).to.equal(1)
     }
   })
 
   it('Should have my scheduled updated video in my account videos', async function () {
-    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5)
-    expect(res.body.total).to.equal(2)
+    const { total, data } = await servers[0].videos.listMyVideos()
+    expect(total).to.equal(2)
 
-    const video = res.body.data.find(v => v.uuid === video2UUID)
+    const video = data.find(v => v.uuid === video2UUID)
     expect(video).not.to.be.undefined
 
     expect(video.name).to.equal('video 2 updated')
@@ -155,11 +149,10 @@ describe('Test video update scheduler', function () {
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-
-      expect(res.body.total).to.equal(2)
+      const { total, data } = await server.videos.list()
+      expect(total).to.equal(2)
 
-      const video = res.body.data.find(v => v.uuid === video2UUID)
+      const video = data.find(v => v.uuid === video2UUID)
       expect(video).not.to.be.undefined
       expect(video.name).to.equal('video 2 updated')
     }
diff --git a/server/tests/api/videos/video-transcoder.ts b/server/tests/api/videos/video-transcoder.ts
index ea5ffd239..2a09e95bf 100644
--- a/server/tests/api/videos/video-transcoder.ts
+++ b/server/tests/api/videos/video-transcoder.ts
@@ -2,36 +2,23 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { FfprobeData } from 'fluent-ffmpeg'
 import { omit } from 'lodash'
-import { join } from 'path'
-import { Job } from '@shared/models'
-import { VIDEO_TRANSCODING_FPS } from '../../../../server/initializers/constants'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   buildAbsoluteFixturePath,
-  buildServerDirectory,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
   generateHighBitrateVideo,
   generateVideoWithFramerate,
-  getJobsListPaginationAndSort,
-  getMyVideos,
-  getServerFileSize,
-  getVideo,
-  getVideoFileMetadataUrl,
-  getVideosList,
+  getFileSize,
   makeGetRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateCustomSubConfig,
-  uploadVideo,
-  uploadVideoAndGetId,
   waitJobs,
   webtorrentAdd
-} from '../../../../shared/extra-utils'
-import { getMaxBitrate, VideoDetails, VideoResolution, VideoState } from '../../../../shared/models/videos'
+} from '@shared/extra-utils'
+import { getMaxBitrate, HttpStatusCode, VideoResolution, VideoState } from '@shared/models'
+import { VIDEO_TRANSCODING_FPS } from '../../../../server/initializers/constants'
 import {
   canDoQuickTranscode,
   getAudioStream,
@@ -43,37 +30,39 @@ import {
 
 const expect = chai.expect
 
-function updateConfigForTranscoding (server: ServerInfo) {
-  return updateCustomSubConfig(server.url, server.accessToken, {
-    transcoding: {
-      enabled: true,
-      allowAdditionalExtensions: true,
-      allowAudioFiles: true,
-      hls: { enabled: true },
-      webtorrent: { enabled: true },
-      resolutions: {
-        '0p': false,
-        '240p': true,
-        '360p': true,
-        '480p': true,
-        '720p': true,
-        '1080p': true,
-        '1440p': true,
-        '2160p': true
+function updateConfigForTranscoding (server: PeerTubeServer) {
+  return server.config.updateCustomSubConfig({
+    newConfig: {
+      transcoding: {
+        enabled: true,
+        allowAdditionalExtensions: true,
+        allowAudioFiles: true,
+        hls: { enabled: true },
+        webtorrent: { enabled: true },
+        resolutions: {
+          '0p': false,
+          '240p': true,
+          '360p': true,
+          '480p': true,
+          '720p': true,
+          '1080p': true,
+          '1440p': true,
+          '2160p': true
+        }
       }
     }
   })
 }
 
 describe('Test video transcoding', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let video4k: string
 
   before(async function () {
     this.timeout(30_000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
@@ -87,21 +76,20 @@ describe('Test video transcoding', function () {
     it('Should not transcode video on server 1', async function () {
       this.timeout(60_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name for server 1',
         description: 'my super description for server 1',
         fixture: 'video_short.webm'
       }
-      await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+      await servers[0].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        const video = res.body.data[0]
+        const { data } = await server.videos.list()
+        const video = data[0]
 
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails = res2.body
+        const videoDetails = await server.videos.get({ id: video.id })
         expect(videoDetails.files).to.have.lengthOf(1)
 
         const magnetUri = videoDetails.files[0].magnetUri
@@ -117,21 +105,20 @@ describe('Test video transcoding', function () {
     it('Should transcode video on server 2', async function () {
       this.timeout(120_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name for server 2',
         description: 'my super description for server 2',
         fixture: 'video_short.webm'
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails = res2.body
+        const video = data.find(v => v.name === attributes.name)
+        const videoDetails = await server.videos.get({ id: video.id })
 
         expect(videoDetails.files).to.have.lengthOf(4)
 
@@ -150,47 +137,50 @@ describe('Test video transcoding', function () {
 
       {
         // Upload the video, but wait transcoding
-        const videoAttributes = {
+        const attributes = {
           name: 'waiting video',
           fixture: 'video_short1.webm',
           waitTranscoding: true
         }
-        const resVideo = await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
-        const videoId = resVideo.body.video.uuid
+        const { uuid } = await servers[1].videos.upload({ attributes })
+        const videoId = uuid
 
         // Should be in transcode state
-        const { body } = await getVideo(servers[1].url, videoId)
+        const body = await servers[1].videos.get({ id: videoId })
         expect(body.name).to.equal('waiting video')
         expect(body.state.id).to.equal(VideoState.TO_TRANSCODE)
         expect(body.state.label).to.equal('To transcode')
         expect(body.waitTranscoding).to.be.true
 
-        // Should have my video
-        const resMyVideos = await getMyVideos(servers[1].url, servers[1].accessToken, 0, 10)
-        const videoToFindInMine = resMyVideos.body.data.find(v => v.name === videoAttributes.name)
-        expect(videoToFindInMine).not.to.be.undefined
-        expect(videoToFindInMine.state.id).to.equal(VideoState.TO_TRANSCODE)
-        expect(videoToFindInMine.state.label).to.equal('To transcode')
-        expect(videoToFindInMine.waitTranscoding).to.be.true
+        {
+          // Should have my video
+          const { data } = await servers[1].videos.listMyVideos()
+          const videoToFindInMine = data.find(v => v.name === attributes.name)
+          expect(videoToFindInMine).not.to.be.undefined
+          expect(videoToFindInMine.state.id).to.equal(VideoState.TO_TRANSCODE)
+          expect(videoToFindInMine.state.label).to.equal('To transcode')
+          expect(videoToFindInMine.waitTranscoding).to.be.true
+        }
 
-        // Should not list this video
-        const resVideos = await getVideosList(servers[1].url)
-        const videoToFindInList = resVideos.body.data.find(v => v.name === videoAttributes.name)
-        expect(videoToFindInList).to.be.undefined
+        {
+          // Should not list this video
+          const { data } = await servers[1].videos.list()
+          const videoToFindInList = data.find(v => v.name === attributes.name)
+          expect(videoToFindInList).to.be.undefined
+        }
 
         // Server 1 should not have the video yet
-        await getVideo(servers[0].url, videoId, HttpStatusCode.NOT_FOUND_404)
+        await servers[0].videos.get({ id: videoId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        const videoToFind = res.body.data.find(v => v.name === 'waiting video')
+        const { data } = await server.videos.list()
+        const videoToFind = data.find(v => v.name === 'waiting video')
         expect(videoToFind).not.to.be.undefined
 
-        const res2 = await getVideo(server.url, videoToFind.id)
-        const videoDetails: VideoDetails = res2.body
+        const videoDetails = await server.videos.get({ id: videoToFind.id })
 
         expect(videoDetails.state.id).to.equal(VideoState.PUBLISHED)
         expect(videoDetails.state.label).to.equal('Published')
@@ -211,22 +201,20 @@ describe('Test video transcoding', function () {
       }
 
       for (const fixture of [ 'video_short.mkv', 'video_short.avi' ]) {
-        const videoAttributes = {
+        const attributes = {
           name: fixture,
           fixture
         }
 
-        await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+        await servers[1].videos.upload({ attributes })
 
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getVideosList(server.url)
-
-          const video = res.body.data.find(v => v.name === videoAttributes.name)
-          const res2 = await getVideo(server.url, video.id)
-          const videoDetails = res2.body
+          const { data } = await server.videos.list()
 
+          const video = data.find(v => v.name === attributes.name)
+          const videoDetails = await server.videos.get({ id: video.id })
           expect(videoDetails.files).to.have.lengthOf(4)
 
           const magnetUri = videoDetails.files[0].magnetUri
@@ -238,22 +226,20 @@ describe('Test video transcoding', function () {
     it('Should transcode a 4k video', async function () {
       this.timeout(200_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: '4k video',
         fixture: 'video_short_4k.mp4'
       }
 
-      const resUpload = await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
-      video4k = resUpload.body.video.uuid
+      const { uuid } = await servers[1].videos.upload({ attributes })
+      video4k = uuid
 
       await waitJobs(servers)
 
       const resolutions = [ 240, 360, 480, 720, 1080, 1440, 2160 ]
 
       for (const server of servers) {
-        const res = await getVideo(server.url, video4k)
-        const videoDetails: VideoDetails = res.body
-
+        const videoDetails = await server.videos.get({ id: video4k })
         expect(videoDetails.files).to.have.lengthOf(resolutions.length)
 
         for (const r of resolutions) {
@@ -269,24 +255,24 @@ describe('Test video transcoding', function () {
     it('Should transcode high bit rate mp3 to proper bit rate', async function () {
       this.timeout(60_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'mp3_256k',
         fixture: 'video_short_mp3_256k.mp4'
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails: VideoDetails = res2.body
+        const video = data.find(v => v.name === attributes.name)
+        const videoDetails = await server.videos.get({ id: video.id })
 
         expect(videoDetails.files).to.have.lengthOf(4)
 
-        const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-240.mp4'))
+        const file = videoDetails.files.find(f => f.resolution.id === 240)
+        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
         const probe = await getAudioStream(path)
 
         if (probe.audioStream) {
@@ -301,23 +287,23 @@ describe('Test video transcoding', function () {
     it('Should transcode video with no audio and have no audio itself', async function () {
       this.timeout(60_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'no_audio',
         fixture: 'video_short_no_audio.mp4'
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails: VideoDetails = res2.body
+        const video = data.find(v => v.name === attributes.name)
+        const videoDetails = await server.videos.get({ id: video.id })
+
+        const file = videoDetails.files.find(f => f.resolution.id === 240)
+        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
 
-        expect(videoDetails.files).to.have.lengthOf(4)
-        const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-240.mp4'))
         const probe = await getAudioStream(path)
         expect(probe).to.not.have.property('audioStream')
       }
@@ -326,26 +312,27 @@ describe('Test video transcoding', function () {
     it('Should leave the audio untouched, but properly transcode the video', async function () {
       this.timeout(60_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'untouched_audio',
         fixture: 'video_short.mp4'
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails: VideoDetails = res2.body
+        const video = data.find(v => v.name === attributes.name)
+        const videoDetails = await server.videos.get({ id: video.id })
 
         expect(videoDetails.files).to.have.lengthOf(4)
 
-        const fixturePath = buildAbsoluteFixturePath(videoAttributes.fixture)
+        const fixturePath = buildAbsoluteFixturePath(attributes.fixture)
         const fixtureVideoProbe = await getAudioStream(fixturePath)
-        const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-240.mp4'))
+
+        const file = videoDetails.files.find(f => f.resolution.id === 240)
+        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
 
         const videoProbe = await getAudioStream(path)
 
@@ -364,19 +351,21 @@ describe('Test video transcoding', function () {
     function runSuite (mode: 'legacy' | 'resumable') {
 
       before(async function () {
-        await updateCustomSubConfig(servers[1].url, servers[1].accessToken, {
-          transcoding: {
-            hls: { enabled: true },
-            webtorrent: { enabled: true },
-            resolutions: {
-              '0p': false,
-              '240p': false,
-              '360p': false,
-              '480p': false,
-              '720p': false,
-              '1080p': false,
-              '1440p': false,
-              '2160p': false
+        await servers[1].config.updateCustomSubConfig({
+          newConfig: {
+            transcoding: {
+              hls: { enabled: true },
+              webtorrent: { enabled: true },
+              resolutions: {
+                '0p': false,
+                '240p': false,
+                '360p': false,
+                '480p': false,
+                '720p': false,
+                '1080p': false,
+                '1440p': false,
+                '2160p': false
+              }
             }
           }
         })
@@ -385,22 +374,21 @@ describe('Test video transcoding', function () {
       it('Should merge an audio file with the preview file', async function () {
         this.timeout(60_000)
 
-        const videoAttributesArg = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
-        await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributesArg, HttpStatusCode.OK_200, mode)
+        const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
+        await servers[1].videos.upload({ attributes, mode })
 
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getVideosList(server.url)
+          const { data } = await server.videos.list()
 
-          const video = res.body.data.find(v => v.name === 'audio_with_preview')
-          const res2 = await getVideo(server.url, video.id)
-          const videoDetails: VideoDetails = res2.body
+          const video = data.find(v => v.name === 'audio_with_preview')
+          const videoDetails = await server.videos.get({ id: video.id })
 
           expect(videoDetails.files).to.have.lengthOf(1)
 
-          await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, statusCodeExpected: HttpStatusCode.OK_200 })
-          await makeGetRequest({ url: server.url, path: videoDetails.previewPath, statusCodeExpected: HttpStatusCode.OK_200 })
+          await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+          await makeGetRequest({ url: server.url, path: videoDetails.previewPath, expectedStatus: HttpStatusCode.OK_200 })
 
           const magnetUri = videoDetails.files[0].magnetUri
           expect(magnetUri).to.contain('.mp4')
@@ -410,22 +398,21 @@ describe('Test video transcoding', function () {
       it('Should upload an audio file and choose a default background image', async function () {
         this.timeout(60_000)
 
-        const videoAttributesArg = { name: 'audio_without_preview', fixture: 'sample.ogg' }
-        await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributesArg, HttpStatusCode.OK_200, mode)
+        const attributes = { name: 'audio_without_preview', fixture: 'sample.ogg' }
+        await servers[1].videos.upload({ attributes, mode })
 
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res = await getVideosList(server.url)
+          const { data } = await server.videos.list()
 
-          const video = res.body.data.find(v => v.name === 'audio_without_preview')
-          const res2 = await getVideo(server.url, video.id)
-          const videoDetails = res2.body
+          const video = data.find(v => v.name === 'audio_without_preview')
+          const videoDetails = await server.videos.get({ id: video.id })
 
           expect(videoDetails.files).to.have.lengthOf(1)
 
-          await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, statusCodeExpected: HttpStatusCode.OK_200 })
-          await makeGetRequest({ url: server.url, path: videoDetails.previewPath, statusCodeExpected: HttpStatusCode.OK_200 })
+          await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+          await makeGetRequest({ url: server.url, path: videoDetails.previewPath, expectedStatus: HttpStatusCode.OK_200 })
 
           const magnetUri = videoDetails.files[0].magnetUri
           expect(magnetUri).to.contain('.mp4')
@@ -435,26 +422,27 @@ describe('Test video transcoding', function () {
       it('Should upload an audio file and create an audio version only', async function () {
         this.timeout(60_000)
 
-        await updateCustomSubConfig(servers[1].url, servers[1].accessToken, {
-          transcoding: {
-            hls: { enabled: true },
-            webtorrent: { enabled: true },
-            resolutions: {
-              '0p': true,
-              '240p': false,
-              '360p': false
+        await servers[1].config.updateCustomSubConfig({
+          newConfig: {
+            transcoding: {
+              hls: { enabled: true },
+              webtorrent: { enabled: true },
+              resolutions: {
+                '0p': true,
+                '240p': false,
+                '360p': false
+              }
             }
           }
         })
 
-        const videoAttributesArg = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
-        const resVideo = await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributesArg, HttpStatusCode.OK_200, mode)
+        const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
+        const { id } = await servers[1].videos.upload({ attributes, mode })
 
         await waitJobs(servers)
 
         for (const server of servers) {
-          const res2 = await getVideo(server.url, resVideo.body.video.id)
-          const videoDetails: VideoDetails = res2.body
+          const videoDetails = await server.videos.get({ id })
 
           for (const files of [ videoDetails.files, videoDetails.streamingPlaylists[0].files ]) {
             expect(files).to.have.lengthOf(2)
@@ -480,21 +468,20 @@ describe('Test video transcoding', function () {
     it('Should transcode a 60 FPS video', async function () {
       this.timeout(60_000)
 
-      const videoAttributes = {
+      const attributes = {
         name: 'my super 30fps name for server 2',
         description: 'my super 30fps description for server 2',
         fixture: '60fps_720p_small.mp4'
       }
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
-        const res2 = await getVideo(server.url, video.id)
-        const videoDetails: VideoDetails = res2.body
+        const video = data.find(v => v.name === attributes.name)
+        const videoDetails = await server.videos.get({ id: video.id })
 
         expect(videoDetails.files).to.have.lengthOf(4)
         expect(videoDetails.files[0].fps).to.be.above(58).and.below(62)
@@ -502,14 +489,16 @@ describe('Test video transcoding', function () {
         expect(videoDetails.files[2].fps).to.be.below(31)
         expect(videoDetails.files[3].fps).to.be.below(31)
 
-        for (const resolution of [ '240', '360', '480' ]) {
-          const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-' + resolution + '.mp4'))
+        for (const resolution of [ 240, 360, 480 ]) {
+          const file = videoDetails.files.find(f => f.resolution.id === resolution)
+          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
           const fps = await getVideoFileFPS(path)
 
           expect(fps).to.be.below(31)
         }
 
-        const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-720.mp4'))
+        const file = videoDetails.files.find(f => f.resolution.id === 720)
+        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
         const fps = await getVideoFileFPS(path)
 
         expect(fps).to.be.above(58).and.below(62)
@@ -528,29 +517,32 @@ describe('Test video transcoding', function () {
         expect(fps).to.be.equal(59)
       }
 
-      const videoAttributes = {
+      const attributes = {
         name: '59fps video',
         description: '59fps video',
         fixture: tempFixturePath
       }
 
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
+        const { id } = data.find(v => v.name === attributes.name)
+        const video = await server.videos.get({ id })
 
         {
-          const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-240.mp4'))
+          const file = video.files.find(f => f.resolution.id === 240)
+          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
           const fps = await getVideoFileFPS(path)
           expect(fps).to.be.equal(25)
         }
 
         {
-          const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-720.mp4'))
+          const file = video.files.find(f => f.resolution.id === 720)
+          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
           const fps = await getVideoFileFPS(path)
           expect(fps).to.be.equal(59)
         }
@@ -559,6 +551,7 @@ describe('Test video transcoding', function () {
   })
 
   describe('Bitrate control', function () {
+
     it('Should respect maximum bitrate values', async function () {
       this.timeout(160_000)
 
@@ -571,30 +564,32 @@ describe('Test video transcoding', function () {
         expect(bitrate).to.be.above(getMaxBitrate(VideoResolution.H_1080P, 25, VIDEO_TRANSCODING_FPS))
       }
 
-      const videoAttributes = {
+      const attributes = {
         name: 'high bitrate video',
         description: 'high bitrate video',
         fixture: tempFixturePath
       }
 
-      await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+      await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
+        const { data } = await server.videos.list()
 
-        const video = res.body.data.find(v => v.name === videoAttributes.name)
+        const { id } = data.find(v => v.name === attributes.name)
+        const video = await server.videos.get({ id })
 
-        for (const resolution of [ '240', '360', '480', '720', '1080' ]) {
-          const path = buildServerDirectory(servers[1], join('videos', video.uuid + '-' + resolution + '.mp4'))
+        for (const resolution of [ 240, 360, 480, 720, 1080 ]) {
+          const file = video.files.find(f => f.resolution.id === resolution)
+          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
 
           const bitrate = await getVideoFileBitrate(path)
           const fps = await getVideoFileFPS(path)
-          const resolution2 = await getVideoFileResolution(path)
+          const { videoFileResolution } = await getVideoFileResolution(path)
 
-          expect(resolution2.videoFileResolution.toString()).to.equal(resolution)
-          expect(bitrate).to.be.below(getMaxBitrate(resolution2.videoFileResolution, fps, VIDEO_TRANSCODING_FPS))
+          expect(videoFileResolution).to.equal(resolution)
+          expect(bitrate).to.be.below(getMaxBitrate(videoFileResolution, fps, VIDEO_TRANSCODING_FPS))
         }
       }
     })
@@ -602,7 +597,7 @@ describe('Test video transcoding', function () {
     it('Should not transcode to an higher bitrate than the original file', async function () {
       this.timeout(160_000)
 
-      const config = {
+      const newConfig = {
         transcoding: {
           enabled: true,
           resolutions: {
@@ -618,22 +613,25 @@ describe('Test video transcoding', function () {
           hls: { enabled: true }
         }
       }
-      await updateCustomSubConfig(servers[1].url, servers[1].accessToken, config)
+      await servers[1].config.updateCustomSubConfig({ newConfig })
 
-      const videoAttributes = {
+      const attributes = {
         name: 'low bitrate',
         fixture: 'low-bitrate.mp4'
       }
 
-      const resUpload = await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
-      const videoUUID = resUpload.body.video.uuid
+      const { id } = await servers[1].videos.upload({ attributes })
 
       await waitJobs(servers)
 
+      const video = await servers[1].videos.get({ id })
+
       const resolutions = [ 240, 360, 480, 720, 1080 ]
       for (const r of resolutions) {
-        const path = `videos/${videoUUID}-${r}.mp4`
-        const size = await getServerFileSize(servers[1], path)
+        const file = video.files.find(f => f.resolution.id === r)
+
+        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const size = await getFileSize(path)
         expect(size, `${path} not below ${60_000}`).to.be.below(60_000)
       }
     })
@@ -644,11 +642,13 @@ describe('Test video transcoding', function () {
     it('Should provide valid ffprobe data', async function () {
       this.timeout(160_000)
 
-      const videoUUID = (await uploadVideoAndGetId({ server: servers[1], videoName: 'ffprobe data' })).uuid
+      const videoUUID = (await servers[1].videos.quickUpload({ name: 'ffprobe data' })).uuid
       await waitJobs(servers)
 
       {
-        const path = buildServerDirectory(servers[1], join('videos', videoUUID + '-240.mp4'))
+        const video = await servers[1].videos.get({ id: videoUUID })
+        const file = video.files.find(f => f.resolution.id === 240)
+        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
         const metadata = await getMetadataFromFile(path)
 
         // expected format properties
@@ -678,8 +678,7 @@ describe('Test video transcoding', function () {
       }
 
       for (const server of servers) {
-        const res2 = await getVideo(server.url, videoUUID)
-        const videoDetails: VideoDetails = res2.body
+        const videoDetails = await server.videos.get({ id: videoUUID })
 
         const videoFiles = videoDetails.files
                                       .concat(videoDetails.streamingPlaylists[0].files)
@@ -691,8 +690,7 @@ describe('Test video transcoding', function () {
           expect(file.metadataUrl).to.contain(servers[1].url)
           expect(file.metadataUrl).to.contain(videoUUID)
 
-          const res3 = await getVideoFileMetadataUrl(file.metadataUrl)
-          const metadata: FfprobeData = res3.body
+          const metadata = await server.videos.getFileMetadata({ url: file.metadataUrl })
           expect(metadata).to.have.nested.property('format.size')
         }
       }
@@ -709,17 +707,14 @@ describe('Test video transcoding', function () {
   describe('Transcoding job queue', function () {
 
     it('Should have the appropriate priorities for transcoding jobs', async function () {
-      const res = await getJobsListPaginationAndSort({
-        url: servers[1].url,
-        accessToken: servers[1].accessToken,
+      const body = await servers[1].jobs.getJobsList({
         start: 0,
         count: 100,
         sort: '-createdAt',
         jobType: 'video-transcoding'
       })
 
-      const jobs = res.body.data as Job[]
-
+      const jobs = body.data
       const transcodingJobs = jobs.filter(j => j.data.videoUUID === video4k)
 
       expect(transcodingJobs).to.have.lengthOf(14)
diff --git a/server/tests/api/videos/videos-filter.ts b/server/tests/api/videos/videos-filter.ts
index 7428b82c5..2306807bf 100644
--- a/server/tests/api/videos/videos-filter.ts
+++ b/server/tests/api/videos/videos-filter.ts
@@ -1,25 +1,18 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import { expect } from 'chai'
 import {
   cleanupTests,
-  createUser,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
   makeGetRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo,
-  userLogin
-} from '../../../../shared/extra-utils'
-import { Video, VideoPrivacy } from '../../../../shared/models/videos'
-import { UserRole } from '../../../../shared/models/users'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-
-const expect = chai.expect
-
-async function getVideosNames (server: ServerInfo, token: string, filter: string, statusCodeExpected = HttpStatusCode.OK_200) {
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode, UserRole, Video, VideoPrivacy } from '@shared/models'
+
+async function getVideosNames (server: PeerTubeServer, token: string, filter: string, expectedStatus = HttpStatusCode.OK_200) {
   const paths = [
     '/api/v1/video-channels/root_channel/videos',
     '/api/v1/accounts/root/videos',
@@ -38,7 +31,7 @@ async function getVideosNames (server: ServerInfo, token: string, filter: string
         sort: 'createdAt',
         filter
       },
-      statusCodeExpected
+      expectedStatus
     })
 
     videosResults.push(res.body.data.map(v => v.name))
@@ -48,42 +41,32 @@ async function getVideosNames (server: ServerInfo, token: string, filter: string
 }
 
 describe('Test videos filter', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(160000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
     for (const server of servers) {
       const moderator = { username: 'moderator', password: 'my super password' }
-      await createUser(
-        {
-          url: server.url,
-          accessToken: server.accessToken,
-          username: moderator.username,
-          password: moderator.password,
-          videoQuota: undefined,
-          videoQuotaDaily: undefined,
-          role: UserRole.MODERATOR
-        }
-      )
-      server['moderatorAccessToken'] = await userLogin(server, moderator)
+      await server.users.create({ username: moderator.username, password: moderator.password, role: UserRole.MODERATOR })
+      server['moderatorAccessToken'] = await server.login.getAccessToken(moderator)
 
-      await uploadVideo(server.url, server.accessToken, { name: 'public ' + server.serverNumber })
+      await server.videos.upload({ attributes: { name: 'public ' + server.serverNumber } })
 
       {
         const attributes = { name: 'unlisted ' + server.serverNumber, privacy: VideoPrivacy.UNLISTED }
-        await uploadVideo(server.url, server.accessToken, attributes)
+        await server.videos.upload({ attributes })
       }
 
       {
         const attributes = { name: 'private ' + server.serverNumber, privacy: VideoPrivacy.PRIVATE }
-        await uploadVideo(server.url, server.accessToken, attributes)
+        await server.videos.upload({ attributes })
       }
     }
 
diff --git a/server/tests/api/videos/videos-history.ts b/server/tests/api/videos/videos-history.ts
index b25cff879..e4bc0bb3a 100644
--- a/server/tests/api/videos/videos-history.ts
+++ b/server/tests/api/videos/videos-history.ts
@@ -1,74 +1,66 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
   cleanupTests,
-  createUser,
-  flushAndRunServer,
-  getVideosListWithToken,
-  getVideoWithToken,
+  createSingleServer,
+  HistoryCommand,
   killallServers,
-  reRunServer,
-  searchVideoWithToken,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateMyUser,
-  uploadVideo,
-  userLogin,
   wait
-} from '../../../../shared/extra-utils'
-import { Video, VideoDetails } from '../../../../shared/models/videos'
-import { listMyVideosHistory, removeMyVideosHistory, userWatchVideo } from '../../../../shared/extra-utils/videos/video-history'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+} from '@shared/extra-utils'
+import { HttpStatusCode, Video } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test videos history', function () {
-  let server: ServerInfo = null
+  let server: PeerTubeServer = null
   let video1UUID: string
   let video2UUID: string
   let video3UUID: string
   let video3WatchedDate: Date
   let userAccessToken: string
+  let command: HistoryCommand
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
 
+    command = server.history
+
     {
-      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 1' })
-      video1UUID = res.body.video.uuid
+      const { uuid } = await server.videos.upload({ attributes: { name: 'video 1' } })
+      video1UUID = uuid
     }
 
     {
-      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
-      video2UUID = res.body.video.uuid
+      const { uuid } = await server.videos.upload({ attributes: { name: 'video 2' } })
+      video2UUID = uuid
     }
 
     {
-      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 3' })
-      video3UUID = res.body.video.uuid
+      const { uuid } = await server.videos.upload({ attributes: { name: 'video 3' } })
+      video3UUID = uuid
     }
 
     const user = {
       username: 'user_1',
       password: 'super password'
     }
-    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
-    userAccessToken = await userLogin(server, user)
+    await server.users.create({ username: user.username, password: user.password })
+    userAccessToken = await server.login.getAccessToken(user)
   })
 
   it('Should get videos, without watching history', async function () {
-    const res = await getVideosListWithToken(server.url, server.accessToken)
-    const videos: Video[] = res.body.data
+    const { data } = await server.videos.listWithToken()
 
-    for (const video of videos) {
-      const resDetail = await getVideoWithToken(server.url, server.accessToken, video.id)
-      const videoDetails: VideoDetails = resDetail.body
+    for (const video of data) {
+      const videoDetails = await server.videos.getWithToken({ id: video.id })
 
       expect(video.userHistory).to.be.undefined
       expect(videoDetails.userHistory).to.be.undefined
@@ -76,21 +68,21 @@ describe('Test videos history', function () {
   })
 
   it('Should watch the first and second video', async function () {
-    await userWatchVideo(server.url, server.accessToken, video2UUID, 8)
-    await userWatchVideo(server.url, server.accessToken, video1UUID, 3)
+    await command.wathVideo({ videoId: video2UUID, currentTime: 8 })
+    await command.wathVideo({ videoId: video1UUID, currentTime: 3 })
   })
 
   it('Should return the correct history when listing, searching and getting videos', async function () {
     const videosOfVideos: Video[][] = []
 
     {
-      const res = await getVideosListWithToken(server.url, server.accessToken)
-      videosOfVideos.push(res.body.data)
+      const { data } = await server.videos.listWithToken()
+      videosOfVideos.push(data)
     }
 
     {
-      const res = await searchVideoWithToken(server.url, 'video', server.accessToken)
-      videosOfVideos.push(res.body.data)
+      const body = await server.search.searchVideos({ token: server.accessToken, search: 'video' })
+      videosOfVideos.push(body.data)
     }
 
     for (const videos of videosOfVideos) {
@@ -108,24 +100,21 @@ describe('Test videos history', function () {
     }
 
     {
-      const resDetail = await getVideoWithToken(server.url, server.accessToken, video1UUID)
-      const videoDetails: VideoDetails = resDetail.body
+      const videoDetails = await server.videos.getWithToken({ id: video1UUID })
 
       expect(videoDetails.userHistory).to.not.be.undefined
       expect(videoDetails.userHistory.currentTime).to.equal(3)
     }
 
     {
-      const resDetail = await getVideoWithToken(server.url, server.accessToken, video2UUID)
-      const videoDetails: VideoDetails = resDetail.body
+      const videoDetails = await server.videos.getWithToken({ id: video2UUID })
 
       expect(videoDetails.userHistory).to.not.be.undefined
       expect(videoDetails.userHistory.currentTime).to.equal(8)
     }
 
     {
-      const resDetail = await getVideoWithToken(server.url, server.accessToken, video3UUID)
-      const videoDetails: VideoDetails = resDetail.body
+      const videoDetails = await server.videos.getWithToken({ id: video3UUID })
 
       expect(videoDetails.userHistory).to.be.undefined
     }
@@ -133,71 +122,64 @@ describe('Test videos history', function () {
 
   it('Should have these videos when listing my history', async function () {
     video3WatchedDate = new Date()
-    await userWatchVideo(server.url, server.accessToken, video3UUID, 2)
+    await command.wathVideo({ videoId: video3UUID, currentTime: 2 })
 
-    const res = await listMyVideosHistory(server.url, server.accessToken)
+    const body = await command.list()
 
-    expect(res.body.total).to.equal(3)
+    expect(body.total).to.equal(3)
 
-    const videos: Video[] = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('video 3')
     expect(videos[1].name).to.equal('video 1')
     expect(videos[2].name).to.equal('video 2')
   })
 
   it('Should not have videos history on another user', async function () {
-    const res = await listMyVideosHistory(server.url, userAccessToken)
+    const body = await command.list({ token: userAccessToken })
 
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.have.lengthOf(0)
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
   })
 
   it('Should be able to search through videos in my history', async function () {
-    const res = await listMyVideosHistory(server.url, server.accessToken, '2')
-
-    expect(res.body.total).to.equal(1)
+    const body = await command.list({ search: '2' })
+    expect(body.total).to.equal(1)
 
-    const videos: Video[] = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('video 2')
   })
 
   it('Should clear my history', async function () {
-    await removeMyVideosHistory(server.url, server.accessToken, video3WatchedDate.toISOString())
+    await command.remove({ beforeDate: video3WatchedDate.toISOString() })
   })
 
   it('Should have my history cleared', async function () {
-    const res = await listMyVideosHistory(server.url, server.accessToken)
+    const body = await command.list()
+    expect(body.total).to.equal(1)
 
-    expect(res.body.total).to.equal(1)
-
-    const videos: Video[] = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('video 3')
   })
 
   it('Should disable videos history', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: server.accessToken,
+    await server.users.updateMe({
       videosHistoryEnabled: false
     })
 
-    await userWatchVideo(server.url, server.accessToken, video2UUID, 8, HttpStatusCode.CONFLICT_409)
+    await command.wathVideo({ videoId: video2UUID, currentTime: 8, expectedStatus: HttpStatusCode.CONFLICT_409 })
   })
 
   it('Should re-enable videos history', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: server.accessToken,
+    await server.users.updateMe({
       videosHistoryEnabled: true
     })
 
-    await userWatchVideo(server.url, server.accessToken, video1UUID, 8)
-
-    const res = await listMyVideosHistory(server.url, server.accessToken)
+    await command.wathVideo({ videoId: video1UUID, currentTime: 8 })
 
-    expect(res.body.total).to.equal(2)
+    const body = await command.list()
+    expect(body.total).to.equal(2)
 
-    const videos: Video[] = res.body.data
+    const videos = body.data
     expect(videos[0].name).to.equal('video 1')
     expect(videos[1].name).to.equal('video 3')
   })
@@ -205,30 +187,29 @@ describe('Test videos history', function () {
   it('Should not clean old history', async function () {
     this.timeout(50000)
 
-    killallServers([ server ])
+    await killallServers([ server ])
 
-    await reRunServer(server, { history: { videos: { max_age: '10 days' } } })
+    await server.run({ history: { videos: { max_age: '10 days' } } })
 
     await wait(6000)
 
     // Should still have history
 
-    const res = await listMyVideosHistory(server.url, server.accessToken)
-
-    expect(res.body.total).to.equal(2)
+    const body = await command.list()
+    expect(body.total).to.equal(2)
   })
 
   it('Should clean old history', async function () {
     this.timeout(50000)
 
-    killallServers([ server ])
+    await killallServers([ server ])
 
-    await reRunServer(server, { history: { videos: { max_age: '5 seconds' } } })
+    await server.run({ history: { videos: { max_age: '5 seconds' } } })
 
     await wait(6000)
 
-    const res = await listMyVideosHistory(server.url, server.accessToken)
-    expect(res.body.total).to.equal(0)
+    const body = await command.list()
+    expect(body.total).to.equal(0)
   })
 
   after(async function () {
diff --git a/server/tests/api/videos/videos-overview.ts b/server/tests/api/videos/videos-overview.ts
index c266a1dc5..70aa66549 100644
--- a/server/tests/api/videos/videos-overview.ts
+++ b/server/tests/api/videos/videos-overview.ts
@@ -2,29 +2,15 @@
 
 import 'mocha'
 import * as chai from 'chai'
-
-import {
-  cleanupTests,
-  flushAndRunServer,
-  generateUserAccessToken,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo,
-  wait
-} from '../../../../shared/extra-utils'
-import { getVideosOverview, getVideosOverviewWithToken } from '../../../../shared/extra-utils/overviews/overviews'
-import { VideosOverview } from '../../../../shared/models/overviews'
-import { addAccountToAccountBlocklist } from '@shared/extra-utils/users/blocklist'
-import { Response } from 'superagent'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers, wait } from '@shared/extra-utils'
+import { VideosOverview } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test a videos overview', function () {
-  let server: ServerInfo = null
-
-  function testOverviewCount (res: Response, expected: number) {
-    const overview: VideosOverview = res.body
+  let server: PeerTubeServer = null
 
+  function testOverviewCount (overview: VideosOverview, expected: number) {
     expect(overview.tags).to.have.lengthOf(expected)
     expect(overview.categories).to.have.lengthOf(expected)
     expect(overview.channels).to.have.lengthOf(expected)
@@ -33,15 +19,15 @@ describe('Test a videos overview', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
 
     await setAccessTokensToServers([ server ])
   })
 
   it('Should send empty overview', async function () {
-    const res = await getVideosOverview(server.url, 1)
+    const body = await server.overviews.getVideos({ page: 1 })
 
-    testOverviewCount(res, 0)
+    testOverviewCount(body, 0)
   })
 
   it('Should upload 5 videos in a specific category, tag and channel but not include them in overview', async function () {
@@ -49,40 +35,45 @@ describe('Test a videos overview', function () {
 
     await wait(3000)
 
-    await uploadVideo(server.url, server.accessToken, {
-      name: 'video 0',
-      category: 3,
-      tags: [ 'coucou1', 'coucou2' ]
+    await server.videos.upload({
+      attributes: {
+        name: 'video 0',
+        category: 3,
+        tags: [ 'coucou1', 'coucou2' ]
+      }
     })
 
-    const res = await getVideosOverview(server.url, 1)
+    const body = await server.overviews.getVideos({ page: 1 })
 
-    testOverviewCount(res, 0)
+    testOverviewCount(body, 0)
   })
 
   it('Should upload another video and include all videos in the overview', async function () {
     this.timeout(30000)
 
-    for (let i = 1; i < 6; i++) {
-      await uploadVideo(server.url, server.accessToken, {
-        name: 'video ' + i,
-        category: 3,
-        tags: [ 'coucou1', 'coucou2' ]
-      })
+    {
+      for (let i = 1; i < 6; i++) {
+        await server.videos.upload({
+          attributes: {
+            name: 'video ' + i,
+            category: 3,
+            tags: [ 'coucou1', 'coucou2' ]
+          }
+        })
+      }
+
+      await wait(3000)
     }
 
-    await wait(3000)
-
     {
-      const res = await getVideosOverview(server.url, 1)
+      const body = await server.overviews.getVideos({ page: 1 })
 
-      testOverviewCount(res, 1)
+      testOverviewCount(body, 1)
     }
 
     {
-      const res = await getVideosOverview(server.url, 2)
+      const overview = await server.overviews.getVideos({ page: 2 })
 
-      const overview: VideosOverview = res.body
       expect(overview.tags).to.have.lengthOf(1)
       expect(overview.categories).to.have.lengthOf(0)
       expect(overview.channels).to.have.lengthOf(0)
@@ -90,20 +81,10 @@ describe('Test a videos overview', function () {
   })
 
   it('Should have the correct overview', async function () {
-    const res1 = await getVideosOverview(server.url, 1)
-    const res2 = await getVideosOverview(server.url, 2)
-
-    const overview1: VideosOverview = res1.body
-    const overview2: VideosOverview = res2.body
-
-    const tmp = [
-      overview1.tags,
-      overview1.categories,
-      overview1.channels,
-      overview2.tags
-    ]
+    const overview1 = await server.overviews.getVideos({ page: 1 })
+    const overview2 = await server.overviews.getVideos({ page: 2 })
 
-    for (const arr of tmp) {
+    for (const arr of [ overview1.tags, overview1.categories, overview1.channels, overview2.tags ]) {
       expect(arr).to.have.lengthOf(1)
 
       const obj = arr[0]
@@ -127,20 +108,20 @@ describe('Test a videos overview', function () {
   })
 
   it('Should hide muted accounts', async function () {
-    const token = await generateUserAccessToken(server, 'choco')
+    const token = await server.users.generateUserAndToken('choco')
 
-    await addAccountToAccountBlocklist(server.url, token, 'root@' + server.host)
+    await server.blocklist.addToMyBlocklist({ token, account: 'root@' + server.host })
 
     {
-      const res = await getVideosOverview(server.url, 1)
+      const body = await server.overviews.getVideos({ page: 1 })
 
-      testOverviewCount(res, 1)
+      testOverviewCount(body, 1)
     }
 
     {
-      const res = await getVideosOverviewWithToken(server.url, 1, token)
+      const body = await server.overviews.getVideos({ page: 1, token })
 
-      testOverviewCount(res, 0)
+      testOverviewCount(body, 0)
     }
   })
 
diff --git a/server/tests/api/videos/videos-views-cleaner.ts b/server/tests/api/videos/videos-views-cleaner.ts
index b89f33217..82268b1be 100644
--- a/server/tests/api/videos/videos-views-cleaner.ts
+++ b/server/tests/api/videos/videos-views-cleaner.ts
@@ -1,19 +1,14 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import {
   cleanupTests,
-  closeAllSequelize,
-  countVideoViewsOf,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
   killallServers,
-  reRunServer,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  uploadVideoAndGetId,
-  viewVideo,
   wait,
   waitJobs
 } from '../../../../shared/extra-utils'
@@ -21,7 +16,7 @@ import {
 const expect = chai.expect
 
 describe('Test video views cleaner', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
 
   let videoIdServer1: string
   let videoIdServer2: string
@@ -29,20 +24,20 @@ describe('Test video views cleaner', function () {
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     await doubleFollow(servers[0], servers[1])
 
-    videoIdServer1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video server 1' })).uuid
-    videoIdServer2 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video server 2' })).uuid
+    videoIdServer1 = (await servers[0].videos.quickUpload({ name: 'video server 1' })).uuid
+    videoIdServer2 = (await servers[1].videos.quickUpload({ name: 'video server 2' })).uuid
 
     await waitJobs(servers)
 
-    await viewVideo(servers[0].url, videoIdServer1)
-    await viewVideo(servers[1].url, videoIdServer1)
-    await viewVideo(servers[0].url, videoIdServer2)
-    await viewVideo(servers[1].url, videoIdServer2)
+    await servers[0].videos.view({ id: videoIdServer1 })
+    await servers[1].videos.view({ id: videoIdServer1 })
+    await servers[0].videos.view({ id: videoIdServer2 })
+    await servers[1].videos.view({ id: videoIdServer2 })
 
     await waitJobs(servers)
   })
@@ -50,9 +45,9 @@ describe('Test video views cleaner', function () {
   it('Should not clean old video views', async function () {
     this.timeout(50000)
 
-    killallServers([ servers[0] ])
+    await killallServers([ servers[0] ])
 
-    await reRunServer(servers[0], { views: { videos: { remote: { max_age: '10 days' } } } })
+    await servers[0].run({ views: { videos: { remote: { max_age: '10 days' } } } })
 
     await wait(6000)
 
@@ -60,14 +55,14 @@ describe('Test video views cleaner', function () {
 
     {
       for (const server of servers) {
-        const total = await countVideoViewsOf(server.internalServerNumber, videoIdServer1)
+        const total = await server.sql.countVideoViewsOf(videoIdServer1)
         expect(total).to.equal(2, 'Server ' + server.serverNumber + ' does not have the correct amount of views')
       }
     }
 
     {
       for (const server of servers) {
-        const total = await countVideoViewsOf(server.internalServerNumber, videoIdServer2)
+        const total = await server.sql.countVideoViewsOf(videoIdServer2)
         expect(total).to.equal(2, 'Server ' + server.serverNumber + ' does not have the correct amount of views')
       }
     }
@@ -76,9 +71,9 @@ describe('Test video views cleaner', function () {
   it('Should clean old video views', async function () {
     this.timeout(50000)
 
-    killallServers([ servers[0] ])
+    await killallServers([ servers[0] ])
 
-    await reRunServer(servers[0], { views: { videos: { remote: { max_age: '5 seconds' } } } })
+    await servers[0].run({ views: { videos: { remote: { max_age: '5 seconds' } } } })
 
     await wait(6000)
 
@@ -86,23 +81,21 @@ describe('Test video views cleaner', function () {
 
     {
       for (const server of servers) {
-        const total = await countVideoViewsOf(server.internalServerNumber, videoIdServer1)
+        const total = await server.sql.countVideoViewsOf(videoIdServer1)
         expect(total).to.equal(2)
       }
     }
 
     {
-      const totalServer1 = await countVideoViewsOf(servers[0].internalServerNumber, videoIdServer2)
+      const totalServer1 = await servers[0].sql.countVideoViewsOf(videoIdServer2)
       expect(totalServer1).to.equal(0)
 
-      const totalServer2 = await countVideoViewsOf(servers[1].internalServerNumber, videoIdServer2)
+      const totalServer2 = await servers[1].sql.countVideoViewsOf(videoIdServer2)
       expect(totalServer2).to.equal(2)
     }
   })
 
   after(async function () {
-    await closeAllSequelize(servers)
-
     await cleanupTests(servers)
   })
 })
diff --git a/server/tests/cli/create-import-video-file-job.ts b/server/tests/cli/create-import-video-file-job.ts
index 49758ff56..bddcff5e7 100644
--- a/server/tests/cli/create-import-video-file-job.ts
+++ b/server/tests/cli/create-import-video-file-job.ts
@@ -2,21 +2,8 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { VideoFile } from '@shared/models/videos/video-file.model'
-import {
-  cleanupTests,
-  doubleFollow,
-  execCLI,
-  flushAndRunMultipleServers,
-  getEnvCli,
-  getVideo,
-  getVideosList,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo
-} from '../../../shared/extra-utils'
-import { waitJobs } from '../../../shared/extra-utils/server/jobs'
-import { VideoDetails } from '../../../shared/models/videos'
+import { cleanupTests, createMultipleServers, doubleFollow, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { VideoFile } from '@shared/models'
 
 const expect = chai.expect
 
@@ -33,7 +20,7 @@ function assertVideoProperties (video: VideoFile, resolution: number, extname: s
 describe('Test create import video jobs', function () {
   this.timeout(60000)
 
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let video1UUID: string
   let video2UUID: string
 
@@ -41,56 +28,61 @@ describe('Test create import video jobs', function () {
     this.timeout(90000)
 
     // Run server 2 to have transcoding enabled
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     await doubleFollow(servers[0], servers[1])
 
     // Upload two videos for our needs
-    const res1 = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video1' })
-    video1UUID = res1.body.video.uuid
-    const res2 = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video2' })
-    video2UUID = res2.body.video.uuid
+    {
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video1' } })
+      video1UUID = uuid
+    }
+
+    {
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video2' } })
+      video2UUID = uuid
+    }
 
     // Transcoding
     await waitJobs(servers)
   })
 
   it('Should run a import job on video 1 with a lower resolution', async function () {
-    const env = getEnvCli(servers[0])
-    await execCLI(`${env} npm run create-import-video-file-job -- -v ${video1UUID} -i server/tests/fixtures/video_short-480.webm`)
+    const command = `npm run create-import-video-file-job -- -v ${video1UUID} -i server/tests/fixtures/video_short-480.webm`
+    await servers[0].cli.execWithEnv(command)
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const { data: videos } = (await getVideosList(server.url)).body
+      const { data: videos } = await server.videos.list()
       expect(videos).to.have.lengthOf(2)
 
       const video = videos.find(({ uuid }) => uuid === video1UUID)
-      const videoDetail: VideoDetails = (await getVideo(server.url, video.uuid)).body
+      const videoDetails = await server.videos.get({ id: video.uuid })
 
-      expect(videoDetail.files).to.have.lengthOf(2)
-      const [ originalVideo, transcodedVideo ] = videoDetail.files
+      expect(videoDetails.files).to.have.lengthOf(2)
+      const [ originalVideo, transcodedVideo ] = videoDetails.files
       assertVideoProperties(originalVideo, 720, 'webm', 218910)
       assertVideoProperties(transcodedVideo, 480, 'webm', 69217)
     }
   })
 
   it('Should run a import job on video 2 with the same resolution and a different extension', async function () {
-    const env = getEnvCli(servers[1])
-    await execCLI(`${env} npm run create-import-video-file-job -- -v ${video2UUID} -i server/tests/fixtures/video_short.ogv`)
+    const command = `npm run create-import-video-file-job -- -v ${video2UUID} -i server/tests/fixtures/video_short.ogv`
+    await servers[1].cli.execWithEnv(command)
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const { data: videos } = (await getVideosList(server.url)).body
+      const { data: videos } = await server.videos.list()
       expect(videos).to.have.lengthOf(2)
 
       const video = videos.find(({ uuid }) => uuid === video2UUID)
-      const videoDetail: VideoDetails = (await getVideo(server.url, video.uuid)).body
+      const videoDetails = await server.videos.get({ id: video.uuid })
 
-      expect(videoDetail.files).to.have.lengthOf(4)
-      const [ originalVideo, transcodedVideo420, transcodedVideo320, transcodedVideo240 ] = videoDetail.files
+      expect(videoDetails.files).to.have.lengthOf(4)
+      const [ originalVideo, transcodedVideo420, transcodedVideo320, transcodedVideo240 ] = videoDetails.files
       assertVideoProperties(originalVideo, 720, 'ogv', 140849)
       assertVideoProperties(transcodedVideo420, 480, 'mp4')
       assertVideoProperties(transcodedVideo320, 360, 'mp4')
@@ -99,20 +91,20 @@ describe('Test create import video jobs', function () {
   })
 
   it('Should run a import job on video 2 with the same resolution and the same extension', async function () {
-    const env = getEnvCli(servers[0])
-    await execCLI(`${env} npm run create-import-video-file-job -- -v ${video1UUID} -i server/tests/fixtures/video_short2.webm`)
+    const command = `npm run create-import-video-file-job -- -v ${video1UUID} -i server/tests/fixtures/video_short2.webm`
+    await servers[0].cli.execWithEnv(command)
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const { data: videos } = (await getVideosList(server.url)).body
+      const { data: videos } = await server.videos.list()
       expect(videos).to.have.lengthOf(2)
 
       const video = videos.find(({ uuid }) => uuid === video1UUID)
-      const videoDetail: VideoDetails = (await getVideo(server.url, video.uuid)).body
+      const videoDetails = await server.videos.get({ id: video.uuid })
 
-      expect(videoDetail.files).to.have.lengthOf(2)
-      const [ video720, video480 ] = videoDetail.files
+      expect(videoDetails.files).to.have.lengthOf(2)
+      const [ video720, video480 ] = videoDetails.files
       assertVideoProperties(video720, 720, 'webm', 942961)
       assertVideoProperties(video480, 480, 'webm', 69217)
     }
diff --git a/server/tests/cli/create-transcoding-job.ts b/server/tests/cli/create-transcoding-job.ts
index 5bc1687cd..df787ccdc 100644
--- a/server/tests/cli/create-transcoding-job.ts
+++ b/server/tests/cli/create-transcoding-job.ts
@@ -2,26 +2,19 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { VideoDetails } from '../../../shared/models/videos'
 import {
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  execCLI,
-  flushAndRunMultipleServers,
-  getEnvCli,
-  getVideo,
-  getVideosList,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateCustomSubConfig,
-  uploadVideo
+  waitJobs
 } from '../../../shared/extra-utils'
-import { waitJobs } from '../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
 describe('Test create transcoding jobs', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   const videosUUID: string[] = []
 
   const config = {
@@ -46,16 +39,16 @@ describe('Test create transcoding jobs', function () {
     this.timeout(60000)
 
     // Run server 2 to have transcoding enabled
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
+    await servers[0].config.updateCustomSubConfig({ newConfig: config })
 
     await doubleFollow(servers[0], servers[1])
 
     for (let i = 1; i <= 5; i++) {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video' + i })
-      videosUUID.push(res.body.video.uuid)
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video' + i } })
+      videosUUID.push(uuid)
     }
 
     await waitJobs(servers)
@@ -65,13 +58,11 @@ describe('Test create transcoding jobs', function () {
     this.timeout(30000)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      const videos = res.body.data
-      expect(videos).to.have.lengthOf(videosUUID.length)
+      const { data } = await server.videos.list()
+      expect(data).to.have.lengthOf(videosUUID.length)
 
-      for (const video of videos) {
-        const res2 = await getVideo(server.url, video.uuid)
-        const videoDetail: VideoDetails = res2.body
+      for (const video of data) {
+        const videoDetail = await server.videos.get({ id: video.uuid })
         expect(videoDetail.files).to.have.lengthOf(1)
         expect(videoDetail.streamingPlaylists).to.have.lengthOf(0)
       }
@@ -81,20 +72,16 @@ describe('Test create transcoding jobs', function () {
   it('Should run a transcoding job on video 2', async function () {
     this.timeout(60000)
 
-    const env = getEnvCli(servers[0])
-    await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[1]}`)
-
+    await servers[0].cli.execWithEnv(`npm run create-transcoding-job -- -v ${videosUUID[1]}`)
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      const videos = res.body.data
+      const { data } = await server.videos.list()
 
       let infoHashes: { [id: number]: string }
 
-      for (const video of videos) {
-        const res2 = await getVideo(server.url, video.uuid)
-        const videoDetail: VideoDetails = res2.body
+      for (const video of data) {
+        const videoDetail = await server.videos.get({ id: video.uuid })
 
         if (video.uuid === videosUUID[1]) {
           expect(videoDetail.files).to.have.lengthOf(4)
@@ -123,43 +110,38 @@ describe('Test create transcoding jobs', function () {
   it('Should run a transcoding job on video 1 with resolution', async function () {
     this.timeout(60000)
 
-    const env = getEnvCli(servers[0])
-    await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[0]} -r 480`)
+    await servers[0].cli.execWithEnv(`npm run create-transcoding-job -- -v ${videosUUID[0]} -r 480`)
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      const videos = res.body.data
-      expect(videos).to.have.lengthOf(videosUUID.length)
+      const { data } = await server.videos.list()
+      expect(data).to.have.lengthOf(videosUUID.length)
 
-      const res2 = await getVideo(server.url, videosUUID[0])
-      const videoDetail: VideoDetails = res2.body
+      const videoDetails = await server.videos.get({ id: videosUUID[0] })
 
-      expect(videoDetail.files).to.have.lengthOf(2)
-      expect(videoDetail.files[0].resolution.id).to.equal(720)
-      expect(videoDetail.files[1].resolution.id).to.equal(480)
+      expect(videoDetails.files).to.have.lengthOf(2)
+      expect(videoDetails.files[0].resolution.id).to.equal(720)
+      expect(videoDetails.files[1].resolution.id).to.equal(480)
 
-      expect(videoDetail.streamingPlaylists).to.have.lengthOf(0)
+      expect(videoDetails.streamingPlaylists).to.have.lengthOf(0)
     }
   })
 
   it('Should generate an HLS resolution', async function () {
     this.timeout(120000)
 
-    const env = getEnvCli(servers[0])
-    await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[2]} --generate-hls -r 480`)
+    await servers[0].cli.execWithEnv(`npm run create-transcoding-job -- -v ${videosUUID[2]} --generate-hls -r 480`)
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videosUUID[2])
-      const videoDetail: VideoDetails = res.body
+      const videoDetails = await server.videos.get({ id: videosUUID[2] })
 
-      expect(videoDetail.files).to.have.lengthOf(1)
-      expect(videoDetail.streamingPlaylists).to.have.lengthOf(1)
+      expect(videoDetails.files).to.have.lengthOf(1)
+      expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
 
-      const files = videoDetail.streamingPlaylists[0].files
+      const files = videoDetails.streamingPlaylists[0].files
       expect(files).to.have.lengthOf(1)
       expect(files[0].resolution.id).to.equal(480)
     }
@@ -168,16 +150,14 @@ describe('Test create transcoding jobs', function () {
   it('Should not duplicate an HLS resolution', async function () {
     this.timeout(120000)
 
-    const env = getEnvCli(servers[0])
-    await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[2]} --generate-hls -r 480`)
+    await servers[0].cli.execWithEnv(`npm run create-transcoding-job -- -v ${videosUUID[2]} --generate-hls -r 480`)
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videosUUID[2])
-      const videoDetail: VideoDetails = res.body
+      const videoDetails = await server.videos.get({ id: videosUUID[2] })
 
-      const files = videoDetail.streamingPlaylists[0].files
+      const files = videoDetails.streamingPlaylists[0].files
       expect(files).to.have.lengthOf(1)
       expect(files[0].resolution.id).to.equal(480)
     }
@@ -186,19 +166,17 @@ describe('Test create transcoding jobs', function () {
   it('Should generate all HLS resolutions', async function () {
     this.timeout(120000)
 
-    const env = getEnvCli(servers[0])
-    await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[3]} --generate-hls`)
+    await servers[0].cli.execWithEnv(`npm run create-transcoding-job -- -v ${videosUUID[3]} --generate-hls`)
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videosUUID[3])
-      const videoDetail: VideoDetails = res.body
+      const videoDetails = await server.videos.get({ id: videosUUID[3] })
 
-      expect(videoDetail.files).to.have.lengthOf(1)
-      expect(videoDetail.streamingPlaylists).to.have.lengthOf(1)
+      expect(videoDetails.files).to.have.lengthOf(1)
+      expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
 
-      const files = videoDetail.streamingPlaylists[0].files
+      const files = videoDetails.streamingPlaylists[0].files
       expect(files).to.have.lengthOf(4)
     }
   })
@@ -207,20 +185,18 @@ describe('Test create transcoding jobs', function () {
     this.timeout(120000)
 
     config.transcoding.hls.enabled = true
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
+    await servers[0].config.updateCustomSubConfig({ newConfig: config })
 
-    const env = getEnvCli(servers[0])
-    await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[4]}`)
+    await servers[0].cli.execWithEnv(`npm run create-transcoding-job -- -v ${videosUUID[4]}`)
 
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideo(server.url, videosUUID[4])
-      const videoDetail: VideoDetails = res.body
+      const videoDetails = await server.videos.get({ id: videosUUID[4] })
 
-      expect(videoDetail.files).to.have.lengthOf(4)
-      expect(videoDetail.streamingPlaylists).to.have.lengthOf(1)
-      expect(videoDetail.streamingPlaylists[0].files).to.have.lengthOf(4)
+      expect(videoDetails.files).to.have.lengthOf(4)
+      expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
+      expect(videoDetails.streamingPlaylists[0].files).to.have.lengthOf(4)
     }
   })
 
diff --git a/server/tests/cli/optimize-old-videos.ts b/server/tests/cli/optimize-old-videos.ts
index 91a1c9cc4..579b2e7d8 100644
--- a/server/tests/cli/optimize-old-videos.ts
+++ b/server/tests/cli/optimize-old-videos.ts
@@ -2,38 +2,30 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { join } from 'path'
 import {
-  buildServerDirectory,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  execCLI,
-  flushAndRunMultipleServers,
   generateHighBitrateVideo,
-  getEnvCli,
-  getVideo,
-  getVideosList,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  uploadVideo,
-  viewVideo,
-  wait
-} from '../../../shared/extra-utils'
-import { waitJobs } from '../../../shared/extra-utils/server/jobs'
-import { getMaxBitrate, Video, VideoDetails, VideoResolution } from '../../../shared/models/videos'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { getMaxBitrate, VideoResolution } from '@shared/models'
 import { getVideoFileBitrate, getVideoFileFPS, getVideoFileResolution } from '../../helpers/ffprobe-utils'
 import { VIDEO_TRANSCODING_FPS } from '../../initializers/constants'
 
 const expect = chai.expect
 
 describe('Test optimize old videos', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
 
   before(async function () {
     this.timeout(200000)
 
     // Run server 2 to have transcoding enabled
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     await doubleFollow(servers[0], servers[1])
@@ -48,8 +40,8 @@ describe('Test optimize old videos', function () {
     }
 
     // Upload two videos for our needs
-    await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video1', fixture: tempFixturePath })
-    await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video2', fixture: tempFixturePath })
+    await servers[0].videos.upload({ attributes: { name: 'video1', fixture: tempFixturePath } })
+    await servers[0].videos.upload({ attributes: { name: 'video2', fixture: tempFixturePath } })
 
     await waitJobs(servers)
   })
@@ -58,14 +50,12 @@ describe('Test optimize old videos', function () {
     this.timeout(30000)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      const videos = res.body.data
-      expect(videos).to.have.lengthOf(2)
-
-      for (const video of videos) {
-        const res2 = await getVideo(server.url, video.uuid)
-        const videoDetail: VideoDetails = res2.body
-        expect(videoDetail.files).to.have.lengthOf(1)
+      const { data } = await server.videos.list()
+      expect(data).to.have.lengthOf(2)
+
+      for (const video of data) {
+        const videoDetails = await server.videos.get({ id: video.uuid })
+        expect(videoDetails.files).to.have.lengthOf(1)
       }
     }
   })
@@ -73,34 +63,29 @@ describe('Test optimize old videos', function () {
   it('Should run optimize script', async function () {
     this.timeout(200000)
 
-    const env = getEnvCli(servers[0])
-    await execCLI(`${env} npm run optimize-old-videos`)
-
+    await servers[0].cli.execWithEnv('npm run optimize-old-videos')
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      const videos: Video[] = res.body.data
-
-      expect(videos).to.have.lengthOf(2)
+      const { data } = await server.videos.list()
+      expect(data).to.have.lengthOf(2)
 
-      for (const video of videos) {
-        await viewVideo(server.url, video.uuid)
+      for (const video of data) {
+        await server.videos.view({ id: video.uuid })
 
         // Refresh video
         await waitJobs(servers)
         await wait(5000)
         await waitJobs(servers)
 
-        const res2 = await getVideo(server.url, video.uuid)
-        const videosDetails: VideoDetails = res2.body
+        const videoDetails = await server.videos.get({ id: video.uuid })
 
-        expect(videosDetails.files).to.have.lengthOf(1)
-        const file = videosDetails.files[0]
+        expect(videoDetails.files).to.have.lengthOf(1)
+        const file = videoDetails.files[0]
 
         expect(file.size).to.be.below(8000000)
 
-        const path = buildServerDirectory(servers[0], join('videos', video.uuid + '-' + file.resolution.id + '.mp4'))
+        const path = servers[0].servers.buildWebTorrentFilePath(file.fileUrl)
         const bitrate = await getVideoFileBitrate(path)
         const fps = await getVideoFileFPS(path)
         const resolution = await getVideoFileResolution(path)
diff --git a/server/tests/cli/peertube.ts b/server/tests/cli/peertube.ts
index fcf7e2e2e..f2a984962 100644
--- a/server/tests/cli/peertube.ts
+++ b/server/tests/cli/peertube.ts
@@ -2,97 +2,91 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import { Video, VideoDetails } from '../../../shared'
 import {
-  addVideoChannel,
   areHttpImportTestsDisabled,
   buildAbsoluteFixturePath,
   cleanupTests,
-  createUser,
+  CLICommand,
+  createSingleServer,
   doubleFollow,
-  execCLI,
-  flushAndRunServer,
-  getEnvCli,
-  getLocalIdByUUID,
-  getVideo,
-  getVideosList,
-  removeVideo,
-  ServerInfo,
+  FIXTURE_URLS,
+  PeerTubeServer,
   setAccessTokensToServers,
   testHelloWorldRegisteredSettings,
-  uploadVideoAndGetId,
-  userLogin,
   waitJobs
 } from '../../../shared/extra-utils'
-import { getYoutubeVideoUrl } from '../../../shared/extra-utils/videos/video-imports'
 
 describe('Test CLI wrapper', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let userAccessToken: string
 
+  let cliCommand: CLICommand
+
   const cmd = 'node ./dist/server/tools/peertube.js'
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
-    await createUser({ url: server.url, accessToken: server.accessToken, username: 'user_1', password: 'super_password' })
+    await server.users.create({ username: 'user_1', password: 'super_password' })
 
-    userAccessToken = await userLogin(server, { username: 'user_1', password: 'super_password' })
+    userAccessToken = await server.login.getAccessToken({ username: 'user_1', password: 'super_password' })
 
     {
-      const args = { name: 'user_channel', displayName: 'User channel', support: 'super support text' }
-      await addVideoChannel(server.url, userAccessToken, args)
+      const attributes = { name: 'user_channel', displayName: 'User channel', support: 'super support text' }
+      await server.channels.create({ token: userAccessToken, attributes })
     }
+
+    cliCommand = server.cli
   })
 
   describe('Authentication and instance selection', function () {
 
+    it('Should get an access token', async function () {
+      const stdout = await cliCommand.execWithEnv(`${cmd} token --url ${server.url} --username user_1 --password super_password`)
+      const token = stdout.trim()
+
+      const body = await server.users.getMyInfo({ token })
+      expect(body.username).to.equal('user_1')
+    })
+
     it('Should display no selected instance', async function () {
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-      const stdout = await execCLI(`${env} ${cmd} --help`)
-
+      const stdout = await cliCommand.execWithEnv(`${cmd} --help`)
       expect(stdout).to.contain('no instance selected')
     })
 
     it('Should add a user', async function () {
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-      await execCLI(`${env} ${cmd} auth add -u ${server.url} -U user_1 -p super_password`)
+      await cliCommand.execWithEnv(`${cmd} auth add -u ${server.url} -U user_1 -p super_password`)
     })
 
     it('Should not fail to add a user if there is a slash at the end of the instance URL', async function () {
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-      let fullServerURL
-      fullServerURL = server.url + '/'
-      await execCLI(`${env} ${cmd} auth add -u ${fullServerURL} -U user_1 -p super_password`)
+      let fullServerURL = server.url + '/'
+
+      await cliCommand.execWithEnv(`${cmd} auth add -u ${fullServerURL} -U user_1 -p super_password`)
 
       fullServerURL = server.url + '/asdfasdf'
-      await execCLI(`${env} ${cmd} auth add -u ${fullServerURL} -U user_1 -p super_password`)
+      await cliCommand.execWithEnv(`${cmd} auth add -u ${fullServerURL} -U user_1 -p super_password`)
     })
 
     it('Should default to this user', async function () {
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-      const stdout = await execCLI(`${env} ${cmd} --help`)
-
+      const stdout = await cliCommand.execWithEnv(`${cmd} --help`)
       expect(stdout).to.contain(`instance ${server.url} selected`)
     })
 
     it('Should remember the user', async function () {
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-      const stdout = await execCLI(`${env} ${cmd} auth list`)
-
+      const stdout = await cliCommand.execWithEnv(`${cmd} auth list`)
       expect(stdout).to.contain(server.url)
     })
   })
@@ -102,24 +96,17 @@ describe('Test CLI wrapper', function () {
     it('Should upload a video', async function () {
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-
       const fixture = buildAbsoluteFixturePath('60fps_720p_small.mp4')
-
       const params = `-f ${fixture} --video-name 'test upload' --channel-name user_channel --support 'support_text'`
 
-      await execCLI(`${env} ${cmd} upload ${params}`)
+      await cliCommand.execWithEnv(`${cmd} upload ${params}`)
     })
 
     it('Should have the video uploaded', async function () {
-      const res = await getVideosList(server.url)
-
-      expect(res.body.total).to.equal(1)
-
-      const videos: Video[] = res.body.data
-
-      const video: VideoDetails = (await getVideo(server.url, videos[0].uuid)).body
+      const { total, data } = await server.videos.list()
+      expect(total).to.equal(1)
 
+      const video = await server.videos.get({ id: data[0].uuid })
       expect(video.name).to.equal('test upload')
       expect(video.support).to.equal('support_text')
       expect(video.channel.name).to.equal('user_channel')
@@ -130,11 +117,8 @@ describe('Test CLI wrapper', function () {
 
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-
-      const params = `--target-url ${getYoutubeVideoUrl()} --channel-name user_channel`
-
-      await execCLI(`${env} ${cmd} import ${params}`)
+      const params = `--target-url ${FIXTURE_URLS.youtube} --channel-name user_channel`
+      await cliCommand.execWithEnv(`${cmd} import ${params}`)
     })
 
     it('Should have imported the video', async function () {
@@ -144,21 +128,19 @@ describe('Test CLI wrapper', function () {
 
       await waitJobs([ server ])
 
-      const res = await getVideosList(server.url)
-
-      expect(res.body.total).to.equal(2)
+      const { total, data } = await server.videos.list()
+      expect(total).to.equal(2)
 
-      const videos: Video[] = res.body.data
-      const video = videos.find(v => v.name === 'small video - youtube')
+      const video = data.find(v => v.name === 'small video - youtube')
       expect(video).to.not.be.undefined
 
-      const videoDetails: VideoDetails = (await getVideo(server.url, video.id)).body
+      const videoDetails = await server.videos.get({ id: video.id })
       expect(videoDetails.channel.name).to.equal('user_channel')
       expect(videoDetails.support).to.equal('super support text')
       expect(videoDetails.nsfw).to.be.false
 
       // So we can reimport it
-      await removeVideo(server.url, userAccessToken, video.id)
+      await server.videos.remove({ token: userAccessToken, id: video.id })
     })
 
     it('Should import and override some imported attributes', async function () {
@@ -166,23 +148,20 @@ describe('Test CLI wrapper', function () {
 
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-
-      const params = `--target-url ${getYoutubeVideoUrl()} --channel-name user_channel --video-name toto --nsfw --support support`
-
-      await execCLI(`${env} ${cmd} import ${params}`)
+      const params = `--target-url ${FIXTURE_URLS.youtube} ` +
+                     `--channel-name user_channel --video-name toto --nsfw --support support`
+      await cliCommand.execWithEnv(`${cmd} import ${params}`)
 
       await waitJobs([ server ])
 
       {
-        const res = await getVideosList(server.url)
-        expect(res.body.total).to.equal(2)
+        const { total, data } = await server.videos.list()
+        expect(total).to.equal(2)
 
-        const videos: Video[] = res.body.data
-        const video = videos.find(v => v.name === 'toto')
+        const video = data.find(v => v.name === 'toto')
         expect(video).to.not.be.undefined
 
-        const videoDetails: VideoDetails = (await getVideo(server.url, video.id)).body
+        const videoDetails = await server.videos.get({ id: video.id })
         expect(videoDetails.channel.name).to.equal('user_channel')
         expect(videoDetails.support).to.equal('support')
         expect(videoDetails.nsfw).to.be.true
@@ -194,18 +173,14 @@ describe('Test CLI wrapper', function () {
   describe('Admin auth', function () {
 
     it('Should remove the auth user', async function () {
-      const env = getEnvCli(server)
-
-      await execCLI(`${env} ${cmd} auth del ${server.url}`)
-
-      const stdout = await execCLI(`${env} ${cmd} --help`)
+      await cliCommand.execWithEnv(`${cmd} auth del ${server.url}`)
 
+      const stdout = await cliCommand.execWithEnv(`${cmd} --help`)
       expect(stdout).to.contain('no instance selected')
     })
 
     it('Should add the admin user', async function () {
-      const env = getEnvCli(server)
-      await execCLI(`${env} ${cmd} auth add -u ${server.url} -U root -p test${server.internalServerNumber}`)
+      await cliCommand.execWithEnv(`${cmd} auth add -u ${server.url} -U root -p test${server.internalServerNumber}`)
     })
   })
 
@@ -214,8 +189,7 @@ describe('Test CLI wrapper', function () {
     it('Should install a plugin', async function () {
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-      await execCLI(`${env} ${cmd} plugins install --npm-name peertube-plugin-hello-world`)
+      await cliCommand.execWithEnv(`${cmd} plugins install --npm-name peertube-plugin-hello-world`)
     })
 
     it('Should have registered settings', async function () {
@@ -223,29 +197,27 @@ describe('Test CLI wrapper', function () {
     })
 
     it('Should list installed plugins', async function () {
-      const env = getEnvCli(server)
-      const res = await execCLI(`${env} ${cmd} plugins list`)
+      const res = await cliCommand.execWithEnv(`${cmd} plugins list`)
 
       expect(res).to.contain('peertube-plugin-hello-world')
     })
 
     it('Should uninstall the plugin', async function () {
-      const env = getEnvCli(server)
-      const res = await execCLI(`${env} ${cmd} plugins uninstall --npm-name peertube-plugin-hello-world`)
+      const res = await cliCommand.execWithEnv(`${cmd} plugins uninstall --npm-name peertube-plugin-hello-world`)
 
       expect(res).to.not.contain('peertube-plugin-hello-world')
     })
   })
 
   describe('Manage video redundancies', function () {
-    let anotherServer: ServerInfo
+    let anotherServer: PeerTubeServer
     let video1Server2: number
-    let servers: ServerInfo[]
+    let servers: PeerTubeServer[]
 
     before(async function () {
       this.timeout(120000)
 
-      anotherServer = await flushAndRunServer(2)
+      anotherServer = await createSingleServer(2)
       await setAccessTokensToServers([ anotherServer ])
 
       await doubleFollow(server, anotherServer)
@@ -253,20 +225,17 @@ describe('Test CLI wrapper', function () {
       servers = [ server, anotherServer ]
       await waitJobs(servers)
 
-      const uuid = (await uploadVideoAndGetId({ server: anotherServer, videoName: 'super video' })).uuid
+      const { uuid } = await anotherServer.videos.quickUpload({ name: 'super video' })
       await waitJobs(servers)
 
-      video1Server2 = await getLocalIdByUUID(server.url, uuid)
+      video1Server2 = await server.videos.getId({ uuid })
     })
 
     it('Should add a redundancy', async function () {
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-
       const params = `add --video ${video1Server2}`
-
-      await execCLI(`${env} ${cmd} redundancy ${params}`)
+      await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
 
       await waitJobs(servers)
     })
@@ -275,10 +244,8 @@ describe('Test CLI wrapper', function () {
       this.timeout(60000)
 
       {
-        const env = getEnvCli(server)
-
         const params = 'list-my-redundancies'
-        const stdout = await execCLI(`${env} ${cmd} redundancy ${params}`)
+        const stdout = await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
 
         expect(stdout).to.contain('super video')
         expect(stdout).to.contain(`localhost:${server.port}`)
@@ -288,18 +255,14 @@ describe('Test CLI wrapper', function () {
     it('Should remove a redundancy', async function () {
       this.timeout(60000)
 
-      const env = getEnvCli(server)
-
       const params = `remove --video ${video1Server2}`
-
-      await execCLI(`${env} ${cmd} redundancy ${params}`)
+      await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
 
       await waitJobs(servers)
 
       {
-        const env = getEnvCli(server)
         const params = 'list-my-redundancies'
-        const stdout = await execCLI(`${env} ${cmd} redundancy ${params}`)
+        const stdout = await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
 
         expect(stdout).to.not.contain('super video')
       }
diff --git a/server/tests/cli/plugins.ts b/server/tests/cli/plugins.ts
index 7f19f14b7..07c78cc89 100644
--- a/server/tests/cli/plugins.ts
+++ b/server/tests/cli/plugins.ts
@@ -1,55 +1,47 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
+import { expect } from 'chai'
 import {
   cleanupTests,
-  execCLI,
-  flushAndRunServer,
-  getConfig,
-  getEnvCli,
-  getPluginTestPath,
+  createSingleServer,
   killallServers,
-  reRunServer,
-  ServerInfo,
+  PeerTubeServer,
+  PluginsCommand,
   setAccessTokensToServers
 } from '../../../shared/extra-utils'
-import { ServerConfig } from '../../../shared/models/server'
-import { expect } from 'chai'
 
 describe('Test plugin scripts', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
   })
 
   it('Should install a plugin from stateless CLI', async function () {
     this.timeout(60000)
 
-    const packagePath = getPluginTestPath()
+    const packagePath = PluginsCommand.getPluginTestPath()
 
-    const env = getEnvCli(server)
-    await execCLI(`${env} npm run plugin:install -- --plugin-path ${packagePath}`)
+    await server.cli.execWithEnv(`npm run plugin:install -- --plugin-path ${packagePath}`)
   })
 
   it('Should install a theme from stateless CLI', async function () {
     this.timeout(60000)
 
-    const env = getEnvCli(server)
-    await execCLI(`${env} npm run plugin:install -- --npm-name peertube-theme-background-red`)
+    await server.cli.execWithEnv(`npm run plugin:install -- --npm-name peertube-theme-background-red`)
   })
 
   it('Should have the theme and the plugin registered when we restart peertube', async function () {
     this.timeout(30000)
 
-    killallServers([ server ])
-    await reRunServer(server)
+    await killallServers([ server ])
+    await server.run()
 
-    const res = await getConfig(server.url)
-    const config: ServerConfig = res.body
+    const config = await server.config.getConfig()
 
     const plugin = config.plugin.registered
                          .find(p => p.name === 'test')
@@ -63,18 +55,16 @@ describe('Test plugin scripts', function () {
   it('Should uninstall a plugin from stateless CLI', async function () {
     this.timeout(60000)
 
-    const env = getEnvCli(server)
-    await execCLI(`${env} npm run plugin:uninstall -- --npm-name peertube-plugin-test`)
+    await server.cli.execWithEnv(`npm run plugin:uninstall -- --npm-name peertube-plugin-test`)
   })
 
   it('Should have removed the plugin on another peertube restart', async function () {
     this.timeout(30000)
 
-    killallServers([ server ])
-    await reRunServer(server)
+    await killallServers([ server ])
+    await server.run()
 
-    const res = await getConfig(server.url)
-    const config: ServerConfig = res.body
+    const config = await server.config.getConfig()
 
     const plugin = config.plugin.registered
                          .find(p => p.name === 'test')
diff --git a/server/tests/cli/print-transcode-command.ts b/server/tests/cli/print-transcode-command.ts
index 2d7255db7..3a7969e68 100644
--- a/server/tests/cli/print-transcode-command.ts
+++ b/server/tests/cli/print-transcode-command.ts
@@ -2,14 +2,15 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { execCLI } from '../../../shared/extra-utils'
+import { getVideoFileBitrate, getVideoFileFPS } from '@server/helpers/ffprobe-utils'
+import { CLICommand } from '@shared/extra-utils'
 import { getTargetBitrate, VideoResolution } from '../../../shared/models/videos'
 import { VIDEO_TRANSCODING_FPS } from '../../initializers/constants'
-import { getVideoFileBitrate, getVideoFileFPS } from '@server/helpers/ffprobe-utils'
 
 const expect = chai.expect
 
 describe('Test create transcoding jobs', function () {
+
   it('Should print the correct command for each resolution', async function () {
     const fixturePath = 'server/tests/fixtures/video_short.webm'
     const fps = await getVideoFileFPS(fixturePath)
@@ -19,7 +20,7 @@ describe('Test create transcoding jobs', function () {
       VideoResolution.H_720P,
       VideoResolution.H_1080P
     ]) {
-      const command = await execCLI(`npm run print-transcode-command -- ${fixturePath} -r ${resolution}`)
+      const command = await CLICommand.exec(`npm run print-transcode-command -- ${fixturePath} -r ${resolution}`)
       const targetBitrate = Math.min(getTargetBitrate(resolution, fps, VIDEO_TRANSCODING_FPS), bitrate)
 
       expect(command).to.includes(`-vf scale=w=-2:h=${resolution}`)
diff --git a/server/tests/cli/prune-storage.ts b/server/tests/cli/prune-storage.ts
index a0af09de8..2d4c02da7 100644
--- a/server/tests/cli/prune-storage.ts
+++ b/server/tests/cli/prune-storage.ts
@@ -5,87 +5,89 @@ import * as chai from 'chai'
 import { createFile, readdir } from 'fs-extra'
 import { join } from 'path'
 import { buildUUID } from '@server/helpers/uuid'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 import {
-  buildServerDirectory,
   cleanupTests,
-  createVideoPlaylist,
+  CLICommand,
+  createMultipleServers,
   doubleFollow,
-  execCLI,
-  flushAndRunMultipleServers,
-  getAccount,
-  getEnvCli,
   killallServers,
   makeGetRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
-  updateMyAvatar,
-  uploadVideo,
-  wait
-} from '../../../shared/extra-utils'
-import { waitJobs } from '../../../shared/extra-utils/server/jobs'
-import { Account, VideoPlaylistPrivacy } from '../../../shared/models'
+  wait,
+  waitJobs
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoPlaylistPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
-async function countFiles (internalServerNumber: number, directory: string) {
-  const files = await readdir(buildServerDirectory({ internalServerNumber }, directory))
+async function countFiles (server: PeerTubeServer, directory: string) {
+  const files = await readdir(server.servers.buildDirectory(directory))
 
   return files.length
 }
 
-async function assertNotExists (internalServerNumber: number, directory: string, substring: string) {
-  const files = await readdir(buildServerDirectory({ internalServerNumber }, directory))
+async function assertNotExists (server: PeerTubeServer, directory: string, substring: string) {
+  const files = await readdir(server.servers.buildDirectory(directory))
 
   for (const f of files) {
     expect(f).to.not.contain(substring)
   }
 }
 
-async function assertCountAreOkay (servers: ServerInfo[]) {
+async function assertCountAreOkay (servers: PeerTubeServer[], videoServer2UUID: string) {
   for (const server of servers) {
-    const videosCount = await countFiles(server.internalServerNumber, 'videos')
+    const videosCount = await countFiles(server, 'videos')
     expect(videosCount).to.equal(8)
 
-    const torrentsCount = await countFiles(server.internalServerNumber, 'torrents')
+    const torrentsCount = await countFiles(server, 'torrents')
     expect(torrentsCount).to.equal(16)
 
-    const previewsCount = await countFiles(server.internalServerNumber, 'previews')
+    const previewsCount = await countFiles(server, 'previews')
     expect(previewsCount).to.equal(2)
 
-    const thumbnailsCount = await countFiles(server.internalServerNumber, 'thumbnails')
+    const thumbnailsCount = await countFiles(server, 'thumbnails')
     expect(thumbnailsCount).to.equal(6)
 
-    const avatarsCount = await countFiles(server.internalServerNumber, 'avatars')
+    const avatarsCount = await countFiles(server, 'avatars')
     expect(avatarsCount).to.equal(2)
   }
+
+  // When we'll prune HLS directories too
+  // const hlsRootCount = await countFiles(servers[1], 'streaming-playlists/hls/')
+  // expect(hlsRootCount).to.equal(2)
+
+  // const hlsCount = await countFiles(servers[1], 'streaming-playlists/hls/' + videoServer2UUID)
+  // expect(hlsCount).to.equal(10)
 }
 
 describe('Test prune storage scripts', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   const badNames: { [directory: string]: string[] } = {}
 
+  let videoServer2UUID: string
+
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2, { transcoding: { enabled: true } })
+    servers = await createMultipleServers(2, { transcoding: { enabled: true } })
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
     for (const server of servers) {
-      await uploadVideo(server.url, server.accessToken, { name: 'video 1' })
-      await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
+      await server.videos.upload({ attributes: { name: 'video 1' } })
 
-      await updateMyAvatar({ url: server.url, accessToken: server.accessToken, fixture: 'avatar.png' })
+      const { uuid } = await server.videos.upload({ attributes: { name: 'video 2' } })
+      if (server.serverNumber === 2) videoServer2UUID = uuid
 
-      await createVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
+      await server.users.updateMyAvatar({ fixture: 'avatar.png' })
+
+      await server.playlists.create({
+        attributes: {
           displayName: 'playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: server.videoChannel.id,
+          videoChannelId: server.store.channel.id,
           thumbnailfile: 'thumbnail.jpg'
         }
       })
@@ -95,41 +97,39 @@ describe('Test prune storage scripts', function () {
 
     // Lazy load the remote avatar
     {
-      const res = await getAccount(servers[0].url, 'root@localhost:' + servers[1].port)
-      const account: Account = res.body
+      const account = await servers[0].accounts.get({ accountName: 'root@localhost:' + servers[1].port })
       await makeGetRequest({
         url: servers[0].url,
         path: account.avatar.path,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     }
 
     {
-      const res = await getAccount(servers[1].url, 'root@localhost:' + servers[0].port)
-      const account: Account = res.body
+      const account = await servers[1].accounts.get({ accountName: 'root@localhost:' + servers[0].port })
       await makeGetRequest({
         url: servers[1].url,
         path: account.avatar.path,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
     }
 
     await wait(1000)
 
     await waitJobs(servers)
-    killallServers(servers)
+    await killallServers(servers)
 
     await wait(1000)
   })
 
   it('Should have the files on the disk', async function () {
-    await assertCountAreOkay(servers)
+    await assertCountAreOkay(servers, videoServer2UUID)
   })
 
   it('Should create some dirty files', async function () {
     for (let i = 0; i < 2; i++) {
       {
-        const base = buildServerDirectory(servers[0], 'videos')
+        const base = servers[0].servers.buildDirectory('videos')
 
         const n1 = buildUUID() + '.mp4'
         const n2 = buildUUID() + '.webm'
@@ -141,7 +141,7 @@ describe('Test prune storage scripts', function () {
       }
 
       {
-        const base = buildServerDirectory(servers[0], 'torrents')
+        const base = servers[0].servers.buildDirectory('torrents')
 
         const n1 = buildUUID() + '-240.torrent'
         const n2 = buildUUID() + '-480.torrent'
@@ -153,7 +153,7 @@ describe('Test prune storage scripts', function () {
       }
 
       {
-        const base = buildServerDirectory(servers[0], 'thumbnails')
+        const base = servers[0].servers.buildDirectory('thumbnails')
 
         const n1 = buildUUID() + '.jpg'
         const n2 = buildUUID() + '.jpg'
@@ -165,7 +165,7 @@ describe('Test prune storage scripts', function () {
       }
 
       {
-        const base = buildServerDirectory(servers[0], 'previews')
+        const base = servers[0].servers.buildDirectory('previews')
 
         const n1 = buildUUID() + '.jpg'
         const n2 = buildUUID() + '.jpg'
@@ -177,7 +177,7 @@ describe('Test prune storage scripts', function () {
       }
 
       {
-        const base = buildServerDirectory(servers[0], 'avatars')
+        const base = servers[0].servers.buildDirectory('avatars')
 
         const n1 = buildUUID() + '.png'
         const n2 = buildUUID() + '.jpg'
@@ -187,22 +187,44 @@ describe('Test prune storage scripts', function () {
 
         badNames['avatars'] = [ n1, n2 ]
       }
+
+      // When we'll prune HLS directories too
+      // {
+      //   const directory = join('streaming-playlists', 'hls')
+      //   const base = servers[1].servers.buildDirectory(directory)
+
+      //   const n1 = buildUUID()
+      //   await createFile(join(base, n1))
+      //   badNames[directory] = [ n1 ]
+      // }
+
+      // {
+      //   const directory = join('streaming-playlists', 'hls', videoServer2UUID)
+      //   const base = servers[1].servers.buildDirectory(directory)
+      //   const n1 = buildUUID() + '-240-fragmented-.mp4'
+      //   const n2 = buildUUID() + '-master.m3u8'
+
+      //   await createFile(join(base, n1))
+      //   await createFile(join(base, n2))
+
+      //   badNames[directory] = [ n1, n2 ]
+      // }
     }
   })
 
   it('Should run prune storage', async function () {
     this.timeout(30000)
 
-    const env = getEnvCli(servers[0])
-    await execCLI(`echo y | ${env} npm run prune-storage`)
+    const env = servers[0].cli.getEnv()
+    await CLICommand.exec(`echo y | ${env} npm run prune-storage`)
   })
 
   it('Should have removed files', async function () {
-    await assertCountAreOkay(servers)
+    await assertCountAreOkay(servers, videoServer2UUID)
 
     for (const directory of Object.keys(badNames)) {
       for (const name of badNames[directory]) {
-        await assertNotExists(servers[0].internalServerNumber, directory, name)
+        await assertNotExists(servers[0], directory, name)
       }
     }
   })
diff --git a/server/tests/cli/regenerate-thumbnails.ts b/server/tests/cli/regenerate-thumbnails.ts
index 8acb9f263..780c9b4bd 100644
--- a/server/tests/cli/regenerate-thumbnails.ts
+++ b/server/tests/cli/regenerate-thumbnails.ts
@@ -2,36 +2,33 @@ import 'mocha'
 import { expect } from 'chai'
 import { writeFile } from 'fs-extra'
 import { basename, join } from 'path'
-import { Video, VideoDetails } from '@shared/models'
+import { HttpStatusCode, Video } from '@shared/models'
 import {
-  buildServerDirectory,
   cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  execCLI,
-  flushAndRunMultipleServers,
-  getEnvCli,
-  getVideo,
   makeRawRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  uploadVideoAndGetId,
   waitJobs
 } from '../../../shared/extra-utils'
-import { HttpStatusCode } from '@shared/core-utils'
 
-async function testThumbnail (server: ServerInfo, videoId: number | string) {
-  const res = await getVideo(server.url, videoId)
-  const video: VideoDetails = res.body
+async function testThumbnail (server: PeerTubeServer, videoId: number | string) {
+  const video = await server.videos.get({ id: videoId })
 
-  const res1 = await makeRawRequest(join(server.url, video.thumbnailPath), HttpStatusCode.OK_200)
-  expect(res1.body).to.not.have.lengthOf(0)
+  const requests = [
+    makeRawRequest(join(server.url, video.thumbnailPath), HttpStatusCode.OK_200),
+    makeRawRequest(join(server.url, video.thumbnailPath), HttpStatusCode.OK_200)
+  ]
 
-  const res2 = await makeRawRequest(join(server.url, video.thumbnailPath), HttpStatusCode.OK_200)
-  expect(res2.body).to.not.have.lengthOf(0)
+  for (const req of requests) {
+    const res = await req
+    expect(res.body).to.not.have.lengthOf(0)
+  }
 }
 
 describe('Test regenerate thumbnails script', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
 
   let video1: Video
   let video2: Video
@@ -43,28 +40,28 @@ describe('Test regenerate thumbnails script', function () {
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     await doubleFollow(servers[0], servers[1])
 
     {
-      const videoUUID1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 1' })).uuid
-      video1 = await (getVideo(servers[0].url, videoUUID1).then(res => res.body))
+      const videoUUID1 = (await servers[0].videos.quickUpload({ name: 'video 1' })).uuid
+      video1 = await servers[0].videos.get({ id: videoUUID1 })
 
-      thumbnail1Path = join(buildServerDirectory(servers[0], 'thumbnails'), basename(video1.thumbnailPath))
+      thumbnail1Path = join(servers[0].servers.buildDirectory('thumbnails'), basename(video1.thumbnailPath))
 
-      const videoUUID2 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 2' })).uuid
-      video2 = await (getVideo(servers[0].url, videoUUID2).then(res => res.body))
+      const videoUUID2 = (await servers[0].videos.quickUpload({ name: 'video 2' })).uuid
+      video2 = await servers[0].videos.get({ id: videoUUID2 })
     }
 
     {
-      const videoUUID = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video 3' })).uuid
+      const videoUUID = (await servers[1].videos.quickUpload({ name: 'video 3' })).uuid
       await waitJobs(servers)
 
-      remoteVideo = await (getVideo(servers[0].url, videoUUID).then(res => res.body))
+      remoteVideo = await servers[0].videos.get({ id: videoUUID })
 
-      thumbnailRemotePath = join(buildServerDirectory(servers[0], 'thumbnails'), basename(remoteVideo.thumbnailPath))
+      thumbnailRemotePath = join(servers[0].servers.buildDirectory('thumbnails'), basename(remoteVideo.thumbnailPath))
     }
 
     await writeFile(thumbnail1Path, '')
@@ -91,8 +88,7 @@ describe('Test regenerate thumbnails script', function () {
   it('Should regenerate local thumbnails from the CLI', async function () {
     this.timeout(15000)
 
-    const env = getEnvCli(servers[0])
-    await execCLI(`${env} npm run regenerate-thumbnails`)
+    await servers[0].cli.execWithEnv(`npm run regenerate-thumbnails`)
   })
 
   it('Should have generated new thumbnail files', async function () {
diff --git a/server/tests/cli/reset-password.ts b/server/tests/cli/reset-password.ts
index a84463b33..4a02db35d 100644
--- a/server/tests/cli/reset-password.ts
+++ b/server/tests/cli/reset-password.ts
@@ -1,35 +1,24 @@
 import 'mocha'
-
-import {
-  cleanupTests,
-  createUser,
-  execCLI,
-  flushAndRunServer,
-  getEnvCli,
-  login,
-  ServerInfo,
-  setAccessTokensToServers
-} from '../../../shared/extra-utils'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { cleanupTests, CLICommand, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '../../../shared/extra-utils'
 
 describe('Test reset password scripts', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   before(async function () {
     this.timeout(30000)
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
-    await createUser({ url: server.url, accessToken: server.accessToken, username: 'user_1', password: 'super password' })
+    await server.users.create({ username: 'user_1', password: 'super password' })
   })
 
   it('Should change the user password from CLI', async function () {
     this.timeout(60000)
 
-    const env = getEnvCli(server)
-    await execCLI(`echo coucou | ${env} npm run reset-password -- -u user_1`)
+    const env = server.cli.getEnv()
+    await CLICommand.exec(`echo coucou | ${env} npm run reset-password -- -u user_1`)
 
-    await login(server.url, server.client, { username: 'user_1', password: 'coucou' }, HttpStatusCode.OK_200)
+    await server.login.login({ user: { username: 'user_1', password: 'coucou' } })
   })
 
   after(async function () {
diff --git a/server/tests/cli/update-host.ts b/server/tests/cli/update-host.ts
index 2070f16f5..43fbaec30 100644
--- a/server/tests/cli/update-host.ts
+++ b/server/tests/cli/update-host.ts
@@ -1,33 +1,20 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import * as chai from 'chai'
-import { VideoDetails } from '../../../shared/models/videos'
-import { waitJobs } from '../../../shared/extra-utils/server/jobs'
-import { addVideoCommentThread } from '../../../shared/extra-utils/videos/video-comments'
+import { expect } from 'chai'
 import {
-  addVideoChannel,
   cleanupTests,
-  createUser,
-  execCLI,
-  flushAndRunServer,
-  getEnvCli,
-  getVideo,
-  getVideoChannelsList,
-  getVideosList,
+  createSingleServer,
   killallServers,
   makeActivityPubGetRequest,
-  parseTorrentVideo, reRunServer,
-  ServerInfo,
+  parseTorrentVideo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  uploadVideo
-} from '../../../shared/extra-utils'
-import { getAccountsList } from '../../../shared/extra-utils/users/accounts'
-
-const expect = chai.expect
+  waitJobs
+} from '@shared/extra-utils'
 
 describe('Test update host scripts', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   before(async function () {
     this.timeout(60000)
@@ -38,17 +25,15 @@ describe('Test update host scripts', function () {
       }
     }
     // Run server 2 to have transcoding enabled
-    server = await flushAndRunServer(2, overrideConfig)
+    server = await createSingleServer(2, overrideConfig)
     await setAccessTokensToServers([ server ])
 
     // Upload two videos for our needs
-    const videoAttributes = {}
-    const resVideo1 = await uploadVideo(server.url, server.accessToken, videoAttributes)
-    const video1UUID = resVideo1.body.video.uuid
-    await uploadVideo(server.url, server.accessToken, videoAttributes)
+    const { uuid: video1UUID } = await server.videos.upload()
+    await server.videos.upload()
 
     // Create a user
-    await createUser({ url: server.url, accessToken: server.accessToken, username: 'toto', password: 'coucou' })
+    await server.users.create({ username: 'toto', password: 'coucou' })
 
     // Create channel
     const videoChannel = {
@@ -56,11 +41,11 @@ describe('Test update host scripts', function () {
       displayName: 'second video channel',
       description: 'super video channel description'
     }
-    await addVideoChannel(server.url, server.accessToken, videoChannel)
+    await server.channels.create({ attributes: videoChannel })
 
     // Create comments
     const text = 'my super first comment'
-    await addVideoCommentThread(server.url, server.accessToken, video1UUID, text)
+    await server.comments.createThread({ videoId: video1UUID, text })
 
     await waitJobs(server)
   })
@@ -68,25 +53,23 @@ describe('Test update host scripts', function () {
   it('Should run update host', async function () {
     this.timeout(30000)
 
-    killallServers([ server ])
+    await killallServers([ server ])
     // Run server with standard configuration
-    await reRunServer(server)
+    await server.run()
 
-    const env = getEnvCli(server)
-    await execCLI(`${env} npm run update-host`)
+    await server.cli.execWithEnv(`npm run update-host`)
   })
 
   it('Should have updated videos url', async function () {
-    const res = await getVideosList(server.url)
-    expect(res.body.total).to.equal(2)
+    const { total, data } = await server.videos.list()
+    expect(total).to.equal(2)
 
-    for (const video of res.body.data) {
+    for (const video of data) {
       const { body } = await makeActivityPubGetRequest(server.url, '/videos/watch/' + video.uuid)
 
       expect(body.id).to.equal('http://localhost:9002/videos/watch/' + video.uuid)
 
-      const res = await getVideo(server.url, video.uuid)
-      const videoDetails: VideoDetails = res.body
+      const videoDetails = await server.videos.get({ id: video.uuid })
 
       expect(videoDetails.trackerUrls[0]).to.include(server.host)
       expect(videoDetails.streamingPlaylists[0].playlistUrl).to.include(server.host)
@@ -95,10 +78,10 @@ describe('Test update host scripts', function () {
   })
 
   it('Should have updated video channels url', async function () {
-    const res = await getVideoChannelsList(server.url, 0, 5, '-name')
-    expect(res.body.total).to.equal(3)
+    const { data, total } = await server.channels.list({ sort: '-name' })
+    expect(total).to.equal(3)
 
-    for (const channel of res.body.data) {
+    for (const channel of data) {
       const { body } = await makeActivityPubGetRequest(server.url, '/video-channels/' + channel.name)
 
       expect(body.id).to.equal('http://localhost:9002/video-channels/' + channel.name)
@@ -106,10 +89,10 @@ describe('Test update host scripts', function () {
   })
 
   it('Should have updated accounts url', async function () {
-    const res = await getAccountsList(server.url)
-    expect(res.body.total).to.equal(3)
+    const body = await server.accounts.list()
+    expect(body.total).to.equal(3)
 
-    for (const account of res.body.data) {
+    for (const account of body.data) {
       const usernameWithDomain = account.name
       const { body } = await makeActivityPubGetRequest(server.url, '/accounts/' + usernameWithDomain)
 
@@ -120,28 +103,27 @@ describe('Test update host scripts', function () {
   it('Should have updated torrent hosts', async function () {
     this.timeout(30000)
 
-    const res = await getVideosList(server.url)
-    const videos = res.body.data
-    expect(videos).to.have.lengthOf(2)
+    const { data } = await server.videos.list()
+    expect(data).to.have.lengthOf(2)
 
-    for (const video of videos) {
-      const res2 = await getVideo(server.url, video.id)
-      const videoDetails: VideoDetails = res2.body
+    for (const video of data) {
+      const videoDetails = await server.videos.get({ id: video.id })
+      const files = videoDetails.files.concat(videoDetails.streamingPlaylists[0].files)
 
-      expect(videoDetails.files).to.have.lengthOf(4)
+      expect(files).to.have.lengthOf(8)
 
-      for (const file of videoDetails.files) {
+      for (const file of files) {
         expect(file.magnetUri).to.contain('localhost%3A9002%2Ftracker%2Fsocket')
-        expect(file.magnetUri).to.contain('localhost%3A9002%2Fstatic%2Fwebseed%2F')
+        expect(file.magnetUri).to.contain('localhost%3A9002%2Fstatic%2F')
 
-        const torrent = await parseTorrentVideo(server, videoDetails.uuid, file.resolution.id)
+        const torrent = await parseTorrentVideo(server, file)
         const announceWS = torrent.announce.find(a => a === 'ws://localhost:9002/tracker/socket')
         expect(announceWS).to.not.be.undefined
 
         const announceHttp = torrent.announce.find(a => a === 'http://localhost:9002/tracker/announce')
         expect(announceHttp).to.not.be.undefined
 
-        expect(torrent.urlList[0]).to.contain('http://localhost:9002/static/webseed')
+        expect(torrent.urlList[0]).to.contain('http://localhost:9002/static/')
       }
     }
   })
diff --git a/server/tests/client.ts b/server/tests/client.ts
index 7c4fb4e46..4f0d052c8 100644
--- a/server/tests/client.ts
+++ b/server/tests/client.ts
@@ -3,28 +3,16 @@
 import 'mocha'
 import * as chai from 'chai'
 import { omit } from 'lodash'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
-import { Account, CustomConfig, HTMLServerConfig, ServerConfig, VideoPlaylistCreateResult, VideoPlaylistPrivacy } from '@shared/models'
+import { Account, HTMLServerConfig, HttpStatusCode, ServerConfig, VideoPlaylistCreateResult, VideoPlaylistPrivacy } from '@shared/models'
 import {
-  addVideoInPlaylist,
   cleanupTests,
-  createVideoPlaylist,
+  createMultipleServers,
   doubleFollow,
-  flushAndRunMultipleServers,
-  getAccount,
-  getConfig,
-  getCustomConfig,
-  getVideosList,
   makeGetRequest,
   makeHTMLRequest,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
   setDefaultVideoChannel,
-  updateCustomConfig,
-  updateCustomSubConfig,
-  updateMyUser,
-  updateVideoChannel,
-  uploadVideo,
   waitJobs
 } from '../../shared/extra-utils'
 
@@ -40,7 +28,7 @@ function checkIndexTags (html: string, title: string, description: string, css:
 }
 
 describe('Test a client controllers', function () {
-  let servers: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
   let account: Account
 
   const videoName = 'my super name for server 1'
@@ -62,7 +50,7 @@ describe('Test a client controllers', function () {
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
@@ -70,47 +58,48 @@ describe('Test a client controllers', function () {
 
     await setDefaultVideoChannel(servers)
 
-    await updateVideoChannel(servers[0].url, servers[0].accessToken, servers[0].videoChannel.name, { description: channelDescription })
+    await servers[0].channels.update({
+      channelName: servers[0].store.channel.name,
+      attributes: { description: channelDescription }
+    })
 
     // Video
 
-    const videoAttributes = { name: videoName, description: videoDescription }
-    await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+    {
+      const attributes = { name: videoName, description: videoDescription }
+      await servers[0].videos.upload({ attributes })
 
-    const resVideosRequest = await getVideosList(servers[0].url)
-    const videos = resVideosRequest.body.data
-    expect(videos.length).to.equal(1)
+      const { data } = await servers[0].videos.list()
+      expect(data.length).to.equal(1)
 
-    const video = videos[0]
-    servers[0].video = video
-    videoIds = [ video.id, video.uuid, video.shortUUID ]
+      const video = data[0]
+      servers[0].store.video = video
+      videoIds = [ video.id, video.uuid, video.shortUUID ]
+    }
 
     // Playlist
 
-    const playlistAttrs = {
-      displayName: playlistName,
-      description: playlistDescription,
-      privacy: VideoPlaylistPrivacy.PUBLIC,
-      videoChannelId: servers[0].videoChannel.id
-    }
+    {
+      const attributes = {
+        displayName: playlistName,
+        description: playlistDescription,
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId: servers[0].store.channel.id
+      }
 
-    const resVideoPlaylistRequest = await createVideoPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistAttrs })
-    playlist = resVideoPlaylistRequest.body.videoPlaylist
-    playlistIds = [ playlist.id, playlist.shortUUID, playlist.uuid ]
+      playlist = await servers[0].playlists.create({ attributes })
+      playlistIds = [ playlist.id, playlist.shortUUID, playlist.uuid ]
 
-    await addVideoInPlaylist({
-      url: servers[0].url,
-      token: servers[0].accessToken,
-      playlistId: playlist.shortUUID,
-      elementAttrs: { videoId: video.id }
-    })
+      await servers[0].playlists.addElement({ playlistId: playlist.shortUUID, attributes: { videoId: servers[0].store.video.id } })
+    }
 
     // Account
 
-    await updateMyUser({ url: servers[0].url, accessToken: servers[0].accessToken, description: 'my account description' })
+    {
+      await servers[0].users.updateMe({ description: 'my account description' })
 
-    const resAccountRequest = await getAccount(servers[0].url, `${servers[0].user.username}@${servers[0].host}`)
-    account = resAccountRequest.body
+      account = await servers[0].accounts.get({ accountName: `${servers[0].store.user.username}@${servers[0].host}` })
+    }
 
     await waitJobs(servers)
   })
@@ -124,14 +113,14 @@ describe('Test a client controllers', function () {
             url: servers[0].url,
             path: basePath + id,
             accept: 'text/html',
-            statusCodeExpected: HttpStatusCode.OK_200
+            expectedStatus: HttpStatusCode.OK_200
           })
 
           const port = servers[0].port
 
           const expectedLink = '<link rel="alternate" type="application/json+oembed" href="http://localhost:' + port + '/services/oembed?' +
-            `url=http%3A%2F%2Flocalhost%3A${port}%2Fw%2F${servers[0].video.uuid}" ` +
-            `title="${servers[0].video.name}" />`
+            `url=http%3A%2F%2Flocalhost%3A${port}%2Fw%2F${servers[0].store.video.shortUUID}" ` +
+            `title="${servers[0].store.video.name}" />`
 
           expect(res.text).to.contain(expectedLink)
         }
@@ -145,13 +134,13 @@ describe('Test a client controllers', function () {
             url: servers[0].url,
             path: basePath + id,
             accept: 'text/html',
-            statusCodeExpected: HttpStatusCode.OK_200
+            expectedStatus: HttpStatusCode.OK_200
           })
 
           const port = servers[0].port
 
           const expectedLink = '<link rel="alternate" type="application/json+oembed" href="http://localhost:' + port + '/services/oembed?' +
-            `url=http%3A%2F%2Flocalhost%3A${port}%2Fw%2Fp%2F${playlist.uuid}" ` +
+            `url=http%3A%2F%2Flocalhost%3A${port}%2Fw%2Fp%2F${playlist.shortUUID}" ` +
             `title="${playlistName}" />`
 
           expect(res.text).to.contain(expectedLink)
@@ -163,55 +152,55 @@ describe('Test a client controllers', function () {
   describe('Open Graph', function () {
 
     async function accountPageTest (path: string) {
-      const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+      const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
       const text = res.text
 
       expect(text).to.contain(`<meta property="og:title" content="${account.displayName}" />`)
       expect(text).to.contain(`<meta property="og:description" content="${account.description}" />`)
       expect(text).to.contain('<meta property="og:type" content="website" />')
-      expect(text).to.contain(`<meta property="og:url" content="${servers[0].url}/accounts/${servers[0].user.username}" />`)
+      expect(text).to.contain(`<meta property="og:url" content="${servers[0].url}/accounts/${servers[0].store.user.username}" />`)
     }
 
     async function channelPageTest (path: string) {
-      const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+      const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
       const text = res.text
 
-      expect(text).to.contain(`<meta property="og:title" content="${servers[0].videoChannel.displayName}" />`)
+      expect(text).to.contain(`<meta property="og:title" content="${servers[0].store.channel.displayName}" />`)
       expect(text).to.contain(`<meta property="og:description" content="${channelDescription}" />`)
       expect(text).to.contain('<meta property="og:type" content="website" />')
-      expect(text).to.contain(`<meta property="og:url" content="${servers[0].url}/video-channels/${servers[0].videoChannel.name}" />`)
+      expect(text).to.contain(`<meta property="og:url" content="${servers[0].url}/video-channels/${servers[0].store.channel.name}" />`)
     }
 
     async function watchVideoPageTest (path: string) {
-      const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+      const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
       const text = res.text
 
       expect(text).to.contain(`<meta property="og:title" content="${videoName}" />`)
       expect(text).to.contain(`<meta property="og:description" content="${videoDescriptionPlainText}" />`)
       expect(text).to.contain('<meta property="og:type" content="video" />')
-      expect(text).to.contain(`<meta property="og:url" content="${servers[0].url}/w/${servers[0].video.uuid}" />`)
+      expect(text).to.contain(`<meta property="og:url" content="${servers[0].url}/w/${servers[0].store.video.shortUUID}" />`)
     }
 
     async function watchPlaylistPageTest (path: string) {
-      const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+      const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
       const text = res.text
 
       expect(text).to.contain(`<meta property="og:title" content="${playlistName}" />`)
       expect(text).to.contain(`<meta property="og:description" content="${playlistDescription}" />`)
       expect(text).to.contain('<meta property="og:type" content="video" />')
-      expect(text).to.contain(`<meta property="og:url" content="${servers[0].url}/w/p/${playlist.uuid}" />`)
+      expect(text).to.contain(`<meta property="og:url" content="${servers[0].url}/w/p/${playlist.shortUUID}" />`)
     }
 
     it('Should have valid Open Graph tags on the account page', async function () {
-      await accountPageTest('/accounts/' + servers[0].user.username)
-      await accountPageTest('/a/' + servers[0].user.username)
-      await accountPageTest('/@' + servers[0].user.username)
+      await accountPageTest('/accounts/' + servers[0].store.user.username)
+      await accountPageTest('/a/' + servers[0].store.user.username)
+      await accountPageTest('/@' + servers[0].store.user.username)
     })
 
     it('Should have valid Open Graph tags on the channel page', async function () {
-      await channelPageTest('/video-channels/' + servers[0].videoChannel.name)
-      await channelPageTest('/c/' + servers[0].videoChannel.name)
-      await channelPageTest('/@' + servers[0].videoChannel.name)
+      await channelPageTest('/video-channels/' + servers[0].store.channel.name)
+      await channelPageTest('/c/' + servers[0].store.channel.name)
+      await channelPageTest('/@' + servers[0].store.channel.name)
     })
 
     it('Should have valid Open Graph tags on the watch page', async function () {
@@ -236,7 +225,7 @@ describe('Test a client controllers', function () {
     describe('Not whitelisted', function () {
 
       async function accountPageTest (path: string) {
-        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
         const text = res.text
 
         expect(text).to.contain('<meta property="twitter:card" content="summary" />')
@@ -246,17 +235,17 @@ describe('Test a client controllers', function () {
       }
 
       async function channelPageTest (path: string) {
-        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
         const text = res.text
 
         expect(text).to.contain('<meta property="twitter:card" content="summary" />')
         expect(text).to.contain('<meta property="twitter:site" content="@Chocobozzz" />')
-        expect(text).to.contain(`<meta property="twitter:title" content="${servers[0].videoChannel.displayName}" />`)
+        expect(text).to.contain(`<meta property="twitter:title" content="${servers[0].store.channel.displayName}" />`)
         expect(text).to.contain(`<meta property="twitter:description" content="${channelDescription}" />`)
       }
 
       async function watchVideoPageTest (path: string) {
-        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
         const text = res.text
 
         expect(text).to.contain('<meta property="twitter:card" content="summary_large_image" />')
@@ -266,7 +255,7 @@ describe('Test a client controllers', function () {
       }
 
       async function watchPlaylistPageTest (path: string) {
-        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
         const text = res.text
 
         expect(text).to.contain('<meta property="twitter:card" content="summary" />')
@@ -298,27 +287,26 @@ describe('Test a client controllers', function () {
       })
 
       it('Should have valid twitter card on the channel page', async function () {
-        await channelPageTest('/video-channels/' + servers[0].videoChannel.name)
-        await channelPageTest('/c/' + servers[0].videoChannel.name)
-        await channelPageTest('/@' + servers[0].videoChannel.name)
+        await channelPageTest('/video-channels/' + servers[0].store.channel.name)
+        await channelPageTest('/c/' + servers[0].store.channel.name)
+        await channelPageTest('/@' + servers[0].store.channel.name)
       })
     })
 
     describe('Whitelisted', function () {
 
       before(async function () {
-        const res = await getCustomConfig(servers[0].url, servers[0].accessToken)
-        const config = res.body as CustomConfig
+        const config = await servers[0].config.getCustomConfig()
         config.services.twitter = {
           username: '@Kuja',
           whitelisted: true
         }
 
-        await updateCustomConfig(servers[0].url, servers[0].accessToken, config)
+        await servers[0].config.updateCustomConfig({ newCustomConfig: config })
       })
 
       async function accountPageTest (path: string) {
-        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
         const text = res.text
 
         expect(text).to.contain('<meta property="twitter:card" content="summary" />')
@@ -326,7 +314,7 @@ describe('Test a client controllers', function () {
       }
 
       async function channelPageTest (path: string) {
-        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
         const text = res.text
 
         expect(text).to.contain('<meta property="twitter:card" content="summary" />')
@@ -334,7 +322,7 @@ describe('Test a client controllers', function () {
       }
 
       async function watchVideoPageTest (path: string) {
-        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
         const text = res.text
 
         expect(text).to.contain('<meta property="twitter:card" content="player" />')
@@ -342,7 +330,7 @@ describe('Test a client controllers', function () {
       }
 
       async function watchPlaylistPageTest (path: string) {
-        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', statusCodeExpected: HttpStatusCode.OK_200 })
+        const res = await makeGetRequest({ url: servers[0].url, path, accept: 'text/html', expectedStatus: HttpStatusCode.OK_200 })
         const text = res.text
 
         expect(text).to.contain('<meta property="twitter:card" content="player" />')
@@ -372,9 +360,9 @@ describe('Test a client controllers', function () {
       })
 
       it('Should have valid twitter card on the channel page', async function () {
-        await channelPageTest('/video-channels/' + servers[0].videoChannel.name)
-        await channelPageTest('/c/' + servers[0].videoChannel.name)
-        await channelPageTest('/@' + servers[0].videoChannel.name)
+        await channelPageTest('/video-channels/' + servers[0].store.channel.name)
+        await channelPageTest('/c/' + servers[0].store.channel.name)
+        await channelPageTest('/@' + servers[0].store.channel.name)
       })
     })
   })
@@ -382,53 +370,55 @@ describe('Test a client controllers', function () {
   describe('Index HTML', function () {
 
     it('Should have valid index html tags (title, description...)', async function () {
-      const resConfig = await getConfig(servers[0].url)
+      const config = await servers[0].config.getConfig()
       const res = await makeHTMLRequest(servers[0].url, '/videos/trending')
 
       const description = 'PeerTube, an ActivityPub-federated video streaming platform using P2P directly in your web browser.'
-      checkIndexTags(res.text, 'PeerTube', description, '', resConfig.body)
+      checkIndexTags(res.text, 'PeerTube', description, '', config)
     })
 
     it('Should update the customized configuration and have the correct index html tags', async function () {
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-        instance: {
-          name: 'PeerTube updated',
-          shortDescription: 'my short description',
-          description: 'my super description',
-          terms: 'my super terms',
-          defaultNSFWPolicy: 'blur',
-          defaultClientRoute: '/videos/recently-added',
-          customizations: {
-            javascript: 'alert("coucou")',
-            css: 'body { background-color: red; }'
+      await servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          instance: {
+            name: 'PeerTube updated',
+            shortDescription: 'my short description',
+            description: 'my super description',
+            terms: 'my super terms',
+            defaultNSFWPolicy: 'blur',
+            defaultClientRoute: '/videos/recently-added',
+            customizations: {
+              javascript: 'alert("coucou")',
+              css: 'body { background-color: red; }'
+            }
           }
         }
       })
 
-      const resConfig = await getConfig(servers[0].url)
+      const config = await servers[0].config.getConfig()
       const res = await makeHTMLRequest(servers[0].url, '/videos/trending')
 
-      checkIndexTags(res.text, 'PeerTube updated', 'my short description', 'body { background-color: red; }', resConfig.body)
+      checkIndexTags(res.text, 'PeerTube updated', 'my short description', 'body { background-color: red; }', config)
     })
 
     it('Should have valid index html updated tags (title, description...)', async function () {
-      const resConfig = await getConfig(servers[0].url)
+      const config = await servers[0].config.getConfig()
       const res = await makeHTMLRequest(servers[0].url, '/videos/trending')
 
-      checkIndexTags(res.text, 'PeerTube updated', 'my short description', 'body { background-color: red; }', resConfig.body)
+      checkIndexTags(res.text, 'PeerTube updated', 'my short description', 'body { background-color: red; }', config)
     })
 
     it('Should use the original video URL for the canonical tag', async function () {
       for (const basePath of watchVideoBasePaths) {
         for (const id of videoIds) {
           const res = await makeHTMLRequest(servers[1].url, basePath + id)
-          expect(res.text).to.contain(`<link rel="canonical" href="${servers[0].url}/videos/watch/${servers[0].video.uuid}" />`)
+          expect(res.text).to.contain(`<link rel="canonical" href="${servers[0].url}/videos/watch/${servers[0].store.video.uuid}" />`)
         }
       }
     })
 
     it('Should use the original account URL for the canonical tag', async function () {
-      const accountURLtest = (res) => {
+      const accountURLtest = res => {
         expect(res.text).to.contain(`<link rel="canonical" href="${servers[0].url}/accounts/root" />`)
       }
 
@@ -438,7 +428,7 @@ describe('Test a client controllers', function () {
     })
 
     it('Should use the original channel URL for the canonical tag', async function () {
-      const channelURLtests = (res) => {
+      const channelURLtests = res => {
         expect(res.text).to.contain(`<link rel="canonical" href="${servers[0].url}/video-channels/root_channel" />`)
       }
 
@@ -455,15 +445,49 @@ describe('Test a client controllers', function () {
         }
       }
     })
+
+    it('Should add noindex meta tag for remote accounts', async function () {
+      const handle = 'root@' + servers[0].host
+      const paths = [ '/accounts/', '/a/', '/@' ]
+
+      for (const path of paths) {
+        {
+          const { text } = await makeHTMLRequest(servers[1].url, path + handle)
+          expect(text).to.contain('<meta name="robots" content="noindex" />')
+        }
+
+        {
+          const { text } = await makeHTMLRequest(servers[0].url, path + handle)
+          expect(text).to.not.contain('<meta name="robots" content="noindex" />')
+        }
+      }
+    })
+
+    it('Should add noindex meta tag for remote accounts', async function () {
+      const handle = 'root_channel@' + servers[0].host
+      const paths = [ '/video-channels/', '/c/', '/@' ]
+
+      for (const path of paths) {
+        {
+          const { text } = await makeHTMLRequest(servers[1].url, path + handle)
+          expect(text).to.contain('<meta name="robots" content="noindex" />')
+        }
+
+        {
+          const { text } = await makeHTMLRequest(servers[0].url, path + handle)
+          expect(text).to.not.contain('<meta name="robots" content="noindex" />')
+        }
+      }
+    })
   })
 
   describe('Embed HTML', function () {
 
     it('Should have the correct embed html tags', async function () {
-      const resConfig = await getConfig(servers[0].url)
-      const res = await makeHTMLRequest(servers[0].url, servers[0].video.embedPath)
+      const config = await servers[0].config.getConfig()
+      const res = await makeHTMLRequest(servers[0].url, servers[0].store.video.embedPath)
 
-      checkIndexTags(res.text, 'PeerTube updated', 'my short description', 'body { background-color: red; }', resConfig.body)
+      checkIndexTags(res.text, 'PeerTube updated', 'my short description', 'body { background-color: red; }', config)
     })
   })
 
diff --git a/server/tests/external-plugins/auth-ldap.ts b/server/tests/external-plugins/auth-ldap.ts
index e4eae7e8c..acec69df5 100644
--- a/server/tests/external-plugins/auth-ldap.ts
+++ b/server/tests/external-plugins/auth-ldap.ts
@@ -2,46 +2,29 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import { User } from '@shared/models/users/user.model'
-import {
-  blockUser,
-  getMyUserInformation,
-  installPlugin,
-  setAccessTokensToServers,
-  unblockUser,
-  uninstallPlugin,
-  updatePluginSettings,
-  uploadVideo,
-  userLogin
-} from '../../../shared/extra-utils'
-import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Official plugin auth-ldap', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   let accessToken: string
   let userId: number
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-plugin-auth-ldap'
-    })
+    await server.plugins.install({ npmName: 'peertube-plugin-auth-ldap' })
   })
 
   it('Should not login with without LDAP settings', async function () {
-    await userLogin(server, { username: 'fry', password: 'fry' }, 400)
+    await server.login.login({ user: { username: 'fry', password: 'fry' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should not login with bad LDAP settings', async function () {
-    await updatePluginSettings({
-      url: server.url,
-      accessToken: server.accessToken,
+    await server.plugins.updateSettings({
       npmName: 'peertube-plugin-auth-ldap',
       settings: {
         'bind-credentials': 'GoodNewsEveryone',
@@ -55,13 +38,11 @@ describe('Official plugin auth-ldap', function () {
       }
     })
 
-    await userLogin(server, { username: 'fry', password: 'fry' }, 400)
+    await server.login.login({ user: { username: 'fry', password: 'fry' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should not login with good LDAP settings but wrong username/password', async function () {
-    await updatePluginSettings({
-      url: server.url,
-      accessToken: server.accessToken,
+    await server.plugins.updateSettings({
       npmName: 'peertube-plugin-auth-ldap',
       settings: {
         'bind-credentials': 'GoodNewsEveryone',
@@ -75,22 +56,20 @@ describe('Official plugin auth-ldap', function () {
       }
     })
 
-    await userLogin(server, { username: 'fry', password: 'bad password' }, 400)
-    await userLogin(server, { username: 'fryr', password: 'fry' }, 400)
+    await server.login.login({ user: { username: 'fry', password: 'bad password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await server.login.login({ user: { username: 'fryr', password: 'fry' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should login with the appropriate username/password', async function () {
-    accessToken = await userLogin(server, { username: 'fry', password: 'fry' })
+    accessToken = await server.login.getAccessToken({ username: 'fry', password: 'fry' })
   })
 
   it('Should login with the appropriate email/password', async function () {
-    accessToken = await userLogin(server, { username: 'fry@planetexpress.com', password: 'fry' })
+    accessToken = await server.login.getAccessToken({ username: 'fry@planetexpress.com', password: 'fry' })
   })
 
   it('Should login get my profile', async function () {
-    const res = await getMyUserInformation(server.url, accessToken)
-    const body: User = res.body
-
+    const body = await server.users.getMyInfo({ token: accessToken })
     expect(body.username).to.equal('fry')
     expect(body.email).to.equal('fry@planetexpress.com')
 
@@ -98,25 +77,31 @@ describe('Official plugin auth-ldap', function () {
   })
 
   it('Should upload a video', async function () {
-    await uploadVideo(server.url, accessToken, { name: 'my super video' })
+    await server.videos.upload({ token: accessToken, attributes: { name: 'my super video' } })
   })
 
   it('Should not be able to login if the user is banned', async function () {
-    await blockUser(server.url, userId, server.accessToken)
+    await server.users.banUser({ userId })
 
-    await userLogin(server, { username: 'fry@planetexpress.com', password: 'fry' }, 400)
+    await server.login.login({
+      user: { username: 'fry@planetexpress.com', password: 'fry' },
+      expectedStatus: HttpStatusCode.BAD_REQUEST_400
+    })
   })
 
   it('Should be able to login if the user is unbanned', async function () {
-    await unblockUser(server.url, userId, server.accessToken)
+    await server.users.unbanUser({ userId })
 
-    await userLogin(server, { username: 'fry@planetexpress.com', password: 'fry' })
+    await server.login.login({ user: { username: 'fry@planetexpress.com', password: 'fry' } })
   })
 
   it('Should not login if the plugin is uninstalled', async function () {
-    await uninstallPlugin({ url: server.url, accessToken: server.accessToken, npmName: 'peertube-plugin-auth-ldap' })
+    await server.plugins.uninstall({ npmName: 'peertube-plugin-auth-ldap' })
 
-    await userLogin(server, { username: 'fry@planetexpress.com', password: 'fry' }, 400)
+    await server.login.login({
+      user: { username: 'fry@planetexpress.com', password: 'fry' },
+      expectedStatus: HttpStatusCode.BAD_REQUEST_400
+    })
   })
 
   after(async function () {
diff --git a/server/tests/external-plugins/auto-block-videos.ts b/server/tests/external-plugins/auto-block-videos.ts
index 18ea17d78..0eb4bda9a 100644
--- a/server/tests/external-plugins/auto-block-videos.ts
+++ b/server/tests/external-plugins/auto-block-videos.ts
@@ -2,41 +2,29 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import { Video, VideoBlacklist } from '@shared/models'
 import {
+  cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  getBlacklistedVideosList,
-  getVideosList,
-  installPlugin,
+  killallServers,
   MockBlocklist,
-  removeVideoFromBlacklist,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updatePluginSettings,
-  uploadVideoAndGetId,
   wait
-} from '../../../shared/extra-utils'
-import {
-  cleanupTests,
-  flushAndRunMultipleServers,
-  killallServers,
-  reRunServer,
-  ServerInfo
-} from '../../../shared/extra-utils/server/servers'
+} from '@shared/extra-utils'
+import { Video } from '@shared/models'
 
-async function check (server: ServerInfo, videoUUID: string, exists = true) {
-  const res = await getVideosList(server.url)
+async function check (server: PeerTubeServer, videoUUID: string, exists = true) {
+  const { data } = await server.videos.list()
 
-  const video = res.body.data.find(v => v.uuid === videoUUID)
+  const video = data.find(v => v.uuid === videoUUID)
 
-  if (exists) {
-    expect(video).to.not.be.undefined
-  } else {
-    expect(video).to.be.undefined
-  }
+  if (exists) expect(video).to.not.be.undefined
+  else expect(video).to.be.undefined
 }
 
 describe('Official plugin auto-block videos', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let blocklistServer: MockBlocklist
   let server1Videos: Video[] = []
   let server2Videos: Video[] = []
@@ -45,42 +33,36 @@ describe('Official plugin auto-block videos', function () {
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     for (const server of servers) {
-      await installPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        npmName: 'peertube-plugin-auto-block-videos'
-      })
+      await server.plugins.install({ npmName: 'peertube-plugin-auto-block-videos' })
     }
 
     blocklistServer = new MockBlocklist()
     port = await blocklistServer.initialize()
 
-    await uploadVideoAndGetId({ server: servers[0], videoName: 'video server 1' })
-    await uploadVideoAndGetId({ server: servers[1], videoName: 'video server 2' })
-    await uploadVideoAndGetId({ server: servers[1], videoName: 'video 2 server 2' })
-    await uploadVideoAndGetId({ server: servers[1], videoName: 'video 3 server 2' })
+    await servers[0].videos.quickUpload({ name: 'video server 1' })
+    await servers[1].videos.quickUpload({ name: 'video server 2' })
+    await servers[1].videos.quickUpload({ name: 'video 2 server 2' })
+    await servers[1].videos.quickUpload({ name: 'video 3 server 2' })
 
     {
-      const res = await getVideosList(servers[0].url)
-      server1Videos = res.body.data.map(v => Object.assign(v, { url: servers[0].url + '/videos/watch/' + v.uuid }))
+      const { data } = await servers[0].videos.list()
+      server1Videos = data.map(v => Object.assign(v, { url: servers[0].url + '/videos/watch/' + v.uuid }))
     }
 
     {
-      const res = await getVideosList(servers[1].url)
-      server2Videos = res.body.data.map(v => Object.assign(v, { url: servers[1].url + '/videos/watch/' + v.uuid }))
+      const { data } = await servers[1].videos.list()
+      server2Videos = data.map(v => Object.assign(v, { url: servers[1].url + '/videos/watch/' + v.uuid }))
     }
 
     await doubleFollow(servers[0], servers[1])
   })
 
   it('Should update plugin settings', async function () {
-    await updatePluginSettings({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].plugins.updateSettings({
       npmName: 'peertube-plugin-auto-block-videos',
       settings: {
         'blocklist-urls': `http://localhost:${port}/blocklist`,
@@ -108,10 +90,9 @@ describe('Official plugin auto-block videos', function () {
   })
 
   it('Should have video in blacklists', async function () {
-    const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken })
-
-    const videoBlacklists = res.body.data as VideoBlacklist[]
+    const body = await servers[0].blacklist.list()
 
+    const videoBlacklists = body.data
     expect(videoBlacklists).to.have.lengthOf(1)
     expect(videoBlacklists[0].reason).to.contains('Automatically blocked from auto block plugin')
     expect(videoBlacklists[0].video.name).to.equal(server2Videos[0].name)
@@ -174,12 +155,12 @@ describe('Official plugin auto-block videos', function () {
 
     await check(servers[0], video.uuid, false)
 
-    await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, video.uuid)
+    await servers[0].blacklist.remove({ videoId: video.uuid })
 
     await check(servers[0], video.uuid, true)
 
-    killallServers([ servers[0] ])
-    await reRunServer(servers[0])
+    await killallServers([ servers[0] ])
+    await servers[0].run()
     await wait(2000)
 
     await check(servers[0], video.uuid, true)
diff --git a/server/tests/external-plugins/auto-mute.ts b/server/tests/external-plugins/auto-mute.ts
index 09355d932..271779dd4 100644
--- a/server/tests/external-plugins/auto-mute.ts
+++ b/server/tests/external-plugins/auto-mute.ts
@@ -3,63 +3,45 @@
 import 'mocha'
 import { expect } from 'chai'
 import {
-  addAccountToServerBlocklist,
-  addServerToAccountBlocklist,
-  removeAccountFromServerBlocklist
-} from '@shared/extra-utils/users/blocklist'
-import {
+  cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  getVideosList,
-  installPlugin,
+  killallServers,
   makeGetRequest,
   MockBlocklist,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updatePluginSettings,
-  uploadVideoAndGetId,
   wait
-} from '../../../shared/extra-utils'
-import {
-  cleanupTests,
-  flushAndRunMultipleServers,
-  killallServers,
-  reRunServer,
-  ServerInfo
-} from '../../../shared/extra-utils/server/servers'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Official plugin auto-mute', function () {
   const autoMuteListPath = '/plugins/auto-mute/router/api/v1/mute-list'
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let blocklistServer: MockBlocklist
   let port: number
 
   before(async function () {
     this.timeout(30000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     for (const server of servers) {
-      await installPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        npmName: 'peertube-plugin-auto-mute'
-      })
+      await server.plugins.install({ npmName: 'peertube-plugin-auto-mute' })
     }
 
     blocklistServer = new MockBlocklist()
     port = await blocklistServer.initialize()
 
-    await uploadVideoAndGetId({ server: servers[0], videoName: 'video server 1' })
-    await uploadVideoAndGetId({ server: servers[1], videoName: 'video server 2' })
+    await servers[0].videos.quickUpload({ name: 'video server 1' })
+    await servers[1].videos.quickUpload({ name: 'video server 2' })
 
     await doubleFollow(servers[0], servers[1])
   })
 
   it('Should update plugin settings', async function () {
-    await updatePluginSettings({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].plugins.updateSettings({
       npmName: 'peertube-plugin-auto-mute',
       settings: {
         'blocklist-urls': `http://localhost:${port}/blocklist`,
@@ -81,8 +63,8 @@ describe('Official plugin auto-mute', function () {
 
     await wait(2000)
 
-    const res = await getVideosList(servers[0].url)
-    expect(res.body.total).to.equal(1)
+    const { total } = await servers[0].videos.list()
+    expect(total).to.equal(1)
   })
 
   it('Should remove a server blocklist', async function () {
@@ -99,8 +81,8 @@ describe('Official plugin auto-mute', function () {
 
     await wait(2000)
 
-    const res = await getVideosList(servers[0].url)
-    expect(res.body.total).to.equal(2)
+    const { total } = await servers[0].videos.list()
+    expect(total).to.equal(2)
   })
 
   it('Should add an account blocklist', async function () {
@@ -116,8 +98,8 @@ describe('Official plugin auto-mute', function () {
 
     await wait(2000)
 
-    const res = await getVideosList(servers[0].url)
-    expect(res.body.total).to.equal(1)
+    const { total } = await servers[0].videos.list()
+    expect(total).to.equal(1)
   })
 
   it('Should remove an account blocklist', async function () {
@@ -134,8 +116,8 @@ describe('Official plugin auto-mute', function () {
 
     await wait(2000)
 
-    const res = await getVideosList(servers[0].url)
-    expect(res.body.total).to.equal(2)
+    const { total } = await servers[0].videos.list()
+    expect(total).to.equal(2)
   })
 
   it('Should auto mute an account, manually unmute it and do not remute it automatically', async function () {
@@ -155,24 +137,24 @@ describe('Official plugin auto-mute', function () {
     await wait(2000)
 
     {
-      const res = await getVideosList(servers[0].url)
-      expect(res.body.total).to.equal(1)
+      const { total } = await servers[0].videos.list()
+      expect(total).to.equal(1)
     }
 
-    await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, account)
+    await servers[0].blocklist.removeFromServerBlocklist({ account })
 
     {
-      const res = await getVideosList(servers[0].url)
-      expect(res.body.total).to.equal(2)
+      const { total } = await servers[0].videos.list()
+      expect(total).to.equal(2)
     }
 
-    killallServers([ servers[0] ])
-    await reRunServer(servers[0])
+    await killallServers([ servers[0] ])
+    await servers[0].run()
     await wait(2000)
 
     {
-      const res = await getVideosList(servers[0].url)
-      expect(res.body.total).to.equal(2)
+      const { total } = await servers[0].videos.list()
+      expect(total).to.equal(2)
     }
   })
 
@@ -180,14 +162,12 @@ describe('Official plugin auto-mute', function () {
     await makeGetRequest({
       url: servers[0].url,
       path: '/plugins/auto-mute/router/api/v1/mute-list',
-      statusCodeExpected: HttpStatusCode.FORBIDDEN_403
+      expectedStatus: HttpStatusCode.FORBIDDEN_403
     })
   })
 
   it('Should enable auto mute list', async function () {
-    await updatePluginSettings({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
+    await servers[0].plugins.updateSettings({
       npmName: 'peertube-plugin-auto-mute',
       settings: {
         'blocklist-urls': '',
@@ -199,16 +179,14 @@ describe('Official plugin auto-mute', function () {
     await makeGetRequest({
       url: servers[0].url,
       path: '/plugins/auto-mute/router/api/v1/mute-list',
-      statusCodeExpected: HttpStatusCode.OK_200
+      expectedStatus: HttpStatusCode.OK_200
     })
   })
 
   it('Should mute an account on server 1, and server 2 auto mutes it', async function () {
     this.timeout(20000)
 
-    await updatePluginSettings({
-      url: servers[1].url,
-      accessToken: servers[1].accessToken,
+    await servers[1].plugins.updateSettings({
       npmName: 'peertube-plugin-auto-mute',
       settings: {
         'blocklist-urls': 'http://localhost:' + servers[0].port + autoMuteListPath,
@@ -217,13 +195,13 @@ describe('Official plugin auto-mute', function () {
       }
     })
 
-    await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, 'root@localhost:' + servers[1].port)
-    await addServerToAccountBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
+    await servers[0].blocklist.addToServerBlocklist({ account: 'root@localhost:' + servers[1].port })
+    await servers[0].blocklist.addToMyBlocklist({ server: 'localhost:' + servers[1].port })
 
     const res = await makeGetRequest({
       url: servers[0].url,
       path: '/plugins/auto-mute/router/api/v1/mute-list',
-      statusCodeExpected: HttpStatusCode.OK_200
+      expectedStatus: HttpStatusCode.OK_200
     })
 
     const data = res.body.data
@@ -234,8 +212,8 @@ describe('Official plugin auto-mute', function () {
     await wait(2000)
 
     for (const server of servers) {
-      const res = await getVideosList(server.url)
-      expect(res.body.total).to.equal(1)
+      const { total } = await server.videos.list()
+      expect(total).to.equal(1)
     }
   })
 
diff --git a/server/tests/feeds/feeds.ts b/server/tests/feeds/feeds.ts
index 7bad81751..55b434846 100644
--- a/server/tests/feeds/feeds.ts
+++ b/server/tests/feeds/feeds.ts
@@ -4,34 +4,16 @@ import 'mocha'
 import * as chai from 'chai'
 import * as xmlParser from 'fast-xml-parser'
 import {
-  addAccountToAccountBlocklist,
-  addAccountToServerBlocklist,
-  removeAccountFromServerBlocklist
-} from '@shared/extra-utils/users/blocklist'
-import { addUserSubscription, listUserSubscriptionVideos } from '@shared/extra-utils/users/user-subscriptions'
-import { VideoPrivacy } from '@shared/models'
-import { ScopedToken } from '@shared/models/users/user-scoped-token'
-import {
   cleanupTests,
-  createUser,
+  createMultipleServers,
+  createSingleServer,
   doubleFollow,
-  flushAndRunMultipleServers,
-  flushAndRunServer,
-  getJSONfeed,
-  getMyUserInformation,
-  getUserScopedTokens,
-  getXMLfeed,
-  renewUserScopedTokens,
-  ServerInfo,
+  makeGetRequest,
+  PeerTubeServer,
   setAccessTokensToServers,
-  uploadVideo,
-  uploadVideoAndGetId,
-  userLogin
-} from '../../../shared/extra-utils'
-import { waitJobs } from '../../../shared/extra-utils/server/jobs'
-import { addVideoCommentThread } from '../../../shared/extra-utils/videos/video-comments'
-import { User } from '../../../shared/models/users'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+  waitJobs
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
 
 chai.use(require('chai-xml'))
 chai.use(require('chai-json-schema'))
@@ -39,8 +21,8 @@ chai.config.includeStack = true
 const expect = chai.expect
 
 describe('Test syndication feeds', () => {
-  let servers: ServerInfo[] = []
-  let serverHLSOnly: ServerInfo
+  let servers: PeerTubeServer[] = []
+  let serverHLSOnly: PeerTubeServer
   let userAccessToken: string
   let rootAccountId: number
   let rootChannelId: number
@@ -52,8 +34,8 @@ describe('Test syndication feeds', () => {
     this.timeout(120000)
 
     // Run servers
-    servers = await flushAndRunMultipleServers(2)
-    serverHLSOnly = await flushAndRunServer(3, {
+    servers = await createMultipleServers(2)
+    serverHLSOnly = await createSingleServer(3, {
       transcoding: {
         enabled: true,
         webtorrent: { enabled: false },
@@ -65,50 +47,43 @@ describe('Test syndication feeds', () => {
     await doubleFollow(servers[0], servers[1])
 
     {
-      const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
-      const user: User = res.body
+      const user = await servers[0].users.getMyInfo()
       rootAccountId = user.account.id
       rootChannelId = user.videoChannels[0].id
     }
 
     {
-      const attr = { username: 'john', password: 'password' }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: attr.username, password: attr.password })
-      userAccessToken = await userLogin(servers[0], attr)
+      userAccessToken = await servers[0].users.generateUserAndToken('john')
 
-      const res = await getMyUserInformation(servers[0].url, userAccessToken)
-      const user: User = res.body
+      const user = await servers[0].users.getMyInfo({ token: userAccessToken })
       userAccountId = user.account.id
       userChannelId = user.videoChannels[0].id
 
-      const res2 = await getUserScopedTokens(servers[0].url, userAccessToken)
-      const token: ScopedToken = res2.body
+      const token = await servers[0].users.getMyScopedTokens({ token: userAccessToken })
       userFeedToken = token.feedToken
     }
 
     {
-      await uploadVideo(servers[0].url, userAccessToken, { name: 'user video' })
+      await servers[0].videos.upload({ token: userAccessToken, attributes: { name: 'user video' } })
     }
 
     {
-      const videoAttributes = {
+      const attributes = {
         name: 'my super name for server 1',
         description: 'my super description for server 1',
         fixture: 'video_short.webm'
       }
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
-      const videoId = res.body.video.id
+      const { id } = await servers[0].videos.upload({ attributes })
 
-      await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoId, 'super comment 1')
-      await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoId, 'super comment 2')
+      await servers[0].comments.createThread({ videoId: id, text: 'super comment 1' })
+      await servers[0].comments.createThread({ videoId: id, text: 'super comment 2' })
     }
 
     {
-      const videoAttributes = { name: 'unlisted video', privacy: VideoPrivacy.UNLISTED }
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
-      const videoId = res.body.video.id
+      const attributes = { name: 'unlisted video', privacy: VideoPrivacy.UNLISTED }
+      const { id } = await servers[0].videos.upload({ attributes })
 
-      await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoId, 'comment on unlisted video')
+      await servers[0].comments.createThread({ videoId: id, text: 'comment on unlisted video' })
     }
 
     await waitJobs(servers)
@@ -118,30 +93,65 @@ describe('Test syndication feeds', () => {
 
     it('Should be well formed XML (covers RSS 2.0 and ATOM 1.0 endpoints)', async function () {
       for (const feed of [ 'video-comments' as 'video-comments', 'videos' as 'videos' ]) {
-        const rss = await getXMLfeed(servers[0].url, feed)
-        expect(rss.text).xml.to.be.valid()
+        const rss = await servers[0].feed.getXML({ feed })
+        expect(rss).xml.to.be.valid()
 
-        const atom = await getXMLfeed(servers[0].url, feed, 'atom')
-        expect(atom.text).xml.to.be.valid()
+        const atom = await servers[0].feed.getXML({ feed, format: 'atom' })
+        expect(atom).xml.to.be.valid()
       }
     })
 
     it('Should be well formed JSON (covers JSON feed 1.0 endpoint)', async function () {
       for (const feed of [ 'video-comments' as 'video-comments', 'videos' as 'videos' ]) {
-        const json = await getJSONfeed(servers[0].url, feed)
-        expect(JSON.parse(json.text)).to.be.jsonSchema({ type: 'object' })
+        const jsonText = await servers[0].feed.getJSON({ feed })
+        expect(JSON.parse(jsonText)).to.be.jsonSchema({ type: 'object' })
       }
     })
+
+    it('Should serve the endpoint with a classic request', async function () {
+      await makeGetRequest({
+        url: servers[0].url,
+        path: '/feeds/videos.xml',
+        accept: 'application/xml',
+        expectedStatus: HttpStatusCode.OK_200
+      })
+    })
+
+    it('Should serve the endpoint as a cached request', async function () {
+      const res = await makeGetRequest({
+        url: servers[0].url,
+        path: '/feeds/videos.xml',
+        accept: 'application/xml',
+        expectedStatus: HttpStatusCode.OK_200
+      })
+
+      expect(res.headers['x-api-cache-cached']).to.equal('true')
+    })
+
+    it('Should not serve the endpoint as a cached request', async function () {
+      const res = await makeGetRequest({
+        url: servers[0].url,
+        path: '/feeds/videos.xml?v=186',
+        accept: 'application/xml',
+        expectedStatus: HttpStatusCode.OK_200
+      })
+
+      expect(res.headers['x-api-cache-cached']).to.not.exist
+    })
+
+    it('Should refuse to serve the endpoint without accept header', async function () {
+      await makeGetRequest({ url: servers[0].url, path: '/feeds/videos.xml', expectedStatus: HttpStatusCode.NOT_ACCEPTABLE_406 })
+    })
   })
 
   describe('Videos feed', function () {
 
     it('Should contain a valid enclosure (covers RSS 2.0 endpoint)', async function () {
       for (const server of servers) {
-        const rss = await getXMLfeed(server.url, 'videos')
-        expect(xmlParser.validate(rss.text)).to.be.true
+        const rss = await server.feed.getXML({ feed: 'videos' })
+        expect(xmlParser.validate(rss)).to.be.true
 
-        const xmlDoc = xmlParser.parse(rss.text, { parseAttributeValue: true, ignoreAttributes: false })
+        const xmlDoc = xmlParser.parse(rss, { parseAttributeValue: true, ignoreAttributes: false })
 
         const enclosure = xmlDoc.rss.channel.item[0].enclosure
         expect(enclosure).to.exist
@@ -153,8 +163,8 @@ describe('Test syndication feeds', () => {
 
     it('Should contain a valid \'attachments\' object (covers JSON feed 1.0 endpoint)', async function () {
       for (const server of servers) {
-        const json = await getJSONfeed(server.url, 'videos')
-        const jsonObj = JSON.parse(json.text)
+        const json = await server.feed.getJSON({ feed: 'videos' })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(2)
         expect(jsonObj.items[0].attachments).to.exist
         expect(jsonObj.items[0].attachments.length).to.be.eq(1)
@@ -166,16 +176,16 @@ describe('Test syndication feeds', () => {
 
     it('Should filter by account', async function () {
       {
-        const json = await getJSONfeed(servers[0].url, 'videos', { accountId: rootAccountId })
-        const jsonObj = JSON.parse(json.text)
+        const json = await servers[0].feed.getJSON({ feed: 'videos', query: { accountId: rootAccountId } })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(1)
         expect(jsonObj.items[0].title).to.equal('my super name for server 1')
         expect(jsonObj.items[0].author.name).to.equal('root')
       }
 
       {
-        const json = await getJSONfeed(servers[0].url, 'videos', { accountId: userAccountId })
-        const jsonObj = JSON.parse(json.text)
+        const json = await servers[0].feed.getJSON({ feed: 'videos', query: { accountId: userAccountId } })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(1)
         expect(jsonObj.items[0].title).to.equal('user video')
         expect(jsonObj.items[0].author.name).to.equal('john')
@@ -183,15 +193,15 @@ describe('Test syndication feeds', () => {
 
       for (const server of servers) {
         {
-          const json = await getJSONfeed(server.url, 'videos', { accountName: 'root@localhost:' + servers[0].port })
-          const jsonObj = JSON.parse(json.text)
+          const json = await server.feed.getJSON({ feed: 'videos', query: { accountName: 'root@localhost:' + servers[0].port } })
+          const jsonObj = JSON.parse(json)
           expect(jsonObj.items.length).to.be.equal(1)
           expect(jsonObj.items[0].title).to.equal('my super name for server 1')
         }
 
         {
-          const json = await getJSONfeed(server.url, 'videos', { accountName: 'john@localhost:' + servers[0].port })
-          const jsonObj = JSON.parse(json.text)
+          const json = await server.feed.getJSON({ feed: 'videos', query: { accountName: 'john@localhost:' + servers[0].port } })
+          const jsonObj = JSON.parse(json)
           expect(jsonObj.items.length).to.be.equal(1)
           expect(jsonObj.items[0].title).to.equal('user video')
         }
@@ -200,16 +210,16 @@ describe('Test syndication feeds', () => {
 
     it('Should filter by video channel', async function () {
       {
-        const json = await getJSONfeed(servers[0].url, 'videos', { videoChannelId: rootChannelId })
-        const jsonObj = JSON.parse(json.text)
+        const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: rootChannelId } })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(1)
         expect(jsonObj.items[0].title).to.equal('my super name for server 1')
         expect(jsonObj.items[0].author.name).to.equal('root')
       }
 
       {
-        const json = await getJSONfeed(servers[0].url, 'videos', { videoChannelId: userChannelId })
-        const jsonObj = JSON.parse(json.text)
+        const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: userChannelId } })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(1)
         expect(jsonObj.items[0].title).to.equal('user video')
         expect(jsonObj.items[0].author.name).to.equal('john')
@@ -217,15 +227,17 @@ describe('Test syndication feeds', () => {
 
       for (const server of servers) {
         {
-          const json = await getJSONfeed(server.url, 'videos', { videoChannelName: 'root_channel@localhost:' + servers[0].port })
-          const jsonObj = JSON.parse(json.text)
+          const query = { videoChannelName: 'root_channel@localhost:' + servers[0].port }
+          const json = await server.feed.getJSON({ feed: 'videos', query })
+          const jsonObj = JSON.parse(json)
           expect(jsonObj.items.length).to.be.equal(1)
           expect(jsonObj.items[0].title).to.equal('my super name for server 1')
         }
 
         {
-          const json = await getJSONfeed(server.url, 'videos', { videoChannelName: 'john_channel@localhost:' + servers[0].port })
-          const jsonObj = JSON.parse(json.text)
+          const query = { videoChannelName: 'john_channel@localhost:' + servers[0].port }
+          const json = await server.feed.getJSON({ feed: 'videos', query })
+          const jsonObj = JSON.parse(json)
           expect(jsonObj.items.length).to.be.equal(1)
           expect(jsonObj.items[0].title).to.equal('user video')
         }
@@ -235,12 +247,12 @@ describe('Test syndication feeds', () => {
     it('Should correctly have videos feed with HLS only', async function () {
       this.timeout(120000)
 
-      await uploadVideo(serverHLSOnly.url, serverHLSOnly.accessToken, { name: 'hls only video' })
+      await serverHLSOnly.videos.upload({ attributes: { name: 'hls only video' } })
 
       await waitJobs([ serverHLSOnly ])
 
-      const json = await getJSONfeed(serverHLSOnly.url, 'videos')
-      const jsonObj = JSON.parse(json.text)
+      const json = await serverHLSOnly.feed.getJSON({ feed: 'videos' })
+      const jsonObj = JSON.parse(json)
       expect(jsonObj.items.length).to.be.equal(1)
       expect(jsonObj.items[0].attachments).to.exist
       expect(jsonObj.items[0].attachments.length).to.be.eq(4)
@@ -257,9 +269,9 @@ describe('Test syndication feeds', () => {
 
     it('Should contain valid comments (covers JSON feed 1.0 endpoint) and not from unlisted videos', async function () {
       for (const server of servers) {
-        const json = await getJSONfeed(server.url, 'video-comments')
+        const json = await server.feed.getJSON({ feed: 'video-comments' })
 
-        const jsonObj = JSON.parse(json.text)
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(2)
         expect(jsonObj.items[0].html_content).to.equal('super comment 2')
         expect(jsonObj.items[1].html_content).to.equal('super comment 1')
@@ -271,32 +283,32 @@ describe('Test syndication feeds', () => {
 
       const remoteHandle = 'root@localhost:' + servers[0].port
 
-      await addAccountToServerBlocklist(servers[1].url, servers[1].accessToken, remoteHandle)
+      await servers[1].blocklist.addToServerBlocklist({ account: remoteHandle })
 
       {
-        const json = await getJSONfeed(servers[1].url, 'video-comments', { version: 2 })
-        const jsonObj = JSON.parse(json.text)
+        const json = await servers[1].feed.getJSON({ feed: 'video-comments', query: { version: 2 } })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(0)
       }
 
-      await removeAccountFromServerBlocklist(servers[1].url, servers[1].accessToken, remoteHandle)
+      await servers[1].blocklist.removeFromServerBlocklist({ account: remoteHandle })
 
       {
-        const videoUUID = (await uploadVideoAndGetId({ server: servers[1], videoName: 'server 2' })).uuid
+        const videoUUID = (await servers[1].videos.quickUpload({ name: 'server 2' })).uuid
         await waitJobs(servers)
-        await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, 'super comment')
+        await servers[0].comments.createThread({ videoId: videoUUID, text: 'super comment' })
         await waitJobs(servers)
 
-        const json = await getJSONfeed(servers[1].url, 'video-comments', { version: 3 })
-        const jsonObj = JSON.parse(json.text)
+        const json = await servers[1].feed.getJSON({ feed: 'video-comments', query: { version: 3 } })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(3)
       }
 
-      await addAccountToAccountBlocklist(servers[1].url, servers[1].accessToken, remoteHandle)
+      await servers[1].blocklist.addToMyBlocklist({ account: remoteHandle })
 
       {
-        const json = await getJSONfeed(servers[1].url, 'video-comments', { version: 4 })
-        const jsonObj = JSON.parse(json.text)
+        const json = await servers[1].feed.getJSON({ feed: 'video-comments', query: { version: 4 } })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(2)
       }
     })
@@ -308,66 +320,64 @@ describe('Test syndication feeds', () => {
 
     it('Should list no videos for a user with no videos and no subscriptions', async function () {
       const attr = { username: 'feeduser', password: 'password' }
-      await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: attr.username, password: attr.password })
-      const feeduserAccessToken = await userLogin(servers[0], attr)
+      await servers[0].users.create({ username: attr.username, password: attr.password })
+      const feeduserAccessToken = await servers[0].login.getAccessToken(attr)
 
       {
-        const res = await getMyUserInformation(servers[0].url, feeduserAccessToken)
-        const user: User = res.body
+        const user = await servers[0].users.getMyInfo({ token: feeduserAccessToken })
         feeduserAccountId = user.account.id
       }
 
       {
-        const res = await getUserScopedTokens(servers[0].url, feeduserAccessToken)
-        const token: ScopedToken = res.body
+        const token = await servers[0].users.getMyScopedTokens({ token: feeduserAccessToken })
         feeduserFeedToken = token.feedToken
       }
 
       {
-        const res = await listUserSubscriptionVideos(servers[0].url, feeduserAccessToken)
-        expect(res.body.total).to.equal(0)
+        const body = await servers[0].subscriptions.listVideos({ token: feeduserAccessToken })
+        expect(body.total).to.equal(0)
 
-        const json = await getJSONfeed(servers[0].url, 'subscriptions', { accountId: feeduserAccountId, token: feeduserFeedToken })
-        const jsonObj = JSON.parse(json.text)
+        const query = { accountId: feeduserAccountId, token: feeduserFeedToken }
+        const json = await servers[0].feed.getJSON({ feed: 'subscriptions', query })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(0) // no subscription, it should not list the instance's videos but list 0 videos
       }
     })
 
     it('Should fail with an invalid token', async function () {
-      await getJSONfeed(servers[0].url, 'subscriptions', { accountId: feeduserAccountId, token: 'toto' }, HttpStatusCode.FORBIDDEN_403)
+      const query = { accountId: feeduserAccountId, token: 'toto' }
+      await servers[0].feed.getJSON({ feed: 'subscriptions', query, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a token of another user', async function () {
-      await getJSONfeed(
-        servers[0].url,
-        'subscriptions',
-        { accountId: feeduserAccountId, token: userFeedToken },
-        HttpStatusCode.FORBIDDEN_403
-      )
+      const query = { accountId: feeduserAccountId, token: userFeedToken }
+      await servers[0].feed.getJSON({ feed: 'subscriptions', query, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should list no videos for a user with videos but no subscriptions', async function () {
-      const res = await listUserSubscriptionVideos(servers[0].url, userAccessToken)
-      expect(res.body.total).to.equal(0)
+      const body = await servers[0].subscriptions.listVideos({ token: userAccessToken })
+      expect(body.total).to.equal(0)
 
-      const json = await getJSONfeed(servers[0].url, 'subscriptions', { accountId: userAccountId, token: userFeedToken })
-      const jsonObj = JSON.parse(json.text)
+      const query = { accountId: userAccountId, token: userFeedToken }
+      const json = await servers[0].feed.getJSON({ feed: 'subscriptions', query })
+      const jsonObj = JSON.parse(json)
       expect(jsonObj.items.length).to.be.equal(0) // no subscription, it should not list the instance's videos but list 0 videos
     })
 
     it('Should list self videos for a user with a subscription to themselves', async function () {
       this.timeout(30000)
 
-      await addUserSubscription(servers[0].url, userAccessToken, 'john_channel@localhost:' + servers[0].port)
+      await servers[0].subscriptions.add({ token: userAccessToken, targetUri: 'john_channel@localhost:' + servers[0].port })
       await waitJobs(servers)
 
       {
-        const res = await listUserSubscriptionVideos(servers[0].url, userAccessToken)
-        expect(res.body.total).to.equal(1)
-        expect(res.body.data[0].name).to.equal('user video')
+        const body = await servers[0].subscriptions.listVideos({ token: userAccessToken })
+        expect(body.total).to.equal(1)
+        expect(body.data[0].name).to.equal('user video')
 
-        const json = await getJSONfeed(servers[0].url, 'subscriptions', { accountId: userAccountId, token: userFeedToken, version: 1 })
-        const jsonObj = JSON.parse(json.text)
+        const query = { accountId: userAccountId, token: userFeedToken, version: 1 }
+        const json = await servers[0].feed.getJSON({ feed: 'subscriptions', query })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(1) // subscribed to self, it should not list the instance's videos but list john's
       }
     })
@@ -375,36 +385,33 @@ describe('Test syndication feeds', () => {
     it('Should list videos of a user\'s subscription', async function () {
       this.timeout(30000)
 
-      await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:' + servers[0].port)
+      await servers[0].subscriptions.add({ token: userAccessToken, targetUri: 'root_channel@localhost:' + servers[0].port })
       await waitJobs(servers)
 
       {
-        const res = await listUserSubscriptionVideos(servers[0].url, userAccessToken)
-        expect(res.body.total).to.equal(2, "there should be 2 videos part of the subscription")
+        const body = await servers[0].subscriptions.listVideos({ token: userAccessToken })
+        expect(body.total).to.equal(2, "there should be 2 videos part of the subscription")
 
-        const json = await getJSONfeed(servers[0].url, 'subscriptions', { accountId: userAccountId, token: userFeedToken, version: 2 })
-        const jsonObj = JSON.parse(json.text)
+        const query = { accountId: userAccountId, token: userFeedToken, version: 2 }
+        const json = await servers[0].feed.getJSON({ feed: 'subscriptions', query })
+        const jsonObj = JSON.parse(json)
         expect(jsonObj.items.length).to.be.equal(2) // subscribed to root, it should not list the instance's videos but list root/john's
       }
     })
 
     it('Should renew the token, and so have an invalid old token', async function () {
-      await renewUserScopedTokens(servers[0].url, userAccessToken)
-
-      await getJSONfeed(
-        servers[0].url,
-        'subscriptions',
-        { accountId: userAccountId, token: userFeedToken, version: 3 },
-        HttpStatusCode.FORBIDDEN_403
-      )
+      await servers[0].users.renewMyScopedTokens({ token: userAccessToken })
+
+      const query = { accountId: userAccountId, token: userFeedToken, version: 3 }
+      await servers[0].feed.getJSON({ feed: 'subscriptions', query, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should succeed with the new token', async function () {
-      const res2 = await getUserScopedTokens(servers[0].url, userAccessToken)
-      const token: ScopedToken = res2.body
+      const token = await servers[0].users.getMyScopedTokens({ token: userAccessToken })
       userFeedToken = token.feedToken
 
-      await getJSONfeed(servers[0].url, 'subscriptions', { accountId: userAccountId, token: userFeedToken, version: 4 })
+      const query = { accountId: userAccountId, token: userFeedToken, version: 4 }
+      await servers[0].feed.getJSON({ feed: 'subscriptions', query })
     })
 
   })
diff --git a/server/tests/fixtures/peertube-plugin-test-transcoding-one/main.js b/server/tests/fixtures/peertube-plugin-test-transcoding-one/main.js
index 59b136947..c4ae777f5 100644
--- a/server/tests/fixtures/peertube-plugin-test-transcoding-one/main.js
+++ b/server/tests/fixtures/peertube-plugin-test-transcoding-one/main.js
@@ -18,12 +18,12 @@ async function register ({ transcodingManager }) {
       const builder = (options) => {
         return {
           outputOptions: [
-            '-r:' + options.streamNum + ' 5'
+            '-r:' + options.streamNum + ' 50'
           ]
         }
       }
 
-      transcodingManager.addLiveProfile('libx264', 'low-live', builder)
+      transcodingManager.addLiveProfile('libx264', 'high-live', builder)
     }
   }
 
@@ -45,7 +45,7 @@ async function register ({ transcodingManager }) {
       const builder = () => {
         return {
           inputOptions: [
-            '-r 5'
+            '-r 50'
           ]
         }
       }
@@ -82,7 +82,6 @@ async function register ({ transcodingManager }) {
   }
 }
 
-
 async function unregister () {
   return
 }
diff --git a/server/tests/fixtures/peertube-plugin-test-video-constants/main.js b/server/tests/fixtures/peertube-plugin-test-video-constants/main.js
index 3e650e0a1..06527bd35 100644
--- a/server/tests/fixtures/peertube-plugin-test-video-constants/main.js
+++ b/server/tests/fixtures/peertube-plugin-test-video-constants/main.js
@@ -1,46 +1,46 @@
 async function register ({
-  registerHook,
-  registerSetting,
-  settingsManager,
-  storageManager,
   videoCategoryManager,
   videoLicenceManager,
   videoLanguageManager,
   videoPrivacyManager,
-  playlistPrivacyManager
+  playlistPrivacyManager,
+  getRouter
 }) {
-  videoLanguageManager.addLanguage('al_bhed', 'Al Bhed')
+  videoLanguageManager.addConstant('al_bhed', 'Al Bhed')
   videoLanguageManager.addLanguage('al_bhed2', 'Al Bhed 2')
-  videoLanguageManager.addLanguage('al_bhed3', 'Al Bhed 3')
-  videoLanguageManager.deleteLanguage('en')
+  videoLanguageManager.addConstant('al_bhed3', 'Al Bhed 3')
+  videoLanguageManager.deleteConstant('en')
   videoLanguageManager.deleteLanguage('fr')
-  videoLanguageManager.deleteLanguage('al_bhed3')
+  videoLanguageManager.deleteConstant('al_bhed3')
 
   videoCategoryManager.addCategory(42, 'Best category')
-  videoCategoryManager.addCategory(43, 'High best category')
-  videoCategoryManager.deleteCategory(1) // Music
+  videoCategoryManager.addConstant(43, 'High best category')
+  videoCategoryManager.deleteConstant(1) // Music
   videoCategoryManager.deleteCategory(2) // Films
 
   videoLicenceManager.addLicence(42, 'Best licence')
-  videoLicenceManager.addLicence(43, 'High best licence')
-  videoLicenceManager.deleteLicence(1) // Attribution
-  videoLicenceManager.deleteLicence(7) // Public domain
+  videoLicenceManager.addConstant(43, 'High best licence')
+  videoLicenceManager.deleteConstant(1) // Attribution
+  videoLicenceManager.deleteConstant(7) // Public domain
 
+  videoPrivacyManager.deleteConstant(2)
   videoPrivacyManager.deletePrivacy(2)
+  playlistPrivacyManager.deleteConstant(3)
   playlistPrivacyManager.deletePlaylistPrivacy(3)
-}
 
-async function unregister () {
-  return
+  {
+    const router = getRouter()
+    router.get('/reset-categories', (req, res) => {
+      videoCategoryManager.resetConstants()
+
+      res.sendStatus(204)
+    })
+  }
 }
 
+async function unregister () {}
+
 module.exports = {
   register,
   unregister
 }
-
-// ############################################################################
-
-function addToCount (obj) {
-  return Object.assign({}, obj, { count: obj.count + 1 })
-}
diff --git a/server/tests/fixtures/peertube-plugin-test/main.js b/server/tests/fixtures/peertube-plugin-test/main.js
index f8e6f0b98..db405ff31 100644
--- a/server/tests/fixtures/peertube-plugin-test/main.js
+++ b/server/tests/fixtures/peertube-plugin-test/main.js
@@ -234,7 +234,7 @@ async function register ({ registerHook, registerSetting, settingsManager, stora
   })
 
   {
-    const searchHooks = [
+    const filterHooks = [
       'filter:api.search.videos.local.list.params',
       'filter:api.search.videos.local.list.result',
       'filter:api.search.videos.index.list.params',
@@ -246,10 +246,13 @@ async function register ({ registerHook, registerSetting, settingsManager, stora
       'filter:api.search.video-playlists.local.list.params',
       'filter:api.search.video-playlists.local.list.result',
       'filter:api.search.video-playlists.index.list.params',
-      'filter:api.search.video-playlists.index.list.result'
+      'filter:api.search.video-playlists.index.list.result',
+
+      'filter:api.overviews.videos.list.params',
+      'filter:api.overviews.videos.list.result'
     ]
 
-    for (const h of searchHooks) {
+    for (const h of filterHooks) {
       registerHook({
         target: h,
         handler: (obj) => {
diff --git a/server/tests/fixtures/video_very_short_240p.mp4 b/server/tests/fixtures/video_very_short_240p.mp4
new file mode 100644
index 000000000..95b6be92a
--- /dev/null
+++ b/server/tests/fixtures/video_very_short_240p.mp4
diff --git a/server/tests/helpers/comment-model.ts b/server/tests/helpers/comment-model.ts
index 4c51b7000..31dc6ec72 100644
--- a/server/tests/helpers/comment-model.ts
+++ b/server/tests/helpers/comment-model.ts
@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import { VideoCommentModel } from '../../models/video/video-comment'
 
 const expect = chai.expect
diff --git a/server/tests/helpers/core-utils.ts b/server/tests/helpers/core-utils.ts
index c028b316d..d5cac51a3 100644
--- a/server/tests/helpers/core-utils.ts
+++ b/server/tests/helpers/core-utils.ts
@@ -1,10 +1,10 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
+import * as chai from 'chai'
 import { snakeCase } from 'lodash'
-import { objectConverter, parseBytes } from '../../helpers/core-utils'
 import validator from 'validator'
+import { objectConverter, parseBytes } from '../../helpers/core-utils'
 
 const expect = chai.expect
 
diff --git a/server/tests/helpers/image.ts b/server/tests/helpers/image.ts
index 54911697f..9fe9aa4cb 100644
--- a/server/tests/helpers/image.ts
+++ b/server/tests/helpers/image.ts
@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
+import { expect } from 'chai'
 import { readFile, remove } from 'fs-extra'
 import { join } from 'path'
 import { processImage } from '../../../server/helpers/image-utils'
 import { buildAbsoluteFixturePath, root } from '../../../shared/extra-utils'
-import { expect } from 'chai'
 
 async function checkBuffers (path1: string, path2: string, equals: boolean) {
   const [ buf1, buf2 ] = await Promise.all([
diff --git a/server/tests/helpers/request.ts b/server/tests/helpers/request.ts
index 5e77f129e..7f7873df3 100644
--- a/server/tests/helpers/request.ts
+++ b/server/tests/helpers/request.ts
@@ -4,7 +4,7 @@ import 'mocha'
 import { expect } from 'chai'
 import { pathExists, remove } from 'fs-extra'
 import { join } from 'path'
-import { get4KFileUrl, root, wait } from '../../../shared/extra-utils'
+import { FIXTURE_URLS, root, wait } from '../../../shared/extra-utils'
 import { doRequest, doRequestAndSaveToFile } from '../../helpers/requests'
 
 describe('Request helpers', function () {
@@ -13,7 +13,7 @@ describe('Request helpers', function () {
 
   it('Should throw an error when the bytes limit is exceeded for request', async function () {
     try {
-      await doRequest(get4KFileUrl(), { bodyKBLimit: 3 })
+      await doRequest(FIXTURE_URLS.video4K, { bodyKBLimit: 3 })
     } catch {
       return
     }
@@ -23,7 +23,7 @@ describe('Request helpers', function () {
 
   it('Should throw an error when the bytes limit is exceeded for request and save file', async function () {
     try {
-      await doRequestAndSaveToFile(get4KFileUrl(), destPath1, { bodyKBLimit: 3 })
+      await doRequestAndSaveToFile(FIXTURE_URLS.video4K, destPath1, { bodyKBLimit: 3 })
     } catch {
 
       await wait(500)
@@ -35,8 +35,8 @@ describe('Request helpers', function () {
   })
 
   it('Should succeed if the file is below the limit', async function () {
-    await doRequest(get4KFileUrl(), { bodyKBLimit: 5 })
-    await doRequestAndSaveToFile(get4KFileUrl(), destPath2, { bodyKBLimit: 5 })
+    await doRequest(FIXTURE_URLS.video4K, { bodyKBLimit: 5 })
+    await doRequestAndSaveToFile(FIXTURE_URLS.video4K, destPath2, { bodyKBLimit: 5 })
 
     expect(await pathExists(destPath2)).to.be.true
   })
diff --git a/server/tests/index.ts b/server/tests/index.ts
index 3fbd0ebbd..1718ac424 100644
--- a/server/tests/index.ts
+++ b/server/tests/index.ts
@@ -6,3 +6,4 @@ import './cli/'
 import './api/'
 import './plugins/'
 import './helpers/'
+import './lib/'
diff --git a/server/tests/lib/index.ts b/server/tests/lib/index.ts
new file mode 100644
index 000000000..a40df35fd
--- /dev/null
+++ b/server/tests/lib/index.ts
@@ -0,0 +1 @@
+export * from './video-constant-registry-factory'
diff --git a/server/tests/lib/video-constant-registry-factory.ts b/server/tests/lib/video-constant-registry-factory.ts
new file mode 100644
index 000000000..e26b286e1
--- /dev/null
+++ b/server/tests/lib/video-constant-registry-factory.ts
@@ -0,0 +1,155 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+import 'mocha'
+import { expect } from 'chai'
+import { VideoConstantManagerFactory } from '@server/lib/plugins/video-constant-manager-factory'
+import {
+  VIDEO_CATEGORIES,
+  VIDEO_LANGUAGES,
+  VIDEO_LICENCES,
+  VIDEO_PLAYLIST_PRIVACIES,
+  VIDEO_PRIVACIES
+} from '@server/initializers/constants'
+import {
+  VideoPlaylistPrivacy,
+  VideoPrivacy
+} from '@shared/models'
+
+describe('VideoConstantManagerFactory', function () {
+  const factory = new VideoConstantManagerFactory('peertube-plugin-constants')
+
+  afterEach(() => {
+    factory.resetVideoConstants('peertube-plugin-constants')
+  })
+
+  describe('VideoCategoryManager', () => {
+    const videoCategoryManager = factory.createVideoConstantManager<number>('category')
+
+    it('Should be able to list all video category constants', () => {
+      const constants = videoCategoryManager.getConstants()
+      expect(constants).to.deep.equal(VIDEO_CATEGORIES)
+    })
+
+    it('Should be able to delete a video category constant', () => {
+      const successfullyDeleted = videoCategoryManager.deleteConstant(1)
+      expect(successfullyDeleted).to.be.true
+      expect(videoCategoryManager.getConstantValue(1)).to.be.undefined
+    })
+
+    it('Should be able to add a video category constant', () => {
+      const successfullyAdded = videoCategoryManager.addConstant(42, 'The meaning of life')
+      expect(successfullyAdded).to.be.true
+      expect(videoCategoryManager.getConstantValue(42)).to.equal('The meaning of life')
+    })
+
+    it('Should be able to reset video category constants', () => {
+      videoCategoryManager.deleteConstant(1)
+      videoCategoryManager.resetConstants()
+      expect(videoCategoryManager.getConstantValue(1)).not.be.undefined
+    })
+  })
+
+  describe('VideoLicenceManager', () => {
+    const videoLicenceManager = factory.createVideoConstantManager<number>('licence')
+    it('Should be able to list all video licence constants', () => {
+      const constants = videoLicenceManager.getConstants()
+      expect(constants).to.deep.equal(VIDEO_LICENCES)
+    })
+
+    it('Should be able to delete a video licence constant', () => {
+      const successfullyDeleted = videoLicenceManager.deleteConstant(1)
+      expect(successfullyDeleted).to.be.true
+      expect(videoLicenceManager.getConstantValue(1)).to.be.undefined
+    })
+
+    it('Should be able to add a video licence constant', () => {
+      const successfullyAdded = videoLicenceManager.addConstant(42, 'European Union Public Licence')
+      expect(successfullyAdded).to.be.true
+      expect(videoLicenceManager.getConstantValue(42)).to.equal('European Union Public Licence')
+    })
+
+    it('Should be able to reset video licence constants', () => {
+      videoLicenceManager.deleteConstant(1)
+      videoLicenceManager.resetConstants()
+      expect(videoLicenceManager.getConstantValue(1)).not.be.undefined
+    })
+  })
+
+  describe('PlaylistPrivacyManager', () => {
+    const playlistPrivacyManager = factory.createVideoConstantManager<VideoPlaylistPrivacy>('playlistPrivacy')
+    it('Should be able to list all video playlist privacy constants', () => {
+      const constants = playlistPrivacyManager.getConstants()
+      expect(constants).to.deep.equal(VIDEO_PLAYLIST_PRIVACIES)
+    })
+
+    it('Should be able to delete a video playlist privacy constant', () => {
+      const successfullyDeleted = playlistPrivacyManager.deleteConstant(1)
+      expect(successfullyDeleted).to.be.true
+      expect(playlistPrivacyManager.getConstantValue(1)).to.be.undefined
+    })
+
+    it('Should be able to add a video playlist privacy constant', () => {
+      const successfullyAdded = playlistPrivacyManager.addConstant(42, 'Friends only')
+      expect(successfullyAdded).to.be.true
+      expect(playlistPrivacyManager.getConstantValue(42)).to.equal('Friends only')
+    })
+
+    it('Should be able to reset video playlist privacy constants', () => {
+      playlistPrivacyManager.deleteConstant(1)
+      playlistPrivacyManager.resetConstants()
+      expect(playlistPrivacyManager.getConstantValue(1)).not.be.undefined
+    })
+  })
+
+  describe('VideoPrivacyManager', () => {
+    const videoPrivacyManager = factory.createVideoConstantManager<VideoPrivacy>('privacy')
+    it('Should be able to list all video privacy constants', () => {
+      const constants = videoPrivacyManager.getConstants()
+      expect(constants).to.deep.equal(VIDEO_PRIVACIES)
+    })
+
+    it('Should be able to delete a video privacy constant', () => {
+      const successfullyDeleted = videoPrivacyManager.deleteConstant(1)
+      expect(successfullyDeleted).to.be.true
+      expect(videoPrivacyManager.getConstantValue(1)).to.be.undefined
+    })
+
+    it('Should be able to add a video privacy constant', () => {
+      const successfullyAdded = videoPrivacyManager.addConstant(42, 'Friends only')
+      expect(successfullyAdded).to.be.true
+      expect(videoPrivacyManager.getConstantValue(42)).to.equal('Friends only')
+    })
+
+    it('Should be able to reset video privacy constants', () => {
+      videoPrivacyManager.deleteConstant(1)
+      videoPrivacyManager.resetConstants()
+      expect(videoPrivacyManager.getConstantValue(1)).not.be.undefined
+    })
+  })
+
+  describe('VideoLanguageManager', () => {
+    const videoLanguageManager = factory.createVideoConstantManager<string>('language')
+    it('Should be able to list all video language constants', () => {
+      const constants = videoLanguageManager.getConstants()
+      expect(constants).to.deep.equal(VIDEO_LANGUAGES)
+    })
+
+    it('Should be able to add a video language constant', () => {
+      const successfullyAdded = videoLanguageManager.addConstant('fr', 'Fr occitan')
+      expect(successfullyAdded).to.be.true
+      expect(videoLanguageManager.getConstantValue('fr')).to.equal('Fr occitan')
+    })
+
+    it('Should be able to delete a video language constant', () => {
+      videoLanguageManager.addConstant('fr', 'Fr occitan')
+      const successfullyDeleted = videoLanguageManager.deleteConstant('fr')
+      expect(successfullyDeleted).to.be.true
+      expect(videoLanguageManager.getConstantValue('fr')).to.be.undefined
+    })
+
+    it('Should be able to reset video language constants', () => {
+      videoLanguageManager.addConstant('fr', 'Fr occitan')
+      videoLanguageManager.resetConstants()
+      expect(videoLanguageManager.getConstantValue('fr')).to.be.undefined
+    })
+  })
+})
diff --git a/server/tests/misc-endpoints.ts b/server/tests/misc-endpoints.ts
index 09e5afcf9..4968eef08 100644
--- a/server/tests/misc-endpoints.ts
+++ b/server/tests/misc-endpoints.ts
@@ -2,28 +2,18 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import {
-  addVideoChannel,
-  cleanupTests,
-  createUser,
-  flushAndRunServer,
-  makeGetRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo
-} from '../../shared/extra-utils'
-import { VideoPrivacy } from '../../shared/models/videos'
-import { HttpStatusCode } from '@shared/core-utils'
+import { cleanupTests, createSingleServer, makeGetRequest, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test misc endpoints', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   before(async function () {
     this.timeout(120000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
   })
 
@@ -33,7 +23,7 @@ describe('Test misc endpoints', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/.well-known/security.txt',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.text).to.contain('security issue')
@@ -43,7 +33,7 @@ describe('Test misc endpoints', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/.well-known/nodeinfo',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body.links).to.be.an('array')
@@ -55,7 +45,7 @@ describe('Test misc endpoints', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/.well-known/dnt-policy.txt',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.text).to.contain('http://www.w3.org/TR/tracking-dnt')
@@ -65,7 +55,7 @@ describe('Test misc endpoints', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/.well-known/dnt',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body.tracking).to.equal('N')
@@ -75,7 +65,7 @@ describe('Test misc endpoints', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/.well-known/change-password',
-        statusCodeExpected: HttpStatusCode.FOUND_302
+        expectedStatus: HttpStatusCode.FOUND_302
       })
 
       expect(res.header.location).to.equal('/my-account/settings')
@@ -88,7 +78,7 @@ describe('Test misc endpoints', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/.well-known/webfinger?resource=' + resource,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       const data = res.body
@@ -113,7 +103,7 @@ describe('Test misc endpoints', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/robots.txt',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.text).to.contain('User-agent')
@@ -123,7 +113,7 @@ describe('Test misc endpoints', function () {
       await makeGetRequest({
         url: server.url,
         path: '/security.txt',
-        statusCodeExpected: HttpStatusCode.MOVED_PERMANENTLY_301
+        expectedStatus: HttpStatusCode.MOVED_PERMANENTLY_301
       })
     })
 
@@ -131,7 +121,7 @@ describe('Test misc endpoints', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/nodeinfo/2.0.json',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body.software.name).to.equal('peertube')
@@ -146,7 +136,7 @@ describe('Test misc endpoints', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/sitemap.xml',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.text).to.contain('xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"')
@@ -157,7 +147,7 @@ describe('Test misc endpoints', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: '/sitemap.xml',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.text).to.contain('xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"')
@@ -167,20 +157,20 @@ describe('Test misc endpoints', function () {
     it('Should add videos, channel and accounts and get sitemap', async function () {
       this.timeout(35000)
 
-      await uploadVideo(server.url, server.accessToken, { name: 'video 1', nsfw: false })
-      await uploadVideo(server.url, server.accessToken, { name: 'video 2', nsfw: false })
-      await uploadVideo(server.url, server.accessToken, { name: 'video 3', privacy: VideoPrivacy.PRIVATE })
+      await server.videos.upload({ attributes: { name: 'video 1', nsfw: false } })
+      await server.videos.upload({ attributes: { name: 'video 2', nsfw: false } })
+      await server.videos.upload({ attributes: { name: 'video 3', privacy: VideoPrivacy.PRIVATE } })
 
-      await addVideoChannel(server.url, server.accessToken, { name: 'channel1', displayName: 'channel 1' })
-      await addVideoChannel(server.url, server.accessToken, { name: 'channel2', displayName: 'channel 2' })
+      await server.channels.create({ attributes: { name: 'channel1', displayName: 'channel 1' } })
+      await server.channels.create({ attributes: { name: 'channel2', displayName: 'channel 2' } })
 
-      await createUser({ url: server.url, accessToken: server.accessToken, username: 'user1', password: 'password' })
-      await createUser({ url: server.url, accessToken: server.accessToken, username: 'user2', password: 'password' })
+      await server.users.create({ username: 'user1', password: 'password' })
+      await server.users.create({ username: 'user2', password: 'password' })
 
       const res = await makeGetRequest({
         url: server.url,
         path: '/sitemap.xml?t=1', // avoid using cache
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.text).to.contain('xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"')
diff --git a/server/tests/plugins/action-hooks.ts b/server/tests/plugins/action-hooks.ts
index 0f57ef7fe..4c1bc7d06 100644
--- a/server/tests/plugins/action-hooks.ts
+++ b/server/tests/plugins/action-hooks.ts
@@ -1,63 +1,38 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { ServerHookName, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
-import {
-  addVideoCommentReply,
-  addVideoCommentThread,
-  addVideoInPlaylist,
-  blockUser,
-  createLive,
-  createUser,
-  createVideoPlaylist,
-  deleteVideoComment,
-  getPluginTestPath,
-  installPlugin,
-  registerUser,
-  removeUser,
-  setAccessTokensToServers,
-  setDefaultVideoChannel,
-  unblockUser,
-  updateUser,
-  updateVideo,
-  uploadVideo,
-  userLogin,
-  viewVideo
-} from '../../../shared/extra-utils'
 import {
   cleanupTests,
-  flushAndRunMultipleServers,
+  createMultipleServers,
   killallServers,
-  reRunServer,
-  ServerInfo,
-  waitUntilLog
-} from '../../../shared/extra-utils/server/servers'
+  PeerTubeServer,
+  PluginsCommand,
+  setAccessTokensToServers,
+  setDefaultVideoChannel
+} from '@shared/extra-utils'
+import { ServerHookName, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
 
 describe('Test plugin action hooks', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let videoUUID: string
   let threadId: number
 
   function checkHook (hook: ServerHookName) {
-    return waitUntilLog(servers[0], 'Run hook ' + hook)
+    return servers[0].servers.waitUntilLog('Run hook ' + hook)
   }
 
   before(async function () {
     this.timeout(30000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
 
-    await installPlugin({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      path: getPluginTestPath()
-    })
+    await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath() })
 
-    killallServers([ servers[0] ])
+    await killallServers([ servers[0] ])
 
-    await reRunServer(servers[0], {
+    await servers[0].run({
       live: {
         enabled: true
       }
@@ -73,20 +48,20 @@ describe('Test plugin action hooks', function () {
   describe('Videos hooks', function () {
 
     it('Should run action:api.video.uploaded', async function () {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video' })
-      videoUUID = res.body.video.uuid
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video' } })
+      videoUUID = uuid
 
       await checkHook('action:api.video.uploaded')
     })
 
     it('Should run action:api.video.updated', async function () {
-      await updateVideo(servers[0].url, servers[0].accessToken, videoUUID, { name: 'video updated' })
+      await servers[0].videos.update({ id: videoUUID, attributes: { name: 'video updated' } })
 
       await checkHook('action:api.video.updated')
     })
 
     it('Should run action:api.video.viewed', async function () {
-      await viewVideo(servers[0].url, videoUUID)
+      await servers[0].videos.view({ id: videoUUID })
 
       await checkHook('action:api.video.viewed')
     })
@@ -98,10 +73,10 @@ describe('Test plugin action hooks', function () {
       const attributes = {
         name: 'live',
         privacy: VideoPrivacy.PUBLIC,
-        channelId: servers[0].videoChannel.id
+        channelId: servers[0].store.channel.id
       }
 
-      await createLive(servers[0].url, servers[0].accessToken, attributes)
+      await servers[0].live.create({ fields: attributes })
 
       await checkHook('action:api.live-video.created')
     })
@@ -109,20 +84,20 @@ describe('Test plugin action hooks', function () {
 
   describe('Comments hooks', function () {
     it('Should run action:api.video-thread.created', async function () {
-      const res = await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, 'thread')
-      threadId = res.body.comment.id
+      const created = await servers[0].comments.createThread({ videoId: videoUUID, text: 'thread' })
+      threadId = created.id
 
       await checkHook('action:api.video-thread.created')
     })
 
     it('Should run action:api.video-comment-reply.created', async function () {
-      await addVideoCommentReply(servers[0].url, servers[0].accessToken, videoUUID, threadId, 'reply')
+      await servers[0].comments.addReply({ videoId: videoUUID, toCommentId: threadId, text: 'reply' })
 
       await checkHook('action:api.video-comment-reply.created')
     })
 
     it('Should run action:api.video-comment.deleted', async function () {
-      await deleteVideoComment(servers[0].url, servers[0].accessToken, videoUUID, threadId)
+      await servers[0].comments.delete({ videoId: videoUUID, commentId: threadId })
 
       await checkHook('action:api.video-comment.deleted')
     })
@@ -132,49 +107,44 @@ describe('Test plugin action hooks', function () {
     let userId: number
 
     it('Should run action:api.user.registered', async function () {
-      await registerUser(servers[0].url, 'registered_user', 'super_password')
+      await servers[0].users.register({ username: 'registered_user' })
 
       await checkHook('action:api.user.registered')
     })
 
     it('Should run action:api.user.created', async function () {
-      const res = await createUser({
-        url: servers[0].url,
-        accessToken: servers[0].accessToken,
-        username: 'created_user',
-        password: 'super_password'
-      })
-      userId = res.body.user.id
+      const user = await servers[0].users.create({ username: 'created_user' })
+      userId = user.id
 
       await checkHook('action:api.user.created')
     })
 
     it('Should run action:api.user.oauth2-got-token', async function () {
-      await userLogin(servers[0], { username: 'created_user', password: 'super_password' })
+      await servers[0].login.login({ user: { username: 'created_user' } })
 
       await checkHook('action:api.user.oauth2-got-token')
     })
 
     it('Should run action:api.user.blocked', async function () {
-      await blockUser(servers[0].url, userId, servers[0].accessToken)
+      await servers[0].users.banUser({ userId })
 
       await checkHook('action:api.user.blocked')
     })
 
     it('Should run action:api.user.unblocked', async function () {
-      await unblockUser(servers[0].url, userId, servers[0].accessToken)
+      await servers[0].users.unbanUser({ userId })
 
       await checkHook('action:api.user.unblocked')
     })
 
     it('Should run action:api.user.updated', async function () {
-      await updateUser({ url: servers[0].url, accessToken: servers[0].accessToken, userId, videoQuota: 50 })
+      await servers[0].users.update({ userId, videoQuota: 50 })
 
       await checkHook('action:api.user.updated')
     })
 
     it('Should run action:api.user.deleted', async function () {
-      await removeUser(servers[0].url, userId, servers[0].accessToken)
+      await servers[0].users.remove({ userId })
 
       await checkHook('action:api.user.deleted')
     })
@@ -186,30 +156,23 @@ describe('Test plugin action hooks', function () {
 
     before(async function () {
       {
-        const res = await createVideoPlaylist({
-          url: servers[0].url,
-          token: servers[0].accessToken,
-          playlistAttrs: {
+        const { id } = await servers[0].playlists.create({
+          attributes: {
             displayName: 'My playlist',
             privacy: VideoPlaylistPrivacy.PRIVATE
           }
         })
-        playlistId = res.body.videoPlaylist.id
+        playlistId = id
       }
 
       {
-        const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'my super name' })
-        videoId = res.body.video.id
+        const { id } = await servers[0].videos.upload({ attributes: { name: 'my super name' } })
+        videoId = id
       }
     })
 
     it('Should run action:api.video-playlist-element.created', async function () {
-      await addVideoInPlaylist({
-        url: servers[0].url,
-        token: servers[0].accessToken,
-        playlistId,
-        elementAttrs: { videoId }
-      })
+      await servers[0].playlists.addElement({ playlistId, attributes: { videoId } })
 
       await checkHook('action:api.video-playlist-element.created')
     })
diff --git a/server/tests/plugins/external-auth.ts b/server/tests/plugins/external-auth.ts
index 5addb45c7..f3e018d43 100644
--- a/server/tests/plugins/external-auth.ts
+++ b/server/tests/plugins/external-auth.ts
@@ -2,44 +2,32 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import { ServerConfig, User, UserRole } from '@shared/models'
 import {
+  cleanupTests,
+  createSingleServer,
   decodeQueryString,
-  getConfig,
-  getExternalAuth,
-  getMyUserInformation,
-  getPluginTestPath,
-  installPlugin,
-  loginUsingExternalToken,
-  logout,
-  refreshToken,
+  PeerTubeServer,
+  PluginsCommand,
   setAccessTokensToServers,
-  uninstallPlugin,
-  updateMyUser,
-  wait,
-  userLogin,
-  updatePluginSettings,
-  createUser
-} from '../../../shared/extra-utils'
-import { cleanupTests, flushAndRunServer, ServerInfo, waitUntilLog } from '../../../shared/extra-utils/server/servers'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+  wait
+} from '@shared/extra-utils'
+import { HttpStatusCode, UserRole } from '@shared/models'
 
 async function loginExternal (options: {
-  server: ServerInfo
+  server: PeerTubeServer
   npmName: string
   authName: string
   username: string
   query?: any
-  statusCodeExpected?: HttpStatusCode
-  statusCodeExpectedStep2?: HttpStatusCode
+  expectedStatus?: HttpStatusCode
+  expectedStatusStep2?: HttpStatusCode
 }) {
-  const res = await getExternalAuth({
-    url: options.server.url,
+  const res = await options.server.plugins.getExternalAuth({
     npmName: options.npmName,
     npmVersion: '0.0.1',
     authName: options.authName,
     query: options.query,
-    statusCodeExpected: options.statusCodeExpected || HttpStatusCode.FOUND_302
+    expectedStatus: options.expectedStatus || HttpStatusCode.FOUND_302
   })
 
   if (res.status !== HttpStatusCode.FOUND_302) return
@@ -47,18 +35,17 @@ async function loginExternal (options: {
   const location = res.header.location
   const { externalAuthToken } = decodeQueryString(location)
 
-  const resLogin = await loginUsingExternalToken(
-    options.server,
-    options.username,
-    externalAuthToken as string,
-    options.statusCodeExpectedStep2
-  )
+  const resLogin = await options.server.login.loginUsingExternalToken({
+    username: options.username,
+    externalAuthToken: externalAuthToken as string,
+    expectedStatus: options.expectedStatusStep2
+  })
 
   return resLogin.body
 }
 
 describe('Test external auth plugins', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   let cyanAccessToken: string
   let cyanRefreshToken: string
@@ -71,22 +58,16 @@ describe('Test external auth plugins', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
     for (const suffix of [ 'one', 'two', 'three' ]) {
-      await installPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        path: getPluginTestPath('-external-auth-' + suffix)
-      })
+      await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-external-auth-' + suffix) })
     }
   })
 
   it('Should display the correct configuration', async function () {
-    const res = await getConfig(server.url)
-
-    const config: ServerConfig = res.body
+    const config = await server.config.getConfig()
 
     const auths = config.plugin.registeredExternalAuths
     expect(auths).to.have.lengthOf(8)
@@ -98,15 +79,14 @@ describe('Test external auth plugins', function () {
   })
 
   it('Should redirect for a Cyan login', async function () {
-    const res = await getExternalAuth({
-      url: server.url,
+    const res = await server.plugins.getExternalAuth({
       npmName: 'test-external-auth-one',
       npmVersion: '0.0.1',
       authName: 'external-auth-1',
       query: {
         username: 'cyan'
       },
-      statusCodeExpected: HttpStatusCode.FOUND_302
+      expectedStatus: HttpStatusCode.FOUND_302
     })
 
     const location = res.header.location
@@ -121,13 +101,17 @@ describe('Test external auth plugins', function () {
   })
 
   it('Should reject auto external login with a missing or invalid token', async function () {
-    await loginUsingExternalToken(server, 'cyan', '', HttpStatusCode.BAD_REQUEST_400)
-    await loginUsingExternalToken(server, 'cyan', 'blabla', HttpStatusCode.BAD_REQUEST_400)
+    const command = server.login
+
+    await command.loginUsingExternalToken({ username: 'cyan', externalAuthToken: '', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await command.loginUsingExternalToken({ username: 'cyan', externalAuthToken: 'blabla', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should reject auto external login with a missing or invalid username', async function () {
-    await loginUsingExternalToken(server, '', externalAuthToken, HttpStatusCode.BAD_REQUEST_400)
-    await loginUsingExternalToken(server, '', externalAuthToken, HttpStatusCode.BAD_REQUEST_400)
+    const command = server.login
+
+    await command.loginUsingExternalToken({ username: '', externalAuthToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await command.loginUsingExternalToken({ username: '', externalAuthToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should reject auto external login with an expired token', async function () {
@@ -135,9 +119,13 @@ describe('Test external auth plugins', function () {
 
     await wait(5000)
 
-    await loginUsingExternalToken(server, 'cyan', externalAuthToken, HttpStatusCode.BAD_REQUEST_400)
+    await server.login.loginUsingExternalToken({
+      username: 'cyan',
+      externalAuthToken,
+      expectedStatus: HttpStatusCode.BAD_REQUEST_400
+    })
 
-    await waitUntilLog(server, 'expired external auth token', 2)
+    await server.servers.waitUntilLog('expired external auth token', 2)
   })
 
   it('Should auto login Cyan, create the user and use the token', async function () {
@@ -157,9 +145,7 @@ describe('Test external auth plugins', function () {
     }
 
     {
-      const res = await getMyUserInformation(server.url, cyanAccessToken)
-
-      const body: User = res.body
+      const body = await server.users.getMyInfo({ token: cyanAccessToken })
       expect(body.username).to.equal('cyan')
       expect(body.account.displayName).to.equal('cyan')
       expect(body.email).to.equal('cyan@example.com')
@@ -181,9 +167,7 @@ describe('Test external auth plugins', function () {
     }
 
     {
-      const res = await getMyUserInformation(server.url, kefkaAccessToken)
-
-      const body: User = res.body
+      const body = await server.users.getMyInfo({ token: kefkaAccessToken })
       expect(body.username).to.equal('kefka')
       expect(body.account.displayName).to.equal('Kefka Palazzo')
       expect(body.email).to.equal('kefka@example.com')
@@ -193,43 +177,39 @@ describe('Test external auth plugins', function () {
 
   it('Should refresh Cyan token, but not Kefka token', async function () {
     {
-      const resRefresh = await refreshToken(server, cyanRefreshToken)
+      const resRefresh = await server.login.refreshToken({ refreshToken: cyanRefreshToken })
       cyanAccessToken = resRefresh.body.access_token
       cyanRefreshToken = resRefresh.body.refresh_token
 
-      const res = await getMyUserInformation(server.url, cyanAccessToken)
-      const user: User = res.body
-      expect(user.username).to.equal('cyan')
+      const body = await server.users.getMyInfo({ token: cyanAccessToken })
+      expect(body.username).to.equal('cyan')
     }
 
     {
-      await refreshToken(server, kefkaRefreshToken, HttpStatusCode.BAD_REQUEST_400)
+      await server.login.refreshToken({ refreshToken: kefkaRefreshToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     }
   })
 
   it('Should update Cyan profile', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: cyanAccessToken,
+    await server.users.updateMe({
+      token: cyanAccessToken,
       displayName: 'Cyan Garamonde',
       description: 'Retainer to the king of Doma'
     })
 
-    const res = await getMyUserInformation(server.url, cyanAccessToken)
-
-    const body: User = res.body
+    const body = await server.users.getMyInfo({ token: cyanAccessToken })
     expect(body.account.displayName).to.equal('Cyan Garamonde')
     expect(body.account.description).to.equal('Retainer to the king of Doma')
   })
 
   it('Should logout Cyan', async function () {
-    await logout(server.url, cyanAccessToken)
+    await server.login.logout({ token: cyanAccessToken })
   })
 
   it('Should have logged out Cyan', async function () {
-    await waitUntilLog(server, 'On logout cyan')
+    await server.servers.waitUntilLog('On logout cyan')
 
-    await getMyUserInformation(server.url, cyanAccessToken, HttpStatusCode.UNAUTHORIZED_401)
+    await server.users.getMyInfo({ token: cyanAccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
   })
 
   it('Should login Cyan and keep the old existing profile', async function () {
@@ -247,9 +227,7 @@ describe('Test external auth plugins', function () {
       cyanAccessToken = res.access_token
     }
 
-    const res = await getMyUserInformation(server.url, cyanAccessToken)
-
-    const body: User = res.body
+    const body = await server.users.getMyInfo({ token: cyanAccessToken })
     expect(body.username).to.equal('cyan')
     expect(body.account.displayName).to.equal('Cyan Garamonde')
     expect(body.account.description).to.equal('Retainer to the king of Doma')
@@ -257,12 +235,11 @@ describe('Test external auth plugins', function () {
   })
 
   it('Should not update an external auth email', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: cyanAccessToken,
+    await server.users.updateMe({
+      token: cyanAccessToken,
       email: 'toto@example.com',
       currentPassword: 'toto',
-      statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+      expectedStatus: HttpStatusCode.BAD_REQUEST_400
     })
   })
 
@@ -271,18 +248,16 @@ describe('Test external auth plugins', function () {
 
     await wait(5000)
 
-    await getMyUserInformation(server.url, kefkaAccessToken, HttpStatusCode.UNAUTHORIZED_401)
+    await server.users.getMyInfo({ token: kefkaAccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
   })
 
   it('Should unregister external-auth-2 and do not login existing Kefka', async function () {
-    await updatePluginSettings({
-      url: server.url,
-      accessToken: server.accessToken,
+    await server.plugins.updateSettings({
       npmName: 'peertube-plugin-test-external-auth-one',
       settings: { disableKefka: true }
     })
 
-    await userLogin(server, { username: 'kefka', password: 'fake' }, HttpStatusCode.BAD_REQUEST_400)
+    await server.login.login({ user: { username: 'kefka', password: 'fake' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
     await loginExternal({
       server,
@@ -292,14 +267,12 @@ describe('Test external auth plugins', function () {
         username: 'kefka'
       },
       username: 'kefka',
-      statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+      expectedStatus: HttpStatusCode.NOT_FOUND_404
     })
   })
 
   it('Should have disabled this auth', async function () {
-    const res = await getConfig(server.url)
-
-    const config: ServerConfig = res.body
+    const config = await server.config.getConfig()
 
     const auths = config.plugin.registeredExternalAuths
     expect(auths).to.have.lengthOf(7)
@@ -309,11 +282,7 @@ describe('Test external auth plugins', function () {
   })
 
   it('Should uninstall the plugin one and do not login Cyan', async function () {
-    await uninstallPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-plugin-test-external-auth-one'
-    })
+    await server.plugins.uninstall({ npmName: 'peertube-plugin-test-external-auth-one' })
 
     await loginExternal({
       server,
@@ -323,12 +292,12 @@ describe('Test external auth plugins', function () {
         username: 'cyan'
       },
       username: 'cyan',
-      statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+      expectedStatus: HttpStatusCode.NOT_FOUND_404
     })
 
-    await userLogin(server, { username: 'cyan', password: null }, HttpStatusCode.BAD_REQUEST_400)
-    await userLogin(server, { username: 'cyan', password: '' }, HttpStatusCode.BAD_REQUEST_400)
-    await userLogin(server, { username: 'cyan', password: 'fake' }, HttpStatusCode.BAD_REQUEST_400)
+    await server.login.login({ user: { username: 'cyan', password: null }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await server.login.login({ user: { username: 'cyan', password: '' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await server.login.login({ user: { username: 'cyan', password: 'fake' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should not login kefka with another plugin', async function () {
@@ -337,7 +306,7 @@ describe('Test external auth plugins', function () {
       npmName: 'test-external-auth-two',
       authName: 'external-auth-4',
       username: 'kefka2',
-      statusCodeExpectedStep2: HttpStatusCode.BAD_REQUEST_400
+      expectedStatusStep2: HttpStatusCode.BAD_REQUEST_400
     })
 
     await loginExternal({
@@ -345,31 +314,24 @@ describe('Test external auth plugins', function () {
       npmName: 'test-external-auth-two',
       authName: 'external-auth-4',
       username: 'kefka',
-      statusCodeExpectedStep2: HttpStatusCode.BAD_REQUEST_400
+      expectedStatusStep2: HttpStatusCode.BAD_REQUEST_400
     })
   })
 
   it('Should not login an existing user', async function () {
-    await createUser({
-      url: server.url,
-      accessToken: server.accessToken,
-      username: 'existing_user',
-      password: 'super_password'
-    })
+    await server.users.create({ username: 'existing_user', password: 'super_password' })
 
     await loginExternal({
       server,
       npmName: 'test-external-auth-two',
       authName: 'external-auth-6',
       username: 'existing_user',
-      statusCodeExpectedStep2: HttpStatusCode.BAD_REQUEST_400
+      expectedStatusStep2: HttpStatusCode.BAD_REQUEST_400
     })
   })
 
   it('Should display the correct configuration', async function () {
-    const res = await getConfig(server.url)
-
-    const config: ServerConfig = res.body
+    const config = await server.config.getConfig()
 
     const auths = config.plugin.registeredExternalAuths
     expect(auths).to.have.lengthOf(6)
@@ -390,9 +352,8 @@ describe('Test external auth plugins', function () {
       username: 'cid'
     })
 
-    const resLogout = await logout(server.url, resLogin.access_token)
-
-    expect(resLogout.body.redirectUrl).to.equal('https://example.com/redirectUrl')
+    const { redirectUrl } = await server.login.logout({ token: resLogin.access_token })
+    expect(redirectUrl).to.equal('https://example.com/redirectUrl')
   })
 
   it('Should call the plugin\'s onLogout method with the request', async function () {
@@ -403,8 +364,7 @@ describe('Test external auth plugins', function () {
       username: 'cid'
     })
 
-    const resLogout = await logout(server.url, resLogin.access_token)
-
-    expect(resLogout.body.redirectUrl).to.equal('https://example.com/redirectUrl?access_token=' + resLogin.access_token)
+    const { redirectUrl } = await server.login.logout({ token: resLogin.access_token })
+    expect(redirectUrl).to.equal('https://example.com/redirectUrl?access_token=' + resLogin.access_token)
   })
 })
diff --git a/server/tests/plugins/filter-hooks.ts b/server/tests/plugins/filter-hooks.ts
index 644b41dea..02915f08c 100644
--- a/server/tests/plugins/filter-hooks.ts
+++ b/server/tests/plugins/filter-hooks.ts
@@ -2,192 +2,152 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { advancedVideoChannelSearch } from '@shared/extra-utils/search/video-channels'
-import { ServerConfig } from '@shared/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoCommentReply,
-  addVideoCommentThread,
-  advancedVideoPlaylistSearch,
-  advancedVideosSearch,
-  createLive,
-  createVideoPlaylist,
+  cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  getAccountVideos,
-  getConfig,
-  getMyVideos,
-  getPluginTestPath,
-  getVideo,
-  getVideoChannelVideos,
-  getVideoCommentThreads,
-  getVideoPlaylist,
-  getVideosList,
-  getVideosListPagination,
-  getVideoThreadComments,
-  getVideoWithToken,
-  installPlugin,
+  FIXTURE_URLS,
   makeRawRequest,
-  registerUser,
+  PeerTubeServer,
+  PluginsCommand,
   setAccessTokensToServers,
   setDefaultVideoChannel,
-  updateCustomSubConfig,
-  updateVideo,
-  uploadVideo,
-  uploadVideoAndGetId,
   waitJobs
-} from '../../../shared/extra-utils'
-import { cleanupTests, flushAndRunMultipleServers, ServerInfo, waitUntilLog } from '../../../shared/extra-utils/server/servers'
-import { getGoodVideoUrl, getMyVideoImports, importVideo } from '../../../shared/extra-utils/videos/video-imports'
-import {
-  VideoCommentThreadTree,
-  VideoDetails,
-  VideoImport,
-  VideoImportState,
-  VideoPlaylist,
-  VideoPlaylistPrivacy,
-  VideoPrivacy
-} from '../../../shared/models/videos'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoDetails, VideoImportState, VideoPlaylist, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test plugin filter hooks', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let videoUUID: string
   let threadId: number
 
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
     await doubleFollow(servers[0], servers[1])
 
-    await installPlugin({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      path: getPluginTestPath()
-    })
-
-    await installPlugin({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      path: getPluginTestPath('-filter-translations')
-    })
+    await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath() })
+    await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath('-filter-translations') })
 
     for (let i = 0; i < 10; i++) {
-      await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'default video ' + i })
+      await servers[0].videos.upload({ attributes: { name: 'default video ' + i } })
     }
 
-    const res = await getVideosList(servers[0].url)
-    videoUUID = res.body.data[0].uuid
-
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      live: { enabled: true },
-      signup: { enabled: true },
-      import: {
-        videos: {
-          http: { enabled: true },
-          torrent: { enabled: true }
+    const { data } = await servers[0].videos.list()
+    videoUUID = data[0].uuid
+
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: { enabled: true },
+        signup: { enabled: true },
+        import: {
+          videos: {
+            http: { enabled: true },
+            torrent: { enabled: true }
+          }
         }
       }
     })
   })
 
   it('Should run filter:api.videos.list.params', async function () {
-    const res = await getVideosListPagination(servers[0].url, 0, 2)
+    const { data } = await servers[0].videos.list({ start: 0, count: 2 })
 
     // 2 plugins do +1 to the count parameter
-    expect(res.body.data).to.have.lengthOf(4)
+    expect(data).to.have.lengthOf(4)
   })
 
   it('Should run filter:api.videos.list.result', async function () {
-    const res = await getVideosListPagination(servers[0].url, 0, 0)
+    const { total } = await servers[0].videos.list({ start: 0, count: 0 })
 
     // Plugin do +1 to the total result
-    expect(res.body.total).to.equal(11)
+    expect(total).to.equal(11)
   })
 
   it('Should run filter:api.accounts.videos.list.params', async function () {
-    const res = await getAccountVideos(servers[0].url, servers[0].accessToken, 'root', 0, 2)
+    const { data } = await servers[0].videos.listByAccount({ handle: 'root', start: 0, count: 2 })
 
     // 1 plugin do +1 to the count parameter
-    expect(res.body.data).to.have.lengthOf(3)
+    expect(data).to.have.lengthOf(3)
   })
 
   it('Should run filter:api.accounts.videos.list.result', async function () {
-    const res = await getAccountVideos(servers[0].url, servers[0].accessToken, 'root', 0, 2)
+    const { total } = await servers[0].videos.listByAccount({ handle: 'root', start: 0, count: 2 })
 
     // Plugin do +2 to the total result
-    expect(res.body.total).to.equal(12)
+    expect(total).to.equal(12)
   })
 
   it('Should run filter:api.video-channels.videos.list.params', async function () {
-    const res = await getVideoChannelVideos(servers[0].url, servers[0].accessToken, 'root_channel', 0, 2)
+    const { data } = await servers[0].videos.listByChannel({ handle: 'root_channel', start: 0, count: 2 })
 
     // 1 plugin do +3 to the count parameter
-    expect(res.body.data).to.have.lengthOf(5)
+    expect(data).to.have.lengthOf(5)
   })
 
   it('Should run filter:api.video-channels.videos.list.result', async function () {
-    const res = await getVideoChannelVideos(servers[0].url, servers[0].accessToken, 'root_channel', 0, 2)
+    const { total } = await servers[0].videos.listByChannel({ handle: 'root_channel', start: 0, count: 2 })
 
     // Plugin do +3 to the total result
-    expect(res.body.total).to.equal(13)
+    expect(total).to.equal(13)
   })
 
   it('Should run filter:api.user.me.videos.list.params', async function () {
-    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 2)
+    const { data } = await servers[0].videos.listMyVideos({ start: 0, count: 2 })
 
     // 1 plugin do +4 to the count parameter
-    expect(res.body.data).to.have.lengthOf(6)
+    expect(data).to.have.lengthOf(6)
   })
 
   it('Should run filter:api.user.me.videos.list.result', async function () {
-    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 2)
+    const { total } = await servers[0].videos.listMyVideos({ start: 0, count: 2 })
 
     // Plugin do +4 to the total result
-    expect(res.body.total).to.equal(14)
+    expect(total).to.equal(14)
   })
 
   it('Should run filter:api.video.get.result', async function () {
-    const res = await getVideo(servers[0].url, videoUUID)
-
-    expect(res.body.name).to.contain('<3')
+    const video = await servers[0].videos.get({ id: videoUUID })
+    expect(video.name).to.contain('<3')
   })
 
   it('Should run filter:api.video.upload.accept.result', async function () {
-    await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video with bad word' }, HttpStatusCode.FORBIDDEN_403)
+    await servers[0].videos.upload({ attributes: { name: 'video with bad word' }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should run filter:api.live-video.create.accept.result', async function () {
     const attributes = {
       name: 'video with bad word',
       privacy: VideoPrivacy.PUBLIC,
-      channelId: servers[0].videoChannel.id
+      channelId: servers[0].store.channel.id
     }
 
-    await createLive(servers[0].url, servers[0].accessToken, attributes, HttpStatusCode.FORBIDDEN_403)
+    await servers[0].live.create({ fields: attributes, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should run filter:api.video.pre-import-url.accept.result', async function () {
-    const baseAttributes = {
+    const attributes = {
       name: 'normal title',
       privacy: VideoPrivacy.PUBLIC,
-      channelId: servers[0].videoChannel.id,
-      targetUrl: getGoodVideoUrl() + 'bad'
+      channelId: servers[0].store.channel.id,
+      targetUrl: FIXTURE_URLS.goodVideo + 'bad'
     }
-    await importVideo(servers[0].url, servers[0].accessToken, baseAttributes, HttpStatusCode.FORBIDDEN_403)
+    await servers[0].imports.importVideo({ attributes, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should run filter:api.video.pre-import-torrent.accept.result', async function () {
-    const baseAttributes = {
+    const attributes = {
       name: 'bad torrent',
       privacy: VideoPrivacy.PUBLIC,
-      channelId: servers[0].videoChannel.id,
+      channelId: servers[0].store.channel.id,
       torrentfile: 'video-720p.torrent' as any
     }
-    await importVideo(servers[0].url, servers[0].accessToken, baseAttributes, HttpStatusCode.FORBIDDEN_403)
+    await servers[0].imports.importVideo({ attributes, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should run filter:api.video.post-import-url.accept.result', async function () {
@@ -196,21 +156,21 @@ describe('Test plugin filter hooks', function () {
     let videoImportId: number
 
     {
-      const baseAttributes = {
+      const attributes = {
         name: 'title with bad word',
         privacy: VideoPrivacy.PUBLIC,
-        channelId: servers[0].videoChannel.id,
-        targetUrl: getGoodVideoUrl()
+        channelId: servers[0].store.channel.id,
+        targetUrl: FIXTURE_URLS.goodVideo
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, baseAttributes)
-      videoImportId = res.body.id
+      const body = await servers[0].imports.importVideo({ attributes })
+      videoImportId = body.id
     }
 
     await waitJobs(servers)
 
     {
-      const res = await getMyVideoImports(servers[0].url, servers[0].accessToken)
-      const videoImports = res.body.data as VideoImport[]
+      const body = await servers[0].imports.getMyVideoImports()
+      const videoImports = body.data
 
       const videoImport = videoImports.find(i => i.id === videoImportId)
 
@@ -225,21 +185,20 @@ describe('Test plugin filter hooks', function () {
     let videoImportId: number
 
     {
-      const baseAttributes = {
+      const attributes = {
         name: 'title with bad word',
         privacy: VideoPrivacy.PUBLIC,
-        channelId: servers[0].videoChannel.id,
+        channelId: servers[0].store.channel.id,
         torrentfile: 'video-720p.torrent' as any
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, baseAttributes)
-      videoImportId = res.body.id
+      const body = await servers[0].imports.importVideo({ attributes })
+      videoImportId = body.id
     }
 
     await waitJobs(servers)
 
     {
-      const res = await getMyVideoImports(servers[0].url, servers[0].accessToken)
-      const videoImports = res.body.data as VideoImport[]
+      const { data: videoImports } = await servers[0].imports.getMyVideoImports()
 
       const videoImport = videoImports.find(i => i.id === videoImportId)
 
@@ -249,60 +208,71 @@ describe('Test plugin filter hooks', function () {
   })
 
   it('Should run filter:api.video-thread.create.accept.result', async function () {
-    await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, 'comment with bad word', HttpStatusCode.FORBIDDEN_403)
+    await servers[0].comments.createThread({
+      videoId: videoUUID,
+      text: 'comment with bad word',
+      expectedStatus: HttpStatusCode.FORBIDDEN_403
+    })
   })
 
   it('Should run filter:api.video-comment-reply.create.accept.result', async function () {
-    const res = await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, 'thread')
-    threadId = res.body.comment.id
-
-    await addVideoCommentReply(
-      servers[0].url,
-      servers[0].accessToken,
-      videoUUID,
-      threadId,
-      'comment with bad word',
-      HttpStatusCode.FORBIDDEN_403
-    )
-    await addVideoCommentReply(servers[0].url, servers[0].accessToken, videoUUID, threadId, 'comment with good word', HttpStatusCode.OK_200)
+    const created = await servers[0].comments.createThread({ videoId: videoUUID, text: 'thread' })
+    threadId = created.id
+
+    await servers[0].comments.addReply({
+      videoId: videoUUID,
+      toCommentId: threadId,
+      text: 'comment with bad word',
+      expectedStatus: HttpStatusCode.FORBIDDEN_403
+    })
+    await servers[0].comments.addReply({
+      videoId: videoUUID,
+      toCommentId: threadId,
+      text: 'comment with good word',
+      expectedStatus: HttpStatusCode.OK_200
+    })
   })
 
   it('Should run filter:api.video-threads.list.params', async function () {
-    const res = await getVideoCommentThreads(servers[0].url, videoUUID, 0, 0)
+    const { data } = await servers[0].comments.listThreads({ videoId: videoUUID, start: 0, count: 0 })
 
     // our plugin do +1 to the count parameter
-    expect(res.body.data).to.have.lengthOf(1)
+    expect(data).to.have.lengthOf(1)
   })
 
   it('Should run filter:api.video-threads.list.result', async function () {
-    const res = await getVideoCommentThreads(servers[0].url, videoUUID, 0, 0)
+    const { total } = await servers[0].comments.listThreads({ videoId: videoUUID, start: 0, count: 0 })
 
     // Plugin do +1 to the total result
-    expect(res.body.total).to.equal(2)
+    expect(total).to.equal(2)
   })
 
   it('Should run filter:api.video-thread-comments.list.params')
 
   it('Should run filter:api.video-thread-comments.list.result', async function () {
-    const res = await getVideoThreadComments(servers[0].url, videoUUID, threadId)
+    const thread = await servers[0].comments.getThread({ videoId: videoUUID, threadId })
 
-    const thread = res.body as VideoCommentThreadTree
     expect(thread.comment.text.endsWith(' <3')).to.be.true
   })
 
-  describe('Should run filter:video.auto-blacklist.result', function () {
+  it('Should run filter:api.overviews.videos.list.{params,result}', async function () {
+    await servers[0].overviews.getVideos({ page: 1 })
 
-    async function checkIsBlacklisted (oldRes: any, value: boolean) {
-      const videoId = oldRes.body.video.uuid
+    // 3 because we get 3 samples per page
+    await servers[0].servers.waitUntilLog('Run hook filter:api.overviews.videos.list.params', 3)
+    await servers[0].servers.waitUntilLog('Run hook filter:api.overviews.videos.list.result', 3)
+  })
 
-      const res = await getVideoWithToken(servers[0].url, servers[0].accessToken, videoId)
-      const video: VideoDetails = res.body
+  describe('Should run filter:video.auto-blacklist.result', function () {
+
+    async function checkIsBlacklisted (id: number | string, value: boolean) {
+      const video = await servers[0].videos.getWithToken({ id })
       expect(video.blacklisted).to.equal(value)
     }
 
     it('Should blacklist on upload', async function () {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video please blacklist me' })
-      await checkIsBlacklisted(res, true)
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video please blacklist me' } })
+      await checkIsBlacklisted(uuid, true)
     })
 
     it('Should blacklist on import', async function () {
@@ -310,60 +280,62 @@ describe('Test plugin filter hooks', function () {
 
       const attributes = {
         name: 'video please blacklist me',
-        targetUrl: getGoodVideoUrl(),
-        channelId: servers[0].videoChannel.id
+        targetUrl: FIXTURE_URLS.goodVideo,
+        channelId: servers[0].store.channel.id
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      await checkIsBlacklisted(res, true)
+      const body = await servers[0].imports.importVideo({ attributes })
+      await checkIsBlacklisted(body.video.uuid, true)
     })
 
     it('Should blacklist on update', async function () {
-      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video' })
-      const videoId = res.body.video.uuid
-      await checkIsBlacklisted(res, false)
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video' } })
+      await checkIsBlacklisted(uuid, false)
 
-      await updateVideo(servers[0].url, servers[0].accessToken, videoId, { name: 'please blacklist me' })
-      await checkIsBlacklisted(res, true)
+      await servers[0].videos.update({ id: uuid, attributes: { name: 'please blacklist me' } })
+      await checkIsBlacklisted(uuid, true)
     })
 
     it('Should blacklist on remote upload', async function () {
       this.timeout(120000)
 
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'remote please blacklist me' })
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'remote please blacklist me' } })
       await waitJobs(servers)
 
-      await checkIsBlacklisted(res, true)
+      await checkIsBlacklisted(uuid, true)
     })
 
     it('Should blacklist on remote update', async function () {
       this.timeout(120000)
 
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video' })
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video' } })
       await waitJobs(servers)
 
-      const videoId = res.body.video.uuid
-      await checkIsBlacklisted(res, false)
+      await checkIsBlacklisted(uuid, false)
 
-      await updateVideo(servers[1].url, servers[1].accessToken, videoId, { name: 'please blacklist me' })
+      await servers[1].videos.update({ id: uuid, attributes: { name: 'please blacklist me' } })
       await waitJobs(servers)
 
-      await checkIsBlacklisted(res, true)
+      await checkIsBlacklisted(uuid, true)
     })
   })
 
   describe('Should run filter:api.user.signup.allowed.result', function () {
 
     it('Should run on config endpoint', async function () {
-      const res = await getConfig(servers[0].url)
-      expect((res.body as ServerConfig).signup.allowed).to.be.true
+      const body = await servers[0].config.getConfig()
+      expect(body.signup.allowed).to.be.true
     })
 
     it('Should allow a signup', async function () {
-      await registerUser(servers[0].url, 'john', 'password')
+      await servers[0].users.register({ username: 'john', password: 'password' })
     })
 
     it('Should not allow a signup', async function () {
-      const res = await registerUser(servers[0].url, 'jma', 'password', HttpStatusCode.FORBIDDEN_403)
+      const res = await servers[0].users.register({
+        username: 'jma',
+        password: 'password',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
 
       expect(res.body.error).to.equal('No jma')
     })
@@ -375,13 +347,15 @@ describe('Test plugin filter hooks', function () {
     before(async function () {
       this.timeout(120000)
 
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-        transcoding: {
-          webtorrent: {
-            enabled: true
-          },
-          hls: {
-            enabled: true
+      await servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          transcoding: {
+            webtorrent: {
+              enabled: true
+            },
+            hls: {
+              enabled: true
+            }
           }
         }
       })
@@ -389,15 +363,14 @@ describe('Test plugin filter hooks', function () {
       const uuids: string[] = []
 
       for (const name of [ 'bad torrent', 'bad file', 'bad playlist file' ]) {
-        const uuid = (await uploadVideoAndGetId({ server: servers[0], videoName: name })).uuid
+        const uuid = (await servers[0].videos.quickUpload({ name: name })).uuid
         uuids.push(uuid)
       }
 
       await waitJobs(servers)
 
       for (const uuid of uuids) {
-        const res = await getVideo(servers[0].url, uuid)
-        downloadVideos.push(res.body)
+        downloadVideos.push(await servers[0].videos.get({ id: uuid }))
       }
     })
 
@@ -437,25 +410,26 @@ describe('Test plugin filter hooks', function () {
     before(async function () {
       this.timeout(60000)
 
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-        transcoding: {
-          enabled: false
+      await servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          transcoding: {
+            enabled: false
+          }
         }
       })
 
       for (const name of [ 'bad embed', 'good embed' ]) {
         {
-          const uuid = (await uploadVideoAndGetId({ server: servers[0], videoName: name })).uuid
-          const res = await getVideo(servers[0].url, uuid)
-          embedVideos.push(res.body)
+          const uuid = (await servers[0].videos.quickUpload({ name: name })).uuid
+          embedVideos.push(await servers[0].videos.get({ id: uuid }))
         }
 
         {
-          const playlistAttrs = { displayName: name, videoChannelId: servers[0].videoChannel.id, privacy: VideoPlaylistPrivacy.PUBLIC }
-          const res = await createVideoPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistAttrs })
+          const attributes = { displayName: name, videoChannelId: servers[0].store.channel.id, privacy: VideoPlaylistPrivacy.PUBLIC }
+          const { id } = await servers[0].playlists.create({ attributes })
 
-          const resPlaylist = await getVideoPlaylist(servers[0].url, res.body.videoPlaylist.id)
-          embedPlaylists.push(resPlaylist.body)
+          const playlist = await servers[0].playlists.get({ playlistId: id })
+          embedPlaylists.push(playlist)
         }
       }
     })
@@ -474,78 +448,92 @@ describe('Test plugin filter hooks', function () {
   describe('Search filters', function () {
 
     before(async function () {
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-        search: {
-          searchIndex: {
-            enabled: true,
-            isDefaultSearch: false,
-            disableLocalSearch: false
+      await servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          search: {
+            searchIndex: {
+              enabled: true,
+              isDefaultSearch: false,
+              disableLocalSearch: false
+            }
           }
         }
       })
     })
 
     it('Should run filter:api.search.videos.local.list.{params,result}', async function () {
-      await advancedVideosSearch(servers[0].url, {
-        search: 'Sun Quan'
+      await servers[0].search.advancedVideoSearch({
+        search: {
+          search: 'Sun Quan'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.local.list.result', 1)
     })
 
     it('Should run filter:api.search.videos.index.list.{params,result}', async function () {
-      await advancedVideosSearch(servers[0].url, {
-        search: 'Sun Quan',
-        searchTarget: 'search-index'
+      await servers[0].search.advancedVideoSearch({
+        search: {
+          search: 'Sun Quan',
+          searchTarget: 'search-index'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.local.list.result', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.index.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.index.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.index.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.index.list.result', 1)
     })
 
     it('Should run filter:api.search.video-channels.local.list.{params,result}', async function () {
-      await advancedVideoChannelSearch(servers[0].url, {
-        search: 'Sun Ce'
+      await servers[0].search.advancedChannelSearch({
+        search: {
+          search: 'Sun Ce'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.local.list.result', 1)
     })
 
     it('Should run filter:api.search.video-channels.index.list.{params,result}', async function () {
-      await advancedVideoChannelSearch(servers[0].url, {
-        search: 'Sun Ce',
-        searchTarget: 'search-index'
+      await servers[0].search.advancedChannelSearch({
+        search: {
+          search: 'Sun Ce',
+          searchTarget: 'search-index'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.local.list.result', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.index.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.index.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.index.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.index.list.result', 1)
     })
 
     it('Should run filter:api.search.video-playlists.local.list.{params,result}', async function () {
-      await advancedVideoPlaylistSearch(servers[0].url, {
-        search: 'Sun Jian'
+      await servers[0].search.advancedPlaylistSearch({
+        search: {
+          search: 'Sun Jian'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.local.list.result', 1)
     })
 
     it('Should run filter:api.search.video-playlists.index.list.{params,result}', async function () {
-      await advancedVideoPlaylistSearch(servers[0].url, {
-        search: 'Sun Jian',
-        searchTarget: 'search-index'
+      await servers[0].search.advancedPlaylistSearch({
+        search: {
+          search: 'Sun Jian',
+          searchTarget: 'search-index'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.local.list.result', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.index.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.index.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.index.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.index.list.result', 1)
     })
   })
 
diff --git a/server/tests/plugins/html-injection.ts b/server/tests/plugins/html-injection.ts
index 4fa8caa3a..95c0cd687 100644
--- a/server/tests/plugins/html-injection.ts
+++ b/server/tests/plugins/html-injection.ts
@@ -4,31 +4,32 @@ import 'mocha'
 import * as chai from 'chai'
 import {
   cleanupTests,
-  flushAndRunServer,
-  getPluginsCSS,
-  installPlugin,
+  createSingleServer,
   makeHTMLRequest,
-  ServerInfo,
-  setAccessTokensToServers,
-  uninstallPlugin
+  PeerTubeServer,
+  PluginsCommand,
+  setAccessTokensToServers
 } from '../../../shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test plugins HTML injection', function () {
-  let server: ServerInfo = null
+  let server: PeerTubeServer = null
+  let command: PluginsCommand
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
+
+    command = server.plugins
   })
 
   it('Should not inject global css file in HTML', async function () {
     {
-      const res = await getPluginsCSS(server.url)
-      expect(res.text).to.be.empty
+      const text = await command.getCSS()
+      expect(text).to.be.empty
     }
 
     for (const path of [ '/', '/videos/embed/1', '/video-playlists/embed/1' ]) {
@@ -40,17 +41,13 @@ describe('Test plugins HTML injection', function () {
   it('Should install a plugin and a theme', async function () {
     this.timeout(30000)
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-plugin-hello-world'
-    })
+    await command.install({ npmName: 'peertube-plugin-hello-world' })
   })
 
   it('Should have the correct global css', async function () {
     {
-      const res = await getPluginsCSS(server.url)
-      expect(res.text).to.contain('background-color: red')
+      const text = await command.getCSS()
+      expect(text).to.contain('background-color: red')
     }
 
     for (const path of [ '/', '/videos/embed/1', '/video-playlists/embed/1' ]) {
@@ -60,15 +57,11 @@ describe('Test plugins HTML injection', function () {
   })
 
   it('Should have an empty global css on uninstall', async function () {
-    await uninstallPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-plugin-hello-world'
-    })
+    await command.uninstall({ npmName: 'peertube-plugin-hello-world' })
 
     {
-      const res = await getPluginsCSS(server.url)
-      expect(res.text).to.be.empty
+      const text = await command.getCSS()
+      expect(text).to.be.empty
     }
 
     for (const path of [ '/', '/videos/embed/1', '/video-playlists/embed/1' ]) {
diff --git a/server/tests/plugins/id-and-pass-auth.ts b/server/tests/plugins/id-and-pass-auth.ts
index cbba638c2..fde0166f9 100644
--- a/server/tests/plugins/id-and-pass-auth.ts
+++ b/server/tests/plugins/id-and-pass-auth.ts
@@ -1,24 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { cleanupTests, flushAndRunServer, ServerInfo, waitUntilLog } from '../../../shared/extra-utils/server/servers'
-import {
-  getMyUserInformation,
-  getPluginTestPath,
-  installPlugin,
-  logout,
-  setAccessTokensToServers,
-  uninstallPlugin,
-  updateMyUser,
-  userLogin,
-  wait,
-  login, refreshToken, getConfig, updatePluginSettings, getUsersList
-} from '../../../shared/extra-utils'
-import { User, UserRole, ServerConfig } from '@shared/models'
 import { expect } from 'chai'
+import { cleanupTests, createSingleServer, PeerTubeServer, PluginsCommand, setAccessTokensToServers, wait } from '@shared/extra-utils'
+import { HttpStatusCode, UserRole } from '@shared/models'
 
 describe('Test id and pass auth plugins', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   let crashAccessToken: string
   let crashRefreshToken: string
@@ -29,22 +17,16 @@ describe('Test id and pass auth plugins', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
     for (const suffix of [ 'one', 'two', 'three' ]) {
-      await installPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        path: getPluginTestPath('-id-pass-auth-' + suffix)
-      })
+      await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-id-pass-auth-' + suffix) })
     }
   })
 
   it('Should display the correct configuration', async function () {
-    const res = await getConfig(server.url)
-
-    const config: ServerConfig = res.body
+    const config = await server.config.getConfig()
 
     const auths = config.plugin.registeredIdAndPassAuths
     expect(auths).to.have.lengthOf(8)
@@ -56,15 +38,14 @@ describe('Test id and pass auth plugins', function () {
   })
 
   it('Should not login', async function () {
-    await userLogin(server, { username: 'toto', password: 'password' }, 400)
+    await server.login.login({ user: { username: 'toto', password: 'password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should login Spyro, create the user and use the token', async function () {
-    const accessToken = await userLogin(server, { username: 'spyro', password: 'spyro password' })
+    const accessToken = await server.login.getAccessToken({ username: 'spyro', password: 'spyro password' })
 
-    const res = await getMyUserInformation(server.url, accessToken)
+    const body = await server.users.getMyInfo({ token: accessToken })
 
-    const body: User = res.body
     expect(body.username).to.equal('spyro')
     expect(body.account.displayName).to.equal('Spyro the Dragon')
     expect(body.role).to.equal(UserRole.USER)
@@ -72,15 +53,14 @@ describe('Test id and pass auth plugins', function () {
 
   it('Should login Crash, create the user and use the token', async function () {
     {
-      const res = await login(server.url, server.client, { username: 'crash', password: 'crash password' })
-      crashAccessToken = res.body.access_token
-      crashRefreshToken = res.body.refresh_token
+      const body = await server.login.login({ user: { username: 'crash', password: 'crash password' } })
+      crashAccessToken = body.access_token
+      crashRefreshToken = body.refresh_token
     }
 
     {
-      const res = await getMyUserInformation(server.url, crashAccessToken)
+      const body = await server.users.getMyInfo({ token: crashAccessToken })
 
-      const body: User = res.body
       expect(body.username).to.equal('crash')
       expect(body.account.displayName).to.equal('Crash Bandicoot')
       expect(body.role).to.equal(UserRole.MODERATOR)
@@ -89,15 +69,14 @@ describe('Test id and pass auth plugins', function () {
 
   it('Should login the first Laguna, create the user and use the token', async function () {
     {
-      const res = await login(server.url, server.client, { username: 'laguna', password: 'laguna password' })
-      lagunaAccessToken = res.body.access_token
-      lagunaRefreshToken = res.body.refresh_token
+      const body = await server.login.login({ user: { username: 'laguna', password: 'laguna password' } })
+      lagunaAccessToken = body.access_token
+      lagunaRefreshToken = body.refresh_token
     }
 
     {
-      const res = await getMyUserInformation(server.url, lagunaAccessToken)
+      const body = await server.users.getMyInfo({ token: lagunaAccessToken })
 
-      const body: User = res.body
       expect(body.username).to.equal('laguna')
       expect(body.account.displayName).to.equal('laguna')
       expect(body.role).to.equal(UserRole.USER)
@@ -106,51 +85,47 @@ describe('Test id and pass auth plugins', function () {
 
   it('Should refresh crash token, but not laguna token', async function () {
     {
-      const resRefresh = await refreshToken(server, crashRefreshToken)
+      const resRefresh = await server.login.refreshToken({ refreshToken: crashRefreshToken })
       crashAccessToken = resRefresh.body.access_token
       crashRefreshToken = resRefresh.body.refresh_token
 
-      const res = await getMyUserInformation(server.url, crashAccessToken)
-      const user: User = res.body
-      expect(user.username).to.equal('crash')
+      const body = await server.users.getMyInfo({ token: crashAccessToken })
+      expect(body.username).to.equal('crash')
     }
 
     {
-      await refreshToken(server, lagunaRefreshToken, 400)
+      await server.login.refreshToken({ refreshToken: lagunaRefreshToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     }
   })
 
   it('Should update Crash profile', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: crashAccessToken,
+    await server.users.updateMe({
+      token: crashAccessToken,
       displayName: 'Beautiful Crash',
       description: 'Mutant eastern barred bandicoot'
     })
 
-    const res = await getMyUserInformation(server.url, crashAccessToken)
+    const body = await server.users.getMyInfo({ token: crashAccessToken })
 
-    const body: User = res.body
     expect(body.account.displayName).to.equal('Beautiful Crash')
     expect(body.account.description).to.equal('Mutant eastern barred bandicoot')
   })
 
   it('Should logout Crash', async function () {
-    await logout(server.url, crashAccessToken)
+    await server.login.logout({ token: crashAccessToken })
   })
 
   it('Should have logged out Crash', async function () {
-    await waitUntilLog(server, 'On logout for auth 1 - 2')
+    await server.servers.waitUntilLog('On logout for auth 1 - 2')
 
-    await getMyUserInformation(server.url, crashAccessToken, 401)
+    await server.users.getMyInfo({ token: crashAccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
   })
 
   it('Should login Crash and keep the old existing profile', async function () {
-    crashAccessToken = await userLogin(server, { username: 'crash', password: 'crash password' })
+    crashAccessToken = await server.login.getAccessToken({ username: 'crash', password: 'crash password' })
 
-    const res = await getMyUserInformation(server.url, crashAccessToken)
+    const body = await server.users.getMyInfo({ token: crashAccessToken })
 
-    const body: User = res.body
     expect(body.username).to.equal('crash')
     expect(body.account.displayName).to.equal('Beautiful Crash')
     expect(body.account.description).to.equal('Mutant eastern barred bandicoot')
@@ -162,39 +137,38 @@ describe('Test id and pass auth plugins', function () {
 
     await wait(5000)
 
-    await getMyUserInformation(server.url, lagunaAccessToken, 401)
+    await server.users.getMyInfo({ token: lagunaAccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
   })
 
   it('Should reject an invalid username, email, role or display name', async function () {
-    await userLogin(server, { username: 'ward', password: 'ward password' }, 400)
-    await waitUntilLog(server, 'valid username')
+    const command = server.login
 
-    await userLogin(server, { username: 'kiros', password: 'kiros password' }, 400)
-    await waitUntilLog(server, 'valid display name')
+    await command.login({ user: { username: 'ward', password: 'ward password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await server.servers.waitUntilLog('valid username')
 
-    await userLogin(server, { username: 'raine', password: 'raine password' }, 400)
-    await waitUntilLog(server, 'valid role')
+    await command.login({ user: { username: 'kiros', password: 'kiros password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await server.servers.waitUntilLog('valid display name')
 
-    await userLogin(server, { username: 'ellone', password: 'elonne password' }, 400)
-    await waitUntilLog(server, 'valid email')
+    await command.login({ user: { username: 'raine', password: 'raine password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await server.servers.waitUntilLog('valid role')
+
+    await command.login({ user: { username: 'ellone', password: 'elonne password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await server.servers.waitUntilLog('valid email')
   })
 
   it('Should unregister spyro-auth and do not login existing Spyro', async function () {
-    await updatePluginSettings({
-      url: server.url,
-      accessToken: server.accessToken,
+    await server.plugins.updateSettings({
       npmName: 'peertube-plugin-test-id-pass-auth-one',
       settings: { disableSpyro: true }
     })
 
-    await userLogin(server, { username: 'spyro', password: 'spyro password' }, 400)
-    await userLogin(server, { username: 'spyro', password: 'fake' }, 400)
+    const command = server.login
+    await command.login({ user: { username: 'spyro', password: 'spyro password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await command.login({ user: { username: 'spyro', password: 'fake' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should have disabled this auth', async function () {
-    const res = await getConfig(server.url)
-
-    const config: ServerConfig = res.body
+    const config = await server.config.getConfig()
 
     const auths = config.plugin.registeredIdAndPassAuths
     expect(auths).to.have.lengthOf(7)
@@ -204,19 +178,16 @@ describe('Test id and pass auth plugins', function () {
   })
 
   it('Should uninstall the plugin one and do not login existing Crash', async function () {
-    await uninstallPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-plugin-test-id-pass-auth-one'
-    })
+    await server.plugins.uninstall({ npmName: 'peertube-plugin-test-id-pass-auth-one' })
 
-    await userLogin(server, { username: 'crash', password: 'crash password' }, 400)
+    await server.login.login({
+      user: { username: 'crash', password: 'crash password' },
+      expectedStatus: HttpStatusCode.BAD_REQUEST_400
+    })
   })
 
   it('Should display the correct configuration', async function () {
-    const res = await getConfig(server.url)
-
-    const config: ServerConfig = res.body
+    const config = await server.config.getConfig()
 
     const auths = config.plugin.registeredIdAndPassAuths
     expect(auths).to.have.lengthOf(6)
@@ -226,13 +197,11 @@ describe('Test id and pass auth plugins', function () {
   })
 
   it('Should display plugin auth information in users list', async function () {
-    const res = await getUsersList(server.url, server.accessToken)
-
-    const users: User[] = res.body.data
+    const { data } = await server.users.list()
 
-    const root = users.find(u => u.username === 'root')
-    const crash = users.find(u => u.username === 'crash')
-    const laguna = users.find(u => u.username === 'laguna')
+    const root = data.find(u => u.username === 'root')
+    const crash = data.find(u => u.username === 'crash')
+    const laguna = data.find(u => u.username === 'laguna')
 
     expect(root.pluginAuth).to.be.null
     expect(crash.pluginAuth).to.equal('peertube-plugin-test-id-pass-auth-one')
diff --git a/server/tests/plugins/plugin-helpers.ts b/server/tests/plugins/plugin-helpers.ts
index 0296d6eb7..5d16b28a4 100644
--- a/server/tests/plugins/plugin-helpers.ts
+++ b/server/tests/plugins/plugin-helpers.ts
@@ -1,25 +1,22 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
+import { expect } from 'chai'
 import {
   checkVideoFilesWereRemoved,
+  cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  getPluginTestPath,
-  getVideo,
-  installPlugin,
+  makeGetRequest,
   makePostBodyRequest,
+  PeerTubeServer,
+  PluginsCommand,
   setAccessTokensToServers,
-  uploadVideoAndGetId,
-  viewVideo,
-  getVideosList,
-  waitJobs,
-  makeGetRequest
-} from '../../../shared/extra-utils'
-import { cleanupTests, flushAndRunMultipleServers, ServerInfo, waitUntilLog } from '../../../shared/extra-utils/server/servers'
-import { expect } from 'chai'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+  waitJobs
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
-function postCommand (server: ServerInfo, command: string, bodyArg?: object) {
+function postCommand (server: PeerTubeServer, command: string, bodyArg?: object) {
   const body = { command }
   if (bodyArg) Object.assign(body, bodyArg)
 
@@ -27,54 +24,50 @@ function postCommand (server: ServerInfo, command: string, bodyArg?: object) {
     url: server.url,
     path: '/plugins/test-four/router/commander',
     fields: body,
-    statusCodeExpected: HttpStatusCode.NO_CONTENT_204
+    expectedStatus: HttpStatusCode.NO_CONTENT_204
   })
 }
 
 describe('Test plugin helpers', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
 
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     await doubleFollow(servers[0], servers[1])
 
-    await installPlugin({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      path: getPluginTestPath('-four')
-    })
+    await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath('-four') })
   })
 
   describe('Logger', function () {
 
     it('Should have logged things', async function () {
-      await waitUntilLog(servers[0], 'localhost:' + servers[0].port + ' peertube-plugin-test-four', 1, false)
-      await waitUntilLog(servers[0], 'Hello world from plugin four', 1)
+      await servers[0].servers.waitUntilLog('localhost:' + servers[0].port + ' peertube-plugin-test-four', 1, false)
+      await servers[0].servers.waitUntilLog('Hello world from plugin four', 1)
     })
   })
 
   describe('Database', function () {
 
     it('Should have made a query', async function () {
-      await waitUntilLog(servers[0], `root email is admin${servers[0].internalServerNumber}@example.com`)
+      await servers[0].servers.waitUntilLog(`root email is admin${servers[0].internalServerNumber}@example.com`)
     })
   })
 
   describe('Config', function () {
 
     it('Should have the correct webserver url', async function () {
-      await waitUntilLog(servers[0], `server url is http://localhost:${servers[0].port}`)
+      await servers[0].servers.waitUntilLog(`server url is http://localhost:${servers[0].port}`)
     })
 
     it('Should have the correct config', async function () {
       const res = await makeGetRequest({
         url: servers[0].url,
         path: '/plugins/test-four/router/server-config',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body.serverConfig).to.exist
@@ -85,7 +78,7 @@ describe('Test plugin helpers', function () {
   describe('Server', function () {
 
     it('Should get the server actor', async function () {
-      await waitUntilLog(servers[0], 'server actor name is peertube')
+      await servers[0].servers.waitUntilLog('server actor name is peertube')
     })
   })
 
@@ -95,7 +88,7 @@ describe('Test plugin helpers', function () {
       const res = await makeGetRequest({
         url: servers[0].url,
         path: '/plugins/test-four/router/static-route',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body.staticRoute).to.equal('/plugins/test-four/0.0.1/static/')
@@ -107,7 +100,7 @@ describe('Test plugin helpers', function () {
       const res = await makeGetRequest({
         url: servers[0].url,
         path: baseRouter + 'router-route',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body.routerRoute).to.equal(baseRouter)
@@ -120,7 +113,7 @@ describe('Test plugin helpers', function () {
       await makeGetRequest({
         url: servers[0].url,
         path: '/plugins/test-four/router/user',
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     })
 
@@ -129,7 +122,7 @@ describe('Test plugin helpers', function () {
         url: servers[0].url,
         token: servers[0].accessToken,
         path: '/plugins/test-four/router/user',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body.username).to.equal('root')
@@ -147,59 +140,54 @@ describe('Test plugin helpers', function () {
       this.timeout(60000)
 
       {
-        const res = await uploadVideoAndGetId({ server: servers[0], videoName: 'video server 1' })
+        const res = await servers[0].videos.quickUpload({ name: 'video server 1' })
         videoUUIDServer1 = res.uuid
       }
 
       {
-        await uploadVideoAndGetId({ server: servers[1], videoName: 'video server 2' })
+        await servers[1].videos.quickUpload({ name: 'video server 2' })
       }
 
       await waitJobs(servers)
 
-      const res = await getVideosList(servers[0].url)
-      const videos = res.body.data
+      const { data } = await servers[0].videos.list()
 
-      expect(videos).to.have.lengthOf(2)
+      expect(data).to.have.lengthOf(2)
     })
 
     it('Should mute server 2', async function () {
       this.timeout(10000)
       await postCommand(servers[0], 'blockServer', { hostToBlock: `localhost:${servers[1].port}` })
 
-      const res = await getVideosList(servers[0].url)
-      const videos = res.body.data
+      const { data } = await servers[0].videos.list()
 
-      expect(videos).to.have.lengthOf(1)
-      expect(videos[0].name).to.equal('video server 1')
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].name).to.equal('video server 1')
     })
 
     it('Should unmute server 2', async function () {
       await postCommand(servers[0], 'unblockServer', { hostToUnblock: `localhost:${servers[1].port}` })
 
-      const res = await getVideosList(servers[0].url)
-      const videos = res.body.data
+      const { data } = await servers[0].videos.list()
 
-      expect(videos).to.have.lengthOf(2)
+      expect(data).to.have.lengthOf(2)
     })
 
     it('Should mute account of server 2', async function () {
       await postCommand(servers[0], 'blockAccount', { handleToBlock: `root@localhost:${servers[1].port}` })
 
-      const res = await getVideosList(servers[0].url)
-      const videos = res.body.data
+      const { data } = await servers[0].videos.list()
 
-      expect(videos).to.have.lengthOf(1)
-      expect(videos[0].name).to.equal('video server 1')
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].name).to.equal('video server 1')
     })
 
     it('Should unmute account of server 2', async function () {
       await postCommand(servers[0], 'unblockAccount', { handleToUnblock: `root@localhost:${servers[1].port}` })
 
-      const res = await getVideosList(servers[0].url)
-      const videos = res.body.data
+      const { data } = await servers[0].videos.list()
 
-      expect(videos).to.have.lengthOf(2)
+      expect(data).to.have.lengthOf(2)
     })
 
     it('Should blacklist video', async function () {
@@ -210,11 +198,10 @@ describe('Test plugin helpers', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        const videos = res.body.data
+        const { data } = await server.videos.list()
 
-        expect(videos).to.have.lengthOf(1)
-        expect(videos[0].name).to.equal('video server 2')
+        expect(data).to.have.lengthOf(1)
+        expect(data[0].name).to.equal('video server 2')
       }
     })
 
@@ -226,10 +213,9 @@ describe('Test plugin helpers', function () {
       await waitJobs(servers)
 
       for (const server of servers) {
-        const res = await getVideosList(server.url)
-        const videos = res.body.data
+        const { data } = await server.videos.list()
 
-        expect(videos).to.have.lengthOf(2)
+        expect(data).to.have.lengthOf(2)
       }
     })
   })
@@ -238,7 +224,7 @@ describe('Test plugin helpers', function () {
     let videoUUID: string
 
     before(async () => {
-      const res = await uploadVideoAndGetId({ server: servers[0], videoName: 'video1' })
+      const res = await servers[0].videos.quickUpload({ name: 'video1' })
       videoUUID = res.uuid
     })
 
@@ -246,25 +232,25 @@ describe('Test plugin helpers', function () {
       this.timeout(40000)
 
       // Should not throw -> video exists
-      await getVideo(servers[0].url, videoUUID)
+      const video = await servers[0].videos.get({ id: videoUUID })
       // Should delete the video
-      await viewVideo(servers[0].url, videoUUID)
+      await servers[0].videos.view({ id: videoUUID })
 
-      await waitUntilLog(servers[0], 'Video deleted by plugin four.')
+      await servers[0].servers.waitUntilLog('Video deleted by plugin four.')
 
       try {
         // Should throw because the video should have been deleted
-        await getVideo(servers[0].url, videoUUID)
+        await servers[0].videos.get({ id: videoUUID })
         throw new Error('Video exists')
       } catch (err) {
         if (err.message.includes('exists')) throw err
       }
 
-      await checkVideoFilesWereRemoved(videoUUID, servers[0].internalServerNumber)
+      await checkVideoFilesWereRemoved({ server: servers[0], video })
     })
 
     it('Should have fetched the video by URL', async function () {
-      await waitUntilLog(servers[0], `video from DB uuid is ${videoUUID}`)
+      await servers[0].servers.waitUntilLog(`video from DB uuid is ${videoUUID}`)
     })
   })
 
diff --git a/server/tests/plugins/plugin-router.ts b/server/tests/plugins/plugin-router.ts
index 24e6a1e83..b1ac9e2fe 100644
--- a/server/tests/plugins/plugin-router.ts
+++ b/server/tests/plugins/plugin-router.ts
@@ -1,19 +1,20 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
+import { expect } from 'chai'
 import {
-  getPluginTestPath,
-  installPlugin,
+  cleanupTests,
+  createSingleServer,
   makeGetRequest,
   makePostBodyRequest,
-  setAccessTokensToServers, uninstallPlugin
-} from '../../../shared/extra-utils'
-import { expect } from 'chai'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+  PeerTubeServer,
+  PluginsCommand,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test plugin helpers', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
   const basePaths = [
     '/plugins/test-five/router/',
     '/plugins/test-five/0.0.1/router/'
@@ -22,14 +23,10 @@ describe('Test plugin helpers', function () {
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      path: getPluginTestPath('-five')
-    })
+    await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-five') })
   })
 
   it('Should answer "pong"', async function () {
@@ -37,7 +34,7 @@ describe('Test plugin helpers', function () {
       const res = await makeGetRequest({
         url: server.url,
         path: path + 'ping',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body.message).to.equal('pong')
@@ -50,7 +47,7 @@ describe('Test plugin helpers', function () {
         url: server.url,
         path: path + 'is-authenticated',
         token: server.accessToken,
-        statusCodeExpected: 200
+        expectedStatus: 200
       })
 
       expect(res.body.isAuthenticated).to.equal(true)
@@ -58,7 +55,7 @@ describe('Test plugin helpers', function () {
       const secRes = await makeGetRequest({
         url: server.url,
         path: path + 'is-authenticated',
-        statusCodeExpected: 200
+        expectedStatus: 200
       })
 
       expect(secRes.body.isAuthenticated).to.equal(false)
@@ -77,7 +74,7 @@ describe('Test plugin helpers', function () {
         url: server.url,
         path: path + 'form/post/mirror',
         fields: body,
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       expect(res.body).to.deep.equal(body)
@@ -85,24 +82,20 @@ describe('Test plugin helpers', function () {
   })
 
   it('Should remove the plugin and remove the routes', async function () {
-    await uninstallPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-plugin-test-five'
-    })
+    await server.plugins.uninstall({ npmName: 'peertube-plugin-test-five' })
 
     for (const path of basePaths) {
       await makeGetRequest({
         url: server.url,
         path: path + 'ping',
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
 
       await makePostBodyRequest({
         url: server.url,
         path: path + 'ping',
         fields: {},
-        statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
       })
     }
   })
diff --git a/server/tests/plugins/plugin-storage.ts b/server/tests/plugins/plugin-storage.ts
index 3c46b2585..e20c36dba 100644
--- a/server/tests/plugins/plugin-storage.ts
+++ b/server/tests/plugins/plugin-storage.ts
@@ -4,37 +4,32 @@ import 'mocha'
 import { expect } from 'chai'
 import { pathExists, readdir, readFile } from 'fs-extra'
 import { join } from 'path'
-import { HttpStatusCode } from '@shared/core-utils'
 import {
-  buildServerDirectory,
-  getPluginTestPath,
-  installPlugin,
+  cleanupTests,
+  createSingleServer,
   makeGetRequest,
-  setAccessTokensToServers,
-  uninstallPlugin
-} from '../../../shared/extra-utils'
-import { cleanupTests, flushAndRunServer, ServerInfo, waitUntilLog } from '../../../shared/extra-utils/server/servers'
+  PeerTubeServer,
+  PluginsCommand,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test plugin storage', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      path: getPluginTestPath('-six')
-    })
+    await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-six') })
   })
 
   describe('DB storage', function () {
 
     it('Should correctly store a subkey', async function () {
-      await waitUntilLog(server, 'superkey stored value is toto')
+      await server.servers.waitUntilLog('superkey stored value is toto')
     })
   })
 
@@ -50,12 +45,12 @@ describe('Test plugin storage', function () {
     }
 
     before(function () {
-      dataPath = buildServerDirectory(server, 'plugins/data')
+      dataPath = server.servers.buildDirectory('plugins/data')
       pluginDataPath = join(dataPath, 'peertube-plugin-test-six')
     })
 
     it('Should have created the directory on install', async function () {
-      const dataPath = buildServerDirectory(server, 'plugins/data')
+      const dataPath = server.servers.buildDirectory('plugins/data')
       const pluginDataPath = join(dataPath, 'peertube-plugin-test-six')
 
       expect(await pathExists(dataPath)).to.be.true
@@ -68,7 +63,7 @@ describe('Test plugin storage', function () {
         url: server.url,
         token: server.accessToken,
         path: '/plugins/test-six/router/create-file',
-        statusCodeExpected: HttpStatusCode.OK_200
+        expectedStatus: HttpStatusCode.OK_200
       })
 
       const content = await getFileContent()
@@ -76,22 +71,14 @@ describe('Test plugin storage', function () {
     })
 
     it('Should still have the file after an uninstallation', async function () {
-      await uninstallPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        npmName: 'peertube-plugin-test-six'
-      })
+      await server.plugins.uninstall({ npmName: 'peertube-plugin-test-six' })
 
       const content = await getFileContent()
       expect(content).to.equal('Prince Ali')
     })
 
     it('Should still have the file after the reinstallation', async function () {
-      await installPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        path: getPluginTestPath('-six')
-      })
+      await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-six') })
 
       const content = await getFileContent()
       expect(content).to.equal('Prince Ali')
diff --git a/server/tests/plugins/plugin-transcoding.ts b/server/tests/plugins/plugin-transcoding.ts
index eefb2294d..93637e3ce 100644
--- a/server/tests/plugins/plugin-transcoding.ts
+++ b/server/tests/plugins/plugin-transcoding.ts
@@ -2,79 +2,73 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import { join } from 'path'
 import { getAudioStream, getVideoFileFPS, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
-import { ServerConfig, VideoDetails, VideoPrivacy } from '@shared/models'
 import {
-  buildServerDirectory,
-  createLive,
-  getConfig,
-  getPluginTestPath,
-  getVideo,
-  installPlugin,
-  sendRTMPStreamInVideo,
+  cleanupTests,
+  createSingleServer,
+  PeerTubeServer,
+  PluginsCommand,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   testFfmpegStreamError,
-  uninstallPlugin,
-  updateCustomSubConfig,
-  uploadVideoAndGetId,
-  waitJobs,
-  waitUntilLivePublished
-} from '../../../shared/extra-utils'
-import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
-
-async function createLiveWrapper (server: ServerInfo) {
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoPrivacy } from '@shared/models'
+
+async function createLiveWrapper (server: PeerTubeServer) {
   const liveAttributes = {
     name: 'live video',
-    channelId: server.videoChannel.id,
+    channelId: server.store.channel.id,
     privacy: VideoPrivacy.PUBLIC
   }
 
-  const res = await createLive(server.url, server.accessToken, liveAttributes)
-  return res.body.video.uuid
+  const { uuid } = await server.live.create({ fields: liveAttributes })
+
+  return uuid
 }
 
-function updateConf (server: ServerInfo, vodProfile: string, liveProfile: string) {
-  return updateCustomSubConfig(server.url, server.accessToken, {
-    transcoding: {
-      enabled: true,
-      profile: vodProfile,
-      hls: {
-        enabled: true
-      },
-      webtorrent: {
-        enabled: true
-      },
-      resolutions: {
-        '240p': true,
-        '360p': false,
-        '480p': false,
-        '720p': true
-      }
-    },
-    live: {
+function updateConf (server: PeerTubeServer, vodProfile: string, liveProfile: string) {
+  return server.config.updateCustomSubConfig({
+    newConfig: {
       transcoding: {
-        profile: liveProfile,
         enabled: true,
+        profile: vodProfile,
+        hls: {
+          enabled: true
+        },
+        webtorrent: {
+          enabled: true
+        },
         resolutions: {
           '240p': true,
           '360p': false,
           '480p': false,
           '720p': true
         }
+      },
+      live: {
+        transcoding: {
+          profile: liveProfile,
+          enabled: true,
+          resolutions: {
+            '240p': true,
+            '360p': false,
+            '480p': false,
+            '720p': true
+          }
+        }
       }
     }
   })
 }
 
 describe('Test transcoding plugins', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   before(async function () {
     this.timeout(60000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
     await setDefaultVideoChannel([ server ])
 
@@ -84,8 +78,7 @@ describe('Test transcoding plugins', function () {
   describe('When using a plugin adding profiles to existing encoders', function () {
 
     async function checkVideoFPS (uuid: string, type: 'above' | 'below', fps: number) {
-      const res = await getVideo(server.url, uuid)
-      const video = res.body as VideoDetails
+      const video = await server.videos.get({ id: uuid })
       const files = video.files.concat(...video.streamingPlaylists.map(p => p.files))
 
       for (const file of files) {
@@ -109,134 +102,132 @@ describe('Test transcoding plugins', function () {
     }
 
     before(async function () {
-      await installPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        path: getPluginTestPath('-transcoding-one')
-      })
+      await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-transcoding-one') })
     })
 
     it('Should have the appropriate available profiles', async function () {
-      const res = await getConfig(server.url)
-      const config = res.body as ServerConfig
+      const config = await server.config.getConfig()
 
       expect(config.transcoding.availableProfiles).to.have.members([ 'default', 'low-vod', 'input-options-vod', 'bad-scale-vod' ])
-      expect(config.live.transcoding.availableProfiles).to.have.members([ 'default', 'low-live', 'input-options-live', 'bad-scale-live' ])
+      expect(config.live.transcoding.availableProfiles).to.have.members([ 'default', 'high-live', 'input-options-live', 'bad-scale-live' ])
     })
 
-    it('Should not use the plugin profile if not chosen by the admin', async function () {
-      this.timeout(240000)
+    describe('VOD', function () {
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
-      await waitJobs([ server ])
+      it('Should not use the plugin profile if not chosen by the admin', async function () {
+        this.timeout(240000)
 
-      await checkVideoFPS(videoUUID, 'above', 20)
-    })
+        const videoUUID = (await server.videos.quickUpload({ name: 'video' })).uuid
+        await waitJobs([ server ])
 
-    it('Should use the vod profile', async function () {
-      this.timeout(240000)
+        await checkVideoFPS(videoUUID, 'above', 20)
+      })
 
-      await updateConf(server, 'low-vod', 'default')
+      it('Should use the vod profile', async function () {
+        this.timeout(240000)
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
-      await waitJobs([ server ])
+        await updateConf(server, 'low-vod', 'default')
 
-      await checkVideoFPS(videoUUID, 'below', 12)
-    })
+        const videoUUID = (await server.videos.quickUpload({ name: 'video' })).uuid
+        await waitJobs([ server ])
 
-    it('Should apply input options in vod profile', async function () {
-      this.timeout(240000)
+        await checkVideoFPS(videoUUID, 'below', 12)
+      })
 
-      await updateConf(server, 'input-options-vod', 'default')
+      it('Should apply input options in vod profile', async function () {
+        this.timeout(240000)
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
-      await waitJobs([ server ])
+        await updateConf(server, 'input-options-vod', 'default')
 
-      await checkVideoFPS(videoUUID, 'below', 6)
-    })
+        const videoUUID = (await server.videos.quickUpload({ name: 'video' })).uuid
+        await waitJobs([ server ])
 
-    it('Should apply the scale filter in vod profile', async function () {
-      this.timeout(240000)
+        await checkVideoFPS(videoUUID, 'below', 6)
+      })
 
-      await updateConf(server, 'bad-scale-vod', 'default')
+      it('Should apply the scale filter in vod profile', async function () {
+        this.timeout(240000)
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
-      await waitJobs([ server ])
+        await updateConf(server, 'bad-scale-vod', 'default')
 
-      // Transcoding failed
-      const res = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = res.body
+        const videoUUID = (await server.videos.quickUpload({ name: 'video' })).uuid
+        await waitJobs([ server ])
 
-      expect(video.files).to.have.lengthOf(1)
-      expect(video.streamingPlaylists).to.have.lengthOf(0)
+        // Transcoding failed
+        const video = await server.videos.get({ id: videoUUID })
+        expect(video.files).to.have.lengthOf(1)
+        expect(video.streamingPlaylists).to.have.lengthOf(0)
+      })
     })
 
-    it('Should not use the plugin profile if not chosen by the admin', async function () {
-      this.timeout(240000)
+    describe('Live', function () {
 
-      const liveVideoId = await createLiveWrapper(server)
+      it('Should not use the plugin profile if not chosen by the admin', async function () {
+        this.timeout(240000)
 
-      await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
-      await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
-      await waitJobs([ server ])
+        const liveVideoId = await createLiveWrapper(server)
 
-      await checkLiveFPS(liveVideoId, 'above', 20)
-    })
+        await server.live.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_very_short_240p.mp4' })
+        await server.live.waitUntilPublished({ videoId: liveVideoId })
+        await waitJobs([ server ])
 
-    it('Should use the live profile', async function () {
-      this.timeout(240000)
+        await checkLiveFPS(liveVideoId, 'above', 20)
+      })
 
-      await updateConf(server, 'low-vod', 'low-live')
+      it('Should use the live profile', async function () {
+        this.timeout(240000)
 
-      const liveVideoId = await createLiveWrapper(server)
+        await updateConf(server, 'low-vod', 'high-live')
 
-      await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
-      await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
-      await waitJobs([ server ])
+        const liveVideoId = await createLiveWrapper(server)
 
-      await checkLiveFPS(liveVideoId, 'below', 12)
-    })
+        await server.live.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_very_short_240p.mp4' })
+        await server.live.waitUntilPublished({ videoId: liveVideoId })
+        await waitJobs([ server ])
 
-    it('Should apply the input options on live profile', async function () {
-      this.timeout(240000)
+        await checkLiveFPS(liveVideoId, 'above', 45)
+      })
 
-      await updateConf(server, 'low-vod', 'input-options-live')
+      it('Should apply the input options on live profile', async function () {
+        this.timeout(240000)
 
-      const liveVideoId = await createLiveWrapper(server)
+        await updateConf(server, 'low-vod', 'input-options-live')
 
-      await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
-      await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
-      await waitJobs([ server ])
+        const liveVideoId = await createLiveWrapper(server)
 
-      await checkLiveFPS(liveVideoId, 'below', 6)
-    })
+        await server.live.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_very_short_240p.mp4' })
+        await server.live.waitUntilPublished({ videoId: liveVideoId })
+        await waitJobs([ server ])
 
-    it('Should apply the scale filter name on live profile', async function () {
-      this.timeout(240000)
+        await checkLiveFPS(liveVideoId, 'above', 45)
+      })
 
-      await updateConf(server, 'low-vod', 'bad-scale-live')
+      it('Should apply the scale filter name on live profile', async function () {
+        this.timeout(240000)
 
-      const liveVideoId = await createLiveWrapper(server)
+        await updateConf(server, 'low-vod', 'bad-scale-live')
 
-      const command = await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
-      await testFfmpegStreamError(command, true)
-    })
+        const liveVideoId = await createLiveWrapper(server)
 
-    it('Should default to the default profile if the specified profile does not exist', async function () {
-      this.timeout(240000)
+        const command = await server.live.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_very_short_240p.mp4' })
+        await testFfmpegStreamError(command, true)
+      })
 
-      await uninstallPlugin({ url: server.url, accessToken: server.accessToken, npmName: 'peertube-plugin-test-transcoding-one' })
+      it('Should default to the default profile if the specified profile does not exist', async function () {
+        this.timeout(240000)
 
-      const res = await getConfig(server.url)
-      const config = res.body as ServerConfig
+        await server.plugins.uninstall({ npmName: 'peertube-plugin-test-transcoding-one' })
 
-      expect(config.transcoding.availableProfiles).to.deep.equal([ 'default' ])
-      expect(config.live.transcoding.availableProfiles).to.deep.equal([ 'default' ])
+        const config = await server.config.getConfig()
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
-      await waitJobs([ server ])
+        expect(config.transcoding.availableProfiles).to.deep.equal([ 'default' ])
+        expect(config.live.transcoding.availableProfiles).to.deep.equal([ 'default' ])
+
+        const videoUUID = (await server.videos.quickUpload({ name: 'video', fixture: 'video_very_short_240p.mp4' })).uuid
+        await waitJobs([ server ])
 
-      await checkVideoFPS(videoUUID, 'above', 20)
+        await checkVideoFPS(videoUUID, 'above', 20)
+      })
     })
 
   })
@@ -244,11 +235,7 @@ describe('Test transcoding plugins', function () {
   describe('When using a plugin adding new encoders', function () {
 
     before(async function () {
-      await installPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        path: getPluginTestPath('-transcoding-two')
-      })
+      await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-transcoding-two') })
 
       await updateConf(server, 'test-vod-profile', 'test-live-profile')
     })
@@ -256,10 +243,12 @@ describe('Test transcoding plugins', function () {
     it('Should use the new vod encoders', async function () {
       this.timeout(240000)
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video', fixture: 'video_short_240p.mp4' })).uuid
+      const videoUUID = (await server.videos.quickUpload({ name: 'video', fixture: 'video_very_short_240p.mp4' })).uuid
       await waitJobs([ server ])
 
-      const path = buildServerDirectory(server, join('videos', videoUUID + '-240.mp4'))
+      const video = await server.videos.get({ id: videoUUID })
+
+      const path = server.servers.buildWebTorrentFilePath(video.files[0].fileUrl)
       const audioProbe = await getAudioStream(path)
       expect(audioProbe.audioStream.codec_name).to.equal('opus')
 
@@ -272,8 +261,8 @@ describe('Test transcoding plugins', function () {
 
       const liveVideoId = await createLiveWrapper(server)
 
-      await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
-      await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
+      await server.live.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
+      await server.live.waitUntilPublished({ videoId: liveVideoId })
       await waitJobs([ server ])
 
       const playlistUrl = `${server.url}/static/streaming-playlists/hls/${liveVideoId}/0.m3u8`
diff --git a/server/tests/plugins/plugin-unloading.ts b/server/tests/plugins/plugin-unloading.ts
index 74ca82e2f..6bf2fda9b 100644
--- a/server/tests/plugins/plugin-unloading.ts
+++ b/server/tests/plugins/plugin-unloading.ts
@@ -1,42 +1,36 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
+import { expect } from 'chai'
 import {
   cleanupTests,
-  flushAndRunServer,
-  getPluginTestPath,
+  createSingleServer,
   makeGetRequest,
-  installPlugin,
-  uninstallPlugin,
-  ServerInfo,
+  PeerTubeServer,
+  PluginsCommand,
   setAccessTokensToServers
-} from '../../../shared/extra-utils'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { expect } from 'chai'
+} from '@shared/extra-utils'
+import { HttpStatusCode } from '@shared/models'
 
 describe('Test plugins module unloading', function () {
-  let server: ServerInfo = null
+  let server: PeerTubeServer = null
   const requestPath = '/plugins/test-unloading/router/get'
   let value: string = null
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      path: getPluginTestPath('-unloading')
-    })
+    await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-unloading') })
   })
 
   it('Should return a numeric value', async function () {
     const res = await makeGetRequest({
       url: server.url,
       path: requestPath,
-      statusCodeExpected: HttpStatusCode.OK_200
+      expectedStatus: HttpStatusCode.OK_200
     })
 
     expect(res.body.message).to.match(/^\d+$/)
@@ -47,36 +41,29 @@ describe('Test plugins module unloading', function () {
     const res = await makeGetRequest({
       url: server.url,
       path: requestPath,
-      statusCodeExpected: HttpStatusCode.OK_200
+      expectedStatus: HttpStatusCode.OK_200
     })
 
     expect(res.body.message).to.be.equal(value)
   })
 
   it('Should uninstall the plugin and free the route', async function () {
-    await uninstallPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      npmName: 'peertube-plugin-test-unloading'
-    })
+    await server.plugins.uninstall({ npmName: 'peertube-plugin-test-unloading' })
 
     await makeGetRequest({
       url: server.url,
       path: requestPath,
-      statusCodeExpected: HttpStatusCode.NOT_FOUND_404
+      expectedStatus: HttpStatusCode.NOT_FOUND_404
     })
   })
 
   it('Should return a different numeric value', async function () {
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      path: getPluginTestPath('-unloading')
-    })
+    await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-unloading') })
+
     const res = await makeGetRequest({
       url: server.url,
       path: requestPath,
-      statusCodeExpected: HttpStatusCode.OK_200
+      expectedStatus: HttpStatusCode.OK_200
     })
 
     expect(res.body.message).to.match(/^\d+$/)
diff --git a/server/tests/plugins/translations.ts b/server/tests/plugins/translations.ts
index 9fd2ba1c5..8b25c6b75 100644
--- a/server/tests/plugins/translations.ts
+++ b/server/tests/plugins/translations.ts
@@ -1,50 +1,37 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
-import {
-  getPluginTestPath,
-  getPluginTranslations,
-  installPlugin,
-  setAccessTokensToServers,
-  uninstallPlugin
-} from '../../../shared/extra-utils'
+import * as chai from 'chai'
+import { cleanupTests, createSingleServer, PeerTubeServer, PluginsCommand, setAccessTokensToServers } from '@shared/extra-utils'
 
 const expect = chai.expect
 
 describe('Test plugin translations', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
+  let command: PluginsCommand
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      path: getPluginTestPath()
-    })
+    command = server.plugins
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      path: getPluginTestPath('-filter-translations')
-    })
+    await command.install({ path: PluginsCommand.getPluginTestPath() })
+    await command.install({ path: PluginsCommand.getPluginTestPath('-filter-translations') })
   })
 
   it('Should not have translations for locale pt', async function () {
-    const res = await getPluginTranslations({ url: server.url, locale: 'pt' })
+    const body = await command.getTranslations({ locale: 'pt' })
 
-    expect(res.body).to.deep.equal({})
+    expect(body).to.deep.equal({})
   })
 
   it('Should have translations for locale fr', async function () {
-    const res = await getPluginTranslations({ url: server.url, locale: 'fr-FR' })
+    const body = await command.getTranslations({ locale: 'fr-FR' })
 
-    expect(res.body).to.deep.equal({
+    expect(body).to.deep.equal({
       'peertube-plugin-test': {
         Hi: 'Coucou'
       },
@@ -55,9 +42,9 @@ describe('Test plugin translations', function () {
   })
 
   it('Should have translations of locale it', async function () {
-    const res = await getPluginTranslations({ url: server.url, locale: 'it-IT' })
+    const body = await command.getTranslations({ locale: 'it-IT' })
 
-    expect(res.body).to.deep.equal({
+    expect(body).to.deep.equal({
       'peertube-plugin-test-filter-translations': {
         'Hello world': 'Ciao, mondo!'
       }
@@ -65,12 +52,12 @@ describe('Test plugin translations', function () {
   })
 
   it('Should remove the plugin and remove the locales', async function () {
-    await uninstallPlugin({ url: server.url, accessToken: server.accessToken, npmName: 'peertube-plugin-test-filter-translations' })
+    await command.uninstall({ npmName: 'peertube-plugin-test-filter-translations' })
 
     {
-      const res = await getPluginTranslations({ url: server.url, locale: 'fr-FR' })
+      const body = await command.getTranslations({ locale: 'fr-FR' })
 
-      expect(res.body).to.deep.equal({
+      expect(body).to.deep.equal({
         'peertube-plugin-test': {
           Hi: 'Coucou'
         }
@@ -78,9 +65,9 @@ describe('Test plugin translations', function () {
     }
 
     {
-      const res = await getPluginTranslations({ url: server.url, locale: 'it-IT' })
+      const body = await command.getTranslations({ locale: 'it-IT' })
 
-      expect(res.body).to.deep.equal({})
+      expect(body).to.deep.equal({})
     }
   })
 
diff --git a/server/tests/plugins/video-constants.ts b/server/tests/plugins/video-constants.ts
index eb014c596..19cba6c2c 100644
--- a/server/tests/plugins/video-constants.ts
+++ b/server/tests/plugins/video-constants.ts
@@ -1,44 +1,33 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
 import 'mocha'
-import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
+import * as chai from 'chai'
 import {
-  createVideoPlaylist,
-  getPluginTestPath,
-  getVideo,
-  getVideoCategories,
-  getVideoLanguages,
-  getVideoLicences, getVideoPlaylistPrivacies, getVideoPrivacies,
-  installPlugin,
-  setAccessTokensToServers,
-  uninstallPlugin,
-  uploadVideo
-} from '../../../shared/extra-utils'
-import { VideoDetails, VideoPlaylistPrivacy } from '../../../shared/models/videos'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+  cleanupTests,
+  createSingleServer,
+  makeGetRequest,
+  PeerTubeServer,
+  PluginsCommand,
+  setAccessTokensToServers
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoPlaylistPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test plugin altering video constants', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   before(async function () {
     this.timeout(30000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
 
-    await installPlugin({
-      url: server.url,
-      accessToken: server.accessToken,
-      path: getPluginTestPath('-video-constants')
-    })
+    await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-video-constants') })
   })
 
   it('Should have updated languages', async function () {
-    const res = await getVideoLanguages(server.url)
-    const languages = res.body
+    const languages = await server.videos.getLanguages()
 
     expect(languages['en']).to.not.exist
     expect(languages['fr']).to.not.exist
@@ -49,8 +38,7 @@ describe('Test plugin altering video constants', function () {
   })
 
   it('Should have updated categories', async function () {
-    const res = await getVideoCategories(server.url)
-    const categories = res.body
+    const categories = await server.videos.getCategories()
 
     expect(categories[1]).to.not.exist
     expect(categories[2]).to.not.exist
@@ -60,8 +48,7 @@ describe('Test plugin altering video constants', function () {
   })
 
   it('Should have updated licences', async function () {
-    const res = await getVideoLicences(server.url)
-    const licences = res.body
+    const licences = await server.videos.getLicences()
 
     expect(licences[1]).to.not.exist
     expect(licences[7]).to.not.exist
@@ -71,8 +58,7 @@ describe('Test plugin altering video constants', function () {
   })
 
   it('Should have updated video privacies', async function () {
-    const res = await getVideoPrivacies(server.url)
-    const privacies = res.body
+    const privacies = await server.videos.getPrivacies()
 
     expect(privacies[1]).to.exist
     expect(privacies[2]).to.not.exist
@@ -81,8 +67,7 @@ describe('Test plugin altering video constants', function () {
   })
 
   it('Should have updated playlist privacies', async function () {
-    const res = await getVideoPlaylistPrivacies(server.url)
-    const playlistPrivacies = res.body
+    const playlistPrivacies = await server.playlists.getPrivacies()
 
     expect(playlistPrivacies[1]).to.exist
     expect(playlistPrivacies[2]).to.exist
@@ -90,38 +75,30 @@ describe('Test plugin altering video constants', function () {
   })
 
   it('Should not be able to create a video with this privacy', async function () {
-    const attrs = { name: 'video', privacy: 2 }
-    await uploadVideo(server.url, server.accessToken, attrs, HttpStatusCode.BAD_REQUEST_400)
+    const attributes = { name: 'video', privacy: 2 }
+    await server.videos.upload({ attributes, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should not be able to create a video with this privacy', async function () {
-    const attrs = { displayName: 'video playlist', privacy: VideoPlaylistPrivacy.PRIVATE }
-    await createVideoPlaylist({
-      url: server.url,
-      token: server.accessToken,
-      playlistAttrs: attrs,
-      expectedStatus: HttpStatusCode.BAD_REQUEST_400
-    })
+    const attributes = { displayName: 'video playlist', privacy: VideoPlaylistPrivacy.PRIVATE }
+    await server.playlists.create({ attributes, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
   })
 
   it('Should be able to upload a video with these values', async function () {
-    const attrs = { name: 'video', category: 42, licence: 42, language: 'al_bhed2' }
-    const resUpload = await uploadVideo(server.url, server.accessToken, attrs)
+    const attributes = { name: 'video', category: 42, licence: 42, language: 'al_bhed2' }
+    const { uuid } = await server.videos.upload({ attributes })
 
-    const res = await getVideo(server.url, resUpload.body.video.uuid)
-
-    const video: VideoDetails = res.body
+    const video = await server.videos.get({ id: uuid })
     expect(video.language.label).to.equal('Al Bhed 2')
     expect(video.licence.label).to.equal('Best licence')
     expect(video.category.label).to.equal('Best category')
   })
 
   it('Should uninstall the plugin and reset languages, categories, licences and privacies', async function () {
-    await uninstallPlugin({ url: server.url, accessToken: server.accessToken, npmName: 'peertube-plugin-test-video-constants' })
+    await server.plugins.uninstall({ npmName: 'peertube-plugin-test-video-constants' })
 
     {
-      const res = await getVideoLanguages(server.url)
-      const languages = res.body
+      const languages = await server.videos.getLanguages()
 
       expect(languages['en']).to.equal('English')
       expect(languages['fr']).to.equal('French')
@@ -132,8 +109,7 @@ describe('Test plugin altering video constants', function () {
     }
 
     {
-      const res = await getVideoCategories(server.url)
-      const categories = res.body
+      const categories = await server.videos.getCategories()
 
       expect(categories[1]).to.equal('Music')
       expect(categories[2]).to.equal('Films')
@@ -143,8 +119,7 @@ describe('Test plugin altering video constants', function () {
     }
 
     {
-      const res = await getVideoLicences(server.url)
-      const licences = res.body
+      const licences = await server.videos.getLicences()
 
       expect(licences[1]).to.equal('Attribution')
       expect(licences[7]).to.equal('Public Domain Dedication')
@@ -154,8 +129,7 @@ describe('Test plugin altering video constants', function () {
     }
 
     {
-      const res = await getVideoPrivacies(server.url)
-      const privacies = res.body
+      const privacies = await server.videos.getPrivacies()
 
       expect(privacies[1]).to.exist
       expect(privacies[2]).to.exist
@@ -164,8 +138,7 @@ describe('Test plugin altering video constants', function () {
     }
 
     {
-      const res = await getVideoPlaylistPrivacies(server.url)
-      const playlistPrivacies = res.body
+      const playlistPrivacies = await server.playlists.getPrivacies()
 
       expect(playlistPrivacies[1]).to.exist
       expect(playlistPrivacies[2]).to.exist
@@ -173,6 +146,37 @@ describe('Test plugin altering video constants', function () {
     }
   })
 
+  it('Should be able to reset categories', async function () {
+    await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-video-constants') })
+
+    {
+      const categories = await server.videos.getCategories()
+
+      expect(categories[1]).to.not.exist
+      expect(categories[2]).to.not.exist
+
+      expect(categories[42]).to.exist
+      expect(categories[43]).to.exist
+    }
+
+    await makeGetRequest({
+      url: server.url,
+      token: server.accessToken,
+      path: '/plugins/test-video-constants/router/reset-categories',
+      expectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+
+    {
+      const categories = await server.videos.getCategories()
+
+      expect(categories[1]).to.exist
+      expect(categories[2]).to.exist
+
+      expect(categories[42]).to.not.exist
+      expect(categories[43]).to.not.exist
+    }
+  })
+
   after(async function () {
     await cleanupTests([ server ])
   })
diff --git a/server/tools/cli.ts b/server/tools/cli.ts
index 7b94306cd..52e6ea593 100644
--- a/server/tools/cli.ts
+++ b/server/tools/cli.ts
@@ -1,14 +1,11 @@
+import { Command } from 'commander'
 import { Netrc } from 'netrc-parser'
-import { getAppNumber, isTestInstance } from '../helpers/core-utils'
 import { join } from 'path'
-import { root } from '../../shared/extra-utils/miscs/miscs'
-import { getVideoChannel } from '../../shared/extra-utils/videos/video-channels'
-import { VideoChannel, VideoPrivacy } from '../../shared/models/videos'
 import { createLogger, format, transports } from 'winston'
-import { getMyUserInformation } from '@shared/extra-utils/users/users'
-import { User, UserRole } from '@shared/models'
-import { getAccessToken } from '@shared/extra-utils/users/login'
-import { Command } from 'commander'
+import { PeerTubeServer } from '@shared/extra-utils'
+import { UserRole } from '@shared/models'
+import { VideoPrivacy } from '../../shared/models/videos'
+import { getAppNumber, isTestInstance, root } from '../helpers/core-utils'
 
 let configName = 'PeerTube/CLI'
 if (isTestInstance()) configName += `-${getAppNumber()}`
@@ -17,17 +14,16 @@ const config = require('application-config')(configName)
 
 const version = require('../../../package.json').version
 
-async function getAdminTokenOrDie (url: string, username: string, password: string) {
-  const accessToken = await getAccessToken(url, username, password)
-  const resMe = await getMyUserInformation(url, accessToken)
-  const me: User = resMe.body
+async function getAdminTokenOrDie (server: PeerTubeServer, username: string, password: string) {
+  const token = await server.login.getAccessToken(username, password)
+  const me = await server.users.getMyInfo({ token })
 
   if (me.role !== UserRole.ADMINISTRATOR) {
     console.error('You must be an administrator.')
     process.exit(-1)
   }
 
-  return accessToken
+  return token
 }
 
 interface Settings {
@@ -128,7 +124,7 @@ function buildCommonVideoOptions (command: Command) {
     .option('-v, --verbose <verbose>', 'Verbosity, from 0/\'error\' to 4/\'debug\'', 'info')
 }
 
-async function buildVideoAttributesFromCommander (url: string, command: Command, defaultAttributes: any = {}) {
+async function buildVideoAttributesFromCommander (server: PeerTubeServer, command: Command, defaultAttributes: any = {}) {
   const options = command.opts()
 
   const defaultBooleanAttributes = {
@@ -164,8 +160,7 @@ async function buildVideoAttributesFromCommander (url: string, command: Command,
   Object.assign(videoAttributes, booleanAttributes)
 
   if (options.channelName) {
-    const res = await getVideoChannel(url, options.channelName)
-    const videoChannel: VideoChannel = res.body
+    const videoChannel = await server.channels.get({ channelName: options.channelName })
 
     Object.assign(videoAttributes, { channelId: videoChannel.id })
 
@@ -184,6 +179,19 @@ function getServerCredentials (program: Command) {
                 })
 }
 
+function buildServer (url: string) {
+  return new PeerTubeServer({ url })
+}
+
+async function assignToken (server: PeerTubeServer, username: string, password: string) {
+  const bodyClient = await server.login.getClient()
+  const client = { id: bodyClient.client_id, secret: bodyClient.client_secret }
+
+  const body = await server.login.login({ client, user: { username, password } })
+
+  server.accessToken = body.access_token
+}
+
 function getLogger (logLevel = 'info') {
   const logLevels = {
     0: 0,
@@ -230,5 +238,7 @@ export {
   buildCommonVideoOptions,
   buildVideoAttributesFromCommander,
 
-  getAdminTokenOrDie
+  getAdminTokenOrDie,
+  buildServer,
+  assignToken
 }
diff --git a/server/tools/peertube-auth.ts b/server/tools/peertube-auth.ts
index 1934e7986..b9f4ef4f8 100644
--- a/server/tools/peertube-auth.ts
+++ b/server/tools/peertube-auth.ts
@@ -5,9 +5,8 @@ registerTSPaths()
 
 import { OptionValues, program } from 'commander'
 import * as prompt from 'prompt'
-import { getNetrc, getSettings, writeSettings } from './cli'
+import { assignToken, buildServer, getNetrc, getSettings, writeSettings } from './cli'
 import { isUserUsernameValid } from '../helpers/custom-validators/users'
-import { getAccessToken } from '../../shared/extra-utils'
 import * as CliTable3 from 'cli-table3'
 
 async function delInstance (url: string) {
@@ -97,7 +96,8 @@ program
         // @see https://github.com/Chocobozzz/PeerTube/issues/3520
         result.url = stripExtraneousFromPeerTubeUrl(result.url)
 
-        await getAccessToken(result.url, result.username, result.password)
+        const server = buildServer(result.url)
+        await assignToken(server, result.username, result.password)
       } catch (err) {
         console.error(err.message)
         process.exit(-1)
diff --git a/server/tools/peertube-get-access-token.ts b/server/tools/peertube-get-access-token.ts
index 9488eba0e..a67de9180 100644
--- a/server/tools/peertube-get-access-token.ts
+++ b/server/tools/peertube-get-access-token.ts
@@ -2,7 +2,7 @@ import { registerTSPaths } from '../helpers/register-ts-paths'
 registerTSPaths()
 
 import { program } from 'commander'
-import { getClient, Server, serverLogin } from '../../shared/extra-utils'
+import { assignToken, buildServer } from './cli'
 
 program
   .option('-u, --url <url>', 'Server url')
@@ -24,24 +24,11 @@ if (
   process.exit(-1)
 }
 
-getClient(options.url)
-  .then(res => {
-    const server = {
-      url: options.url,
-      user: {
-        username: options.username,
-        password: options.password
-      },
-      client: {
-        id: res.body.client_id,
-        secret: res.body.client_secret
-      }
-    } as Server
+const server = buildServer(options.url)
 
-    return serverLogin(server)
-  })
-  .then(accessToken => {
-    console.log(accessToken)
+assignToken(server, options.username, options.password)
+  .then(() => {
+    console.log(server.accessToken)
     process.exit(0)
   })
   .catch(err => {
diff --git a/server/tools/peertube-import-videos.ts b/server/tools/peertube-import-videos.ts
index 101a95b2a..52aae3d2c 100644
--- a/server/tools/peertube-import-videos.ts
+++ b/server/tools/peertube-import-videos.ts
@@ -8,17 +8,19 @@ import { truncate } from 'lodash'
 import { join } from 'path'
 import * as prompt from 'prompt'
 import { promisify } from 'util'
-import { advancedVideosSearch, getClient, getVideoCategories, login, uploadVideo } from '../../shared/extra-utils/index'
+import { YoutubeDL } from '@server/helpers/youtube-dl'
 import { sha256 } from '../helpers/core-utils'
 import { doRequestAndSaveToFile } from '../helpers/requests'
 import { CONSTRAINTS_FIELDS } from '../initializers/constants'
-import { buildCommonVideoOptions, buildVideoAttributesFromCommander, getLogger, getServerCredentials } from './cli'
-import { YoutubeDL } from '@server/helpers/youtube-dl'
-
-type UserInfo = {
-  username: string
-  password: string
-}
+import {
+  assignToken,
+  buildCommonVideoOptions,
+  buildServer,
+  buildVideoAttributesFromCommander,
+  getLogger,
+  getServerCredentials
+} from './cli'
+import { PeerTubeServer } from '@shared/extra-utils'
 
 const processOptions = {
   maxBuffer: Infinity
@@ -62,17 +64,13 @@ getServerCredentials(command)
     url = normalizeTargetUrl(url)
     options.targetUrl = normalizeTargetUrl(options.targetUrl)
 
-    const user = { username, password }
-
-    run(url, user)
+    run(url, username, password)
       .catch(err => exitError(err))
   })
   .catch(err => console.error(err))
 
-async function run (url: string, user: UserInfo) {
-  if (!user.password) {
-    user.password = await promptPassword()
-  }
+async function run (url: string, username: string, password: string) {
+  if (!password) password = await promptPassword()
 
   const youtubeDLBinary = await YoutubeDL.safeGetYoutubeDL()
 
@@ -111,7 +109,8 @@ async function run (url: string, user: UserInfo) {
       await processVideo({
         cwd: options.tmpdir,
         url,
-        user,
+        username,
+        password,
         youtubeInfo: info
       })
     } catch (err) {
@@ -119,17 +118,18 @@ async function run (url: string, user: UserInfo) {
     }
   }
 
-  log.info('Video/s for user %s imported: %s', user.username, options.targetUrl)
+  log.info('Video/s for user %s imported: %s', username, options.targetUrl)
   process.exit(0)
 }
 
 async function processVideo (parameters: {
   cwd: string
   url: string
-  user: { username: string, password: string }
+  username: string
+  password: string
   youtubeInfo: any
 }) {
-  const { youtubeInfo, cwd, url, user } = parameters
+  const { youtubeInfo, cwd, url, username, password } = parameters
   const youtubeDL = new YoutubeDL('', [])
 
   log.debug('Fetching object.', youtubeInfo)
@@ -138,22 +138,29 @@ async function processVideo (parameters: {
   log.debug('Fetched object.', videoInfo)
 
   const originallyPublishedAt = youtubeDL.buildOriginallyPublishedAt(videoInfo)
+
   if (options.since && originallyPublishedAt && originallyPublishedAt.getTime() < options.since.getTime()) {
-    log.info('Video "%s" has been published before "%s", don\'t upload it.\n',
-      videoInfo.title, formatDate(options.since))
+    log.info('Video "%s" has been published before "%s", don\'t upload it.\n', videoInfo.title, formatDate(options.since))
     return
   }
+
   if (options.until && originallyPublishedAt && originallyPublishedAt.getTime() > options.until.getTime()) {
-    log.info('Video "%s" has been published after "%s", don\'t upload it.\n',
-      videoInfo.title, formatDate(options.until))
+    log.info('Video "%s" has been published after "%s", don\'t upload it.\n', videoInfo.title, formatDate(options.until))
     return
   }
 
-  const result = await advancedVideosSearch(url, { search: videoInfo.title, sort: '-match', searchTarget: 'local' })
+  const server = buildServer(url)
+  const { data } = await server.search.advancedVideoSearch({
+    search: {
+      search: videoInfo.title,
+      sort: '-match',
+      searchTarget: 'local'
+    }
+  })
 
   log.info('############################################################\n')
 
-  if (result.body.data.find(v => v.name === videoInfo.title)) {
+  if (data.find(v => v.name === videoInfo.title)) {
     log.info('Video "%s" already exists, don\'t reupload it.\n', videoInfo.title)
     return
   }
@@ -172,7 +179,8 @@ async function processVideo (parameters: {
       youtubeDL,
       cwd,
       url,
-      user,
+      username,
+      password,
       videoInfo: normalizeObject(videoInfo),
       videoPath: path
     })
@@ -187,11 +195,15 @@ async function uploadVideoOnPeerTube (parameters: {
   videoPath: string
   cwd: string
   url: string
-  user: { username: string, password: string }
+  username: string
+  password: string
 }) {
-  const { youtubeDL, videoInfo, videoPath, cwd, url, user } = parameters
+  const { youtubeDL, videoInfo, videoPath, cwd, url, username, password } = parameters
 
-  const category = await getCategory(videoInfo.categories, url)
+  const server = buildServer(url)
+  await assignToken(server, username, password)
+
+  const category = await getCategory(server, videoInfo.categories)
   const licence = getLicence(videoInfo.license)
   let tags = []
   if (Array.isArray(videoInfo.tags)) {
@@ -223,28 +235,28 @@ async function uploadVideoOnPeerTube (parameters: {
     tags
   }
 
-  const videoAttributes = await buildVideoAttributesFromCommander(url, program, defaultAttributes)
+  const baseAttributes = await buildVideoAttributesFromCommander(server, program, defaultAttributes)
+
+  const attributes = {
+    ...baseAttributes,
 
-  Object.assign(videoAttributes, {
     originallyPublishedAt: originallyPublishedAt ? originallyPublishedAt.toISOString() : null,
     thumbnailfile,
     previewfile: thumbnailfile,
     fixture: videoPath
-  })
-
-  log.info('\nUploading on PeerTube video "%s".', videoAttributes.name)
+  }
 
-  let accessToken = await getAccessTokenOrDie(url, user)
+  log.info('\nUploading on PeerTube video "%s".', attributes.name)
 
   try {
-    await uploadVideo(url, accessToken, videoAttributes)
+    await server.videos.upload({ attributes })
   } catch (err) {
     if (err.message.indexOf('401') !== -1) {
       log.info('Got 401 Unauthorized, token may have expired, renewing token and retry.')
 
-      accessToken = await getAccessTokenOrDie(url, user)
+      server.accessToken = await server.login.getAccessToken(username, password)
 
-      await uploadVideo(url, accessToken, videoAttributes)
+      await server.videos.upload({ attributes })
     } else {
       exitError(err.message)
     }
@@ -253,20 +265,19 @@ async function uploadVideoOnPeerTube (parameters: {
   await remove(videoPath)
   if (thumbnailfile) await remove(thumbnailfile)
 
-  log.warn('Uploaded video "%s"!\n', videoAttributes.name)
+  log.warn('Uploaded video "%s"!\n', attributes.name)
 }
 
 /* ---------------------------------------------------------- */
 
-async function getCategory (categories: string[], url: string) {
+async function getCategory (server: PeerTubeServer, categories: string[]) {
   if (!categories) return undefined
 
   const categoryString = categories[0]
 
   if (categoryString === 'News & Politics') return 11
 
-  const res = await getVideoCategories(url)
-  const categoriesServer = res.body
+  const categoriesServer = await server.videos.getCategories()
 
   for (const key of Object.keys(categoriesServer)) {
     const categoryServer = categoriesServer[key]
@@ -362,21 +373,6 @@ async function promptPassword () {
   })
 }
 
-async function getAccessTokenOrDie (url: string, user: UserInfo) {
-  const resClient = await getClient(url)
-  const client = {
-    id: resClient.body.client_id,
-    secret: resClient.body.client_secret
-  }
-
-  try {
-    const res = await login(url, client, user)
-    return res.body.access_token
-  } catch (err) {
-    exitError('Cannot authenticate. Please check your username/password.')
-  }
-}
-
 function parseDate (dateAsStr: string): Date {
   if (!/\d{4}-\d{2}-\d{2}/.test(dateAsStr)) {
     exitError(`Invalid date passed: ${dateAsStr}. Expected format: YYYY-MM-DD. See help for usage.`)
diff --git a/server/tools/peertube-plugins.ts b/server/tools/peertube-plugins.ts
index 54ea1264d..d9c285115 100644
--- a/server/tools/peertube-plugins.ts
+++ b/server/tools/peertube-plugins.ts
@@ -4,9 +4,8 @@ import { registerTSPaths } from '../helpers/register-ts-paths'
 registerTSPaths()
 
 import { program, Command, OptionValues } from 'commander'
-import { installPlugin, listPlugins, uninstallPlugin, updatePlugin } from '../../shared/extra-utils/server/plugins'
-import { getAdminTokenOrDie, getServerCredentials } from './cli'
-import { PeerTubePlugin, PluginType } from '../../shared/models'
+import { assignToken, buildServer, getServerCredentials } from './cli'
+import { PluginType } from '../../shared/models'
 import { isAbsolute } from 'path'
 import * as CliTable3 from 'cli-table3'
 
@@ -63,28 +62,21 @@ program.parse(process.argv)
 
 async function pluginsListCLI (command: Command, options: OptionValues) {
   const { url, username, password } = await getServerCredentials(command)
-  const accessToken = await getAdminTokenOrDie(url, username, password)
+  const server = buildServer(url)
+  await assignToken(server, username, password)
 
   let pluginType: PluginType
   if (options.onlyThemes) pluginType = PluginType.THEME
   if (options.onlyPlugins) pluginType = PluginType.PLUGIN
 
-  const res = await listPlugins({
-    url,
-    accessToken,
-    start: 0,
-    count: 100,
-    sort: 'name',
-    pluginType
-  })
-  const plugins: PeerTubePlugin[] = res.body.data
+  const { data } = await server.plugins.list({ start: 0, count: 100, sort: 'name', pluginType })
 
   const table = new CliTable3({
     head: [ 'name', 'version', 'homepage' ],
     colWidths: [ 50, 10, 50 ]
   }) as any
 
-  for (const plugin of plugins) {
+  for (const plugin of data) {
     const npmName = plugin.type === PluginType.PLUGIN
       ? 'peertube-plugin-' + plugin.name
       : 'peertube-theme-' + plugin.name
@@ -113,15 +105,11 @@ async function installPluginCLI (command: Command, options: OptionValues) {
   }
 
   const { url, username, password } = await getServerCredentials(command)
-  const accessToken = await getAdminTokenOrDie(url, username, password)
+  const server = buildServer(url)
+  await assignToken(server, username, password)
 
   try {
-    await installPlugin({
-      url,
-      accessToken,
-      npmName: options.npmName,
-      path: options.path
-    })
+    await server.plugins.install({ npmName: options.npmName, path: options.path })
   } catch (err) {
     console.error('Cannot install plugin.', err)
     process.exit(-1)
@@ -144,15 +132,11 @@ async function updatePluginCLI (command: Command, options: OptionValues) {
   }
 
   const { url, username, password } = await getServerCredentials(command)
-  const accessToken = await getAdminTokenOrDie(url, username, password)
+  const server = buildServer(url)
+  await assignToken(server, username, password)
 
   try {
-    await updatePlugin({
-      url,
-      accessToken,
-      npmName: options.npmName,
-      path: options.path
-    })
+    await server.plugins.update({ npmName: options.npmName, path: options.path })
   } catch (err) {
     console.error('Cannot update plugin.', err)
     process.exit(-1)
@@ -170,14 +154,11 @@ async function uninstallPluginCLI (command: Command, options: OptionValues) {
   }
 
   const { url, username, password } = await getServerCredentials(command)
-  const accessToken = await getAdminTokenOrDie(url, username, password)
+  const server = buildServer(url)
+  await assignToken(server, username, password)
 
   try {
-    await uninstallPlugin({
-      url,
-      accessToken,
-      npmName: options.npmName
-    })
+    await server.plugins.uninstall({ npmName: options.npmName })
   } catch (err) {
     console.error('Cannot uninstall plugin.', err)
     process.exit(-1)
diff --git a/server/tools/peertube-redundancy.ts b/server/tools/peertube-redundancy.ts
index 4810deee0..73b026ac8 100644
--- a/server/tools/peertube-redundancy.ts
+++ b/server/tools/peertube-redundancy.ts
@@ -1,17 +1,13 @@
-// eslint-disable @typescript-eslint/no-unnecessary-type-assertion
-
 import { registerTSPaths } from '../helpers/register-ts-paths'
 registerTSPaths()
 
-import { program, Command } from 'commander'
-import { getAdminTokenOrDie, getServerCredentials } from './cli'
-import { VideoRedundanciesTarget, VideoRedundancy } from '@shared/models'
-import { addVideoRedundancy, listVideoRedundancies, removeVideoRedundancy } from '@shared/extra-utils/server/redundancy'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
-import validator from 'validator'
 import * as CliTable3 from 'cli-table3'
-import { URL } from 'url'
+import { Command, program } from 'commander'
 import { uniq } from 'lodash'
+import { URL } from 'url'
+import validator from 'validator'
+import { HttpStatusCode, VideoRedundanciesTarget } from '@shared/models'
+import { assignToken, buildServer, getServerCredentials } from './cli'
 
 import bytes = require('bytes')
 
@@ -63,15 +59,16 @@ program.parse(process.argv)
 
 async function listRedundanciesCLI (target: VideoRedundanciesTarget) {
   const { url, username, password } = await getServerCredentials(program)
-  const accessToken = await getAdminTokenOrDie(url, username, password)
+  const server = buildServer(url)
+  await assignToken(server, username, password)
 
-  const redundancies = await listVideoRedundanciesData(url, accessToken, target)
+  const { data } = await server.redundancy.listVideos({ start: 0, count: 100, sort: 'name', target })
 
   const table = new CliTable3({
     head: [ 'video id', 'video name', 'video url', 'files', 'playlists', 'by instances', 'total size' ]
   }) as any
 
-  for (const redundancy of redundancies) {
+  for (const redundancy of data) {
     const webtorrentFiles = redundancy.redundancies.files
     const streamingPlaylists = redundancy.redundancies.streamingPlaylists
 
@@ -106,7 +103,8 @@ async function listRedundanciesCLI (target: VideoRedundanciesTarget) {
 
 async function addRedundancyCLI (options: { video: number }, command: Command) {
   const { url, username, password } = await getServerCredentials(command)
-  const accessToken = await getAdminTokenOrDie(url, username, password)
+  const server = buildServer(url)
+  await assignToken(server, username, password)
 
   if (!options.video || validator.isInt('' + options.video) === false) {
     console.error('You need to specify the video id to duplicate and it should be a number.\n')
@@ -115,11 +113,7 @@ async function addRedundancyCLI (options: { video: number }, command: Command) {
   }
 
   try {
-    await addVideoRedundancy({
-      url,
-      accessToken,
-      videoId: options.video
-    })
+    await server.redundancy.addVideo({ videoId: options.video })
 
     console.log('Video will be duplicated by your instance!')
 
@@ -139,7 +133,8 @@ async function addRedundancyCLI (options: { video: number }, command: Command) {
 
 async function removeRedundancyCLI (options: { video: number }, command: Command) {
   const { url, username, password } = await getServerCredentials(command)
-  const accessToken = await getAdminTokenOrDie(url, username, password)
+  const server = buildServer(url)
+  await assignToken(server, username, password)
 
   if (!options.video || validator.isInt('' + options.video) === false) {
     console.error('You need to specify the video id to remove from your redundancies.\n')
@@ -149,12 +144,12 @@ async function removeRedundancyCLI (options: { video: number }, command: Command
 
   const videoId = parseInt(options.video + '', 10)
 
-  let redundancies = await listVideoRedundanciesData(url, accessToken, 'my-videos')
-  let videoRedundancy = redundancies.find(r => videoId === r.id)
+  const myVideoRedundancies = await server.redundancy.listVideos({ target: 'my-videos' })
+  let videoRedundancy = myVideoRedundancies.data.find(r => videoId === r.id)
 
   if (!videoRedundancy) {
-    redundancies = await listVideoRedundanciesData(url, accessToken, 'remote-videos')
-    videoRedundancy = redundancies.find(r => videoId === r.id)
+    const remoteVideoRedundancies = await server.redundancy.listVideos({ target: 'remote-videos' })
+    videoRedundancy = remoteVideoRedundancies.data.find(r => videoId === r.id)
   }
 
   if (!videoRedundancy) {
@@ -168,11 +163,7 @@ async function removeRedundancyCLI (options: { video: number }, command: Command
                                .map(r => r.id)
 
     for (const id of ids) {
-      await removeVideoRedundancy({
-        url,
-        accessToken,
-        redundancyId: id
-      })
+      await server.redundancy.removeVideo({ redundancyId: id })
     }
 
     console.log('Video redundancy removed!')
@@ -183,16 +174,3 @@ async function removeRedundancyCLI (options: { video: number }, command: Command
     process.exit(-1)
   }
 }
-
-async function listVideoRedundanciesData (url: string, accessToken: string, target: VideoRedundanciesTarget) {
-  const res = await listVideoRedundancies({
-    url,
-    accessToken,
-    start: 0,
-    count: 100,
-    sort: 'name',
-    target
-  })
-
-  return res.body.data as VideoRedundancy[]
-}
diff --git a/server/tools/peertube-upload.ts b/server/tools/peertube-upload.ts
index 02edbd809..01fb1fe8d 100644
--- a/server/tools/peertube-upload.ts
+++ b/server/tools/peertube-upload.ts
@@ -4,9 +4,7 @@ registerTSPaths()
 import { program } from 'commander'
 import { access, constants } from 'fs-extra'
 import { isAbsolute } from 'path'
-import { getAccessToken } from '../../shared/extra-utils'
-import { uploadVideo } from '../../shared/extra-utils/'
-import { buildCommonVideoOptions, buildVideoAttributesFromCommander, getServerCredentials } from './cli'
+import { assignToken, buildCommonVideoOptions, buildServer, buildVideoAttributesFromCommander, getServerCredentials } from './cli'
 
 let command = program
   .name('upload')
@@ -46,22 +44,25 @@ getServerCredentials(command)
   .catch(err => console.error(err))
 
 async function run (url: string, username: string, password: string) {
-  const accessToken = await getAccessToken(url, username, password)
+  const server = buildServer(url)
+  await assignToken(server, username, password)
 
   await access(options.file, constants.F_OK)
 
   console.log('Uploading %s video...', options.videoName)
 
-  const videoAttributes = await buildVideoAttributesFromCommander(url, program)
+  const baseAttributes = await buildVideoAttributesFromCommander(server, program)
+
+  const attributes = {
+    ...baseAttributes,
 
-  Object.assign(videoAttributes, {
     fixture: options.file,
     thumbnailfile: options.thumbnail,
     previewfile: options.preview
-  })
+  }
 
   try {
-    await uploadVideo(url, accessToken, videoAttributes)
+    await server.videos.upload({ attributes })
     console.log(`Video ${options.videoName} uploaded.`)
     process.exit(0)
   } catch (err) {
diff --git a/server/tools/test.ts b/server/tools/test-live.ts
index fbdbae0b0..50dc04438 100644
--- a/server/tools/test.ts
+++ b/server/tools/test-live.ts
@@ -1,26 +1,23 @@
-import { registerTSPaths } from '../helpers/register-ts-paths'
-registerTSPaths()
-
-import { LiveVideo, LiveVideoCreate, VideoPrivacy } from '@shared/models'
 import { program } from 'commander'
+import { LiveVideoCreate, VideoPrivacy } from '@shared/models'
 import {
-  createLive,
-  flushAndRunServer,
-  getLive,
+  createSingleServer,
   killallServers,
   sendRTMPStream,
-  ServerInfo,
+  PeerTubeServer,
   setAccessTokensToServers,
-  setDefaultVideoChannel,
-  updateCustomSubConfig
+  setDefaultVideoChannel
 } from '../../shared/extra-utils'
+import { registerTSPaths } from '../helpers/register-ts-paths'
+
+registerTSPaths()
 
 type CommandType = 'live-mux' | 'live-transcoding'
 
 registerTSPaths()
 
 const command = program
-  .name('test')
+  .name('test-live')
   .option('-t, --type <type>', 'live-muxing|live-transcoding')
   .parse(process.argv)
 
@@ -39,11 +36,11 @@ async function run () {
 
   console.log('Starting server.')
 
-  const server = await flushAndRunServer(1, {}, [], { hideLogs: false, execArgv: [ '--inspect' ] })
+  const server = await createSingleServer(1, {}, { hideLogs: false, nodeArgs: [ '--inspect' ] })
 
-  const cleanup = () => {
+  const cleanup = async () => {
     console.log('Killing server')
-    killallServers([ server ])
+    await killallServers([ server ])
   }
 
   process.on('exit', cleanup)
@@ -57,17 +54,15 @@ async function run () {
   const attributes: LiveVideoCreate = {
     name: 'live',
     saveReplay: true,
-    channelId: server.videoChannel.id,
+    channelId: server.store.channel.id,
     privacy: VideoPrivacy.PUBLIC
   }
 
   console.log('Creating live.')
 
-  const res = await createLive(server.url, server.accessToken, attributes)
-  const liveVideoUUID = res.body.video.uuid
+  const { uuid: liveVideoUUID } = await server.live.create({ fields: attributes })
 
-  const resLive = await getLive(server.url, server.accessToken, liveVideoUUID)
-  const live: LiveVideo = resLive.body
+  const live = await server.live.get({ videoId: liveVideoUUID })
 
   console.log('Sending RTMP stream.')
 
@@ -86,19 +81,21 @@ async function run () {
 
 // ----------------------------------------------------------------------------
 
-async function buildConfig (server: ServerInfo, commandType: CommandType) {
-  await updateCustomSubConfig(server.url, server.accessToken, {
-    instance: {
-      customizations: {
-        javascript: '',
-        css: ''
-      }
-    },
-    live: {
-      enabled: true,
-      allowReplay: true,
-      transcoding: {
-        enabled: commandType === 'live-transcoding'
+async function buildConfig (server: PeerTubeServer, commandType: CommandType) {
+  await server.config.updateCustomSubConfig({
+    newConfig: {
+      instance: {
+        customizations: {
+          javascript: '',
+          css: ''
+        }
+      },
+      live: {
+        enabled: true,
+        allowReplay: true,
+        transcoding: {
+          enabled: commandType === 'live-transcoding'
+        }
       }
     }
   })
diff --git a/server/types/models/video/video-streaming-playlist.ts b/server/types/models/video/video-streaming-playlist.ts
index 8b3ef51fc..1e4dccb8e 100644
--- a/server/types/models/video/video-streaming-playlist.ts
+++ b/server/types/models/video/video-streaming-playlist.ts
@@ -39,5 +39,5 @@ export type MStreamingPlaylistRedundanciesOpt =
   PickWithOpt<VideoStreamingPlaylistModel, 'RedundancyVideos', MVideoRedundancyFileUrl[]>
 
 export function isStreamingPlaylist (value: MVideo | MStreamingPlaylistVideo): value is MStreamingPlaylistVideo {
-  return !!(value as MStreamingPlaylist).playlistUrl
+  return !!(value as MStreamingPlaylist).videoId
 }
diff --git a/server/typings/express/index.d.ts b/server/typings/express/index.d.ts
index 1a8dc3430..1a99b598a 100644
--- a/server/typings/express/index.d.ts
+++ b/server/typings/express/index.d.ts
@@ -1,4 +1,5 @@
 
+import { OutgoingHttpHeaders } from 'http'
 import { RegisterServerAuthExternalOptions } from '@server/types'
 import {
   MAbuseMessage,
@@ -22,8 +23,7 @@ import { MPlugin, MServer, MServerBlocklist } from '@server/types/models/server'
 import { MVideoImportDefault } from '@server/types/models/video/video-import'
 import { MVideoPlaylistElement, MVideoPlaylistElementVideoUrlPlaylistPrivacy } from '@server/types/models/video/video-playlist-element'
 import { MAccountVideoRateAccountVideo } from '@server/types/models/video/video-rate'
-import { HttpMethod } from '@shared/core-utils/miscs/http-methods'
-import { PeerTubeProblemDocumentData, ServerErrorCode, VideoCreate } from '@shared/models'
+import { HttpMethod, PeerTubeProblemDocumentData, ServerErrorCode, VideoCreate } from '@shared/models'
 import { File as UploadXFile, Metadata } from '@uploadx/core'
 import { RegisteredPlugin } from '../../lib/plugins/plugin-manager'
 import {
@@ -41,6 +41,7 @@ import {
   MVideoShareActor,
   MVideoThumbnail
 } from '../../types/models'
+import { Writable } from 'stream'
 
 declare module 'express' {
   export interface Request {
@@ -99,6 +100,15 @@ declare module 'express' {
     }) => void
 
     locals: {
+      apicache: {
+        content: string | Buffer
+        write: Writable['write']
+        writeHead: Response['writeHead']
+        end: Response['end']
+        cacheable: boolean
+        headers: OutgoingHttpHeaders
+      }
+
       docUrl?: string
 
       videoAPI?: MVideoFormattableDetails