X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Ftests%2Fapi%2Fcheck-params%2Fvideo-playlists.ts;h=ae5aa287fb9ac978fa496aa7a55add6e69b16340;hb=592c735c19b25e9b38f82d90d15a81307902ed62;hp=68fe362e9c3d55c8e696a07be8901ce82153a74f;hpb=07b1a18aa678d260009a93e36606c5c5f585723d;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/tests/api/check-params/video-playlists.ts b/server/tests/api/check-params/video-playlists.ts
index 68fe362e9..ae5aa287f 100644
--- a/server/tests/api/check-params/video-playlists.ts
+++ b/server/tests/api/check-params/video-playlists.ts
@@ -2,59 +2,73 @@
 
 import 'mocha'
 import {
-  createUser,
+  addVideoInPlaylist,
+  cleanupTests,
   createVideoPlaylist,
   deleteVideoPlaylist,
-  flushTests,
+  flushAndRunServer,
+  generateUserAccessToken,
+  getAccountPlaylistsListWithToken,
   getVideoPlaylist,
   immutableAssign,
-  killallServers,
   makeGetRequest,
-  runServer,
+  removeVideoFromPlaylist,
+  reorderVideosPlaylist,
   ServerInfo,
   setAccessTokensToServers,
+  setDefaultVideoChannel,
   updateVideoPlaylist,
-  userLogin,
-  addVideoInPlaylist, uploadVideo, updateVideoPlaylistElement, removeVideoFromPlaylist, reorderVideosPlaylist
-} from '../../../../shared/utils'
+  updateVideoPlaylistElement,
+  uploadVideoAndGetId
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
+} from '../../../../shared/extra-utils/requests/check-api-params'
 import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
 
 describe('Test video playlists API validator', function () {
   let server: ServerInfo
-  let userAccessToken = ''
+  let userAccessToken: string
   let playlistUUID: string
+  let privatePlaylistUUID: string
+  let watchLaterPlaylistId: number
   let videoId: number
   let videoId2: number
+  let playlistElementId: number
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
+    await setDefaultVideoChannel([ server ])
 
-    const username = 'user1'
-    const password = 'my super password'
-    await createUser(server.url, server.accessToken, username, password)
-    userAccessToken = await userLogin(server, { username, password })
+    userAccessToken = await generateUserAccessToken(server, 'user1')
+    videoId = (await uploadVideoAndGetId({ server, videoName: 'video 1' })).id
+    videoId2 = (await uploadVideoAndGetId({ server, videoName: 'video 2' })).id
 
     {
-      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 1' })
-      videoId = res.body.video.id
+      const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root',0, 5, VideoPlaylistType.WATCH_LATER)
+      watchLaterPlaylistId = res.body.data[0].id
     }
 
     {
-      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
-      videoId2 = res.body.video.id
+      const res = await createVideoPlaylist({
+        url: server.url,
+        token: server.accessToken,
+        playlistAttrs: {
+          displayName: 'super playlist',
+          privacy: VideoPlaylistPrivacy.PUBLIC,
+          videoChannelId: server.videoChannel.id
+        }
+      })
+      playlistUUID = res.body.videoPlaylist.uuid
     }
 
     {
@@ -62,11 +76,11 @@ describe('Test video playlists API validator', function () {
         url: server.url,
         token: server.accessToken,
         playlistAttrs: {
-          displayName: 'super playlist',
-          privacy: VideoPlaylistPrivacy.PUBLIC
+          displayName: 'private',
+          privacy: VideoPlaylistPrivacy.PRIVATE
         }
       })
-      playlistUUID = res.body.videoPlaylist.uuid
+      privatePlaylistUUID = res.body.videoPlaylist.uuid
     }
   })
 
@@ -93,6 +107,12 @@ describe('Test video playlists API validator', function () {
       await checkBadSortPagination(server.url, videoChannelPath, server.accessToken)
     })
 
