-/* tslint:disable:no-unused-expression */
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
import 'mocha'
import {
- createUser,
+ addVideoInPlaylist,
+ cleanupTests,
createVideoPlaylist,
deleteVideoPlaylist,
- flushTests,
+ flushAndRunServer,
+ generateUserAccessToken,
+ getAccountPlaylistsListWithToken,
getVideoPlaylist,
immutableAssign,
- killallServers,
makeGetRequest,
- runServer,
+ removeVideoFromPlaylist,
+ reorderVideosPlaylist,
ServerInfo,
setAccessTokensToServers,
+ setDefaultVideoChannel,
updateVideoPlaylist,
- userLogin,
- addVideoInPlaylist, uploadVideo, updateVideoPlaylistElement, removeVideoFromPlaylist, reorderVideosPlaylist
-} from '../../../../shared/utils'
+ updateVideoPlaylistElement,
+ uploadVideoAndGetId
+} from '../../../../shared/extra-utils'
import {
checkBadCountPagination,
checkBadSortPagination,
checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
+} from '../../../../shared/extra-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 privatePlaylistUUID: string
+ let watchLaterPlaylistId: number
let videoId: number
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
let videoId2: number
+ let playlistElementId: number
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
- await flushTests()
-
- server = await runServer(1)
+ server = await flushAndRunServer(1)
await setAccessTokensToServers([ server ])
+ await setDefaultVideoChannel([ 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 getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root', 0, 5, VideoPlaylistType.WATCH_LATER)
+ watchLaterPlaylistId = res.body.data[0].id
}
{
- const res = await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
- videoId2 = res.body.video.id
+ const res = await createVideoPlaylist({
+ url: server.url,
+ token: server.accessToken,
+ playlistAttrs: {
+ displayName: 'super playlist',
+ privacy: VideoPlaylistPrivacy.PUBLIC,
+ videoChannelId: server.videoChannel.id
+ }
+ })
+ playlistUUID = res.body.videoPlaylist.uuid
}
{
url: server.url,
token: server.accessToken,
playlistAttrs: {
- displayName: 'super playlist',
- privacy: VideoPlaylistPrivacy.PUBLIC
+ displayName: 'private',
+ privacy: VideoPlaylistPrivacy.PRIVATE
}
})
- playlistUUID = res.body.videoPlaylist.uuid
+ privatePlaylistUUID = res.body.videoPlaylist.uuid
}
})
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'
})
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 + playlistUUID + '/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 + playlistUUID + '/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 + playlistUUID + '/videos', statusCodeExpected: 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({
+ displayName: 'display name',
+ privacy: VideoPlaylistPrivacy.UNLISTED,
+ thumbnailfile: 'thumbnail.jpg',
+ videoChannelId: server.videoChannel.id
+ }, 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)
})
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(params)
+ await updateVideoPlaylist(getUpdate(params, playlistUUID))
+ })
+
+ 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(baseParams)
- await updateVideoPlaylist(immutableAssign(baseParams, { playlistId: playlistUUID }))
+ await createVideoPlaylist(params)
+ await createVideoPlaylist(params2)
+ await updateVideoPlaylist(getUpdate(params, privatePlaylistUUID))
+ await updateVideoPlaylist(getUpdate(params2, playlistUUID))
+ await updateVideoPlaylist(getUpdate(params3, 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 playlist = res.body.videoPlaylist
-
- await updateVideoPlaylist({
- url: server.url,
- token: server.accessToken,
- playlistId: playlist.id,
- playlistAttrs: {
- displayName: 'display name',
- privacy: VideoPlaylistPrivacy.PRIVATE
- },
- expectedStatus: 409
- })
+ it('Should fail to update the watch later playlist', async function () {
+ await updateVideoPlaylist(getUpdate(
+ getBase({}, { expectedStatus: 400 }),
+ 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,
+ 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 })
+ const res = await addVideoInPlaylist(params)
+ playlistElementId = res.body.videoPlaylistElement.id
})
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: { },
- videoId: videoId,
+ token: server.accessToken,
+ elementAttrs: Object.assign({
+ startTimestamp: 1,
+ stopTimestamp: 2
+ }, elementAttrs),
+ playlistElementId,
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
- })
+ it('Should fail with an unknown or incorrect playlistElement id', async function () {
+ {
+ const params = getBase({}, { playlistElementId: 'toto' })
+ await updateVideoPlaylistElement(params)
+ }
- await updateVideoPlaylistElement({
- url: server.url,
- token: server.accessToken,
- elementAttrs: { },
- videoId: 42,
- playlistId: playlistUUID,
- expectedStatus: 404
- })
+ {
+ const params = getBase({}, { playlistElementId: 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({}, { playlistElementId: 888, 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)
})
})
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 (const 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)
+ }
+
+ {
+ const params = getBase({ insertAfterPosition: 42 })
+ await reorderVideosPlaylist(params)
+ }
+ })
+
+ it('Should fail with an invalid reorder length', async function () {
+ {
+ const params = getBase({ reorderLength: 'toto' as any })
+ await reorderVideosPlaylist(params)
+ }
+
+ {
+ const params = getBase({ reorderLength: -2 })
+ await reorderVideosPlaylist(params)
+ }
+
+ {
+ const params = getBase({ reorderLength: 42 })
+ await reorderVideosPlaylist(params)
+ }
+ })
+
+ it('Succeed with the correct params', async function () {
+ const params = getBase({}, { expectedStatus: 204 })
+ await reorderVideosPlaylist(params)
+ })
+ })
- await reorderVideosPlaylist({
+ 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,
- token: server.accessToken,
- playlistId: playlistUUID,
- elementAttrs: {
- startPosition: 1,
- insertAfterPosition: 42
- },
- expectedStatus: 400
+ path,
+ query: { videoIds: [ 1, 2 ] },
+ statusCodeExpected: 401
})
})
- it('Should fail with an invalid reorder length', async function () {
- await reorderVideosPlaylist({
+ it('Should fail with invalid video ids', async function () {
+ await makeGetRequest({
url: server.url,
token: server.accessToken,
- playlistId: playlistUUID,
- elementAttrs: {
- startPosition: 1,
- insertAfterPosition: 2,
- reorderLength: 'toto' as any
- },
- expectedStatus: 400
+ path,
+ query: { videoIds: 'toto' }
})
- await reorderVideosPlaylist({
+ await makeGetRequest({
url: server.url,
token: server.accessToken,
- playlistId: playlistUUID,
- elementAttrs: {
- startPosition: 1,
- insertAfterPosition: 2,
- reorderLength: -1
- },
- expectedStatus: 400
+ path,
+ query: { videoIds: [ 'toto' ] }
})
- await reorderVideosPlaylist({
+ await makeGetRequest({
url: server.url,
token: server.accessToken,
- playlistId: playlistUUID,
- elementAttrs: {
- startPosition: 1,
- insertAfterPosition: 2,
- reorderLength: 4
- },
- expectedStatus: 400
+ path,
+ query: { videoIds: [ 1, 'toto' ] }
})
})
- it('Succeed with the correct params', async function () {
- await reorderVideosPlaylist({
+ it('Should succeed with the correct params', async function () {
+ await makeGetRequest({
url: server.url,
token: server.accessToken,
- playlistId: playlistUUID,
- elementAttrs: {
- startPosition: 1,
- insertAfterPosition: 2,
- reorderLength: 3
- },
- expectedStatus: 204
+ path,
+ query: { videoIds: [ 1, 2 ] },
+ statusCodeExpected: 200
})
})
})
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,
+ playlistElementId,
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({ playlistElementId: 'toto' })
+ await removeVideoFromPlaylist(params)
+ }
- await removeVideoFromPlaylist({
- url: server.url,
- token: server.accessToken,
- videoId: 42,
- playlistId: playlistUUID,
- expectedStatus: 404
- })
+ {
+ const params = getBase({ playlistElementId: 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({ playlistElementId: 888, 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)
})
})
await deleteVideoPlaylist(server.url, userAccessToken, playlistUUID, 403)
})
+ it('Should fail with the watch later playlist', async function () {
+ await deleteVideoPlaylist(server.url, server.accessToken, watchLaterPlaylistId, 400)
+ })
+
it('Should succeed with the correct params', async function () {
await deleteVideoPlaylist(server.url, server.accessToken, playlistUUID)
})
})
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