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