server/tests/plugins/plugin-transcoding.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import { expect } from 'chai'
   5 import { join } from 'path'
   6 import { getAudioStream, getVideoFileFPS, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
   7 import { ServerConfig, VideoDetails, VideoPrivacy } from '@shared/models'
   8 import {
   9   buildServerDirectory,
  10   createLive,
  11   getConfig,
  12   getPluginTestPath,
  13   getVideo,
  14   installPlugin,
  15   sendRTMPStreamInVideo,
  16   setAccessTokensToServers,
  17   setDefaultVideoChannel,
  18   uninstallPlugin,
  19   updateCustomSubConfig,
  20   uploadVideoAndGetId,
  21   waitJobs,
  22   waitUntilLivePublished
  23 } from '../../../shared/extra-utils'
  24 import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
  25
  26 async function createLiveWrapper (server: ServerInfo) {
  27   const liveAttributes = {
  28     name: 'live video',
  29     channelId: server.videoChannel.id,
  30     privacy: VideoPrivacy.PUBLIC
  31   }
  32
  33   const res = await createLive(server.url, server.accessToken, liveAttributes)
  34   return res.body.video.uuid
  35 }
  36
  37 function updateConf (server: ServerInfo, vodProfile: string, liveProfile: string) {
  38   return updateCustomSubConfig(server.url, server.accessToken, {
  39     transcoding: {
  40       enabled: true,
  41       profile: vodProfile,
  42       hls: {
  43         enabled: true
  44       },
  45       webtorrent: {
  46         enabled: true
  47       }
  48     },
  49     live: {
  50       transcoding: {
  51         profile: liveProfile,
  52         enabled: true
  53       }
  54     }
  55   })
  56 }
  57
  58 describe('Test transcoding plugins', function () {
  59   let server: ServerInfo
  60
  61   before(async function () {
  62     this.timeout(60000)
  63
  64     server = await flushAndRunServer(1)
  65     await setAccessTokensToServers([ server ])
  66     await setDefaultVideoChannel([ server ])
  67
  68     await updateConf(server, 'default', 'default')
  69   })
  70
  71   describe('When using a plugin adding profiles to existing encoders', function () {
  72
  73     async function checkVideoFPS (uuid: string, type: 'above' | 'below', fps: number) {
  74       const res = await getVideo(server.url, uuid)
  75       const video = res.body as VideoDetails
  76       const files = video.files.concat(...video.streamingPlaylists.map(p => p.files))
  77
  78       for (const file of files) {
  79         if (type === 'above') {
  80           expect(file.fps).to.be.above(fps)
  81         } else {
  82           expect(file.fps).to.be.below(fps)
  83         }
  84       }
  85     }
  86
  87     async function checkLiveFPS (uuid: string, type: 'above' | 'below', fps: number) {
  88       const playlistUrl = `${server.url}/static/streaming-playlists/hls/${uuid}/0.m3u8`
  89       const videoFPS = await getVideoFileFPS(playlistUrl)
  90
  91       if (type === 'above') {
  92         expect(videoFPS).to.be.above(fps)
  93       } else {
  94         expect(videoFPS).to.be.below(fps)
  95       }
  96     }
  97
  98     before(async function () {
  99       await installPlugin({
 100         url: server.url,
 101         accessToken: server.accessToken,
 102         path: getPluginTestPath('-transcoding-one')
 103       })
 104     })
 105
 106     it('Should have the appropriate available profiles', async function () {
 107       const res = await getConfig(server.url)
 108       const config = res.body as ServerConfig
 109
 110       expect(config.transcoding.availableProfiles).to.have.members([ 'default', 'low-vod' ])
 111       expect(config.live.transcoding.availableProfiles).to.have.members([ 'default', 'low-live' ])
 112     })
 113
 114     it('Should not use the plugin profile if not chosen by the admin', async function () {
 115       this.timeout(120000)
 116
 117       const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
 118       await waitJobs([ server ])
 119
 120       await checkVideoFPS(videoUUID, 'above', 20)
 121     })
 122
 123     it('Should use the vod profile', async function () {
 124       this.timeout(120000)
 125
 126       await updateConf(server, 'low-vod', 'default')
 127
 128       const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
 129       await waitJobs([ server ])
 130
 131       await checkVideoFPS(videoUUID, 'below', 12)
 132     })
 133
 134     it('Should not use the plugin profile if not chosen by the admin', async function () {
 135       this.timeout(120000)
 136
 137       const liveVideoId = await createLiveWrapper(server)
 138
 139       await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
 140       await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
 141       await waitJobs([ server ])
 142
 143       await checkLiveFPS(liveVideoId, 'above', 20)
 144     })
 145
 146     it('Should use the live profile', async function () {
 147       this.timeout(120000)
 148
 149       await updateConf(server, 'low-vod', 'low-live')
 150
 151       const liveVideoId = await createLiveWrapper(server)
 152
 153       await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
 154       await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
 155       await waitJobs([ server ])
 156
 157       await checkLiveFPS(liveVideoId, 'below', 12)
 158     })
 159
 160     it('Should default to the default profile if the specified profile does not exist', async function () {
 161       this.timeout(120000)
 162
 163       await uninstallPlugin({ url: server.url, accessToken: server.accessToken, npmName: 'peertube-plugin-test-transcoding-one' })
 164
 165       const res = await getConfig(server.url)
 166       const config = res.body as ServerConfig
 167
 168       expect(config.transcoding.availableProfiles).to.deep.equal([ 'default' ])
 169       expect(config.live.transcoding.availableProfiles).to.deep.equal([ 'default' ])
 170
 171       const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
 172       await waitJobs([ server ])
 173
 174       await checkVideoFPS(videoUUID, 'above', 20)
 175     })
 176
 177   })
 178
 179   describe('When using a plugin adding new encoders', function () {
 180
 181     before(async function () {
 182       await installPlugin({
 183         url: server.url,
 184         accessToken: server.accessToken,
 185         path: getPluginTestPath('-transcoding-two')
 186       })
 187
 188       await updateConf(server, 'test-vod-profile', 'test-live-profile')
 189     })
 190
 191     it('Should use the new vod encoders', async function () {
 192       this.timeout(240000)
 193
 194       const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
 195       await waitJobs([ server ])
 196
 197       const path = buildServerDirectory(server, join('videos', videoUUID + '-720.mp4'))
 198       const audioProbe = await getAudioStream(path)
 199       expect(audioProbe.audioStream.codec_name).to.equal('opus')
 200
 201       const videoProbe = await getVideoStreamFromFile(path)
 202       expect(videoProbe.codec_name).to.equal('vp9')
 203     })
 204
 205     it('Should use the new live encoders', async function () {
 206       this.timeout(120000)
 207
 208       const liveVideoId = await createLiveWrapper(server)
 209
 210       await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
 211       await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
 212       await waitJobs([ server ])
 213
 214       const playlistUrl = `${server.url}/static/streaming-playlists/hls/${liveVideoId}/0.m3u8`
 215       const audioProbe = await getAudioStream(playlistUrl)
 216       expect(audioProbe.audioStream.codec_name).to.equal('opus')
 217
 218       const videoProbe = await getVideoStreamFromFile(playlistUrl)
 219       expect(videoProbe.codec_name).to.equal('h264')
 220     })
 221   })
 222
 223   after(async function () {
 224     await cleanupTests([ server ])
 225   })
 226 })