Add austrian sign language

[github/Chocobozzz/PeerTube.git] / server / tests / api / live / live-save-replay.ts

diff --git a/server/tests/api/live/live-save-replay.ts b/server/tests/api/live/live-save-replay.ts
index fc6acc624e64ca1b6bc892f04b639bf924a6b3e4..8f17b456669627f58e611010ecc0b63e6263c472 100644 (file)
--- a/server/tests/api/live/live-save-replay.ts
+++ b/server/tests/api/live/live-save-replay.ts
@@ -1,11 +1,10 @@
 /* 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'
-import { HttpStatusCode, LiveVideoCreate, VideoPrivacy, VideoState } from '@shared/models'
+import { HttpStatusCode, LiveVideoCreate, LiveVideoError, VideoPrivacy, VideoState } from '@shared/models'
 import {
   cleanupTests,
   ConfigCommand,
@@ -23,8 +22,6 @@ import {
   waitUntilLiveWaitingOnAllServers
 } from '@shared/server-commands'
 
-const expect = chai.expect
-
 describe('Save replay setting', function () {
   let servers: PeerTubeServer[] = []
   let liveVideoUUID: string
@@ -143,6 +140,9 @@ describe('Save replay setting', function () {
   })
 
   describe('With save replay disabled', function () {
+    let sessionStartDateMin: Date
+    let sessionStartDateMax: Date
+    let sessionEndDateMin: Date
 
     it('Should correctly create and federate the "waiting for stream" live', async function () {
       this.timeout(20000)
@@ -160,7 +160,9 @@ describe('Save replay setting', function () {
 
       ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
 
+      sessionStartDateMin = new Date()
       await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+      sessionStartDateMax = new Date()
 
       await waitJobs(servers)
 
@@ -171,6 +173,7 @@ describe('Save replay setting', function () {
     it('Should correctly delete the video files after the stream ended', async function () {
       this.timeout(40000)
 
+      sessionEndDateMin = new Date()
       await stopFfmpeg(ffmpegCommand)
 
       for (const server of servers) {
@@ -183,7 +186,26 @@ 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 () {
+      const { data, total } = await servers[0].live.listSessions({ videoId: liveVideoUUID })
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
+
+      const session = data[0]
+
+      const startDate = new Date(session.startDate)
+      expect(startDate).to.be.above(sessionStartDateMin)
+      expect(startDate).to.be.below(sessionStartDateMax)
+
+      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 () {
@@ -198,7 +220,16 @@ 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 () {
+      const session = await servers[0].live.findLatestSession({ videoId: liveVideoUUID })
+      expect(session.startDate).to.exist
+      expect(session.endDate).to.exist
+
+      expect(session.error).to.equal(LiveVideoError.BLACKLISTED)
+      expect(session.replayVideo).to.not.exist
     })
 
     it('Should correctly terminate the stream on delete and delete the video', async function () {
@@ -207,7 +238,7 @@ describe('Save replay setting', function () {
       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 })
     })
   })
 
@@ -239,6 +270,11 @@ describe('Save replay setting', function () {
     it('Should correctly have saved the live and federated it after the streaming', async function () {
       this.timeout(30000)
 
+      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
+
       await stopFfmpeg(ffmpegCommand)
 
       await waitUntilLiveReplacedByReplayOnAllServers(servers, liveVideoUUID)
@@ -249,6 +285,24 @@ describe('Save replay setting', function () {
       await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
     })
 
+    it('Should find the replay live session', async function () {
+      const session = await servers[0].live.getReplaySession({ videoId: liveVideoUUID })
+
+      expect(session).to.exist
+
+      expect(session.startDate).to.exist
+      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.replayVideo).to.exist
+      expect(session.replayVideo.id).to.exist
+      expect(session.replayVideo.shortUUID).to.exist
+      expect(session.replayVideo.uuid).to.equal(liveVideoUUID)
+    })
+
     it('Should update the saved live and correctly federate the updated attributes', async function () {
       this.timeout(30000)
 
@@ -263,11 +317,11 @@ describe('Save replay setting', function () {
     })
 
     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 })
 
@@ -278,7 +332,7 @@ 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 () {
@@ -287,7 +341,7 @@ describe('Save replay setting', function () {
       await publishLiveAndDelete({ permanent: false, replay: true })
 
       await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
-      await checkLiveCleanup(servers[0], liveVideoUUID, [])
+      await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
     })
   })
 
@@ -337,12 +391,33 @@ describe('Save replay setting', function () {
       lastReplayUUID = 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)
+
+      const sessionFromLive = data[0]
+      const sessionFromReplay = await servers[0].live.getReplaySession({ videoId: lastReplayUUID })
+
+      for (const session of [ sessionFromLive, sessionFromReplay ]) {
+        expect(session.startDate).to.exist
+        expect(session.endDate).to.exist
+
+        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 cleaned up the live files', async function () {
-      await checkLiveCleanup(servers[0], liveVideoUUID, [])
+      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(60000)
+      this.timeout(120000)
 
       await servers[0].videos.remove({ id: lastReplayUUID })
       const { liveDetails } = await publishLiveAndBlacklist({ permanent: true, replay: true })
@@ -357,7 +432,7 @@ describe('Save replay setting', function () {
         await servers[1].videos.get({ id: videoId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
       }
 
-      await checkLiveCleanup(servers[0], liveVideoUUID, [])
+      await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
     })
 
     it('Should correctly terminate the stream on delete and not save the video', async function () {
@@ -369,7 +444,7 @@ describe('Save replay setting', function () {
       expect(replay).to.not.exist
 
       await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
-      await checkLiveCleanup(servers[0], liveVideoUUID, [])
+      await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
     })
   })