server/tests/api/live/live-constraints.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 { User, VideoDetails, VideoPrivacy } from '@shared/models'
   6 import {
   7   checkLiveCleanup,
   8   cleanupTests,
   9   createLive,
  10   createUser,
  11   doubleFollow,
  12   flushAndRunMultipleServers,
  13   getMyUserInformation,
  14   getVideo,
  15   runAndTestFfmpegStreamError,
  16   ServerInfo,
  17   setAccessTokensToServers,
  18   setDefaultVideoChannel,
  19   updateCustomSubConfig,
  20   updateUser,
  21   userLogin,
  22   wait,
  23   waitJobs,
  24   waitUntilLivePublished
  25 } from '../../../../shared/extra-utils'
  26
  27 const expect = chai.expect
  28
  29 describe('Test live constraints', function () {
  30   let servers: ServerInfo[] = []
  31   let userId: number
  32   let userAccessToken: string
  33   let userChannelId: number
  34
  35   async function createLiveWrapper (saveReplay: boolean) {
  36     const liveAttributes = {
  37       name: 'user live',
  38       channelId: userChannelId,
  39       privacy: VideoPrivacy.PUBLIC,
  40       saveReplay
  41     }
  42
  43     const res = await createLive(servers[0].url, userAccessToken, liveAttributes)
  44     return res.body.video.uuid as string
  45   }
  46
  47   async function checkSaveReplay (videoId: string, resolutions = [ 720 ]) {
  48     for (const server of servers) {
  49       const res = await getVideo(server.url, videoId)
  50
  51       const video: VideoDetails = res.body
  52       expect(video.isLive).to.be.false
  53       expect(video.duration).to.be.greaterThan(0)
  54     }
  55
  56     await checkLiveCleanup(servers[0], videoId, resolutions)
  57   }
  58
  59   async function waitUntilLivePublishedOnAllServers (videoId: string) {
  60     for (const server of servers) {
  61       await waitUntilLivePublished(server.url, server.accessToken, videoId)
  62     }
  63   }
  64
  65   before(async function () {
  66     this.timeout(120000)
  67
  68     servers = await flushAndRunMultipleServers(2)
  69
  70     // Get the access tokens
  71     await setAccessTokensToServers(servers)
  72     await setDefaultVideoChannel(servers)
  73
  74     await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
  75       live: {
  76         enabled: true,
  77         allowReplay: true,
  78         transcoding: {
  79           enabled: false
  80         }
  81       }
  82     })
  83
  84     {
  85       const user = { username: 'user1', password: 'superpassword' }
  86       const res = await createUser({
  87         url: servers[0].url,
  88         accessToken: servers[0].accessToken,
  89         username: user.username,
  90         password: user.password
  91       })
  92       userId = res.body.user.id
  93
  94       userAccessToken = await userLogin(servers[0], user)
  95
  96       const resMe = await getMyUserInformation(servers[0].url, userAccessToken)
  97       userChannelId = (resMe.body as User).videoChannels[0].id
  98
  99       await updateUser({
 100         url: servers[0].url,
 101         userId,
 102         accessToken: servers[0].accessToken,
 103         videoQuota: 1,
 104         videoQuotaDaily: -1
 105       })
 106     }
 107
 108     // Server 1 and server 2 follow each other
 109     await doubleFollow(servers[0], servers[1])
 110   })
 111
 112   it('Should not have size limit if save replay is disabled', async function () {
 113     this.timeout(60000)
 114
 115     const userVideoLiveoId = await createLiveWrapper(false)
 116     await runAndTestFfmpegStreamError(servers[0].url, userAccessToken, userVideoLiveoId, false)
 117   })
 118
 119   it('Should have size limit depending on user global quota if save replay is enabled', async function () {
 120     this.timeout(60000)
 121
 122     // Wait for user quota memoize cache invalidation
 123     await wait(5000)
 124
 125     const userVideoLiveoId = await createLiveWrapper(true)
 126     await runAndTestFfmpegStreamError(servers[0].url, userAccessToken, userVideoLiveoId, true)
 127
 128     await waitUntilLivePublishedOnAllServers(userVideoLiveoId)
 129     await waitJobs(servers)
 130
 131     await checkSaveReplay(userVideoLiveoId)
 132   })
 133
 134   it('Should have size limit depending on user daily quota if save replay is enabled', async function () {
 135     this.timeout(60000)
 136
 137     // Wait for user quota memoize cache invalidation
 138     await wait(5000)
 139
 140     await updateUser({
 141       url: servers[0].url,
 142       userId,
 143       accessToken: servers[0].accessToken,
 144       videoQuota: -1,
 145       videoQuotaDaily: 1
 146     })
 147
 148     const userVideoLiveoId = await createLiveWrapper(true)
 149     await runAndTestFfmpegStreamError(servers[0].url, userAccessToken, userVideoLiveoId, true)
 150
 151     await waitUntilLivePublishedOnAllServers(userVideoLiveoId)
 152     await waitJobs(servers)
 153
 154     await checkSaveReplay(userVideoLiveoId)
 155   })
 156
 157   it('Should succeed without quota limit', async function () {
 158     this.timeout(60000)
 159
 160     // Wait for user quota memoize cache invalidation
 161     await wait(5000)
 162
 163     await updateUser({
 164       url: servers[0].url,
 165       userId,
 166       accessToken: servers[0].accessToken,
 167       videoQuota: 10 * 1000 * 1000,
 168       videoQuotaDaily: -1
 169     })
 170
 171     const userVideoLiveoId = await createLiveWrapper(true)
 172     await runAndTestFfmpegStreamError(servers[0].url, userAccessToken, userVideoLiveoId, false)
 173   })
 174
 175   it('Should have max duration limit', async function () {
 176     this.timeout(60000)
 177
 178     await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
 179       live: {
 180         enabled: true,
 181         allowReplay: true,
 182         maxDuration: 1,
 183         transcoding: {
 184           enabled: true,
 185           resolutions: {
 186             '240p': true,
 187             '360p': true,
 188             '480p': true,
 189             '720p': true,
 190             '1080p': true,
 191             '1440p': true,
 192             '2160p': true
 193           }
 194         }
 195       }
 196     })
 197
 198     const userVideoLiveoId = await createLiveWrapper(true)
 199     await runAndTestFfmpegStreamError(servers[0].url, userAccessToken, userVideoLiveoId, true)
 200
 201     await waitUntilLivePublishedOnAllServers(userVideoLiveoId)
 202     await waitJobs(servers)
 203
 204     await checkSaveReplay(userVideoLiveoId, [ 720, 480, 360, 240 ])
 205   })
 206
 207   after(async function () {
 208     await cleanupTests(servers)
 209   })
 210 })