server/tests/api/runners/runner-studio-transcoding.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import { expect } from 'chai'
   4 import { readFile } from 'fs-extra'
   5 import { checkPersistentTmpIsEmpty, checkVideoDuration } from '@server/tests/shared'
   6 import { buildAbsoluteFixturePath } from '@shared/core-utils'
   7 import {
   8   RunnerJobStudioTranscodingPayload,
   9   VideoStudioTranscodingSuccess,
  10   VideoState,
  11   VideoStudioTask,
  12   VideoStudioTaskIntro
  13 } from '@shared/models'
  14 import {
  15   cleanupTests,
  16   createMultipleServers,
  17   doubleFollow,
  18   PeerTubeServer,
  19   setAccessTokensToServers,
  20   setDefaultVideoChannel,
  21   VideoStudioCommand,
  22   waitJobs
  23 } from '@shared/server-commands'
  24
  25 describe('Test runner video studio transcoding', function () {
  26   let servers: PeerTubeServer[] = []
  27   let runnerToken: string
  28   let videoUUID: string
  29   let jobUUID: string
  30
  31   async function renewStudio (tasks: VideoStudioTask[] = VideoStudioCommand.getComplexTask()) {
  32     const { uuid } = await servers[0].videos.quickUpload({ name: 'video' })
  33     videoUUID = uuid
  34
  35     await waitJobs(servers)
  36
  37     await servers[0].videoStudio.createEditionTasks({ videoId: uuid, tasks })
  38     await waitJobs(servers)
  39
  40     const { availableJobs } = await servers[0].runnerJobs.request({ runnerToken })
  41     expect(availableJobs).to.have.lengthOf(1)
  42
  43     jobUUID = availableJobs[0].uuid
  44   }
  45
  46   before(async function () {
  47     this.timeout(120_000)
  48
  49     servers = await createMultipleServers(2)
  50
  51     await setAccessTokensToServers(servers)
  52     await setDefaultVideoChannel(servers)
  53
  54     await doubleFollow(servers[0], servers[1])
  55
  56     await servers[0].config.enableTranscoding(true, true)
  57     await servers[0].config.enableStudio()
  58     await servers[0].config.enableRemoteStudio()
  59
  60     runnerToken = await servers[0].runners.autoRegisterRunner()
  61   })
  62
  63   it('Should error a studio transcoding job', async function () {
  64     this.timeout(60000)
  65
  66     await renewStudio()
  67
  68     for (let i = 0; i < 5; i++) {
  69       const { job } = await servers[0].runnerJobs.accept({ runnerToken, jobUUID })
  70       const jobToken = job.jobToken
  71
  72       await servers[0].runnerJobs.error({ runnerToken, jobUUID, jobToken, message: 'Error' })
  73     }
  74
  75     const video = await servers[0].videos.get({ id: videoUUID })
  76     expect(video.state.id).to.equal(VideoState.PUBLISHED)
  77
  78     await checkPersistentTmpIsEmpty(servers[0])
  79   })
  80
  81   it('Should cancel a transcoding job', async function () {
  82     this.timeout(60000)
  83
  84     await renewStudio()
  85
  86     await servers[0].runnerJobs.cancelByAdmin({ jobUUID })
  87
  88     const video = await servers[0].videos.get({ id: videoUUID })
  89     expect(video.state.id).to.equal(VideoState.PUBLISHED)
  90
  91     await checkPersistentTmpIsEmpty(servers[0])
  92   })
  93
  94   it('Should execute a remote studio job', async function () {
  95     this.timeout(240_000)
  96
  97     const tasks = [
  98       {
  99         name: 'add-outro' as 'add-outro',
 100         options: {
 101           file: 'video_short.webm'
 102         }
 103       },
 104       {
 105         name: 'add-watermark' as 'add-watermark',
 106         options: {
 107           file: 'thumbnail.png'
 108         }
 109       },
 110       {
 111         name: 'add-intro' as 'add-intro',
 112         options: {
 113           file: 'video_very_short_240p.mp4'
 114         }
 115       }
 116     ]
 117
 118     await renewStudio(tasks)
 119
 120     for (const server of servers) {
 121       await checkVideoDuration(server, videoUUID, 5)
 122     }
 123
 124     const { job } = await servers[0].runnerJobs.accept<RunnerJobStudioTranscodingPayload>({ runnerToken, jobUUID })
 125     const jobToken = job.jobToken
 126
 127     expect(job.type === 'video-studio-transcoding')
 128     expect(job.payload.input.videoFileUrl).to.exist
 129
 130     // Check video input file
 131     {
 132       await servers[0].runnerJobs.getJobFile({ url: job.payload.input.videoFileUrl, jobToken, runnerToken })
 133     }
 134
 135     // Check task files
 136     for (let i = 0; i < tasks.length; i++) {
 137       const task = tasks[i]
 138       const payloadTask = job.payload.tasks[i]
 139
 140       expect(payloadTask.name).to.equal(task.name)
 141
 142       const inputFile = await readFile(buildAbsoluteFixturePath(task.options.file))
 143
 144       const { body } = await servers[0].runnerJobs.getJobFile({
 145         url: (payloadTask as VideoStudioTaskIntro).options.file as string,
 146         jobToken,
 147         runnerToken
 148       })
 149
 150       expect(body).to.deep.equal(inputFile)
 151     }
 152
 153     const payload: VideoStudioTranscodingSuccess = { videoFile: 'video_very_short_240p.mp4' }
 154     await servers[0].runnerJobs.success({ runnerToken, jobUUID, jobToken, payload })
 155
 156     await waitJobs(servers)
 157
 158     for (const server of servers) {
 159       await checkVideoDuration(server, videoUUID, 2)
 160     }
 161
 162     await checkPersistentTmpIsEmpty(servers[0])
 163   })
 164
 165   after(async function () {
 166     await cleanupTests(servers)
 167   })
 168 })