PeerTube/server/tests/api/live/live-constraints.ts

227 lines
7.4 KiB
TypeScript
Raw Normal View History

2020-11-04 07:16:57 -06:00
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
2022-08-17 08:44:32 -05:00
import { expect } from 'chai'
import { wait } from '@shared/core-utils'
2022-05-03 04:38:07 -05:00
import { LiveVideoError, VideoPrivacy } from '@shared/models'
2020-11-04 07:16:57 -06:00
import {
cleanupTests,
2021-07-07 04:51:09 -05:00
ConfigCommand,
2021-07-16 02:47:51 -05:00
createMultipleServers,
2021-07-16 07:27:30 -05:00
doubleFollow,
2021-07-16 02:47:51 -05:00
PeerTubeServer,
2020-11-04 07:16:57 -06:00
setAccessTokensToServers,
setDefaultVideoChannel,
2022-05-04 03:07:06 -05:00
stopFfmpeg,
2022-05-03 04:38:07 -05:00
waitJobs,
2022-05-03 09:12:10 -05:00
waitUntilLiveReplacedByReplayOnAllServers,
2022-05-03 04:38:07 -05:00
waitUntilLiveWaitingOnAllServers
} from '@shared/server-commands'
import { checkLiveCleanup } from '../../shared'
2020-11-04 07:16:57 -06:00
describe('Test live constraints', function () {
2021-07-16 02:47:51 -05:00
let servers: PeerTubeServer[] = []
2020-11-04 07:16:57 -06:00
let userId: number
let userAccessToken: string
let userChannelId: number
2022-05-03 04:38:07 -05:00
async function createLiveWrapper (options: {
replay: boolean
permanent: boolean
}) {
const { replay, permanent } = options
2020-11-04 07:16:57 -06:00
const liveAttributes = {
name: 'user live',
channelId: userChannelId,
privacy: VideoPrivacy.PUBLIC,
2022-05-03 04:38:07 -05:00
saveReplay: replay,
permanentLive: permanent
2020-11-04 07:16:57 -06:00
}
2021-07-16 02:04:35 -05:00
const { uuid } = await servers[0].live.create({ token: userAccessToken, fields: liveAttributes })
2021-07-08 03:18:40 -05:00
return uuid
2020-11-04 07:16:57 -06:00
}
async function checkSaveReplay (videoId: string, resolutions = [ 720 ]) {
for (const server of servers) {
2021-07-16 02:04:35 -05:00
const video = await server.videos.get({ id: videoId })
2020-11-04 07:16:57 -06:00
expect(video.isLive).to.be.false
expect(video.duration).to.be.greaterThan(0)
}
await checkLiveCleanup({ server: servers[0], permanent: false, videoUUID: videoId, savedResolutions: resolutions })
2020-11-04 07:16:57 -06:00
}
2021-05-07 04:53:46 -05:00
function updateQuota (options: { total: number, daily: number }) {
2021-07-16 02:04:35 -05:00
return servers[0].users.update({
2021-05-07 04:53:46 -05:00
userId,
videoQuota: options.total,
videoQuotaDaily: options.daily
})
}
2020-11-04 07:16:57 -06:00
before(async function () {
this.timeout(120000)
2021-07-16 02:47:51 -05:00
servers = await createMultipleServers(2)
2020-11-04 07:16:57 -06:00
// Get the access tokens
await setAccessTokensToServers(servers)
await setDefaultVideoChannel(servers)
2021-07-16 02:04:35 -05:00
await servers[0].config.updateCustomSubConfig({
2021-07-07 04:51:09 -05:00
newConfig: {
live: {
enabled: true,
allowReplay: true,
transcoding: {
enabled: false
}
2020-11-04 07:16:57 -06:00
}
}
})
{
2021-07-16 02:04:35 -05:00
const res = await servers[0].users.generate('user1')
2021-05-07 04:53:46 -05:00
userId = res.userId
userChannelId = res.userChannelId
userAccessToken = res.token
await updateQuota({ total: 1, daily: -1 })
2020-11-04 07:16:57 -06:00
}
// Server 1 and server 2 follow each other
await doubleFollow(servers[0], servers[1])
})
it('Should not have size limit if save replay is disabled', async function () {
this.timeout(60000)
2022-05-03 04:38:07 -05:00
const userVideoLiveoId = await createLiveWrapper({ replay: false, permanent: false })
2021-07-16 02:04:35 -05:00
await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: false })
2020-11-04 07:16:57 -06:00
})
2022-05-03 04:38:07 -05:00
it('Should have size limit depending on user global quota if save replay is enabled on non permanent live', async function () {
2020-11-04 07:16:57 -06:00
this.timeout(60000)
// Wait for user quota memoize cache invalidation
await wait(5000)
2022-05-03 04:38:07 -05:00
const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: false })
2021-07-16 02:04:35 -05:00
await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
2020-11-04 07:16:57 -06:00
2022-05-03 09:12:10 -05:00
await waitUntilLiveReplacedByReplayOnAllServers(servers, userVideoLiveoId)
2020-11-04 07:16:57 -06:00
await waitJobs(servers)
await checkSaveReplay(userVideoLiveoId)
2022-05-03 04:38:07 -05:00
const session = await servers[0].live.getReplaySession({ videoId: userVideoLiveoId })
expect(session.error).to.equal(LiveVideoError.QUOTA_EXCEEDED)
})
it('Should have size limit depending on user global quota if save replay is enabled on a permanent live', async function () {
this.timeout(60000)
// Wait for user quota memoize cache invalidation
await wait(5000)
const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: true })
await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
await waitJobs(servers)
await waitUntilLiveWaitingOnAllServers(servers, userVideoLiveoId)
const session = await servers[0].live.findLatestSession({ videoId: userVideoLiveoId })
expect(session.error).to.equal(LiveVideoError.QUOTA_EXCEEDED)
2020-11-04 07:16:57 -06:00
})
it('Should have size limit depending on user daily quota if save replay is enabled', async function () {
this.timeout(60000)
// Wait for user quota memoize cache invalidation
await wait(5000)
2021-05-07 04:53:46 -05:00
await updateQuota({ total: -1, daily: 1 })
2020-11-04 07:16:57 -06:00
2022-05-03 04:38:07 -05:00
const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: false })
2021-07-16 02:04:35 -05:00
await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
2020-11-04 07:16:57 -06:00
2022-05-03 09:12:10 -05:00
await waitUntilLiveReplacedByReplayOnAllServers(servers, userVideoLiveoId)
2020-11-04 07:16:57 -06:00
await waitJobs(servers)
await checkSaveReplay(userVideoLiveoId)
2022-05-03 04:38:07 -05:00
const session = await servers[0].live.getReplaySession({ videoId: userVideoLiveoId })
expect(session.error).to.equal(LiveVideoError.QUOTA_EXCEEDED)
2020-11-04 07:16:57 -06:00
})
it('Should succeed without quota limit', async function () {
this.timeout(60000)
// Wait for user quota memoize cache invalidation
await wait(5000)
2021-05-07 04:53:46 -05:00
await updateQuota({ total: 10 * 1000 * 1000, daily: -1 })
2020-11-04 07:16:57 -06:00
2022-05-03 04:38:07 -05:00
const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: false })
2021-07-16 02:04:35 -05:00
await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: false })
2020-11-04 07:16:57 -06:00
})
2022-05-04 03:07:06 -05:00
it('Should have the same quota in admin and as a user', async function () {
this.timeout(120000)
const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: false })
const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ token: userAccessToken, videoId: userVideoLiveoId })
await servers[0].live.waitUntilPublished({ videoId: userVideoLiveoId })
await wait(3000)
const quotaUser = await servers[0].users.getMyQuotaUsed({ token: userAccessToken })
const { data } = await servers[0].users.list()
const quotaAdmin = data.find(u => u.username === 'user1')
expect(quotaUser.videoQuotaUsed).to.equal(quotaAdmin.videoQuotaUsed)
expect(quotaUser.videoQuotaUsedDaily).to.equal(quotaAdmin.videoQuotaUsedDaily)
expect(quotaUser.videoQuotaUsed).to.be.above(10)
expect(quotaUser.videoQuotaUsedDaily).to.be.above(10)
await stopFfmpeg(ffmpegCommand)
})
2020-11-04 07:16:57 -06:00
it('Should have max duration limit', async function () {
2020-12-02 09:58:45 -06:00
this.timeout(60000)
2020-11-04 07:16:57 -06:00
2021-07-16 02:04:35 -05:00
await servers[0].config.updateCustomSubConfig({
2021-07-07 04:51:09 -05:00
newConfig: {
live: {
2020-11-04 07:16:57 -06:00
enabled: true,
2021-07-07 04:51:09 -05:00
allowReplay: true,
maxDuration: 1,
transcoding: {
enabled: true,
resolutions: ConfigCommand.getCustomConfigResolutions(true)
}
2020-11-04 07:16:57 -06:00
}
}
})
2022-05-03 04:38:07 -05:00
const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: false })
2021-07-16 02:04:35 -05:00
await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
2020-11-04 07:16:57 -06:00
2022-05-03 09:12:10 -05:00
await waitUntilLiveReplacedByReplayOnAllServers(servers, userVideoLiveoId)
2020-11-04 07:16:57 -06:00
await waitJobs(servers)
await checkSaveReplay(userVideoLiveoId, [ 720, 480, 360, 240, 144 ])
2022-05-03 04:38:07 -05:00
const session = await servers[0].live.getReplaySession({ videoId: userVideoLiveoId })
expect(session.error).to.equal(LiveVideoError.DURATION_EXCEEDED)
2020-11-04 07:16:57 -06:00
})
after(async function () {
await cleanupTests(servers)
})
})