+    it('Should fail with a bad playlist type', async function () {
+      await makeGetRequest({ url: server.url, path: globalPath, query: { playlistType: 3 } })
+      await makeGetRequest({ url: server.url, path: accountPath, query: { playlistType: 3 } })
+      await makeGetRequest({ url: server.url, path: videoChannelPath, query: { playlistType: 3 } })
+    })
+
     it('Should fail with a bad account parameter', async function () {
       const accountPath = '/api/v1/accounts/root2/video-playlists'
 
@@ -113,18 +133,18 @@ describe('Test video playlists API validator', function () {
   })
 
   describe('When listing videos of a playlist', function () {
-    const path = '/api/v1/video-playlists'
+    const path = '/api/v1/video-playlists/'
 
     it('Should fail with a bad start pagination', async function () {
-      await checkBadStartPagination(server.url, path, server.accessToken)
+      await checkBadStartPagination(server.url, path + playlistUUID + '/videos', server.accessToken)
     })
 
     it('Should fail with a bad count pagination', async function () {
-      await checkBadCountPagination(server.url, path, server.accessToken)
+      await checkBadCountPagination(server.url, path + playlistUUID + '/videos', server.accessToken)
     })
 
-    it('Should fail with a bad filter', async function () {
-      await checkBadSortPagination(server.url, path, server.accessToken)
+    it('Should success with the correct parameters', async function () {
+      await makeGetRequest({ url: server.url, path: path + playlistUUID + '/videos', statusCodeExpected: 200 })
     })
   })
 
@@ -158,410 +178,252 @@ describe('Test video playlists API validator', function () {
   })
 
   describe('When creating/updating a video playlist', function () {
+    const getBase = (playlistAttrs: any = {}, wrapper: any = {}) => {
+      return Object.assign({
+        expectedStatus: 400,
+        url: server.url,
+        token: server.accessToken,
+        playlistAttrs: Object.assign({
+          displayName: 'display name',
+          privacy: VideoPlaylistPrivacy.UNLISTED,
+          thumbnailfile: 'thumbnail.jpg',
+          videoChannelId: server.videoChannel.id
+        }, playlistAttrs)
+      }, wrapper)
+    }
+    const getUpdate = (params: any, playlistId: number | string) => {
+      return immutableAssign(params, { playlistId: playlistId })
+    }
 
     it('Should fail with an unauthenticated user', async function () {
-      const baseParams = {
-        url: server.url,
-        token: null,
-        playlistAttrs: {
-          displayName: 'super playlist',
-          privacy: VideoPlaylistPrivacy.PUBLIC
-        },
-        expectedStatus: 401
-      }
+      const params = getBase({}, { token: null, expectedStatus: 401 })
 
-      await createVideoPlaylist(baseParams)
-      await updateVideoPlaylist(immutableAssign(baseParams, { playlistId: playlistUUID }))
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
     })
 
     it('Should fail without displayName', async function () {
-      const baseParams = {
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
-          privacy: VideoPlaylistPrivacy.PUBLIC
-        } as any,
-        expectedStatus: 400
-      }
+      const params = getBase({ displayName: undefined })
 
-      await createVideoPlaylist(baseParams)
-      await updateVideoPlaylist(immutableAssign(baseParams, { playlistId: playlistUUID }))
+      await createVideoPlaylist(params)
     })
 
     it('Should fail with an incorrect display name', async function () {
-      const baseParams = {
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
-          displayName: 's'.repeat(300),
-          privacy: VideoPlaylistPrivacy.PUBLIC
-        },
-        expectedStatus: 400
-      }
+      const params = getBase({ displayName: 's'.repeat(300) })
 
-      await createVideoPlaylist(baseParams)
-      await updateVideoPlaylist(immutableAssign(baseParams, { playlistId: playlistUUID }))
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
     })
 
     it('Should fail with an incorrect description', async function () {
-      const baseParams = {
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
-          displayName: 'display name',
-          privacy: VideoPlaylistPrivacy.PUBLIC,
-          description: 't'
-        },
-        expectedStatus: 400
-      }
+      const params = getBase({ description: 't' })
 
-      await createVideoPlaylist(baseParams)
-      await updateVideoPlaylist(immutableAssign(baseParams, { playlistId: playlistUUID }))
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
     })
 
     it('Should fail with an incorrect privacy', async function () {
-      const baseParams = {
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
-          displayName: 'display name',
-          privacy: 45
-        } as any,
-        expectedStatus: 400
-      }
+      const params = getBase({ privacy: 45 })
 
-      await createVideoPlaylist(baseParams)
-      await updateVideoPlaylist(immutableAssign(baseParams, { playlistId: playlistUUID }))
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
     })
 
     it('Should fail with an unknown video channel id', async function () {
-      const baseParams = {
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
-          displayName: 'display name',
-          privacy: VideoPlaylistPrivacy.PUBLIC,
-          videoChannelId: 42
-        },
-        expectedStatus: 404
-      }
+      const params = getBase({ videoChannelId: 42 }, { expectedStatus: 404 })
 
-      await createVideoPlaylist(baseParams)
-      await updateVideoPlaylist(immutableAssign(baseParams, { playlistId: playlistUUID }))
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
     })
 
     it('Should fail with an incorrect thumbnail file', async function () {
-      const baseParams = {
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
-          displayName: 'display name',
-          privacy: VideoPlaylistPrivacy.PUBLIC,
-          thumbnailfile: 'avatar.png'
-        },
-        expectedStatus: 400
-      }
+      const params = getBase({ thumbnailfile: 'avatar.png' })
+
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
+    })
+
+    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' })
 
