1 files changed, 122 insertions, 134 deletions

diff --git a/server/tests/plugins/plugin-transcoding.ts b/server/tests/plugins/plugin-transcoding.ts
index eefb2294d..c14c34c7e 100644
--- a/server/tests/plugins/plugin-transcoding.ts
+++ b/server/tests/plugins/plugin-transcoding.ts
@@ -4,77 +4,72 @@ import 'mocha'
 import { expect } from 'chai'
 import { join } from 'path'
 import { getAudioStream, getVideoFileFPS, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
-import { ServerConfig, VideoDetails, VideoPrivacy } from '@shared/models'
 import {
-  buildServerDirectory,
-  createLive,
-  getConfig,
-  getPluginTestPath,
-  getVideo,
-  installPlugin,
-  sendRTMPStreamInVideo,
+  cleanupTests,
+  createSingleServer,
+  PeerTubeServer,
+  PluginsCommand,
   setAccessTokensToServers,
   setDefaultVideoChannel,
   testFfmpegStreamError,
-  uninstallPlugin,
-  updateCustomSubConfig,
-  uploadVideoAndGetId,
-  waitJobs,
-  waitUntilLivePublished
-} from '../../../shared/extra-utils'
-import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
-
-async function createLiveWrapper (server: ServerInfo) {
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoPrivacy } from '@shared/models'
+
+async function createLiveWrapper (server: PeerTubeServer) {
   const liveAttributes = {
     name: 'live video',
-    channelId: server.videoChannel.id,
+    channelId: server.store.channel.id,
     privacy: VideoPrivacy.PUBLIC
   }
 
-  const res = await createLive(server.url, server.accessToken, liveAttributes)
-  return res.body.video.uuid
+  const { uuid } = await server.live.create({ fields: liveAttributes })
+
+  return uuid
 }
 
-function updateConf (server: ServerInfo, vodProfile: string, liveProfile: string) {
-  return updateCustomSubConfig(server.url, server.accessToken, {
-    transcoding: {
-      enabled: true,
-      profile: vodProfile,
-      hls: {
-        enabled: true
-      },
-      webtorrent: {
-        enabled: true
-      },
-      resolutions: {
-        '240p': true,
-        '360p': false,
-        '480p': false,
-        '720p': true
-      }
-    },
-    live: {
+function updateConf (server: PeerTubeServer, vodProfile: string, liveProfile: string) {
+  return server.config.updateCustomSubConfig({
+    newConfig: {
       transcoding: {
-        profile: liveProfile,
         enabled: true,
+        profile: vodProfile,
+        hls: {
+          enabled: true
+        },
+        webtorrent: {
+          enabled: true
+        },
         resolutions: {
           '240p': true,
           '360p': false,
           '480p': false,
           '720p': true
         }
+      },
+      live: {
+        transcoding: {
+          profile: liveProfile,
+          enabled: true,
+          resolutions: {
+            '240p': true,
+            '360p': false,
+            '480p': false,
+            '720p': true
+          }
+        }
       }
     }
   })
 }
 
 describe('Test transcoding plugins', function () {
-  let server: ServerInfo
+  let server: PeerTubeServer
 
   before(async function () {
     this.timeout(60000)
 
-    server = await flushAndRunServer(1)
+    server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
     await setDefaultVideoChannel([ server ])
 
@@ -84,8 +79,7 @@ describe('Test transcoding plugins', function () {
   describe('When using a plugin adding profiles to existing encoders', function () {
 
     async function checkVideoFPS (uuid: string, type: 'above' | 'below', fps: number) {
-      const res = await getVideo(server.url, uuid)
-      const video = res.body as VideoDetails
+      const video = await server.videos.get({ id: uuid })
       const files = video.files.concat(...video.streamingPlaylists.map(p => p.files))
 
       for (const file of files) {
@@ -109,134 +103,132 @@ describe('Test transcoding plugins', function () {
     }
 
     before(async function () {
-      await installPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        path: getPluginTestPath('-transcoding-one')
-      })
+      await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-transcoding-one') })
     })
 
     it('Should have the appropriate available profiles', async function () {
-      const res = await getConfig(server.url)
-      const config = res.body as ServerConfig
+      const config = await server.config.getConfig()
 
       expect(config.transcoding.availableProfiles).to.have.members([ 'default', 'low-vod', 'input-options-vod', 'bad-scale-vod' ])
-      expect(config.live.transcoding.availableProfiles).to.have.members([ 'default', 'low-live', 'input-options-live', 'bad-scale-live' ])
+      expect(config.live.transcoding.availableProfiles).to.have.members([ 'default', 'high-live', 'input-options-live', 'bad-scale-live' ])
     })
 
-    it('Should not use the plugin profile if not chosen by the admin', async function () {
-      this.timeout(240000)
+    describe('VOD', function () {
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
-      await waitJobs([ server ])
+      it('Should not use the plugin profile if not chosen by the admin', async function () {
+        this.timeout(240000)
 
-      await checkVideoFPS(videoUUID, 'above', 20)
-    })
+        const videoUUID = (await server.videos.quickUpload({ name: 'video' })).uuid
+        await waitJobs([ server ])
 
-    it('Should use the vod profile', async function () {
-      this.timeout(240000)
+        await checkVideoFPS(videoUUID, 'above', 20)
+      })
 
-      await updateConf(server, 'low-vod', 'default')
+      it('Should use the vod profile', async function () {
+        this.timeout(240000)
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
-      await waitJobs([ server ])
+        await updateConf(server, 'low-vod', 'default')
 
-      await checkVideoFPS(videoUUID, 'below', 12)
-    })
+        const videoUUID = (await server.videos.quickUpload({ name: 'video' })).uuid
+        await waitJobs([ server ])
 
-    it('Should apply input options in vod profile', async function () {
-      this.timeout(240000)
+        await checkVideoFPS(videoUUID, 'below', 12)
+      })
 
-      await updateConf(server, 'input-options-vod', 'default')
+      it('Should apply input options in vod profile', async function () {
+        this.timeout(240000)
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
-      await waitJobs([ server ])
+        await updateConf(server, 'input-options-vod', 'default')
 
-      await checkVideoFPS(videoUUID, 'below', 6)
-    })
+        const videoUUID = (await server.videos.quickUpload({ name: 'video' })).uuid
+        await waitJobs([ server ])
 
-    it('Should apply the scale filter in vod profile', async function () {
-      this.timeout(240000)
+        await checkVideoFPS(videoUUID, 'below', 6)
+      })
 
-      await updateConf(server, 'bad-scale-vod', 'default')
+      it('Should apply the scale filter in vod profile', async function () {
+        this.timeout(240000)
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
-      await waitJobs([ server ])
+        await updateConf(server, 'bad-scale-vod', 'default')
 
-      // Transcoding failed
-      const res = await getVideo(server.url, videoUUID)
-      const video: VideoDetails = res.body
+        const videoUUID = (await server.videos.quickUpload({ name: 'video' })).uuid
+        await waitJobs([ server ])
 
-      expect(video.files).to.have.lengthOf(1)
-      expect(video.streamingPlaylists).to.have.lengthOf(0)
+        // Transcoding failed
+        const video = await server.videos.get({ id: videoUUID })
+        expect(video.files).to.have.lengthOf(1)
+        expect(video.streamingPlaylists).to.have.lengthOf(0)
+      })
     })
 
-    it('Should not use the plugin profile if not chosen by the admin', async function () {
-      this.timeout(240000)
+    describe('Live', function () {
 
-      const liveVideoId = await createLiveWrapper(server)
+      it('Should not use the plugin profile if not chosen by the admin', async function () {
+        this.timeout(240000)
 
-      await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
-      await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
-      await waitJobs([ server ])
+        const liveVideoId = await createLiveWrapper(server)
 
-      await checkLiveFPS(liveVideoId, 'above', 20)
-    })
+        await server.live.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_very_short_240p.mp4' })
+        await server.live.waitUntilPublished({ videoId: liveVideoId })
+        await waitJobs([ server ])
 
-    it('Should use the live profile', async function () {
-      this.timeout(240000)
+        await checkLiveFPS(liveVideoId, 'above', 20)
+      })
 
-      await updateConf(server, 'low-vod', 'low-live')
+      it('Should use the live profile', async function () {
+        this.timeout(240000)
 
-      const liveVideoId = await createLiveWrapper(server)
+        await updateConf(server, 'low-vod', 'high-live')
 
-      await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
-      await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
-      await waitJobs([ server ])
+        const liveVideoId = await createLiveWrapper(server)
 
-      await checkLiveFPS(liveVideoId, 'below', 12)
-    })
+        await server.live.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_very_short_240p.mp4' })
+        await server.live.waitUntilPublished({ videoId: liveVideoId })
+        await waitJobs([ server ])
 
-    it('Should apply the input options on live profile', async function () {
-      this.timeout(240000)
+        await checkLiveFPS(liveVideoId, 'above', 45)
+      })
 
-      await updateConf(server, 'low-vod', 'input-options-live')
+      it('Should apply the input options on live profile', async function () {
+        this.timeout(240000)
 
-      const liveVideoId = await createLiveWrapper(server)
+        await updateConf(server, 'low-vod', 'input-options-live')
 
-      await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
-      await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
-      await waitJobs([ server ])
+        const liveVideoId = await createLiveWrapper(server)
 
-      await checkLiveFPS(liveVideoId, 'below', 6)
-    })
+        await server.live.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_very_short_240p.mp4' })
+        await server.live.waitUntilPublished({ videoId: liveVideoId })
+        await waitJobs([ server ])
 
-    it('Should apply the scale filter name on live profile', async function () {
-      this.timeout(240000)
+        await checkLiveFPS(liveVideoId, 'above', 45)
+      })
 
-      await updateConf(server, 'low-vod', 'bad-scale-live')
+      it('Should apply the scale filter name on live profile', async function () {
+        this.timeout(240000)
 
-      const liveVideoId = await createLiveWrapper(server)
+        await updateConf(server, 'low-vod', 'bad-scale-live')
 
-      const command = await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
-      await testFfmpegStreamError(command, true)
-    })
+        const liveVideoId = await createLiveWrapper(server)
 
-    it('Should default to the default profile if the specified profile does not exist', async function () {
-      this.timeout(240000)
+        const command = await server.live.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_very_short_240p.mp4' })
+        await testFfmpegStreamError(command, true)
+      })
 
-      await uninstallPlugin({ url: server.url, accessToken: server.accessToken, npmName: 'peertube-plugin-test-transcoding-one' })
+      it('Should default to the default profile if the specified profile does not exist', async function () {
+        this.timeout(240000)
 
-      const res = await getConfig(server.url)
-      const config = res.body as ServerConfig
+        await server.plugins.uninstall({ npmName: 'peertube-plugin-test-transcoding-one' })
 
-      expect(config.transcoding.availableProfiles).to.deep.equal([ 'default' ])
-      expect(config.live.transcoding.availableProfiles).to.deep.equal([ 'default' ])
+        const config = await server.config.getConfig()
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video' })).uuid
-      await waitJobs([ server ])
+        expect(config.transcoding.availableProfiles).to.deep.equal([ 'default' ])
+        expect(config.live.transcoding.availableProfiles).to.deep.equal([ 'default' ])
+
+        const videoUUID = (await server.videos.quickUpload({ name: 'video', fixture: 'video_very_short_240p.mp4' })).uuid
+        await waitJobs([ server ])
 
-      await checkVideoFPS(videoUUID, 'above', 20)
+        await checkVideoFPS(videoUUID, 'above', 20)
+      })
     })
 
   })
@@ -244,11 +236,7 @@ describe('Test transcoding plugins', function () {
   describe('When using a plugin adding new encoders', function () {
 
     before(async function () {
-      await installPlugin({
-        url: server.url,
-        accessToken: server.accessToken,
-        path: getPluginTestPath('-transcoding-two')
-      })
+      await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-transcoding-two') })
 
       await updateConf(server, 'test-vod-profile', 'test-live-profile')
     })
@@ -256,10 +244,10 @@ describe('Test transcoding plugins', function () {
     it('Should use the new vod encoders', async function () {
       this.timeout(240000)
 
-      const videoUUID = (await uploadVideoAndGetId({ server, videoName: 'video', fixture: 'video_short_240p.mp4' })).uuid
+      const videoUUID = (await server.videos.quickUpload({ name: 'video', fixture: 'video_very_short_240p.mp4' })).uuid
       await waitJobs([ server ])
 
-      const path = buildServerDirectory(server, join('videos', videoUUID + '-240.mp4'))
+      const path = server.servers.buildDirectory(join('videos', videoUUID + '-240.mp4'))
       const audioProbe = await getAudioStream(path)
       expect(audioProbe.audioStream.codec_name).to.equal('opus')
 
@@ -272,8 +260,8 @@ describe('Test transcoding plugins', function () {
 
       const liveVideoId = await createLiveWrapper(server)
 
-      await sendRTMPStreamInVideo(server.url, server.accessToken, liveVideoId, 'video_short2.webm')
-      await waitUntilLivePublished(server.url, server.accessToken, liveVideoId)
+      await server.live.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
+      await server.live.waitUntilPublished({ videoId: liveVideoId })
       await waitJobs([ server ])
 
       const playlistUrl = `${server.url}/static/streaming-playlists/hls/${liveVideoId}/0.m3u8`