Merge branch 'release/v1.2.0'

[github/Chocobozzz/PeerTube.git] / server / tests / api / videos / video-transcoder.ts

diff --git a/server/tests/api/videos/video-transcoder.ts b/server/tests/api/videos/video-transcoder.ts
index 0ce5197eaf7f03ba2d99acfd3de89cb846272b1f..eefd32ef81a34e0785a1b2709962542b3bacd1a6 100644 (file)
--- a/server/tests/api/videos/video-transcoder.ts
+++ b/server/tests/api/videos/video-transcoder.ts
@@ -3,13 +3,13 @@
 import * as chai from 'chai'
 import 'mocha'
 import { omit } from 'lodash'
-import * as ffmpeg from 'fluent-ffmpeg'
 import { getMaxBitrate, VideoDetails, VideoResolution, VideoState } from '../../../../shared/models/videos'
 import { audio, getVideoFileBitrate, getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffmpeg-utils'
 import {
   buildAbsoluteFixturePath,
   doubleFollow,
   flushAndRunMultipleServers,
+  generateHighBitrateVideo,
   getMyVideos,
   getVideo,
   getVideosList,
@@ -19,10 +19,9 @@ import {
   setAccessTokensToServers,
   uploadVideo,
   webtorrentAdd
-} from '../../utils'
-import { join } from 'path'
-import { waitJobs } from '../../utils/server/jobs'
-import { pathExists } from 'fs-extra'
+} from '../../../../shared/utils'
+import { extname, join } from 'path'
+import { waitJobs } from '../../../../shared/utils/server/jobs'
 import { VIDEO_TRANSCODING_FPS } from '../../../../server/initializers/constants'
 
 const expect = chai.expect
@@ -123,7 +122,7 @@ describe('Test video transcoding', function () {
       expect(videoDetails.files).to.have.lengthOf(4)
 
       const path = join(root(), 'test2', 'videos', video.uuid + '-240.mp4')
-      const probe = await audio.get(ffmpeg, path)
+      const probe = await audio.get(path)
 
       if (probe.audioStream) {
         expect(probe.audioStream[ 'codec_name' ]).to.be.equal('aac')
@@ -154,7 +153,7 @@ describe('Test video transcoding', function () {
 
       expect(videoDetails.files).to.have.lengthOf(4)
       const path = join(root(), 'test2', 'videos', video.uuid + '-240.mp4')
-      const probe = await audio.get(ffmpeg, path)
+      const probe = await audio.get(path)
       expect(probe).to.not.have.property('audioStream')
     }
   })
@@ -179,9 +178,9 @@ describe('Test video transcoding', function () {
 
       expect(videoDetails.files).to.have.lengthOf(4)
       const fixturePath = buildAbsoluteFixturePath(videoAttributes.fixture)
-      const fixtureVideoProbe = await audio.get(ffmpeg, fixturePath)
+      const fixtureVideoProbe = await audio.get(fixturePath)
       const path = join(root(), 'test2', 'videos', video.uuid + '-240.mp4')
-      const videoProbe = await audio.get(ffmpeg, path)
+      const videoProbe = await audio.get(path)
       if (videoProbe.audioStream && fixtureVideoProbe.audioStream) {
         const toOmit = [ 'max_bit_rate', 'duration', 'duration_ts', 'nb_frames', 'start_time', 'start_pts' ]
         expect(omit(videoProbe.audioStream, toOmit)).to.be.deep.equal(omit(fixtureVideoProbe.audioStream, toOmit))
@@ -283,29 +282,13 @@ describe('Test video transcoding', function () {
     }
   })
 
-  const tempFixturePath = buildAbsoluteFixturePath('video_high_bitrate_1080p.mp4', true)
   it('Should respect maximum bitrate values', async function () {
     this.timeout(160000)
 
+    let tempFixturePath: string
+
     {
-      const exists = await pathExists(tempFixturePath)
-      if (!exists) {
-
-        // Generate a random, high bitrate video on the fly, so we don't have to include
-        // a large file in the repo. The video needs to have a certain minimum length so
-        // that FFmpeg properly applies bitrate limits.
-        // https://stackoverflow.com/a/15795112
-        await new Promise<void>(async (res, rej) => {
-          ffmpeg()
-            .outputOptions([ '-f rawvideo', '-video_size 1920x1080', '-i /dev/urandom' ])
-            .outputOptions([ '-ac 2', '-f s16le', '-i /dev/urandom', '-t 10' ])
-            .outputOptions([ '-maxrate 10M', '-bufsize 10M' ])
-            .output(tempFixturePath)
-            .on('error', rej)
-            .on('end', res)
-            .run()
-        })
-      }
+      tempFixturePath = await generateHighBitrateVideo()
 
       const bitrate = await getVideoFileBitrate(tempFixturePath)
       expect(bitrate).to.be.above(getMaxBitrate(VideoResolution.H_1080P, 60, VIDEO_TRANSCODING_FPS))
@@ -338,6 +321,34 @@ describe('Test video transcoding', function () {
     }
   })
 
+  it('Should accept and transcode additional extensions', async function () {
+    this.timeout(300000)
+
+    for (const fixture of [ 'video_short.mkv', 'video_short.avi' ]) {
+      const videoAttributes = {
+        name: fixture,
+        fixture
+      }
+
+      await uploadVideo(servers[ 1 ].url, servers[ 1 ].accessToken, videoAttributes)
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const res = await getVideosList(server.url)
+
+        const video = res.body.data.find(v => v.name === videoAttributes.name)
+        const res2 = await getVideo(server.url, video.id)
+        const videoDetails = res2.body
+
+        expect(videoDetails.files).to.have.lengthOf(4)
+
+        const magnetUri = videoDetails.files[ 0 ].magnetUri
+        expect(magnetUri).to.contain('.mp4')
+      }
+    }
+  })
+
   after(async function () {
     killallServers(servers)
   })