-      await createVideoPlaylist(baseParams)
-      await updateVideoPlaylist(immutableAssign(baseParams, { playlistId: playlistUUID }))
+      await createVideoPlaylist(params)
+      await createVideoPlaylist(params2)
+      await updateVideoPlaylist(getUpdate(params, privatePlaylistUUID))
+      await updateVideoPlaylist(getUpdate(params2, playlistUUID))
+      await updateVideoPlaylist(getUpdate(params3, playlistUUID))
     })
 
     it('Should fail with an unknown playlist to update', async function () {
-      await updateVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: 42,
-        playlistAttrs: {
-          displayName: 'display name',
-          privacy: VideoPlaylistPrivacy.PUBLIC
-        },
-        expectedStatus: 404
-      })
+      await updateVideoPlaylist(getUpdate(
+        getBase({}, { expectedStatus: 404 }),
+        42
+      ))
     })
 
     it('Should fail to update a playlist of another user', async function () {
-      await updateVideoPlaylist({
-        url: server.url,
-        token: userAccessToken,
-        playlistId: playlistUUID,
-        playlistAttrs: {
-          displayName: 'display name',
-          privacy: VideoPlaylistPrivacy.PUBLIC
-        },
-        expectedStatus: 403
-      })
+      await updateVideoPlaylist(getUpdate(
+        getBase({}, { token: userAccessToken, expectedStatus: 403 }),
+        playlistUUID
+      ))
     })
 
