server/tests/api/transcoding/audio-only.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import * as chai from 'chai'
   4 import { getAudioStream, getVideoStreamDimensionsInfo } from '@server/helpers/ffmpeg'
   5 import {
   6   cleanupTests,
   7   createMultipleServers,
   8   doubleFollow,
   9   PeerTubeServer,
  10   setAccessTokensToServers,
  11   waitJobs
  12 } from '@shared/server-commands'
  13
  14 const expect = chai.expect
  15
  16 describe('Test audio only video transcoding', function () {
  17   let servers: PeerTubeServer[] = []
  18   let videoUUID: string
  19   let webtorrentAudioFileUrl: string
  20   let fragmentedAudioFileUrl: string
  21
  22   before(async function () {
  23     this.timeout(120000)
  24
  25     const configOverride = {
  26       transcoding: {
  27         enabled: true,
  28         resolutions: {
  29           '0p': true,
  30           '144p': false,
  31           '240p': true,
  32           '360p': false,
  33           '480p': false,
  34           '720p': false,
  35           '1080p': false,
  36           '1440p': false,
  37           '2160p': false
  38         },
  39         hls: {
  40           enabled: true
  41         },
  42         webtorrent: {
  43           enabled: true
  44         }
  45       }
  46     }
  47     servers = await createMultipleServers(2, configOverride)
  48
  49     // Get the access tokens
  50     await setAccessTokensToServers(servers)
  51
  52     // Server 1 and server 2 follow each other
  53     await doubleFollow(servers[0], servers[1])
  54   })
  55
  56   it('Should upload a video and transcode it', async function () {
  57     this.timeout(120000)
  58
  59     const { uuid } = await servers[0].videos.upload({ attributes: { name: 'audio only' } })
  60     videoUUID = uuid
  61
  62     await waitJobs(servers)
  63
  64     for (const server of servers) {
  65       const video = await server.videos.get({ id: videoUUID })
  66       expect(video.streamingPlaylists).to.have.lengthOf(1)
  67
  68       for (const files of [ video.files, video.streamingPlaylists[0].files ]) {
  69         expect(files).to.have.lengthOf(3)
  70         expect(files[0].resolution.id).to.equal(720)
  71         expect(files[1].resolution.id).to.equal(240)
  72         expect(files[2].resolution.id).to.equal(0)
  73       }
  74
  75       if (server.serverNumber === 1) {
  76         webtorrentAudioFileUrl = video.files[2].fileUrl
  77         fragmentedAudioFileUrl = video.streamingPlaylists[0].files[2].fileUrl
  78       }
  79     }
  80   })
  81
  82   it('0p transcoded video should not have video', async function () {
  83     const paths = [
  84       servers[0].servers.buildWebTorrentFilePath(webtorrentAudioFileUrl),
  85       servers[0].servers.buildFragmentedFilePath(videoUUID, fragmentedAudioFileUrl)
  86     ]
  87
  88     for (const path of paths) {
  89       const { audioStream } = await getAudioStream(path)
  90       expect(audioStream['codec_name']).to.be.equal('aac')
  91       expect(audioStream['bit_rate']).to.be.at.most(384 * 8000)
  92
  93       const size = await getVideoStreamDimensionsInfo(path)
  94       expect(size).to.not.exist
  95     }
  96   })
  97
  98   after(async function () {
  99     await cleanupTests(servers)
 100   })
 101 })