/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-import 'mocha'
-import * as chai from 'chai'
+import { expect } from 'chai'
import { FfmpegCommand } from 'fluent-ffmpeg'
import { checkLiveCleanup } from '@server/tests/shared'
import { wait } from '@shared/core-utils'
createMultipleServers,
doubleFollow,
findExternalSavedVideo,
- makeRawRequest,
PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
waitUntilLiveWaitingOnAllServers
} from '@shared/server-commands'
-const expect = chai.expect
-
describe('Save replay setting', function () {
let servers: PeerTubeServer[] = []
let liveVideoUUID: string
let ffmpegCommand: FfmpegCommand
- async function createLiveWrapper (options: { permanent: boolean, replay: boolean }) {
+ async function createLiveWrapper (options: { permanent: boolean, replay: boolean, replaySettings?: { privacy: VideoPrivacy } }) {
if (liveVideoUUID) {
try {
await servers[0].videos.remove({ id: liveVideoUUID })
privacy: VideoPrivacy.PUBLIC,
name: 'my super live',
saveReplay: options.replay,
+ replaySettings: options.replaySettings,
permanentLive: options.permanent
}
return uuid
}
- async function publishLive (options: { permanent: boolean, replay: boolean }) {
+ async function publishLive (options: { permanent: boolean, replay: boolean, replaySettings?: { privacy: VideoPrivacy } }) {
liveVideoUUID = await createLiveWrapper(options)
const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
return { ffmpegCommand, liveDetails }
}
- async function publishLiveAndDelete (options: { permanent: boolean, replay: boolean }) {
+ async function publishLiveAndDelete (options: { permanent: boolean, replay: boolean, replaySettings?: { privacy: VideoPrivacy } }) {
const { ffmpegCommand, liveDetails } = await publishLive(options)
await Promise.all([
return { liveDetails }
}
- async function publishLiveAndBlacklist (options: { permanent: boolean, replay: boolean }) {
+ async function publishLiveAndBlacklist (options: { permanent: boolean, replay: boolean, replaySettings?: { privacy: VideoPrivacy } }) {
const { ffmpegCommand, liveDetails } = await publishLive(options)
await Promise.all([
}
}
+ async function checkVideoPrivacy (videoId: string, privacy: VideoPrivacy) {
+ for (const server of servers) {
+ const video = await server.videos.get({ id: videoId })
+ expect(video.privacy.id).to.equal(privacy)
+ }
+ }
+
before(async function () {
this.timeout(120000)
let sessionEndDateMin: Date
it('Should correctly create and federate the "waiting for stream" live', async function () {
- this.timeout(20000)
+ this.timeout(40000)
liveVideoUUID = await createLiveWrapper({ permanent: false, replay: false })
})
it('Should correctly have updated the live and federated it when streaming in the live', async function () {
- this.timeout(30000)
+ this.timeout(60000)
ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
})
it('Should correctly delete the video files after the stream ended', async function () {
- this.timeout(40000)
+ this.timeout(60000)
sessionEndDateMin = new Date()
await stopFfmpeg(ffmpegCommand)
await checkVideoState(liveVideoUUID, VideoState.LIVE_ENDED)
// No resolutions saved since we did not save replay
- await checkLiveCleanup(servers[0], liveVideoUUID, [])
+ await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
})
it('Should have appropriate ended session', async function () {
expect(session.endDate).to.exist
expect(new Date(session.endDate)).to.be.above(sessionEndDateMin)
+ expect(session.saveReplay).to.be.false
expect(session.error).to.not.exist
expect(session.replayVideo).to.not.exist
})
it('Should correctly terminate the stream on blacklist and delete the live', async function () {
- this.timeout(40000)
+ this.timeout(60000)
await publishLiveAndBlacklist({ permanent: false, replay: false })
await wait(5000)
await waitJobs(servers)
- await checkLiveCleanup(servers[0], liveVideoUUID, [])
+ await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
})
it('Should have blacklisted session error', async function () {
})
it('Should correctly terminate the stream on delete and delete the video', async function () {
- this.timeout(40000)
+ this.timeout(60000)
await publishLiveAndDelete({ permanent: false, replay: false })
await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
- await checkLiveCleanup(servers[0], liveVideoUUID, [])
+ await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
})
})
describe('With save replay enabled on non permanent live', function () {
it('Should correctly create and federate the "waiting for stream" live', async function () {
- this.timeout(20000)
+ this.timeout(60000)
- liveVideoUUID = await createLiveWrapper({ permanent: false, replay: true })
+ liveVideoUUID = await createLiveWrapper({ permanent: false, replay: true, replaySettings: { privacy: VideoPrivacy.UNLISTED } })
await waitJobs(servers)
await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
await checkVideoState(liveVideoUUID, VideoState.WAITING_FOR_LIVE)
+ await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.PUBLIC)
})
it('Should correctly have updated the live and federated it when streaming in the live', async function () {
- this.timeout(20000)
+ this.timeout(60000)
ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
+ await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.PUBLIC)
})
it('Should correctly have saved the live and federated it after the streaming', async function () {
- this.timeout(30000)
+ this.timeout(60000)
+
+ const session = await servers[0].live.findLatestSession({ videoId: liveVideoUUID })
+ expect(session.endDate).to.not.exist
+ expect(session.endingProcessed).to.be.false
+ expect(session.saveReplay).to.be.true
+ expect(session.replaySettings).to.exist
+ expect(session.replaySettings.privacy).to.equal(VideoPrivacy.UNLISTED)
await stopFfmpeg(ffmpegCommand)
await waitJobs(servers)
// Live has been transcoded
- await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
+ await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
+ await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.UNLISTED)
})
it('Should find the replay live session', async function () {
expect(session.endDate).to.exist
expect(session.error).to.not.exist
+ expect(session.saveReplay).to.be.true
+ expect(session.endingProcessed).to.be.true
+ expect(session.replaySettings).to.exist
+ expect(session.replaySettings.privacy).to.equal(VideoPrivacy.UNLISTED)
expect(session.replayVideo).to.exist
expect(session.replayVideo.id).to.exist
})
it('Should update the saved live and correctly federate the updated attributes', async function () {
- this.timeout(30000)
+ this.timeout(60000)
- await servers[0].videos.update({ id: liveVideoUUID, attributes: { name: 'video updated' } })
+ await servers[0].videos.update({ id: liveVideoUUID, attributes: { name: 'video updated', privacy: VideoPrivacy.PUBLIC } })
await waitJobs(servers)
for (const server of servers) {
const video = await server.videos.get({ id: liveVideoUUID })
expect(video.name).to.equal('video updated')
expect(video.isLive).to.be.false
+ expect(video.privacy.id).to.equal(VideoPrivacy.PUBLIC)
}
})
it('Should have cleaned up the live files', async function () {
- await checkLiveCleanup(servers[0], liveVideoUUID, [ 720 ])
+ await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false, savedResolutions: [ 720 ] })
})
it('Should correctly terminate the stream on blacklist and blacklist the saved replay video', async function () {
- this.timeout(40000)
+ this.timeout(120000)
- await publishLiveAndBlacklist({ permanent: false, replay: true })
+ await publishLiveAndBlacklist({ permanent: false, replay: true, replaySettings: { privacy: VideoPrivacy.PUBLIC } })
await checkVideosExist(liveVideoUUID, false)
await wait(5000)
await waitJobs(servers)
- await checkLiveCleanup(servers[0], liveVideoUUID, [ 720 ])
+ await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false, savedResolutions: [ 720 ] })
})
it('Should correctly terminate the stream on delete and delete the video', async function () {
- this.timeout(40000)
+ this.timeout(60000)
- await publishLiveAndDelete({ permanent: false, replay: true })
+ await publishLiveAndDelete({ permanent: false, replay: true, replaySettings: { privacy: VideoPrivacy.PUBLIC } })
await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
- await checkLiveCleanup(servers[0], liveVideoUUID, [])
+ await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
})
})
describe('With save replay enabled on permanent live', function () {
let lastReplayUUID: string
- it('Should correctly create and federate the "waiting for stream" live', async function () {
- this.timeout(20000)
+ describe('With a first live and its replay', function () {
- liveVideoUUID = await createLiveWrapper({ permanent: true, replay: true })
+ it('Should correctly create and federate the "waiting for stream" live', async function () {
+ this.timeout(60000)
- await waitJobs(servers)
+ liveVideoUUID = await createLiveWrapper({ permanent: true, replay: true, replaySettings: { privacy: VideoPrivacy.UNLISTED } })
- await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
- await checkVideoState(liveVideoUUID, VideoState.WAITING_FOR_LIVE)
- })
+ await waitJobs(servers)
- it('Should correctly have updated the live and federated it when streaming in the live', async function () {
- this.timeout(20000)
+ await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
+ await checkVideoState(liveVideoUUID, VideoState.WAITING_FOR_LIVE)
+ await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.PUBLIC)
+ })
- ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
- await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+ it('Should correctly have updated the live and federated it when streaming in the live', async function () {
+ this.timeout(60000)
- await waitJobs(servers)
+ ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
+ await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
- await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
- await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
- })
+ await waitJobs(servers)
- it('Should correctly have saved the live and federated it after the streaming', async function () {
- this.timeout(30000)
+ await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
+ await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
+ await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.PUBLIC)
+ })
- const liveDetails = await servers[0].videos.get({ id: liveVideoUUID })
+ it('Should correctly have saved the live and federated it after the streaming', async function () {
+ this.timeout(60000)
- await stopFfmpeg(ffmpegCommand)
+ const liveDetails = await servers[0].videos.get({ id: liveVideoUUID })
- await waitUntilLiveWaitingOnAllServers(servers, liveVideoUUID)
- await waitJobs(servers)
+ await stopFfmpeg(ffmpegCommand)
- const video = await findExternalSavedVideo(servers[0], liveDetails)
- expect(video).to.exist
+ await waitUntilLiveWaitingOnAllServers(servers, liveVideoUUID)
+ await waitJobs(servers)
- for (const server of servers) {
- await server.videos.get({ id: video.uuid })
- }
+ const video = await findExternalSavedVideo(servers[0], liveDetails)
+ expect(video).to.exist
- lastReplayUUID = video.uuid
- })
+ for (const server of servers) {
+ await server.videos.get({ id: video.uuid })
+ }
- it('Should have appropriate ended session and replay live session', async function () {
- const { data, total } = await servers[0].live.listSessions({ videoId: liveVideoUUID })
- expect(total).to.equal(1)
- expect(data).to.have.lengthOf(1)
+ lastReplayUUID = video.uuid
+ })
- const sessionFromLive = data[0]
- const sessionFromReplay = await servers[0].live.getReplaySession({ videoId: lastReplayUUID })
+ it('Should have appropriate ended session and replay live session', async function () {
+ const { data, total } = await servers[0].live.listSessions({ videoId: liveVideoUUID })
+ expect(total).to.equal(1)
+ expect(data).to.have.lengthOf(1)
- for (const session of [ sessionFromLive, sessionFromReplay ]) {
- expect(session.startDate).to.exist
- expect(session.endDate).to.exist
+ const sessionFromLive = data[0]
+ const sessionFromReplay = await servers[0].live.getReplaySession({ videoId: lastReplayUUID })
- expect(session.error).to.not.exist
+ for (const session of [ sessionFromLive, sessionFromReplay ]) {
+ expect(session.startDate).to.exist
+ expect(session.endDate).to.exist
- expect(session.replayVideo).to.exist
- expect(session.replayVideo.id).to.exist
- expect(session.replayVideo.shortUUID).to.exist
- expect(session.replayVideo.uuid).to.equal(lastReplayUUID)
- }
- })
+ expect(session.replaySettings).to.exist
+ expect(session.replaySettings.privacy).to.equal(VideoPrivacy.UNLISTED)
- it('Should have cleaned up the live files', async function () {
- await checkLiveCleanup(servers[0], liveVideoUUID, [])
+ expect(session.error).to.not.exist
+
+ expect(session.replayVideo).to.exist
+ expect(session.replayVideo.id).to.exist
+ expect(session.replayVideo.shortUUID).to.exist
+ expect(session.replayVideo.uuid).to.equal(lastReplayUUID)
+ }
+ })
+
+ it('Should have the first live replay with correct settings', async function () {
+ await checkVideosExist(lastReplayUUID, false, HttpStatusCode.OK_200)
+ await checkVideoState(lastReplayUUID, VideoState.PUBLISHED)
+ await checkVideoPrivacy(lastReplayUUID, VideoPrivacy.UNLISTED)
+ })
})
- it('Should correctly terminate the stream on blacklist and blacklist the saved replay video', async function () {
- this.timeout(60000)
+ describe('With a second live and its replay', function () {
- await servers[0].videos.remove({ id: lastReplayUUID })
- const { liveDetails } = await publishLiveAndBlacklist({ permanent: true, replay: true })
+ it('Should update the replay settings', async function () {
+ await servers[0].live.update({ videoId: liveVideoUUID, fields: { replaySettings: { privacy: VideoPrivacy.PUBLIC } } })
+ await waitJobs(servers)
- const replay = await findExternalSavedVideo(servers[0], liveDetails)
- expect(replay).to.exist
+ const live = await servers[0].live.get({ videoId: liveVideoUUID })
- for (const videoId of [ liveVideoUUID, replay.uuid ]) {
- await checkVideosExist(videoId, false)
+ expect(live.saveReplay).to.be.true
+ expect(live.replaySettings).to.exist
+ expect(live.replaySettings.privacy).to.equal(VideoPrivacy.PUBLIC)
- await servers[0].videos.get({ id: videoId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
- await servers[1].videos.get({ id: videoId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
- }
+ })
- await checkLiveCleanup(servers[0], liveVideoUUID, [])
- })
+ it('Should correctly have updated the live and federated it when streaming in the live', async function () {
+ this.timeout(60000)
- it('Should correctly terminate the stream on delete and not save the video', async function () {
- this.timeout(40000)
+ ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
+ await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
- const { liveDetails } = await publishLiveAndDelete({ permanent: true, replay: true })
+ await waitJobs(servers)
- const replay = await findExternalSavedVideo(servers[0], liveDetails)
- expect(replay).to.not.exist
+ await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
+ await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
+ await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.PUBLIC)
+ })
- await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
- await checkLiveCleanup(servers[0], liveVideoUUID, [])
- })
+ it('Should correctly have saved the live and federated it after the streaming', async function () {
+ this.timeout(60000)
- it('Should correctly save replays with multiple sessions', async function () {
- this.timeout(120000)
+ const liveDetails = await servers[0].videos.get({ id: liveVideoUUID })
- liveVideoUUID = await createLiveWrapper({ permanent: true, replay: true })
- await waitJobs(servers)
+ await stopFfmpeg(ffmpegCommand)
- // Streaming session #1
- ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
- await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
- await stopFfmpeg(ffmpegCommand)
- await servers[0].live.waitUntilWaiting({ videoId: liveVideoUUID })
+ await waitUntilLiveWaitingOnAllServers(servers, liveVideoUUID)
+ await waitJobs(servers)
- // Streaming session #2
- ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
- await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+ const video = await findExternalSavedVideo(servers[0], liveDetails)
+ expect(video).to.exist
- await wait(5000)
- const video = await servers[0].videos.get({ id: liveVideoUUID })
- expect(video.streamingPlaylists).to.have.lengthOf(1)
- await makeRawRequest(video.streamingPlaylists[0].playlistUrl)
+ for (const server of servers) {
+ await server.videos.get({ id: video.uuid })
+ }
- await stopFfmpeg(ffmpegCommand)
- await waitUntilLiveWaitingOnAllServers(servers, liveVideoUUID)
+ lastReplayUUID = video.uuid
+ })
- // Wait for replays
- await waitJobs(servers)
+ it('Should have appropriate ended session and replay live session', async function () {
+ const { data, total } = await servers[0].live.listSessions({ videoId: liveVideoUUID })
+ expect(total).to.equal(2)
+ expect(data).to.have.lengthOf(2)
- const { total, data: sessions } = await servers[0].live.listSessions({ videoId: liveVideoUUID })
+ const sessionFromLive = data[1]
+ const sessionFromReplay = await servers[0].live.getReplaySession({ videoId: lastReplayUUID })
- expect(total).to.equal(2)
- expect(sessions).to.have.lengthOf(2)
+ for (const session of [ sessionFromLive, sessionFromReplay ]) {
+ expect(session.startDate).to.exist
+ expect(session.endDate).to.exist
- for (const session of sessions) {
- expect(session.error).to.be.null
- expect(session.replayVideo).to.exist
+ expect(session.replaySettings).to.exist
+ expect(session.replaySettings.privacy).to.equal(VideoPrivacy.PUBLIC)
- await servers[0].videos.get({ id: session.replayVideo.uuid })
- }
+ expect(session.error).to.not.exist
+
+ expect(session.replayVideo).to.exist
+ expect(session.replayVideo.id).to.exist
+ expect(session.replayVideo.shortUUID).to.exist
+ expect(session.replayVideo.uuid).to.equal(lastReplayUUID)
+ }
+ })
+
+ it('Should have the first live replay with correct settings', async function () {
+ await checkVideosExist(lastReplayUUID, true, HttpStatusCode.OK_200)
+ await checkVideoState(lastReplayUUID, VideoState.PUBLISHED)
+ await checkVideoPrivacy(lastReplayUUID, VideoPrivacy.PUBLIC)
+ })
+
+ it('Should have cleaned up the live files', async function () {
+ await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
+ })
+
+ it('Should correctly terminate the stream on blacklist and blacklist the saved replay video', async function () {
+ this.timeout(120000)
+
+ await servers[0].videos.remove({ id: lastReplayUUID })
+ const { liveDetails } = await publishLiveAndBlacklist({
+ permanent: true,
+ replay: true,
+ replaySettings: { privacy: VideoPrivacy.PUBLIC }
+ })
+
+ const replay = await findExternalSavedVideo(servers[0], liveDetails)
+ expect(replay).to.exist
+
+ for (const videoId of [ liveVideoUUID, replay.uuid ]) {
+ await checkVideosExist(videoId, false)
+
+ await servers[0].videos.get({ id: videoId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+ await servers[1].videos.get({ id: videoId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+ }
+
+ await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
+ })
+
+ it('Should correctly terminate the stream on delete and not save the video', async function () {
+ this.timeout(60000)
+
+ const { liveDetails } = await publishLiveAndDelete({
+ permanent: true,
+ replay: true,
+ replaySettings: { privacy: VideoPrivacy.PUBLIC }
+ })
+
+ const replay = await findExternalSavedVideo(servers[0], liveDetails)
+ expect(replay).to.not.exist
+
+ await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
+ await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
+ })
})
})