-    it('Should fail to update to private a public/unlisted playlist', async function () {
-      const res = await createVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
-          displayName: 'super playlist',
-          privacy: VideoPlaylistPrivacy.PUBLIC
-        }
-      })
-      const playlist = res.body.videoPlaylist
-
-      await updateVideoPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlist.id,
-        playlistAttrs: {
-          displayName: 'display name',
-          privacy: VideoPlaylistPrivacy.PRIVATE
-        },
-        expectedStatus: 409
-      })
+    it('Should fail to update the watch later playlist', async function () {
+      await updateVideoPlaylist(getUpdate(
+        getBase({}, { expectedStatus: 400 }),
+        watchLaterPlaylistId
+      ))
     })
 
     it('Should succeed with the correct params', async function () {
-      const baseParams = {
-        url: server.url,
-        token: server.accessToken,
-        playlistAttrs: {
-          displayName: 'display name',
-          privacy: VideoPlaylistPrivacy.UNLISTED,
-          thumbnailfile: 'thumbnail.jpg'
-        }
+      {
+        const params = getBase({}, { expectedStatus: 200 })
+        await createVideoPlaylist(params)
       }
 
-      await createVideoPlaylist(baseParams)
-      await updateVideoPlaylist(immutableAssign(baseParams, { playlistId: playlistUUID }))
+      {
+        const params = getBase({}, { expectedStatus: 204 })
+        await updateVideoPlaylist(getUpdate(params, playlistUUID))
+      }
     })
   })
 
   describe('When adding an element in a playlist', function () {
-    it('Should fail with an unauthenticated user', async function () {
-      await addVideoInPlaylist({
+    const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
+      return Object.assign({
+        expectedStatus: 400,
         url: server.url,
-        token: null,
-        elementAttrs: {
-          videoId: videoId
-        },
+        token: server.accessToken,
         playlistId: playlistUUID,
-        expectedStatus: 401
-      })
+        elementAttrs: Object.assign({
+          videoId,
+          startTimestamp: 2,
+          stopTimestamp: 3
+        }, elementAttrs)
+      }, wrapper)
+    }
+
+    it('Should fail with an unauthenticated user', async function () {
+      const params = getBase({}, { token: null, expectedStatus: 401 })
+      await addVideoInPlaylist(params)
     })
 
     it('Should fail with the playlist of another user', async function () {
-      await addVideoInPlaylist({
-        url: server.url,
-        token: userAccessToken,
-        elementAttrs: {
-          videoId: videoId
-        },
-        playlistId: playlistUUID,
-        expectedStatus: 403
-      })
+      const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
+      await addVideoInPlaylist(params)
     })
 
     it('Should fail with an unknown or incorrect playlist id', async function () {
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          videoId: videoId
-        },
-        playlistId: 'toto',
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({}, { playlistId: 'toto' })
+        await addVideoInPlaylist(params)
+      }
 
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          videoId: videoId
-        },
-        playlistId: 42,
-        expectedStatus: 404
-      })
+      {
+        const params = getBase({}, { playlistId: 42, expectedStatus: 404 })
+        await addVideoInPlaylist(params)
+      }
     })
 
     it('Should fail with an unknown or incorrect video id', async function () {
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          videoId: 'toto' as any
-        },
-        playlistId: playlistUUID,
-        expectedStatus: 400
-      })
-
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          videoId: 42
-        },
-        playlistId: playlistUUID,
-        expectedStatus: 404
-      })
+      const params = getBase({ videoId: 42 }, { expectedStatus: 404 })
+      await addVideoInPlaylist(params)
     })
 
     it('Should fail with a bad start/stop timestamp', async function () {
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          videoId: videoId,
-          startTimestamp: -42
-        },
-        playlistId: playlistUUID,
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ startTimestamp: -42 })
+        await addVideoInPlaylist(params)
+      }
 
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          videoId: videoId,
-          stopTimestamp: 'toto' as any
-        },
-        playlistId: playlistUUID,
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ stopTimestamp: 'toto' as any })
+        await addVideoInPlaylist(params)
+      }
     })
 
     it('Succeed with the correct params', async function () {
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          videoId: videoId,
-          stopTimestamp: 3
-        },
-        playlistId: playlistUUID,
-        expectedStatus: 200
-      })
+      const params = getBase({}, { expectedStatus: 200 })
+      const res = await addVideoInPlaylist(params)
+      playlistElementId = res.body.videoPlaylistElement.id
     })
 
     it('Should fail if the video was already added in the playlist', async function () {
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          videoId: videoId,
-          stopTimestamp: 3
-        },
-        playlistId: playlistUUID,
-        expectedStatus: 409
-      })
+      const params = getBase({}, { expectedStatus: 409 })
+      await addVideoInPlaylist(params)
     })
   })
 
   describe('When updating an element in a playlist', function () {
-    it('Should fail with an unauthenticated user', async function () {
-      await updateVideoPlaylistElement({
+    const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
+      return Object.assign({
         url: server.url,
-        token: null,
-        elementAttrs: { },
-        videoId: videoId,
+        token: server.accessToken,
+        elementAttrs: Object.assign({
+          startTimestamp: 1,
+          stopTimestamp: 2
+        }, elementAttrs),
+        playlistElementId,
         playlistId: playlistUUID,
-        expectedStatus: 401
-      })
+        expectedStatus: 400
+      }, wrapper)
+    }
+
+    it('Should fail with an unauthenticated user', async function () {
+      const params = getBase({}, { token: null, expectedStatus: 401 })
+      await updateVideoPlaylistElement(params)
     })
 
     it('Should fail with the playlist of another user', async function () {
-      await updateVideoPlaylistElement({
-        url: server.url,
-        token: userAccessToken,
-        elementAttrs: { },
-        videoId: videoId,
-        playlistId: playlistUUID,
-        expectedStatus: 403
-      })
+      const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
+      await updateVideoPlaylistElement(params)
     })
 
     it('Should fail with an unknown or incorrect playlist id', async function () {
-      await updateVideoPlaylistElement({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: { },
-        videoId: videoId,
-        playlistId: 'toto',
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({}, { playlistId: 'toto' })
+        await updateVideoPlaylistElement(params)
+      }
 
-      await updateVideoPlaylistElement({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: { },
-        videoId: videoId,
-        playlistId: 42,
-        expectedStatus: 404
-      })
+      {
+        const params = getBase({}, { playlistId: 42, expectedStatus: 404 })
+        await updateVideoPlaylistElement(params)
+      }
     })
 
-    it('Should fail with an unknown or incorrect video id', async function () {
-      await updateVideoPlaylistElement({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: { },
-        videoId: 'toto',
-        playlistId: playlistUUID,
-        expectedStatus: 400
-      })
+    it('Should fail with an unknown or incorrect playlistElement id', async function () {
+      {
+        const params = getBase({}, { playlistElementId: 'toto' })
+        await updateVideoPlaylistElement(params)
+      }
 
-      await updateVideoPlaylistElement({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: { },
-        videoId: 42,
-        playlistId: playlistUUID,
-        expectedStatus: 404
-      })
+      {
+        const params = getBase({}, { playlistElementId: 42, expectedStatus: 404 })
+        await updateVideoPlaylistElement(params)
+      }
     })
 
     it('Should fail with a bad start/stop timestamp', async function () {
-      await updateVideoPlaylistElement({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          startTimestamp: 'toto' as any
-        },
-        videoId: videoId,
-        playlistId: playlistUUID,
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ startTimestamp: 'toto' as any })
+        await updateVideoPlaylistElement(params)
+      }
 
-      await updateVideoPlaylistElement({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          stopTimestamp: -42
-        },
-        videoId: videoId,
-        playlistId: playlistUUID,
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ stopTimestamp: -42 })
+        await updateVideoPlaylistElement(params)
+      }
     })
 
     it('Should fail with an unknown element', async function () {
-      await updateVideoPlaylistElement({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          stopTimestamp: 2
-        },
-        videoId: videoId2,
-        playlistId: playlistUUID,
-        expectedStatus: 404
-      })
+      const params = getBase({}, { playlistElementId: 888, expectedStatus: 404 })
+      await updateVideoPlaylistElement(params)
     })
 
     it('Succeed with the correct params', async function () {
-      await updateVideoPlaylistElement({
-        url: server.url,
-        token: server.accessToken,
-        elementAttrs: {
-          stopTimestamp: 2
-        },
-        videoId: videoId,
-        playlistId: playlistUUID,
-        expectedStatus: 204
-      })
+      const params = getBase({}, { expectedStatus: 204 })
+      await updateVideoPlaylistElement(params)
     })
   })
 
