X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Ftests%2Fapi%2Flive%2Flive-save-replay.ts;h=05ffe8af9e59ff974cc7f3dfff845c098e66638c;hb=6a9b3151822461a85bbc72b7a50e12ffb69bec3a;hp=99d500711c08ab0883c737a43a7a98df5d54f416;hpb=cdd838168d617f70fc04fe7f23846810e7e07082;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/tests/api/live/live-save-replay.ts b/server/tests/api/live/live-save-replay.ts index 99d500711..05ffe8af9 100644 --- a/server/tests/api/live/live-save-replay.ts +++ b/server/tests/api/live/live-save-replay.ts @@ -1,7 +1,6 @@ /* 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' @@ -12,7 +11,6 @@ import { createMultipleServers, doubleFollow, findExternalSavedVideo, - makeRawRequest, PeerTubeServer, setAccessTokensToServers, setDefaultVideoChannel, @@ -24,14 +22,12 @@ import { 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 }) @@ -44,6 +40,7 @@ describe('Save replay setting', function () { privacy: VideoPrivacy.PUBLIC, name: 'my super live', saveReplay: options.replay, + replaySettings: options.replaySettings, permanentLive: options.permanent } @@ -51,7 +48,7 @@ describe('Save replay setting', function () { 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 }) @@ -65,7 +62,7 @@ describe('Save replay setting', function () { 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([ @@ -80,7 +77,7 @@ describe('Save replay setting', function () { 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([ @@ -116,6 +113,13 @@ describe('Save replay setting', function () { } } + 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) @@ -149,7 +153,7 @@ describe('Save replay setting', function () { 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 }) @@ -160,7 +164,7 @@ describe('Save replay setting', function () { }) 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 }) @@ -175,7 +179,7 @@ describe('Save replay setting', function () { }) 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) @@ -190,7 +194,7 @@ describe('Save replay setting', function () { 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 () { @@ -207,12 +211,13 @@ describe('Save replay setting', 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 }) @@ -223,7 +228,7 @@ describe('Save replay setting', function () { 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 () { @@ -236,30 +241,31 @@ describe('Save replay setting', 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) @@ -268,10 +274,18 @@ describe('Save replay setting', function () { 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) @@ -279,8 +293,9 @@ describe('Save replay setting', function () { 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 () { @@ -292,6 +307,10 @@ describe('Save replay setting', 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 @@ -300,26 +319,27 @@ describe('Save replay setting', function () { }) 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) @@ -328,159 +348,219 @@ describe('Save replay setting', function () { 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 }) + }) }) })