server/tests/cli/create-transcoding-job.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 { VideoDetails } from '../../../shared/models/videos'
   6 import {
   7   cleanupTests,
   8   doubleFollow,
   9   execCLI,
  10   flushAndRunMultipleServers,
  11   getEnvCli,
  12   getVideo,
  13   getVideosList,
  14   ServerInfo,
  15   setAccessTokensToServers,
  16   updateCustomSubConfig,
  17   uploadVideo
  18 } from '../../../shared/extra-utils'
  19 import { waitJobs } from '../../../shared/extra-utils/server/jobs'
  20
  21 const expect = chai.expect
  22
  23 describe('Test create transcoding jobs', function () {
  24   let servers: ServerInfo[] = []
  25   const videosUUID: string[] = []
  26
  27   const config = {
  28     transcoding: {
  29       enabled: false,
  30       resolutions: {
  31         '240p': true,
  32         '360p': true,
  33         '480p': true,
  34         '720p': true,
  35         '1080p': true,
  36         '2160p': true
  37       },
  38       hls: {
  39         enabled: false
  40       }
  41     }
  42   }
  43
  44   before(async function () {
  45     this.timeout(60000)
  46
  47     // Run server 2 to have transcoding enabled
  48     servers = await flushAndRunMultipleServers(2)
  49     await setAccessTokensToServers(servers)
  50
  51     await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
  52
  53     await doubleFollow(servers[0], servers[1])
  54
  55     for (let i = 1; i <= 5; i++) {
  56       const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video' + i })
  57       videosUUID.push(res.body.video.uuid)
  58     }
  59
  60     await waitJobs(servers)
  61   })
  62
  63   it('Should have two video files on each server', async function () {
  64     this.timeout(30000)
  65
  66     for (const server of servers) {
  67       const res = await getVideosList(server.url)
  68       const videos = res.body.data
  69       expect(videos).to.have.lengthOf(videosUUID.length)
  70
  71       for (const video of videos) {
  72         const res2 = await getVideo(server.url, video.uuid)
  73         const videoDetail: VideoDetails = res2.body
  74         expect(videoDetail.files).to.have.lengthOf(1)
  75         expect(videoDetail.streamingPlaylists).to.have.lengthOf(0)
  76       }
  77     }
  78   })
  79
  80   it('Should run a transcoding job on video 2', async function () {
  81     this.timeout(60000)
  82
  83     const env = getEnvCli(servers[0])
  84     await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[1]}`)
  85
  86     await waitJobs(servers)
  87
  88     for (const server of servers) {
  89       const res = await getVideosList(server.url)
  90       const videos = res.body.data
  91
  92       let infoHashes: { [id: number]: string }
  93
  94       for (const video of videos) {
  95         const res2 = await getVideo(server.url, video.uuid)
  96         const videoDetail: VideoDetails = res2.body
  97
  98         if (video.uuid === videosUUID[1]) {
  99           expect(videoDetail.files).to.have.lengthOf(4)
 100           expect(videoDetail.streamingPlaylists).to.have.lengthOf(0)
 101
 102           if (!infoHashes) {
 103             infoHashes = {}
 104
 105             for (const file of videoDetail.files) {
 106               infoHashes[file.resolution.id.toString()] = file.magnetUri
 107             }
 108           } else {
 109             for (const resolution of Object.keys(infoHashes)) {
 110               const file = videoDetail.files.find(f => f.resolution.id.toString() === resolution)
 111               expect(file.magnetUri).to.equal(infoHashes[resolution])
 112             }
 113           }
 114         } else {
 115           expect(videoDetail.files).to.have.lengthOf(1)
 116           expect(videoDetail.streamingPlaylists).to.have.lengthOf(0)
 117         }
 118       }
 119     }
 120   })
 121
 122   it('Should run a transcoding job on video 1 with resolution', async function () {
 123     this.timeout(60000)
 124
 125     const env = getEnvCli(servers[0])
 126     await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[0]} -r 480`)
 127
 128     await waitJobs(servers)
 129
 130     for (const server of servers) {
 131       const res = await getVideosList(server.url)
 132       const videos = res.body.data
 133       expect(videos).to.have.lengthOf(videosUUID.length)
 134
 135       const res2 = await getVideo(server.url, videosUUID[0])
 136       const videoDetail: VideoDetails = res2.body
 137
 138       expect(videoDetail.files).to.have.lengthOf(2)
 139       expect(videoDetail.files[0].resolution.id).to.equal(720)
 140       expect(videoDetail.files[1].resolution.id).to.equal(480)
 141
 142       expect(videoDetail.streamingPlaylists).to.have.lengthOf(0)
 143     }
 144   })
 145
 146   it('Should generate an HLS resolution', async function () {
 147     this.timeout(120000)
 148
 149     const env = getEnvCli(servers[0])
 150     await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[2]} --generate-hls -r 480`)
 151
 152     await waitJobs(servers)
 153
 154     for (const server of servers) {
 155       const res = await getVideo(server.url, videosUUID[2])
 156       const videoDetail: VideoDetails = res.body
 157
 158       expect(videoDetail.files).to.have.lengthOf(1)
 159       expect(videoDetail.streamingPlaylists).to.have.lengthOf(1)
 160
 161       const files = videoDetail.streamingPlaylists[0].files
 162       expect(files).to.have.lengthOf(1)
 163       expect(files[0].resolution.id).to.equal(480)
 164     }
 165   })
 166
 167   it('Should not duplicate an HLS resolution', async function () {
 168     this.timeout(120000)
 169
 170     const env = getEnvCli(servers[0])
 171     await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[2]} --generate-hls -r 480`)
 172
 173     await waitJobs(servers)
 174
 175     for (const server of servers) {
 176       const res = await getVideo(server.url, videosUUID[2])
 177       const videoDetail: VideoDetails = res.body
 178
 179       const files = videoDetail.streamingPlaylists[0].files
 180       expect(files).to.have.lengthOf(1)
 181       expect(files[0].resolution.id).to.equal(480)
 182     }
 183   })
 184
 185   it('Should generate all HLS resolutions', async function () {
 186     this.timeout(120000)
 187
 188     const env = getEnvCli(servers[0])
 189     await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[3]} --generate-hls`)
 190
 191     await waitJobs(servers)
 192
 193     for (const server of servers) {
 194       const res = await getVideo(server.url, videosUUID[3])
 195       const videoDetail: VideoDetails = res.body
 196
 197       expect(videoDetail.files).to.have.lengthOf(1)
 198       expect(videoDetail.streamingPlaylists).to.have.lengthOf(1)
 199
 200       const files = videoDetail.streamingPlaylists[0].files
 201       expect(files).to.have.lengthOf(4)
 202     }
 203   })
 204
 205   it('Should optimize the video file and generate HLS videos if enabled in config', async function () {
 206     this.timeout(120000)
 207
 208     config.transcoding.hls.enabled = true
 209     await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
 210
 211     const env = getEnvCli(servers[0])
 212     await execCLI(`${env} npm run create-transcoding-job -- -v ${videosUUID[4]}`)
 213
 214     await waitJobs(servers)
 215
 216     for (const server of servers) {
 217       const res = await getVideo(server.url, videosUUID[4])
 218       const videoDetail: VideoDetails = res.body
 219
 220       expect(videoDetail.files).to.have.lengthOf(4)
 221       expect(videoDetail.streamingPlaylists).to.have.lengthOf(1)
 222       expect(videoDetail.streamingPlaylists[0].files).to.have.lengthOf(4)
 223     }
 224   })
 225
 226   after(async function () {
 227     await cleanupTests(servers)
 228   })
 229 })