@@ -569,280 +431,212 @@ describe('Test video playlists API validator', function () {
     let videoId3: number
     let videoId4: number
 
-    before(async function () {
-      {
-        const res = await uploadVideo(server.url, server.accessToken, { name: 'video 3' })
-        videoId3 = res.body.video.id
-      }
-
-      {
-        const res = await uploadVideo(server.url, server.accessToken, { name: 'video 4' })
-        videoId4 = res.body.video.id
-      }
-
-      await addVideoInPlaylist({
+    const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
+      return Object.assign({
         url: server.url,
         token: server.accessToken,
         playlistId: playlistUUID,
-        elementAttrs: { videoId: videoId3 }
-      })
+        elementAttrs: Object.assign({
+          startPosition: 1,
+          insertAfterPosition: 2,
+          reorderLength: 3
+        }, elementAttrs),
+        expectedStatus: 400
+      }, wrapper)
+    }
 
-      await addVideoInPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: { videoId: videoId4 }
-      })
+    before(async function () {
+      videoId3 = (await uploadVideoAndGetId({ server, videoName: 'video 3' })).id
+      videoId4 = (await uploadVideoAndGetId({ server, videoName: 'video 4' })).id
+
+      for (let id of [ videoId3, videoId4 ]) {
+        await addVideoInPlaylist({
+          url: server.url,
+          token: server.accessToken,
+          playlistId: playlistUUID,
+          elementAttrs: { videoId: id }
+        })
+      }
     })
 
     it('Should fail with an unauthenticated user', async function () {
-      await reorderVideosPlaylist({
-        url: server.url,
-        token: null,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: 2
-        },
-        expectedStatus: 401
-      })
+      const params = getBase({}, { token: null, expectedStatus: 401 })
+      await reorderVideosPlaylist(params)
     })
 
     it('Should fail with the playlist of another user', async function () {
-      await reorderVideosPlaylist({
-        url: server.url,
-        token: userAccessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: 2
-        },
-        expectedStatus: 403
-      })
+      const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
+      await reorderVideosPlaylist(params)
     })
 
     it('Should fail with an invalid playlist', async function () {
-      await reorderVideosPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: 'toto',
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: 2
-        },
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({}, { playlistId: 'toto' })
+        await reorderVideosPlaylist(params)
+      }
 
