1 files changed, 36 insertions, 36 deletions

diff --git a/server/tests/api/check-params/live.ts b/server/tests/api/check-params/live.ts
index 7a623c169..56116848f 100644
--- a/server/tests/api/check-params/live.ts
+++ b/server/tests/api/check-params/live.ts
@@ -2,27 +2,24 @@
 
 import 'mocha'
 import { omit } from 'lodash'
-import { LiveVideo, VideoCreateResult, VideoPrivacy } from '@shared/models'
+import { VideoCreateResult, VideoPrivacy } from '@shared/models'
 import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import {
   buildAbsoluteFixturePath,
   cleanupTests,
   createUser,
   flushAndRunServer,
-  getLive,
   getMyUserInformation,
   immutableAssign,
+  LiveCommand,
   makePostBodyRequest,
   makeUploadRequest,
-  runAndTestFfmpegStreamError,
   sendRTMPStream,
   ServerInfo,
   setAccessTokensToServers,
   stopFfmpeg,
-  updateLive,
   uploadVideoAndGetId,
-  userLogin,
-  waitUntilLivePublished
+  userLogin
 } from '../../../../shared/extra-utils'
 
 describe('Test video lives API validator', function () {
@@ -32,6 +29,7 @@ describe('Test video lives API validator', function () {
   let channelId: number
   let video: VideoCreateResult
   let videoIdNotLive: number
+  let command: LiveCommand
 
   // ---------------------------------------------------------------
 
@@ -66,6 +64,8 @@ describe('Test video lives API validator', function () {
     {
       videoIdNotLive = (await uploadVideoAndGetId({ server, videoName: 'not live' })).id
     }
+
+    command = server.liveCommand
   })
 
   describe('When creating a live', function () {
@@ -337,70 +337,72 @@ describe('Test video lives API validator', function () {
   describe('When getting live information', function () {
 
     it('Should fail without access token', async function () {
-      await getLive(server.url, '', video.id, HttpStatusCode.UNAUTHORIZED_401)
+      await command.getLive({ token: '', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a bad access token', async function () {
-      await getLive(server.url, 'toto', video.id, HttpStatusCode.UNAUTHORIZED_401)
+      await command.getLive({ token: 'toto', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with access token of another user', async function () {
-      await getLive(server.url, userAccessToken, video.id, HttpStatusCode.FORBIDDEN_403)
+      await command.getLive({ token: userAccessToken, videoId: video.id, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a bad video id', async function () {
-      await getLive(server.url, server.accessToken, 'toto', HttpStatusCode.BAD_REQUEST_400)
+      await command.getLive({ videoId: 'toto', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with an unknown video id', async function () {
-      await getLive(server.url, server.accessToken, 454555, HttpStatusCode.NOT_FOUND_404)
+      await command.getLive({ videoId: 454555, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a non live video', async function () {
-      await getLive(server.url, server.accessToken, videoIdNotLive, HttpStatusCode.NOT_FOUND_404)
+      await command.getLive({ videoId: videoIdNotLive, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await getLive(server.url, server.accessToken, video.id)
-      await getLive(server.url, server.accessToken, video.shortUUID)
+      await command.getLive({ videoId: video.id })
+      await command.getLive({ videoId: video.uuid })
+      await command.getLive({ videoId: video.shortUUID })
     })
   })
 
   describe('When updating live information', async function () {
 
     it('Should fail without access token', async function () {
-      await updateLive(server.url, '', video.id, {}, HttpStatusCode.UNAUTHORIZED_401)
+      await command.updateLive({ token: '', videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with a bad access token', async function () {
-      await updateLive(server.url, 'toto', video.id, {}, HttpStatusCode.UNAUTHORIZED_401)
+      await command.updateLive({ token: 'toto', videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should fail with access token of another user', async function () {
-      await updateLive(server.url, userAccessToken, video.id, {}, HttpStatusCode.FORBIDDEN_403)
+      await command.updateLive({ token: userAccessToken, videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail with a bad video id', async function () {
-      await updateLive(server.url, server.accessToken, 'toto', {}, HttpStatusCode.BAD_REQUEST_400)
+      await command.updateLive({ videoId: 'toto', fields: {}, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should fail with an unknown video id', async function () {
-      await updateLive(server.url, server.accessToken, 454555, {}, HttpStatusCode.NOT_FOUND_404)
+      await command.updateLive({ videoId: 454555, fields: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with a non live video', async function () {
-      await updateLive(server.url, server.accessToken, videoIdNotLive, {}, HttpStatusCode.NOT_FOUND_404)
+      await command.updateLive({ videoId: videoIdNotLive, fields: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should fail with save replay and permanent live set to true', async function () {
       const fields = { saveReplay: true, permanentLive: true }
 
-      await updateLive(server.url, server.accessToken, video.id, fields, HttpStatusCode.BAD_REQUEST_400)
+      await command.updateLive({ videoId: video.id, fields, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should succeed with the correct params', async function () {
-      await updateLive(server.url, server.accessToken, video.id, { saveReplay: false })
-      await updateLive(server.url, server.accessToken, video.shortUUID, { saveReplay: false })
+      await command.updateLive({ videoId: video.id, fields: { saveReplay: false } })
+      await command.updateLive({ videoId: video.uuid, fields: { saveReplay: false } })
+      await command.updateLive({ videoId: video.shortUUID, fields: { saveReplay: false } })
     })
 
     it('Should fail to update replay status if replay is not allowed on the instance', async function () {
@@ -413,36 +415,34 @@ describe('Test video lives API validator', function () {
         }
       })
 
-      await updateLive(server.url, server.accessToken, video.id, { saveReplay: true }, HttpStatusCode.FORBIDDEN_403)
+      await command.updateLive({ videoId: video.id, fields: { saveReplay: true }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
     })
 
     it('Should fail to update a live if it has already started', async function () {
       this.timeout(40000)
 
-      const resLive = await getLive(server.url, server.accessToken, video.id)
-      const live: LiveVideo = resLive.body
+      const live = await command.getLive({ videoId: video.id })
 
-      const command = sendRTMPStream(live.rtmpUrl, live.streamKey)
+      const ffmpegCommand = sendRTMPStream(live.rtmpUrl, live.streamKey)
 
-      await waitUntilLivePublished(server.url, server.accessToken, video.id)
-      await updateLive(server.url, server.accessToken, video.id, {}, HttpStatusCode.BAD_REQUEST_400)
+      await command.waitUntilLivePublished({ videoId: video.id })
+      await command.updateLive({ videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
-      await stopFfmpeg(command)
+      await stopFfmpeg(ffmpegCommand)
     })
 
     it('Should fail to stream twice in the save live', async function () {
       this.timeout(40000)
 
-      const resLive = await getLive(server.url, server.accessToken, video.id)
-      const live: LiveVideo = resLive.body
+      const live = await command.getLive({ videoId: video.id })
 
-      const command = sendRTMPStream(live.rtmpUrl, live.streamKey)
+      const ffmpegCommand = sendRTMPStream(live.rtmpUrl, live.streamKey)
 
-      await waitUntilLivePublished(server.url, server.accessToken, video.id)
+      await command.waitUntilLivePublished({ videoId: video.id })
 
-      await runAndTestFfmpegStreamError(server.url, server.accessToken, video.id, true)
+      await command.runAndTestFfmpegStreamError({ videoId: video.id, shouldHaveError: true })
 
-      await stopFfmpeg(command)
+      await stopFfmpeg(ffmpegCommand)
     })
   })