Migrate server to ESM

Sorry for the very big commit that may lead to git log issues and merge
conflicts, but it's a major step forward:

 * Server can be faster at startup because imports() are async and we can
   easily lazy import big modules
 * Angular doesn't seem to support ES import (with .js extension), so we
   had to correctly organize peertube into a monorepo:
    * Use yarn workspace feature
    * Use typescript reference projects for dependencies
    * Shared projects have been moved into "packages", each one is now a
      node module (with a dedicated package.json/tsconfig.json)
    * server/tools have been moved into apps/ and is now a dedicated app
      bundled and published on NPM so users don't have to build peertube
      cli tools manually
    * server/tests have been moved into packages/ so we don't compile
      them every time we want to run the server
 * Use isolatedModule option:
   * Had to move from const enum to const
     (https://www.typescriptlang.org/docs/handbook/enums.html#objects-vs-enums)
   * Had to explictely specify "type" imports when used in decorators
 * Prefer tsx (that uses esbuild under the hood) instead of ts-node to
   load typescript files (tests with mocha or scripts):
     * To reduce test complexity as esbuild doesn't support decorator
       metadata, we only test server files that do not import server
       models
     * We still build tests files into js files for a faster CI
 * Remove unmaintained peertube CLI import script
 * Removed some barrels to speed up execution (less imports)

5 files changed, 0 insertions, 1434 deletions

diff --git a/server/tests/api/object-storage/index.ts b/server/tests/api/object-storage/index.ts
deleted file mode 100644
index 1f4489fa3..000000000
--- a/server/tests/api/object-storage/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export * from './live'
-export * from './video-imports'
-export * from './video-static-file-privacy'
-export * from './videos'
diff --git a/server/tests/api/object-storage/live.ts b/server/tests/api/object-storage/live.ts
deleted file mode 100644
index 07ff4763b..000000000
--- a/server/tests/api/object-storage/live.ts
+++ /dev/null
@@ -1,311 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-
-import { expect } from 'chai'
-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,
-  makeRawRequest,
-  ObjectStorageCommand,
-  PeerTubeServer,
-  setAccessTokensToServers,
-  setDefaultVideoChannel,
-  stopFfmpeg,
-  waitJobs,
-  waitUntilLivePublishedOnAllServers,
-  waitUntilLiveReplacedByReplayOnAllServers,
-  waitUntilLiveWaitingOnAllServers
-} from '@shared/server-commands'
-
-async function createLive (server: PeerTubeServer, permanent: boolean) {
-  const attributes: LiveVideoCreate = {
-    channelId: server.store.channel.id,
-    privacy: VideoPrivacy.PUBLIC,
-    name: 'my super live',
-    saveReplay: true,
-    replaySettings: { privacy: VideoPrivacy.PUBLIC },
-    permanentLive: permanent
-  }
-
-  const { uuid } = await server.live.create({ fields: attributes })
-
-  return uuid
-}
-
-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 })
-
-    expect(video.files).to.have.lengthOf(0)
-    expect(video.streamingPlaylists).to.have.lengthOf(1)
-
-    const files = video.streamingPlaylists[0].files
-    expect(files).to.have.lengthOf(numberOfFiles)
-
-    for (const file of files) {
-      expectStartWith(file.fileUrl, objectStorage.getMockPlaylistBaseUrl())
-
-      await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
-    }
-  }
-}
-
-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)) {
-    await server.live.getPlaylistFile({
-      videoUUID,
-      playlistName,
-      expectedStatus: HttpStatusCode.NOT_FOUND_404,
-      objectStorage
-    })
-  }
-
-  await server.live.getSegmentFile({
-    videoUUID,
-    playlistNumber: 0,
-    segment: 0,
-    objectStorage,
-    expectedStatus: HttpStatusCode.NOT_FOUND_404
-  })
-}
-
-describe('Object storage for lives', function () {
-  if (areMockObjectStorageTestsDisabled()) return
-
-  let servers: PeerTubeServer[]
-  let sqlCommandServer1: SQLCommand
-  const objectStorage = new ObjectStorageCommand()
-
-  before(async function () {
-    this.timeout(120000)
-
-    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', function () {
-    let videoUUID: string
-
-    before(async function () {
-      await servers[0].config.enableLive({ transcoding: false })
-
-      videoUUID = await createLive(servers[0], false)
-    })
-
-    it('Should create a live and publish it on object storage', async function () {
-      this.timeout(220000)
-
-      const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
-      await waitUntilLivePublishedOnAllServers(servers, videoUUID)
-
-      await testLiveVideoResolutions({
-        originServer: servers[0],
-        sqlCommand: sqlCommandServer1,
-        servers,
-        liveVideoId: videoUUID,
-        resolutions: [ 720 ],
-        transcoded: false,
-        objectStorage
-      })
-
-      await stopFfmpeg(ffmpegCommand)
-    })
-
-    it('Should have saved the replay on object storage', async function () {
-      this.timeout(220000)
-
-      await waitUntilLiveReplacedByReplayOnAllServers(servers, videoUUID)
-      await waitJobs(servers)
-
-      await checkFilesExist({ servers, videoUUID, numberOfFiles: 1, objectStorage })
-    })
-
-    it('Should have cleaned up live files from object storage', async function () {
-      await checkFilesCleanup({ server: servers[0], videoUUID, resolutions: [ 720 ], objectStorage })
-    })
-  })
-
-  describe('With live transcoding', function () {
-    const resolutions = [ 720, 480, 360, 240, 144 ]
-
-    before(async function () {
-      await servers[0].config.enableLive({ transcoding: true })
-    })
-
-    describe('Normal replay', function () {
-      let videoUUIDNonPermanent: string
-
-      before(async function () {
-        videoUUIDNonPermanent = await createLive(servers[0], false)
-      })
-
-      it('Should create a live and publish it on object storage', async function () {
-        this.timeout(240000)
-
-        const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDNonPermanent })
-        await waitUntilLivePublishedOnAllServers(servers, videoUUIDNonPermanent)
-
-        await testLiveVideoResolutions({
-          originServer: servers[0],
-          sqlCommand: sqlCommandServer1,
-          servers,
-          liveVideoId: videoUUIDNonPermanent,
-          resolutions,
-          transcoded: true,
-          objectStorage
-        })
-
-        await stopFfmpeg(ffmpegCommand)
-      })
-
-      it('Should have saved the replay on object storage', async function () {
-        this.timeout(220000)
-
-        await waitUntilLiveReplacedByReplayOnAllServers(servers, videoUUIDNonPermanent)
-        await waitJobs(servers)
-
-        await checkFilesExist({ servers, videoUUID: videoUUIDNonPermanent, numberOfFiles: 5, objectStorage })
-      })
-
-      it('Should have cleaned up live files from object storage', async function () {
-        await checkFilesCleanup({ server: servers[0], videoUUID: videoUUIDNonPermanent, resolutions, objectStorage })
-      })
-    })
-
-    describe('Permanent replay', function () {
-      let videoUUIDPermanent: string
-
-      before(async function () {
-        videoUUIDPermanent = await createLive(servers[0], true)
-      })
-
-      it('Should create a live and publish it on object storage', async function () {
-        this.timeout(240000)
-
-        const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDPermanent })
-        await waitUntilLivePublishedOnAllServers(servers, videoUUIDPermanent)
-
-        await testLiveVideoResolutions({
-          originServer: servers[0],
-          sqlCommand: sqlCommandServer1,
-          servers,
-          liveVideoId: videoUUIDPermanent,
-          resolutions,
-          transcoded: true,
-          objectStorage
-        })
-
-        await stopFfmpeg(ffmpegCommand)
-      })
-
-      it('Should have saved the replay on object storage', async function () {
-        this.timeout(220000)
-
-        await waitUntilLiveWaitingOnAllServers(servers, videoUUIDPermanent)
-        await waitJobs(servers)
-
-        const videoLiveDetails = await servers[0].videos.get({ id: videoUUIDPermanent })
-        const replay = await findExternalSavedVideo(servers[0], videoLiveDetails)
-
-        await checkFilesExist({ servers, videoUUID: replay.uuid, numberOfFiles: 5, objectStorage })
-      })
-
-      it('Should have cleaned up live files from object storage', async function () {
-        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 sqlCommandServer1.cleanup()
-    await objectStorage.cleanupMock()
-
-    await cleanupTests(servers)
-  })
-})
diff --git a/server/tests/api/object-storage/video-imports.ts b/server/tests/api/object-storage/video-imports.ts
deleted file mode 100644
index 57150e5a6..000000000
--- a/server/tests/api/object-storage/video-imports.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-
-import { expect } from 'chai'
-import { expectStartWith, FIXTURE_URLS } from '@server/tests/shared'
-import { areMockObjectStorageTestsDisabled } from '@shared/core-utils'
-import { HttpStatusCode, VideoPrivacy } from '@shared/models'
-import {
-  cleanupTests,
-  createSingleServer,
-  makeRawRequest,
-  ObjectStorageCommand,
-  PeerTubeServer,
-  setAccessTokensToServers,
-  setDefaultVideoChannel,
-  waitJobs
-} from '@shared/server-commands'
-
-async function importVideo (server: PeerTubeServer) {
-  const attributes = {
-    name: 'import 2',
-    privacy: VideoPrivacy.PUBLIC,
-    channelId: server.store.channel.id,
-    targetUrl: FIXTURE_URLS.goodVideo720
-  }
-
-  const { video: { uuid } } = await server.imports.importVideo({ attributes })
-
-  return uuid
-}
-
-describe('Object storage for video import', function () {
-  if (areMockObjectStorageTestsDisabled()) return
-
-  let server: PeerTubeServer
-  const objectStorage = new ObjectStorageCommand()
-
-  before(async function () {
-    this.timeout(120000)
-
-    await objectStorage.prepareDefaultMockBuckets()
-
-    server = await createSingleServer(1, objectStorage.getDefaultMockConfig())
-
-    await setAccessTokensToServers([ server ])
-    await setDefaultVideoChannel([ server ])
-
-    await server.config.enableImports()
-  })
-
-  describe('Without transcoding', async function () {
-
-    before(async function () {
-      await server.config.disableTranscoding()
-    })
-
-    it('Should import a video and have sent it to object storage', async function () {
-      this.timeout(120000)
-
-      const uuid = await importVideo(server)
-      await waitJobs(server)
-
-      const video = await server.videos.get({ id: uuid })
-
-      expect(video.files).to.have.lengthOf(1)
-      expect(video.streamingPlaylists).to.have.lengthOf(0)
-
-      const fileUrl = video.files[0].fileUrl
-      expectStartWith(fileUrl, objectStorage.getMockWebVideosBaseUrl())
-
-      await makeRawRequest({ url: fileUrl, expectedStatus: HttpStatusCode.OK_200 })
-    })
-  })
-
-  describe('With transcoding', async function () {
-
-    before(async function () {
-      await server.config.enableTranscoding()
-    })
-
-    it('Should import a video and have sent it to object storage', async function () {
-      this.timeout(120000)
-
-      const uuid = await importVideo(server)
-      await waitJobs(server)
-
-      const video = await server.videos.get({ id: uuid })
-
-      expect(video.files).to.have.lengthOf(5)
-      expect(video.streamingPlaylists).to.have.lengthOf(1)
-      expect(video.streamingPlaylists[0].files).to.have.lengthOf(5)
-
-      for (const file of video.files) {
-        expectStartWith(file.fileUrl, objectStorage.getMockWebVideosBaseUrl())
-
-        await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
-      }
-
-      for (const file of video.streamingPlaylists[0].files) {
-        expectStartWith(file.fileUrl, objectStorage.getMockPlaylistBaseUrl())
-
-        await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
-      }
-    })
-  })
-
-  after(async function () {
-    await objectStorage.cleanupMock()
-
-    await cleanupTests([ server ])
-  })
-})
diff --git a/server/tests/api/object-storage/video-static-file-privacy.ts b/server/tests/api/object-storage/video-static-file-privacy.ts
deleted file mode 100644
index 64ab542a5..000000000
--- a/server/tests/api/object-storage/video-static-file-privacy.ts
+++ /dev/null
@@ -1,570 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-
-import { expect } from 'chai'
-import { basename } from 'path'
-import { checkVideoFileTokenReinjection, expectStartWith, SQLCommand } from '@server/tests/shared'
-import { areScalewayObjectStorageTestsDisabled, getAllFiles, getHLS } from '@shared/core-utils'
-import { HttpStatusCode, LiveVideo, VideoDetails, VideoPrivacy } from '@shared/models'
-import {
-  cleanupTests,
-  createSingleServer,
-  findExternalSavedVideo,
-  makeRawRequest,
-  ObjectStorageCommand,
-  PeerTubeServer,
-  sendRTMPStream,
-  setAccessTokensToServers,
-  setDefaultVideoChannel,
-  stopFfmpeg,
-  waitJobs
-} from '@shared/server-commands'
-
-function extractFilenameFromUrl (url: string) {
-  const parts = basename(url).split(':')
-
-  return parts[parts.length - 1]
-}
-
-describe('Object storage for video static file privacy', function () {
-  // We need real world object storage to check ACL
-  if (areScalewayObjectStorageTestsDisabled()) return
-
-  let server: PeerTubeServer
-  let sqlCommand: SQLCommand
-  let userToken: string
-
-  // ---------------------------------------------------------------------------
-
-  async function checkPrivateVODFiles (uuid: string) {
-    const video = await server.videos.getWithToken({ id: uuid })
-
-    for (const file of video.files) {
-      expectStartWith(file.fileUrl, server.url + '/object-storage-proxy/web-videos/private/')
-
-      await makeRawRequest({ url: file.fileUrl, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-    }
-
-    for (const file of getAllFiles(video)) {
-      const internalFileUrl = await sqlCommand.getInternalFileUrl(file.id)
-      expectStartWith(internalFileUrl, ObjectStorageCommand.getScalewayBaseUrl())
-      await makeRawRequest({ url: internalFileUrl, token: server.accessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-    }
-
-    const hls = getHLS(video)
-
-    if (hls) {
-      for (const url of [ hls.playlistUrl, hls.segmentsSha256Url ]) {
-        expectStartWith(url, server.url + '/object-storage-proxy/streaming-playlists/hls/private/')
-      }
-
-      await makeRawRequest({ url: hls.playlistUrl, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-      await makeRawRequest({ url: hls.segmentsSha256Url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-
-      for (const file of hls.files) {
-        expectStartWith(file.fileUrl, server.url + '/object-storage-proxy/streaming-playlists/hls/private/')
-
-        await makeRawRequest({ url: file.fileUrl, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-      }
-    }
-  }
-
-  async function checkPublicVODFiles (uuid: string) {
-    const video = await server.videos.getWithToken({ id: uuid })
-
-    for (const file of getAllFiles(video)) {
-      expectStartWith(file.fileUrl, ObjectStorageCommand.getScalewayBaseUrl())
-
-      await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
-    }
-
-    const hls = getHLS(video)
-
-    if (hls) {
-      expectStartWith(hls.playlistUrl, ObjectStorageCommand.getScalewayBaseUrl())
-      expectStartWith(hls.segmentsSha256Url, ObjectStorageCommand.getScalewayBaseUrl())
-
-      await makeRawRequest({ url: hls.playlistUrl, expectedStatus: HttpStatusCode.OK_200 })
-      await makeRawRequest({ url: hls.segmentsSha256Url, expectedStatus: HttpStatusCode.OK_200 })
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-
-  before(async function () {
-    this.timeout(120000)
-
-    server = await createSingleServer(1, ObjectStorageCommand.getDefaultScalewayConfig({ serverNumber: 1 }))
-    await setAccessTokensToServers([ server ])
-    await setDefaultVideoChannel([ server ])
-
-    await server.config.enableMinimumTranscoding()
-
-    userToken = await server.users.generateUserAndToken('user1')
-
-    sqlCommand = new SQLCommand(server)
-  })
-
-  describe('VOD', function () {
-    let privateVideoUUID: string
-    let publicVideoUUID: string
-    let passwordProtectedVideoUUID: string
-    let userPrivateVideoUUID: string
-
-    const correctPassword = 'my super password'
-    const correctPasswordHeader = { 'x-peertube-video-password': correctPassword }
-    const incorrectPasswordHeader = { 'x-peertube-video-password': correctPassword + 'toto' }
-
-    // ---------------------------------------------------------------------------
-
-    async function getSampleFileUrls (videoId: string) {
-      const video = await server.videos.getWithToken({ id: videoId })
-
-      return {
-        webVideoFile: video.files[0].fileUrl,
-        hlsFile: getHLS(video).files[0].fileUrl
-      }
-    }
-
-    // ---------------------------------------------------------------------------
-
-    it('Should upload a private video and have appropriate object storage ACL', async function () {
-      this.timeout(120000)
-
-      {
-        const { uuid } = await server.videos.quickUpload({ name: 'video', privacy: VideoPrivacy.PRIVATE })
-        privateVideoUUID = uuid
-      }
-
-      {
-        const { uuid } = await server.videos.quickUpload({ name: 'user video', token: userToken, privacy: VideoPrivacy.PRIVATE })
-        userPrivateVideoUUID = uuid
-      }
-
-      await waitJobs([ server ])
-
-      await checkPrivateVODFiles(privateVideoUUID)
-    })
-
-    it('Should upload a password protected video and have appropriate object storage ACL', async function () {
-      this.timeout(120000)
-
-      {
-        const { uuid } = await server.videos.quickUpload({
-          name: 'video',
-          privacy: VideoPrivacy.PASSWORD_PROTECTED,
-          videoPasswords: [ correctPassword ]
-        })
-        passwordProtectedVideoUUID = uuid
-      }
-      await waitJobs([ server ])
-
-      await checkPrivateVODFiles(passwordProtectedVideoUUID)
-    })
-
-    it('Should upload a public video and have appropriate object storage ACL', async function () {
-      this.timeout(120000)
-
-      const { uuid } = await server.videos.quickUpload({ name: 'video', privacy: VideoPrivacy.UNLISTED })
-      await waitJobs([ server ])
-
-      publicVideoUUID = uuid
-
-      await checkPublicVODFiles(publicVideoUUID)
-    })
-
-    it('Should not get files without appropriate OAuth token', async function () {
-      this.timeout(60000)
-
-      const { webVideoFile, hlsFile } = await getSampleFileUrls(privateVideoUUID)
-
-      await makeRawRequest({ url: webVideoFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      await makeRawRequest({ url: webVideoFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-
-      await makeRawRequest({ url: hlsFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      await makeRawRequest({ url: hlsFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-    })
-
-    it('Should not get files without appropriate password or appropriate OAuth token', async function () {
-      this.timeout(60000)
-
-      const { webVideoFile, hlsFile } = await getSampleFileUrls(passwordProtectedVideoUUID)
-
-      await makeRawRequest({ url: webVideoFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      await makeRawRequest({
-        url: webVideoFile,
-        token: null,
-        headers: incorrectPasswordHeader,
-        expectedStatus: HttpStatusCode.FORBIDDEN_403
-      })
-      await makeRawRequest({ url: webVideoFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-      await makeRawRequest({
-        url: webVideoFile,
-        token: null,
-        headers: correctPasswordHeader,
-        expectedStatus: HttpStatusCode.OK_200
-      })
-
-      await makeRawRequest({ url: hlsFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      await makeRawRequest({
-        url: hlsFile,
-        token: null,
-        headers: incorrectPasswordHeader,
-        expectedStatus: HttpStatusCode.FORBIDDEN_403
-      })
-      await makeRawRequest({ url: hlsFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-      await makeRawRequest({
-        url: hlsFile,
-        token: null,
-        headers: correctPasswordHeader,
-        expectedStatus: HttpStatusCode.OK_200
-      })
-    })
-
-    it('Should not get HLS file of another video', async function () {
-      this.timeout(60000)
-
-      const privateVideo = await server.videos.getWithToken({ id: privateVideoUUID })
-      const hlsFilename = basename(getHLS(privateVideo).files[0].fileUrl)
-
-      const badUrl = server.url + '/object-storage-proxy/streaming-playlists/hls/private/' + userPrivateVideoUUID + '/' + hlsFilename
-      const goodUrl = server.url + '/object-storage-proxy/streaming-playlists/hls/private/' + privateVideoUUID + '/' + hlsFilename
-
-      await makeRawRequest({ url: badUrl, token: server.accessToken, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-      await makeRawRequest({ url: goodUrl, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-    })
-
-    it('Should correctly check OAuth, video file token of private video', async function () {
-      this.timeout(60000)
-
-      const badVideoFileToken = await server.videoToken.getVideoFileToken({ token: userToken, videoId: userPrivateVideoUUID })
-      const goodVideoFileToken = await server.videoToken.getVideoFileToken({ videoId: privateVideoUUID })
-
-      const { webVideoFile, hlsFile } = await getSampleFileUrls(privateVideoUUID)
-
-      for (const url of [ webVideoFile, hlsFile ]) {
-        await makeRawRequest({ url, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-
-        await makeRawRequest({ url, query: { videoFileToken: badVideoFileToken }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url, query: { videoFileToken: goodVideoFileToken }, expectedStatus: HttpStatusCode.OK_200 })
-
-      }
-    })
-
-    it('Should correctly check OAuth, video file token or video password of password protected video', async function () {
-      this.timeout(60000)
-
-      const badVideoFileToken = await server.videoToken.getVideoFileToken({ token: userToken, videoId: userPrivateVideoUUID })
-      const goodVideoFileToken = await server.videoToken.getVideoFileToken({
-        videoId: passwordProtectedVideoUUID,
-        videoPassword: correctPassword
-      })
-
-      const { webVideoFile, hlsFile } = await getSampleFileUrls(passwordProtectedVideoUUID)
-
-      for (const url of [ hlsFile, webVideoFile ]) {
-        await makeRawRequest({ url, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-
-        await makeRawRequest({ url, query: { videoFileToken: badVideoFileToken }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url, query: { videoFileToken: goodVideoFileToken }, expectedStatus: HttpStatusCode.OK_200 })
-
-        await makeRawRequest({
-          url,
-          headers: incorrectPasswordHeader,
-          expectedStatus: HttpStatusCode.FORBIDDEN_403
-        })
-        await makeRawRequest({ url, headers: correctPasswordHeader, expectedStatus: HttpStatusCode.OK_200 })
-      }
-    })
-
-    it('Should reinject video file token', async function () {
-      this.timeout(120000)
-
-      const videoFileToken = await server.videoToken.getVideoFileToken({ videoId: privateVideoUUID })
-
-      await checkVideoFileTokenReinjection({
-        server,
-        videoUUID: privateVideoUUID,
-        videoFileToken,
-        resolutions: [ 240, 720 ],
-        isLive: false
-      })
-    })
-
-    it('Should update public video to private', async function () {
-      this.timeout(60000)
-
-      await server.videos.update({ id: publicVideoUUID, attributes: { privacy: VideoPrivacy.INTERNAL } })
-
-      await checkPrivateVODFiles(publicVideoUUID)
-    })
-
-    it('Should update private video to public', async function () {
-      this.timeout(60000)
-
-      await server.videos.update({ id: publicVideoUUID, attributes: { privacy: VideoPrivacy.PUBLIC } })
-
-      await checkPublicVODFiles(publicVideoUUID)
-    })
-  })
-
-  describe('Live', function () {
-    let normalLiveId: string
-    let normalLive: LiveVideo
-
-    let permanentLiveId: string
-    let permanentLive: LiveVideo
-
-    let passwordProtectedLiveId: string
-    let passwordProtectedLive: LiveVideo
-
-    const correctPassword = 'my super password'
-
-    let unrelatedFileToken: string
-
-    // ---------------------------------------------------------------------------
-
-    async function checkLiveFiles (live: LiveVideo, liveId: string, videoPassword?: string) {
-      const ffmpegCommand = sendRTMPStream({ rtmpBaseUrl: live.rtmpUrl, streamKey: live.streamKey })
-      await server.live.waitUntilPublished({ videoId: liveId })
-
-      const video = videoPassword
-        ? await server.videos.getWithPassword({ id: liveId, password: videoPassword })
-        : await server.videos.getWithToken({ id: liveId })
-
-      const fileToken = videoPassword
-        ? await server.videoToken.getVideoFileToken({ token: null, videoId: video.uuid, videoPassword })
-        : await server.videoToken.getVideoFileToken({ videoId: video.uuid })
-
-      const hls = video.streamingPlaylists[0]
-
-      for (const url of [ hls.playlistUrl, hls.segmentsSha256Url ]) {
-        expectStartWith(url, server.url + '/object-storage-proxy/streaming-playlists/hls/private/')
-
-        await makeRawRequest({ url: hls.playlistUrl, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-        await makeRawRequest({ url: hls.segmentsSha256Url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-
-        await makeRawRequest({ url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-        await makeRawRequest({ url, query: { videoFileToken: fileToken }, expectedStatus: HttpStatusCode.OK_200 })
-        if (videoPassword) {
-          await makeRawRequest({ url, headers: { 'x-peertube-video-password': videoPassword }, expectedStatus: HttpStatusCode.OK_200 })
-        }
-        await makeRawRequest({ url, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url, query: { videoFileToken: unrelatedFileToken }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        if (videoPassword) {
-          await makeRawRequest({
-            url,
-            headers: { 'x-peertube-video-password': 'incorrectPassword' },
-            expectedStatus: HttpStatusCode.FORBIDDEN_403
-          })
-        }
-      }
-
-      await stopFfmpeg(ffmpegCommand)
-    }
-
-    async function checkReplay (replay: VideoDetails) {
-      const fileToken = await server.videoToken.getVideoFileToken({ videoId: replay.uuid })
-
-      const hls = replay.streamingPlaylists[0]
-      expect(hls.files).to.not.have.lengthOf(0)
-
-      for (const file of hls.files) {
-        await makeRawRequest({ url: file.fileUrl, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-        await makeRawRequest({ url: file.fileUrl, query: { videoFileToken: fileToken }, expectedStatus: HttpStatusCode.OK_200 })
-
-        await makeRawRequest({ url: file.fileUrl, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({
-          url: file.fileUrl,
-          query: { videoFileToken: unrelatedFileToken },
-          expectedStatus: HttpStatusCode.FORBIDDEN_403
-        })
-      }
-
-      for (const url of [ hls.playlistUrl, hls.segmentsSha256Url ]) {
-        expectStartWith(url, server.url + '/object-storage-proxy/streaming-playlists/hls/private/')
-
-        await makeRawRequest({ url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
-        await makeRawRequest({ url, query: { videoFileToken: fileToken }, expectedStatus: HttpStatusCode.OK_200 })
-
-        await makeRawRequest({ url, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-        await makeRawRequest({ url, query: { videoFileToken: unrelatedFileToken }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      }
-    }
-
-    // ---------------------------------------------------------------------------
-
-    before(async function () {
-      await server.config.enableMinimumTranscoding()
-
-      const { uuid } = await server.videos.quickUpload({ name: 'another video' })
-      unrelatedFileToken = await server.videoToken.getVideoFileToken({ videoId: uuid })
-
-      await server.config.enableLive({
-        allowReplay: true,
-        transcoding: true,
-        resolutions: 'min'
-      })
-
-      {
-        const { video, live } = await server.live.quickCreate({
-          saveReplay: true,
-          permanentLive: false,
-          privacy: VideoPrivacy.PRIVATE
-        })
-        normalLiveId = video.uuid
-        normalLive = live
-      }
-
-      {
-        const { video, live } = await server.live.quickCreate({
-          saveReplay: true,
-          permanentLive: true,
-          privacy: VideoPrivacy.PRIVATE
-        })
-        permanentLiveId = video.uuid
-        permanentLive = live
-      }
-
-      {
-        const { video, live } = await server.live.quickCreate({
-          saveReplay: false,
-          permanentLive: false,
-          privacy: VideoPrivacy.PASSWORD_PROTECTED,
-          videoPasswords: [ correctPassword ]
-        })
-        passwordProtectedLiveId = video.uuid
-        passwordProtectedLive = live
-      }
-    })
-
-    it('Should create a private normal live and have a private static path', async function () {
-      this.timeout(240000)
-
-      await checkLiveFiles(normalLive, normalLiveId)
-    })
-
-    it('Should create a private permanent live and have a private static path', async function () {
-      this.timeout(240000)
-
-      await checkLiveFiles(permanentLive, permanentLiveId)
-    })
-
-    it('Should create a password protected live and have a private static path', async function () {
-      this.timeout(240000)
-
-      await checkLiveFiles(passwordProtectedLive, passwordProtectedLiveId, correctPassword)
-    })
-
-    it('Should reinject video file token in permanent live', async function () {
-      this.timeout(240000)
-
-      const ffmpegCommand = sendRTMPStream({ rtmpBaseUrl: permanentLive.rtmpUrl, streamKey: permanentLive.streamKey })
-      await server.live.waitUntilPublished({ videoId: permanentLiveId })
-
-      const video = await server.videos.getWithToken({ id: permanentLiveId })
-      const videoFileToken = await server.videoToken.getVideoFileToken({ videoId: video.uuid })
-
-      await checkVideoFileTokenReinjection({
-        server,
-        videoUUID: permanentLiveId,
-        videoFileToken,
-        resolutions: [ 720 ],
-        isLive: true
-      })
-
-      await stopFfmpeg(ffmpegCommand)
-    })
-
-    it('Should have created a replay of the normal live with a private static path', async function () {
-      this.timeout(240000)
-
-      await server.live.waitUntilReplacedByReplay({ videoId: normalLiveId })
-
-      const replay = await server.videos.getWithToken({ id: normalLiveId })
-      await checkReplay(replay)
-    })
-
-    it('Should have created a replay of the permanent live with a private static path', async function () {
-      this.timeout(240000)
-
-      await server.live.waitUntilWaiting({ videoId: permanentLiveId })
-      await waitJobs([ server ])
-
-      const live = await server.videos.getWithToken({ id: permanentLiveId })
-      const replayFromList = await findExternalSavedVideo(server, live)
-      const replay = await server.videos.getWithToken({ id: replayFromList.id })
-
-      await checkReplay(replay)
-    })
-  })
-
-  describe('With private files proxy disabled and public ACL for private files', function () {
-    let videoUUID: string
-
-    before(async function () {
-      this.timeout(240000)
-
-      await server.kill()
-
-      const config = ObjectStorageCommand.getDefaultScalewayConfig({
-        serverNumber: 1,
-        enablePrivateProxy: false,
-        privateACL: 'public-read'
-      })
-      await server.run(config)
-
-      const { uuid } = await server.videos.quickUpload({ name: 'video', privacy: VideoPrivacy.PRIVATE })
-      videoUUID = uuid
-
-      await waitJobs([ server ])
-    })
-
-    it('Should display object storage path for a private video and be able to access them', async function () {
-      this.timeout(60000)
-
-      await checkPublicVODFiles(videoUUID)
-    })
-
-    it('Should not be able to access object storage proxy', async function () {
-      const privateVideo = await server.videos.getWithToken({ id: videoUUID })
-      const webVideoFilename = extractFilenameFromUrl(privateVideo.files[0].fileUrl)
-      const hlsFilename = extractFilenameFromUrl(getHLS(privateVideo).files[0].fileUrl)
-
-      await makeRawRequest({
-        url: server.url + '/object-storage-proxy/web-videos/private/' + webVideoFilename,
-        token: server.accessToken,
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400
-      })
-
-      await makeRawRequest({
-        url: server.url + '/object-storage-proxy/streaming-playlists/hls/private/' + videoUUID + '/' + hlsFilename,
-        token: server.accessToken,
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400
-      })
-    })
-  })
-
-  after(async function () {
-    this.timeout(240000)
-
-    const { data } = await server.videos.listAllForAdmin()
-
-    for (const v of data) {
-      await server.videos.remove({ id: v.uuid })
-    }
-
-    for (const v of data) {
-      await server.servers.waitUntilLog('Removed files of video ' + v.url)
-    }
-
-    await sqlCommand.cleanup()
-    await cleanupTests([ server ])
-  })
-})
diff --git a/server/tests/api/object-storage/videos.ts b/server/tests/api/object-storage/videos.ts
deleted file mode 100644
index dcc52ef06..000000000
--- a/server/tests/api/object-storage/videos.ts
+++ /dev/null
@@ -1,438 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-
-import bytes from 'bytes'
-import { expect } from 'chai'
-import { stat } from 'fs-extra'
-import { merge } from 'lodash'
-import {
-  checkTmpIsEmpty,
-  checkWebTorrentWorks,
-  expectLogDoesNotContain,
-  expectStartWith,
-  generateHighBitrateVideo,
-  MockObjectStorageProxy,
-  SQLCommand
-} from '@server/tests/shared'
-import { areMockObjectStorageTestsDisabled } from '@shared/core-utils'
-import { sha1 } from '@shared/extra-utils'
-import { HttpStatusCode, VideoDetails } from '@shared/models'
-import {
-  cleanupTests,
-  createMultipleServers,
-  createSingleServer,
-  doubleFollow,
-  killallServers,
-  makeRawRequest,
-  ObjectStorageCommand,
-  PeerTubeServer,
-  setAccessTokensToServers,
-  waitJobs
-} from '@shared/server-commands'
-
-async function checkFiles (options: {
-  server: PeerTubeServer
-  originServer: PeerTubeServer
-  originSQLCommand: SQLCommand
-
-  video: VideoDetails
-
-  baseMockUrl?: string
-
-  playlistBucket: string
-  playlistPrefix?: string
-
-  webVideoBucket: string
-  webVideoPrefix?: string
-}) {
-  const {
-    server,
-    originServer,
-    originSQLCommand,
-    video,
-    playlistBucket,
-    webVideoBucket,
-    baseMockUrl,
-    playlistPrefix,
-    webVideoPrefix
-  } = options
-
-  let allFiles = video.files
-
-  for (const file of video.files) {
-    const baseUrl = baseMockUrl
-      ? `${baseMockUrl}/${webVideoBucket}/`
-      : `http://${webVideoBucket}.${ObjectStorageCommand.getMockEndpointHost()}/`
-
-    const prefix = webVideoPrefix || ''
-    const start = baseUrl + prefix
-
-    expectStartWith(file.fileUrl, start)
-
-    const res = await makeRawRequest({ url: file.fileDownloadUrl, expectedStatus: HttpStatusCode.FOUND_302 })
-    const location = res.headers['location']
-    expectStartWith(location, start)
-
-    await makeRawRequest({ url: location, expectedStatus: HttpStatusCode.OK_200 })
-  }
-
-  const hls = video.streamingPlaylists[0]
-
-  if (hls) {
-    allFiles = allFiles.concat(hls.files)
-
-    const baseUrl = baseMockUrl
-      ? `${baseMockUrl}/${playlistBucket}/`
-      : `http://${playlistBucket}.${ObjectStorageCommand.getMockEndpointHost()}/`
-
-    const prefix = playlistPrefix || ''
-    const start = baseUrl + prefix
-
-    expectStartWith(hls.playlistUrl, start)
-    expectStartWith(hls.segmentsSha256Url, start)
-
-    await makeRawRequest({ url: hls.playlistUrl, expectedStatus: HttpStatusCode.OK_200 })
-
-    const resSha = await makeRawRequest({ url: hls.segmentsSha256Url, expectedStatus: HttpStatusCode.OK_200 })
-    expect(JSON.stringify(resSha.body)).to.not.throw
-
-    let i = 0
-    for (const file of hls.files) {
-      expectStartWith(file.fileUrl, start)
-
-      const res = await makeRawRequest({ url: file.fileDownloadUrl, expectedStatus: HttpStatusCode.FOUND_302 })
-      const location = res.headers['location']
-      expectStartWith(location, start)
-
-      await makeRawRequest({ url: location, expectedStatus: HttpStatusCode.OK_200 })
-
-      if (originServer.internalServerNumber === server.internalServerNumber) {
-        const infohash = sha1(`${2 + hls.playlistUrl}+V${i}`)
-        const dbInfohashes = await originSQLCommand.getPlaylistInfohash(hls.id)
-
-        expect(dbInfohashes).to.include(infohash)
-      }
-
-      i++
-    }
-  }
-
-  for (const file of allFiles) {
-    await checkWebTorrentWorks(file.magnetUri)
-
-    const res = await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
-    expect(res.body).to.have.length.above(100)
-  }
-
-  return allFiles.map(f => f.fileUrl)
-}
-
-function runTestSuite (options: {
-  fixture?: string
-
-  maxUploadPart?: string
-
-  playlistBucket: string
-  playlistPrefix?: string
-
-  webVideoBucket: string
-  webVideoPrefix?: string
-
-  useMockBaseUrl?: boolean
-}) {
-  const mockObjectStorageProxy = new MockObjectStorageProxy()
-  const { fixture } = options
-  let baseMockUrl: string
-
-  let servers: PeerTubeServer[]
-  let sqlCommands: SQLCommand[] = []
-  const objectStorage = new ObjectStorageCommand()
-
-  let keptUrls: string[] = []
-
-  const uuidsToDelete: string[] = []
-  let deletedUrls: string[] = []
-
-  before(async function () {
-    this.timeout(240000)
-
-    const port = await mockObjectStorageProxy.initialize()
-    baseMockUrl = options.useMockBaseUrl
-      ? `http://127.0.0.1:${port}`
-      : undefined
-
-    await objectStorage.createMockBucket(options.playlistBucket)
-    await objectStorage.createMockBucket(options.webVideoBucket)
-
-    const config = {
-      object_storage: {
-        enabled: true,
-        endpoint: 'http://' + ObjectStorageCommand.getMockEndpointHost(),
-        region: ObjectStorageCommand.getMockRegion(),
-
-        credentials: ObjectStorageCommand.getMockCredentialsConfig(),
-
-        max_upload_part: options.maxUploadPart || '5MB',
-
-        streaming_playlists: {
-          bucket_name: options.playlistBucket,
-          prefix: options.playlistPrefix,
-          base_url: baseMockUrl
-            ? `${baseMockUrl}/${options.playlistBucket}`
-            : undefined
-        },
-
-        web_videos: {
-          bucket_name: options.webVideoBucket,
-          prefix: options.webVideoPrefix,
-          base_url: baseMockUrl
-            ? `${baseMockUrl}/${options.webVideoBucket}`
-            : undefined
-        }
-      }
-    }
-
-    servers = await createMultipleServers(2, config)
-
-    await setAccessTokensToServers(servers)
-    await doubleFollow(servers[0], servers[1])
-
-    for (const server of servers) {
-      const { uuid } = await server.videos.quickUpload({ name: 'video to keep' })
-      await waitJobs(servers)
-
-      const files = await server.videos.listFiles({ id: uuid })
-      keptUrls = keptUrls.concat(files.map(f => f.fileUrl))
-    }
-
-    sqlCommands = servers.map(s => new SQLCommand(s))
-  })
-
-  it('Should upload a video and move it to the object storage without transcoding', async function () {
-    this.timeout(40000)
-
-    const { uuid } = await servers[0].videos.quickUpload({ name: 'video 1', fixture })
-    uuidsToDelete.push(uuid)
-
-    await waitJobs(servers)
-
-    for (const server of servers) {
-      const video = await server.videos.get({ id: uuid })
-      const files = await checkFiles({ ...options, server, originServer: servers[0], originSQLCommand: sqlCommands[0], video, baseMockUrl })
-
-      deletedUrls = deletedUrls.concat(files)
-    }
-  })
-
-  it('Should upload a video and move it to the object storage with transcoding', async function () {
-    this.timeout(120000)
-
-    const { uuid } = await servers[1].videos.quickUpload({ name: 'video 2', fixture })
-    uuidsToDelete.push(uuid)
-
-    await waitJobs(servers)
-
-    for (const server of servers) {
-      const video = await server.videos.get({ id: uuid })
-      const files = await checkFiles({ ...options, server, originServer: servers[0], originSQLCommand: sqlCommands[0], video, baseMockUrl })
-
-      deletedUrls = deletedUrls.concat(files)
-    }
-  })
-
-  it('Should fetch correctly all the files', async function () {
-    for (const url of deletedUrls.concat(keptUrls)) {
-      await makeRawRequest({ url, expectedStatus: HttpStatusCode.OK_200 })
-    }
-  })
-
-  it('Should correctly delete the files', async function () {
-    await servers[0].videos.remove({ id: uuidsToDelete[0] })
-    await servers[1].videos.remove({ id: uuidsToDelete[1] })
-
-    await waitJobs(servers)
-
-    for (const url of deletedUrls) {
-      await makeRawRequest({ url, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-    }
-  })
-
-  it('Should have kept other files', async function () {
-    for (const url of keptUrls) {
-      await makeRawRequest({ url, expectedStatus: HttpStatusCode.OK_200 })
-    }
-  })
-
-  it('Should have an empty tmp directory', async function () {
-    for (const server of servers) {
-      await checkTmpIsEmpty(server)
-    }
-  })
-
-  it('Should not have downloaded files from object storage', async function () {
-    for (const server of servers) {
-      await expectLogDoesNotContain(server, 'from object storage')
-    }
-  })
-
-  after(async function () {
-    await mockObjectStorageProxy.terminate()
-    await objectStorage.cleanupMock()
-
-    for (const sqlCommand of sqlCommands) {
-      await sqlCommand.cleanup()
-    }
-
-    await cleanupTests(servers)
-  })
-}
-
-describe('Object storage for videos', function () {
-  if (areMockObjectStorageTestsDisabled()) return
-
-  const objectStorage = new ObjectStorageCommand()
-
-  describe('Test config', function () {
-    let server: PeerTubeServer
-
-    const baseConfig = objectStorage.getDefaultMockConfig()
-
-    const badCredentials = {
-      access_key_id: 'AKIAIOSFODNN7EXAMPLE',
-      secret_access_key: 'aJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'
-    }
-
-    it('Should fail with same bucket names without prefix', function (done) {
-      const config = merge({}, baseConfig, {
-        object_storage: {
-          streaming_playlists: {
-            bucket_name: 'aaa'
-          },
-
-          web_videos: {
-            bucket_name: 'aaa'
-          }
-        }
-      })
-
-      createSingleServer(1, config)
-        .then(() => done(new Error('Did not throw')))
-        .catch(() => done())
-    })
-
-    it('Should fail with bad credentials', async function () {
-      this.timeout(60000)
-
-      await objectStorage.prepareDefaultMockBuckets()
-
-      const config = merge({}, baseConfig, {
-        object_storage: {
-          credentials: badCredentials
-        }
-      })
-
-      server = await createSingleServer(1, config)
-      await setAccessTokensToServers([ server ])
-
-      const { uuid } = await server.videos.quickUpload({ name: 'video' })
-
-      await waitJobs([ server ], { skipDelayed: true })
-      const video = await server.videos.get({ id: uuid })
-
-      expectStartWith(video.files[0].fileUrl, server.url)
-
-      await killallServers([ server ])
-    })
-
-    it('Should succeed with credentials from env', async function () {
-      this.timeout(60000)
-
-      await objectStorage.prepareDefaultMockBuckets()
-
-      const config = merge({}, baseConfig, {
-        object_storage: {
-          credentials: {
-            access_key_id: '',
-            secret_access_key: ''
-          }
-        }
-      })
-
-      const goodCredentials = ObjectStorageCommand.getMockCredentialsConfig()
-
-      server = await createSingleServer(1, config, {
-        env: {
-          AWS_ACCESS_KEY_ID: goodCredentials.access_key_id,
-          AWS_SECRET_ACCESS_KEY: goodCredentials.secret_access_key
-        }
-      })
-
-      await setAccessTokensToServers([ server ])
-
-      const { uuid } = await server.videos.quickUpload({ name: 'video' })
-
-      await waitJobs([ server ], { skipDelayed: true })
-      const video = await server.videos.get({ id: uuid })
-
-      expectStartWith(video.files[0].fileUrl, objectStorage.getMockWebVideosBaseUrl())
-    })
-
-    after(async function () {
-      await objectStorage.cleanupMock()
-
-      await cleanupTests([ server ])
-    })
-  })
-
-  describe('Test simple object storage', function () {
-    runTestSuite({
-      playlistBucket: objectStorage.getMockBucketName('streaming-playlists'),
-      webVideoBucket: objectStorage.getMockBucketName('web-videos')
-    })
-  })
-
-  describe('Test object storage with prefix', function () {
-    runTestSuite({
-      playlistBucket: objectStorage.getMockBucketName('mybucket'),
-      webVideoBucket: objectStorage.getMockBucketName('mybucket'),
-
-      playlistPrefix: 'streaming-playlists_',
-      webVideoPrefix: 'webvideo_'
-    })
-  })
-
-  describe('Test object storage with prefix and base URL', function () {
-    runTestSuite({
-      playlistBucket: objectStorage.getMockBucketName('mybucket'),
-      webVideoBucket: objectStorage.getMockBucketName('mybucket'),
-
-      playlistPrefix: 'streaming-playlists/',
-      webVideoPrefix: 'webvideo/',
-
-      useMockBaseUrl: true
-    })
-  })
-
-  describe('Test object storage with file bigger than upload part', function () {
-    let fixture: string
-    const maxUploadPart = '5MB'
-
-    before(async function () {
-      this.timeout(120000)
-
-      fixture = await generateHighBitrateVideo()
-
-      const { size } = await stat(fixture)
-
-      if (bytes.parse(maxUploadPart) > size) {
-        throw Error(`Fixture file is too small (${size}) to make sense for this test.`)
-      }
-    })
-
-    runTestSuite({
-      maxUploadPart,
-      playlistBucket: objectStorage.getMockBucketName('streaming-playlists'),
-      webVideoBucket: objectStorage.getMockBucketName('web-videos'),
-      fixture
-    })
-  })
-})