-      await reorderVideosPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: 42,
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: 2
-        },
-        expectedStatus: 404
-      })
+      {
+        const params = getBase({}, {  playlistId: 42, expectedStatus: 404 })
+        await reorderVideosPlaylist(params)
+      }
     })
 
     it('Should fail with an invalid start position', async function () {
-      await reorderVideosPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: -1,
-          insertAfterPosition: 2
-        },
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ startPosition: -1 })
+        await reorderVideosPlaylist(params)
+      }
 
-      await reorderVideosPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 'toto' as any,
-          insertAfterPosition: 2
-        },
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ startPosition: 'toto' as any })
+        await reorderVideosPlaylist(params)
+      }
 
-      await reorderVideosPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 42,
-          insertAfterPosition: 2
-        },
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ startPosition: 42 })
+        await reorderVideosPlaylist(params)
+      }
     })
 
     it('Should fail with an invalid insert after position', async function () {
-      await reorderVideosPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: 'toto' as any
-        },
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ insertAfterPosition: 'toto' as any })
+        await reorderVideosPlaylist(params)
+      }
 
-      await reorderVideosPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: -2
-        },
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ insertAfterPosition: -2 })
+        await reorderVideosPlaylist(params)
+      }
+
+      {
+        const params = getBase({ insertAfterPosition: 42 })
+        await reorderVideosPlaylist(params)
+      }
+    })
+
+    it('Should fail with an invalid reorder length', async function () {
+      {
+        const params = getBase({ reorderLength: 'toto' as any })
+        await reorderVideosPlaylist(params)
+      }
+
+      {
+        const params = getBase({ reorderLength: -2 })
+        await reorderVideosPlaylist(params)
+      }
+
+      {
+        const params = getBase({ reorderLength: 42 })
+        await reorderVideosPlaylist(params)
+      }
+    })
+
+    it('Succeed with the correct params', async function () {
+      const params = getBase({}, { expectedStatus: 204 })
+      await reorderVideosPlaylist(params)
+    })
+  })
 
