server/tests/api/videos/video-transcoder.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import * as chai from 'chai'
   5 import { omit } from 'lodash'
   6 import { canDoQuickTranscode } from '@server/helpers/ffmpeg'
   7 import { generateHighBitrateVideo, generateVideoWithFramerate, getAllFiles } from '@server/tests/shared'
   8 import { buildAbsoluteFixturePath, getMaxBitrate, getMinLimitBitrate } from '@shared/core-utils'
   9 import {
  10   getAudioStream,
  11   buildFileMetadata,
  12   getVideoStreamBitrate,
  13   getVideoStreamFPS,
  14   getVideoStreamDimensionsInfo,
  15   hasAudioStream
  16 } from '@shared/extra-utils'
  17 import { HttpStatusCode, VideoState } from '@shared/models'
  18 import {
  19   cleanupTests,
  20   createMultipleServers,
  21   doubleFollow,
  22   makeGetRequest,
  23   PeerTubeServer,
  24   setAccessTokensToServers,
  25   waitJobs,
  26   webtorrentAdd
  27 } from '@shared/server-commands'
  28
  29 const expect = chai.expect
  30
  31 function 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
  56 describe('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 })