Add playlist rest tests

1 files changed, 672 insertions, 56 deletions

diff --git a/server/tests/api/videos/video-playlists.ts b/server/tests/api/videos/video-playlists.ts
index cb23239da..7dd1563fc 100644
--- a/server/tests/api/videos/video-playlists.ts
+++ b/server/tests/api/videos/video-playlists.ts
@@ -2,152 +2,768 @@
 
 import * as chai from 'chai'
 import 'mocha'
-import { join } from 'path'
-import * as request from 'supertest'
-import { VideoPrivacy } from '../../../../shared/models/videos'
-import { VideoComment, VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
 import {
   addVideoChannel,
-  checkTmpIsEmpty,
-  checkVideoFilesWereRemoved,
-  completeVideoCheck,
+  addVideoInPlaylist,
+  checkPlaylistFilesWereRemoved,
   createUser,
-  dateIsValid,
+  createVideoPlaylist,
+  deleteVideoChannel,
+  deleteVideoPlaylist,
   doubleFollow,
   flushAndRunMultipleServers,
   flushTests,
-  getLocalVideos,
-  getVideo,
-  getVideoChannelsList,
-  getVideosList,
+  getAccountPlaylistsList,
+  getAccountPlaylistsListWithToken,
+  getPlaylistVideos,
+  getVideoChannelPlaylistsList,
+  getVideoPlaylist,
+  getVideoPlaylistsList,
+  getVideoPlaylistWithToken,
   killallServers,
-  rateVideo,
-  removeVideo,
+  removeUser,
+  removeVideoFromPlaylist,
+  reorderVideosPlaylist,
   ServerInfo,
   setAccessTokensToServers,
+  setDefaultVideoChannel,
   testImage,
-  updateVideo,
+  unfollow,
+  updateVideoPlaylist,
+  updateVideoPlaylistElement,
   uploadVideo,
+  uploadVideoAndGetId,
   userLogin,
-  viewVideo,
-  wait,
-  webtorrentAdd
+  waitJobs
 } from '../../../../shared/utils'
-import {
-  addVideoCommentReply,
-  addVideoCommentThread,
-  deleteVideoComment,
-  getVideoCommentThreads,
-  getVideoThreadComments
-} from '../../../../shared/utils/videos/video-comments'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { VideoPlaylist } from '../../../../shared/models/videos/playlist/video-playlist.model'
+import { Video } from '../../../../shared/models/videos'
+import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
 
 const expect = chai.expect
 
 describe('Test video playlists', function () {
   let servers: ServerInfo[] = []
 
+  let playlistServer2Id1: number
+  let playlistServer2Id2: number
+  let playlistServer2UUID2: number
+
+  let playlistServer1Id: number
+  let playlistServer1UUID: string
+
+  let nsfwVideoServer1: number
+
   before(async function () {
     this.timeout(120000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await flushAndRunMultipleServers(3, { transcoding: { enabled: false } })
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
 
     // Server 1 and server 2 follow each other
     await doubleFollow(servers[0], servers[1])
     // Server 1 and server 3 follow each other
     await doubleFollow(servers[0], servers[2])
+
+    {
+      const serverPromises: Promise<any>[][] = []
+
+      for (const server of servers) {
+        const videoPromises: Promise<any>[] = []
+
+        for (let i = 0; i < 7; i++) {
+          videoPromises.push(
+            uploadVideo(server.url, server.accessToken, { name: `video ${i} server ${server.serverNumber}`, nsfw: false })
+              .then(res => res.body.video)
+          )
+        }
+
+        serverPromises.push(videoPromises)
+      }
+
+      servers[0].videos = await Promise.all(serverPromises[0])
+      servers[1].videos = await Promise.all(serverPromises[1])
+      servers[2].videos = await Promise.all(serverPromises[2])
+    }
+
+    nsfwVideoServer1 = (await uploadVideoAndGetId({ server: servers[ 0 ], videoName: 'NSFW video', nsfw: true })).id
+
+    await waitJobs(servers)
   })
 
-  it('Should create a playlist on server 1 and have the playlist on server 2 and 3', async function () {
+  it('Should list watch later playlist', async function () {
+    const url = servers[ 0 ].url
+    const accessToken = servers[ 0 ].accessToken
+
+    {
+      const res = await getAccountPlaylistsListWithToken(url, accessToken, 'root', 0, 5, VideoPlaylistType.WATCH_LATER)
+
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data).to.have.lengthOf(1)
 
+      const playlist: VideoPlaylist = res.body.data[ 0 ]
+      expect(playlist.displayName).to.equal('Watch later')
+      expect(playlist.type.id).to.equal(VideoPlaylistType.WATCH_LATER)
+      expect(playlist.type.label).to.equal('Watch later')
+    }
+
+    {
+      const res = await getAccountPlaylistsListWithToken(url, accessToken, 'root', 0, 5, VideoPlaylistType.REGULAR)
+
+      expect(res.body.total).to.equal(0)
+      expect(res.body.data).to.have.lengthOf(0)
+    }
+
+    {
+      const res = await getAccountPlaylistsList(url, 'root', 0, 5)
+      expect(res.body.total).to.equal(0)
+      expect(res.body.data).to.have.lengthOf(0)
+    }
+  })
+
+  it('Should create a playlist on server 1 and have the playlist on server 2 and 3', async function () {
+    this.timeout(30000)
+
+    await createVideoPlaylist({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistAttrs: {
+        displayName: 'my super playlist',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        description: 'my super description',
+        thumbnailfile: 'thumbnail.jpg',
+        videoChannelId: servers[0].videoChannel.id
+      }
+    })
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getVideoPlaylistsList(server.url, 0, 5)
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data).to.have.lengthOf(1)
+
+      const playlistFromList = res.body.data[0] as VideoPlaylist
+
+      const res2 = await getVideoPlaylist(server.url, playlistFromList.uuid)
+      const playlistFromGet = res2.body
+
+      for (const playlist of [ playlistFromGet, playlistFromList ]) {
+        expect(playlist.id).to.be.a('number')
+        expect(playlist.uuid).to.be.a('string')
+
+        expect(playlist.isLocal).to.equal(server.serverNumber === 1)
+
+        expect(playlist.displayName).to.equal('my super playlist')
+        expect(playlist.description).to.equal('my super description')
+        expect(playlist.privacy.id).to.equal(VideoPlaylistPrivacy.PUBLIC)
+        expect(playlist.privacy.label).to.equal('Public')
+        expect(playlist.type.id).to.equal(VideoPlaylistType.REGULAR)
+        expect(playlist.type.label).to.equal('Regular')
+
+        expect(playlist.videosLength).to.equal(0)
+
+        expect(playlist.ownerAccount.name).to.equal('root')
+        expect(playlist.ownerAccount.displayName).to.equal('root')
+        expect(playlist.videoChannel.name).to.equal('root_channel')
+        expect(playlist.videoChannel.displayName).to.equal('Main root channel')
+      }
+    }
   })
 
   it('Should create a playlist on server 2 and have the playlist on server 1 but not on server 3', async function () {
-    // create 2 playlists (with videos and no videos)
-    // With thumbnail and no thumbnail
+    this.timeout(30000)
+
+    {
+      const res = await createVideoPlaylist({
+        url: servers[1].url,
+        token: servers[1].accessToken,
+        playlistAttrs: {
+          displayName: 'playlist 2',
+          privacy: VideoPlaylistPrivacy.PUBLIC
+        }
+      })
+      playlistServer2Id1 = res.body.videoPlaylist.id
+    }
+
+    {
+      const res = await createVideoPlaylist({
+        url: servers[ 1 ].url,
+        token: servers[ 1 ].accessToken,
+        playlistAttrs: {
+          displayName: 'playlist 3',
+          privacy: VideoPlaylistPrivacy.PUBLIC,
+          thumbnailfile: 'thumbnail.jpg'
+        }
+      })
+
+      playlistServer2Id2 = res.body.videoPlaylist.id
+      playlistServer2UUID2 = res.body.videoPlaylist.uuid
+    }
+
+    for (let id of [ playlistServer2Id1, playlistServer2Id2 ]) {
+      await addVideoInPlaylist({
+        url: servers[ 1 ].url,
+        token: servers[ 1 ].accessToken,
+        playlistId: id,
+        elementAttrs: { videoId: servers[ 1 ].videos[ 0 ].id, startTimestamp: 1, stopTimestamp: 2 }
+      })
+      await addVideoInPlaylist({
+        url: servers[ 1 ].url,
+        token: servers[ 1 ].accessToken,
+        playlistId: id,
+        elementAttrs: { videoId: servers[ 1 ].videos[ 1 ].id }
+      })
+    }
+
+    await waitJobs(servers)
+
+    for (const server of [ servers[0], servers[1] ]) {
+      const res = await getVideoPlaylistsList(server.url, 0, 5)
+
+      const playlist2 = res.body.data.find(p => p.displayName === 'playlist 2')
+      expect(playlist2).to.not.be.undefined
+      await testImage(server.url, 'thumbnail-playlist', playlist2.thumbnailPath)
+
+      const playlist3 = res.body.data.find(p => p.displayName === 'playlist 3')
+      expect(playlist3).to.not.be.undefined
+      await testImage(server.url, 'thumbnail', playlist3.thumbnailPath)
+    }
+
+    const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
+    expect(res.body.data.find(p => p.displayName === 'playlist 2')).to.be.undefined
+    expect(res.body.data.find(p => p.displayName === 'playlist 3')).to.be.undefined
   })
 
   it('Should have the playlist on server 3 after a new follow', async function () {
+    this.timeout(30000)
+
     // Server 2 and server 3 follow each other
     await doubleFollow(servers[1], servers[2])
+
+    const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
+
+    const playlist2 = res.body.data.find(p => p.displayName === 'playlist 2')
+    expect(playlist2).to.not.be.undefined
+    await testImage(servers[2].url, 'thumbnail-playlist', playlist2.thumbnailPath)
+
+    expect(res.body.data.find(p => p.displayName === 'playlist 3')).to.not.be.undefined
   })
 
-  it('Should create some playlists and list them correctly', async function () {
-    // create 3 playlists with some videos in it
-    // check pagination
-    // check sort
-    // check empty
+  it('Should correctly list the playlists', async function () {
+    this.timeout(30000)
+
+    {
+      const res = await getVideoPlaylistsList(servers[ 2 ].url, 1, 2, 'createdAt')
+
+      expect(res.body.total).to.equal(3)
+
+      const data: VideoPlaylist[] = res.body.data
+      expect(data).to.have.lengthOf(2)
+      expect(data[ 0 ].displayName).to.equal('playlist 2')
+      expect(data[ 1 ].displayName).to.equal('playlist 3')
+    }
+
+    {
+      const res = await getVideoPlaylistsList(servers[ 2 ].url, 1, 2, '-createdAt')
+
+      expect(res.body.total).to.equal(3)
+
+      const data: VideoPlaylist[] = res.body.data
+      expect(data).to.have.lengthOf(2)
+      expect(data[ 0 ].displayName).to.equal('playlist 2')
+      expect(data[ 1 ].displayName).to.equal('my super playlist')
+    }
   })
 
   it('Should list video channel playlists', async function () {
-    // check pagination
-    // check sort
-    // check empty
+    this.timeout(30000)
+
+    {
+      const res = await getVideoChannelPlaylistsList(servers[ 0 ].url, 'root_channel', 0, 2, '-createdAt')
+
+      expect(res.body.total).to.equal(1)
+
+      const data: VideoPlaylist[] = res.body.data
+      expect(data).to.have.lengthOf(1)
+      expect(data[ 0 ].displayName).to.equal('my super playlist')
+    }
   })
 
   it('Should list account playlists', async function () {
-    // check pagination
-    // check sort
-    // check empty
+    this.timeout(30000)
+
+    {
+      const res = await getAccountPlaylistsList(servers[ 1 ].url, 'root', 1, 2, '-createdAt')
+
+      expect(res.body.total).to.equal(2)
+
+      const data: VideoPlaylist[] = res.body.data
+      expect(data).to.have.lengthOf(1)
+      expect(data[ 0 ].displayName).to.equal('playlist 2')
+    }
+
+    {
+      const res = await getAccountPlaylistsList(servers[ 1 ].url, 'root', 1, 2, 'createdAt')
+
+      expect(res.body.total).to.equal(2)
+
+      const data: VideoPlaylist[] = res.body.data
+      expect(data).to.have.lengthOf(1)
+      expect(data[ 0 ].displayName).to.equal('playlist 3')
+    }
   })
 
-  it('Should get a playlist', async function () {
-    // get empty playlist
-    // get non empty playlist
+  it('Should not list unlisted or private playlists', async function () {
+    this.timeout(30000)
+
+    await createVideoPlaylist({
+      url: servers[ 1 ].url,
+      token: servers[ 1 ].accessToken,
+      playlistAttrs: {
+        displayName: 'playlist unlisted',
+        privacy: VideoPlaylistPrivacy.UNLISTED
+      }
+    })
+
+    await createVideoPlaylist({
+      url: servers[ 1 ].url,
+      token: servers[ 1 ].accessToken,
+      playlistAttrs: {
+        displayName: 'playlist private',
+        privacy: VideoPlaylistPrivacy.PRIVATE
+      }
+    })
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const results = [
+        await getAccountPlaylistsList(server.url, 'root@localhost:9002', 0, 5, '-createdAt'),
+        await getVideoPlaylistsList(server.url, 0, 2, '-createdAt')
+      ]
+
+      expect(results[0].body.total).to.equal(2)
+      expect(results[1].body.total).to.equal(3)
+
+      for (const res of results) {
+        const data: VideoPlaylist[] = res.body.data
+        expect(data).to.have.lengthOf(2)
+        expect(data[ 0 ].displayName).to.equal('playlist 3')
+        expect(data[ 1 ].displayName).to.equal('playlist 2')
+      }
+    }
   })
 
   it('Should update a playlist', async function () {
-    // update thumbnail
-
-    // update other details
+    this.timeout(30000)
+
+    await updateVideoPlaylist({
+      url: servers[1].url,
+      token: servers[1].accessToken,
+      playlistAttrs: {
+        displayName: 'playlist 3 updated',
+        description: 'description updated',
+        privacy: VideoPlaylistPrivacy.UNLISTED,
+        thumbnailfile: 'thumbnail.jpg',
+        videoChannelId: servers[1].videoChannel.id
+      },
+      playlistId: playlistServer2Id2
+    })
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getVideoPlaylist(server.url, playlistServer2UUID2)
+      const playlist: VideoPlaylist = res.body
+
+      expect(playlist.displayName).to.equal('playlist 3 updated')
+      expect(playlist.description).to.equal('description updated')
+
+      expect(playlist.privacy.id).to.equal(VideoPlaylistPrivacy.UNLISTED)
+      expect(playlist.privacy.label).to.equal('Unlisted')
+
+      expect(playlist.type.id).to.equal(VideoPlaylistType.REGULAR)
+      expect(playlist.type.label).to.equal('Regular')
+
+      expect(playlist.videosLength).to.equal(2)
+
+      expect(playlist.ownerAccount.name).to.equal('root')
+      expect(playlist.ownerAccount.displayName).to.equal('root')
+      expect(playlist.videoChannel.name).to.equal('root_channel')
+      expect(playlist.videoChannel.displayName).to.equal('Main root channel')
+    }
   })
 
   it('Should create a playlist containing different startTimestamp/endTimestamp videos', async function () {
+    this.timeout(30000)
+
+    const addVideo = (elementAttrs: any) => {
+      return addVideoInPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistId: playlistServer1Id, elementAttrs })
+    }
 
+    const res = await createVideoPlaylist({
+      url: servers[ 0 ].url,
+      token: servers[ 0 ].accessToken,
+      playlistAttrs: {
+        displayName: 'playlist 4',
+        privacy: VideoPlaylistPrivacy.PUBLIC
+      }
+    })
+
+    playlistServer1Id = res.body.videoPlaylist.id
+    playlistServer1UUID = res.body.videoPlaylist.uuid
+
+    await addVideo({ videoId: servers[0].videos[0].uuid, startTimestamp: 15, stopTimestamp: 28 })
+    await addVideo({ videoId: servers[2].videos[1].uuid, startTimestamp: 35 })
+    await addVideo({ videoId: servers[2].videos[2].uuid })
+    await addVideo({ videoId: servers[0].videos[3].uuid, stopTimestamp: 35 })
+    await addVideo({ videoId: servers[0].videos[4].uuid, startTimestamp: 45, stopTimestamp: 60 })
+    await addVideo({ videoId: nsfwVideoServer1, startTimestamp: 5 })
+
+    await waitJobs(servers)
   })
 
   it('Should correctly list playlist videos', async function () {
-    // empty
-    // some filters?
+    this.timeout(30000)
+
+    for (const server of servers) {
+      const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+
+      expect(res.body.total).to.equal(6)
+
+      const videos: Video[] = res.body.data
+      expect(videos).to.have.lengthOf(6)
+
+      expect(videos[0].name).to.equal('video 0 server 1')
+      expect(videos[0].playlistElement.position).to.equal(1)
+      expect(videos[0].playlistElement.startTimestamp).to.equal(15)
+      expect(videos[0].playlistElement.stopTimestamp).to.equal(28)
+
+      expect(videos[1].name).to.equal('video 1 server 3')
+      expect(videos[1].playlistElement.position).to.equal(2)
+      expect(videos[1].playlistElement.startTimestamp).to.equal(35)
+      expect(videos[1].playlistElement.stopTimestamp).to.be.null
+
+      expect(videos[2].name).to.equal('video 2 server 3')
+      expect(videos[2].playlistElement.position).to.equal(3)
+      expect(videos[2].playlistElement.startTimestamp).to.be.null
+      expect(videos[2].playlistElement.stopTimestamp).to.be.null
+
+      expect(videos[3].name).to.equal('video 3 server 1')
+      expect(videos[3].playlistElement.position).to.equal(4)
+      expect(videos[3].playlistElement.startTimestamp).to.be.null
+      expect(videos[3].playlistElement.stopTimestamp).to.equal(35)
+
+      expect(videos[4].name).to.equal('video 4 server 1')
+      expect(videos[4].playlistElement.position).to.equal(5)
+      expect(videos[4].playlistElement.startTimestamp).to.equal(45)
+      expect(videos[4].playlistElement.stopTimestamp).to.equal(60)
+
+      expect(videos[5].name).to.equal('NSFW video')
+      expect(videos[5].playlistElement.position).to.equal(6)
+      expect(videos[5].playlistElement.startTimestamp).to.equal(5)
+      expect(videos[5].playlistElement.stopTimestamp).to.be.null
+
+      const res2 = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10, { nsfw: false })
+      expect(res2.body.total).to.equal(5)
+      expect(res2.body.data.find(v => v.name === 'NSFW video')).to.be.undefined
+
+      const res3 = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 2)
+      expect(res3.body.data).to.have.lengthOf(2)
+    }
   })
 
   it('Should reorder the playlist', async function () {
-    // reorder 1 element
-    // reorder 3 elements
-    // reorder at the beginning
-    // reorder at the end
-    // reorder before/after
+    this.timeout(30000)
+
+    {
+      await reorderVideosPlaylist({
+        url: servers[ 0 ].url,
+        token: servers[ 0 ].accessToken,
+        playlistId: playlistServer1Id,
+        elementAttrs: {
+          startPosition: 2,
+          insertAfterPosition: 3
+        }
+      })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+        const names = res.body.data.map(v => v.name)
+
+        expect(names).to.deep.equal([
+          'video 0 server 1',
+          'video 2 server 3',
+          'video 1 server 3',
+          'video 3 server 1',
+          'video 4 server 1',
+          'NSFW video'
+        ])
+      }
+    }
+
+    {
+      await reorderVideosPlaylist({
+        url: servers[0].url,
+        token: servers[0].accessToken,
+        playlistId: playlistServer1Id,
+        elementAttrs: {
+          startPosition: 1,
+          reorderLength: 3,
+          insertAfterPosition: 4
+        }
+      })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+        const names = res.body.data.map(v => v.name)
+
+        expect(names).to.deep.equal([
+          'video 3 server 1',
+          'video 0 server 1',
+          'video 2 server 3',
+          'video 1 server 3',
+          'video 4 server 1',
+          'NSFW video'
+        ])
+      }
+    }
+
+    {
+      await reorderVideosPlaylist({
+        url: servers[0].url,
+        token: servers[0].accessToken,
+        playlistId: playlistServer1Id,
+        elementAttrs: {
+          startPosition: 6,
+          insertAfterPosition: 3
+        }
+      })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+        const videos: Video[] = res.body.data
+
+        const names = videos.map(v => v.name)
+
+        expect(names).to.deep.equal([
+          'video 3 server 1',
+          'video 0 server 1',
+          'video 2 server 3',
+          'NSFW video',
+          'video 1 server 3',
+          'video 4 server 1'
+        ])
+
+        for (let i = 1; i <= videos.length; i++) {
+          expect(videos[i - 1].playlistElement.position).to.equal(i)
+        }
+      }
+    }
   })
 
   it('Should update startTimestamp/endTimestamp of some elements', async function () {
-
+    this.timeout(30000)
+
+    await updateVideoPlaylistElement({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistId: playlistServer1Id,
+      videoId: servers[0].videos[3].uuid,
+      elementAttrs: {
+        startTimestamp: 1
+      }
+    })
+
+    await updateVideoPlaylistElement({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistId: playlistServer1Id,
+      videoId: servers[0].videos[4].uuid,
+      elementAttrs: {
+        stopTimestamp: null
+      }
+    })
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+      const videos: Video[] = res.body.data
+
+      expect(videos[0].name).to.equal('video 3 server 1')
+      expect(videos[0].playlistElement.position).to.equal(1)
+      expect(videos[0].playlistElement.startTimestamp).to.equal(1)
+      expect(videos[0].playlistElement.stopTimestamp).to.equal(35)
+
+      expect(videos[5].name).to.equal('video 4 server 1')
+      expect(videos[5].playlistElement.position).to.equal(6)
+      expect(videos[5].playlistElement.startTimestamp).to.equal(45)
+      expect(videos[5].playlistElement.stopTimestamp).to.be.null
+    }
   })
 
   it('Should delete some elements', async function () {
+    this.timeout(30000)
+
+    await removeVideoFromPlaylist({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistId: playlistServer1Id,
+      videoId: servers[0].videos[3].uuid
+    })
+
+    await removeVideoFromPlaylist({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistId: playlistServer1Id,
+      videoId: nsfwVideoServer1
+    })
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+
+      expect(res.body.total).to.equal(4)
+
+      const videos: Video[] = res.body.data
+      expect(videos).to.have.lengthOf(4)
 
+      expect(videos[ 0 ].name).to.equal('video 0 server 1')
+      expect(videos[ 0 ].playlistElement.position).to.equal(1)
+
+      expect(videos[ 1 ].name).to.equal('video 2 server 3')
+      expect(videos[ 1 ].playlistElement.position).to.equal(2)
+
+      expect(videos[ 2 ].name).to.equal('video 1 server 3')
+      expect(videos[ 2 ].playlistElement.position).to.equal(3)
+
+      expect(videos[ 3 ].name).to.equal('video 4 server 1')
+      expect(videos[ 3 ].playlistElement.position).to.equal(4)
+    }
   })
 
   it('Should delete the playlist on server 1 and delete on server 2 and 3', async function () {
+    this.timeout(30000)
 
+    await deleteVideoPlaylist(servers[0].url, servers[0].accessToken, playlistServer1Id)
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      await getVideoPlaylist(server.url, playlistServer1UUID, 404)
+    }
   })
 
   it('Should have deleted the thumbnail on server 1, 2 and 3', async function () {
+    this.timeout(30000)
 
+    for (const server of servers) {
+      await checkPlaylistFilesWereRemoved(playlistServer1UUID, server.serverNumber)
+    }
   })
 
   it('Should unfollow servers 1 and 2 and hide their playlists', async function () {
+    this.timeout(30000)
 
+    const finder = data => data.find(p => p.displayName === 'my super playlist')
+
+    {
+      const res = await getVideoPlaylistsList(servers[ 2 ].url, 0, 5)
+      expect(res.body.total).to.equal(2)
+      expect(finder(res.body.data)).to.not.be.undefined
+    }
+
+    await unfollow(servers[2].url, servers[2].accessToken, servers[0])
+
+    {
+      const res = await getVideoPlaylistsList(servers[ 2 ].url, 0, 5)
+      expect(res.body.total).to.equal(1)
+
+      expect(finder(res.body.data)).to.be.undefined
+    }
   })
 
