1 import { basename } from 'path'
2 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
3 import { checkBadCountPagination, checkBadSortPagination, checkBadStartPagination } from '@server/tests/shared'
6 isVideoStudioTaskIntro,
9 RunnerJobSuccessPayload,
10 RunnerJobUpdatePayload,
11 RunnerJobStudioTranscodingPayload,
14 } from '@shared/models'
21 setAccessTokensToServers,
22 setDefaultVideoChannel,
26 } from '@shared/server-commands'
28 const badUUID = '910ec12a-d9e6-458b-a274-0abb655f9464'
30 describe('Test managing runners', function () {
31 let server: PeerTubeServer
35 let registrationTokenId: number
36 let registrationToken: string
38 let runnerToken: string
39 let runnerToken2: string
41 let completedJobToken: string
42 let completedJobUUID: string
44 let cancelledJobUUID: string
46 before(async function () {
57 server = await createSingleServer(1, config)
58 await setAccessTokensToServers([ server ])
59 await setDefaultVideoChannel([ server ])
61 userToken = await server.users.generateUserAndToken('user1')
63 const { data } = await server.runnerRegistrationTokens.list()
64 registrationToken = data[0].registrationToken
65 registrationTokenId = data[0].id
67 await server.config.enableTranscoding(true, true)
68 await server.config.enableStudio()
69 await server.config.enableRemoteTranscoding()
70 await server.config.enableRemoteStudio()
72 runnerToken = await server.runners.autoRegisterRunner()
73 runnerToken2 = await server.runners.autoRegisterRunner()
76 await server.videos.quickUpload({ name: 'video 1' })
77 await server.videos.quickUpload({ name: 'video 2' })
79 await waitJobs([ server ])
82 const job = await server.runnerJobs.autoProcessWebVideoJob(runnerToken)
83 completedJobToken = job.jobToken
84 completedJobUUID = job.uuid
88 const { job } = await server.runnerJobs.autoAccept({ runnerToken })
89 cancelledJobUUID = job.uuid
90 await server.runnerJobs.cancelByAdmin({ jobUUID: cancelledJobUUID })
95 describe('Managing runner registration tokens', function () {
97 describe('Common', function () {
99 it('Should fail to generate, list or delete runner registration token without oauth token', async function () {
100 const expectedStatus = HttpStatusCode.UNAUTHORIZED_401
102 await server.runnerRegistrationTokens.generate({ token: null, expectedStatus })
103 await server.runnerRegistrationTokens.list({ token: null, expectedStatus })
104 await server.runnerRegistrationTokens.delete({ token: null, id: registrationTokenId, expectedStatus })
107 it('Should fail to generate, list or delete runner registration token without admin rights', async function () {
108 const expectedStatus = HttpStatusCode.FORBIDDEN_403
110 await server.runnerRegistrationTokens.generate({ token: userToken, expectedStatus })
111 await server.runnerRegistrationTokens.list({ token: userToken, expectedStatus })
112 await server.runnerRegistrationTokens.delete({ token: userToken, id: registrationTokenId, expectedStatus })
116 describe('Delete', function () {
118 it('Should fail to delete with a bad id', async function () {
119 await server.runnerRegistrationTokens.delete({ id: 404, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
123 describe('List', function () {
124 const path = '/api/v1/runners/registration-tokens'
126 it('Should fail to list with a bad start pagination', async function () {
127 await checkBadStartPagination(server.url, path, server.accessToken)
130 it('Should fail to list with a bad count pagination', async function () {
131 await checkBadCountPagination(server.url, path, server.accessToken)
134 it('Should fail to list with an incorrect sort', async function () {
135 await checkBadSortPagination(server.url, path, server.accessToken)
138 it('Should succeed to list with the correct params', async function () {
139 await server.runnerRegistrationTokens.list({ start: 0, count: 5, sort: '-createdAt' })
144 describe('Managing runners', function () {
145 let toDeleteId: number
147 describe('Register', function () {
148 const name = 'runner name'
150 it('Should fail with a bad registration token', async function () {
151 const expectedStatus = HttpStatusCode.BAD_REQUEST_400
153 await server.runners.register({ name, registrationToken: 'a'.repeat(4000), expectedStatus })
154 await server.runners.register({ name, registrationToken: null, expectedStatus })
157 it('Should fail with an unknown registration token', async function () {
158 await server.runners.register({ name, registrationToken: 'aaa', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
161 it('Should fail with a bad name', async function () {
162 const expectedStatus = HttpStatusCode.BAD_REQUEST_400
164 await server.runners.register({ name: '', registrationToken, expectedStatus })
165 await server.runners.register({ name: 'a'.repeat(200), registrationToken, expectedStatus })
168 it('Should fail with an invalid description', async function () {
169 const expectedStatus = HttpStatusCode.BAD_REQUEST_400
171 await server.runners.register({ name, description: '', registrationToken, expectedStatus })
172 await server.runners.register({ name, description: 'a'.repeat(5000), registrationToken, expectedStatus })
175 it('Should succeed with the correct params', async function () {
176 const { id } = await server.runners.register({ name, description: 'super description', registrationToken })
182 describe('Delete', function () {
184 it('Should fail without oauth token', async function () {
185 await server.runners.delete({ token: null, id: toDeleteId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
188 it('Should fail without admin rights', async function () {
189 await server.runners.delete({ token: userToken, id: toDeleteId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
192 it('Should fail with a bad id', async function () {
193 await server.runners.delete({ id: 'hi' as any, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
196 it('Should fail with an unknown id', async function () {
197 await server.runners.delete({ id: 404, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
200 it('Should succeed with the correct params', async function () {
201 await server.runners.delete({ id: toDeleteId })
205 describe('List', function () {
206 const path = '/api/v1/runners'
208 it('Should fail without oauth token', async function () {
209 await server.runners.list({ token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
212 it('Should fail without admin rights', async function () {
213 await server.runners.list({ token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
216 it('Should fail to list with a bad start pagination', async function () {
217 await checkBadStartPagination(server.url, path, server.accessToken)
220 it('Should fail to list with a bad count pagination', async function () {
221 await checkBadCountPagination(server.url, path, server.accessToken)
224 it('Should fail to list with an incorrect sort', async function () {
225 await checkBadSortPagination(server.url, path, server.accessToken)
228 it('Should succeed to list with the correct params', async function () {
229 await server.runners.list({ start: 0, count: 5, sort: '-createdAt' })
235 describe('Runner jobs by admin', function () {
237 describe('Cancel', function () {
240 before(async function () {
243 await server.videos.quickUpload({ name: 'video' })
244 await waitJobs([ server ])
246 const { availableJobs } = await server.runnerJobs.request({ runnerToken })
247 jobUUID = availableJobs[0].uuid
250 it('Should fail without oauth token', async function () {
251 await server.runnerJobs.cancelByAdmin({ token: null, jobUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
254 it('Should fail without admin rights', async function () {
255 await server.runnerJobs.cancelByAdmin({ token: userToken, jobUUID, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
258 it('Should fail with a bad job uuid', async function () {
259 await server.runnerJobs.cancelByAdmin({ jobUUID: 'hello', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
262 it('Should fail with an unknown job uuid', async function () {
263 const jobUUID = badUUID
264 await server.runnerJobs.cancelByAdmin({ jobUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
267 it('Should fail with an already cancelled job', async function () {
268 await server.runnerJobs.cancelByAdmin({ jobUUID: cancelledJobUUID, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
271 it('Should succeed with the correct params', async function () {
272 await server.runnerJobs.cancelByAdmin({ jobUUID })
276 describe('List', function () {
277 const path = '/api/v1/runners/jobs'
279 it('Should fail without oauth token', async function () {
280 await server.runnerJobs.list({ token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
283 it('Should fail without admin rights', async function () {
284 await server.runnerJobs.list({ token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
287 it('Should fail to list with a bad start pagination', async function () {
288 await checkBadStartPagination(server.url, path, server.accessToken)
291 it('Should fail to list with a bad count pagination', async function () {
292 await checkBadCountPagination(server.url, path, server.accessToken)
295 it('Should fail to list with an incorrect sort', async function () {
296 await checkBadSortPagination(server.url, path, server.accessToken)
299 it('Should succeed to list with the correct params', async function () {
300 await server.runnerJobs.list({ start: 0, count: 5, sort: '-createdAt' })
306 describe('Runner jobs by runners', function () {
309 let videoUUID: string
312 let jobToken2: string
314 let videoUUID2: string
316 let pendingUUID: string
318 let videoStudioUUID: string
319 let studioFile: string
321 let liveAcceptedJob: RunnerJob & { jobToken: string }
322 let studioAcceptedJob: RunnerJob & { jobToken: string }
324 async function fetchVideoInputFiles (options: {
329 expectedStatus: HttpStatusCode
331 const { jobUUID, expectedStatus, videoUUID, runnerToken, jobToken } = options
333 const basePath = '/api/v1/runners/jobs/' + jobUUID + '/files/videos/' + videoUUID
334 const paths = [ `${basePath}/max-quality`, `${basePath}/previews/max-quality` ]
336 for (const path of paths) {
337 await makePostBodyRequest({ url: server.url, path, fields: { runnerToken, jobToken }, expectedStatus })
341 async function fetchStudioFiles (options: {
347 expectedStatus: HttpStatusCode
349 const { jobUUID, expectedStatus, videoUUID, runnerToken, jobToken, studioFile } = options
351 const path = `/api/v1/runners/jobs/${jobUUID}/files/videos/${videoUUID}/studio/task-files/${studioFile}`
353 await makePostBodyRequest({ url: server.url, path, fields: { runnerToken, jobToken }, expectedStatus })
356 before(async function () {
360 await server.runnerJobs.cancelAllJobs({ state: RunnerJobState.PENDING })
364 const { uuid } = await server.videos.quickUpload({ name: 'video' })
367 await waitJobs([ server ])
369 const { job } = await server.runnerJobs.autoAccept({ runnerToken })
371 jobToken = job.jobToken
375 const { uuid } = await server.videos.quickUpload({ name: 'video' })
378 await waitJobs([ server ])
380 const { job } = await server.runnerJobs.autoAccept({ runnerToken: runnerToken2 })
382 jobToken2 = job.jobToken
386 await server.videos.quickUpload({ name: 'video' })
387 await waitJobs([ server ])
389 const { availableJobs } = await server.runnerJobs.request({ runnerToken })
390 pendingUUID = availableJobs[0].uuid
394 await server.config.disableTranscoding()
396 const { uuid } = await server.videos.quickUpload({ name: 'video studio' })
397 videoStudioUUID = uuid
399 await server.config.enableTranscoding(true, true)
400 await server.config.enableStudio()
402 await server.videoStudio.createEditionTasks({
403 videoId: videoStudioUUID,
404 tasks: VideoStudioCommand.getComplexTask()
407 const { job } = await server.runnerJobs.autoAccept({ runnerToken, type: 'video-studio-transcoding' })
408 studioAcceptedJob = job
410 const tasks = (job.payload as RunnerJobStudioTranscodingPayload).tasks
411 const fileUrl = (tasks.find(t => isVideoStudioTaskIntro(t)) as VideoStudioTaskIntro).options.file as string
412 studioFile = basename(fileUrl)
416 await server.config.enableLive({
422 const { live } = await server.live.quickCreate({ permanentLive: true, saveReplay: false, privacy: VideoPrivacy.PUBLIC })
424 const ffmpegCommand = sendRTMPStream({ rtmpBaseUrl: live.rtmpUrl, streamKey: live.streamKey })
425 await waitJobs([ server ])
427 await server.runnerJobs.requestLiveJob(runnerToken)
429 const { job } = await server.runnerJobs.autoAccept({ runnerToken, type: 'live-rtmp-hls-transcoding' })
430 liveAcceptedJob = job
432 await stopFfmpeg(ffmpegCommand)
436 describe('Common runner tokens validations', function () {
438 async function testEndpoints (options: {
442 expectedStatus: HttpStatusCode
444 await server.runnerJobs.abort({ ...options, reason: 'reason' })
445 await server.runnerJobs.update({ ...options })
446 await server.runnerJobs.error({ ...options, message: 'message' })
447 await server.runnerJobs.success({ ...options, payload: { videoFile: 'video_short.mp4' } })
450 it('Should fail with an invalid job uuid', async function () {
451 const options = { jobUUID: 'a', runnerToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 }
453 await testEndpoints({ ...options, jobToken })
454 await fetchVideoInputFiles({ ...options, videoUUID, jobToken })
455 await fetchStudioFiles({ ...options, videoUUID, jobToken: studioAcceptedJob.jobToken, studioFile })
458 it('Should fail with an unknown job uuid', async function () {
459 const options = { jobUUID: badUUID, runnerToken, expectedStatus: HttpStatusCode.NOT_FOUND_404 }
461 await testEndpoints({ ...options, jobToken })
462 await fetchVideoInputFiles({ ...options, videoUUID, jobToken })
463 await fetchStudioFiles({ ...options, jobToken: studioAcceptedJob.jobToken, videoUUID, studioFile })
466 it('Should fail with an invalid runner token', async function () {
467 const options = { runnerToken: '', expectedStatus: HttpStatusCode.BAD_REQUEST_400 }
469 await testEndpoints({ ...options, jobUUID, jobToken })
470 await fetchVideoInputFiles({ ...options, jobUUID, videoUUID, jobToken })
471 await fetchStudioFiles({
473 jobToken: studioAcceptedJob.jobToken,
474 jobUUID: studioAcceptedJob.uuid,
475 videoUUID: videoStudioUUID,
480 it('Should fail with an unknown runner token', async function () {
481 const options = { runnerToken: badUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 }
483 await testEndpoints({ ...options, jobUUID, jobToken })
484 await fetchVideoInputFiles({ ...options, jobUUID, videoUUID, jobToken })
485 await fetchStudioFiles({
487 jobToken: studioAcceptedJob.jobToken,
488 jobUUID: studioAcceptedJob.uuid,
489 videoUUID: videoStudioUUID,
494 it('Should fail with an invalid job token job uuid', async function () {
495 const options = { runnerToken, jobToken: '', expectedStatus: HttpStatusCode.BAD_REQUEST_400 }
497 await testEndpoints({ ...options, jobUUID })
498 await fetchVideoInputFiles({ ...options, jobUUID, videoUUID })
499 await fetchStudioFiles({ ...options, jobUUID: studioAcceptedJob.uuid, videoUUID: videoStudioUUID, studioFile })
502 it('Should fail with an unknown job token job uuid', async function () {
503 const options = { runnerToken, jobToken: badUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 }
505 await testEndpoints({ ...options, jobUUID })
506 await fetchVideoInputFiles({ ...options, jobUUID, videoUUID })
507 await fetchStudioFiles({ ...options, jobUUID: studioAcceptedJob.uuid, videoUUID: videoStudioUUID, studioFile })
510 it('Should fail with a runner token not associated to this job', async function () {
511 const options = { runnerToken: runnerToken2, expectedStatus: HttpStatusCode.NOT_FOUND_404 }
513 await testEndpoints({ ...options, jobUUID, jobToken })
514 await fetchVideoInputFiles({ ...options, jobUUID, videoUUID, jobToken })
515 await fetchStudioFiles({
517 jobToken: studioAcceptedJob.jobToken,
518 jobUUID: studioAcceptedJob.uuid,
519 videoUUID: videoStudioUUID,
524 it('Should fail with a job uuid not associated to the job token', async function () {
526 const options = { jobUUID: jobUUID2, runnerToken, expectedStatus: HttpStatusCode.NOT_FOUND_404 }
528 await testEndpoints({ ...options, jobToken })
529 await fetchVideoInputFiles({ ...options, jobToken, videoUUID })
530 await fetchStudioFiles({ ...options, jobToken: studioAcceptedJob.jobToken, videoUUID: videoStudioUUID, studioFile })
534 const options = { runnerToken, jobToken: jobToken2, expectedStatus: HttpStatusCode.NOT_FOUND_404 }
536 await testEndpoints({ ...options, jobUUID })
537 await fetchVideoInputFiles({ ...options, jobUUID, videoUUID })
538 await fetchStudioFiles({ ...options, jobUUID: studioAcceptedJob.uuid, videoUUID: videoStudioUUID, studioFile })
543 describe('Unregister', function () {
545 it('Should fail without a runner token', async function () {
546 await server.runners.unregister({ runnerToken: null, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
549 it('Should fail with a bad a runner token', async function () {
550 await server.runners.unregister({ runnerToken: '', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
553 it('Should fail with an unknown runner token', async function () {
554 await server.runners.unregister({ runnerToken: badUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
558 describe('Request', function () {
560 it('Should fail without a runner token', async function () {
561 await server.runnerJobs.request({ runnerToken: null, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
564 it('Should fail with a bad a runner token', async function () {
565 await server.runnerJobs.request({ runnerToken: '', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
568 it('Should fail with an unknown runner token', async function () {
569 await server.runnerJobs.request({ runnerToken: badUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
573 describe('Accept', function () {
575 it('Should fail with a bad a job uuid', async function () {
576 await server.runnerJobs.accept({ jobUUID: '', runnerToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
579 it('Should fail with an unknown job uuid', async function () {
580 await server.runnerJobs.accept({ jobUUID: badUUID, runnerToken, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
583 it('Should fail with a job not in pending state', async function () {
584 await server.runnerJobs.accept({ jobUUID: completedJobUUID, runnerToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
585 await server.runnerJobs.accept({ jobUUID: cancelledJobUUID, runnerToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
588 it('Should fail without a runner token', async function () {
589 await server.runnerJobs.accept({ jobUUID: pendingUUID, runnerToken: null, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
592 it('Should fail with a bad a runner token', async function () {
593 await server.runnerJobs.accept({ jobUUID: pendingUUID, runnerToken: '', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
596 it('Should fail with an unknown runner token', async function () {
597 await server.runnerJobs.accept({ jobUUID: pendingUUID, runnerToken: badUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
601 describe('Abort', function () {
603 it('Should fail without a reason', async function () {
604 await server.runnerJobs.abort({ jobUUID, jobToken, runnerToken, reason: null, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
607 it('Should fail with a bad reason', async function () {
608 const reason = 'reason'.repeat(5000)
609 await server.runnerJobs.abort({ jobUUID, jobToken, runnerToken, reason, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
612 it('Should fail with a job not in processing state', async function () {
613 await server.runnerJobs.abort({
614 jobUUID: completedJobUUID,
615 jobToken: completedJobToken,
618 expectedStatus: HttpStatusCode.BAD_REQUEST_400
623 describe('Update', function () {
625 describe('Common', function () {
627 it('Should fail with an invalid progress', async function () {
628 await server.runnerJobs.update({ jobUUID, jobToken, runnerToken, progress: 101, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
631 it('Should fail with a job not in processing state', async function () {
632 await server.runnerJobs.update({
633 jobUUID: completedJobUUID,
634 jobToken: completedJobToken,
636 expectedStatus: HttpStatusCode.BAD_REQUEST_400
641 describe('Live RTMP to HLS', function () {
642 const base: RunnerJobUpdatePayload = {
643 masterPlaylistFile: 'live/master.m3u8',
644 resolutionPlaylistFilename: '0.m3u8',
645 resolutionPlaylistFile: 'live/1.m3u8',
647 videoChunkFile: 'live/1-000069.ts',
648 videoChunkFilename: '1-000068.ts'
651 function testUpdate (payload: RunnerJobUpdatePayload) {
652 return server.runnerJobs.update({
653 jobUUID: liveAcceptedJob.uuid,
654 jobToken: liveAcceptedJob.jobToken,
657 expectedStatus: HttpStatusCode.BAD_REQUEST_400
661 it('Should fail with an invalid resolutionPlaylistFilename', async function () {
662 await testUpdate({ ...base, resolutionPlaylistFilename: undefined })
663 await testUpdate({ ...base, resolutionPlaylistFilename: 'coucou/hello' })
664 await testUpdate({ ...base, resolutionPlaylistFilename: 'hello' })
667 it('Should fail with an invalid videoChunkFilename', async function () {
668 await testUpdate({ ...base, resolutionPlaylistFilename: undefined })
669 await testUpdate({ ...base, resolutionPlaylistFilename: 'coucou/hello' })
670 await testUpdate({ ...base, resolutionPlaylistFilename: 'hello' })
673 it('Should fail with an invalid type', async function () {
674 await testUpdate({ ...base, type: undefined })
675 await testUpdate({ ...base, type: 'toto' as any })
678 it('Should succeed with the correct params', async function () {
679 await server.runnerJobs.update({
680 jobUUID: liveAcceptedJob.uuid,
681 jobToken: liveAcceptedJob.jobToken,
686 await server.runnerJobs.update({
687 jobUUID: liveAcceptedJob.uuid,
688 jobToken: liveAcceptedJob.jobToken,
689 payload: { ...base, masterPlaylistFile: undefined },
696 describe('Error', function () {
698 it('Should fail with a missing error message', async function () {
699 await server.runnerJobs.error({ jobUUID, jobToken, runnerToken, message: null, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
702 it('Should fail with an invalid error messgae', async function () {
703 const message = 'a'.repeat(6000)
704 await server.runnerJobs.error({ jobUUID, jobToken, runnerToken, message, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
707 it('Should fail with a job not in processing state', async function () {
708 await server.runnerJobs.error({
709 jobUUID: completedJobUUID,
710 jobToken: completedJobToken,
711 message: 'my message',
713 expectedStatus: HttpStatusCode.BAD_REQUEST_400
718 describe('Success', function () {
719 let vodJobUUID: string
720 let vodJobToken: string
722 describe('Common', function () {
724 it('Should fail with a job not in processing state', async function () {
725 await server.runnerJobs.success({
726 jobUUID: completedJobUUID,
727 jobToken: completedJobToken,
728 payload: { videoFile: 'video_short.mp4' },
730 expectedStatus: HttpStatusCode.BAD_REQUEST_400
735 describe('VOD', function () {
737 it('Should fail with an invalid vod web video payload', async function () {
738 const { job } = await server.runnerJobs.autoAccept({ runnerToken, type: 'vod-web-video-transcoding' })
740 await server.runnerJobs.success({
742 jobToken: job.jobToken,
743 payload: { hello: 'video_short.mp4' } as any,
745 expectedStatus: HttpStatusCode.BAD_REQUEST_400
748 vodJobUUID = job.uuid
749 vodJobToken = job.jobToken
752 it('Should fail with an invalid vod hls payload', async function () {
753 // To create HLS jobs
754 const payload: RunnerJobSuccessPayload = { videoFile: 'video_short.mp4' }
755 await server.runnerJobs.success({ runnerToken, jobUUID: vodJobUUID, jobToken: vodJobToken, payload })
757 await waitJobs([ server ])
759 const { job } = await server.runnerJobs.autoAccept({ runnerToken, type: 'vod-hls-transcoding' })
761 await server.runnerJobs.success({
763 jobToken: job.jobToken,
764 payload: { videoFile: 'video_short.mp4' } as any,
766 expectedStatus: HttpStatusCode.BAD_REQUEST_400
770 it('Should fail with an invalid vod audio merge payload', async function () {
771 const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
772 await server.videos.upload({ attributes, mode: 'legacy' })
774 await waitJobs([ server ])
776 const { job } = await server.runnerJobs.autoAccept({ runnerToken, type: 'vod-audio-merge-transcoding' })
778 await server.runnerJobs.success({
780 jobToken: job.jobToken,
781 payload: { hello: 'video_short.mp4' } as any,
783 expectedStatus: HttpStatusCode.BAD_REQUEST_400
788 describe('Video studio', function () {
790 it('Should fail with an invalid video studio transcoding payload', async function () {
791 await server.runnerJobs.success({
792 jobUUID: studioAcceptedJob.uuid,
793 jobToken: studioAcceptedJob.jobToken,
794 payload: { hello: 'video_short.mp4' } as any,
796 expectedStatus: HttpStatusCode.BAD_REQUEST_400
802 describe('Job files', function () {
804 describe('Check video param for common job file routes', function () {
806 async function fetchFiles (options: {
808 expectedStatus: HttpStatusCode
810 await fetchVideoInputFiles({ videoUUID, ...options, jobToken, jobUUID, runnerToken })
812 await fetchStudioFiles({
813 videoUUID: videoStudioUUID,
817 jobToken: studioAcceptedJob.jobToken,
818 jobUUID: studioAcceptedJob.uuid,
824 it('Should fail with an invalid video id', async function () {
827 expectedStatus: HttpStatusCode.BAD_REQUEST_400
831 it('Should fail with an unknown video id', async function () {
832 const videoUUID = '910ec12a-d9e6-458b-a274-0abb655f9464'
836 expectedStatus: HttpStatusCode.NOT_FOUND_404
840 it('Should fail with a video id not associated to this job', async function () {
842 videoUUID: videoUUID2,
843 expectedStatus: HttpStatusCode.FORBIDDEN_403
847 it('Should succeed with the correct params', async function () {
848 await fetchFiles({ expectedStatus: HttpStatusCode.OK_200 })
852 describe('Video studio tasks file routes', function () {
854 it('Should fail with an invalid studio filename', async function () {
855 await fetchStudioFiles({
856 videoUUID: videoStudioUUID,
857 jobUUID: studioAcceptedJob.uuid,
859 jobToken: studioAcceptedJob.jobToken,
861 expectedStatus: HttpStatusCode.BAD_REQUEST_400
868 after(async function () {
869 await cleanupTests([ server ])