From df0b219d36bf6852cdf2a7ad09ed4a41c6bccefa Mon Sep 17 00:00:00 2001 From: Chocobozzz Date: Tue, 5 Mar 2019 10:58:44 +0100 Subject: Add playlist rest tests --- server/tests/api/videos/video-playlists.ts | 728 ++++++++++++++++++++++++++--- 1 file changed, 672 insertions(+), 56 deletions(-) (limited to 'server/tests/api/videos') 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[][] = [] + + for (const server of servers) { + const videoPromises: Promise[] = [] + + 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 () { -- cgit v1.2.3