Fix bitrate tests

[github/Chocobozzz/PeerTube.git] / server / tests / api / live / live.ts

diff --git a/server/tests/api/live/live.ts b/server/tests/api/live/live.ts
index 4676a840a5c1d5ee7ead6ace4db530bd7b29c104..0b405dd94dcbfe44b48c8d2a6cd1f1f93f09a9ea 100644 (file)
--- a/server/tests/api/live/live.ts
+++ b/server/tests/api/live/live.ts
@@ -2,10 +2,10 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { join } from 'path'
+import { basename, join } from 'path'
 import { ffprobePromise, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
 import {
-  checkLiveCleanup,
+  checkLiveCleanupAfterSave,
   checkLiveSegmentHash,
   checkResolutionsInMasterPlaylist,
   cleanupTests,
@@ -302,21 +302,21 @@ describe('Test live', function () {
 
       liveVideo = await createLiveWrapper()
 
-      const command = sendRTMPStream(rtmpUrl + '/bad-live', liveVideo.streamKey)
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/bad-live', streamKey: liveVideo.streamKey })
       await testFfmpegStreamError(command, true)
     })
 
     it('Should not allow a stream without the appropriate stream key', async function () {
       this.timeout(60000)
 
-      const command = sendRTMPStream(rtmpUrl + '/live', 'bad-stream-key')
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: 'bad-stream-key' })
       await testFfmpegStreamError(command, true)
     })
 
     it('Should succeed with the correct params', async function () {
       this.timeout(60000)
 
-      const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey)
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
       await testFfmpegStreamError(command, false)
     })
 
@@ -340,7 +340,7 @@ describe('Test live', function () {
 
       await servers[0].blacklist.add({ videoId: liveVideo.uuid })
 
-      const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey)
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
       await testFfmpegStreamError(command, true)
     })
 
@@ -351,7 +351,7 @@ describe('Test live', function () {
 
       await servers[0].videos.remove({ id: liveVideo.uuid })
 
-      const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey)
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
       await testFfmpegStreamError(command, true)
     })
   })
@@ -439,7 +439,7 @@ describe('Test live', function () {
     })
 
     it('Should enable transcoding without additional resolutions', async function () {
-      this.timeout(60000)
+      this.timeout(120000)
 
       liveVideoId = await createLiveWrapper(false)
 
@@ -453,7 +453,7 @@ describe('Test live', function () {
     })
 
     it('Should enable transcoding with some resolutions', async function () {
-      this.timeout(60000)
+      this.timeout(120000)
 
       const resolutions = [ 240, 480 ]
       await updateConf(resolutions)
@@ -468,6 +468,34 @@ describe('Test live', function () {
       await stopFfmpeg(ffmpegCommand)
     })
 
+    it('Should correctly set the appropriate bitrate depending on the input', async function () {
+      this.timeout(120000)
+
+      liveVideoId = await createLiveWrapper(false)
+
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({
+        videoId: liveVideoId,
+        fixtureName: 'video_short.mp4',
+        copyCodecs: true
+      })
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+      await waitJobs(servers)
+
+      const video = await servers[0].videos.get({ id: liveVideoId })
+
+      const masterPlaylist = video.streamingPlaylists[0].playlistUrl
+      const probe = await ffprobePromise(masterPlaylist)
+
+      const bitrates = probe.streams.map(s => parseInt(s.tags.variant_bitrate))
+      for (const bitrate of bitrates) {
+        expect(bitrate).to.exist
+        expect(isNaN(bitrate)).to.be.false
+        expect(bitrate).to.be.below(61_000_000) // video_short.mp4 bitrate
+      }
+
+      await stopFfmpeg(ffmpegCommand)
+    })
+
     it('Should enable transcoding with some resolutions and correctly save them', async function () {
       this.timeout(200000)
 
@@ -489,10 +517,16 @@ describe('Test live', function () {
 
       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 
-      const bitrateLimits = {
-        720: 5000 * 1000, // 60FPS
-        360: 1100 * 1000,
-        240: 600 * 1000
+      const maxBitrateLimits = {
+        720: 6500 * 1000, // 60FPS
+        360: 1250 * 1000,
+        240: 700 * 1000
+      }
+
+      const minBitrateLimits = {
+        720: 5500 * 1000,
+        360: 1000 * 1000,
+        240: 550 * 1000
       }
 
       for (const server of servers) {
@@ -506,6 +540,10 @@ describe('Test live', function () {
         await makeRawRequest(hlsPlaylist.playlistUrl, HttpStatusCode.OK_200)
         await makeRawRequest(hlsPlaylist.segmentsSha256Url, HttpStatusCode.OK_200)
 
+        // We should have generated random filenames
+        expect(basename(hlsPlaylist.playlistUrl)).to.not.equal('master.m3u8')
+        expect(basename(hlsPlaylist.segmentsSha256Url)).to.not.equal('segments-sha256.json')
+
         expect(hlsPlaylist.files).to.have.lengthOf(resolutions.length)
 
         for (const resolution of resolutions) {
@@ -520,13 +558,16 @@ describe('Test live', function () {
             expect(file.fps).to.be.approximately(30, 2)
           }
 
-          const filename = `${video.uuid}-${resolution}-fragmented.mp4`
+          const filename = basename(file.fileUrl)
+          expect(filename).to.not.contain(video.uuid)
+
           const segmentPath = servers[0].servers.buildDirectory(join('streaming-playlists', 'hls', video.uuid, filename))
 
           const probe = await ffprobePromise(segmentPath)
           const videoStream = await getVideoStreamFromFile(segmentPath, probe)
 
-          expect(probe.format.bit_rate).to.be.below(bitrateLimits[videoStream.height])
+          expect(probe.format.bit_rate).to.be.below(maxBitrateLimits[videoStream.height])
+          expect(probe.format.bit_rate).to.be.at.least(minBitrateLimits[videoStream.height])
 
           await makeRawRequest(file.torrentUrl, HttpStatusCode.OK_200)
           await makeRawRequest(file.fileUrl, HttpStatusCode.OK_200)
@@ -537,7 +578,7 @@ describe('Test live', function () {
     it('Should correctly have cleaned up the live files', async function () {
       this.timeout(30000)
 
-      await checkLiveCleanup(servers[0], liveVideoId, [ 240, 360, 720 ])
+      await checkLiveCleanupAfterSave(servers[0], liveVideoId, [ 240, 360, 720 ])
     })
   })