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

699 lines
22 KiB
TypeScript
Raw Normal View History

2020-01-31 16:56:52 +01:00
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
2019-02-26 10:55:40 +01:00
import 'mocha'
import {
checkBadCountPagination,
checkBadSortPagination,
checkBadStartPagination,
2019-04-24 15:10:37 +02:00
cleanupTests,
2021-07-16 09:47:51 +02:00
createSingleServer,
2019-02-26 10:55:40 +01:00
makeGetRequest,
2021-07-16 09:47:51 +02:00
PeerTubeServer,
2021-07-16 14:27:30 +02:00
PlaylistsCommand,
2019-04-24 15:10:37 +02:00
setAccessTokensToServers,
2021-07-15 10:02:54 +02:00
setDefaultVideoChannel
} from '@shared/extra-utils'
import {
2021-07-16 14:27:30 +02:00
HttpStatusCode,
2021-07-15 10:02:54 +02:00
VideoPlaylistCreate,
VideoPlaylistCreateResult,
VideoPlaylistElementCreate,
VideoPlaylistElementUpdate,
VideoPlaylistPrivacy,
VideoPlaylistReorder,
VideoPlaylistType
} from '@shared/models'
2019-02-26 10:55:40 +01:00
describe('Test video playlists API validator', function () {
2021-07-16 09:47:51 +02:00
let server: PeerTubeServer
2019-03-05 10:58:44 +01:00
let userAccessToken: string
let playlist: VideoPlaylistCreateResult
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
2021-07-08 15:54:39 +02:00
let elementId: number
let command: PlaylistsCommand
2019-02-26 10:55:40 +01:00
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
2021-07-16 09:47:51 +02:00
server = await createSingleServer(1)
2019-02-26 10:55:40 +01:00
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
2019-02-26 10:55:40 +01:00
2021-07-16 09:04:35 +02:00
userAccessToken = await server.users.generateUserAndToken('user1')
videoId = (await server.videos.quickUpload({ name: 'video 1' })).id
2019-02-28 11:14:26 +01:00
2021-07-16 09:04:35 +02:00
command = server.playlists
2021-07-08 15:54:39 +02:00
2019-02-28 11:14:26 +01:00
{
2021-07-08 15:54:39 +02:00
const { data } = await command.listByAccount({
token: server.accessToken,
handle: 'root',
start: 0,
count: 5,
playlistType: VideoPlaylistType.WATCH_LATER
})
watchLaterPlaylistId = data[0].id
2019-02-28 11:14:26 +01:00
}
{
2021-07-08 15:54:39 +02:00
playlist = await command.create({
attributes: {
2019-02-28 11:14:26 +01:00
displayName: 'super playlist',
privacy: VideoPlaylistPrivacy.PUBLIC,
2021-07-16 09:04:35 +02:00
videoChannelId: server.store.channel.id
2019-02-28 11:14:26 +01:00
}
})
}
{
2021-07-08 15:54:39 +02:00
const created = await command.create({
attributes: {
displayName: 'private',
privacy: VideoPlaylistPrivacy.PRIVATE
}
})
2021-07-08 15:54:39 +02:00
privatePlaylistUUID = created.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,
2021-07-16 10:42:24 +02:00
expectedStatus: HttpStatusCode.NOT_FOUND_404,
token: server.accessToken
})
2019-02-26 10:55:40 +01:00
})
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,
2021-07-16 10:42:24 +02:00
expectedStatus: HttpStatusCode.NOT_FOUND_404,
token: server.accessToken
})
2019-02-26 10:55:40 +01:00
})
it('Should success with the correct parameters', async function () {
2021-07-16 10:42:24 +02:00
await makeGetRequest({ url: server.url, path: globalPath, expectedStatus: HttpStatusCode.OK_200, token: server.accessToken })
await makeGetRequest({ url: server.url, path: accountPath, expectedStatus: HttpStatusCode.OK_200, token: server.accessToken })
await makeGetRequest({
url: server.url,
path: videoChannelPath,
2021-07-16 10:42:24 +02:00
expectedStatus: HttpStatusCode.OK_200,
token: server.accessToken
})
2019-02-26 10:55:40 +01:00
})
})
2019-02-28 11:14:26 +01:00
describe('When listing videos of a playlist', function () {
2019-07-31 15:57:32 +02:00
const path = '/api/v1/video-playlists/'
2019-02-26 10:55:40 +01:00
it('Should fail with a bad start pagination', async function () {
await checkBadStartPagination(server.url, path + playlist.shortUUID + '/videos', server.accessToken)
2019-02-26 10:55:40 +01:00
})
it('Should fail with a bad count pagination', async function () {
await checkBadCountPagination(server.url, path + playlist.shortUUID + '/videos', server.accessToken)
2019-02-26 10:55:40 +01:00
})
2019-07-31 15:57:32 +02:00
it('Should success with the correct parameters', async function () {
2021-07-16 10:42:24 +02:00
await makeGetRequest({ url: server.url, path: path + playlist.shortUUID + '/videos', expectedStatus: HttpStatusCode.OK_200 })
2019-02-26 10:55:40 +01:00
})
})
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 () {
2021-07-08 15:54:39 +02:00
await command.get({ playlistId: 'toto', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown playlist', async function () {
2021-07-08 15:54:39 +02:00
await command.get({ playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
2019-02-28 11:14:26 +01:00
})
it('Should fail to get an unlisted playlist with the number id', async function () {
2021-07-08 15:54:39 +02:00
const playlist = await command.create({
attributes: {
2019-02-28 11:14:26 +01:00
displayName: 'super playlist',
2021-07-16 09:04:35 +02:00
videoChannelId: server.store.channel.id,
2019-02-28 11:14:26 +01:00
privacy: VideoPlaylistPrivacy.UNLISTED
}
})
2021-07-08 15:54:39 +02:00
await command.get({ playlistId: playlist.id, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
await command.get({ playlistId: playlist.uuid, expectedStatus: HttpStatusCode.OK_200 })
2019-02-28 11:14:26 +01:00
})
it('Should succeed with the correct params', async function () {
2021-07-08 15:54:39 +02:00
await command.get({ playlistId: playlist.uuid, expectedStatus: HttpStatusCode.OK_200 })
2019-02-28 11:14:26 +01:00
})
})
describe('When creating/updating a video playlist', function () {
2021-07-08 15:54:39 +02:00
const getBase = (
attributes?: Partial<VideoPlaylistCreate>,
wrapper?: Partial<Parameters<PlaylistsCommand['create']>[0]>
) => {
return {
attributes: {
2019-03-05 10:58:44 +01:00
displayName: 'display name',
privacy: VideoPlaylistPrivacy.UNLISTED,
thumbnailfile: 'thumbnail.jpg',
2021-07-16 09:04:35 +02:00
videoChannelId: server.store.channel.id,
2021-07-08 15:54:39 +02:00
...attributes
},
expectedStatus: HttpStatusCode.BAD_REQUEST_400,
...wrapper
}
2019-03-05 10:58:44 +01:00
}
const getUpdate = (params: any, playlistId: number | string) => {
2021-07-13 09:43:59 +02:00
return { ...params, playlistId: playlistId }
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
it('Should fail with an unauthenticated user', async function () {
const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
2019-02-28 11:14:26 +01:00
2021-07-08 15:54:39 +02:00
await command.create(params)
await command.update(getUpdate(params, playlist.shortUUID))
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
2021-07-08 15:54:39 +02:00
await command.create(params)
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
2021-07-08 15:54:39 +02:00
await command.create(params)
await command.update(getUpdate(params, playlist.shortUUID))
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
2021-07-08 15:54:39 +02:00
await command.create(params)
await command.update(getUpdate(params, playlist.shortUUID))
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
2021-07-08 15:54:39 +02:00
await command.create(params)
await command.update(getUpdate(params, playlist.shortUUID))
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown video channel id', async function () {
const params = getBase({ videoChannelId: 42 }, { expectedStatus: HttpStatusCode.NOT_FOUND_404 })
2019-02-28 11:14:26 +01:00
2021-07-08 15:54:39 +02:00
await command.create(params)
await command.update(getUpdate(params, playlist.shortUUID))
2019-02-28 11:14:26 +01:00
})
it('Should fail with an incorrect thumbnail file', async function () {
2021-01-26 11:37:31 +01:00
const params = getBase({ thumbnailfile: 'video_short.mp4' })
2021-07-08 15:54:39 +02:00
await command.create(params)
await command.update(getUpdate(params, playlist.shortUUID))
2021-01-26 11:37:31 +01:00
})
it('Should fail with a thumbnail file too big', async function () {
const params = getBase({ thumbnailfile: 'preview-big.png' })
2019-02-28 11:14:26 +01:00
2021-07-08 15:54:39 +02:00
await command.create(params)
await command.update(getUpdate(params, playlist.shortUUID))
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 })
2021-07-08 15:54:39 +02:00
const params2 = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: 'null' as any })
const params3 = getBase({ privacy: undefined, videoChannelId: 'null' as any })
2021-07-08 15:54:39 +02:00
await command.create(params)
await command.create(params2)
await command.update(getUpdate(params, privatePlaylistUUID))
await command.update(getUpdate(params2, playlist.shortUUID))
await command.update(getUpdate(params3, playlist.shortUUID))
})
2019-02-28 11:14:26 +01:00
it('Should fail with an unknown playlist to update', async function () {
2021-07-08 15:54:39 +02:00
await command.update(getUpdate(
getBase({}, { expectedStatus: HttpStatusCode.NOT_FOUND_404 }),
2019-03-05 10:58:44 +01:00
42
))
2019-02-28 11:14:26 +01:00
})
it('Should fail to update a playlist of another user', async function () {
2021-07-08 15:54:39 +02:00
await command.update(getUpdate(
getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 }),
playlist.shortUUID
2019-03-05 10:58:44 +01:00
))
2019-02-28 11:14:26 +01:00
})
2019-03-05 10:58:44 +01:00
it('Should fail to update the watch later playlist', async function () {
2021-07-08 15:54:39 +02:00
await command.update(getUpdate(
getBase({}, { expectedStatus: HttpStatusCode.BAD_REQUEST_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: HttpStatusCode.OK_200 })
2021-07-08 15:54:39 +02:00
await command.create(params)
2019-02-28 11:14:26 +01:00
}
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
2021-07-08 15:54:39 +02:00
await command.update(getUpdate(params, playlist.shortUUID))
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
})
})
describe('When adding an element in a playlist', function () {
2021-07-08 15:54:39 +02:00
const getBase = (
attributes?: Partial<VideoPlaylistElementCreate>,
wrapper?: Partial<Parameters<PlaylistsCommand['addElement']>[0]>
) => {
return {
attributes: {
2019-07-31 15:57:32 +02:00
videoId,
2019-03-05 10:58:44 +01:00
startTimestamp: 2,
2021-07-08 15:54:39 +02:00
stopTimestamp: 3,
...attributes
},
expectedStatus: HttpStatusCode.BAD_REQUEST_400,
playlistId: playlist.id,
...wrapper
}
2019-03-05 10:58:44 +01:00
}
it('Should fail with an unauthenticated user', async function () {
const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
2021-07-08 15:54:39 +02:00
await command.addElement(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with the playlist of another user', async function () {
const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
2021-07-08 15:54:39 +02:00
await command.addElement(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' })
2021-07-08 15:54:39 +02:00
await command.addElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
2021-07-08 15:54:39 +02:00
await command.addElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown or incorrect video id', async function () {
const params = getBase({ videoId: 42 }, { expectedStatus: HttpStatusCode.NOT_FOUND_404 })
2021-07-08 15:54:39 +02:00
await command.addElement(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 })
2021-07-08 15:54:39 +02:00
await command.addElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ stopTimestamp: 'toto' as any })
2021-07-08 15:54:39 +02:00
await command.addElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
})
it('Succeed with the correct params', async function () {
const params = getBase({}, { expectedStatus: HttpStatusCode.OK_200 })
2021-07-08 15:54:39 +02:00
const created = await command.addElement(params)
elementId = created.id
2019-02-28 11:14:26 +01:00
})
})
describe('When updating an element in a playlist', function () {
2021-07-08 15:54:39 +02:00
const getBase = (
attributes?: Partial<VideoPlaylistElementUpdate>,
wrapper?: Partial<Parameters<PlaylistsCommand['updateElement']>[0]>
) => {
return {
attributes: {
2019-03-05 10:58:44 +01:00
startTimestamp: 1,
2021-07-08 15:54:39 +02:00
stopTimestamp: 2,
...attributes
},
elementId,
playlistId: playlist.id,
2021-07-08 15:54:39 +02:00
expectedStatus: HttpStatusCode.BAD_REQUEST_400,
...wrapper
}
2019-03-05 10:58:44 +01:00
}
it('Should fail with an unauthenticated user', async function () {
const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
2021-07-08 15:54:39 +02:00
await command.updateElement(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with the playlist of another user', async function () {
const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
2021-07-08 15:54:39 +02:00
await command.updateElement(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' })
2021-07-08 15:54:39 +02:00
await command.updateElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
2021-07-08 15:54:39 +02:00
await command.updateElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
})
2019-07-31 15:57:32 +02:00
it('Should fail with an unknown or incorrect playlistElement id', async function () {
2019-03-05 10:58:44 +01:00
{
2021-07-08 15:54:39 +02:00
const params = getBase({}, { elementId: 'toto' })
await command.updateElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
2021-07-08 15:54:39 +02:00
const params = getBase({}, { elementId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
await command.updateElement(params)
2019-03-05 10:58:44 +01:00
}
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 })
2021-07-08 15:54:39 +02:00
await command.updateElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ stopTimestamp: -42 })
2021-07-08 15:54:39 +02:00
await command.updateElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown element', async function () {
2021-07-08 15:54:39 +02:00
const params = getBase({}, { elementId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
await command.updateElement(params)
2019-02-28 11:14:26 +01:00
})
it('Succeed with the correct params', async function () {
const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
2021-07-08 15:54:39 +02:00
await command.updateElement(params)
2019-02-28 11:14:26 +01:00
})
})
describe('When reordering elements of a playlist', function () {
let videoId3: number
let videoId4: number
2021-07-08 15:54:39 +02:00
const getBase = (
attributes?: Partial<VideoPlaylistReorder>,
wrapper?: Partial<Parameters<PlaylistsCommand['reorderElements']>[0]>
) => {
return {
attributes: {
2019-03-05 10:58:44 +01:00
startPosition: 1,
insertAfterPosition: 2,
2021-07-08 15:54:39 +02:00
reorderLength: 3,
...attributes
},
playlistId: playlist.shortUUID,
expectedStatus: HttpStatusCode.BAD_REQUEST_400,
...wrapper
}
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
before(async function () {
2021-07-16 09:04:35 +02:00
videoId3 = (await server.videos.quickUpload({ name: 'video 3' })).id
videoId4 = (await server.videos.quickUpload({ name: 'video 4' })).id
2019-03-05 10:58:44 +01:00
2020-01-31 16:56:52 +01:00
for (const id of [ videoId3, videoId4 ]) {
2021-07-08 15:54:39 +02:00
await command.addElement({ playlistId: playlist.shortUUID, attributes: { videoId: id } })
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unauthenticated user', async function () {
const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with the playlist of another user', async function () {
const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(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' })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
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 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ startPosition: 'toto' as any })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ startPosition: 42 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
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 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ insertAfterPosition: -2 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ insertAfterPosition: 42 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
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 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ reorderLength: -2 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ reorderLength: 42 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
})
it('Succeed with the correct params', async function () {
const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
2021-07-08 15:54:39 +02:00
await command.reorderElements(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 ] },
2021-07-16 10:42:24 +02:00
expectedStatus: HttpStatusCode.UNAUTHORIZED_401
2019-03-13 16:03:03 +01:00
})
})
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 ] },
2021-07-16 10:42:24 +02:00
expectedStatus: HttpStatusCode.OK_200
2019-03-13 16:03:03 +01:00
})
})
})
2019-02-28 11:14:26 +01:00
describe('When deleting an element in a playlist', function () {
2021-07-08 15:54:39 +02:00
const getBase = (wrapper: Partial<Parameters<PlaylistsCommand['removeElement']>[0]>) => {
return {
elementId,
playlistId: playlist.uuid,
2021-07-08 15:54:39 +02:00
expectedStatus: HttpStatusCode.BAD_REQUEST_400,
...wrapper
}
2019-03-05 10:58:44 +01:00
}
it('Should fail with an unauthenticated user', async function () {
const params = getBase({ token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
2021-07-08 15:54:39 +02:00
await command.removeElement(params)
2019-02-28 11:14:26 +01:00
})
it('Should fail with the playlist of another user', async function () {
const params = getBase({ token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
2021-07-08 15:54:39 +02:00
await command.removeElement(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' })
2021-07-08 15:54:39 +02:00
await command.removeElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
const params = getBase({ playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
2021-07-08 15:54:39 +02:00
await command.removeElement(params)
2019-03-05 10:58:44 +01:00
}
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
{
2021-07-08 15:54:39 +02:00
const params = getBase({ elementId: 'toto' as any })
await command.removeElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
2019-03-05 10:58:44 +01:00
{
2021-07-08 15:54:39 +02:00
const params = getBase({ elementId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
await command.removeElement(params)
2019-03-05 10:58:44 +01:00
}
2019-02-28 11:14:26 +01:00
})
it('Should fail with an unknown element', async function () {
2021-07-08 15:54:39 +02:00
const params = getBase({ elementId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
await command.removeElement(params)
2019-02-28 11:14:26 +01:00
})
it('Succeed with the correct params', async function () {
const params = getBase({ expectedStatus: HttpStatusCode.NO_CONTENT_204 })
2021-07-08 15:54:39 +02:00
await command.removeElement(params)
2019-02-28 11:14:26 +01:00
})
})
describe('When deleting a playlist', function () {
it('Should fail with an unknown playlist', async function () {
2021-07-08 15:54:39 +02:00
await command.delete({ playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
2019-02-28 11:14:26 +01:00
})
it('Should fail with a playlist of another user', async function () {
2021-07-08 15:54:39 +02:00
await command.delete({ token: userAccessToken, playlistId: playlist.uuid, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
2019-02-28 11:14:26 +01:00
})
2019-03-05 10:58:44 +01:00
it('Should fail with the watch later playlist', async function () {
2021-07-08 15:54:39 +02:00
await command.delete({ playlistId: watchLaterPlaylistId, expectedStatus: HttpStatusCode.BAD_REQUEST_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 () {
2021-07-08 15:54:39 +02:00
await command.delete({ playlistId: playlist.uuid })
2019-02-28 11:14:26 +01:00
})
})
2019-04-24 15:10:37 +02:00
after(async function () {
await cleanupTests([ server ])
2019-02-26 10:55:40 +01:00
})
})