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