14 files changed, 143 insertions, 232 deletions

diff --git a/server/tests/api/check-params/users.ts b/server/tests/api/check-params/users.ts
index da0f55bf8..88fc8e8b1 100644
--- a/server/tests/api/check-params/users.ts
+++ b/server/tests/api/check-params/users.ts
@@ -5,7 +5,6 @@ import { omit } from 'lodash'
 import { User, UserRole, VideoCreateResult } from '../../../../shared'
 import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoChannel,
   blockUser,
   buildAbsoluteFixturePath,
   cleanupTests,
@@ -1041,8 +1040,8 @@ describe('Test users API validators', function () {
     })
 
     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.channelsCommand.create({ attributes })
 
       const fields = immutableAssign(baseCorrectParams, { channel: { name: 'existing_channel', displayName: 'toto' } })
 
diff --git a/server/tests/api/check-params/video-channels.ts b/server/tests/api/check-params/video-channels.ts
index 5c02afd31..d29346dc3 100644
--- a/server/tests/api/check-params/video-channels.ts
+++ b/server/tests/api/check-params/video-channels.ts
@@ -6,11 +6,10 @@ import { omit } from 'lodash'
 import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   buildAbsoluteFixturePath,
+  ChannelsCommand,
   cleanupTests,
   createUser,
-  deleteVideoChannel,
   flushAndRunServer,
-  getAccountVideoChannelsList,
   immutableAssign,
   makeGetRequest,
   makePostBodyRequest,
@@ -33,6 +32,7 @@ describe('Test video channels API validator', function () {
   const videoChannelPath = '/api/v1/video-channels'
   let server: ServerInfo
   let accessTokenUser: string
+  let command: ChannelsCommand
 
   // ---------------------------------------------------------------
 
@@ -52,6 +52,8 @@ 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)
     }
