1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
4 import * as chai from 'chai'
5 import { FfmpegCommand } from 'fluent-ffmpeg'
6 import { checkLiveCleanup } from '@server/tests/shared'
7 import { wait } from '@shared/core-utils'
8 import { HttpStatusCode, LiveVideoCreate, LiveVideoError, VideoPrivacy, VideoState } from '@shared/models'
12 createMultipleServers,
14 findExternalSavedVideo,
16 setAccessTokensToServers,
17 setDefaultVideoChannel,
19 testFfmpegStreamError,
21 waitUntilLivePublishedOnAllServers,
22 waitUntilLiveReplacedByReplayOnAllServers,
23 waitUntilLiveWaitingOnAllServers
24 } from '@shared/server-commands'
26 const expect = chai.expect
28 describe('Save replay setting', function () {
29 let servers: PeerTubeServer[] = []
30 let liveVideoUUID: string
31 let ffmpegCommand: FfmpegCommand
33 async function createLiveWrapper (options: { permanent: boolean, replay: boolean }) {
36 await servers[0].videos.remove({ id: liveVideoUUID })
37 await waitJobs(servers)
41 const attributes: LiveVideoCreate = {
42 channelId: servers[0].store.channel.id,
43 privacy: VideoPrivacy.PUBLIC,
44 name: 'my super live',
45 saveReplay: options.replay,
46 permanentLive: options.permanent
49 const { uuid } = await servers[0].live.create({ fields: attributes })
53 async function publishLive (options: { permanent: boolean, replay: boolean }) {
54 liveVideoUUID = await createLiveWrapper(options)
56 const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
57 await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
59 const liveDetails = await servers[0].videos.get({ id: liveVideoUUID })
61 await waitJobs(servers)
62 await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
64 return { ffmpegCommand, liveDetails }
67 async function publishLiveAndDelete (options: { permanent: boolean, replay: boolean }) {
68 const { ffmpegCommand, liveDetails } = await publishLive(options)
71 servers[0].videos.remove({ id: liveVideoUUID }),
72 testFfmpegStreamError(ffmpegCommand, true)
75 await waitJobs(servers)
77 await waitJobs(servers)
79 return { liveDetails }
82 async function publishLiveAndBlacklist (options: { permanent: boolean, replay: boolean }) {
83 const { ffmpegCommand, liveDetails } = await publishLive(options)
86 servers[0].blacklist.add({ videoId: liveVideoUUID, reason: 'bad live', unfederate: true }),
87 testFfmpegStreamError(ffmpegCommand, true)
90 await waitJobs(servers)
92 await waitJobs(servers)
94 return { liveDetails }
97 async function checkVideosExist (videoId: string, existsInList: boolean, expectedStatus?: number) {
98 for (const server of servers) {
99 const length = existsInList ? 1 : 0
101 const { data, total } = await server.videos.list()
102 expect(data).to.have.lengthOf(length)
103 expect(total).to.equal(length)
105 if (expectedStatus) {
106 await server.videos.get({ id: videoId, expectedStatus })
111 async function checkVideoState (videoId: string, state: VideoState) {
112 for (const server of servers) {
113 const video = await server.videos.get({ id: videoId })
114 expect(video.state.id).to.equal(state)
118 before(async function () {
121 servers = await createMultipleServers(2)
123 // Get the access tokens
124 await setAccessTokensToServers(servers)
125 await setDefaultVideoChannel(servers)
127 // Server 1 and server 2 follow each other
128 await doubleFollow(servers[0], servers[1])
130 await servers[0].config.updateCustomSubConfig({
138 resolutions: ConfigCommand.getCustomConfigResolutions(true)
145 describe('With save replay disabled', function () {
146 let sessionStartDateMin: Date
147 let sessionStartDateMax: Date
148 let sessionEndDateMin: Date
150 it('Should correctly create and federate the "waiting for stream" live', async function () {
153 liveVideoUUID = await createLiveWrapper({ permanent: false, replay: false })
155 await waitJobs(servers)
157 await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
158 await checkVideoState(liveVideoUUID, VideoState.WAITING_FOR_LIVE)
161 it('Should correctly have updated the live and federated it when streaming in the live', async function () {
164 ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
166 sessionStartDateMin = new Date()
167 await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
168 sessionStartDateMax = new Date()
170 await waitJobs(servers)
172 await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
173 await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
176 it('Should correctly delete the video files after the stream ended', async function () {
179 sessionEndDateMin = new Date()
180 await stopFfmpeg(ffmpegCommand)
182 for (const server of servers) {
183 await server.live.waitUntilEnded({ videoId: liveVideoUUID })
185 await waitJobs(servers)
187 // Live still exist, but cannot be played anymore
188 await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
189 await checkVideoState(liveVideoUUID, VideoState.LIVE_ENDED)
191 // No resolutions saved since we did not save replay
192 await checkLiveCleanup(servers[0], liveVideoUUID, [])
195 it('Should have appropriate ended session', async function () {
196 const { data, total } = await servers[0].live.listSessions({ videoId: liveVideoUUID })
197 expect(total).to.equal(1)
198 expect(data).to.have.lengthOf(1)
200 const session = data[0]
202 const startDate = new Date(session.startDate)
203 expect(startDate).to.be.above(sessionStartDateMin)
204 expect(startDate).to.be.below(sessionStartDateMax)
206 expect(session.endDate).to.exist
207 expect(new Date(session.endDate)).to.be.above(sessionEndDateMin)
209 expect(session.saveReplay).to.be.false
210 expect(session.error).to.not.exist
211 expect(session.replayVideo).to.not.exist
214 it('Should correctly terminate the stream on blacklist and delete the live', async function () {
217 await publishLiveAndBlacklist({ permanent: false, replay: false })
219 await checkVideosExist(liveVideoUUID, false)
221 await servers[0].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
222 await servers[1].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
225 await waitJobs(servers)
226 await checkLiveCleanup(servers[0], liveVideoUUID, [])
229 it('Should have blacklisted session error', async function () {
230 const session = await servers[0].live.findLatestSession({ videoId: liveVideoUUID })
231 expect(session.startDate).to.exist
232 expect(session.endDate).to.exist
234 expect(session.error).to.equal(LiveVideoError.BLACKLISTED)
235 expect(session.replayVideo).to.not.exist
238 it('Should correctly terminate the stream on delete and delete the video', async function () {
241 await publishLiveAndDelete({ permanent: false, replay: false })
243 await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
244 await checkLiveCleanup(servers[0], liveVideoUUID, [])
248 describe('With save replay enabled on non permanent live', function () {
250 it('Should correctly create and federate the "waiting for stream" live', async function () {
253 liveVideoUUID = await createLiveWrapper({ permanent: false, replay: true })
255 await waitJobs(servers)
257 await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
258 await checkVideoState(liveVideoUUID, VideoState.WAITING_FOR_LIVE)
261 it('Should correctly have updated the live and federated it when streaming in the live', async function () {
264 ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
265 await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
267 await waitJobs(servers)
269 await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
270 await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
273 it('Should correctly have saved the live and federated it after the streaming', async function () {
276 const session = await servers[0].live.findLatestSession({ videoId: liveVideoUUID })
277 expect(session.endDate).to.not.exist
278 expect(session.endingProcessed).to.be.false
279 expect(session.saveReplay).to.be.true
281 await stopFfmpeg(ffmpegCommand)
283 await waitUntilLiveReplacedByReplayOnAllServers(servers, liveVideoUUID)
284 await waitJobs(servers)
286 // Live has been transcoded
287 await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
288 await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
291 it('Should find the replay live session', async function () {
292 const session = await servers[0].live.getReplaySession({ videoId: liveVideoUUID })
294 expect(session).to.exist
296 expect(session.startDate).to.exist
297 expect(session.endDate).to.exist
299 expect(session.error).to.not.exist
300 expect(session.saveReplay).to.be.true
301 expect(session.endingProcessed).to.be.true
303 expect(session.replayVideo).to.exist
304 expect(session.replayVideo.id).to.exist
305 expect(session.replayVideo.shortUUID).to.exist
306 expect(session.replayVideo.uuid).to.equal(liveVideoUUID)
309 it('Should update the saved live and correctly federate the updated attributes', async function () {
312 await servers[0].videos.update({ id: liveVideoUUID, attributes: { name: 'video updated' } })
313 await waitJobs(servers)
315 for (const server of servers) {
316 const video = await server.videos.get({ id: liveVideoUUID })
317 expect(video.name).to.equal('video updated')
318 expect(video.isLive).to.be.false
322 it('Should have cleaned up the live files', async function () {
323 await checkLiveCleanup(servers[0], liveVideoUUID, [ 720 ])
326 it('Should correctly terminate the stream on blacklist and blacklist the saved replay video', async function () {
329 await publishLiveAndBlacklist({ permanent: false, replay: true })
331 await checkVideosExist(liveVideoUUID, false)
333 await servers[0].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
334 await servers[1].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
337 await waitJobs(servers)
338 await checkLiveCleanup(servers[0], liveVideoUUID, [ 720 ])
341 it('Should correctly terminate the stream on delete and delete the video', async function () {
344 await publishLiveAndDelete({ permanent: false, replay: true })
346 await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
347 await checkLiveCleanup(servers[0], liveVideoUUID, [])
351 describe('With save replay enabled on permanent live', function () {
352 let lastReplayUUID: string
354 it('Should correctly create and federate the "waiting for stream" live', async function () {
357 liveVideoUUID = await createLiveWrapper({ permanent: true, replay: true })
359 await waitJobs(servers)
361 await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
362 await checkVideoState(liveVideoUUID, VideoState.WAITING_FOR_LIVE)
365 it('Should correctly have updated the live and federated it when streaming in the live', async function () {
368 ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
369 await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
371 await waitJobs(servers)
373 await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
374 await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
377 it('Should correctly have saved the live and federated it after the streaming', async function () {
380 const liveDetails = await servers[0].videos.get({ id: liveVideoUUID })
382 await stopFfmpeg(ffmpegCommand)
384 await waitUntilLiveWaitingOnAllServers(servers, liveVideoUUID)
385 await waitJobs(servers)
387 const video = await findExternalSavedVideo(servers[0], liveDetails)
388 expect(video).to.exist
390 for (const server of servers) {
391 await server.videos.get({ id: video.uuid })
394 lastReplayUUID = video.uuid
397 it('Should have appropriate ended session and replay live session', async function () {
398 const { data, total } = await servers[0].live.listSessions({ videoId: liveVideoUUID })
399 expect(total).to.equal(1)
400 expect(data).to.have.lengthOf(1)
402 const sessionFromLive = data[0]
403 const sessionFromReplay = await servers[0].live.getReplaySession({ videoId: lastReplayUUID })
405 for (const session of [ sessionFromLive, sessionFromReplay ]) {
406 expect(session.startDate).to.exist
407 expect(session.endDate).to.exist
409 expect(session.error).to.not.exist
411 expect(session.replayVideo).to.exist
412 expect(session.replayVideo.id).to.exist
413 expect(session.replayVideo.shortUUID).to.exist
414 expect(session.replayVideo.uuid).to.equal(lastReplayUUID)
418 it('Should have cleaned up the live files', async function () {
419 await checkLiveCleanup(servers[0], liveVideoUUID, [])
422 it('Should correctly terminate the stream on blacklist and blacklist the saved replay video', async function () {
425 await servers[0].videos.remove({ id: lastReplayUUID })
426 const { liveDetails } = await publishLiveAndBlacklist({ permanent: true, replay: true })
428 const replay = await findExternalSavedVideo(servers[0], liveDetails)
429 expect(replay).to.exist
431 for (const videoId of [ liveVideoUUID, replay.uuid ]) {
432 await checkVideosExist(videoId, false)
434 await servers[0].videos.get({ id: videoId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
435 await servers[1].videos.get({ id: videoId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
438 await checkLiveCleanup(servers[0], liveVideoUUID, [])
441 it('Should correctly terminate the stream on delete and not save the video', async function () {
444 const { liveDetails } = await publishLiveAndDelete({ permanent: true, replay: true })
446 const replay = await findExternalSavedVideo(servers[0], liveDetails)
447 expect(replay).to.not.exist
449 await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
450 await checkLiveCleanup(servers[0], liveVideoUUID, [])
454 after(async function () {
455 await cleanupTests(servers)