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/check-params/index.ts | 1 + server/tests/api/check-params/video-playlists.ts | 818 ++++++++--------------- server/tests/api/videos/video-playlists.ts | 728 ++++++++++++++++++-- 3 files changed, 950 insertions(+), 597 deletions(-) (limited to 'server/tests/api') diff --git a/server/tests/api/check-params/index.ts b/server/tests/api/check-params/index.ts index 77c17036a..ca51cd39a 100644 --- a/server/tests/api/check-params/index.ts +++ b/server/tests/api/check-params/index.ts @@ -16,6 +16,7 @@ import './video-captions' import './video-channels' import './video-comments' import './video-imports' +import './video-playlists' import './videos' import './videos-filter' import './videos-history' diff --git a/server/tests/api/check-params/video-playlists.ts b/server/tests/api/check-params/video-playlists.ts index 68fe362e9..803e7afb9 100644 --- a/server/tests/api/check-params/video-playlists.ts +++ b/server/tests/api/check-params/video-playlists.ts @@ -2,20 +2,24 @@ import 'mocha' import { - createUser, + addVideoInPlaylist, createVideoPlaylist, deleteVideoPlaylist, flushTests, + generateUserAccessToken, + getAccountPlaylistsListWithToken, getVideoPlaylist, immutableAssign, killallServers, makeGetRequest, + removeVideoFromPlaylist, + reorderVideosPlaylist, runServer, ServerInfo, setAccessTokensToServers, updateVideoPlaylist, - userLogin, - addVideoInPlaylist, uploadVideo, updateVideoPlaylistElement, removeVideoFromPlaylist, reorderVideosPlaylist + updateVideoPlaylistElement, + uploadVideoAndGetId } from '../../../../shared/utils' import { checkBadCountPagination, @@ -23,11 +27,13 @@ import { checkBadStartPagination } from '../../../../shared/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 watchLaterPlaylistId: number let videoId: number let videoId2: number @@ -42,19 +48,13 @@ describe('Test video playlists API validator', function () { await setAccessTokensToServers([ 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 uploadVideo(server.url, server.accessToken, { name: 'video 2' }) - videoId2 = res.body.video.id + const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root',0, 5, VideoPlaylistType.WATCH_LATER) + watchLaterPlaylistId = res.body.data[0].id } { @@ -93,6 +93,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' @@ -158,410 +164,250 @@ 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' + }, 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) + await updateVideoPlaylist(getUpdate(params, playlistUUID)) }) 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(baseParams) - await updateVideoPlaylist(immutableAssign(baseParams, { playlistId: playlistUUID })) + await createVideoPlaylist(params) + await updateVideoPlaylist(getUpdate(params, 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 params = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC }, { expectedStatus: 200 }) + + const res = await createVideoPlaylist(params) 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 - }) + const paramsUpdate = getBase({ privacy: VideoPlaylistPrivacy.PRIVATE }, { expectedStatus: 409 }) + + await updateVideoPlaylist(getUpdate(paramsUpdate, playlist.id)) + }) + + it('Should fail to update the watch later playlist', async function () { + await updateVideoPlaylist(getUpdate( + getBase({}, { expectedStatus: 409 }), + 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: 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 }) + await addVideoInPlaylist(params) }) 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: { }, + token: server.accessToken, + elementAttrs: Object.assign({ + startTimestamp: 1, + stopTimestamp: 2 + }, elementAttrs), videoId: videoId, 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 - }) + { + const params = getBase({}, { videoId: 'toto' }) + await updateVideoPlaylistElement(params) + } - await updateVideoPlaylistElement({ - url: server.url, - token: server.accessToken, - elementAttrs: { }, - videoId: 42, - playlistId: playlistUUID, - expectedStatus: 404 - }) + { + const params = getBase({}, { videoId: 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({}, { videoId: videoId2, 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 +415,166 @@ 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) + } - await reorderVideosPlaylist({ - url: server.url, - token: server.accessToken, - playlistId: playlistUUID, - elementAttrs: { - startPosition: 1, - insertAfterPosition: 42 - }, - expectedStatus: 400 - }) + { + const params = getBase({ insertAfterPosition: 42 }) + await reorderVideosPlaylist(params) + } }) it('Should fail with an invalid reorder length', async function () { - await reorderVideosPlaylist({ - url: server.url, - token: server.accessToken, - playlistId: playlistUUID, - elementAttrs: { - startPosition: 1, - insertAfterPosition: 2, - reorderLength: 'toto' as any - }, - expectedStatus: 400 - }) + { + const params = getBase({ reorderLength: 'toto' as any }) + await reorderVideosPlaylist(params) + } - await reorderVideosPlaylist({ - url: server.url, - token: server.accessToken, - playlistId: playlistUUID, - elementAttrs: { - startPosition: 1, - insertAfterPosition: 2, - reorderLength: -1 - }, - expectedStatus: 400 - }) + { + const params = getBase({ reorderLength: -2 }) + await reorderVideosPlaylist(params) + } - await reorderVideosPlaylist({ - url: server.url, - token: server.accessToken, - playlistId: playlistUUID, - elementAttrs: { - startPosition: 1, - insertAfterPosition: 2, - reorderLength: 4 - }, - expectedStatus: 400 - }) + { + const params = getBase({ reorderLength: 42 }) + await reorderVideosPlaylist(params) + } }) it('Succeed with the correct params', async function () { - await reorderVideosPlaylist({ - url: server.url, - token: server.accessToken, - playlistId: playlistUUID, - elementAttrs: { - startPosition: 1, - insertAfterPosition: 2, - reorderLength: 3 - }, - expectedStatus: 204 - }) + const params = getBase({}, { expectedStatus: 204 }) + await reorderVideosPlaylist(params) }) }) 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, + videoId: videoId, 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({ videoId: 'toto' }) + await removeVideoFromPlaylist(params) + } - await removeVideoFromPlaylist({ - url: server.url, - token: server.accessToken, - videoId: 42, - playlistId: playlistUUID, - expectedStatus: 404 - }) + { + const params = getBase({ videoId: 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({ videoId: videoId2, 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,6 +587,10 @@ 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, 409) + }) + it('Should succeed with the correct params', async function () { await deleteVideoPlaylist(server.url, server.accessToken, playlistUUID) }) 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