+
+    command = server.channelsCommand
   })
 
   describe('When listing a video channels', function () {
@@ -84,7 +86,7 @@ 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.channelsCommand.listByAccount({ accountName: 'unknown', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should succeed with the correct parameters', async function () {
@@ -327,23 +329,23 @@ describe('Test video channels API validator', function () {
 
   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/notifications/user-notifications.ts b/server/tests/api/notifications/user-notifications.ts
index a9315c818..1d159c48f 100644
--- a/server/tests/api/notifications/user-notifications.ts
+++ b/server/tests/api/notifications/user-notifications.ts
@@ -17,7 +17,6 @@ import {
   ServerInfo,
   updateMyUser,
   updateVideo,
-  updateVideoChannel,
   uploadRandomVideoOnServers,
   wait,
   waitJobs
@@ -404,7 +403,11 @@ describe('Test user notifications', function () {
         displayName: 'super root 2 name'
       })
 
-      await updateVideoChannel(servers[0].url, userAccessToken, 'user_1_channel', { displayName: myChannelName })
+      await servers[0].channelsCommand.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 () {
diff --git a/server/tests/api/redundancy/redundancy-constraints.ts b/server/tests/api/redundancy/redundancy-constraints.ts
index a666976b3..500b96747 100644
--- a/server/tests/api/redundancy/redundancy-constraints.ts
+++ b/server/tests/api/redundancy/redundancy-constraints.ts
@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
+import { expect } from 'chai'
 import {
   cleanupTests,
   flushAndRunServer,
@@ -15,8 +16,6 @@ import {
 } from '@shared/extra-utils'
 import { VideoPrivacy } from '@shared/models'
 
-const expect = chai.expect
-
 describe('Test redundancy constraints', function () {
   let remoteServer: ServerInfo
   let localServer: ServerInfo
diff --git a/server/tests/api/search/search-activitypub-video-channels.ts b/server/tests/api/search/search-activitypub-video-channels.ts
index cf5158b66..83be9cd1e 100644
--- a/server/tests/api/search/search-activitypub-video-channels.ts
+++ b/server/tests/api/search/search-activitypub-video-channels.ts
@@ -3,19 +3,15 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  addVideoChannel,
   cleanupTests,
   createUser,
-  deleteVideoChannel,
   flushAndRunMultipleServers,
-  getVideoChannelsList,
   getVideoChannelVideos,
   SearchCommand,
   ServerInfo,
   setAccessTokensToServers,
   updateMyUser,
   updateVideo,
-  updateVideoChannel,
   uploadVideo,
   userLogin,
   wait,
@@ -45,7 +41,7 @@ describe('Test ActivityPub video channels search', function () {
         name: 'channel1_server1',
         displayName: 'Channel 1 server 1'
       }
-      await addVideoChannel(servers[0].url, servers[0].accessToken, channel)
+      await servers[0].channelsCommand.create({ attributes: channel })
     }
 
     {
@@ -57,8 +53,8 @@ describe('Test ActivityPub video channels search', function () {
         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].channelsCommand.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
@@ -143,12 +139,12 @@ describe('Test ActivityPub video channels search', function () {
   })
 
   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].channelsCommand.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 () {
@@ -171,7 +167,11 @@ describe('Test ActivityPub video channels search', function () {
   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 servers[1].channelsCommand.update({
+      token: userServer2Token,
+      channelName: 'channel1_server2',
+      attributes: { displayName: 'channel updated' }
+    })
     await updateMyUser({ url: servers[1].url, accessToken: userServer2Token, displayName: 'user updated' })
 
     await waitJobs(servers)
@@ -217,7 +217,7 @@ describe('Test ActivityPub video channels search', function () {
   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].channelsCommand.delete({ token: userServer2Token, channelName: 'channel1_server2' })
 
     await waitJobs(servers)
     // Expire video
diff --git a/server/tests/api/search/search-activitypub-videos.ts b/server/tests/api/search/search-activitypub-videos.ts
index 7c6455258..403c84010 100644
--- a/server/tests/api/search/search-activitypub-videos.ts
+++ b/server/tests/api/search/search-activitypub-videos.ts
@@ -3,7 +3,6 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  addVideoChannel,
   cleanupTests,
   flushAndRunMultipleServers,
   getVideosList,
@@ -123,8 +122,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].channelsCommand.create({ attributes: channelAttributes })
+    const videoChannelId = created.id
 
     const attributes = {
       name: 'updated',
diff --git a/server/tests/api/search/search-channels.ts b/server/tests/api/search/search-channels.ts
index 307bc063d..6c9ee73ce 100644
--- a/server/tests/api/search/search-channels.ts
+++ b/server/tests/api/search/search-channels.ts
@@ -2,15 +2,7 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import {
-  addVideoChannel,
-  cleanupTests,
-  createUser,
-  flushAndRunServer,
-  SearchCommand,
-  ServerInfo,
-  setAccessTokensToServers
-} from '@shared/extra-utils'
+import { cleanupTests, createUser, flushAndRunServer, SearchCommand, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
 import { VideoChannel } from '@shared/models'
 
 const expect = chai.expect
@@ -32,7 +24,7 @@ describe('Test channels search', function () {
         name: 'squall_channel',
         displayName: 'Squall channel'
       }
-      await addVideoChannel(server.url, server.accessToken, channel)
+      await server.channelsCommand.create({ attributes: channel })
     }
 
     command = server.searchCommand
diff --git a/server/tests/api/server/plugins.ts b/server/tests/api/server/plugins.ts
index 528bbbe58..e22ecfad9 100644
--- a/server/tests/api/server/plugins.ts
+++ b/server/tests/api/server/plugins.ts
@@ -37,6 +37,8 @@ describe('Test plugins', function () {
     }
     server = await flushAndRunServer(1, configOverride)
     await setAccessTokensToServers([ server ])
+
+    command = server.pluginsCommand
   })
 
   it('Should list and search available plugins and themes', async function () {
diff --git a/server/tests/api/server/stats.ts b/server/tests/api/server/stats.ts
index c877a65eb..9c954c347 100644
--- a/server/tests/api/server/stats.ts
+++ b/server/tests/api/server/stats.ts
@@ -3,7 +3,6 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
-  addVideoChannel,
   addVideoCommentThread,
   cleanupTests,
   createUser,
@@ -143,12 +142,12 @@ describe('Test stats (excluding redundancy)', function () {
     }
 
     {
-      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.channelsCommand.create({ attributes })
+      channelId = created.id
 
       const data = await server.statsCommand.get()
 
diff --git a/server/tests/api/users/users-multiple-servers.ts b/server/tests/api/users/users-multiple-servers.ts
index 03fbfabeb..47056be78 100644
--- a/server/tests/api/users/users-multiple-servers.ts
+++ b/server/tests/api/users/users-multiple-servers.ts
@@ -12,7 +12,6 @@ import {
   flushAndRunMultipleServers,
   getAccountVideos,
   getMyUserInformation,
-  getVideoChannelsList,
   removeUser,
   ServerInfo,
   setAccessTokensToServers,
@@ -23,7 +22,7 @@ import {
   userLogin,
   waitJobs
 } from '@shared/extra-utils'
-import { User, VideoChannel } from '@shared/models'
+import { User } from '@shared/models'
 
 const expect = chai.expect
 
@@ -199,10 +198,8 @@ describe('Test users with multiple servers', function () {
       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.channelsCommand.list()
+      const videoChannelDeleted = data.find(a => a.displayName === 'Main user1 channel' && a.host === 'localhost:' + servers[0].port)
       expect(videoChannelDeleted).not.to.be.undefined
     }
 
@@ -216,10 +213,8 @@ describe('Test users with multiple servers', function () {
       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.channelsCommand.list()
+      const videoChannelDeleted = data.find(a => a.name === 'Main user1 channel' && a.host === 'localhost:' + servers[0].port)
       expect(videoChannelDeleted).to.be.undefined
     }
   })
diff --git a/server/tests/api/users/users.ts b/server/tests/api/users/users.ts
index 4b9056306..ed670b3c9 100644
--- a/server/tests/api/users/users.ts
+++ b/server/tests/api/users/users.ts
@@ -18,7 +18,6 @@ import {
   getUserInformation,
   getUsersList,
   getUsersListPaginationAndSort,
-  getVideoChannel,
   getVideosList,
   killallServers,
   login,
@@ -864,9 +863,9 @@ describe('Test users', function () {
     })
 
     it('Should have created the channel', async function () {
-      const res = await getVideoChannel(server.url, 'my_user_15_channel')
+      const { displayName } = await server.channelsCommand.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 () {
diff --git a/server/tests/api/videos/multiple-servers.ts b/server/tests/api/videos/multiple-servers.ts
index a8c8a889b..a59d5a858 100644
--- a/server/tests/api/videos/multiple-servers.ts
+++ b/server/tests/api/videos/multiple-servers.ts
@@ -5,7 +5,6 @@ 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,
@@ -17,7 +16,6 @@ import {
   flushAndRunMultipleServers,
   getLocalVideos,
   getVideo,
-  getVideoChannelsList,
   getVideosList,
   rateVideo,
   removeVideo,
@@ -64,9 +62,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].channelsCommand.create({ attributes: videoChannel })
+      const { data } = await servers[0].channelsCommand.list({ start: 0, count: 1 })
+      videoChannelId = data[0].id
     }
 
     // Server 1 and server 2 follow each other
diff --git a/server/tests/api/videos/video-channels.ts b/server/tests/api/videos/video-channels.ts
index 865098777..daf066eb1 100644
--- a/server/tests/api/videos/video-channels.ts
+++ b/server/tests/api/videos/video-channels.ts
@@ -7,43 +7,29 @@ import { ACTOR_IMAGES_SIZE } from '@server/initializers/constants'
 import {
   cleanupTests,
   createUser,
-  deleteVideoChannelImage,
   doubleFollow,
   flushAndRunMultipleServers,
   getActorImage,
   getVideo,
-  getVideoChannel,
   getVideoChannelVideos,
   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 { getMyUserInformation, ServerInfo, setAccessTokensToServers, viewVideo } from '../../../../shared/extra-utils/index'
 import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import { User, Video, VideoChannel, VideoDetails } from '../../../../shared/index'
 
 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)
+  const body = await server.channelsCommand.list({ sort: '-name' })
 
-  return videoChannel as VideoChannel
+  return body.data.find(c => c.id === channelId)
 }
 
 describe('Test video channels', function () {
@@ -69,11 +55,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].channelsCommand.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,8 +72,8 @@ 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].channelsCommand.create({ attributes: videoChannel })
+      secondVideoChannelId = created.id
     }
 
     // The channel is 1 is propagated to servers 2
@@ -120,16 +106,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].channelsCommand.listByAccount({ accountName })
+    expect(body.total).to.equal(2)
 
-    expect(res.body.total).to.equal(2)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data).to.have.lengthOf(2)
+    const videoChannels = body.data
+
+    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 +125,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].channelsCommand.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].channelsCommand.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].channelsCommand.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].channelsCommand.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].channelsCommand.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,22 +199,23 @@ describe('Test video channels', function () {
       support: 'support updated'
     }
 
-    await updateVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel', videoChannelAttributes)
+    await servers[0].channelsCommand.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.channelsCommand.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')
     }
   })
 
@@ -261,7 +236,7 @@ describe('Test video channels', function () {
       bulkVideosSupportUpdate: true
     }
 
-    await updateVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel', videoChannelAttributes)
+    await servers[0].channelsCommand.update({ channelName: 'second_video_channel', attributes: videoChannelAttributes })
 
     await waitJobs(servers)
 
@@ -278,10 +253,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].channelsCommand.updateImage({
+      channelName: 'second_video_channel',
       fixture,
       type: 'avatar'
     })
@@ -306,10 +279,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].channelsCommand.updateImage({
+      channelName: 'second_video_channel',
       fixture,
       type: 'banner'
     })
@@ -317,8 +288,7 @@ 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.channelsCommand.get({ channelName: 'second_video_channel@' + servers[0].host })
 
       bannerPaths[server.port] = videoChannel.banner.path
       await testImage(server.url, 'banner-resized', bannerPaths[server.port])
@@ -333,12 +303,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].channelsCommand.deleteImage({ channelName: 'second_video_channel', type: 'avatar' })
 
     await waitJobs(servers)
 
@@ -353,12 +318,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].channelsCommand.deleteImage({ channelName: 'second_video_channel', type: 'banner' })
 
     await waitJobs(servers)
 
@@ -411,23 +371,23 @@ describe('Test video channels', function () {
   })
 
   it('Should delete video channel', async function () {
-    await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel')
+    await servers[0].channelsCommand.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].channelsCommand.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].channelsCommand.create({ attributes: videoChannel })
+      totoChannel = created.id
     }
 
     {
@@ -444,15 +404,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].channelsCommand.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
 
@@ -471,26 +425,17 @@ describe('Test video channels', function () {
       // 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].channelsCommand.listByAccount({ accountName, withStats: true })
+      const channelWithView = data.find(channel => channel.id === servers[0].videoChannel.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].channelsCommand.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 +443,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].channelsCommand.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].channelsCommand.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)
     }
   })
@@ -529,30 +466,20 @@ describe('Test video channels', function () {
     await waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getAccountVideoChannelsList({
-        url: server.url,
-        accountName,
-        sort: '-updatedAt'
-      })
+      const { data } = await server.channelsCommand.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 waitJobs(servers)
 
     for (const server of servers) {
-      const res = await getAccountVideoChannelsList({
-        url: server.url,
-        accountName,
-        sort: '-updatedAt'
-      })
+      const { data } = await server.channelsCommand.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-playlists.ts b/server/tests/api/videos/video-playlists.ts
index 4de6b3abf..2bb019348 100644
--- a/server/tests/api/videos/video-playlists.ts
+++ b/server/tests/api/videos/video-playlists.ts
@@ -4,11 +4,9 @@ import 'mocha'
 import * as chai from 'chai'
 import { HttpStatusCode } from '@shared/core-utils'
 import {
-  addVideoChannel,
   checkPlaylistFilesWereRemoved,
   cleanupTests,
   createUser,
-  deleteVideoChannel,
   doubleFollow,
   flushAndRunMultipleServers,
   generateUserAccessToken,
@@ -1096,20 +1094,19 @@ describe('Test video playlists', function () {
     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].channelsCommand.create({ attributes: { name: 'super_channel', displayName: 'super channel' } })
 
       const playlistCreated = await commands[0].create({
         attributes: {
           displayName: 'channel playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId
+          videoChannelId: channel.id
         }
       })
 
       await waitJobs(servers)
 
-      await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'super_channel')
+      await servers[0].channelsCommand.delete({ channelName: 'super_channel' })
 
       await waitJobs(servers)