import 'mocha'
import {
addVideoInPlaylist,
+ cleanupTests,
createVideoPlaylist,
deleteVideoPlaylist,
- flushTests,
+ flushAndRunServer,
generateUserAccessToken,
getAccountPlaylistsListWithToken,
getVideoPlaylist,
immutableAssign,
- killallServers,
makeGetRequest,
removeVideoFromPlaylist,
reorderVideosPlaylist,
- runServer,
ServerInfo,
setAccessTokensToServers,
+ setDefaultVideoChannel,
updateVideoPlaylist,
updateVideoPlaylistElement,
uploadVideoAndGetId
-} from '../../../../shared/utils'
+} 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'
let server: ServerInfo
let userAccessToken: string
let playlistUUID: string
+ let privatePlaylistUUID: string
let watchLaterPlaylistId: number
let videoId: number
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 ])
userAccessToken = await generateUserAccessToken(server, 'user1')
videoId = (await uploadVideoAndGetId({ server, videoName: 'video 1' })).id
videoId2 = (await uploadVideoAndGetId({ server, videoName: 'video 2' })).id
{
- const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root',0, 5, VideoPlaylistType.WATCH_LATER)
+ const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root', 0, 5, VideoPlaylistType.WATCH_LATER)
watchLaterPlaylistId = res.body.data[0].id
}
token: server.accessToken,
playlistAttrs: {
displayName: 'super playlist',
- privacy: VideoPlaylistPrivacy.PUBLIC
+ privacy: VideoPlaylistPrivacy.PUBLIC,
+ videoChannelId: server.videoChannel.id
}
})
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
+ }
})
describe('When listing playlists', function () {
})
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 })
})
})
playlistAttrs: Object.assign({
displayName: 'display name',
privacy: VideoPlaylistPrivacy.UNLISTED,
- thumbnailfile: 'thumbnail.jpg'
+ thumbnailfile: 'thumbnail.jpg',
+ videoChannelId: server.videoChannel.id
}, playlistAttrs)
}, wrapper)
}
const params = getBase({ displayName: undefined })
await createVideoPlaylist(params)
- await updateVideoPlaylist(getUpdate(params, playlistUUID))
})
it('Should fail with an incorrect display name', async function () {
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(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(getUpdate(
getBase({}, { expectedStatus: 404 }),
))
})
- 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: 409 })
-
- await updateVideoPlaylist(getUpdate(paramsUpdate, playlist.id))
- })
-
it('Should fail to update the watch later playlist', async function () {
await updateVideoPlaylist(getUpdate(
- getBase({}, { expectedStatus: 409 }),
+ getBase({}, { expectedStatus: 400 }),
watchLaterPlaylistId
))
})
token: server.accessToken,
playlistId: playlistUUID,
elementAttrs: Object.assign({
- videoId: videoId,
+ videoId,
startTimestamp: 2,
stopTimestamp: 3
}, elementAttrs)
it('Succeed with the correct params', async function () {
const params = getBase({}, { expectedStatus: 200 })
- await addVideoInPlaylist(params)
+ const res = await addVideoInPlaylist(params)
+ playlistElementId = res.body.videoPlaylistElement.id
})
it('Should fail if the video was already added in the playlist', async function () {
startTimestamp: 1,
stopTimestamp: 2
}, elementAttrs),
- videoId: videoId,
+ playlistElementId,
playlistId: playlistUUID,
expectedStatus: 400
}, wrapper)
}
})
- 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' })
+ const params = getBase({}, { playlistElementId: 'toto' })
await updateVideoPlaylistElement(params)
}
{
- const params = getBase({}, { videoId: 42, expectedStatus: 404 })
+ const params = getBase({}, { playlistElementId: 42, expectedStatus: 404 })
await updateVideoPlaylistElement(params)
}
})
})
it('Should fail with an unknown element', async function () {
- const params = getBase({}, { videoId: videoId2, expectedStatus: 404 })
+ const params = getBase({}, { playlistElementId: 888, expectedStatus: 404 })
await updateVideoPlaylistElement(params)
})
})
})
+ 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
+ })
+ })
+ })
+
describe('When deleting an element in a playlist', function () {
const getBase = (wrapper: any = {}) => {
return Object.assign({
url: server.url,
token: server.accessToken,
- videoId: videoId,
+ playlistElementId,
playlistId: playlistUUID,
expectedStatus: 400
}, wrapper)
it('Should fail with an unknown or incorrect video id', async function () {
{
- const params = getBase({ videoId: 'toto' })
+ const params = getBase({ playlistElementId: 'toto' })
await removeVideoFromPlaylist(params)
}
{
- const params = getBase({ videoId: 42, expectedStatus: 404 })
+ const params = getBase({ playlistElementId: 42, expectedStatus: 404 })
await removeVideoFromPlaylist(params)
}
})
it('Should fail with an unknown element', async function () {
- const params = getBase({ videoId: videoId2, expectedStatus: 404 })
+ const params = getBase({ playlistElementId: 888, expectedStatus: 404 })
await removeVideoFromPlaylist(params)
})
})
it('Should fail with the watch later playlist', async function () {
- await deleteVideoPlaylist(server.url, server.accessToken, watchLaterPlaylistId, 409)
+ await deleteVideoPlaylist(server.url, server.accessToken, watchLaterPlaylistId, 400)
})
it('Should succeed with the correct params', async function () {
})
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