Fix s3 mock cleanup

[github/Chocobozzz/PeerTube.git] / server / tests / api / object-storage / live.ts

diff --git a/server/tests/api/object-storage/live.ts b/server/tests/api/object-storage/live.ts
index 7e16b4c890483bde7560bf37f35d39b5a45a358e..07ff4763b9e604abf211f2427bac766470de307e 100644 (file)
--- a/server/tests/api/object-storage/live.ts
+++ b/server/tests/api/object-storage/live.ts
@@ -1,14 +1,14 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import { expect } from 'chai'
-import { expectStartWith, testVideoResolutions } from '@server/tests/shared'
-import { areObjectStorageTestsDisabled } from '@shared/core-utils'
+import { expectStartWith, MockObjectStorageProxy, SQLCommand, testLiveVideoResolutions } from '@server/tests/shared'
+import { areMockObjectStorageTestsDisabled } from '@shared/core-utils'
 import { HttpStatusCode, LiveVideoCreate, VideoPrivacy } from '@shared/models'
 import {
+  cleanupTests,
   createMultipleServers,
   doubleFollow,
   findExternalSavedVideo,
-  killallServers,
   makeRawRequest,
   ObjectStorageCommand,
   PeerTubeServer,
@@ -27,6 +27,7 @@ async function createLive (server: PeerTubeServer, permanent: boolean) {
     privacy: VideoPrivacy.PUBLIC,
     name: 'my super live',
     saveReplay: true,
+    replaySettings: { privacy: VideoPrivacy.PUBLIC },
     permanentLive: permanent
   }
 
@@ -35,7 +36,14 @@ async function createLive (server: PeerTubeServer, permanent: boolean) {
   return uuid
 }
 
-async function checkFilesExist (servers: PeerTubeServer[], videoUUID: string, numberOfFiles: number) {
+async function checkFilesExist (options: {
+  servers: PeerTubeServer[]
+  videoUUID: string
+  numberOfFiles: number
+  objectStorage: ObjectStorageCommand
+}) {
+  const { servers, videoUUID, numberOfFiles, objectStorage } = options
+
   for (const server of servers) {
     const video = await server.videos.get({ id: videoUUID })
 
@@ -46,14 +54,21 @@ async function checkFilesExist (servers: PeerTubeServer[], videoUUID: string, nu
     expect(files).to.have.lengthOf(numberOfFiles)
 
     for (const file of files) {
-      expectStartWith(file.fileUrl, ObjectStorageCommand.getPlaylistBaseUrl())
+      expectStartWith(file.fileUrl, objectStorage.getMockPlaylistBaseUrl())
 
-      await makeRawRequest(file.fileUrl, HttpStatusCode.OK_200)
+      await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
     }
   }
 }
 
-async function checkFilesCleanup (server: PeerTubeServer, videoUUID: string, resolutions: number[]) {
+async function checkFilesCleanup (options: {
+  server: PeerTubeServer
+  videoUUID: string
+  resolutions: number[]
+  objectStorage: ObjectStorageCommand
+}) {
+  const { server, videoUUID, resolutions, objectStorage } = options
+
   const resolutionFiles = resolutions.map((_value, i) => `${i}.m3u8`)
 
   for (const playlistName of [ 'master.m3u8' ].concat(resolutionFiles)) {
@@ -61,7 +76,7 @@ async function checkFilesCleanup (server: PeerTubeServer, videoUUID: string, res
       videoUUID,
       playlistName,
       expectedStatus: HttpStatusCode.NOT_FOUND_404,
-      objectStorage: true
+      objectStorage
     })
   }
 
@@ -69,31 +84,34 @@ async function checkFilesCleanup (server: PeerTubeServer, videoUUID: string, res
     videoUUID,
     playlistNumber: 0,
     segment: 0,
-    objectStorage: true,
+    objectStorage,
     expectedStatus: HttpStatusCode.NOT_FOUND_404
   })
 }
 
 describe('Object storage for lives', function () {
-  if (areObjectStorageTestsDisabled()) return
+  if (areMockObjectStorageTestsDisabled()) return
 
   let servers: PeerTubeServer[]
+  let sqlCommandServer1: SQLCommand
+  const objectStorage = new ObjectStorageCommand()
 
   before(async function () {
     this.timeout(120000)
 
-    await ObjectStorageCommand.prepareDefaultBuckets()
-
-    servers = await createMultipleServers(2, ObjectStorageCommand.getDefaultConfig())
+    await objectStorage.prepareDefaultMockBuckets()
+    servers = await createMultipleServers(2, objectStorage.getDefaultMockConfig())
 
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
     await doubleFollow(servers[0], servers[1])
 
     await servers[0].config.enableTranscoding()
+
+    sqlCommandServer1 = new SQLCommand(servers[0])
   })
 
-  describe('Without live transcoding', async function () {
+  describe('Without live transcoding', function () {
     let videoUUID: string
 
     before(async function () {
@@ -108,13 +126,14 @@ describe('Object storage for lives', function () {
       const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
       await waitUntilLivePublishedOnAllServers(servers, videoUUID)
 
-      await testVideoResolutions({
+      await testLiveVideoResolutions({
         originServer: servers[0],
+        sqlCommand: sqlCommandServer1,
         servers,
         liveVideoId: videoUUID,
         resolutions: [ 720 ],
         transcoded: false,
-        objectStorage: true
+        objectStorage
       })
 
       await stopFfmpeg(ffmpegCommand)
@@ -126,15 +145,15 @@ describe('Object storage for lives', function () {
       await waitUntilLiveReplacedByReplayOnAllServers(servers, videoUUID)
       await waitJobs(servers)
 
-      await checkFilesExist(servers, videoUUID, 1)
+      await checkFilesExist({ servers, videoUUID, numberOfFiles: 1, objectStorage })
     })
 
     it('Should have cleaned up live files from object storage', async function () {
-      await checkFilesCleanup(servers[0], videoUUID, [ 720 ])
+      await checkFilesCleanup({ server: servers[0], videoUUID, resolutions: [ 720 ], objectStorage })
     })
   })
 
-  describe('With live transcoding', async function () {
+  describe('With live transcoding', function () {
     const resolutions = [ 720, 480, 360, 240, 144 ]
 
     before(async function () {
@@ -154,13 +173,14 @@ describe('Object storage for lives', function () {
         const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDNonPermanent })
         await waitUntilLivePublishedOnAllServers(servers, videoUUIDNonPermanent)
 
-        await testVideoResolutions({
+        await testLiveVideoResolutions({
           originServer: servers[0],
+          sqlCommand: sqlCommandServer1,
           servers,
           liveVideoId: videoUUIDNonPermanent,
           resolutions,
           transcoded: true,
-          objectStorage: true
+          objectStorage
         })
 
         await stopFfmpeg(ffmpegCommand)
@@ -172,11 +192,11 @@ describe('Object storage for lives', function () {
         await waitUntilLiveReplacedByReplayOnAllServers(servers, videoUUIDNonPermanent)
         await waitJobs(servers)
 
-        await checkFilesExist(servers, videoUUIDNonPermanent, 5)
+        await checkFilesExist({ servers, videoUUID: videoUUIDNonPermanent, numberOfFiles: 5, objectStorage })
       })
 
       it('Should have cleaned up live files from object storage', async function () {
-        await checkFilesCleanup(servers[0], videoUUIDNonPermanent, resolutions)
+        await checkFilesCleanup({ server: servers[0], videoUUID: videoUUIDNonPermanent, resolutions, objectStorage })
       })
     })
 
@@ -193,13 +213,14 @@ describe('Object storage for lives', function () {
         const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDPermanent })
         await waitUntilLivePublishedOnAllServers(servers, videoUUIDPermanent)
 
-        await testVideoResolutions({
+        await testLiveVideoResolutions({
           originServer: servers[0],
+          sqlCommand: sqlCommandServer1,
           servers,
           liveVideoId: videoUUIDPermanent,
           resolutions,
           transcoded: true,
-          objectStorage: true
+          objectStorage
         })
 
         await stopFfmpeg(ffmpegCommand)
@@ -214,16 +235,77 @@ describe('Object storage for lives', function () {
         const videoLiveDetails = await servers[0].videos.get({ id: videoUUIDPermanent })
         const replay = await findExternalSavedVideo(servers[0], videoLiveDetails)
 
-        await checkFilesExist(servers, replay.uuid, 5)
+        await checkFilesExist({ servers, videoUUID: replay.uuid, numberOfFiles: 5, objectStorage })
       })
 
       it('Should have cleaned up live files from object storage', async function () {
-        await checkFilesCleanup(servers[0], videoUUIDPermanent, resolutions)
+        await checkFilesCleanup({ server: servers[0], videoUUID: videoUUIDPermanent, resolutions, objectStorage })
+      })
+    })
+  })
+
+  describe('With object storage base url', function () {
+    const mockObjectStorageProxy = new MockObjectStorageProxy()
+    let baseMockUrl: string
+
+    before(async function () {
+      this.timeout(120000)
+
+      const port = await mockObjectStorageProxy.initialize()
+      const bucketName = objectStorage.getMockStreamingPlaylistsBucketName()
+      baseMockUrl = `http://127.0.0.1:${port}/${bucketName}`
+
+      await objectStorage.prepareDefaultMockBuckets()
+
+      const config = {
+        object_storage: {
+          enabled: true,
+          endpoint: 'http://' + ObjectStorageCommand.getMockEndpointHost(),
+          region: ObjectStorageCommand.getMockRegion(),
+
+          credentials: ObjectStorageCommand.getMockCredentialsConfig(),
+
+          streaming_playlists: {
+            bucket_name: bucketName,
+            prefix: '',
+            base_url: baseMockUrl
+          }
+        }
+      }
+
+      await servers[0].kill()
+      await servers[0].run(config)
+
+      await servers[0].config.enableLive({ transcoding: true, resolutions: 'min' })
+    })
+
+    it('Should publish a live and replace the base url', async function () {
+      this.timeout(240000)
+
+      const videoUUIDPermanent = await createLive(servers[0], true)
+
+      const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDPermanent })
+      await waitUntilLivePublishedOnAllServers(servers, videoUUIDPermanent)
+
+      await testLiveVideoResolutions({
+        originServer: servers[0],
+        sqlCommand: sqlCommandServer1,
+        servers,
+        liveVideoId: videoUUIDPermanent,
+        resolutions: [ 720 ],
+        transcoded: true,
+        objectStorage,
+        objectStorageBaseUrl: baseMockUrl
       })
+
+      await stopFfmpeg(ffmpegCommand)
     })
   })
 
   after(async function () {
-    await killallServers(servers)
+    await sqlCommandServer1.cleanup()
+    await objectStorage.cleanupMock()
+
+    await cleanupTests(servers)
   })
 })