Introduce playlist command

2 files changed, 191 insertions, 174 deletions

diff --git a/server/tests/api/check-params/services.ts b/server/tests/api/check-params/services.ts
index 514e3da70..595fab70d 100644
--- a/server/tests/api/check-params/services.ts
+++ b/server/tests/api/check-params/services.ts
@@ -1,19 +1,17 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-
+import { VideoPlaylistPrivacy } from '@shared/models'
+import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   cleanupTests,
   flushAndRunServer,
   makeGetRequest,
   ServerInfo,
   setAccessTokensToServers,
-  uploadVideo,
-  createVideoPlaylist,
-  setDefaultVideoChannel
+  setDefaultVideoChannel,
+  uploadVideo
 } from '../../../../shared/extra-utils'
-import { VideoPlaylistPrivacy } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 
 describe('Test services API validators', function () {
   let server: ServerInfo
@@ -34,17 +32,15 @@ describe('Test services API validators', function () {
     }
 
     {
-      const res = await createVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
+      const created = await server.playlistsCommand.create({
+        attributes: {
           displayName: 'super playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
           videoChannelId: server.videoChannel.id
         }
       })
 
-      playlistUUID = res.body.videoPlaylist.uuid
+      playlistUUID = created.uuid
     }
   })
 
diff --git a/server/tests/api/check-params/video-playlists.ts b/server/tests/api/check-params/video-playlists.ts
index 18253d11a..1c507a047 100644
--- a/server/tests/api/check-params/video-playlists.ts
+++ b/server/tests/api/check-params/video-playlists.ts
@@ -1,29 +1,29 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import 'mocha'
-import { VideoPlaylistCreateResult, VideoPlaylistPrivacy, VideoPlaylistType } from '@shared/models'
+import {
+  VideoPlaylistCreate,
+  VideoPlaylistCreateResult,
+  VideoPlaylistElementCreate,
+  VideoPlaylistElementUpdate,
+  VideoPlaylistPrivacy,
+  VideoPlaylistReorder,
+  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,
   makeGetRequest,
-  removeVideoFromPlaylist,
-  reorderVideosPlaylist,
+  PlaylistsCommand,
   ServerInfo,
   setAccessTokensToServers,
   setDefaultVideoChannel,
-  updateVideoPlaylist,
-  updateVideoPlaylistElement,
   uploadVideoAndGetId
 } from '../../../../shared/extra-utils'
 
@@ -36,7 +36,9 @@ describe('Test video playlists API validator', function () {
 
   let watchLaterPlaylistId: number
   let videoId: number
-  let playlistElementId: number
+  let elementId: number
+
+  let command: PlaylistsCommand
 
   // ---------------------------------------------------------------
 
@@ -51,34 +53,37 @@ describe('Test video playlists API validator', function () {
     userAccessToken = await generateUserAccessToken(server, 'user1')
     videoId = (await uploadVideoAndGetId({ server, videoName: 'video 1' })).id
 
+    command = server.playlistsCommand
+
     {
-      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
         }
       })
-      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
     }
   })
 
@@ -163,47 +168,50 @@ describe('Test video playlists API validator', function () {
 
   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,
           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.videoChannel.id,
+
+          ...attributes
+        },
+
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+
+        ...wrapper
+      }
     }
     const getUpdate = (params: any, playlistId: number | string) => {
       return immutableAssign(params, { playlistId: playlistId })
@@ -212,86 +220,86 @@ describe('Test video playlists API validator', function () {
     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 +308,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,18 +467,24 @@ 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 () {
@@ -466,91 +492,86 @@ describe('Test video playlists API validator', function () {
       videoId4 = (await uploadVideoAndGetId({ server, videoName: '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)
     })
   })
 
@@ -601,76 +622,76 @@ describe('Test video playlists API validator', function () {
   })
 
   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 })
     })
   })