Add check params live tests

9 files changed, 527 insertions, 3 deletions

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
 }