-      await reorderVideosPlaylist({
+  describe('When checking exists in playlist endpoint', function () {
+    const path = '/api/v1/users/me/video-playlists/videos-exist'
+
+    it('Should fail with an unauthenticated user', async function () {
+      await makeGetRequest({
         url: server.url,
-        token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: 42
-        },
-        expectedStatus: 400
+        path,
+        query: { videoIds: [ 1, 2 ] },
+        statusCodeExpected: 401
       })
     })
 
-    it('Should fail with an invalid reorder length', async function () {
-      await reorderVideosPlaylist({
+    it('Should fail with invalid video ids', async function () {
+      await makeGetRequest({
         url: server.url,
         token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: 2,
-          reorderLength: 'toto' as any
-        },
-        expectedStatus: 400
+        path,
+        query: { videoIds: 'toto' }
       })
 
-      await reorderVideosPlaylist({
+      await makeGetRequest({
         url: server.url,
         token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: 2,
-          reorderLength: -1
-        },
-        expectedStatus: 400
+        path,
+        query: { videoIds: [ 'toto' ] }
       })
 
-      await reorderVideosPlaylist({
+      await makeGetRequest({
         url: server.url,
         token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: 2,
-          reorderLength: 4
-        },
-        expectedStatus: 400
+        path,
+        query: { videoIds: [ 1, 'toto' ] }
       })
     })
 
-    it('Succeed with the correct params', async function () {
-      await reorderVideosPlaylist({
+    it('Should succeed with the correct params', async function () {
+      await makeGetRequest({
         url: server.url,
         token: server.accessToken,
-        playlistId: playlistUUID,
-        elementAttrs: {
-          startPosition: 1,
-          insertAfterPosition: 2,
-          reorderLength: 3
-        },
-        expectedStatus: 204
+        path,
+        query: { videoIds: [ 1, 2 ] },
+        statusCodeExpected: 200
       })
     })
   })
 
   describe('When deleting an element in a playlist', function () {
-    it('Should fail with an unauthenticated user', async function () {
-      await removeVideoFromPlaylist({
+    const getBase = (wrapper: any = {}) => {
+      return Object.assign({
         url: server.url,
-        token: null,
-        videoId,
+        token: server.accessToken,
+        playlistElementId,
         playlistId: playlistUUID,
-        expectedStatus: 401
-      })
+        expectedStatus: 400
+      }, wrapper)
+    }
+
+    it('Should fail with an unauthenticated user', async function () {
+      const params = getBase({ token: null, expectedStatus: 401 })
+      await removeVideoFromPlaylist(params)
     })
 
     it('Should fail with the playlist of another user', async function () {
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: userAccessToken,
-        videoId,
-        playlistId: playlistUUID,
-        expectedStatus: 403
-      })
+      const params = getBase({ token: userAccessToken, expectedStatus: 403 })
+      await removeVideoFromPlaylist(params)
     })
 
     it('Should fail with an unknown or incorrect playlist id', async function () {
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        videoId,
-        playlistId: 'toto',
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ playlistId: 'toto' })
+        await removeVideoFromPlaylist(params)
+      }
 
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        videoId,
-        playlistId: 42,
-        expectedStatus: 404
-      })
+      {
+        const params = getBase({ playlistId: 42, expectedStatus: 404 })
+        await removeVideoFromPlaylist(params)
+      }
     })
 
     it('Should fail with an unknown or incorrect video id', async function () {
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        videoId: 'toto',
-        playlistId: playlistUUID,
-        expectedStatus: 400
-      })
+      {
+        const params = getBase({ playlistElementId: 'toto' })
+        await removeVideoFromPlaylist(params)
+      }
 
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        videoId: 42,
-        playlistId: playlistUUID,
-        expectedStatus: 404
-      })
+      {
+        const params = getBase({ playlistElementId: 42, expectedStatus: 404 })
+        await removeVideoFromPlaylist(params)
+      }
     })
 
     it('Should fail with an unknown element', async function () {
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        videoId: videoId2,
-        playlistId: playlistUUID,
-        expectedStatus: 404
-      })
+      const params = getBase({ playlistElementId: 888, expectedStatus: 404 })
+      await removeVideoFromPlaylist(params)
     })
 
     it('Succeed with the correct params', async function () {
-      await removeVideoFromPlaylist({
-        url: server.url,
-        token: server.accessToken,
-        videoId: videoId,
-        playlistId: playlistUUID,
-        expectedStatus: 204
-      })
+      const params = getBase({ expectedStatus: 204 })
+      await removeVideoFromPlaylist(params)
     })
   })
 
@@ -855,17 +649,16 @@ describe('Test video playlists API validator', function () {
       await deleteVideoPlaylist(server.url, userAccessToken, playlistUUID, 403)
     })
 
+    it('Should fail with the watch later playlist', async function () {
+      await deleteVideoPlaylist(server.url, server.accessToken, watchLaterPlaylistId, 400)
+    })
+
     it('Should succeed with the correct params', async function () {
       await deleteVideoPlaylist(server.url, server.accessToken, playlistUUID)
     })
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })