From 77e9f859c6ad75ba179dec74e5410cc651eaa49b Mon Sep 17 00:00:00 2001 From: Chocobozzz Date: Fri, 30 Oct 2020 15:09:00 +0100 Subject: [PATCH] Add check params live tests --- config/test-1.yaml | 4 + server/helpers/ffmpeg-utils.ts | 1 + server/lib/live-manager.ts | 2 + server/tests/api/check-params/index.ts | 1 + server/tests/api/check-params/live.ts | 410 +++++++++++++++++++++ shared/extra-utils/index.ts | 3 +- shared/extra-utils/requests/requests.ts | 4 +- shared/extra-utils/videos/live.ts | 102 +++++ shared/models/videos/video-create.model.ts | 3 + 9 files changed, 527 insertions(+), 3 deletions(-) create mode 100644 server/tests/api/check-params/live.ts create mode 100644 shared/extra-utils/videos/live.ts diff --git a/config/test-1.yaml b/config/test-1.yaml index 2ef9e6c7c..fe5b3cf44 100644 --- a/config/test-1.yaml +++ b/config/test-1.yaml @@ -35,3 +35,7 @@ signup: transcoding: enabled: false + +live: + rtmp: + port: 1936 diff --git a/server/helpers/ffmpeg-utils.ts b/server/helpers/ffmpeg-utils.ts index b985988d3..268ed7624 100644 --- a/server/helpers/ffmpeg-utils.ts +++ b/server/helpers/ffmpeg-utils.ts @@ -385,6 +385,7 @@ function runLiveTranscoding (rtmpUrl: string, outPath: string, resolutions: numb command.outputOption('-level 3.1') command.outputOption('-map_metadata -1') command.outputOption('-pix_fmt yuv420p') + command.outputOption('-max_muxing_queue_size 1024') for (let i = 0; i < resolutions.length; i++) { const resolution = resolutions[i] diff --git a/server/lib/live-manager.ts b/server/lib/live-manager.ts index fd9a859f9..e115d2d50 100644 --- a/server/lib/live-manager.ts +++ b/server/lib/live-manager.ts @@ -322,6 +322,8 @@ class LiveManager { if (err?.message?.includes('SIGINT')) return logger.error('Live transcoding error.', { err, stdout, stderr }) + + this.abortSession(sessionId) }) ffmpegExec.on('end', () => onFFmpegEnded()) diff --git a/server/tests/api/check-params/index.ts b/server/tests/api/check-params/index.ts index 0ee1f27aa..b5f0d07be 100644 --- a/server/tests/api/check-params/index.ts +++ b/server/tests/api/check-params/index.ts @@ -8,6 +8,7 @@ import './debug' import './follows' import './jobs' import './logs' +import './live' import './plugins' import './redundancy' import './search' diff --git a/server/tests/api/check-params/live.ts b/server/tests/api/check-params/live.ts new file mode 100644 index 000000000..4134fca0c --- /dev/null +++ b/server/tests/api/check-params/live.ts @@ -0,0 +1,410 @@ +/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ + +import 'mocha' +import * as chai from 'chai' +import { omit } from 'lodash' +import { join } from 'path' +import { LiveVideo, VideoPrivacy } from '@shared/models' +import { + cleanupTests, + createUser, + flushAndRunServer, + getLive, + getMyUserInformation, + immutableAssign, + makePostBodyRequest, + makeUploadRequest, + sendRTMPStream, + ServerInfo, + setAccessTokensToServers, + stopFfmpeg, + updateCustomSubConfig, + updateLive, + uploadVideoAndGetId, + userLogin, + waitUntilLiveStarts +} from '../../../../shared/extra-utils' + +describe('Test video lives API validator', function () { + const path = '/api/v1/videos/live' + let server: ServerInfo + let userAccessToken = '' + let accountName: string + let channelId: number + let channelName: string + let videoId: number + let videoIdNotLive: number + + // --------------------------------------------------------------- + + before(async function () { + this.timeout(30000) + + server = await flushAndRunServer(1) + + await setAccessTokensToServers([ server ]) + + await updateCustomSubConfig(server.url, server.accessToken, { + live: { + enabled: true, + maxInstanceLives: 20, + maxUserLives: 20, + allowReplay: true + } + }) + + const username = 'user1' + const password = 'my super password' + await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password }) + userAccessToken = await userLogin(server, { username, password }) + + { + const res = await getMyUserInformation(server.url, server.accessToken) + channelId = res.body.videoChannels[0].id + } + + { + videoIdNotLive = (await uploadVideoAndGetId({ server, videoName: 'not live' })).id + } + }) + + describe('When creating a live', function () { + let baseCorrectParams + + before(function () { + baseCorrectParams = { + name: 'my super name', + category: 5, + licence: 1, + language: 'pt', + nsfw: false, + commentsEnabled: true, + downloadEnabled: true, + waitTranscoding: true, + description: 'my super description', + support: 'my super support text', + tags: [ 'tag1', 'tag2' ], + privacy: VideoPrivacy.PUBLIC, + channelId, + saveReplay: false + } + }) + + it('Should fail with nothing', async function () { + const fields = {} + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with a long name', async function () { + const fields = immutableAssign(baseCorrectParams, { name: 'super'.repeat(65) }) + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with a bad category', async function () { + const fields = immutableAssign(baseCorrectParams, { category: 125 }) + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with a bad licence', async function () { + const fields = immutableAssign(baseCorrectParams, { licence: 125 }) + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with a bad language', async function () { + const fields = immutableAssign(baseCorrectParams, { language: 'a'.repeat(15) }) + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with a long description', async function () { + const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(2500) }) + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with a long support text', async function () { + const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) }) + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail without a channel', async function () { + const fields = omit(baseCorrectParams, 'channelId') + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with a bad channel', async function () { + const fields = immutableAssign(baseCorrectParams, { channelId: 545454 }) + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with another user channel', async function () { + const user = { + username: 'fake', + password: 'fake_password' + } + await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password }) + + const accessTokenUser = await userLogin(server, user) + const res = await getMyUserInformation(server.url, accessTokenUser) + const customChannelId = res.body.videoChannels[0].id + + const fields = immutableAssign(baseCorrectParams, { channelId: customChannelId }) + + await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields }) + }) + + it('Should fail with too many tags', async function () { + const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] }) + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with a tag length too low', async function () { + const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 't' ] }) + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with a tag length too big', async function () { + const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] }) + + await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) + }) + + it('Should fail with an incorrect thumbnail file', async function () { + const fields = baseCorrectParams + const attaches = { + thumbnailfile: join(__dirname, '..', '..', 'fixtures', 'avatar.png') + } + + await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches }) + }) + + it('Should fail with a big thumbnail file', async function () { + const fields = baseCorrectParams + const attaches = { + thumbnailfile: join(__dirname, '..', '..', 'fixtures', 'avatar-big.png') + } + + await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches }) + }) + + it('Should fail with an incorrect preview file', async function () { + const fields = baseCorrectParams + const attaches = { + previewfile: join(__dirname, '..', '..', 'fixtures', 'avatar.png') + } + + await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches }) + }) + + it('Should fail with a big preview file', async function () { + const fields = baseCorrectParams + const attaches = { + previewfile: join(__dirname, '..', '..', 'fixtures', 'avatar-big.png') + } + + await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches }) + }) + + it('Should succeed with the correct parameters', async function () { + this.timeout(30000) + + const res = await makePostBodyRequest({ + url: server.url, + path, + token: server.accessToken, + fields: baseCorrectParams, + statusCodeExpected: 200 + }) + + videoId = res.body.video.id + }) + + it('Should forbid if live is disabled', async function () { + await updateCustomSubConfig(server.url, server.accessToken, { + live: { + enabled: false + } + }) + + await makePostBodyRequest({ + url: server.url, + path, + token: server.accessToken, + fields: baseCorrectParams, + statusCodeExpected: 403 + }) + }) + + it('Should forbid to save replay if not enabled by the admin', async function () { + const fields = immutableAssign(baseCorrectParams, { saveReplay: true }) + + await updateCustomSubConfig(server.url, server.accessToken, { + live: { + enabled: true, + allowReplay: false + } + }) + + await makePostBodyRequest({ + url: server.url, + path, + token: server.accessToken, + fields, + statusCodeExpected: 403 + }) + }) + + it('Should allow to save replay if enabled by the admin', async function () { + const fields = immutableAssign(baseCorrectParams, { saveReplay: true }) + + await updateCustomSubConfig(server.url, server.accessToken, { + live: { + enabled: true, + allowReplay: true + } + }) + + await makePostBodyRequest({ + url: server.url, + path, + token: server.accessToken, + fields, + statusCodeExpected: 200 + }) + }) + + it('Should not allow live if max instance lives is reached', async function () { + await updateCustomSubConfig(server.url, server.accessToken, { + live: { + enabled: true, + maxInstanceLives: 1 + } + }) + + await makePostBodyRequest({ + url: server.url, + path, + token: server.accessToken, + fields: baseCorrectParams, + statusCodeExpected: 403 + }) + }) + + it('Should not allow live if max user lives is reached', async function () { + await updateCustomSubConfig(server.url, server.accessToken, { + live: { + enabled: true, + maxInstanceLives: 20, + maxUserLives: 1 + } + }) + + await makePostBodyRequest({ + url: server.url, + path, + token: server.accessToken, + fields: baseCorrectParams, + statusCodeExpected: 403 + }) + }) + }) + + describe('When getting live information', function () { + + it('Should fail without access token', async function () { + await getLive(server.url, '', videoId, 401) + }) + + it('Should fail with a bad access token', async function () { + await getLive(server.url, 'toto', videoId, 401) + }) + + it('Should fail with access token of another user', async function () { + await getLive(server.url, userAccessToken, videoId, 403) + }) + + it('Should fail with a bad video id', async function () { + await getLive(server.url, server.accessToken, 'toto', 400) + }) + + it('Should fail with an unknown video id', async function () { + await getLive(server.url, server.accessToken, 454555, 404) + }) + + it('Should fail with a non live video', async function () { + await getLive(server.url, server.accessToken, videoIdNotLive, 404) + }) + + it('Should succeed with the correct params', async function () { + await getLive(server.url, server.accessToken, videoId) + }) + }) + + describe('When updating live information', async function () { + + it('Should fail without access token', async function () { + await updateLive(server.url, '', videoId, {}, 401) + }) + + it('Should fail with a bad access token', async function () { + await updateLive(server.url, 'toto', videoId, {}, 401) + }) + + it('Should fail with access token of another user', async function () { + await updateLive(server.url, userAccessToken, videoId, {}, 403) + }) + + it('Should fail with a bad video id', async function () { + await updateLive(server.url, server.accessToken, 'toto', {}, 400) + }) + + it('Should fail with an unknown video id', async function () { + await updateLive(server.url, server.accessToken, 454555, {}, 404) + }) + + it('Should fail with a non live video', async function () { + await updateLive(server.url, server.accessToken, videoIdNotLive, {}, 404) + }) + + it('Should succeed with the correct params', async function () { + await updateLive(server.url, server.accessToken, videoId, { saveReplay: false }) + }) + + it('Should fail to update replay status if replay is not allowed on the instance', async function () { + await updateCustomSubConfig(server.url, server.accessToken, { + live: { + enabled: true, + allowReplay: false + } + }) + + await updateLive(server.url, server.accessToken, videoId, { saveReplay: true }, 403) + }) + + it('Should fail to update a live if it has already started', async function () { + this.timeout(20000) + + const resLive = await getLive(server.url, server.accessToken, videoId) + const live: LiveVideo = resLive.body + + const command = sendRTMPStream(live.rtmpUrl, live.streamKey) + + await waitUntilLiveStarts(server.url, server.accessToken, videoId) + await updateLive(server.url, server.accessToken, videoId, {}, 400) + + await stopFfmpeg(command) + }) + }) + + after(async function () { + await cleanupTests([ server ]) + }) +}) diff --git a/shared/extra-utils/index.ts b/shared/extra-utils/index.ts index af4d23856..d118b12d2 100644 --- a/shared/extra-utils/index.ts +++ b/shared/extra-utils/index.ts @@ -13,11 +13,12 @@ export * from './requests/requests' export * from './requests/check-api-params' export * from './server/servers' export * from './server/plugins' -export * from './videos/services' export * from './videos/video-playlists' export * from './users/users' export * from './users/accounts' export * from './moderation/abuses' +export * from './videos/services' +export * from './videos/live' export * from './videos/video-abuses' export * from './videos/video-blacklist' export * from './videos/video-captions' diff --git a/shared/extra-utils/requests/requests.ts b/shared/extra-utils/requests/requests.ts index 0e9d67f0b..6b00871e0 100644 --- a/shared/extra-utils/requests/requests.ts +++ b/shared/extra-utils/requests/requests.ts @@ -63,7 +63,7 @@ function makeUploadRequest (options: { path: string token?: string fields: { [ fieldName: string ]: any } - attaches: { [ attachName: string ]: any | any[] } + attaches?: { [ attachName: string ]: any | any[] } statusCodeExpected?: number }) { if (!options.statusCodeExpected) options.statusCodeExpected = 400 @@ -93,7 +93,7 @@ function makeUploadRequest (options: { } }) - Object.keys(options.attaches).forEach(attach => { + Object.keys(options.attaches || {}).forEach(attach => { const value = options.attaches[attach] if (Array.isArray(value)) { req.attach(attach, buildAbsoluteFixturePath(value[0]), value[1]) diff --git a/shared/extra-utils/videos/live.ts b/shared/extra-utils/videos/live.ts new file mode 100644 index 000000000..f500fdc3e --- /dev/null +++ b/shared/extra-utils/videos/live.ts @@ -0,0 +1,102 @@ +import * as ffmpeg from 'fluent-ffmpeg' +import { LiveVideoCreate, LiveVideoUpdate, VideoDetails, VideoState } from '@shared/models' +import { buildAbsoluteFixturePath, wait } from '../miscs/miscs' +import { makeGetRequest, makePutBodyRequest, makeUploadRequest } from '../requests/requests' +import { ServerInfo } from '../server/servers' +import { getVideo, getVideoWithToken } from './videos' + +function getLive (url: string, token: string, videoId: number | string, statusCodeExpected = 200) { + const path = '/api/v1/videos/live' + + return makeGetRequest({ + url, + token, + path: path + '/' + videoId, + statusCodeExpected + }) +} + +function updateLive (url: string, token: string, videoId: number | string, fields: LiveVideoUpdate, statusCodeExpected = 204) { + const path = '/api/v1/videos/live' + + return makePutBodyRequest({ + url, + token, + path: path + '/' + videoId, + fields, + statusCodeExpected + }) +} + +function createLive (url: string, token: string, fields: LiveVideoCreate, statusCodeExpected = 200) { + const path = '/api/v1/videos/live' + + let attaches: any = {} + if (fields.thumbnailfile) attaches = { thumbnailfile: fields.thumbnailfile } + if (fields.previewfile) attaches = { previewfile: fields.previewfile } + + return makeUploadRequest({ + url, + path, + token, + attaches, + fields, + statusCodeExpected + }) +} + +function sendRTMPStream (rtmpBaseUrl: string, streamKey: string) { + const fixture = buildAbsoluteFixturePath('video_short.mp4') + + const command = ffmpeg(fixture) + command.inputOption('-stream_loop -1') + command.inputOption('-re') + + command.outputOption('-c copy') + command.outputOption('-f flv') + + const rtmpUrl = rtmpBaseUrl + '/' + streamKey + command.output(rtmpUrl) + + command.on('error', err => { + if (err?.message?.includes('Exiting normally')) return + + console.error('Cannot send RTMP stream.', { err }) + }) + + if (process.env.DEBUG) { + command.on('stderr', data => console.log(data)) + } + + command.run() + + return command +} + +async function stopFfmpeg (command: ffmpeg.FfmpegCommand) { + command.kill('SIGINT') + + await wait(500) +} + +async function waitUntilLiveStarts (url: string, token: string, videoId: number | string) { + let video: VideoDetails + + do { + const res = await getVideoWithToken(url, token, videoId) + video = res.body + + await wait(500) + } while (video.state.id === VideoState.WAITING_FOR_LIVE) +} + +// --------------------------------------------------------------------------- + +export { + getLive, + updateLive, + waitUntilLiveStarts, + createLive, + stopFfmpeg, + sendRTMPStream +} diff --git a/shared/models/videos/video-create.model.ts b/shared/models/videos/video-create.model.ts index 59b118567..175327afa 100644 --- a/shared/models/videos/video-create.model.ts +++ b/shared/models/videos/video-create.model.ts @@ -17,4 +17,7 @@ export interface VideoCreate { privacy: VideoPrivacy scheduleUpdate?: VideoScheduleUpdate originallyPublishedAt?: Date | string + + thumbnailfile?: Blob + previewfile?: Blob }