PeerTube/server/tests/api/check-params/video-playlists.ts

675 lines
22 KiB
TypeScript
Raw Normal View History

2019-02-26 10:55:40 +01:00
/* tslint:disable:no-unused-expression */
import 'mocha'
import {
2019-03-05 10:58:44 +01:00
addVideoInPlaylist,
2019-04-24 15:10:37 +02:00
cleanupTests,
2019-02-28 11:14:26 +01:00
createVideoPlaylist,
deleteVideoPlaylist,
2019-04-24 15:10:37 +02:00
flushAndRunServer,
2019-03-05 10:58:44 +01:00
generateUserAccessToken,
getAccountPlaylistsListWithToken,
2019-02-28 11:14:26 +01:00
getVideoPlaylist,
2019-02-26 10:55:40 +01:00
immutableAssign,
makeGetRequest,
2019-03-05 10:58:44 +01:00
removeVideoFromPlaylist,
reorderVideosPlaylist,
2019-02-26 10:55:40 +01:00
ServerInfo,
2019-04-24 15:10:37 +02:00
setAccessTokensToServers,
setDefaultVideoChannel,
2019-02-28 11:14:26 +01:00
updateVideoPlaylist,
2019-03-05 10:58:44 +01:00
updateVideoPlaylistElement,
uploadVideoAndGetId
} from '../../../../shared/extra-utils'
2019-02-26 10:55:40 +01:00
import {
checkBadCountPagination,
checkBadSortPagination,
checkBadStartPagination
} from '../../../../shared/extra-utils/requests/check-api-params'
2019-02-28 11:14:26 +01:00
import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
2019-03-05 10:58:44 +01:00
import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
2019-02-26 10:55:40 +01:00
describe('Test video playlists API validator', function () {
let server: ServerInfo
2019-03-05 10:58:44 +01:00
let userAccessToken: string
2019-02-28 11:14:26 +01:00
let playlistUUID: string
let privatePlaylistUUID: string
2019-03-05 10:58:44 +01:00
let watchLaterPlaylistId: number
2019-02-28 11:14:26 +01:00
let videoId: number
let videoId2: number
2019-02-26 10:55:40 +01:00
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
2019-04-24 10:53:40 +02:00
server = await flushAndRunServer(1)
2019-02-26 10:55:40 +01:00
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
2019-02-26 10:55:40 +01:00
2019-03-05 10:58:44 +01:00
userAccessToken = await generateUserAccessToken(server, 'user1')
videoId = (await uploadVideoAndGetId({ server, videoName: 'video 1' })).id
videoId2 = (await uploadVideoAndGetId({ server, videoName: 'video 2' })).id
2019-02-28 11:14:26 +01:00
{
2019-03-05 10:58:44 +01:00
const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root',0, 5, VideoPlaylistType.WATCH_LATER)
watchLaterPlaylistId = res.body.data[0].id
2019-02-28 11:14:26 +01:00
}
{
const res = await createVideoPlaylist({
url: server.url,
token: server.accessToken,
playlistAttrs: {
displayName: 'super playlist',
privacy: VideoPlaylistPrivacy.PUBLIC,
videoChannelId: server.videoChannel.id
2019-02-28 11:14:26 +01:00
}
})
playlistUUID = res.body.videoPlaylist.uuid
}
{
const res = await createVideoPlaylist({
url: server.url,
token: server.accessToken,
playlistAttrs: {
displayName: 'private',
privacy: VideoPlaylistPrivacy.PRIVATE
}
})
privatePlaylistUUID = res.body.videoPlaylist.uuid
}
2019-02-26 10:55:40 +01:00
})
2019-02-28 11:14:26 +01:00
describe('When listing playlists', function () {
2019-02-26 10:55:40 +01:00
const globalPath = '/api/v1/video-playlists'
const accountPath = '/api/v1/accounts/root/video-playlists'
const videoChannelPath = '/api/v1/video-channels/root_channel/video-playlists'
it('Should fail with a bad start pagination', async function () {
await checkBadStartPagination(server.url, globalPath, server.accessToken)
await checkBadStartPagination(server.url, accountPath, server.accessToken)
await checkBadStartPagination(server.url, videoChannelPath, server.accessToken)
})
it('Should fail with a bad count pagination', async function () {
await checkBadCountPagination(server.url, globalPath, server.accessToken)
await checkBadCountPagination(server.url, accountPath, server.accessToken)
await checkBadCountPagination(server.url, videoChannelPath, server.accessToken)
})
it('Should fail with an incorrect sort', async function () {
await checkBadSortPagination(server.url, globalPath, server.accessToken)
await checkBadSortPagination(server.url, accountPath, server.accessToken)
await checkBadSortPagination(server.url, videoChannelPath, server.accessToken)
})
2019-03-05 10:58:44 +01:00
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 } })
})
2019-02-26 10:55:40 +01:00
it('Should fail with a bad account parameter', async function () {
const accountPath = '/api/v1/accounts/root2/video-playlists'
await makeGetRequest({ url: server.url, path: accountPath, statusCodeExpected: 404, token: server.accessToken })
})
it('Should fail with a bad video channel parameter', async function () {
const accountPath = '/api/v1/video-channels/bad_channel/video-playlists'
await makeGetRequest({ url: server.url, path: accountPath, statusCodeExpected: 404, token: server.accessToken })
})
it('Should success with the correct parameters', async function () {
await makeGetRequest({ url: server.url, path: globalPath, statusCodeExpected: 200, token: server.accessToken })
await makeGetRequest({ url: server.url, path: accountPath, statusCodeExpected: 200, token: server.accessToken })
await makeGetRequest({ url: server.url, path: videoChannelPath, statusCodeExpected: 200, token: server.accessToken })
})
})
2019-02-28 11:14:26 +01:00
describe('When listing videos of a playlist', function () {
2019-02-26 10:55:40 +01:00
const path = '/api/v1/video-playlists'
it('Should fail with a bad start pagination', async function () {
await checkBadStartPagination(server.url, path, server.accessToken)
})
it('Should fail with a bad count pagination', async function () {
await checkBadCountPagination(server.url, path, server.accessToken)
})
2019-02-28 11:14:26 +01:00
it('Should fail with a bad filter', async function () {
2019-02-26 10:55:40 +01:00
await checkBadSortPagination(server.url, path, server.accessToken)
})
})
2019-02-28 11:14:26 +01:00
describe('When getting a video playlist', function () {
it('Should fail with a bad id or uuid', async function () {
await getVideoPlaylist(server.url, 'toto', 400)
})
it('Should fail with an unknown playlist', async function () {
await getVideoPlaylist(server.url, 42, 404)
})
it('Should fail to get an unlisted playlist with the number id', async function () {
const res = await createVideoPlaylist({
url: server.url,
token: server.accessToken,
playlistAttrs: {
displayName: 'super playlist',
privacy: VideoPlaylistPrivacy.UNLISTED
}
})
const playlist = res.body.videoPlaylist
await getVideoPlaylist(server.url, playlist.id, 404)
await getVideoPlaylist(server.url, playlist.uuid, 200)
})
it('Should succeed with the correct params', async function () {
await getVideoPlaylist(server.url, playlistUUID, 200)
})
})
describe('When creating/updating a video playlist', function () {
2019-03-05 10:58:44 +01:00
const getBase = (playlistAttrs: any = {}, wrapper: any = {}) => {
return Object.assign({
expectedStatus: 400,
url: server.url,
token: server.accessToken,
playlistAttrs: Object.assign({
displayName: 'display name',
privacy: VideoPlaylistPrivacy.UNLISTED,
thumbnailfile: 'thumbnail.jpg',
videoChannelId: server.videoChannel.id
2019-03-05 10:58:44 +01:00
}, playlistAttrs)
}, wrapper)
}
const getUpdate = (params: any, playlistId: number | string) => {
return immutableAssign(params, { playlistId: playlistId })
}
2019-02-28 11:14:26 +01:00
it('Should fail with an unauthenticated user', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({}, { token: null, expectedStatus: 401 })
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
await createVideoPlaylist(params)
await updateVideoPlaylist(getUpdate(params, playlistUUID))
2019-02-28 11:14:26 +01:00
})
it('Should fail without displayName', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ displayName: undefined })
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
await createVideoPlaylist(params)
await updateVideoPlaylist(getUpdate(params, playlistUUID))
2019-02-28 11:14:26 +01:00
})
it('Should fail with an incorrect display name', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ displayName: 's'.repeat(300) })
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
await createVideoPlaylist(params)
await updateVideoPlaylist(getUpdate(params, playlistUUID))
2019-02-28 11:14:26 +01:00
})
it('Should fail with an incorrect description', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ description: 't' })
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
await createVideoPlaylist(params)
await updateVideoPlaylist(getUpdate(params, playlistUUID))
2019-02-28 11:14:26 +01:00
})
it('Should fail with an incorrect privacy', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ privacy: 45 })
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
await createVideoPlaylist(params)
await updateVideoPlaylist(getUpdate(params, playlistUUID))
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown video channel id', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ videoChannelId: 42 }, { expectedStatus: 404 })
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
await createVideoPlaylist(params)
await updateVideoPlaylist(getUpdate(params, playlistUUID))
2019-02-28 11:14:26 +01:00
})
it('Should fail with an incorrect thumbnail file', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ thumbnailfile: 'avatar.png' })
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
await createVideoPlaylist(params)
await updateVideoPlaylist(getUpdate(params, playlistUUID))
2019-02-28 11:14:26 +01:00
})
it('Should fail to set "public" a playlist not assigned to a channel', async function () {
const params = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: undefined })
const params2 = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: 'null' })
const params3 = getBase({ privacy: undefined, videoChannelId: 'null' })
await createVideoPlaylist(params)
await createVideoPlaylist(params2)
await updateVideoPlaylist(getUpdate(params, privatePlaylistUUID))
await updateVideoPlaylist(getUpdate(params2, playlistUUID))
await updateVideoPlaylist(getUpdate(params3, playlistUUID))
})
2019-02-28 11:14:26 +01:00
it('Should fail with an unknown playlist to update', async function () {
2019-03-05 10:58:44 +01:00
await updateVideoPlaylist(getUpdate(
getBase({}, { expectedStatus: 404 }),
42
))
2019-02-28 11:14:26 +01:00
})
it('Should fail to update a playlist of another user', async function () {
2019-03-05 10:58:44 +01:00
await updateVideoPlaylist(getUpdate(
getBase({}, { token: userAccessToken, expectedStatus: 403 }),
playlistUUID
))
2019-02-28 11:14:26 +01:00
})
it('Should fail to update to private a public/unlisted playlist', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC }, { expectedStatus: 200 })
const res = await createVideoPlaylist(params)
2019-02-28 11:14:26 +01:00
const playlist = res.body.videoPlaylist
const paramsUpdate = getBase({ privacy: VideoPlaylistPrivacy.PRIVATE }, { expectedStatus: 400 })
2019-03-05 10:58:44 +01:00
await updateVideoPlaylist(getUpdate(paramsUpdate, playlist.id))
})
it('Should fail to update the watch later playlist', async function () {
await updateVideoPlaylist(getUpdate(
getBase({}, { expectedStatus: 400 }),
2019-03-05 10:58:44 +01:00
watchLaterPlaylistId
))
2019-02-28 11:14:26 +01:00
})
it('Should succeed with the correct params', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { expectedStatus: 200 })
await createVideoPlaylist(params)
2019-02-28 11:14:26 +01:00
}
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { expectedStatus: 204 })
await updateVideoPlaylist(getUpdate(params, playlistUUID))
}
2019-02-28 11:14:26 +01:00
})
})
describe('When adding an element in a playlist', function () {
2019-03-05 10:58:44 +01:00
const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
return Object.assign({
expectedStatus: 400,
2019-02-28 11:14:26 +01:00
url: server.url,
2019-03-05 10:58:44 +01:00
token: server.accessToken,
2019-02-28 11:14:26 +01:00
playlistId: playlistUUID,
2019-03-05 10:58:44 +01:00
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)
2019-02-28 11:14:26 +01:00
})
it('Should fail with the playlist of another user', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
await addVideoInPlaylist(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown or incorrect playlist id', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { playlistId: 'toto' })
await addVideoInPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { playlistId: 42, expectedStatus: 404 })
await addVideoInPlaylist(params)
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown or incorrect video id', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ videoId: 42 }, { expectedStatus: 404 })
await addVideoInPlaylist(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with a bad start/stop timestamp', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({ startTimestamp: -42 })
await addVideoInPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ stopTimestamp: 'toto' as any })
await addVideoInPlaylist(params)
}
2019-02-28 11:14:26 +01:00
})
it('Succeed with the correct params', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({}, { expectedStatus: 200 })
await addVideoInPlaylist(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail if the video was already added in the playlist', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({}, { expectedStatus: 409 })
await addVideoInPlaylist(params)
2019-02-28 11:14:26 +01:00
})
})
describe('When updating an element in a playlist', function () {
2019-03-05 10:58:44 +01:00
const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
return Object.assign({
2019-02-28 11:14:26 +01:00
url: server.url,
2019-03-05 10:58:44 +01:00
token: server.accessToken,
elementAttrs: Object.assign({
startTimestamp: 1,
stopTimestamp: 2
}, elementAttrs),
2019-02-28 11:14:26 +01:00
videoId: videoId,
playlistId: playlistUUID,
2019-03-05 10:58:44 +01:00
expectedStatus: 400
}, wrapper)
}
it('Should fail with an unauthenticated user', async function () {
const params = getBase({}, { token: null, expectedStatus: 401 })
await updateVideoPlaylistElement(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with the playlist of another user', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
await updateVideoPlaylistElement(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown or incorrect playlist id', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { playlistId: 'toto' })
await updateVideoPlaylistElement(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { playlistId: 42, expectedStatus: 404 })
await updateVideoPlaylistElement(params)
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown or incorrect video id', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { videoId: 'toto' })
await updateVideoPlaylistElement(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { videoId: 42, expectedStatus: 404 })
await updateVideoPlaylistElement(params)
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with a bad start/stop timestamp', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({ startTimestamp: 'toto' as any })
await updateVideoPlaylistElement(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ stopTimestamp: -42 })
await updateVideoPlaylistElement(params)
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown element', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({}, { videoId: videoId2, expectedStatus: 404 })
await updateVideoPlaylistElement(params)
2019-02-28 11:14:26 +01:00
})
it('Succeed with the correct params', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({}, { expectedStatus: 204 })
await updateVideoPlaylistElement(params)
2019-02-28 11:14:26 +01:00
})
})
describe('When reordering elements of a playlist', function () {
let videoId3: number
let videoId4: number
2019-03-05 10:58:44 +01:00
const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
return Object.assign({
2019-02-28 11:14:26 +01:00
url: server.url,
token: server.accessToken,
playlistId: playlistUUID,
2019-03-05 10:58:44 +01:00
elementAttrs: Object.assign({
startPosition: 1,
insertAfterPosition: 2,
reorderLength: 3
}, elementAttrs),
expectedStatus: 400
}, wrapper)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
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 }
})
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unauthenticated user', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({}, { token: null, expectedStatus: 401 })
await reorderVideosPlaylist(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with the playlist of another user', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
await reorderVideosPlaylist(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with an invalid playlist', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { playlistId: 'toto' })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { playlistId: 42, expectedStatus: 404 })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an invalid start position', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({ startPosition: -1 })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ startPosition: 'toto' as any })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ startPosition: 42 })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an invalid insert after position', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({ insertAfterPosition: 'toto' as any })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ insertAfterPosition: -2 })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ insertAfterPosition: 42 })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an invalid reorder length', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({ reorderLength: 'toto' as any })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ reorderLength: -2 })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ reorderLength: 42 })
await reorderVideosPlaylist(params)
}
2019-02-28 11:14:26 +01:00
})
it('Succeed with the correct params', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({}, { expectedStatus: 204 })
await reorderVideosPlaylist(params)
2019-02-28 11:14:26 +01:00
})
})
2019-03-13 16:03:03 +01:00
describe('When checking exists in playlist endpoint', function () {
const path = '/api/v1/users/me/video-playlists/videos-exist'
it('Should fail with an unauthenticated user', async function () {
await makeGetRequest({
url: server.url,
path,
query: { videoIds: [ 1, 2 ] },
statusCodeExpected: 401
})
})
it('Should fail with invalid video ids', async function () {
await makeGetRequest({
url: server.url,
token: server.accessToken,
path,
query: { videoIds: 'toto' }
})
await makeGetRequest({
url: server.url,
token: server.accessToken,
path,
query: { videoIds: [ 'toto' ] }
})
await makeGetRequest({
url: server.url,
token: server.accessToken,
path,
query: { videoIds: [ 1, 'toto' ] }
})
})
it('Should succeed with the correct params', async function () {
await makeGetRequest({
url: server.url,
token: server.accessToken,
path,
query: { videoIds: [ 1, 2 ] },
statusCodeExpected: 200
})
})
})
2019-02-28 11:14:26 +01:00
describe('When deleting an element in a playlist', function () {
2019-03-05 10:58:44 +01:00
const getBase = (wrapper: any = {}) => {
return Object.assign({
2019-02-28 11:14:26 +01:00
url: server.url,
2019-03-05 10:58:44 +01:00
token: server.accessToken,
videoId: videoId,
2019-02-28 11:14:26 +01:00
playlistId: playlistUUID,
2019-03-05 10:58:44 +01:00
expectedStatus: 400
}, wrapper)
}
it('Should fail with an unauthenticated user', async function () {
const params = getBase({ token: null, expectedStatus: 401 })
await removeVideoFromPlaylist(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with the playlist of another user', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ token: userAccessToken, expectedStatus: 403 })
await removeVideoFromPlaylist(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown or incorrect playlist id', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({ playlistId: 'toto' })
await removeVideoFromPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ playlistId: 42, expectedStatus: 404 })
await removeVideoFromPlaylist(params)
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown or incorrect video id', async function () {
2019-03-05 10:58:44 +01:00
{
const params = getBase({ videoId: 'toto' })
await removeVideoFromPlaylist(params)
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ videoId: 42, expectedStatus: 404 })
await removeVideoFromPlaylist(params)
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown element', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ videoId: videoId2, expectedStatus: 404 })
await removeVideoFromPlaylist(params)
2019-02-28 11:14:26 +01:00
})
it('Succeed with the correct params', async function () {
2019-03-05 10:58:44 +01:00
const params = getBase({ expectedStatus: 204 })
await removeVideoFromPlaylist(params)
2019-02-28 11:14:26 +01:00
})
})
describe('When deleting a playlist', function () {
it('Should fail with an unknown playlist', async function () {
await deleteVideoPlaylist(server.url, server.accessToken, 42, 404)
})
it('Should fail with a playlist of another user', async function () {
await deleteVideoPlaylist(server.url, userAccessToken, playlistUUID, 403)
})
2019-03-05 10:58:44 +01:00
it('Should fail with the watch later playlist', async function () {
await deleteVideoPlaylist(server.url, server.accessToken, watchLaterPlaylistId, 400)
2019-03-05 10:58:44 +01:00
})
2019-02-28 11:14:26 +01:00
it('Should succeed with the correct params', async function () {
await deleteVideoPlaylist(server.url, server.accessToken, playlistUUID)
})
})
2019-04-24 15:10:37 +02:00
after(async function () {
await cleanupTests([ server ])
2019-02-26 10:55:40 +01:00
})
})