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