-/* tslint:disable:no-unused-expression */
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-import 'mocha'
+import { checkBadCountPagination, checkBadSortPagination, checkBadStartPagination } from '@server/tests/shared'
import {
- addVideoInPlaylist,
- createVideoPlaylist,
- deleteVideoPlaylist,
- flushTests,
- generateUserAccessToken,
- getAccountPlaylistsListWithToken,
- getVideoPlaylist,
- immutableAssign,
- killallServers,
- makeGetRequest,
- removeVideoFromPlaylist,
- reorderVideosPlaylist,
- runServer,
- ServerInfo,
- setAccessTokensToServers, setDefaultVideoChannel,
- updateVideoPlaylist,
- updateVideoPlaylistElement,
- uploadVideoAndGetId
-} from '../../../../shared/utils'
+ HttpStatusCode,
+ VideoPlaylistCreate,
+ VideoPlaylistCreateResult,
+ VideoPlaylistElementCreate,
+ VideoPlaylistElementUpdate,
+ VideoPlaylistPrivacy,
+ VideoPlaylistReorder,
+ VideoPlaylistType
+} from '@shared/models'
import {
- checkBadCountPagination,
- checkBadSortPagination,
- 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'
+ cleanupTests,
+ createSingleServer,
+ makeGetRequest,
+ PeerTubeServer,
+ PlaylistsCommand,
+ setAccessTokensToServers,
+ setDefaultVideoChannel
+} from '@shared/server-commands'
describe('Test video playlists API validator', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken: string
- let playlistUUID: string
+
+ let playlist: VideoPlaylistCreateResult
let privatePlaylistUUID: string
+
let watchLaterPlaylistId: number
let videoId: number
- let videoId2: number
+ let elementId: number
+
+ let command: PlaylistsCommand
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
- await flushTests()
-
- server = await runServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
- userAccessToken = await generateUserAccessToken(server, 'user1')
- videoId = (await uploadVideoAndGetId({ server, videoName: 'video 1' })).id
- videoId2 = (await uploadVideoAndGetId({ server, videoName: 'video 2' })).id
+ userAccessToken = await server.users.generateUserAndToken('user1')
+ videoId = (await server.videos.quickUpload({ name: 'video 1' })).id
+
+ command = server.playlists
{
- const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root',0, 5, VideoPlaylistType.WATCH_LATER)
- watchLaterPlaylistId = res.body.data[0].id
+ const { data } = await command.listByAccount({
+ token: server.accessToken,
+ handle: 'root',
+ start: 0,
+ count: 5,
+ playlistType: VideoPlaylistType.WATCH_LATER
+ })
+ watchLaterPlaylistId = data[0].id
}
{
- const res = await createVideoPlaylist({
- url: server.url,
- token: server.accessToken,
- playlistAttrs: {
+ playlist = await command.create({
+ attributes: {
displayName: 'super playlist',
privacy: VideoPlaylistPrivacy.PUBLIC,
- videoChannelId: server.videoChannel.id
+ videoChannelId: server.store.channel.id
}
})
- playlistUUID = res.body.videoPlaylist.uuid
}
{
- const res = await createVideoPlaylist({
- url: server.url,
- token: server.accessToken,
- playlistAttrs: {
+ const created = await command.create({
+ attributes: {
displayName: 'private',
privacy: VideoPlaylistPrivacy.PRIVATE
}
})
- privatePlaylistUUID = res.body.videoPlaylist.uuid
+ privatePlaylistUUID = created.uuid
}
})
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 })
+ await makeGetRequest({
+ url: server.url,
+ path: accountPath,
+ expectedStatus: HttpStatusCode.NOT_FOUND_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 })
+ await makeGetRequest({
+ url: server.url,
+ path: accountPath,
+ expectedStatus: HttpStatusCode.NOT_FOUND_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 })
+ 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,
+ expectedStatus: HttpStatusCode.OK_200,
+ token: server.accessToken
+ })
})
})
describe('When listing videos of a playlist', function () {
- const path = '/api/v1/video-playlists'
+ const path = '/api/v1/video-playlists/'
it('Should fail with a bad start pagination', async function () {
- await checkBadStartPagination(server.url, path, server.accessToken)
+ await checkBadStartPagination(server.url, path + playlist.shortUUID + '/videos', server.accessToken)
})
it('Should fail with a bad count pagination', async function () {
- await checkBadCountPagination(server.url, path, server.accessToken)
+ await checkBadCountPagination(server.url, path + playlist.shortUUID + '/videos', server.accessToken)
})
- it('Should fail with a bad filter', async function () {
- await checkBadSortPagination(server.url, path, server.accessToken)
+ it('Should success with the correct parameters', async function () {
+ await makeGetRequest({ url: server.url, path: path + playlist.shortUUID + '/videos', expectedStatus: HttpStatusCode.OK_200 })
})
})
describe('When getting a video playlist', function () {
it('Should fail with a bad id or uuid', async function () {
- await getVideoPlaylist(server.url, 'toto', 400)
+ await command.get({ playlistId: 'toto', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should fail with an unknown playlist', async function () {
- await getVideoPlaylist(server.url, 42, 404)
+ await command.get({ playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_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: {
+ const playlist = await command.create({
+ attributes: {
displayName: 'super playlist',
+ videoChannelId: server.store.channel.id,
privacy: VideoPlaylistPrivacy.UNLISTED
}
})
- const playlist = res.body.videoPlaylist
- await getVideoPlaylist(server.url, playlist.id, 404)
- await getVideoPlaylist(server.url, playlist.uuid, 200)
+ await command.get({ playlistId: playlist.id, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ await command.get({ playlistId: playlist.uuid, expectedStatus: HttpStatusCode.OK_200 })
})
it('Should succeed with the correct params', async function () {
- await getVideoPlaylist(server.url, playlistUUID, 200)
+ await command.get({ playlistId: playlist.uuid, expectedStatus: HttpStatusCode.OK_200 })
})
})
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({
+ const getBase = (
+ attributes?: Partial<VideoPlaylistCreate>,
+ wrapper?: Partial<Parameters<PlaylistsCommand['create']>[0]>
+ ) => {
+ return {
+ attributes: {
displayName: 'display name',
privacy: VideoPlaylistPrivacy.UNLISTED,
thumbnailfile: 'thumbnail.jpg',
- videoChannelId: server.videoChannel.id
- }, playlistAttrs)
- }, wrapper)
+ videoChannelId: server.store.channel.id,
+
+ ...attributes
+ },
+
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+
+ ...wrapper
+ }
}
const getUpdate = (params: any, playlistId: number | string) => {
- return immutableAssign(params, { playlistId: playlistId })
+ return { ...params, playlistId }
}
it('Should fail with an unauthenticated user', async function () {
- const params = getBase({}, { token: null, expectedStatus: 401 })
+ const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
- await createVideoPlaylist(params)
- await updateVideoPlaylist(getUpdate(params, playlistUUID))
+ await command.create(params)
+ await command.update(getUpdate(params, playlist.shortUUID))
})
it('Should fail without displayName', async function () {
const params = getBase({ displayName: undefined })
- await createVideoPlaylist(params)
- await updateVideoPlaylist(getUpdate(params, playlistUUID))
+ await command.create(params)
})
it('Should fail with an incorrect display name', async function () {
const params = getBase({ displayName: 's'.repeat(300) })
- await createVideoPlaylist(params)
- await updateVideoPlaylist(getUpdate(params, playlistUUID))
+ await command.create(params)
+ await command.update(getUpdate(params, playlist.shortUUID))
})
it('Should fail with an incorrect description', async function () {
const params = getBase({ description: 't' })
- await createVideoPlaylist(params)
- await updateVideoPlaylist(getUpdate(params, playlistUUID))
+ await command.create(params)
+ await command.update(getUpdate(params, playlist.shortUUID))
})
it('Should fail with an incorrect privacy', async function () {
- const params = getBase({ privacy: 45 })
+ const params = getBase({ privacy: 45 as any })
- await createVideoPlaylist(params)
- await updateVideoPlaylist(getUpdate(params, playlistUUID))
+ await command.create(params)
+ await command.update(getUpdate(params, playlist.shortUUID))
})
it('Should fail with an unknown video channel id', async function () {
- const params = getBase({ videoChannelId: 42 }, { expectedStatus: 404 })
+ const params = getBase({ videoChannelId: 42 }, { expectedStatus: HttpStatusCode.NOT_FOUND_404 })
- await createVideoPlaylist(params)
- await updateVideoPlaylist(getUpdate(params, playlistUUID))
+ await command.create(params)
+ await command.update(getUpdate(params, playlist.shortUUID))
})
it('Should fail with an incorrect thumbnail file', async function () {
- const params = getBase({ thumbnailfile: 'avatar.png' })
+ const params = getBase({ thumbnailfile: 'video_short.mp4' })
+
+ await command.create(params)
+ await command.update(getUpdate(params, playlist.shortUUID))
+ })
- await createVideoPlaylist(params)
- await updateVideoPlaylist(getUpdate(params, playlistUUID))
+ it('Should fail with a thumbnail file too big', async function () {
+ const params = getBase({ thumbnailfile: 'preview-big.png' })
+
+ await command.create(params)
+ await command.update(getUpdate(params, playlist.shortUUID))
})
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' })
+ const params2 = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: 'null' as any })
+ const params3 = getBase({ privacy: undefined, videoChannelId: 'null' as any })
- await createVideoPlaylist(params)
- await createVideoPlaylist(params2)
- await updateVideoPlaylist(getUpdate(params, privatePlaylistUUID))
- await updateVideoPlaylist(getUpdate(params2, playlistUUID))
- await updateVideoPlaylist(getUpdate(params3, playlistUUID))
+ 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))
})
it('Should fail with an unknown playlist to update', async function () {
- await updateVideoPlaylist(getUpdate(
- getBase({}, { expectedStatus: 404 }),
+ await command.update(getUpdate(
+ getBase({}, { expectedStatus: HttpStatusCode.NOT_FOUND_404 }),
42
))
})
it('Should fail to update a playlist of another user', async function () {
- await updateVideoPlaylist(getUpdate(
- getBase({}, { token: userAccessToken, expectedStatus: 403 }),
- playlistUUID
+ await command.update(getUpdate(
+ getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 }),
+ playlist.shortUUID
))
})
- it('Should fail to update to private a public/unlisted playlist', async function () {
- const params = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC }, { expectedStatus: 200 })
-
- const res = await createVideoPlaylist(params)
- const playlist = res.body.videoPlaylist
-
- const paramsUpdate = getBase({ privacy: VideoPlaylistPrivacy.PRIVATE }, { expectedStatus: 400 })
-
- await updateVideoPlaylist(getUpdate(paramsUpdate, playlist.id))
- })
-
it('Should fail to update the watch later playlist', async function () {
- await updateVideoPlaylist(getUpdate(
- getBase({}, { expectedStatus: 400 }),
+ await command.update(getUpdate(
+ getBase({}, { expectedStatus: HttpStatusCode.BAD_REQUEST_400 }),
watchLaterPlaylistId
))
})
it('Should succeed with the correct params', async function () {
{
- const params = getBase({}, { expectedStatus: 200 })
- await createVideoPlaylist(params)
+ const params = getBase({}, { expectedStatus: HttpStatusCode.OK_200 })
+ await command.create(params)
}
{
- const params = getBase({}, { expectedStatus: 204 })
- await updateVideoPlaylist(getUpdate(params, playlistUUID))
+ const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
+ await command.update(getUpdate(params, playlist.shortUUID))
}
})
})
describe('When adding an element in a playlist', function () {
- const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
- return Object.assign({
- expectedStatus: 400,
- url: server.url,
- token: server.accessToken,
- playlistId: playlistUUID,
- elementAttrs: Object.assign({
- videoId: videoId,
+ const getBase = (
+ attributes?: Partial<VideoPlaylistElementCreate>,
+ wrapper?: Partial<Parameters<PlaylistsCommand['addElement']>[0]>
+ ) => {
+ return {
+ attributes: {
+ videoId,
startTimestamp: 2,
- stopTimestamp: 3
- }, elementAttrs)
- }, wrapper)
+ stopTimestamp: 3,
+
+ ...attributes
+ },
+
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+ playlistId: playlist.id,
+
+ ...wrapper
+ }
}
it('Should fail with an unauthenticated user', async function () {
- const params = getBase({}, { token: null, expectedStatus: 401 })
- await addVideoInPlaylist(params)
+ const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+ await command.addElement(params)
})
it('Should fail with the playlist of another user', async function () {
- const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
- await addVideoInPlaylist(params)
+ const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+ await command.addElement(params)
})
it('Should fail with an unknown or incorrect playlist id', async function () {
{
const params = getBase({}, { playlistId: 'toto' })
- await addVideoInPlaylist(params)
+ await command.addElement(params)
}
{
- const params = getBase({}, { playlistId: 42, expectedStatus: 404 })
- await addVideoInPlaylist(params)
+ const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ await command.addElement(params)
}
})
it('Should fail with an unknown or incorrect video id', async function () {
- const params = getBase({ videoId: 42 }, { expectedStatus: 404 })
- await addVideoInPlaylist(params)
+ const params = getBase({ videoId: 42 }, { expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ await command.addElement(params)
})
it('Should fail with a bad start/stop timestamp', async function () {
{
const params = getBase({ startTimestamp: -42 })
- await addVideoInPlaylist(params)
+ await command.addElement(params)
}
{
const params = getBase({ stopTimestamp: 'toto' as any })
- await addVideoInPlaylist(params)
+ await command.addElement(params)
}
})
it('Succeed with the correct params', async function () {
- const params = getBase({}, { expectedStatus: 200 })
- await addVideoInPlaylist(params)
- })
-
- it('Should fail if the video was already added in the playlist', async function () {
- const params = getBase({}, { expectedStatus: 409 })
- await addVideoInPlaylist(params)
+ const params = getBase({}, { expectedStatus: HttpStatusCode.OK_200 })
+ const created = await command.addElement(params)
+ elementId = created.id
})
})
describe('When updating an element in a playlist', function () {
- const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
- return Object.assign({
- url: server.url,
- token: server.accessToken,
- elementAttrs: Object.assign({
+ const getBase = (
+ attributes?: Partial<VideoPlaylistElementUpdate>,
+ wrapper?: Partial<Parameters<PlaylistsCommand['updateElement']>[0]>
+ ) => {
+ return {
+ attributes: {
startTimestamp: 1,
- stopTimestamp: 2
- }, elementAttrs),
- videoId: videoId,
- playlistId: playlistUUID,
- expectedStatus: 400
- }, wrapper)
+ stopTimestamp: 2,
+
+ ...attributes
+ },
+
+ elementId,
+ playlistId: playlist.id,
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+
+ ...wrapper
+ }
}
it('Should fail with an unauthenticated user', async function () {
- const params = getBase({}, { token: null, expectedStatus: 401 })
- await updateVideoPlaylistElement(params)
+ const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+ await command.updateElement(params)
})
it('Should fail with the playlist of another user', async function () {
- const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
- await updateVideoPlaylistElement(params)
+ const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+ await command.updateElement(params)
})
it('Should fail with an unknown or incorrect playlist id', async function () {
{
const params = getBase({}, { playlistId: 'toto' })
- await updateVideoPlaylistElement(params)
+ await command.updateElement(params)
}
{
- const params = getBase({}, { playlistId: 42, expectedStatus: 404 })
- await updateVideoPlaylistElement(params)
+ const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ await command.updateElement(params)
}
})
- it('Should fail with an unknown or incorrect video id', async function () {
+ it('Should fail with an unknown or incorrect playlistElement id', async function () {
{
- const params = getBase({}, { videoId: 'toto' })
- await updateVideoPlaylistElement(params)
+ const params = getBase({}, { elementId: 'toto' })
+ await command.updateElement(params)
}
{
- const params = getBase({}, { videoId: 42, expectedStatus: 404 })
- await updateVideoPlaylistElement(params)
+ const params = getBase({}, { elementId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ await command.updateElement(params)
}
})
it('Should fail with a bad start/stop timestamp', async function () {
{
const params = getBase({ startTimestamp: 'toto' as any })
- await updateVideoPlaylistElement(params)
+ await command.updateElement(params)
}
{
const params = getBase({ stopTimestamp: -42 })
- await updateVideoPlaylistElement(params)
+ await command.updateElement(params)
}
})
it('Should fail with an unknown element', async function () {
- const params = getBase({}, { videoId: videoId2, expectedStatus: 404 })
- await updateVideoPlaylistElement(params)
+ const params = getBase({}, { elementId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ await command.updateElement(params)
})
it('Succeed with the correct params', async function () {
- const params = getBase({}, { expectedStatus: 204 })
- await updateVideoPlaylistElement(params)
+ const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
+ await command.updateElement(params)
})
})
let videoId3: number
let videoId4: number
- const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
- return Object.assign({
- url: server.url,
- token: server.accessToken,
- playlistId: playlistUUID,
- elementAttrs: Object.assign({
+ const getBase = (
+ attributes?: Partial<VideoPlaylistReorder>,
+ wrapper?: Partial<Parameters<PlaylistsCommand['reorderElements']>[0]>
+ ) => {
+ return {
+ attributes: {
startPosition: 1,
insertAfterPosition: 2,
- reorderLength: 3
- }, elementAttrs),
- expectedStatus: 400
- }, wrapper)
+ reorderLength: 3,
+
+ ...attributes
+ },
+
+ playlistId: playlist.shortUUID,
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+
+ ...wrapper
+ }
}
before(async function () {
- videoId3 = (await uploadVideoAndGetId({ server, videoName: 'video 3' })).id
- videoId4 = (await uploadVideoAndGetId({ server, videoName: 'video 4' })).id
+ videoId3 = (await server.videos.quickUpload({ name: 'video 3' })).id
+ videoId4 = (await server.videos.quickUpload({ name: 'video 4' })).id
- for (let id of [ videoId3, videoId4 ]) {
- await addVideoInPlaylist({
- url: server.url,
- token: server.accessToken,
- playlistId: playlistUUID,
- elementAttrs: { videoId: id }
- })
+ for (const id of [ videoId3, videoId4 ]) {
+ await command.addElement({ playlistId: playlist.shortUUID, attributes: { videoId: id } })
}
})
it('Should fail with an unauthenticated user', async function () {
- const params = getBase({}, { token: null, expectedStatus: 401 })
- await reorderVideosPlaylist(params)
+ const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+ await command.reorderElements(params)
})
it('Should fail with the playlist of another user', async function () {
- const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
- await reorderVideosPlaylist(params)
+ const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+ await command.reorderElements(params)
})
it('Should fail with an invalid playlist', async function () {
{
const params = getBase({}, { playlistId: 'toto' })
- await reorderVideosPlaylist(params)
+ await command.reorderElements(params)
}
{
- const params = getBase({}, { playlistId: 42, expectedStatus: 404 })
- await reorderVideosPlaylist(params)
+ const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ await command.reorderElements(params)
}
})
it('Should fail with an invalid start position', async function () {
{
const params = getBase({ startPosition: -1 })
- await reorderVideosPlaylist(params)
+ await command.reorderElements(params)
}
{
const params = getBase({ startPosition: 'toto' as any })
- await reorderVideosPlaylist(params)
+ await command.reorderElements(params)
}
{
const params = getBase({ startPosition: 42 })
- await reorderVideosPlaylist(params)
+ await command.reorderElements(params)
}
})
it('Should fail with an invalid insert after position', async function () {
{
const params = getBase({ insertAfterPosition: 'toto' as any })
- await reorderVideosPlaylist(params)
+ await command.reorderElements(params)
}
{
const params = getBase({ insertAfterPosition: -2 })
- await reorderVideosPlaylist(params)
+ await command.reorderElements(params)
}
{
const params = getBase({ insertAfterPosition: 42 })
- await reorderVideosPlaylist(params)
+ await command.reorderElements(params)
}
})
it('Should fail with an invalid reorder length', async function () {
{
const params = getBase({ reorderLength: 'toto' as any })
- await reorderVideosPlaylist(params)
+ await command.reorderElements(params)
}
{
const params = getBase({ reorderLength: -2 })
- await reorderVideosPlaylist(params)
+ await command.reorderElements(params)
}
{
const params = getBase({ reorderLength: 42 })
- await reorderVideosPlaylist(params)
+ await command.reorderElements(params)
}
})
it('Succeed with the correct params', async function () {
- const params = getBase({}, { expectedStatus: 204 })
- await reorderVideosPlaylist(params)
+ const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
+ await command.reorderElements(params)
})
})
url: server.url,
path,
query: { videoIds: [ 1, 2 ] },
- statusCodeExpected: 401
+ expectedStatus: HttpStatusCode.UNAUTHORIZED_401
})
})
token: server.accessToken,
path,
query: { videoIds: [ 1, 2 ] },
- statusCodeExpected: 200
+ expectedStatus: HttpStatusCode.OK_200
})
})
})
describe('When deleting an element in a playlist', function () {
- const getBase = (wrapper: any = {}) => {
- return Object.assign({
- url: server.url,
- token: server.accessToken,
- videoId: videoId,
- playlistId: playlistUUID,
- expectedStatus: 400
- }, wrapper)
+ const getBase = (wrapper: Partial<Parameters<PlaylistsCommand['removeElement']>[0]>) => {
+ return {
+ elementId,
+ playlistId: playlist.uuid,
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+
+ ...wrapper
+ }
}
it('Should fail with an unauthenticated user', async function () {
- const params = getBase({ token: null, expectedStatus: 401 })
- await removeVideoFromPlaylist(params)
+ const params = getBase({ token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+ await command.removeElement(params)
})
it('Should fail with the playlist of another user', async function () {
- const params = getBase({ token: userAccessToken, expectedStatus: 403 })
- await removeVideoFromPlaylist(params)
+ const params = getBase({ token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+ await command.removeElement(params)
})
it('Should fail with an unknown or incorrect playlist id', async function () {
{
const params = getBase({ playlistId: 'toto' })
- await removeVideoFromPlaylist(params)
+ await command.removeElement(params)
}
{
- const params = getBase({ playlistId: 42, expectedStatus: 404 })
- await removeVideoFromPlaylist(params)
+ const params = getBase({ playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ await command.removeElement(params)
}
})
it('Should fail with an unknown or incorrect video id', async function () {
{
- const params = getBase({ videoId: 'toto' })
- await removeVideoFromPlaylist(params)
+ const params = getBase({ elementId: 'toto' as any })
+ await command.removeElement(params)
}
{
- const params = getBase({ videoId: 42, expectedStatus: 404 })
- await removeVideoFromPlaylist(params)
+ const params = getBase({ elementId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ await command.removeElement(params)
}
})
it('Should fail with an unknown element', async function () {
- const params = getBase({ videoId: videoId2, expectedStatus: 404 })
- await removeVideoFromPlaylist(params)
+ const params = getBase({ elementId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ await command.removeElement(params)
})
it('Succeed with the correct params', async function () {
- const params = getBase({ expectedStatus: 204 })
- await removeVideoFromPlaylist(params)
+ const params = getBase({ expectedStatus: HttpStatusCode.NO_CONTENT_204 })
+ await command.removeElement(params)
})
})
describe('When deleting a playlist', function () {
it('Should fail with an unknown playlist', async function () {
- await deleteVideoPlaylist(server.url, server.accessToken, 42, 404)
+ await command.delete({ playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
})
it('Should fail with a playlist of another user', async function () {
- await deleteVideoPlaylist(server.url, userAccessToken, playlistUUID, 403)
+ await command.delete({ token: userAccessToken, playlistId: playlist.uuid, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
})
it('Should fail with the watch later playlist', async function () {
- await deleteVideoPlaylist(server.url, server.accessToken, watchLaterPlaylistId, 400)
+ await command.delete({ playlistId: watchLaterPlaylistId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should succeed with the correct params', async function () {
- await deleteVideoPlaylist(server.url, server.accessToken, playlistUUID)
+ await command.delete({ playlistId: playlist.uuid })
})
})
after(async function () {
- killallServers([ server ])
-
- // Keep the logs if the test failed
- if (this['ok']) {
- await flushTests()
- }
+ await cleanupTests([ server ])
})
})
projects / github / Chocobozzz / PeerTube.git / blobdiff