-  it('Should delete a channel and remove the associated playlist', async 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 res2 = await createVideoPlaylist({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistAttrs: {
+        displayName: 'channel playlist',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId
+      }
+    })
+    const videoPlaylistUUID = res2.body.videoPlaylist.uuid
+
+    await waitJobs(servers)
+
+    await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'super_channel')
+
+    await waitJobs(servers)
+
+    const res3 = await getVideoPlaylistWithToken(servers[0].url, servers[0].accessToken, videoPlaylistUUID)
+    expect(res3.body.displayName).to.equal('channel playlist')
+    expect(res3.body.privacy.id).to.equal(VideoPlaylistPrivacy.PRIVATE)
+
+    await getVideoPlaylist(servers[1].url, videoPlaylistUUID, 404)
   })
 
   it('Should delete an account and delete its playlists', async function () {
+    this.timeout(30000)
+
+    const user = { username: 'user_1', password: 'password' }
+    const res = await createUser(servers[0].url, servers[0].accessToken, user.username, user.password)
+
+    const userId = res.body.user.id
+    const userAccessToken = await userLogin(servers[0], user)
 
+    await createVideoPlaylist({
+      url: servers[0].url,
+      token: userAccessToken,
+      playlistAttrs: {
+        displayName: 'playlist to be deleted',
+        privacy: VideoPlaylistPrivacy.PUBLIC
+      }
+    })
+
+    await waitJobs(servers)
+
+    const finder = data => data.find(p => p.displayName === 'playlist to be deleted')
+
+    {
+      for (const server of [ servers[0], servers[1] ]) {
+        const res = await getVideoPlaylistsList(server.url, 0, 15)
+        expect(finder(res.body.data)).to.not.be.undefined
+      }
+    }
+
+    await removeUser(servers[0].url, userId, servers[0].accessToken)
+    await waitJobs(servers)
+
+    {
+      for (const server of [ servers[0], servers[1] ]) {
+        const res = await getVideoPlaylistsList(server.url, 0, 15)
+        expect(finder(res.body.data)).to.be.undefined
+      }
+    }
   })
 
   after(async function () {