1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
4 import { omit } from 'lodash'
5 import { buildAbsoluteFixturePath } from '@shared/core-utils'
6 import { HttpStatusCode, LiveVideoLatencyMode, VideoCreateResult, VideoPrivacy } from '@shared/models'
15 setAccessTokensToServers,
17 } from '@shared/server-commands'
19 describe('Test video lives API validator', function () {
20 const path = '/api/v1/videos/live'
21 let server: PeerTubeServer
22 let userAccessToken = ''
24 let video: VideoCreateResult
25 let videoIdNotLive: number
26 let command: LiveCommand
28 // ---------------------------------------------------------------
30 before(async function () {
33 server = await createSingleServer(1)
35 await setAccessTokensToServers([ server ])
37 await server.config.updateCustomSubConfig({
51 const username = 'user1'
52 const password = 'my super password'
53 await server.users.create({ username: username, password: password })
54 userAccessToken = await server.login.getAccessToken({ username, password })
57 const { videoChannels } = await server.users.getMyInfo()
58 channelId = videoChannels[0].id
62 videoIdNotLive = (await server.videos.quickUpload({ name: 'not live' })).id
68 describe('When creating a live', function () {
73 name: 'my super name',
78 commentsEnabled: true,
79 downloadEnabled: true,
80 waitTranscoding: true,
81 description: 'my super description',
82 support: 'my super support text',
83 tags: [ 'tag1', 'tag2' ],
84 privacy: VideoPrivacy.PUBLIC,
88 latencyMode: LiveVideoLatencyMode.DEFAULT
92 it('Should fail with nothing', async function () {
94 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
97 it('Should fail with a long name', async function () {
98 const fields = { ...baseCorrectParams, name: 'super'.repeat(65) }
100 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
103 it('Should fail with a bad category', async function () {
104 const fields = { ...baseCorrectParams, category: 125 }
106 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
109 it('Should fail with a bad licence', async function () {
110 const fields = { ...baseCorrectParams, licence: 125 }
112 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
115 it('Should fail with a bad language', async function () {
116 const fields = { ...baseCorrectParams, language: 'a'.repeat(15) }
118 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
121 it('Should fail with a long description', async function () {
122 const fields = { ...baseCorrectParams, description: 'super'.repeat(2500) }
124 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
127 it('Should fail with a long support text', async function () {
128 const fields = { ...baseCorrectParams, support: 'super'.repeat(201) }
130 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
133 it('Should fail without a channel', async function () {
134 const fields = omit(baseCorrectParams, 'channelId')
136 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
139 it('Should fail with a bad channel', async function () {
140 const fields = { ...baseCorrectParams, channelId: 545454 }
142 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
145 it('Should fail with another user channel', async function () {
148 password: 'fake_password'
150 await server.users.create({ username: user.username, password: user.password })
152 const accessTokenUser = await server.login.getAccessToken(user)
153 const { videoChannels } = await server.users.getMyInfo({ token: accessTokenUser })
154 const customChannelId = videoChannels[0].id
156 const fields = { ...baseCorrectParams, channelId: customChannelId }
158 await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields })
161 it('Should fail with too many tags', async function () {
162 const fields = { ...baseCorrectParams, tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] }
164 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
167 it('Should fail with a tag length too low', async function () {
168 const fields = { ...baseCorrectParams, tags: [ 'tag1', 't' ] }
170 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
173 it('Should fail with a tag length too big', async function () {
174 const fields = { ...baseCorrectParams, tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] }
176 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
179 it('Should fail with an incorrect thumbnail file', async function () {
180 const fields = baseCorrectParams
182 thumbnailfile: buildAbsoluteFixturePath('video_short.mp4')
185 await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
188 it('Should fail with a big thumbnail file', async function () {
189 const fields = baseCorrectParams
191 thumbnailfile: buildAbsoluteFixturePath('preview-big.png')
194 await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
197 it('Should fail with an incorrect preview file', async function () {
198 const fields = baseCorrectParams
200 previewfile: buildAbsoluteFixturePath('video_short.mp4')
203 await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
206 it('Should fail with a big preview file', async function () {
207 const fields = baseCorrectParams
209 previewfile: buildAbsoluteFixturePath('preview-big.png')
212 await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
215 it('Should fail with save replay and permanent live set to true', async function () {
216 const fields = { ...baseCorrectParams, saveReplay: true, permanentLive: true }
218 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
221 it('Should fail with bad latency setting', async function () {
222 const fields = { ...baseCorrectParams, latencyMode: 42 }
224 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
227 it('Should fail to set latency if the server does not allow it', async function () {
228 const fields = { ...baseCorrectParams, latencyMode: LiveVideoLatencyMode.HIGH_LATENCY }
230 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
233 it('Should succeed with the correct parameters', async function () {
236 const res = await makePostBodyRequest({
239 token: server.accessToken,
240 fields: baseCorrectParams,
241 expectedStatus: HttpStatusCode.OK_200
244 video = res.body.video
247 it('Should forbid if live is disabled', async function () {
248 await server.config.updateCustomSubConfig({
256 await makePostBodyRequest({
259 token: server.accessToken,
260 fields: baseCorrectParams,
261 expectedStatus: HttpStatusCode.FORBIDDEN_403
265 it('Should forbid to save replay if not enabled by the admin', async function () {
266 const fields = { ...baseCorrectParams, saveReplay: true }
268 await server.config.updateCustomSubConfig({
277 await makePostBodyRequest({
280 token: server.accessToken,
282 expectedStatus: HttpStatusCode.FORBIDDEN_403
286 it('Should allow to save replay if enabled by the admin', async function () {
287 const fields = { ...baseCorrectParams, saveReplay: true }
289 await server.config.updateCustomSubConfig({
298 await makePostBodyRequest({
301 token: server.accessToken,
303 expectedStatus: HttpStatusCode.OK_200
307 it('Should not allow live if max instance lives is reached', async function () {
308 await server.config.updateCustomSubConfig({
317 await makePostBodyRequest({
320 token: server.accessToken,
321 fields: baseCorrectParams,
322 expectedStatus: HttpStatusCode.FORBIDDEN_403
326 it('Should not allow live if max user lives is reached', async function () {
327 await server.config.updateCustomSubConfig({
331 maxInstanceLives: 20,
337 await makePostBodyRequest({
340 token: server.accessToken,
341 fields: baseCorrectParams,
342 expectedStatus: HttpStatusCode.FORBIDDEN_403
347 describe('When getting live information', function () {
349 it('Should fail without access token', async function () {
350 await command.get({ token: '', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
353 it('Should fail with a bad access token', async function () {
354 await command.get({ token: 'toto', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
357 it('Should fail with access token of another user', async function () {
358 await command.get({ token: userAccessToken, videoId: video.id, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
361 it('Should fail with a bad video id', async function () {
362 await command.get({ videoId: 'toto', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
365 it('Should fail with an unknown video id', async function () {
366 await command.get({ videoId: 454555, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
369 it('Should fail with a non live video', async function () {
370 await command.get({ videoId: videoIdNotLive, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
373 it('Should succeed with the correct params', async function () {
374 await command.get({ videoId: video.id })
375 await command.get({ videoId: video.uuid })
376 await command.get({ videoId: video.shortUUID })
380 describe('When updating live information', async function () {
382 it('Should fail without access token', async function () {
383 await command.update({ token: '', videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
386 it('Should fail with a bad access token', async function () {
387 await command.update({ token: 'toto', videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
390 it('Should fail with access token of another user', async function () {
391 await command.update({ token: userAccessToken, videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
394 it('Should fail with a bad video id', async function () {
395 await command.update({ videoId: 'toto', fields: {}, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
398 it('Should fail with an unknown video id', async function () {
399 await command.update({ videoId: 454555, fields: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
402 it('Should fail with a non live video', async function () {
403 await command.update({ videoId: videoIdNotLive, fields: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
406 it('Should fail with save replay and permanent live set to true', async function () {
407 const fields = { saveReplay: true, permanentLive: true }
409 await command.update({ videoId: video.id, fields, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
412 it('Should fail with bad latency setting', async function () {
413 const fields = { latencyMode: 42 }
415 await command.update({ videoId: video.id, fields, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
418 it('Should fail to set latency if the server does not allow it', async function () {
419 const fields = { latencyMode: LiveVideoLatencyMode.HIGH_LATENCY }
421 await command.update({ videoId: video.id, fields, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
424 it('Should succeed with the correct params', async function () {
425 await command.update({ videoId: video.id, fields: { saveReplay: false } })
426 await command.update({ videoId: video.uuid, fields: { saveReplay: false } })
427 await command.update({ videoId: video.shortUUID, fields: { saveReplay: false } })
430 it('Should fail to update replay status if replay is not allowed on the instance', async function () {
431 await server.config.updateCustomSubConfig({
440 await command.update({ videoId: video.id, fields: { saveReplay: true }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
443 it('Should fail to update a live if it has already started', async function () {
446 const live = await command.get({ videoId: video.id })
448 const ffmpegCommand = sendRTMPStream({ rtmpBaseUrl: live.rtmpUrl, streamKey: live.streamKey })
450 await command.waitUntilPublished({ videoId: video.id })
451 await command.update({ videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
453 await stopFfmpeg(ffmpegCommand)
456 it('Should fail to stream twice in the save live', async function () {
459 const live = await command.get({ videoId: video.id })
461 const ffmpegCommand = sendRTMPStream({ rtmpBaseUrl: live.rtmpUrl, streamKey: live.streamKey })
463 await command.waitUntilPublished({ videoId: video.id })
465 await command.runAndTestStreamError({ videoId: video.id, shouldHaveError: true })
467 await stopFfmpeg(ffmpegCommand)
471 after(async function () {
472 await cleanupTests([ server ])