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