Add check params live tests

4 files changed, 414 insertions, 0 deletions

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 ])
+  })
+})