aboutsummaryrefslogtreecommitdiffhomepage
path: root/server/tests/api/videos/video-transcoder.ts
diff options
context:
space:
mode:
authorChocobozzz <me@florianbigard.com>2022-02-28 15:56:51 +0100
committerChocobozzz <me@florianbigard.com>2022-02-28 16:02:08 +0100
commit95faf1eafffff4fe1f74025092c7c3eef2951697 (patch)
tree8a18d271200d2c87ea5fff6b1f97efcda69d2f21 /server/tests/api/videos/video-transcoder.ts
parentcba7977552e909ea0ea4dc526788a9166ad5f535 (diff)
downloadPeerTube-95faf1eafffff4fe1f74025092c7c3eef2951697.tar.gz
PeerTube-95faf1eafffff4fe1f74025092c7c3eef2951697.tar.zst
PeerTube-95faf1eafffff4fe1f74025092c7c3eef2951697.zip
Create another test suite for transcoding jobs
Diffstat (limited to 'server/tests/api/videos/video-transcoder.ts')
-rw-r--r--server/tests/api/videos/video-transcoder.ts733
1 files changed, 0 insertions, 733 deletions
diff --git a/server/tests/api/videos/video-transcoder.ts b/server/tests/api/videos/video-transcoder.ts
deleted file mode 100644
index 245c4c012..000000000
--- a/server/tests/api/videos/video-transcoder.ts
+++ /dev/null
@@ -1,733 +0,0 @@
1/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
2
3import 'mocha'
4import * as chai from 'chai'
5import { omit } from 'lodash'
6import { canDoQuickTranscode } from '@server/helpers/ffmpeg'
7import { generateHighBitrateVideo, generateVideoWithFramerate, getAllFiles } from '@server/tests/shared'
8import { buildAbsoluteFixturePath, getMaxBitrate, getMinLimitBitrate } from '@shared/core-utils'
9import {
10 getAudioStream,
11 buildFileMetadata,
12 getVideoStreamBitrate,
13 getVideoStreamFPS,
14 getVideoStreamDimensionsInfo,
15 hasAudioStream
16} from '@shared/extra-utils'
17import { HttpStatusCode, VideoState } from '@shared/models'
18import {
19 cleanupTests,
20 createMultipleServers,
21 doubleFollow,
22 makeGetRequest,
23 PeerTubeServer,
24 setAccessTokensToServers,
25 waitJobs,
26 webtorrentAdd
27} from '@shared/server-commands'
28
29const expect = chai.expect
30
31function updateConfigForTranscoding (server: PeerTubeServer) {
32 return server.config.updateCustomSubConfig({
33 newConfig: {
34 transcoding: {
35 enabled: true,
36 allowAdditionalExtensions: true,
37 allowAudioFiles: true,
38 hls: { enabled: true },
39 webtorrent: { enabled: true },
40 resolutions: {
41 '0p': false,
42 '144p': true,
43 '240p': true,
44 '360p': true,
45 '480p': true,
46 '720p': true,
47 '1080p': true,
48 '1440p': true,
49 '2160p': true
50 }
51 }
52 }
53 })
54}
55
56describe('Test video transcoding', function () {
57 let servers: PeerTubeServer[] = []
58 let video4k: string
59
60 before(async function () {
61 this.timeout(30_000)
62
63 // Run servers
64 servers = await createMultipleServers(2)
65
66 await setAccessTokensToServers(servers)
67
68 await doubleFollow(servers[0], servers[1])
69
70 await updateConfigForTranscoding(servers[1])
71 })
72
73 describe('Basic transcoding (or not)', function () {
74
75 it('Should not transcode video on server 1', async function () {
76 this.timeout(60_000)
77
78 const attributes = {
79 name: 'my super name for server 1',
80 description: 'my super description for server 1',
81 fixture: 'video_short.webm'
82 }
83 await servers[0].videos.upload({ attributes })
84
85 await waitJobs(servers)
86
87 for (const server of servers) {
88 const { data } = await server.videos.list()
89 const video = data[0]
90
91 const videoDetails = await server.videos.get({ id: video.id })
92 expect(videoDetails.files).to.have.lengthOf(1)
93
94 const magnetUri = videoDetails.files[0].magnetUri
95 expect(magnetUri).to.match(/\.webm/)
96
97 const torrent = await webtorrentAdd(magnetUri, true)
98 expect(torrent.files).to.be.an('array')
99 expect(torrent.files.length).to.equal(1)
100 expect(torrent.files[0].path).match(/\.webm$/)
101 }
102 })
103
104 it('Should transcode video on server 2', async function () {
105 this.timeout(120_000)
106
107 const attributes = {
108 name: 'my super name for server 2',
109 description: 'my super description for server 2',
110 fixture: 'video_short.webm'
111 }
112 await servers[1].videos.upload({ attributes })
113
114 await waitJobs(servers)
115
116 for (const server of servers) {
117 const { data } = await server.videos.list()
118
119 const video = data.find(v => v.name === attributes.name)
120 const videoDetails = await server.videos.get({ id: video.id })
121
122 expect(videoDetails.files).to.have.lengthOf(5)
123
124 const magnetUri = videoDetails.files[0].magnetUri
125 expect(magnetUri).to.match(/\.mp4/)
126
127 const torrent = await webtorrentAdd(magnetUri, true)
128 expect(torrent.files).to.be.an('array')
129 expect(torrent.files.length).to.equal(1)
130 expect(torrent.files[0].path).match(/\.mp4$/)
131 }
132 })
133
134 it('Should wait for transcoding before publishing the video', async function () {
135 this.timeout(160_000)
136
137 {
138 // Upload the video, but wait transcoding
139 const attributes = {
140 name: 'waiting video',
141 fixture: 'video_short1.webm',
142 waitTranscoding: true
143 }
144 const { uuid } = await servers[1].videos.upload({ attributes })
145 const videoId = uuid
146
147 // Should be in transcode state
148 const body = await servers[1].videos.get({ id: videoId })
149 expect(body.name).to.equal('waiting video')
150 expect(body.state.id).to.equal(VideoState.TO_TRANSCODE)
151 expect(body.state.label).to.equal('To transcode')
152 expect(body.waitTranscoding).to.be.true
153
154 {
155 // Should have my video
156 const { data } = await servers[1].videos.listMyVideos()
157 const videoToFindInMine = data.find(v => v.name === attributes.name)
158 expect(videoToFindInMine).not.to.be.undefined
159 expect(videoToFindInMine.state.id).to.equal(VideoState.TO_TRANSCODE)
160 expect(videoToFindInMine.state.label).to.equal('To transcode')
161 expect(videoToFindInMine.waitTranscoding).to.be.true
162 }
163
164 {
165 // Should not list this video
166 const { data } = await servers[1].videos.list()
167 const videoToFindInList = data.find(v => v.name === attributes.name)
168 expect(videoToFindInList).to.be.undefined
169 }
170
171 // Server 1 should not have the video yet
172 await servers[0].videos.get({ id: videoId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
173 }
174
175 await waitJobs(servers)
176
177 for (const server of servers) {
178 const { data } = await server.videos.list()
179 const videoToFind = data.find(v => v.name === 'waiting video')
180 expect(videoToFind).not.to.be.undefined
181
182 const videoDetails = await server.videos.get({ id: videoToFind.id })
183
184 expect(videoDetails.state.id).to.equal(VideoState.PUBLISHED)
185 expect(videoDetails.state.label).to.equal('Published')
186 expect(videoDetails.waitTranscoding).to.be.true
187 }
188 })
189
190 it('Should accept and transcode additional extensions', async function () {
191 this.timeout(300_000)
192
193 for (const fixture of [ 'video_short.mkv', 'video_short.avi' ]) {
194 const attributes = {
195 name: fixture,
196 fixture
197 }
198
199 await servers[1].videos.upload({ attributes })
200
201 await waitJobs(servers)
202
203 for (const server of servers) {
204 const { data } = await server.videos.list()
205
206 const video = data.find(v => v.name === attributes.name)
207 const videoDetails = await server.videos.get({ id: video.id })
208 expect(videoDetails.files).to.have.lengthOf(5)
209
210 const magnetUri = videoDetails.files[0].magnetUri
211 expect(magnetUri).to.contain('.mp4')
212 }
213 }
214 })
215
216 it('Should transcode a 4k video', async function () {
217 this.timeout(200_000)
218
219 const attributes = {
220 name: '4k video',
221 fixture: 'video_short_4k.mp4'
222 }
223
224 const { uuid } = await servers[1].videos.upload({ attributes })
225 video4k = uuid
226
227 await waitJobs(servers)
228
229 const resolutions = [ 144, 240, 360, 480, 720, 1080, 1440, 2160 ]
230
231 for (const server of servers) {
232 const videoDetails = await server.videos.get({ id: video4k })
233 expect(videoDetails.files).to.have.lengthOf(resolutions.length)
234
235 for (const r of resolutions) {
236 expect(videoDetails.files.find(f => f.resolution.id === r)).to.not.be.undefined
237 expect(videoDetails.streamingPlaylists[0].files.find(f => f.resolution.id === r)).to.not.be.undefined
238 }
239 }
240 })
241 })
242
243 describe('Audio transcoding', function () {
244
245 it('Should transcode high bit rate mp3 to proper bit rate', async function () {
246 this.timeout(60_000)
247
248 const attributes = {
249 name: 'mp3_256k',
250 fixture: 'video_short_mp3_256k.mp4'
251 }
252 await servers[1].videos.upload({ attributes })
253
254 await waitJobs(servers)
255
256 for (const server of servers) {
257 const { data } = await server.videos.list()
258
259 const video = data.find(v => v.name === attributes.name)
260 const videoDetails = await server.videos.get({ id: video.id })
261
262 expect(videoDetails.files).to.have.lengthOf(5)
263
264 const file = videoDetails.files.find(f => f.resolution.id === 240)
265 const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
266 const probe = await getAudioStream(path)
267
268 if (probe.audioStream) {
269 expect(probe.audioStream['codec_name']).to.be.equal('aac')
270 expect(probe.audioStream['bit_rate']).to.be.at.most(384 * 8000)
271 } else {
272 this.fail('Could not retrieve the audio stream on ' + probe.absolutePath)
273 }
274 }
275 })
276
277 it('Should transcode video with no audio and have no audio itself', async function () {
278 this.timeout(60_000)
279
280 const attributes = {
281 name: 'no_audio',
282 fixture: 'video_short_no_audio.mp4'
283 }
284 await servers[1].videos.upload({ attributes })
285
286 await waitJobs(servers)
287
288 for (const server of servers) {
289 const { data } = await server.videos.list()
290
291 const video = data.find(v => v.name === attributes.name)
292 const videoDetails = await server.videos.get({ id: video.id })
293
294 const file = videoDetails.files.find(f => f.resolution.id === 240)
295 const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
296
297 expect(await hasAudioStream(path)).to.be.false
298 }
299 })
300
301 it('Should leave the audio untouched, but properly transcode the video', async function () {
302 this.timeout(60_000)
303
304 const attributes = {
305 name: 'untouched_audio',
306 fixture: 'video_short.mp4'
307 }
308 await servers[1].videos.upload({ attributes })
309
310 await waitJobs(servers)
311
312 for (const server of servers) {
313 const { data } = await server.videos.list()
314
315 const video = data.find(v => v.name === attributes.name)
316 const videoDetails = await server.videos.get({ id: video.id })
317
318 expect(videoDetails.files).to.have.lengthOf(5)
319
320 const fixturePath = buildAbsoluteFixturePath(attributes.fixture)
321 const fixtureVideoProbe = await getAudioStream(fixturePath)
322
323 const file = videoDetails.files.find(f => f.resolution.id === 240)
324 const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
325
326 const videoProbe = await getAudioStream(path)
327
328 if (videoProbe.audioStream && fixtureVideoProbe.audioStream) {
329 const toOmit = [ 'max_bit_rate', 'duration', 'duration_ts', 'nb_frames', 'start_time', 'start_pts' ]
330 expect(omit(videoProbe.audioStream, toOmit)).to.be.deep.equal(omit(fixtureVideoProbe.audioStream, toOmit))
331 } else {
332 this.fail('Could not retrieve the audio stream on ' + videoProbe.absolutePath)
333 }
334 }
335 })
336 })
337
338 describe('Audio upload', function () {
339
340 function runSuite (mode: 'legacy' | 'resumable') {
341
342 before(async function () {
343 await servers[1].config.updateCustomSubConfig({
344 newConfig: {
345 transcoding: {
346 hls: { enabled: true },
347 webtorrent: { enabled: true },
348 resolutions: {
349 '0p': false,
350 '144p': false,
351 '240p': false,
352 '360p': false,
353 '480p': false,
354 '720p': false,
355 '1080p': false,
356 '1440p': false,
357 '2160p': false
358 }
359 }
360 }
361 })
362 })
363
364 it('Should merge an audio file with the preview file', async function () {
365 this.timeout(60_000)
366
367 const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
368 await servers[1].videos.upload({ attributes, mode })
369
370 await waitJobs(servers)
371
372 for (const server of servers) {
373 const { data } = await server.videos.list()
374
375 const video = data.find(v => v.name === 'audio_with_preview')
376 const videoDetails = await server.videos.get({ id: video.id })
377
378 expect(videoDetails.files).to.have.lengthOf(1)
379
380 await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
381 await makeGetRequest({ url: server.url, path: videoDetails.previewPath, expectedStatus: HttpStatusCode.OK_200 })
382
383 const magnetUri = videoDetails.files[0].magnetUri
384 expect(magnetUri).to.contain('.mp4')
385 }
386 })
387
388 it('Should upload an audio file and choose a default background image', async function () {
389 this.timeout(60_000)
390
391 const attributes = { name: 'audio_without_preview', fixture: 'sample.ogg' }
392 await servers[1].videos.upload({ attributes, mode })
393
394 await waitJobs(servers)
395
396 for (const server of servers) {
397 const { data } = await server.videos.list()
398
399 const video = data.find(v => v.name === 'audio_without_preview')
400 const videoDetails = await server.videos.get({ id: video.id })
401
402 expect(videoDetails.files).to.have.lengthOf(1)
403
404 await makeGetRequest({ url: server.url, path: videoDetails.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
405 await makeGetRequest({ url: server.url, path: videoDetails.previewPath, expectedStatus: HttpStatusCode.OK_200 })
406
407 const magnetUri = videoDetails.files[0].magnetUri
408 expect(magnetUri).to.contain('.mp4')
409 }
410 })
411
412 it('Should upload an audio file and create an audio version only', async function () {
413 this.timeout(60_000)
414
415 await servers[1].config.updateCustomSubConfig({
416 newConfig: {
417 transcoding: {
418 hls: { enabled: true },
419 webtorrent: { enabled: true },
420 resolutions: {
421 '0p': true,
422 '144p': false,
423 '240p': false,
424 '360p': false
425 }
426 }
427 }
428 })
429
430 const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
431 const { id } = await servers[1].videos.upload({ attributes, mode })
432
433 await waitJobs(servers)
434
435 for (const server of servers) {
436 const videoDetails = await server.videos.get({ id })
437
438 for (const files of [ videoDetails.files, videoDetails.streamingPlaylists[0].files ]) {
439 expect(files).to.have.lengthOf(2)
440 expect(files.find(f => f.resolution.id === 0)).to.not.be.undefined
441 }
442 }
443
444 await updateConfigForTranscoding(servers[1])
445 })
446 }
447
448 describe('Legacy upload', function () {
449 runSuite('legacy')
450 })
451
452 describe('Resumable upload', function () {
453 runSuite('resumable')
454 })
455 })
456
457 describe('Framerate', function () {
458
459 it('Should transcode a 60 FPS video', async function () {
460 this.timeout(60_000)
461
462 const attributes = {
463 name: 'my super 30fps name for server 2',
464 description: 'my super 30fps description for server 2',
465 fixture: '60fps_720p_small.mp4'
466 }
467 await servers[1].videos.upload({ attributes })
468
469 await waitJobs(servers)
470
471 for (const server of servers) {
472 const { data } = await server.videos.list()
473
474 const video = data.find(v => v.name === attributes.name)
475 const videoDetails = await server.videos.get({ id: video.id })
476
477 expect(videoDetails.files).to.have.lengthOf(5)
478 expect(videoDetails.files[0].fps).to.be.above(58).and.below(62)
479 expect(videoDetails.files[1].fps).to.be.below(31)
480 expect(videoDetails.files[2].fps).to.be.below(31)
481 expect(videoDetails.files[3].fps).to.be.below(31)
482 expect(videoDetails.files[4].fps).to.be.below(31)
483
484 for (const resolution of [ 144, 240, 360, 480 ]) {
485 const file = videoDetails.files.find(f => f.resolution.id === resolution)
486 const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
487 const fps = await getVideoStreamFPS(path)
488
489 expect(fps).to.be.below(31)
490 }
491
492 const file = videoDetails.files.find(f => f.resolution.id === 720)
493 const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
494 const fps = await getVideoStreamFPS(path)
495
496 expect(fps).to.be.above(58).and.below(62)
497 }
498 })
499
500 it('Should downscale to the closest divisor standard framerate', async function () {
501 this.timeout(200_000)
502
503 let tempFixturePath: string
504
505 {
506 tempFixturePath = await generateVideoWithFramerate(59)
507
508 const fps = await getVideoStreamFPS(tempFixturePath)
509 expect(fps).to.be.equal(59)
510 }
511
512 const attributes = {
513 name: '59fps video',
514 description: '59fps video',
515 fixture: tempFixturePath
516 }
517
518 await servers[1].videos.upload({ attributes })
519
520 await waitJobs(servers)
521
522 for (const server of servers) {
523 const { data } = await server.videos.list()
524
525 const { id } = data.find(v => v.name === attributes.name)
526 const video = await server.videos.get({ id })
527
528 {
529 const file = video.files.find(f => f.resolution.id === 240)
530 const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
531 const fps = await getVideoStreamFPS(path)
532 expect(fps).to.be.equal(25)
533 }
534
535 {
536 const file = video.files.find(f => f.resolution.id === 720)
537 const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
538 const fps = await getVideoStreamFPS(path)
539 expect(fps).to.be.equal(59)
540 }
541 }
542 })
543 })
544
545 describe('Bitrate control', function () {
546
547 it('Should respect maximum bitrate values', async function () {
548 this.timeout(160_000)
549
550 const tempFixturePath = await generateHighBitrateVideo()
551
552 const attributes = {
553 name: 'high bitrate video',
554 description: 'high bitrate video',
555 fixture: tempFixturePath
556 }
557
558 await servers[1].videos.upload({ attributes })
559
560 await waitJobs(servers)
561
562 for (const server of servers) {
563 const { data } = await server.videos.list()
564
565 const { id } = data.find(v => v.name === attributes.name)
566 const video = await server.videos.get({ id })
567
568 for (const resolution of [ 240, 360, 480, 720, 1080 ]) {
569 const file = video.files.find(f => f.resolution.id === resolution)
570 const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
571
572 const bitrate = await getVideoStreamBitrate(path)
573 const fps = await getVideoStreamFPS(path)
574 const dataResolution = await getVideoStreamDimensionsInfo(path)
575
576 expect(resolution).to.equal(resolution)
577
578 const maxBitrate = getMaxBitrate({ ...dataResolution, fps })
579 expect(bitrate).to.be.below(maxBitrate)
580 }
581 }
582 })
583
584 it('Should not transcode to an higher bitrate than the original file but above our low limit', async function () {
585 this.timeout(160_000)
586
587 const newConfig = {
588 transcoding: {
589 enabled: true,
590 resolutions: {
591 '144p': true,
592 '240p': true,
593 '360p': true,
594 '480p': true,
595 '720p': true,
596 '1080p': true,
597 '1440p': true,
598 '2160p': true
599 },
600 webtorrent: { enabled: true },
601 hls: { enabled: true }
602 }
603 }
604 await servers[1].config.updateCustomSubConfig({ newConfig })
605
606 const attributes = {
607 name: 'low bitrate',
608 fixture: 'low-bitrate.mp4'
609 }
610
611 const { id } = await servers[1].videos.upload({ attributes })
612
613 await waitJobs(servers)
614
615 const video = await servers[1].videos.get({ id })
616
617 const resolutions = [ 240, 360, 480, 720, 1080 ]
618 for (const r of resolutions) {
619 const file = video.files.find(f => f.resolution.id === r)
620
621 const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
622 const bitrate = await getVideoStreamBitrate(path)
623
624 const inputBitrate = 60_000
625 const limit = getMinLimitBitrate({ fps: 10, ratio: 1, resolution: r })
626 let belowValue = Math.max(inputBitrate, limit)
627 belowValue += belowValue * 0.20 // Apply 20% margin because bitrate control is not very precise
628
629 expect(bitrate, `${path} not below ${limit}`).to.be.below(belowValue)
630 }
631 })
632 })
633
634 describe('FFprobe', function () {
635
636 it('Should provide valid ffprobe data', async function () {
637 this.timeout(160_000)
638
639 const videoUUID = (await servers[1].videos.quickUpload({ name: 'ffprobe data' })).uuid
640 await waitJobs(servers)
641
642 {
643 const video = await servers[1].videos.get({ id: videoUUID })
644 const file = video.files.find(f => f.resolution.id === 240)
645 const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
646 const metadata = await buildFileMetadata(path)
647
648 // expected format properties
649 for (const p of [
650 'tags.encoder',
651 'format_long_name',
652 'size',
653 'bit_rate'
654 ]) {
655 expect(metadata.format).to.have.nested.property(p)
656 }
657
658 // expected stream properties
659 for (const p of [
660 'codec_long_name',
661 'profile',
662 'width',
663 'height',
664 'display_aspect_ratio',
665 'avg_frame_rate',
666 'pix_fmt'
667 ]) {
668 expect(metadata.streams[0]).to.have.nested.property(p)
669 }
670
671 expect(metadata).to.not.have.nested.property('format.filename')
672 }
673
674 for (const server of servers) {
675 const videoDetails = await server.videos.get({ id: videoUUID })
676
677 const videoFiles = getAllFiles(videoDetails)
678 expect(videoFiles).to.have.lengthOf(10)
679
680 for (const file of videoFiles) {
681 expect(file.metadata).to.be.undefined
682 expect(file.metadataUrl).to.exist
683 expect(file.metadataUrl).to.contain(servers[1].url)
684 expect(file.metadataUrl).to.contain(videoUUID)
685
686 const metadata = await server.videos.getFileMetadata({ url: file.metadataUrl })
687 expect(metadata).to.have.nested.property('format.size')
688 }
689 }
690 })
691
692 it('Should correctly detect if quick transcode is possible', async function () {
693 this.timeout(10_000)
694
695 expect(await canDoQuickTranscode(buildAbsoluteFixturePath('video_short.mp4'))).to.be.true
696 expect(await canDoQuickTranscode(buildAbsoluteFixturePath('video_short.webm'))).to.be.false
697 })
698 })
699
700 describe('Transcoding job queue', function () {
701
702 it('Should have the appropriate priorities for transcoding jobs', async function () {
703 const body = await servers[1].jobs.list({
704 start: 0,
705 count: 100,
706 sort: 'createdAt',
707 jobType: 'video-transcoding'
708 })
709
710 const jobs = body.data
711 const transcodingJobs = jobs.filter(j => j.data.videoUUID === video4k)
712
713 expect(transcodingJobs).to.have.lengthOf(16)
714
715 const hlsJobs = transcodingJobs.filter(j => j.data.type === 'new-resolution-to-hls')
716 const webtorrentJobs = transcodingJobs.filter(j => j.data.type === 'new-resolution-to-webtorrent')
717 const optimizeJobs = transcodingJobs.filter(j => j.data.type === 'optimize-to-webtorrent')
718
719 expect(hlsJobs).to.have.lengthOf(8)
720 expect(webtorrentJobs).to.have.lengthOf(7)
721 expect(optimizeJobs).to.have.lengthOf(1)
722
723 for (const j of optimizeJobs.concat(hlsJobs.concat(webtorrentJobs))) {
724 expect(j.priority).to.be.greaterThan(100)
725 expect(j.priority).to.be.lessThan(150)
726 }
727 })
728 })
729
730 after(async function () {
731 await cleanupTests(servers)
732 })
733})
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 12:49:38 +0000