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)

23 files changed, 5522 insertions, 0 deletions

diff --git a/packages/tests/src/api/server/auto-follows.ts b/packages/tests/src/api/server/auto-follows.ts
new file mode 100644
index 000000000..aa272ebcc
--- /dev/null
+++ b/packages/tests/src/api/server/auto-follows.ts
@@ -0,0 +1,189 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { MockInstancesIndex } from '@tests/shared/mock-servers/index.js'
+import { wait } from '@peertube/peertube-core-utils'
+import { cleanupTests, createMultipleServers, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@peertube/peertube-server-commands'
+
+async function checkFollow (follower: PeerTubeServer, following: PeerTubeServer, exists: boolean) {
+  {
+    const body = await following.follows.getFollowers({ start: 0, count: 5, sort: '-createdAt' })
+    const follow = body.data.find(f => f.follower.host === follower.host && f.state === 'accepted')
+
+    if (exists === true) expect(follow, `Follower ${follower.url} should exist on ${following.url}`).to.exist
+    else expect(follow, `Follower ${follower.url} should not exist on ${following.url}`).to.be.undefined
+  }
+
+  {
+    const body = await follower.follows.getFollowings({ start: 0, count: 5, sort: '-createdAt' })
+    const follow = body.data.find(f => f.following.host === following.host && f.state === 'accepted')
+
+    if (exists === true) expect(follow, `Following ${following.url} should exist on ${follower.url}`).to.exist
+    else expect(follow, `Following ${following.url} should not exist on ${follower.url}`).to.be.undefined
+  }
+}
+
+async function server1Follows2 (servers: PeerTubeServer[]) {
+  await servers[0].follows.follow({ hosts: [ servers[1].host ] })
+
+  await waitJobs(servers)
+}
+
+async function resetFollows (servers: PeerTubeServer[]) {
+  try {
+    await servers[0].follows.unfollow({ target: servers[1] })
+    await servers[1].follows.unfollow({ target: servers[0] })
+  } catch { /* empty */
+  }
+
+  await waitJobs(servers)
+
+  await checkFollow(servers[0], servers[1], false)
+  await checkFollow(servers[1], servers[0], false)
+}
+
+describe('Test auto follows', function () {
+  let servers: PeerTubeServer[] = []
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(3)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+  })
+
+  describe('Auto follow back', function () {
+
+    it('Should not auto follow back if the option is not enabled', async function () {
+      this.timeout(15000)
+
+      await server1Follows2(servers)
+
+      await checkFollow(servers[0], servers[1], true)
+      await checkFollow(servers[1], servers[0], false)
+
+      await resetFollows(servers)
+    })
+
+    it('Should auto follow back on auto accept if the option is enabled', async function () {
+      this.timeout(15000)
+
+      const config = {
+        followings: {
+          instance: {
+            autoFollowBack: { enabled: true }
+          }
+        }
+      }
+      await servers[1].config.updateCustomSubConfig({ newConfig: config })
+
+      await server1Follows2(servers)
+
+      await checkFollow(servers[0], servers[1], true)
+      await checkFollow(servers[1], servers[0], true)
+
+      await resetFollows(servers)
+    })
+
+    it('Should wait the acceptation before auto follow back', async function () {
+      this.timeout(30000)
+
+      const config = {
+        followings: {
+          instance: {
+            autoFollowBack: { enabled: true }
+          }
+        },
+        followers: {
+          instance: {
+            manualApproval: true
+          }
+        }
+      }
+      await servers[1].config.updateCustomSubConfig({ newConfig: config })
+
+      await server1Follows2(servers)
+
+      await checkFollow(servers[0], servers[1], false)
+      await checkFollow(servers[1], servers[0], false)
+
+      await servers[1].follows.acceptFollower({ follower: 'peertube@' + servers[0].host })
+      await waitJobs(servers)
+
+      await checkFollow(servers[0], servers[1], true)
+      await checkFollow(servers[1], servers[0], true)
+
+      await resetFollows(servers)
+
+      config.followings.instance.autoFollowBack.enabled = false
+      config.followers.instance.manualApproval = false
+      await servers[1].config.updateCustomSubConfig({ newConfig: config })
+    })
+  })
+
+  describe('Auto follow index', function () {
+    const instanceIndexServer = new MockInstancesIndex()
+    let port: number
+
+    before(async function () {
+      port = await instanceIndexServer.initialize()
+    })
+
+    it('Should not auto follow index if the option is not enabled', async function () {
+      this.timeout(30000)
+
+      await wait(5000)
+      await waitJobs(servers)
+
+      await checkFollow(servers[0], servers[1], false)
+      await checkFollow(servers[1], servers[0], false)
+    })
+
+    it('Should auto follow the index', async function () {
+      this.timeout(30000)
+
+      instanceIndexServer.addInstance(servers[1].host)
+
+      const config = {
+        followings: {
+          instance: {
+            autoFollowIndex: {
+              indexUrl: `http://127.0.0.1:${port}/api/v1/instances/hosts`,
+              enabled: true
+            }
+          }
+        }
+      }
+      await servers[0].config.updateCustomSubConfig({ newConfig: config })
+
+      await wait(5000)
+      await waitJobs(servers)
+
+      await checkFollow(servers[0], servers[1], true)
+
+      await resetFollows(servers)
+    })
+
+    it('Should follow new added instances in the index but not old ones', async function () {
+      this.timeout(30000)
+
+      instanceIndexServer.addInstance(servers[2].host)
+
+      await wait(5000)
+      await waitJobs(servers)
+
+      await checkFollow(servers[0], servers[1], false)
+      await checkFollow(servers[0], servers[2], true)
+    })
+
+    after(async function () {
+      await instanceIndexServer.terminate()
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/server/bulk.ts b/packages/tests/src/api/server/bulk.ts
new file mode 100644
index 000000000..725bcfef2
--- /dev/null
+++ b/packages/tests/src/api/server/bulk.ts
@@ -0,0 +1,185 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import {
+  BulkCommand,
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Test bulk actions', function () {
+  const commentsUser3: { videoId: number, commentId: number }[] = []
+
+  let servers: PeerTubeServer[] = []
+  let user1Token: string
+  let user2Token: string
+  let user3Token: string
+
+  let bulkCommand: BulkCommand
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    {
+      const user = { username: 'user1', password: 'password' }
+      await servers[0].users.create({ username: user.username, password: user.password })
+
+      user1Token = await servers[0].login.getAccessToken(user)
+    }
+
+    {
+      const user = { username: 'user2', password: 'password' }
+      await servers[0].users.create({ username: user.username, password: user.password })
+
+      user2Token = await servers[0].login.getAccessToken(user)
+    }
+
+    {
+      const user = { username: 'user3', password: 'password' }
+      await servers[1].users.create({ username: user.username, password: user.password })
+
+      user3Token = await servers[1].login.getAccessToken(user)
+    }
+
+    await doubleFollow(servers[0], servers[1])
+
+    bulkCommand = new BulkCommand(servers[0])
+  })
+
+  describe('Bulk remove comments', function () {
+    async function checkInstanceCommentsRemoved () {
+      {
+        const { data } = await servers[0].videos.list()
+
+        // Server 1 should not have these comments anymore
+        for (const video of data) {
+          const { data } = await servers[0].comments.listThreads({ videoId: video.id })
+          const comment = data.find(c => c.text === 'comment by user 3')
+
+          expect(comment).to.not.exist
+        }
+      }
+
+      {
+        const { data } = await servers[1].videos.list()
+
+        // Server 1 should not have these comments on videos of server 1
+        for (const video of data) {
+          const { data } = await servers[1].comments.listThreads({ videoId: video.id })
+          const comment = data.find(c => c.text === 'comment by user 3')
+
+          if (video.account.host === servers[0].host) {
+            expect(comment).to.not.exist
+          } else {
+            expect(comment).to.exist
+          }
+        }
+      }
+    }
+
+    before(async function () {
+      this.timeout(240000)
+
+      await servers[0].videos.upload({ attributes: { name: 'video 1 server 1' } })
+      await servers[0].videos.upload({ attributes: { name: 'video 2 server 1' } })
+      await servers[0].videos.upload({ token: user1Token, attributes: { name: 'video 3 server 1' } })
+
+      await servers[1].videos.upload({ attributes: { name: 'video 1 server 2' } })
+
+      await waitJobs(servers)
+
+      {
+        const { data } = await servers[0].videos.list()
+        for (const video of data) {
+          await servers[0].comments.createThread({ videoId: video.id, text: 'comment by root server 1' })
+          await servers[0].comments.createThread({ token: user1Token, videoId: video.id, text: 'comment by user 1' })
+          await servers[0].comments.createThread({ token: user2Token, videoId: video.id, text: 'comment by user 2' })
+        }
+      }
+
+      {
+        const { data } = await servers[1].videos.list()
+
+        for (const video of data) {
+          await servers[1].comments.createThread({ videoId: video.id, text: 'comment by root server 2' })
+
+          const comment = await servers[1].comments.createThread({ token: user3Token, videoId: video.id, text: 'comment by user 3' })
+          commentsUser3.push({ videoId: video.id, commentId: comment.id })
+        }
+      }
+
+      await waitJobs(servers)
+    })
+
+    it('Should delete comments of an account on my videos', async function () {
+      this.timeout(60000)
+
+      await bulkCommand.removeCommentsOf({
+        token: user1Token,
+        attributes: {
+          accountName: 'user2',
+          scope: 'my-videos'
+        }
+      })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { data } = await server.videos.list()
+
+        for (const video of data) {
+          const { data } = await server.comments.listThreads({ videoId: video.id })
+          const comment = data.find(c => c.text === 'comment by user 2')
+
+          if (video.name === 'video 3 server 1') expect(comment).to.not.exist
+          else expect(comment).to.exist
+        }
+      }
+    })
+
+    it('Should delete comments of an account on the instance', async function () {
+      this.timeout(60000)
+
+      await bulkCommand.removeCommentsOf({
+        attributes: {
+          accountName: 'user3@' + servers[1].host,
+          scope: 'instance'
+        }
+      })
+
+      await waitJobs(servers)
+
+      await checkInstanceCommentsRemoved()
+    })
+
+    it('Should not re create the comment on video update', async function () {
+      this.timeout(60000)
+
+      for (const obj of commentsUser3) {
+        await servers[1].comments.addReply({
+          token: user3Token,
+          videoId: obj.videoId,
+          toCommentId: obj.commentId,
+          text: 'comment by user 3 bis'
+        })
+      }
+
+      await waitJobs(servers)
+
+      await checkInstanceCommentsRemoved()
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/server/config-defaults.ts b/packages/tests/src/api/server/config-defaults.ts
new file mode 100644
index 000000000..e874af012
--- /dev/null
+++ b/packages/tests/src/api/server/config-defaults.ts
@@ -0,0 +1,294 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { VideoDetails, VideoPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel
+} from '@peertube/peertube-server-commands'
+import { FIXTURE_URLS } from '@tests/shared/tests.js'
+
+describe('Test config defaults', function () {
+  let server: PeerTubeServer
+  let channelId: number
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1)
+    await setAccessTokensToServers([ server ])
+    await setDefaultVideoChannel([ server ])
+
+    channelId = server.store.channel.id
+  })
+
+  describe('Default publish values', function () {
+
+    before(async function () {
+      const overrideConfig = {
+        defaults: {
+          publish: {
+            comments_enabled: false,
+            download_enabled: false,
+            privacy: VideoPrivacy.INTERNAL,
+            licence: 4
+          }
+        }
+      }
+
+      await server.kill()
+      await server.run(overrideConfig)
+    })
+
+    const attributes = {
+      name: 'video',
+      downloadEnabled: undefined,
+      commentsEnabled: undefined,
+      licence: undefined,
+      privacy: VideoPrivacy.PUBLIC // Privacy is mandatory for server
+    }
+
+    function checkVideo (video: VideoDetails) {
+      expect(video.downloadEnabled).to.be.false
+      expect(video.commentsEnabled).to.be.false
+      expect(video.licence.id).to.equal(4)
+    }
+
+    before(async function () {
+      await server.config.disableTranscoding()
+      await server.config.enableImports()
+      await server.config.enableLive({ allowReplay: false, transcoding: false })
+    })
+
+    it('Should have the correct server configuration', async function () {
+      const config = await server.config.getConfig()
+
+      expect(config.defaults.publish.commentsEnabled).to.be.false
+      expect(config.defaults.publish.downloadEnabled).to.be.false
+      expect(config.defaults.publish.licence).to.equal(4)
+      expect(config.defaults.publish.privacy).to.equal(VideoPrivacy.INTERNAL)
+    })
+
+    it('Should respect default values when uploading a video', async function () {
+      for (const mode of [ 'legacy' as 'legacy', 'resumable' as 'resumable' ]) {
+        const { id } = await server.videos.upload({ attributes, mode })
+
+        const video = await server.videos.get({ id })
+        checkVideo(video)
+      }
+    })
+
+    it('Should respect default values when importing a video using URL', async function () {
+      const { video: { id } } = await server.imports.importVideo({
+        attributes: {
+          ...attributes,
+          channelId,
+          targetUrl: FIXTURE_URLS.goodVideo
+        }
+      })
+
+      const video = await server.videos.get({ id })
+      checkVideo(video)
+    })
+
+    it('Should respect default values when importing a video using magnet URI', async function () {
+      const { video: { id } } = await server.imports.importVideo({
+        attributes: {
+          ...attributes,
+          channelId,
+          magnetUri: FIXTURE_URLS.magnet
+        }
+      })
+
+      const video = await server.videos.get({ id })
+      checkVideo(video)
+    })
+
+    it('Should respect default values when creating a live', async function () {
+      const { id } = await server.live.create({
+        fields: {
+          ...attributes,
+          channelId
+        }
+      })
+
+      const video = await server.videos.get({ id })
+      checkVideo(video)
+    })
+  })
+
+  describe('Default P2P values', function () {
+
+    describe('Webapp default value', function () {
+
+      before(async function () {
+        const overrideConfig = {
+          defaults: {
+            p2p: {
+              webapp: {
+                enabled: false
+              }
+            }
+          }
+        }
+
+        await server.kill()
+        await server.run(overrideConfig)
+      })
+
+      it('Should have appropriate P2P config', async function () {
+        const config = await server.config.getConfig()
+
+        expect(config.defaults.p2p.webapp.enabled).to.be.false
+        expect(config.defaults.p2p.embed.enabled).to.be.true
+      })
+
+      it('Should create a user with this default setting', async function () {
+        await server.users.create({ username: 'user_p2p_1' })
+        const userToken = await server.login.getAccessToken('user_p2p_1')
+
+        const { p2pEnabled } = await server.users.getMyInfo({ token: userToken })
+        expect(p2pEnabled).to.be.false
+      })
+
+      it('Should register a user with this default setting', async function () {
+        await server.registrations.register({ username: 'user_p2p_2' })
+
+        const userToken = await server.login.getAccessToken('user_p2p_2')
+
+        const { p2pEnabled } = await server.users.getMyInfo({ token: userToken })
+        expect(p2pEnabled).to.be.false
+      })
+    })
+
+    describe('Embed default value', function () {
+
+      before(async function () {
+        const overrideConfig = {
+          defaults: {
+            p2p: {
+              embed: {
+                enabled: false
+              }
+            }
+          },
+          signup: {
+            limit: 15
+          }
+        }
+
+        await server.kill()
+        await server.run(overrideConfig)
+      })
+
+      it('Should have appropriate P2P config', async function () {
+        const config = await server.config.getConfig()
+
+        expect(config.defaults.p2p.webapp.enabled).to.be.true
+        expect(config.defaults.p2p.embed.enabled).to.be.false
+      })
+
+      it('Should create a user with this default setting', async function () {
+        await server.users.create({ username: 'user_p2p_3' })
+        const userToken = await server.login.getAccessToken('user_p2p_3')
+
+        const { p2pEnabled } = await server.users.getMyInfo({ token: userToken })
+        expect(p2pEnabled).to.be.true
+      })
+
+      it('Should register a user with this default setting', async function () {
+        await server.registrations.register({ username: 'user_p2p_4' })
+
+        const userToken = await server.login.getAccessToken('user_p2p_4')
+
+        const { p2pEnabled } = await server.users.getMyInfo({ token: userToken })
+        expect(p2pEnabled).to.be.true
+      })
+    })
+  })
+
+  describe('Default user attributes', function () {
+    it('Should create a user and register a user with the default config', async function () {
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          user: {
+            history: {
+              videos: {
+                enabled: true
+              }
+            },
+            videoQuota : -1,
+            videoQuotaDaily: -1
+          },
+          signup: {
+            enabled: true,
+            requiresApproval: false
+          }
+        }
+      })
+
+      const config = await server.config.getConfig()
+
+      expect(config.user.videoQuota).to.equal(-1)
+      expect(config.user.videoQuotaDaily).to.equal(-1)
+
+      const user1Token = await server.users.generateUserAndToken('user1')
+      const user1 = await server.users.getMyInfo({ token: user1Token })
+
+      const user = { displayName: 'super user 2', username: 'user2', password: 'super password' }
+      const channel = { name: 'my_user_2_channel', displayName: 'my channel' }
+      await server.registrations.register({ ...user, channel })
+      const user2Token = await server.login.getAccessToken(user)
+      const user2 = await server.users.getMyInfo({ token: user2Token })
+
+      for (const user of [ user1, user2 ]) {
+        expect(user.videosHistoryEnabled).to.be.true
+        expect(user.videoQuota).to.equal(-1)
+        expect(user.videoQuotaDaily).to.equal(-1)
+      }
+    })
+
+    it('Should update config and create a user and register a user with the new default config', async function () {
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          user: {
+            history: {
+              videos: {
+                enabled: false
+              }
+            },
+            videoQuota : 5242881,
+            videoQuotaDaily: 318742
+          },
+          signup: {
+            enabled: true,
+            requiresApproval: false
+          }
+        }
+      })
+
+      const user3Token = await server.users.generateUserAndToken('user3')
+      const user3 = await server.users.getMyInfo({ token: user3Token })
+
+      const user = { displayName: 'super user 4', username: 'user4', password: 'super password' }
+      const channel = { name: 'my_user_4_channel', displayName: 'my channel' }
+      await server.registrations.register({ ...user, channel })
+      const user4Token = await server.login.getAccessToken(user)
+      const user4 = await server.users.getMyInfo({ token: user4Token })
+
+      for (const user of [ user3, user4 ]) {
+        expect(user.videosHistoryEnabled).to.be.false
+        expect(user.videoQuota).to.equal(5242881)
+        expect(user.videoQuotaDaily).to.equal(318742)
+      }
+    })
+
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/config.ts b/packages/tests/src/api/server/config.ts
new file mode 100644
index 000000000..ce64668f8
--- /dev/null
+++ b/packages/tests/src/api/server/config.ts
@@ -0,0 +1,645 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { parallelTests } from '@peertube/peertube-node-utils'
+import { CustomConfig, HttpStatusCode } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  killallServers,
+  makeGetRequest,
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@peertube/peertube-server-commands'
+
+function checkInitialConfig (server: PeerTubeServer, data: CustomConfig) {
+  expect(data.instance.name).to.equal('PeerTube')
+  expect(data.instance.shortDescription).to.equal(
+    'PeerTube, an ActivityPub-federated video streaming platform using P2P directly in your web browser.'
+  )
+  expect(data.instance.description).to.equal('Welcome to this PeerTube instance!')
+
+  expect(data.instance.terms).to.equal('No terms for now.')
+  expect(data.instance.creationReason).to.be.empty
+  expect(data.instance.codeOfConduct).to.be.empty
+  expect(data.instance.moderationInformation).to.be.empty
+  expect(data.instance.administrator).to.be.empty
+  expect(data.instance.maintenanceLifetime).to.be.empty
+  expect(data.instance.businessModel).to.be.empty
+  expect(data.instance.hardwareInformation).to.be.empty
+
+  expect(data.instance.languages).to.have.lengthOf(0)
+  expect(data.instance.categories).to.have.lengthOf(0)
+
+  expect(data.instance.defaultClientRoute).to.equal('/videos/trending')
+  expect(data.instance.isNSFW).to.be.false
+  expect(data.instance.defaultNSFWPolicy).to.equal('display')
+  expect(data.instance.customizations.css).to.be.empty
+  expect(data.instance.customizations.javascript).to.be.empty
+
+  expect(data.services.twitter.username).to.equal('@Chocobozzz')
+  expect(data.services.twitter.whitelisted).to.be.false
+
+  expect(data.client.videos.miniature.preferAuthorDisplayName).to.be.false
+  expect(data.client.menu.login.redirectOnSingleExternalAuth).to.be.false
+
+  expect(data.cache.previews.size).to.equal(1)
+  expect(data.cache.captions.size).to.equal(1)
+  expect(data.cache.torrents.size).to.equal(1)
+  expect(data.cache.storyboards.size).to.equal(1)
+
+  expect(data.signup.enabled).to.be.true
+  expect(data.signup.limit).to.equal(4)
+  expect(data.signup.minimumAge).to.equal(16)
+  expect(data.signup.requiresApproval).to.be.false
+  expect(data.signup.requiresEmailVerification).to.be.false
+
+  expect(data.admin.email).to.equal('admin' + server.internalServerNumber + '@example.com')
+  expect(data.contactForm.enabled).to.be.true
+
+  expect(data.user.history.videos.enabled).to.be.true
+  expect(data.user.videoQuota).to.equal(5242880)
+  expect(data.user.videoQuotaDaily).to.equal(-1)
+
+  expect(data.videoChannels.maxPerUser).to.equal(20)
+
+  expect(data.transcoding.enabled).to.be.false
+  expect(data.transcoding.remoteRunners.enabled).to.be.false
+  expect(data.transcoding.allowAdditionalExtensions).to.be.false
+  expect(data.transcoding.allowAudioFiles).to.be.false
+  expect(data.transcoding.threads).to.equal(2)
+  expect(data.transcoding.concurrency).to.equal(2)
+  expect(data.transcoding.profile).to.equal('default')
+  expect(data.transcoding.resolutions['144p']).to.be.false
+  expect(data.transcoding.resolutions['240p']).to.be.true
+  expect(data.transcoding.resolutions['360p']).to.be.true
+  expect(data.transcoding.resolutions['480p']).to.be.true
+  expect(data.transcoding.resolutions['720p']).to.be.true
+  expect(data.transcoding.resolutions['1080p']).to.be.true
+  expect(data.transcoding.resolutions['1440p']).to.be.true
+  expect(data.transcoding.resolutions['2160p']).to.be.true
+  expect(data.transcoding.alwaysTranscodeOriginalResolution).to.be.true
+  expect(data.transcoding.webVideos.enabled).to.be.true
+  expect(data.transcoding.hls.enabled).to.be.true
+
+  expect(data.live.enabled).to.be.false
+  expect(data.live.allowReplay).to.be.false
+  expect(data.live.latencySetting.enabled).to.be.true
+  expect(data.live.maxDuration).to.equal(-1)
+  expect(data.live.maxInstanceLives).to.equal(20)
+  expect(data.live.maxUserLives).to.equal(3)
+  expect(data.live.transcoding.enabled).to.be.false
+  expect(data.live.transcoding.remoteRunners.enabled).to.be.false
+  expect(data.live.transcoding.threads).to.equal(2)
+  expect(data.live.transcoding.profile).to.equal('default')
+  expect(data.live.transcoding.resolutions['144p']).to.be.false
+  expect(data.live.transcoding.resolutions['240p']).to.be.false
+  expect(data.live.transcoding.resolutions['360p']).to.be.false
+  expect(data.live.transcoding.resolutions['480p']).to.be.false
+  expect(data.live.transcoding.resolutions['720p']).to.be.false
+  expect(data.live.transcoding.resolutions['1080p']).to.be.false
+  expect(data.live.transcoding.resolutions['1440p']).to.be.false
+  expect(data.live.transcoding.resolutions['2160p']).to.be.false
+  expect(data.live.transcoding.alwaysTranscodeOriginalResolution).to.be.true
+
+  expect(data.videoStudio.enabled).to.be.false
+  expect(data.videoStudio.remoteRunners.enabled).to.be.false
+
+  expect(data.videoFile.update.enabled).to.be.false
+
+  expect(data.import.videos.concurrency).to.equal(2)
+  expect(data.import.videos.http.enabled).to.be.true
+  expect(data.import.videos.torrent.enabled).to.be.true
+  expect(data.autoBlacklist.videos.ofUsers.enabled).to.be.false
+
+  expect(data.followers.instance.enabled).to.be.true
+  expect(data.followers.instance.manualApproval).to.be.false
+
+  expect(data.followings.instance.autoFollowBack.enabled).to.be.false
+  expect(data.followings.instance.autoFollowIndex.enabled).to.be.false
+  expect(data.followings.instance.autoFollowIndex.indexUrl).to.equal('')
+
+  expect(data.broadcastMessage.enabled).to.be.false
+  expect(data.broadcastMessage.level).to.equal('info')
+  expect(data.broadcastMessage.message).to.equal('')
+  expect(data.broadcastMessage.dismissable).to.be.false
+}
+
+function checkUpdatedConfig (data: CustomConfig) {
+  expect(data.instance.name).to.equal('PeerTube updated')
+  expect(data.instance.shortDescription).to.equal('my short description')
+  expect(data.instance.description).to.equal('my super description')
+
+  expect(data.instance.terms).to.equal('my super terms')
+  expect(data.instance.creationReason).to.equal('my super creation reason')
+  expect(data.instance.codeOfConduct).to.equal('my super coc')
+  expect(data.instance.moderationInformation).to.equal('my super moderation information')
+  expect(data.instance.administrator).to.equal('Kuja')
+  expect(data.instance.maintenanceLifetime).to.equal('forever')
+  expect(data.instance.businessModel).to.equal('my super business model')
+  expect(data.instance.hardwareInformation).to.equal('2vCore 3GB RAM')
+
+  expect(data.instance.languages).to.deep.equal([ 'en', 'es' ])
+  expect(data.instance.categories).to.deep.equal([ 1, 2 ])
+
+  expect(data.instance.defaultClientRoute).to.equal('/videos/recently-added')
+  expect(data.instance.isNSFW).to.be.true
+  expect(data.instance.defaultNSFWPolicy).to.equal('blur')
+  expect(data.instance.customizations.javascript).to.equal('alert("coucou")')
+  expect(data.instance.customizations.css).to.equal('body { background-color: red; }')
+
+  expect(data.services.twitter.username).to.equal('@Kuja')
+  expect(data.services.twitter.whitelisted).to.be.true
+
+  expect(data.client.videos.miniature.preferAuthorDisplayName).to.be.true
+  expect(data.client.menu.login.redirectOnSingleExternalAuth).to.be.true
+
+  expect(data.cache.previews.size).to.equal(2)
+  expect(data.cache.captions.size).to.equal(3)
+  expect(data.cache.torrents.size).to.equal(4)
+  expect(data.cache.storyboards.size).to.equal(5)
+
+  expect(data.signup.enabled).to.be.false
+  expect(data.signup.limit).to.equal(5)
+  expect(data.signup.requiresApproval).to.be.false
+  expect(data.signup.requiresEmailVerification).to.be.false
+  expect(data.signup.minimumAge).to.equal(10)
+
+  // We override admin email in parallel tests, so skip this exception
+  if (parallelTests() === false) {
+    expect(data.admin.email).to.equal('superadmin1@example.com')
+  }
+
+  expect(data.contactForm.enabled).to.be.false
+
+  expect(data.user.history.videos.enabled).to.be.false
+  expect(data.user.videoQuota).to.equal(5242881)
+  expect(data.user.videoQuotaDaily).to.equal(318742)
+
+  expect(data.videoChannels.maxPerUser).to.equal(24)
+
+  expect(data.transcoding.enabled).to.be.true
+  expect(data.transcoding.remoteRunners.enabled).to.be.true
+  expect(data.transcoding.threads).to.equal(1)
+  expect(data.transcoding.concurrency).to.equal(3)
+  expect(data.transcoding.allowAdditionalExtensions).to.be.true
+  expect(data.transcoding.allowAudioFiles).to.be.true
+  expect(data.transcoding.profile).to.equal('vod_profile')
+  expect(data.transcoding.resolutions['144p']).to.be.false
+  expect(data.transcoding.resolutions['240p']).to.be.false
+  expect(data.transcoding.resolutions['360p']).to.be.true
+  expect(data.transcoding.resolutions['480p']).to.be.true
+  expect(data.transcoding.resolutions['720p']).to.be.false
+  expect(data.transcoding.resolutions['1080p']).to.be.false
+  expect(data.transcoding.resolutions['2160p']).to.be.false
+  expect(data.transcoding.alwaysTranscodeOriginalResolution).to.be.false
+  expect(data.transcoding.hls.enabled).to.be.false
+  expect(data.transcoding.webVideos.enabled).to.be.true
+
+  expect(data.live.enabled).to.be.true
+  expect(data.live.allowReplay).to.be.true
+  expect(data.live.latencySetting.enabled).to.be.false
+  expect(data.live.maxDuration).to.equal(5000)
+  expect(data.live.maxInstanceLives).to.equal(-1)
+  expect(data.live.maxUserLives).to.equal(10)
+  expect(data.live.transcoding.enabled).to.be.true
+  expect(data.live.transcoding.remoteRunners.enabled).to.be.true
+  expect(data.live.transcoding.threads).to.equal(4)
+  expect(data.live.transcoding.profile).to.equal('live_profile')
+  expect(data.live.transcoding.resolutions['144p']).to.be.true
+  expect(data.live.transcoding.resolutions['240p']).to.be.true
+  expect(data.live.transcoding.resolutions['360p']).to.be.true
+  expect(data.live.transcoding.resolutions['480p']).to.be.true
+  expect(data.live.transcoding.resolutions['720p']).to.be.true
+  expect(data.live.transcoding.resolutions['1080p']).to.be.true
+  expect(data.live.transcoding.resolutions['2160p']).to.be.true
+  expect(data.live.transcoding.alwaysTranscodeOriginalResolution).to.be.false
+
+  expect(data.videoStudio.enabled).to.be.true
+  expect(data.videoStudio.remoteRunners.enabled).to.be.true
+
+  expect(data.videoFile.update.enabled).to.be.true
+
+  expect(data.import.videos.concurrency).to.equal(4)
+  expect(data.import.videos.http.enabled).to.be.false
+  expect(data.import.videos.torrent.enabled).to.be.false
+  expect(data.autoBlacklist.videos.ofUsers.enabled).to.be.true
+
+  expect(data.followers.instance.enabled).to.be.false
+  expect(data.followers.instance.manualApproval).to.be.true
+
+  expect(data.followings.instance.autoFollowBack.enabled).to.be.true
+  expect(data.followings.instance.autoFollowIndex.enabled).to.be.true
+  expect(data.followings.instance.autoFollowIndex.indexUrl).to.equal('https://updated.example.com')
+
+  expect(data.broadcastMessage.enabled).to.be.true
+  expect(data.broadcastMessage.level).to.equal('error')
+  expect(data.broadcastMessage.message).to.equal('super bad message')
+  expect(data.broadcastMessage.dismissable).to.be.true
+}
+
+const newCustomConfig: CustomConfig = {
+  instance: {
+    name: 'PeerTube updated',
+    shortDescription: 'my short description',
+    description: 'my super description',
+    terms: 'my super terms',
+    codeOfConduct: 'my super coc',
+
+    creationReason: 'my super creation reason',
+    moderationInformation: 'my super moderation information',
+    administrator: 'Kuja',
+    maintenanceLifetime: 'forever',
+    businessModel: 'my super business model',
+    hardwareInformation: '2vCore 3GB RAM',
+
+    languages: [ 'en', 'es' ],
+    categories: [ 1, 2 ],
+
+    isNSFW: true,
+    defaultNSFWPolicy: 'blur' as 'blur',
+
+    defaultClientRoute: '/videos/recently-added',
+
+    customizations: {
+      javascript: 'alert("coucou")',
+      css: 'body { background-color: red; }'
+    }
+  },
+  theme: {
+    default: 'default'
+  },
+  services: {
+    twitter: {
+      username: '@Kuja',
+      whitelisted: true
+    }
+  },
+  client: {
+    videos: {
+      miniature: {
+        preferAuthorDisplayName: true
+      }
+    },
+    menu: {
+      login: {
+        redirectOnSingleExternalAuth: true
+      }
+    }
+  },
+  cache: {
+    previews: {
+      size: 2
+    },
+    captions: {
+      size: 3
+    },
+    torrents: {
+      size: 4
+    },
+    storyboards: {
+      size: 5
+    }
+  },
+  signup: {
+    enabled: false,
+    limit: 5,
+    requiresApproval: false,
+    requiresEmailVerification: false,
+    minimumAge: 10
+  },
+  admin: {
+    email: 'superadmin1@example.com'
+  },
+  contactForm: {
+    enabled: false
+  },
+  user: {
+    history: {
+      videos: {
+        enabled: false
+      }
+    },
+    videoQuota: 5242881,
+    videoQuotaDaily: 318742
+  },
+  videoChannels: {
+    maxPerUser: 24
+  },
+  transcoding: {
+    enabled: true,
+    remoteRunners: {
+      enabled: true
+    },
+    allowAdditionalExtensions: true,
+    allowAudioFiles: true,
+    threads: 1,
+    concurrency: 3,
+    profile: 'vod_profile',
+    resolutions: {
+      '0p': false,
+      '144p': false,
+      '240p': false,
+      '360p': true,
+      '480p': true,
+      '720p': false,
+      '1080p': false,
+      '1440p': false,
+      '2160p': false
+    },
+    alwaysTranscodeOriginalResolution: false,
+    webVideos: {
+      enabled: true
+    },
+    hls: {
+      enabled: false
+    }
+  },
+  live: {
+    enabled: true,
+    allowReplay: true,
+    latencySetting: {
+      enabled: false
+    },
+    maxDuration: 5000,
+    maxInstanceLives: -1,
+    maxUserLives: 10,
+    transcoding: {
+      enabled: true,
+      remoteRunners: {
+        enabled: true
+      },
+      threads: 4,
+      profile: 'live_profile',
+      resolutions: {
+        '144p': true,
+        '240p': true,
+        '360p': true,
+        '480p': true,
+        '720p': true,
+        '1080p': true,
+        '1440p': true,
+        '2160p': true
+      },
+      alwaysTranscodeOriginalResolution: false
+    }
+  },
+  videoStudio: {
+    enabled: true,
+    remoteRunners: {
+      enabled: true
+    }
+  },
+  videoFile: {
+    update: {
+      enabled: true
+    }
+  },
+  import: {
+    videos: {
+      concurrency: 4,
+      http: {
+        enabled: false
+      },
+      torrent: {
+        enabled: false
+      }
+    },
+    videoChannelSynchronization: {
+      enabled: false,
+      maxPerUser: 10
+    }
+  },
+  trending: {
+    videos: {
+      algorithms: {
+        enabled: [ 'hot', 'most-viewed', 'most-liked' ],
+        default: 'hot'
+      }
+    }
+  },
+  autoBlacklist: {
+    videos: {
+      ofUsers: {
+        enabled: true
+      }
+    }
+  },
+  followers: {
+    instance: {
+      enabled: false,
+      manualApproval: true
+    }
+  },
+  followings: {
+    instance: {
+      autoFollowBack: {
+        enabled: true
+      },
+      autoFollowIndex: {
+        enabled: true,
+        indexUrl: 'https://updated.example.com'
+      }
+    }
+  },
+  broadcastMessage: {
+    enabled: true,
+    level: 'error',
+    message: 'super bad message',
+    dismissable: true
+  },
+  search: {
+    remoteUri: {
+      anonymous: true,
+      users: true
+    },
+    searchIndex: {
+      enabled: true,
+      url: 'https://search.joinpeertube.org',
+      disableLocalSearch: true,
+      isDefaultSearch: true
+    }
+  }
+}
+
+describe('Test static config', function () {
+  let server: PeerTubeServer = null
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1, { webadmin: { configuration: { edition: { allowed: false } } } })
+    await setAccessTokensToServers([ server ])
+  })
+
+  it('Should tell the client that edits are not allowed', async function () {
+    const data = await server.config.getConfig()
+
+    expect(data.webadmin.configuration.edition.allowed).to.be.false
+  })
+
+  it('Should error when client tries to update', async function () {
+    await server.config.updateCustomConfig({ newCustomConfig, expectedStatus: 405 })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
+
+describe('Test config', function () {
+  let server: PeerTubeServer = null
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1)
+    await setAccessTokensToServers([ server ])
+  })
+
+  it('Should have a correct config on a server with registration enabled', async function () {
+    const data = await server.config.getConfig()
+
+    expect(data.signup.allowed).to.be.true
+  })
+
+  it('Should have a correct config on a server with registration enabled and a users limit', async function () {
+    this.timeout(5000)
+
+    await Promise.all([
+      server.registrations.register({ username: 'user1' }),
+      server.registrations.register({ username: 'user2' }),
+      server.registrations.register({ username: 'user3' })
+    ])
+
+    const data = await server.config.getConfig()
+
+    expect(data.signup.allowed).to.be.false
+  })
+
+  it('Should have the correct video allowed extensions', async function () {
+    const data = await server.config.getConfig()
+
+    expect(data.video.file.extensions).to.have.lengthOf(3)
+    expect(data.video.file.extensions).to.contain('.mp4')
+    expect(data.video.file.extensions).to.contain('.webm')
+    expect(data.video.file.extensions).to.contain('.ogv')
+
+    await server.videos.upload({ attributes: { fixture: 'video_short.mkv' }, expectedStatus: HttpStatusCode.UNSUPPORTED_MEDIA_TYPE_415 })
+    await server.videos.upload({ attributes: { fixture: 'sample.ogg' }, expectedStatus: HttpStatusCode.UNSUPPORTED_MEDIA_TYPE_415 })
+
+    expect(data.contactForm.enabled).to.be.true
+  })
+
+  it('Should get the customized configuration', async function () {
+    const data = await server.config.getCustomConfig()
+
+    checkInitialConfig(server, data)
+  })
+
+  it('Should update the customized configuration', async function () {
+    await server.config.updateCustomConfig({ newCustomConfig })
+
+    const data = await server.config.getCustomConfig()
+    checkUpdatedConfig(data)
+  })
+
+  it('Should have the correct updated video allowed extensions', async function () {
+    this.timeout(30000)
+
+    const data = await server.config.getConfig()
+
+    expect(data.video.file.extensions).to.have.length.above(4)
+    expect(data.video.file.extensions).to.contain('.mp4')
+    expect(data.video.file.extensions).to.contain('.webm')
+    expect(data.video.file.extensions).to.contain('.ogv')
+    expect(data.video.file.extensions).to.contain('.flv')
+    expect(data.video.file.extensions).to.contain('.wmv')
+    expect(data.video.file.extensions).to.contain('.mkv')
+    expect(data.video.file.extensions).to.contain('.mp3')
+    expect(data.video.file.extensions).to.contain('.ogg')
+    expect(data.video.file.extensions).to.contain('.flac')
+
+    await server.videos.upload({ attributes: { fixture: 'video_short.mkv' }, expectedStatus: HttpStatusCode.OK_200 })
+    await server.videos.upload({ attributes: { fixture: 'sample.ogg' }, expectedStatus: HttpStatusCode.OK_200 })
+  })
+
+  it('Should have the configuration updated after a restart', async function () {
+    this.timeout(30000)
+
+    await killallServers([ server ])
+
+    await server.run()
+
+    const data = await server.config.getCustomConfig()
+
+    checkUpdatedConfig(data)
+  })
+
+  it('Should fetch the about information', async function () {
+    const data = await server.config.getAbout()
+
+    expect(data.instance.name).to.equal('PeerTube updated')
+    expect(data.instance.shortDescription).to.equal('my short description')
+    expect(data.instance.description).to.equal('my super description')
+    expect(data.instance.terms).to.equal('my super terms')
+    expect(data.instance.codeOfConduct).to.equal('my super coc')
+
+    expect(data.instance.creationReason).to.equal('my super creation reason')
+    expect(data.instance.moderationInformation).to.equal('my super moderation information')
+    expect(data.instance.administrator).to.equal('Kuja')
+    expect(data.instance.maintenanceLifetime).to.equal('forever')
+    expect(data.instance.businessModel).to.equal('my super business model')
+    expect(data.instance.hardwareInformation).to.equal('2vCore 3GB RAM')
+
+    expect(data.instance.languages).to.deep.equal([ 'en', 'es' ])
+    expect(data.instance.categories).to.deep.equal([ 1, 2 ])
+  })
+
+  it('Should remove the custom configuration', async function () {
+    await server.config.deleteCustomConfig()
+
+    const data = await server.config.getCustomConfig()
+    checkInitialConfig(server, data)
+  })
+
+  it('Should enable/disable security headers', async function () {
+    this.timeout(25000)
+
+    {
+      const res = await makeGetRequest({
+        url: server.url,
+        path: '/api/v1/config',
+        expectedStatus: 200
+      })
+
+      expect(res.headers['x-frame-options']).to.exist
+      expect(res.headers['x-powered-by']).to.equal('PeerTube')
+    }
+
+    await killallServers([ server ])
+
+    const config = {
+      security: {
+        frameguard: { enabled: false },
+        powered_by_header: { enabled: false }
+      }
+    }
+    await server.run(config)
+
+    {
+      const res = await makeGetRequest({
+        url: server.url,
+        path: '/api/v1/config',
+        expectedStatus: 200
+      })
+
+      expect(res.headers['x-frame-options']).to.not.exist
+      expect(res.headers['x-powered-by']).to.not.exist
+    }
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/contact-form.ts b/packages/tests/src/api/server/contact-form.ts
new file mode 100644
index 000000000..03389aa64
--- /dev/null
+++ b/packages/tests/src/api/server/contact-form.ts
@@ -0,0 +1,101 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { MockSmtpServer } from '@tests/shared/mock-servers/index.js'
+import { wait } from '@peertube/peertube-core-utils'
+import { HttpStatusCode } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  ConfigCommand,
+  ContactFormCommand,
+  createSingleServer,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Test contact form', function () {
+  let server: PeerTubeServer
+  const emails: object[] = []
+  let command: ContactFormCommand
+
+  before(async function () {
+    this.timeout(30000)
+
+    const port = await MockSmtpServer.Instance.collectEmails(emails)
+
+    server = await createSingleServer(1, ConfigCommand.getEmailOverrideConfig(port))
+    await setAccessTokensToServers([ server ])
+
+    command = server.contactForm
+  })
+
+  it('Should send a contact form', async function () {
+    await command.send({
+      fromEmail: 'toto@example.com',
+      body: 'my super message',
+      subject: 'my subject',
+      fromName: 'Super toto'
+    })
+
+    await waitJobs(server)
+
+    expect(emails).to.have.lengthOf(1)
+
+    const email = emails[0]
+
+    expect(email['from'][0]['address']).equal('test-admin@127.0.0.1')
+    expect(email['replyTo'][0]['address']).equal('toto@example.com')
+    expect(email['to'][0]['address']).equal('admin' + server.internalServerNumber + '@example.com')
+    expect(email['subject']).contains('my subject')
+    expect(email['text']).contains('my super message')
+  })
+
+  it('Should not have duplicated email address in text message', async function () {
+    const text = emails[0]['text'] as string
+
+    const matches = text.match(/toto@example.com/g)
+    expect(matches).to.have.lengthOf(1)
+  })
+
+  it('Should not be able to send another contact form because of the anti spam checker', async function () {
+    await wait(1000)
+
+    await command.send({
+      fromEmail: 'toto@example.com',
+      body: 'my super message',
+      subject: 'my subject',
+      fromName: 'Super toto'
+    })
+
+    await command.send({
+      fromEmail: 'toto@example.com',
+      body: 'my super message',
+      fromName: 'Super toto',
+      subject: 'my subject',
+      expectedStatus: HttpStatusCode.FORBIDDEN_403
+    })
+  })
+
+  it('Should be able to send another contact form after a while', async function () {
+    await wait(1000)
+
+    await command.send({
+      fromEmail: 'toto@example.com',
+      fromName: 'Super toto',
+      subject: 'my subject',
+      body: 'my super message'
+    })
+  })
+
+  it('Should not have the manage preferences link in the email', async function () {
+    const email = emails[0]
+    expect(email['text']).to.not.contain('Manage your notification preferences')
+  })
+
+  after(async function () {
+    MockSmtpServer.Instance.kill()
+
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/email.ts b/packages/tests/src/api/server/email.ts
new file mode 100644
index 000000000..6d3f3f3bb
--- /dev/null
+++ b/packages/tests/src/api/server/email.ts
@@ -0,0 +1,371 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { MockSmtpServer } from '@tests/shared/mock-servers/index.js'
+import { HttpStatusCode } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  ConfigCommand,
+  createSingleServer,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Test emails', function () {
+  let server: PeerTubeServer
+  let userId: number
+  let userId2: number
+  let userAccessToken: string
+
+  let videoShortUUID: string
+  let videoId: number
+
+  let videoUserUUID: string
+
+  let verificationString: string
+  let verificationString2: string
+
+  const emails: object[] = []
+  const user = {
+    username: 'user_1',
+    password: 'super_password'
+  }
+
+  before(async function () {
+    this.timeout(120000)
+
+    const emailPort = await MockSmtpServer.Instance.collectEmails(emails)
+    server = await createSingleServer(1, ConfigCommand.getEmailOverrideConfig(emailPort))
+
+    await setAccessTokensToServers([ server ])
+    await server.config.enableSignup(true)
+
+    {
+      const created = await server.users.create({ username: user.username, password: user.password })
+      userId = created.id
+
+      userAccessToken = await server.login.getAccessToken(user)
+    }
+
+    {
+      const attributes = { name: 'my super user video' }
+      const { uuid } = await server.videos.upload({ token: userAccessToken, attributes })
+      videoUserUUID = uuid
+    }
+
+    {
+      const attributes = {
+        name: 'my super name'
+      }
+      const { shortUUID, id } = await server.videos.upload({ attributes })
+      videoShortUUID = shortUUID
+      videoId = id
+    }
+  })
+
+  describe('When resetting user password', function () {
+
+    it('Should ask to reset the password', async function () {
+      await server.users.askResetPassword({ email: 'user_1@example.com' })
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(1)
+
+      const email = emails[0]
+
+      expect(email['from'][0]['name']).equal('PeerTube')
+      expect(email['from'][0]['address']).equal('test-admin@127.0.0.1')
+      expect(email['to'][0]['address']).equal('user_1@example.com')
+      expect(email['subject']).contains('password')
+
+      const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
+      expect(verificationStringMatches).not.to.be.null
+
+      verificationString = verificationStringMatches[1]
+      expect(verificationString).to.have.length.above(2)
+
+      const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
+      expect(userIdMatches).not.to.be.null
+
+      userId = parseInt(userIdMatches[1], 10)
+      expect(verificationString).to.not.be.undefined
+    })
+
+    it('Should not reset the password with an invalid verification string', async function () {
+      await server.users.resetPassword({
+        userId,
+        verificationString: verificationString + 'b',
+        password: 'super_password2',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should reset the password', async function () {
+      await server.users.resetPassword({ userId, verificationString, password: 'super_password2' })
+    })
+
+    it('Should not reset the password with the same verification string', async function () {
+      await server.users.resetPassword({
+        userId,
+        verificationString,
+        password: 'super_password3',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should login with this new password', async function () {
+      user.password = 'super_password2'
+
+      await server.login.getAccessToken(user)
+    })
+  })
+
+  describe('When creating a user without password', function () {
+
+    it('Should send a create password email', async function () {
+      await server.users.create({ username: 'create_password', password: '' })
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(2)
+
+      const email = emails[1]
+
+      expect(email['from'][0]['name']).equal('PeerTube')
+      expect(email['from'][0]['address']).equal('test-admin@127.0.0.1')
+      expect(email['to'][0]['address']).equal('create_password@example.com')
+      expect(email['subject']).contains('account')
+      expect(email['subject']).contains('password')
+
+      const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
+      expect(verificationStringMatches).not.to.be.null
+
+      verificationString2 = verificationStringMatches[1]
+      expect(verificationString2).to.have.length.above(2)
+
+      const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
+      expect(userIdMatches).not.to.be.null
+
+      userId2 = parseInt(userIdMatches[1], 10)
+    })
+
+    it('Should not reset the password with an invalid verification string', async function () {
+      await server.users.resetPassword({
+        userId: userId2,
+        verificationString: verificationString2 + 'c',
+        password: 'newly_created_password',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should reset the password', async function () {
+      await server.users.resetPassword({
+        userId: userId2,
+        verificationString: verificationString2,
+        password: 'newly_created_password'
+      })
+    })
+
+    it('Should login with this new password', async function () {
+      await server.login.getAccessToken({
+        username: 'create_password',
+        password: 'newly_created_password'
+      })
+    })
+  })
+
+  describe('When creating an abuse', function () {
+
+    it('Should send the notification email', async function () {
+      const reason = 'my super bad reason'
+      await server.abuses.report({ token: userAccessToken, videoId, reason })
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(3)
+
+      const email = emails[2]
+
+      expect(email['from'][0]['name']).equal('PeerTube')
+      expect(email['from'][0]['address']).equal('test-admin@127.0.0.1')
+      expect(email['to'][0]['address']).equal('admin' + server.internalServerNumber + '@example.com')
+      expect(email['subject']).contains('abuse')
+      expect(email['text']).contains(videoShortUUID)
+    })
+  })
+
+  describe('When blocking/unblocking user', function () {
+
+    it('Should send the notification email when blocking a user', async function () {
+      const reason = 'my super bad reason'
+      await server.users.banUser({ userId, reason })
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(4)
+
+      const email = emails[3]
+
+      expect(email['from'][0]['name']).equal('PeerTube')
+      expect(email['from'][0]['address']).equal('test-admin@127.0.0.1')
+      expect(email['to'][0]['address']).equal('user_1@example.com')
+      expect(email['subject']).contains(' blocked')
+      expect(email['text']).contains(' blocked')
+      expect(email['text']).contains('bad reason')
+    })
+
+    it('Should send the notification email when unblocking a user', async function () {
+      await server.users.unbanUser({ userId })
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(5)
+
+      const email = emails[4]
+
+      expect(email['from'][0]['name']).equal('PeerTube')
+      expect(email['from'][0]['address']).equal('test-admin@127.0.0.1')
+      expect(email['to'][0]['address']).equal('user_1@example.com')
+      expect(email['subject']).contains(' unblocked')
+      expect(email['text']).contains(' unblocked')
+    })
+  })
+
+  describe('When blacklisting a video', function () {
+    it('Should send the notification email', async function () {
+      const reason = 'my super reason'
+      await server.blacklist.add({ videoId: videoUserUUID, reason })
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(6)
+
+      const email = emails[5]
+
+      expect(email['from'][0]['name']).equal('PeerTube')
+      expect(email['from'][0]['address']).equal('test-admin@127.0.0.1')
+      expect(email['to'][0]['address']).equal('user_1@example.com')
+      expect(email['subject']).contains(' blacklisted')
+      expect(email['text']).contains('my super user video')
+      expect(email['text']).contains('my super reason')
+    })
+
+    it('Should send the notification email', async function () {
+      await server.blacklist.remove({ videoId: videoUserUUID })
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(7)
+
+      const email = emails[6]
+
+      expect(email['from'][0]['name']).equal('PeerTube')
+      expect(email['from'][0]['address']).equal('test-admin@127.0.0.1')
+      expect(email['to'][0]['address']).equal('user_1@example.com')
+      expect(email['subject']).contains(' unblacklisted')
+      expect(email['text']).contains('my super user video')
+    })
+
+    it('Should have the manage preferences link in the email', async function () {
+      const email = emails[6]
+      expect(email['text']).to.contain('Manage your notification preferences')
+    })
+  })
+
+  describe('When verifying a user email', function () {
+
+    it('Should ask to send the verification email', async function () {
+      await server.users.askSendVerifyEmail({ email: 'user_1@example.com' })
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(8)
+
+      const email = emails[7]
+
+      expect(email['from'][0]['name']).equal('PeerTube')
+      expect(email['from'][0]['address']).equal('test-admin@127.0.0.1')
+      expect(email['to'][0]['address']).equal('user_1@example.com')
+      expect(email['subject']).contains('Verify')
+
+      const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
+      expect(verificationStringMatches).not.to.be.null
+
+      verificationString = verificationStringMatches[1]
+      expect(verificationString).to.not.be.undefined
+      expect(verificationString).to.have.length.above(2)
+
+      const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
+      expect(userIdMatches).not.to.be.null
+
+      userId = parseInt(userIdMatches[1], 10)
+    })
+
+    it('Should not verify the email with an invalid verification string', async function () {
+      await server.users.verifyEmail({
+        userId,
+        verificationString: verificationString + 'b',
+        isPendingEmail: false,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should verify the email', async function () {
+      await server.users.verifyEmail({ userId, verificationString })
+    })
+  })
+
+  describe('When verifying a registration email', function () {
+    let registrationId: number
+    let registrationIdEmail: number
+
+    before(async function () {
+      const { id } = await server.registrations.requestRegistration({
+        username: 'request_1',
+        email: 'request_1@example.com',
+        registrationReason: 'tt'
+      })
+      registrationId = id
+    })
+
+    it('Should ask to send the verification email', async function () {
+      await server.registrations.askSendVerifyEmail({ email: 'request_1@example.com' })
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(9)
+
+      const email = emails[8]
+
+      expect(email['from'][0]['name']).equal('PeerTube')
+      expect(email['from'][0]['address']).equal('test-admin@127.0.0.1')
+      expect(email['to'][0]['address']).equal('request_1@example.com')
+      expect(email['subject']).contains('Verify')
+
+      const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
+      expect(verificationStringMatches).not.to.be.null
+
+      verificationString = verificationStringMatches[1]
+      expect(verificationString).to.not.be.undefined
+      expect(verificationString).to.have.length.above(2)
+
+      const registrationIdMatches = /registrationId=([0-9]+)/.exec(email['text'])
+      expect(registrationIdMatches).not.to.be.null
+
+      registrationIdEmail = parseInt(registrationIdMatches[1], 10)
+
+      expect(registrationId).to.equal(registrationIdEmail)
+    })
+
+    it('Should not verify the email with an invalid verification string', async function () {
+      await server.registrations.verifyEmail({
+        registrationId: registrationIdEmail,
+        verificationString: verificationString + 'b',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should verify the email', async function () {
+      await server.registrations.verifyEmail({ registrationId: registrationIdEmail, verificationString })
+    })
+  })
+
+  after(async function () {
+    MockSmtpServer.Instance.kill()
+
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/follow-constraints.ts b/packages/tests/src/api/server/follow-constraints.ts
new file mode 100644
index 000000000..8d277c906
--- /dev/null
+++ b/packages/tests/src/api/server/follow-constraints.ts
@@ -0,0 +1,321 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { HttpStatusCode, PeerTubeProblemDocument, ServerErrorCode } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Test follow constraints', function () {
+  let servers: PeerTubeServer[] = []
+  let video1UUID: string
+  let video2UUID: string
+  let userToken: string
+
+  before(async function () {
+    this.timeout(240000)
+
+    servers = await createMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    {
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video server 1' } })
+      video1UUID = uuid
+    }
+    {
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video server 2' } })
+      video2UUID = uuid
+    }
+
+    const user = {
+      username: 'user1',
+      password: 'super_password'
+    }
+    await servers[0].users.create({ username: user.username, password: user.password })
+    userToken = await servers[0].login.getAccessToken(user)
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  describe('With a followed instance', function () {
+
+    describe('With an unlogged user', function () {
+
+      it('Should get the local video', async function () {
+        await servers[0].videos.get({ id: video1UUID })
+      })
+
+      it('Should get the remote video', async function () {
+        await servers[0].videos.get({ id: video2UUID })
+      })
+
+      it('Should list local account videos', async function () {
+        const { total, data } = await servers[0].videos.listByAccount({ handle: 'root@' + servers[0].host })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should list remote account videos', async function () {
+        const { total, data } = await servers[0].videos.listByAccount({ handle: 'root@' + servers[1].host })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should list local channel videos', async function () {
+        const handle = 'root_channel@' + servers[0].host
+        const { total, data } = await servers[0].videos.listByChannel({ handle })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should list remote channel videos', async function () {
+        const handle = 'root_channel@' + servers[1].host
+        const { total, data } = await servers[0].videos.listByChannel({ handle })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+    })
+
+    describe('With a logged user', function () {
+      it('Should get the local video', async function () {
+        await servers[0].videos.getWithToken({ token: userToken, id: video1UUID })
+      })
+
+      it('Should get the remote video', async function () {
+        await servers[0].videos.getWithToken({ token: userToken, id: video2UUID })
+      })
+
+      it('Should list local account videos', async function () {
+        const { total, data } = await servers[0].videos.listByAccount({ token: userToken, handle: 'root@' + servers[0].host })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should list remote account videos', async function () {
+        const { total, data } = await servers[0].videos.listByAccount({ token: userToken, handle: 'root@' + servers[1].host })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should list local channel videos', async function () {
+        const handle = 'root_channel@' + servers[0].host
+        const { total, data } = await servers[0].videos.listByChannel({ token: userToken, handle })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should list remote channel videos', async function () {
+        const handle = 'root_channel@' + servers[1].host
+        const { total, data } = await servers[0].videos.listByChannel({ token: userToken, handle })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+    })
+  })
+
+  describe('With a non followed instance', function () {
+
+    before(async function () {
+      this.timeout(30000)
+
+      await servers[0].follows.unfollow({ target: servers[1] })
+    })
+
+    describe('With an unlogged user', function () {
+
+      it('Should get the local video', async function () {
+        await servers[0].videos.get({ id: video1UUID })
+      })
+
+      it('Should not get the remote video', async function () {
+        const body = await servers[0].videos.get({ id: video2UUID, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+        const error = body as unknown as PeerTubeProblemDocument
+
+        const doc = 'https://docs.joinpeertube.org/api-rest-reference.html#section/Errors/does_not_respect_follow_constraints'
+        expect(error.type).to.equal(doc)
+        expect(error.code).to.equal(ServerErrorCode.DOES_NOT_RESPECT_FOLLOW_CONSTRAINTS)
+
+        expect(error.detail).to.equal('Cannot get this video regarding follow constraints')
+        expect(error.error).to.equal(error.detail)
+
+        expect(error.status).to.equal(HttpStatusCode.FORBIDDEN_403)
+
+        expect(error.originUrl).to.contains(servers[1].url)
+      })
+
+      it('Should list local account videos', async function () {
+        const { total, data } = await servers[0].videos.listByAccount({
+          token: null,
+          handle: 'root@' + servers[0].host
+        })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should not list remote account videos', async function () {
+        const { total, data } = await servers[0].videos.listByAccount({
+          token: null,
+          handle: 'root@' + servers[1].host
+        })
+
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
+      })
+
+      it('Should list local channel videos', async function () {
+        const handle = 'root_channel@' + servers[0].host
+        const { total, data } = await servers[0].videos.listByChannel({ token: null, handle })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should not list remote channel videos', async function () {
+        const handle = 'root_channel@' + servers[1].host
+        const { total, data } = await servers[0].videos.listByChannel({ token: null, handle })
+
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
+      })
+    })
+
+    describe('With a logged user', function () {
+
+      it('Should get the local video', async function () {
+        await servers[0].videos.getWithToken({ token: userToken, id: video1UUID })
+      })
+
+      it('Should get the remote video', async function () {
+        await servers[0].videos.getWithToken({ token: userToken, id: video2UUID })
+      })
+
+      it('Should list local account videos', async function () {
+        const { total, data } = await servers[0].videos.listByAccount({ token: userToken, handle: 'root@' + servers[0].host })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should list remote account videos', async function () {
+        const { total, data } = await servers[0].videos.listByAccount({ token: userToken, handle: 'root@' + servers[1].host })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should list local channel videos', async function () {
+        const handle = 'root_channel@' + servers[0].host
+        const { total, data } = await servers[0].videos.listByChannel({ token: userToken, handle })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+
+      it('Should list remote channel videos', async function () {
+        const handle = 'root_channel@' + servers[1].host
+        const { total, data } = await servers[0].videos.listByChannel({ token: userToken, handle })
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      })
+    })
+  })
+
+  describe('When following a remote account', function () {
+
+    before(async function () {
+      this.timeout(60000)
+
+      await servers[0].follows.follow({ handles: [ 'root@' + servers[1].host ] })
+      await waitJobs(servers)
+    })
+
+    it('Should get the remote video with an unlogged user', async function () {
+      await servers[0].videos.get({ id: video2UUID })
+    })
+
+    it('Should get the remote video with a logged in user', async function () {
+      await servers[0].videos.getWithToken({ token: userToken, id: video2UUID })
+    })
+  })
+
+  describe('When unfollowing a remote account', function () {
+
+    before(async function () {
+      this.timeout(60000)
+
+      await servers[0].follows.unfollow({ target: 'root@' + servers[1].host })
+      await waitJobs(servers)
+    })
+
+    it('Should not get the remote video with an unlogged user', async function () {
+      const body = await servers[0].videos.get({ id: video2UUID, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+
+      const error = body as unknown as PeerTubeProblemDocument
+      expect(error.code).to.equal(ServerErrorCode.DOES_NOT_RESPECT_FOLLOW_CONSTRAINTS)
+    })
+
+    it('Should get the remote video with a logged in user', async function () {
+      await servers[0].videos.getWithToken({ token: userToken, id: video2UUID })
+    })
+  })
+
+  describe('When following a remote channel', function () {
+
+    before(async function () {
+      this.timeout(60000)
+
+      await servers[0].follows.follow({ handles: [ 'root_channel@' + servers[1].host ] })
+      await waitJobs(servers)
+    })
+
+    it('Should get the remote video with an unlogged user', async function () {
+      await servers[0].videos.get({ id: video2UUID })
+    })
+
+    it('Should get the remote video with a logged in user', async function () {
+      await servers[0].videos.getWithToken({ token: userToken, id: video2UUID })
+    })
+  })
+
+  describe('When unfollowing a remote channel', function () {
+
+    before(async function () {
+      this.timeout(60000)
+
+      await servers[0].follows.unfollow({ target: 'root_channel@' + servers[1].host })
+      await waitJobs(servers)
+    })
+
+    it('Should not get the remote video with an unlogged user', async function () {
+      const body = await servers[0].videos.get({ id: video2UUID, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+
+      const error = body as unknown as PeerTubeProblemDocument
+      expect(error.code).to.equal(ServerErrorCode.DOES_NOT_RESPECT_FOLLOW_CONSTRAINTS)
+    })
+
+    it('Should get the remote video with a logged in user', async function () {
+      await servers[0].videos.getWithToken({ token: userToken, id: video2UUID })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/server/follows-moderation.ts b/packages/tests/src/api/server/follows-moderation.ts
new file mode 100644
index 000000000..811dd5c22
--- /dev/null
+++ b/packages/tests/src/api/server/follows-moderation.ts
@@ -0,0 +1,364 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { expectStartWith } from '@tests/shared/checks.js'
+import { ActorFollow, FollowState } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  FollowsCommand,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+async function checkServer1And2HasFollowers (servers: PeerTubeServer[], state = 'accepted') {
+  const fns = [
+    servers[0].follows.getFollowings.bind(servers[0].follows),
+    servers[1].follows.getFollowers.bind(servers[1].follows)
+  ]
+
+  for (const fn of fns) {
+    const body = await fn({ start: 0, count: 5, sort: 'createdAt' })
+    expect(body.total).to.equal(1)
+
+    const follow = body.data[0]
+    expect(follow.state).to.equal(state)
+    expect(follow.follower.url).to.equal(servers[0].url + '/accounts/peertube')
+    expect(follow.following.url).to.equal(servers[1].url + '/accounts/peertube')
+  }
+}
+
+async function checkFollows (options: {
+  follower: PeerTubeServer
+  followerState: FollowState | 'deleted'
+
+  following: PeerTubeServer
+  followingState: FollowState | 'deleted'
+}) {
+  const { follower, followerState, followingState, following } = options
+
+  const followerUrl = follower.url + '/accounts/peertube'
+  const followingUrl = following.url + '/accounts/peertube'
+  const finder = (d: ActorFollow) => d.follower.url === followerUrl && d.following.url === followingUrl
+
+  {
+    const { data } = await follower.follows.getFollowings()
+    const follow = data.find(finder)
+
+    if (followerState === 'deleted') {
+      expect(follow).to.not.exist
+    } else {
+      expect(follow.state).to.equal(followerState)
+      expect(follow.follower.url).to.equal(followerUrl)
+      expect(follow.following.url).to.equal(followingUrl)
+    }
+  }
+
+  {
+    const { data } = await following.follows.getFollowers()
+    const follow = data.find(finder)
+
+    if (followingState === 'deleted') {
+      expect(follow).to.not.exist
+    } else {
+      expect(follow.state).to.equal(followingState)
+      expect(follow.follower.url).to.equal(followerUrl)
+      expect(follow.following.url).to.equal(followingUrl)
+    }
+  }
+}
+
+async function checkNoFollowers (servers: PeerTubeServer[]) {
+  const fns = [
+    servers[0].follows.getFollowings.bind(servers[0].follows),
+    servers[1].follows.getFollowers.bind(servers[1].follows)
+  ]
+
+  for (const fn of fns) {
+    const body = await fn({ start: 0, count: 5, sort: 'createdAt', state: 'accepted' })
+    expect(body.total).to.equal(0)
+  }
+}
+
+describe('Test follows moderation', function () {
+  let servers: PeerTubeServer[] = []
+  let commands: FollowsCommand[]
+
+  before(async function () {
+    this.timeout(240000)
+
+    servers = await createMultipleServers(3)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    commands = servers.map(s => s.follows)
+  })
+
+  describe('Default behaviour', function () {
+
+    it('Should have server 1 following server 2', async function () {
+      this.timeout(30000)
+
+      await commands[0].follow({ hosts: [ servers[1].url ] })
+
+      await waitJobs(servers)
+    })
+
+    it('Should have correct follows', async function () {
+      await checkServer1And2HasFollowers(servers)
+    })
+
+    it('Should remove follower on server 2', async function () {
+      await commands[1].removeFollower({ follower: servers[0] })
+
+      await waitJobs(servers)
+    })
+
+    it('Should not not have follows anymore', async function () {
+      await checkNoFollowers(servers)
+    })
+  })
+
+  describe('Disabled/Enabled followers', function () {
+
+    it('Should disable followers on server 2', async function () {
+      const subConfig = {
+        followers: {
+          instance: {
+            enabled: false,
+            manualApproval: false
+          }
+        }
+      }
+
+      await servers[1].config.updateCustomSubConfig({ newConfig: subConfig })
+
+      await commands[0].follow({ hosts: [ servers[1].url ] })
+      await waitJobs(servers)
+
+      await checkNoFollowers(servers)
+    })
+
+    it('Should re enable followers on server 2', async function () {
+      const subConfig = {
+        followers: {
+          instance: {
+            enabled: true,
+            manualApproval: false
+          }
+        }
+      }
+
+      await servers[1].config.updateCustomSubConfig({ newConfig: subConfig })
+
+      await commands[0].follow({ hosts: [ servers[1].url ] })
+      await waitJobs(servers)
+
+      await checkServer1And2HasFollowers(servers)
+    })
+  })
+
+  describe('Manual approbation', function () {
+
+    it('Should manually approve followers', async function () {
+      this.timeout(20000)
+
+      await commands[0].unfollow({ target: servers[1] })
+      await waitJobs(servers)
+
+      const subConfig = {
+        followers: {
+          instance: {
+            enabled: true,
+            manualApproval: true
+          }
+        }
+      }
+
+      await servers[1].config.updateCustomSubConfig({ newConfig: subConfig })
+      await servers[2].config.updateCustomSubConfig({ newConfig: subConfig })
+
+      await commands[0].follow({ hosts: [ servers[1].url ] })
+      await waitJobs(servers)
+
+      await checkServer1And2HasFollowers(servers, 'pending')
+    })
+
+    it('Should accept a follower', async function () {
+      await commands[1].acceptFollower({ follower: 'peertube@' + servers[0].host })
+      await waitJobs(servers)
+
+      await checkServer1And2HasFollowers(servers)
+    })
+
+    it('Should reject another follower', async function () {
+      this.timeout(20000)
+
+      await commands[0].follow({ hosts: [ servers[2].url ] })
+      await waitJobs(servers)
+
+      {
+        const body = await commands[0].getFollowings()
+        expect(body.total).to.equal(2)
+      }
+
+      {
+        const body = await commands[1].getFollowers()
+        expect(body.total).to.equal(1)
+      }
+
+      {
+        const body = await commands[2].getFollowers()
+        expect(body.total).to.equal(1)
+      }
+
+      await commands[2].rejectFollower({ follower: 'peertube@' + servers[0].host })
+      await waitJobs(servers)
+
+      { // server 1
+        {
+          const { data } = await commands[0].getFollowings({ state: 'accepted' })
+          expect(data).to.have.lengthOf(1)
+        }
+
+        {
+          const { data } = await commands[0].getFollowings({ state: 'rejected' })
+          expect(data).to.have.lengthOf(1)
+          expectStartWith(data[0].following.url, servers[2].url)
+        }
+      }
+
+      { // server 3
+        {
+          const { data } = await commands[2].getFollowers({ state: 'accepted' })
+          expect(data).to.have.lengthOf(0)
+        }
+
+        {
+          const { data } = await commands[2].getFollowers({ state: 'rejected' })
+          expect(data).to.have.lengthOf(1)
+          expectStartWith(data[0].follower.url, servers[0].url)
+        }
+      }
+    })
+
+    it('Should still auto accept channel followers', async function () {
+      await commands[0].follow({ handles: [ 'root_channel@' + servers[1].host ] })
+
+      await waitJobs(servers)
+
+      const body = await commands[0].getFollowings()
+      const follow = body.data[0]
+      expect(follow.following.name).to.equal('root_channel')
+      expect(follow.state).to.equal('accepted')
+    })
+  })
+
+  describe('Accept/reject state', function () {
+
+    it('Should not change the follow on refollow with and without auto accept', async function () {
+      const run = async () => {
+        await commands[0].follow({ hosts: [ servers[2].url ] })
+        await waitJobs(servers)
+
+        await checkFollows({
+          follower: servers[0],
+          followerState: 'rejected',
+          following: servers[2],
+          followingState: 'rejected'
+        })
+      }
+
+      await servers[2].config.updateExistingSubConfig({ newConfig: { followers: { instance: { manualApproval: false } } } })
+      await run()
+
+      await servers[2].config.updateExistingSubConfig({ newConfig: { followers: { instance: { manualApproval: true } } } })
+      await run()
+    })
+
+    it('Should not change the rejected status on unfollow', async function () {
+      await commands[0].unfollow({ target: servers[2] })
+      await waitJobs(servers)
+
+      await checkFollows({
+        follower: servers[0],
+        followerState: 'deleted',
+        following: servers[2],
+        followingState: 'rejected'
+      })
+    })
+
+    it('Should delete the follower and add again the follower', async function () {
+      await commands[2].removeFollower({ follower: servers[0] })
+      await waitJobs(servers)
+
+      await commands[0].follow({ hosts: [ servers[2].url ] })
+      await waitJobs(servers)
+
+      await checkFollows({
+        follower: servers[0],
+        followerState: 'pending',
+        following: servers[2],
+        followingState: 'pending'
+      })
+    })
+
+    it('Should be able to reject a previously accepted follower', async function () {
+      await commands[1].rejectFollower({ follower: 'peertube@' + servers[0].host })
+      await waitJobs(servers)
+
+      await checkFollows({
+        follower: servers[0],
+        followerState: 'rejected',
+        following: servers[1],
+        followingState: 'rejected'
+      })
+    })
+
+    it('Should be able to re accept a previously rejected follower', async function () {
+      await commands[1].acceptFollower({ follower: 'peertube@' + servers[0].host })
+      await waitJobs(servers)
+
+      await checkFollows({
+        follower: servers[0],
+        followerState: 'accepted',
+        following: servers[1],
+        followingState: 'accepted'
+      })
+    })
+  })
+
+  describe('Muted servers', function () {
+
+    it('Should ignore follow requests of muted servers', async function () {
+      await servers[1].blocklist.addToServerBlocklist({ server: servers[0].host })
+
+      await commands[0].unfollow({ target: servers[1] })
+
+      await waitJobs(servers)
+
+      await checkFollows({
+        follower: servers[0],
+        followerState: 'deleted',
+        following: servers[1],
+        followingState: 'deleted'
+      })
+
+      await commands[0].follow({ hosts: [ servers[1].host ] })
+      await waitJobs(servers)
+
+      await checkFollows({
+        follower: servers[0],
+        followerState: 'rejected',
+        following: servers[1],
+        followingState: 'deleted'
+      })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/server/follows.ts b/packages/tests/src/api/server/follows.ts
new file mode 100644
index 000000000..fbe2e87da
--- /dev/null
+++ b/packages/tests/src/api/server/follows.ts
@@ -0,0 +1,644 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { Video, VideoPrivacy } from '@peertube/peertube-models'
+import { cleanupTests, createMultipleServers, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@peertube/peertube-server-commands'
+import { expectAccountFollows, expectChannelsFollows } from '@tests/shared/actors.js'
+import { testCaptionFile } from '@tests/shared/captions.js'
+import { dateIsValid } from '@tests/shared/checks.js'
+import { completeVideoCheck } from '@tests/shared/videos.js'
+
+describe('Test follows', function () {
+
+  describe('Complex follow', function () {
+    let servers: PeerTubeServer[] = []
+
+    before(async function () {
+      this.timeout(120000)
+
+      servers = await createMultipleServers(3)
+
+      // Get the access tokens
+      await setAccessTokensToServers(servers)
+    })
+
+    describe('Data propagation after follow', function () {
+
+      it('Should not have followers/followings', async function () {
+        for (const server of servers) {
+          const bodies = await Promise.all([
+            server.follows.getFollowers({ start: 0, count: 5, sort: 'createdAt' }),
+            server.follows.getFollowings({ start: 0, count: 5, sort: 'createdAt' })
+          ])
+
+          for (const body of bodies) {
+            expect(body.total).to.equal(0)
+
+            const follows = body.data
+            expect(follows).to.be.an('array')
+            expect(follows).to.have.lengthOf(0)
+          }
+        }
+      })
+
+      it('Should have server 1 following root account of server 2 and server 3', async function () {
+        this.timeout(30000)
+
+        await servers[0].follows.follow({
+          hosts: [ servers[2].url ],
+          handles: [ 'root@' + servers[1].host ]
+        })
+
+        await waitJobs(servers)
+      })
+
+      it('Should have 2 followings on server 1', async function () {
+        const body = await servers[0].follows.getFollowings({ start: 0, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(2)
+
+        let follows = body.data
+        expect(follows).to.be.an('array')
+        expect(follows).to.have.lengthOf(1)
+
+        const body2 = await servers[0].follows.getFollowings({ start: 1, count: 1, sort: 'createdAt' })
+        follows = follows.concat(body2.data)
+
+        const server2Follow = follows.find(f => f.following.host === servers[1].host)
+        const server3Follow = follows.find(f => f.following.host === servers[2].host)
+
+        expect(server2Follow).to.not.be.undefined
+        expect(server2Follow.following.name).to.equal('root')
+        expect(server2Follow.state).to.equal('accepted')
+
+        expect(server3Follow).to.not.be.undefined
+        expect(server3Follow.following.name).to.equal('peertube')
+        expect(server3Follow.state).to.equal('accepted')
+      })
+
+      it('Should have 0 followings on server 2 and 3', async function () {
+        for (const server of [ servers[1], servers[2] ]) {
+          const body = await server.follows.getFollowings({ start: 0, count: 5, sort: 'createdAt' })
+          expect(body.total).to.equal(0)
+
+          const follows = body.data
+          expect(follows).to.be.an('array')
+          expect(follows).to.have.lengthOf(0)
+        }
+      })
+
+      it('Should have 1 followers on server 3', async function () {
+        const body = await servers[2].follows.getFollowers({ start: 0, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(1)
+
+        const follows = body.data
+        expect(follows).to.be.an('array')
+        expect(follows).to.have.lengthOf(1)
+        expect(follows[0].follower.host).to.equal(servers[0].host)
+      })
+
+      it('Should have 0 followers on server 1 and 2', async function () {
+        for (const server of [ servers[0], servers[1] ]) {
+          const body = await server.follows.getFollowers({ start: 0, count: 5, sort: 'createdAt' })
+          expect(body.total).to.equal(0)
+
+          const follows = body.data
+          expect(follows).to.be.an('array')
+          expect(follows).to.have.lengthOf(0)
+        }
+      })
+
+      it('Should search/filter followings on server 1', async function () {
+        const sort = 'createdAt'
+        const start = 0
+        const count = 1
+
+        {
+          const search = ':' + servers[1].port
+
+          {
+            const body = await servers[0].follows.getFollowings({ start, count, sort, search })
+            expect(body.total).to.equal(1)
+
+            const follows = body.data
+            expect(follows).to.have.lengthOf(1)
+            expect(follows[0].following.host).to.equal(servers[1].host)
+          }
+
+          {
+            const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'accepted' })
+            expect(body.total).to.equal(1)
+            expect(body.data).to.have.lengthOf(1)
+          }
+
+          {
+            const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'accepted', actorType: 'Person' })
+            expect(body.total).to.equal(1)
+            expect(body.data).to.have.lengthOf(1)
+          }
+
+          {
+            const body = await servers[0].follows.getFollowings({
+              start,
+              count,
+              sort,
+              search,
+              state: 'accepted',
+              actorType: 'Application'
+            })
+            expect(body.total).to.equal(0)
+            expect(body.data).to.have.lengthOf(0)
+          }
+
+          {
+            const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'pending' })
+            expect(body.total).to.equal(0)
+            expect(body.data).to.have.lengthOf(0)
+          }
+        }
+
+        {
+          const body = await servers[0].follows.getFollowings({ start, count, sort, search: 'root' })
+          expect(body.total).to.equal(1)
+          expect(body.data).to.have.lengthOf(1)
+        }
+
+        {
+          const body = await servers[0].follows.getFollowings({ start, count, sort, search: 'bla' })
+          expect(body.total).to.equal(0)
+
+          expect(body.data).to.have.lengthOf(0)
+        }
+      })
+
+      it('Should search/filter followers on server 2', async function () {
+        const start = 0
+        const count = 5
+        const sort = 'createdAt'
+
+        {
+          const search = servers[0].port + ''
+
+          {
+            const body = await servers[2].follows.getFollowers({ start, count, sort, search })
+            expect(body.total).to.equal(1)
+
+            const follows = body.data
+            expect(follows).to.have.lengthOf(1)
+            expect(follows[0].following.host).to.equal(servers[2].host)
+          }
+
+          {
+            const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'accepted' })
+            expect(body.total).to.equal(1)
+            expect(body.data).to.have.lengthOf(1)
+          }
+
+          {
+            const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'accepted', actorType: 'Person' })
+            expect(body.total).to.equal(0)
+            expect(body.data).to.have.lengthOf(0)
+          }
+
+          {
+            const body = await servers[2].follows.getFollowers({
+              start,
+              count,
+              sort,
+              search,
+              state: 'accepted',
+              actorType: 'Application'
+            })
+            expect(body.total).to.equal(1)
+            expect(body.data).to.have.lengthOf(1)
+          }
+
+          {
+            const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'pending' })
+            expect(body.total).to.equal(0)
+            expect(body.data).to.have.lengthOf(0)
+          }
+        }
+
+        {
+          const body = await servers[2].follows.getFollowers({ start, count, sort, search: 'bla' })
+          expect(body.total).to.equal(0)
+
+          const follows = body.data
+          expect(follows).to.have.lengthOf(0)
+        }
+      })
+
+      it('Should have the correct follows counts', async function () {
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 2 })
+        await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
+
+        // Server 2 and 3 does not know server 1 follow another server (there was not a refresh)
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
+
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
+      })
+
+      it('Should unfollow server 3 on server 1', async function () {
+        this.timeout(15000)
+
+        await servers[0].follows.unfollow({ target: servers[2] })
+
+        await waitJobs(servers)
+      })
+
+      it('Should not follow server 3 on server 1 anymore', async function () {
+        const body = await servers[0].follows.getFollowings({ start: 0, count: 2, sort: 'createdAt' })
+        expect(body.total).to.equal(1)
+
+        const follows = body.data
+        expect(follows).to.be.an('array')
+        expect(follows).to.have.lengthOf(1)
+
+        expect(follows[0].following.host).to.equal(servers[1].host)
+      })
+
+      it('Should not have server 1 as follower on server 3 anymore', async function () {
+        const body = await servers[2].follows.getFollowers({ start: 0, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(0)
+
+        const follows = body.data
+        expect(follows).to.be.an('array')
+        expect(follows).to.have.lengthOf(0)
+      })
+
+      it('Should have the correct follows counts after the unfollow', async function () {
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 0, following: 0 })
+
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
+
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 0 })
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 0, following: 0 })
+      })
+
+      it('Should upload a video on server 2 and 3 and propagate only the video of server 2', async function () {
+        this.timeout(160000)
+
+        await servers[1].videos.upload({ attributes: { name: 'server2' } })
+        await servers[2].videos.upload({ attributes: { name: 'server3' } })
+
+        await waitJobs(servers)
+
+        {
+          const { total, data } = await servers[0].videos.list()
+          expect(total).to.equal(1)
+          expect(data[0].name).to.equal('server2')
+        }
+
+        {
+          const { total, data } = await servers[1].videos.list()
+          expect(total).to.equal(1)
+          expect(data[0].name).to.equal('server2')
+        }
+
+        {
+          const { total, data } = await servers[2].videos.list()
+          expect(total).to.equal(1)
+          expect(data[0].name).to.equal('server3')
+        }
+      })
+
+      it('Should remove account follow', async function () {
+        this.timeout(15000)
+
+        await servers[0].follows.unfollow({ target: 'root@' + servers[1].host })
+
+        await waitJobs(servers)
+      })
+
+      it('Should have removed the account follow', async function () {
+        await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+        await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+
+        {
+          const { total, data } = await servers[0].follows.getFollowings()
+          expect(total).to.equal(0)
+          expect(data).to.have.lengthOf(0)
+        }
+
+        {
+          const { total, data } = await servers[0].videos.list()
+          expect(total).to.equal(0)
+          expect(data).to.have.lengthOf(0)
+        }
+      })
+
+      it('Should follow a channel', async function () {
+        this.timeout(15000)
+
+        await servers[0].follows.follow({
+          handles: [ 'root_channel@' + servers[1].host ]
+        })
+
+        await waitJobs(servers)
+
+        await expectChannelsFollows({ server: servers[0], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+        await expectChannelsFollows({ server: servers[1], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+
+        {
+          const { total, data } = await servers[0].follows.getFollowings()
+          expect(total).to.equal(1)
+          expect(data).to.have.lengthOf(1)
+        }
+
+        {
+          const { total, data } = await servers[0].videos.list()
+          expect(total).to.equal(1)
+          expect(data).to.have.lengthOf(1)
+        }
+      })
+    })
+
+    describe('Should propagate data on a new server follow', function () {
+      let video4: Video
+
+      before(async function () {
+        this.timeout(240000)
+
+        const video4Attributes = {
+          name: 'server3-4',
+          category: 2,
+          nsfw: true,
+          licence: 6,
+          tags: [ 'tag1', 'tag2', 'tag3' ]
+        }
+
+        await servers[2].videos.upload({ attributes: { name: 'server3-2' } })
+        await servers[2].videos.upload({ attributes: { name: 'server3-3' } })
+
+        const video4CreateResult = await servers[2].videos.upload({ attributes: video4Attributes })
+
+        await servers[2].videos.upload({ attributes: { name: 'server3-5' } })
+        await servers[2].videos.upload({ attributes: { name: 'server3-6' } })
+
+        {
+          const userAccessToken = await servers[2].users.generateUserAndToken('captain')
+
+          await servers[2].videos.rate({ id: video4CreateResult.id, rating: 'like' })
+          await servers[2].videos.rate({ token: userAccessToken, id: video4CreateResult.id, rating: 'dislike' })
+        }
+
+        {
+          await servers[2].comments.createThread({ videoId: video4CreateResult.id, text: 'my super first comment' })
+
+          await servers[2].comments.addReplyToLastThread({ text: 'my super answer to thread 1' })
+          await servers[2].comments.addReplyToLastReply({ text: 'my super answer to answer of thread 1' })
+          await servers[2].comments.addReplyToLastThread({ text: 'my second answer to thread 1' })
+        }
+
+        {
+          const { id: threadId } = await servers[2].comments.createThread({ videoId: video4CreateResult.id, text: 'will be deleted' })
+          await servers[2].comments.addReplyToLastThread({ text: 'answer to deleted' })
+
+          const { id: replyId } = await servers[2].comments.addReplyToLastThread({ text: 'will also be deleted' })
+
+          await servers[2].comments.addReplyToLastReply({ text: 'my second answer to deleted' })
+
+          await servers[2].comments.delete({ videoId: video4CreateResult.id, commentId: threadId })
+          await servers[2].comments.delete({ videoId: video4CreateResult.id, commentId: replyId })
+        }
+
+        await servers[2].captions.add({
+          language: 'ar',
+          videoId: video4CreateResult.id,
+          fixture: 'subtitle-good2.vtt'
+        })
+
+        await waitJobs(servers)
+
+        // Server 1 follows server 3
+        await servers[0].follows.follow({ hosts: [ servers[2].url ] })
+
+        await waitJobs(servers)
+      })
+
+      it('Should have the correct follows counts', async function () {
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 2 })
+        await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+        await expectChannelsFollows({ server: servers[0], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
+
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
+        await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+        await expectChannelsFollows({ server: servers[1], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
+      })
+
+      it('Should have propagated videos', async function () {
+        const { total, data } = await servers[0].videos.list()
+        expect(total).to.equal(7)
+
+        const video2 = data.find(v => v.name === 'server3-2')
+        video4 = data.find(v => v.name === 'server3-4')
+        const video6 = data.find(v => v.name === 'server3-6')
+
+        expect(video2).to.not.be.undefined
+        expect(video4).to.not.be.undefined
+        expect(video6).to.not.be.undefined
+
+        const isLocal = false
+        const checkAttributes = {
+          name: 'server3-4',
+          category: 2,
+          licence: 6,
+          language: 'zh',
+          nsfw: true,
+          description: 'my super description',
+          support: 'my super support text',
+          account: {
+            name: 'root',
+            host: servers[2].host
+          },
+          isLocal,
+          commentsEnabled: true,
+          downloadEnabled: true,
+          duration: 5,
+          tags: [ 'tag1', 'tag2', 'tag3' ],
+          privacy: VideoPrivacy.PUBLIC,
+          likes: 1,
+          dislikes: 1,
+          channel: {
+            displayName: 'Main root channel',
+            name: 'root_channel',
+            description: '',
+            isLocal
+          },
+          fixture: 'video_short.webm',
+          files: [
+            {
+              resolution: 720,
+              size: 218910
+            }
+          ]
+        }
+        await completeVideoCheck({
+          server: servers[0],
+          originServer: servers[2],
+          videoUUID: video4.uuid,
+          attributes: checkAttributes
+        })
+      })
+
+      it('Should have propagated comments', async function () {
+        const { total, data } = await servers[0].comments.listThreads({ videoId: video4.id, sort: 'createdAt' })
+
+        expect(total).to.equal(2)
+        expect(data).to.be.an('array')
+        expect(data).to.have.lengthOf(2)
+
+        {
+          const comment = data[0]
+          expect(comment.inReplyToCommentId).to.be.null
+          expect(comment.text).equal('my super first comment')
+          expect(comment.videoId).to.equal(video4.id)
+          expect(comment.id).to.equal(comment.threadId)
+          expect(comment.account.name).to.equal('root')
+          expect(comment.account.host).to.equal(servers[2].host)
+          expect(comment.totalReplies).to.equal(3)
+          expect(dateIsValid(comment.createdAt as string)).to.be.true
+          expect(dateIsValid(comment.updatedAt as string)).to.be.true
+
+          const threadId = comment.threadId
+
+          const tree = await servers[0].comments.getThread({ videoId: video4.id, threadId })
+          expect(tree.comment.text).equal('my super first comment')
+          expect(tree.children).to.have.lengthOf(2)
+
+          const firstChild = tree.children[0]
+          expect(firstChild.comment.text).to.equal('my super answer to thread 1')
+          expect(firstChild.children).to.have.lengthOf(1)
+
+          const childOfFirstChild = firstChild.children[0]
+          expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
+          expect(childOfFirstChild.children).to.have.lengthOf(0)
+
+          const secondChild = tree.children[1]
+          expect(secondChild.comment.text).to.equal('my second answer to thread 1')
+          expect(secondChild.children).to.have.lengthOf(0)
+        }
+
+        {
+          const deletedComment = data[1]
+          expect(deletedComment).to.not.be.undefined
+          expect(deletedComment.isDeleted).to.be.true
+          expect(deletedComment.deletedAt).to.not.be.null
+          expect(deletedComment.text).to.equal('')
+          expect(deletedComment.inReplyToCommentId).to.be.null
+          expect(deletedComment.account).to.be.null
+          expect(deletedComment.totalReplies).to.equal(2)
+          expect(dateIsValid(deletedComment.deletedAt as string)).to.be.true
+
+          const tree = await servers[0].comments.getThread({ videoId: video4.id, threadId: deletedComment.threadId })
+          const [ commentRoot, deletedChildRoot ] = tree.children
+
+          expect(deletedChildRoot).to.not.be.undefined
+          expect(deletedChildRoot.comment.isDeleted).to.be.true
+          expect(deletedChildRoot.comment.deletedAt).to.not.be.null
+          expect(deletedChildRoot.comment.text).to.equal('')
+          expect(deletedChildRoot.comment.inReplyToCommentId).to.equal(deletedComment.id)
+          expect(deletedChildRoot.comment.account).to.be.null
+          expect(deletedChildRoot.children).to.have.lengthOf(1)
+
+          const answerToDeletedChild = deletedChildRoot.children[0]
+          expect(answerToDeletedChild.comment).to.not.be.undefined
+          expect(answerToDeletedChild.comment.inReplyToCommentId).to.equal(deletedChildRoot.comment.id)
+          expect(answerToDeletedChild.comment.text).to.equal('my second answer to deleted')
+          expect(answerToDeletedChild.comment.account.name).to.equal('root')
+
+          expect(commentRoot.comment).to.not.be.undefined
+          expect(commentRoot.comment.inReplyToCommentId).to.equal(deletedComment.id)
+          expect(commentRoot.comment.text).to.equal('answer to deleted')
+          expect(commentRoot.comment.account.name).to.equal('root')
+        }
+      })
+
+      it('Should have propagated captions', async function () {
+        const body = await servers[0].captions.list({ videoId: video4.id })
+        expect(body.total).to.equal(1)
+        expect(body.data).to.have.lengthOf(1)
+
+        const caption1 = body.data[0]
+        expect(caption1.language.id).to.equal('ar')
+        expect(caption1.language.label).to.equal('Arabic')
+        expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/.+-ar.vtt$'))
+        await testCaptionFile(servers[0].url, caption1.captionPath, 'Subtitle good 2.')
+      })
+
+      it('Should unfollow server 3 on server 1 and does not list server 3 videos', async function () {
+        this.timeout(5000)
+
+        await servers[0].follows.unfollow({ target: servers[2] })
+
+        await waitJobs(servers)
+
+        const { total } = await servers[0].videos.list()
+        expect(total).to.equal(1)
+      })
+    })
+
+    after(async function () {
+      await cleanupTests(servers)
+    })
+  })
+
+  describe('Simple data propagation propagate data on a new channel follow', function () {
+    let servers: PeerTubeServer[] = []
+
+    before(async function () {
+      this.timeout(120000)
+
+      servers = await createMultipleServers(3)
+      await setAccessTokensToServers(servers)
+
+      await servers[0].videos.upload({ attributes: { name: 'video to add' } })
+
+      await waitJobs(servers)
+
+      for (const server of [ servers[1], servers[2] ]) {
+        const video = await server.videos.find({ name: 'video to add' })
+        expect(video).to.not.exist
+      }
+    })
+
+    it('Should have propagated video after new channel follow', async function () {
+      this.timeout(60000)
+
+      await servers[1].follows.follow({ handles: [ 'root_channel@' + servers[0].host ] })
+
+      await waitJobs(servers)
+
+      const video = await servers[1].videos.find({ name: 'video to add' })
+      expect(video).to.exist
+    })
+
+    it('Should have propagated video after new account follow', async function () {
+      this.timeout(60000)
+
+      await servers[2].follows.follow({ handles: [ 'root@' + servers[0].host ] })
+
+      await waitJobs(servers)
+
+      const video = await servers[2].videos.find({ name: 'video to add' })
+      expect(video).to.exist
+    })
+
+    after(async function () {
+      await cleanupTests(servers)
+    })
+  })
+})
diff --git a/packages/tests/src/api/server/handle-down.ts b/packages/tests/src/api/server/handle-down.ts
new file mode 100644
index 000000000..604df129f
--- /dev/null
+++ b/packages/tests/src/api/server/handle-down.ts
@@ -0,0 +1,339 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { HttpStatusCode, JobState, VideoCreateResult, VideoPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  CommentsCommand,
+  createMultipleServers,
+  killallServers,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+import { SQLCommand } from '@tests/shared/sql-command.js'
+import { completeVideoCheck } from '@tests/shared/videos.js'
+
+describe('Test handle downs', function () {
+  let servers: PeerTubeServer[] = []
+  let sqlCommands: SQLCommand[] = []
+
+  let threadIdServer1: number
+  let threadIdServer2: number
+  let commentIdServer1: number
+  let commentIdServer2: number
+  let missedVideo1: VideoCreateResult
+  let missedVideo2: VideoCreateResult
+  let unlistedVideo: VideoCreateResult
+
+  const videoIdsServer1: string[] = []
+
+  const videoAttributes = {
+    name: 'my super name for server 1',
+    category: 5,
+    licence: 4,
+    language: 'ja',
+    nsfw: true,
+    privacy: VideoPrivacy.PUBLIC,
+    description: 'my super description for server 1',
+    support: 'my super support text for server 1',
+    tags: [ 'tag1p1', 'tag2p1' ],
+    fixture: 'video_short1.webm'
+  }
+
+  const unlistedVideoAttributes = { ...videoAttributes, privacy: VideoPrivacy.UNLISTED }
+
+  let checkAttributes: any
+  let unlistedCheckAttributes: any
+
+  let commentCommands: CommentsCommand[]
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(3)
+    commentCommands = servers.map(s => s.comments)
+
+    checkAttributes = {
+      name: 'my super name for server 1',
+      category: 5,
+      licence: 4,
+      language: 'ja',
+      nsfw: true,
+      description: 'my super description for server 1',
+      support: 'my super support text for server 1',
+      account: {
+        name: 'root',
+        host: servers[0].host
+      },
+      isLocal: false,
+      duration: 10,
+      tags: [ 'tag1p1', 'tag2p1' ],
+      privacy: VideoPrivacy.PUBLIC,
+      commentsEnabled: true,
+      downloadEnabled: true,
+      channel: {
+        name: 'root_channel',
+        displayName: 'Main root channel',
+        description: '',
+        isLocal: false
+      },
+      fixture: 'video_short1.webm',
+      files: [
+        {
+          resolution: 720,
+          size: 572456
+        }
+      ]
+    }
+    unlistedCheckAttributes = { ...checkAttributes, privacy: VideoPrivacy.UNLISTED }
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    sqlCommands = servers.map(s => new SQLCommand(s))
+  })
+
+  it('Should remove followers that are often down', async function () {
+    this.timeout(240000)
+
+    // Server 2 and 3 follow server 1
+    await servers[1].follows.follow({ hosts: [ servers[0].url ] })
+    await servers[2].follows.follow({ hosts: [ servers[0].url ] })
+
+    await waitJobs(servers)
+
+    // Upload a video to server 1
+    await servers[0].videos.upload({ attributes: videoAttributes })
+
+    await waitJobs(servers)
+
+    // And check all servers have this video
+    for (const server of servers) {
+      const { data } = await server.videos.list()
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(1)
+    }
+
+    // Kill server 2
+    await killallServers([ servers[1] ])
+
+    // Remove server 2 follower
+    for (let i = 0; i < 10; i++) {
+      await servers[0].videos.upload({ attributes: videoAttributes })
+    }
+
+    await waitJobs([ servers[0], servers[2] ])
+
+    // Kill server 3
+    await killallServers([ servers[2] ])
+
+    missedVideo1 = await servers[0].videos.upload({ attributes: videoAttributes })
+
+    missedVideo2 = await servers[0].videos.upload({ attributes: videoAttributes })
+
+    // Unlisted video
+    unlistedVideo = await servers[0].videos.upload({ attributes: unlistedVideoAttributes })
+
+    // Add comments to video 2
+    {
+      const text = 'thread 1'
+      let comment = await commentCommands[0].createThread({ videoId: missedVideo2.uuid, text })
+      threadIdServer1 = comment.id
+
+      comment = await commentCommands[0].addReply({ videoId: missedVideo2.uuid, toCommentId: comment.id, text: 'comment 1-1' })
+
+      const created = await commentCommands[0].addReply({ videoId: missedVideo2.uuid, toCommentId: comment.id, text: 'comment 1-2' })
+      commentIdServer1 = created.id
+    }
+
+    await waitJobs(servers[0])
+    // Wait scheduler
+    await wait(11000)
+
+    // Only server 3 is still a follower of server 1
+    const body = await servers[0].follows.getFollowers({ start: 0, count: 2, sort: 'createdAt' })
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].follower.host).to.equal(servers[2].host)
+  })
+
+  it('Should not have pending/processing jobs anymore', async function () {
+    const states: JobState[] = [ 'waiting', 'active' ]
+
+    for (const state of states) {
+      const body = await servers[0].jobs.list({
+        state,
+        start: 0,
+        count: 50,
+        sort: '-createdAt'
+      })
+      expect(body.data).to.have.length(0)
+    }
+  })
+
+  it('Should re-follow server 1', async function () {
+    this.timeout(70000)
+
+    await servers[1].run()
+    await servers[2].run()
+
+    await servers[1].follows.unfollow({ target: servers[0] })
+    await waitJobs(servers)
+
+    await servers[1].follows.follow({ hosts: [ servers[0].url ] })
+
+    await waitJobs(servers)
+
+    const body = await servers[0].follows.getFollowers({ start: 0, count: 2, sort: 'createdAt' })
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(2)
+  })
+
+  it('Should send an update to server 3, and automatically fetch the video', async function () {
+    this.timeout(15000)
+
+    {
+      const { data } = await servers[2].videos.list()
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(11)
+    }
+
+    await servers[0].videos.update({ id: missedVideo1.uuid })
+    await servers[0].videos.update({ id: unlistedVideo.uuid })
+
+    await waitJobs(servers)
+
+    {
+      const { data } = await servers[2].videos.list()
+      expect(data).to.be.an('array')
+      // 1 video is unlisted
+      expect(data).to.have.lengthOf(12)
+    }
+
+    // Check unlisted video
+    const video = await servers[2].videos.get({ id: unlistedVideo.uuid })
+    await completeVideoCheck({ server: servers[2], originServer: servers[0], videoUUID: video.uuid, attributes: unlistedCheckAttributes })
+  })
+
+  it('Should send comments on a video to server 3, and automatically fetch the video', async function () {
+    this.timeout(25000)
+
+    await commentCommands[0].addReply({ videoId: missedVideo2.uuid, toCommentId: commentIdServer1, text: 'comment 1-3' })
+
+    await waitJobs(servers)
+
+    await servers[2].videos.get({ id: missedVideo2.uuid })
+
+    {
+      const { data } = await servers[2].comments.listThreads({ videoId: missedVideo2.uuid })
+      expect(data).to.be.an('array')
+      expect(data).to.have.lengthOf(1)
+
+      threadIdServer2 = data[0].id
+
+      const tree = await servers[2].comments.getThread({ videoId: missedVideo2.uuid, threadId: threadIdServer2 })
+      expect(tree.comment.text).equal('thread 1')
+      expect(tree.children).to.have.lengthOf(1)
+
+      const firstChild = tree.children[0]
+      expect(firstChild.comment.text).to.equal('comment 1-1')
+      expect(firstChild.children).to.have.lengthOf(1)
+
+      const childOfFirstChild = firstChild.children[0]
+      expect(childOfFirstChild.comment.text).to.equal('comment 1-2')
+      expect(childOfFirstChild.children).to.have.lengthOf(1)
+
+      const childOfChildFirstChild = childOfFirstChild.children[0]
+      expect(childOfChildFirstChild.comment.text).to.equal('comment 1-3')
+      expect(childOfChildFirstChild.children).to.have.lengthOf(0)
+
+      commentIdServer2 = childOfChildFirstChild.comment.id
+    }
+  })
+
+  it('Should correctly reply to the comment', async function () {
+    this.timeout(15000)
+
+    await servers[2].comments.addReply({ videoId: missedVideo2.uuid, toCommentId: commentIdServer2, text: 'comment 1-4' })
+
+    await waitJobs(servers)
+
+    const tree = await commentCommands[0].getThread({ videoId: missedVideo2.uuid, threadId: threadIdServer1 })
+
+    expect(tree.comment.text).equal('thread 1')
+    expect(tree.children).to.have.lengthOf(1)
+
+    const firstChild = tree.children[0]
+    expect(firstChild.comment.text).to.equal('comment 1-1')
+    expect(firstChild.children).to.have.lengthOf(1)
+
+    const childOfFirstChild = firstChild.children[0]
+    expect(childOfFirstChild.comment.text).to.equal('comment 1-2')
+    expect(childOfFirstChild.children).to.have.lengthOf(1)
+
+    const childOfChildFirstChild = childOfFirstChild.children[0]
+    expect(childOfChildFirstChild.comment.text).to.equal('comment 1-3')
+    expect(childOfChildFirstChild.children).to.have.lengthOf(1)
+
+    const childOfChildOfChildOfFirstChild = childOfChildFirstChild.children[0]
+    expect(childOfChildOfChildOfFirstChild.comment.text).to.equal('comment 1-4')
+    expect(childOfChildOfChildOfFirstChild.children).to.have.lengthOf(0)
+  })
+
+  it('Should upload many videos on server 1', async function () {
+    this.timeout(240000)
+
+    for (let i = 0; i < 10; i++) {
+      const uuid = (await servers[0].videos.quickUpload({ name: 'video ' + i })).uuid
+      videoIdsServer1.push(uuid)
+    }
+
+    await waitJobs(servers)
+
+    for (const id of videoIdsServer1) {
+      await servers[1].videos.get({ id })
+    }
+
+    await waitJobs(servers)
+    await sqlCommands[1].setActorFollowScores(20)
+
+    // Wait video expiration
+    await wait(11000)
+
+    // Refresh video -> score + 10 = 30
+    await servers[1].videos.get({ id: videoIdsServer1[0] })
+
+    await waitJobs(servers)
+  })
+
+  it('Should remove followings that are down', async function () {
+    this.timeout(120000)
+
+    await killallServers([ servers[0] ])
+
+    // Wait video expiration
+    await wait(11000)
+
+    for (let i = 0; i < 5; i++) {
+      try {
+        await servers[1].videos.get({ id: videoIdsServer1[i] })
+        await waitJobs([ servers[1] ])
+        await wait(1500)
+      } catch {}
+    }
+
+    for (const id of videoIdsServer1) {
+      await servers[1].videos.get({ id, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+    }
+  })
+
+  after(async function () {
+    for (const sqlCommand of sqlCommands) {
+      await sqlCommand.cleanup()
+    }
+
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/server/homepage.ts b/packages/tests/src/api/server/homepage.ts
new file mode 100644
index 000000000..082a2fb91
--- /dev/null
+++ b/packages/tests/src/api/server/homepage.ts
@@ -0,0 +1,81 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { HttpStatusCode } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  CustomPagesCommand,
+  killallServers,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar
+} from '@peertube/peertube-server-commands'
+
+async function getHomepageState (server: PeerTubeServer) {
+  const config = await server.config.getConfig()
+
+  return config.homepage.enabled
+}
+
+describe('Test instance homepage actions', function () {
+  let server: PeerTubeServer
+  let command: CustomPagesCommand
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1)
+    await setAccessTokensToServers([ server ])
+    await setDefaultChannelAvatar(server)
+    await setDefaultAccountAvatar(server)
+
+    command = server.customPage
+  })
+
+  it('Should not have a homepage', async function () {
+    const state = await getHomepageState(server)
+    expect(state).to.be.false
+
+    await command.getInstanceHomepage({ expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+  })
+
+  it('Should set a homepage', async function () {
+    await command.updateInstanceHomepage({ content: '<picsou-magazine></picsou-magazine>' })
+
+    const page = await command.getInstanceHomepage()
+    expect(page.content).to.equal('<picsou-magazine></picsou-magazine>')
+
+    const state = await getHomepageState(server)
+    expect(state).to.be.true
+  })
+
+  it('Should have the same homepage after a restart', async function () {
+    this.timeout(30000)
+
+    await killallServers([ server ])
+
+    await server.run()
+
+    const page = await command.getInstanceHomepage()
+    expect(page.content).to.equal('<picsou-magazine></picsou-magazine>')
+
+    const state = await getHomepageState(server)
+    expect(state).to.be.true
+  })
+
+  it('Should empty the homepage', async function () {
+    await command.updateInstanceHomepage({ content: '' })
+
+    const page = await command.getInstanceHomepage()
+    expect(page.content).to.be.empty
+
+    const state = await getHomepageState(server)
+    expect(state).to.be.false
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/index.ts b/packages/tests/src/api/server/index.ts
new file mode 100644
index 000000000..5c80a5a37
--- /dev/null
+++ b/packages/tests/src/api/server/index.ts
@@ -0,0 +1,22 @@
+import './auto-follows.js'
+import './bulk.js'
+import './config-defaults.js'
+import './config.js'
+import './contact-form.js'
+import './email.js'
+import './follow-constraints.js'
+import './follows.js'
+import './follows-moderation.js'
+import './homepage.js'
+import './handle-down.js'
+import './jobs.js'
+import './logs.js'
+import './reverse-proxy.js'
+import './services.js'
+import './slow-follows.js'
+import './stats.js'
+import './tracker.js'
+import './no-client.js'
+import './open-telemetry.js'
+import './plugins.js'
+import './proxy.js'
diff --git a/packages/tests/src/api/server/jobs.ts b/packages/tests/src/api/server/jobs.ts
new file mode 100644
index 000000000..3d60b1431
--- /dev/null
+++ b/packages/tests/src/api/server/jobs.ts
@@ -0,0 +1,128 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { dateIsValid } from '@tests/shared/checks.js'
+import { wait } from '@peertube/peertube-core-utils'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Test jobs', function () {
+  let servers: PeerTubeServer[]
+
+  before(async function () {
+    this.timeout(240000)
+
+    servers = await createMultipleServers(2)
+
+    await setAccessTokensToServers(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  it('Should create some jobs', async function () {
+    this.timeout(240000)
+
+    await servers[1].videos.upload({ attributes: { name: 'video1' } })
+    await servers[1].videos.upload({ attributes: { name: 'video2' } })
+
+    await waitJobs(servers)
+  })
+
+  it('Should list jobs', async function () {
+    const body = await servers[1].jobs.list({ state: 'completed' })
+    expect(body.total).to.be.above(2)
+    expect(body.data).to.have.length.above(2)
+  })
+
+  it('Should list jobs with sort, pagination and job type', async function () {
+    {
+      const body = await servers[1].jobs.list({
+        state: 'completed',
+        start: 1,
+        count: 2,
+        sort: 'createdAt'
+      })
+      expect(body.total).to.be.above(2)
+      expect(body.data).to.have.lengthOf(2)
+
+      let job = body.data[0]
+      // Skip repeat jobs
+      if (job.type === 'videos-views-stats') job = body.data[1]
+
+      expect(job.state).to.equal('completed')
+      expect(dateIsValid(job.createdAt as string)).to.be.true
+      expect(dateIsValid(job.processedOn as string)).to.be.true
+      expect(dateIsValid(job.finishedOn as string)).to.be.true
+    }
+
+    {
+      const body = await servers[1].jobs.list({
+        state: 'completed',
+        start: 0,
+        count: 100,
+        sort: 'createdAt',
+        jobType: 'activitypub-http-broadcast'
+      })
+      expect(body.total).to.be.above(2)
+
+      for (const j of body.data) {
+        expect(j.type).to.equal('activitypub-http-broadcast')
+      }
+    }
+  })
+
+  it('Should list all jobs', async function () {
+    const body = await servers[1].jobs.list()
+    expect(body.total).to.be.above(2)
+
+    const jobs = body.data
+    expect(jobs).to.have.length.above(2)
+
+    expect(jobs.find(j => j.state === 'completed')).to.not.be.undefined
+  })
+
+  it('Should pause the job queue', async function () {
+    this.timeout(120000)
+
+    const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video2' } })
+    await waitJobs(servers)
+
+    await servers[1].jobs.pauseJobQueue()
+    await servers[1].videos.runTranscoding({ videoId: uuid, transcodingType: 'hls' })
+
+    await wait(5000)
+
+    {
+      const body = await servers[1].jobs.list({ state: 'waiting', jobType: 'video-transcoding' })
+      // waiting includes waiting-children
+      expect(body.data).to.have.lengthOf(4)
+    }
+
+    {
+      const body = await servers[1].jobs.list({ state: 'waiting-children', jobType: 'video-transcoding' })
+      expect(body.data).to.have.lengthOf(1)
+    }
+  })
+
+  it('Should resume the job queue', async function () {
+    this.timeout(120000)
+
+    await servers[1].jobs.resumeJobQueue()
+
+    await waitJobs(servers)
+
+    const body = await servers[1].jobs.list({ state: 'waiting', jobType: 'video-transcoding' })
+    expect(body.data).to.have.lengthOf(0)
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/server/logs.ts b/packages/tests/src/api/server/logs.ts
new file mode 100644
index 000000000..11c86d694
--- /dev/null
+++ b/packages/tests/src/api/server/logs.ts
@@ -0,0 +1,265 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { HttpStatusCode } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  killallServers,
+  LogsCommand,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Test logs', function () {
+  let server: PeerTubeServer
+  let logsCommand: LogsCommand
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1)
+    await setAccessTokensToServers([ server ])
+
+    logsCommand = server.logs
+  })
+
+  describe('With the standard log file', function () {
+
+    it('Should get logs with a start date', async function () {
+      this.timeout(60000)
+
+      await server.videos.upload({ attributes: { name: 'video 1' } })
+      await waitJobs([ server ])
+
+      const now = new Date()
+
+      await server.videos.upload({ attributes: { name: 'video 2' } })
+      await waitJobs([ server ])
+
+      const body = await logsCommand.getLogs({ startDate: now })
+      const logsString = JSON.stringify(body)
+
+      expect(logsString.includes('Video with name video 1')).to.be.false
+      expect(logsString.includes('Video with name video 2')).to.be.true
+    })
+
+    it('Should get logs with an end date', async function () {
+      this.timeout(60000)
+
+      await server.videos.upload({ attributes: { name: 'video 3' } })
+      await waitJobs([ server ])
+
+      const now1 = new Date()
+
+      await server.videos.upload({ attributes: { name: 'video 4' } })
+      await waitJobs([ server ])
+
+      const now2 = new Date()
+
+      await server.videos.upload({ attributes: { name: 'video 5' } })
+      await waitJobs([ server ])
+
+      const body = await logsCommand.getLogs({ startDate: now1, endDate: now2 })
+      const logsString = JSON.stringify(body)
+
+      expect(logsString.includes('Video with name video 3')).to.be.false
+      expect(logsString.includes('Video with name video 4')).to.be.true
+      expect(logsString.includes('Video with name video 5')).to.be.false
+    })
+
+    it('Should filter by level', async function () {
+      this.timeout(60000)
+
+      const now = new Date()
+
+      await server.videos.upload({ attributes: { name: 'video 6' } })
+      await waitJobs([ server ])
+
+      {
+        const body = await logsCommand.getLogs({ startDate: now, level: 'info' })
+        const logsString = JSON.stringify(body)
+
+        expect(logsString.includes('Video with name video 6')).to.be.true
+      }
+
+      {
+        const body = await logsCommand.getLogs({ startDate: now, level: 'warn' })
+        const logsString = JSON.stringify(body)
+
+        expect(logsString.includes('Video with name video 6')).to.be.false
+      }
+    })
+
+    it('Should filter by tag', async function () {
+      const now = new Date()
+
+      const { uuid } = await server.videos.upload({ attributes: { name: 'video 6' } })
+      await waitJobs([ server ])
+
+      {
+        const body = await logsCommand.getLogs({ startDate: now, level: 'debug', tagsOneOf: [ 'toto' ] })
+        expect(body).to.have.lengthOf(0)
+      }
+
+      {
+        const body = await logsCommand.getLogs({ startDate: now, level: 'debug', tagsOneOf: [ uuid ] })
+        expect(body).to.not.have.lengthOf(0)
+
+        for (const line of body) {
+          expect(line.tags).to.contain(uuid)
+        }
+      }
+    })
+
+    it('Should log ping requests', async function () {
+      const now = new Date()
+
+      await server.servers.ping()
+
+      const body = await logsCommand.getLogs({ startDate: now, level: 'info' })
+      const logsString = JSON.stringify(body)
+
+      expect(logsString.includes('/api/v1/ping')).to.be.true
+    })
+
+    it('Should not log ping requests', async function () {
+      this.timeout(60000)
+
+      await killallServers([ server ])
+
+      await server.run({ log: { log_ping_requests: false } })
+
+      const now = new Date()
+
+      await server.servers.ping()
+
+      const body = await logsCommand.getLogs({ startDate: now, level: 'info' })
+      const logsString = JSON.stringify(body)
+
+      expect(logsString.includes('/api/v1/ping')).to.be.false
+    })
+  })
+
+  describe('With the audit log', function () {
+
+    it('Should get logs with a start date', async function () {
+      this.timeout(60000)
+
+      await server.videos.upload({ attributes: { name: 'video 7' } })
+      await waitJobs([ server ])
+
+      const now = new Date()
+
+      await server.videos.upload({ attributes: { name: 'video 8' } })
+      await waitJobs([ server ])
+
+      const body = await logsCommand.getAuditLogs({ startDate: now })
+      const logsString = JSON.stringify(body)
+
+      expect(logsString.includes('video 7')).to.be.false
+      expect(logsString.includes('video 8')).to.be.true
+
+      expect(body).to.have.lengthOf(1)
+
+      const item = body[0]
+
+      const message = JSON.parse(item.message)
+      expect(message.domain).to.equal('videos')
+      expect(message.action).to.equal('create')
+    })
+
+    it('Should get logs with an end date', async function () {
+      this.timeout(60000)
+
+      await server.videos.upload({ attributes: { name: 'video 9' } })
+      await waitJobs([ server ])
+
+      const now1 = new Date()
+
+      await server.videos.upload({ attributes: { name: 'video 10' } })
+      await waitJobs([ server ])
+
+      const now2 = new Date()
+
+      await server.videos.upload({ attributes: { name: 'video 11' } })
+      await waitJobs([ server ])
+
+      const body = await logsCommand.getAuditLogs({ startDate: now1, endDate: now2 })
+      const logsString = JSON.stringify(body)
+
+      expect(logsString.includes('video 9')).to.be.false
+      expect(logsString.includes('video 10')).to.be.true
+      expect(logsString.includes('video 11')).to.be.false
+    })
+  })
+
+  describe('When creating log from the client', function () {
+
+    it('Should create a warn client log', async function () {
+      const now = new Date()
+
+      await server.logs.createLogClient({
+        payload: {
+          level: 'warn',
+          url: 'http://example.com',
+          message: 'my super client message'
+        },
+        token: null
+      })
+
+      const body = await logsCommand.getLogs({ startDate: now })
+      const logsString = JSON.stringify(body)
+
+      expect(logsString.includes('my super client message')).to.be.true
+    })
+
+    it('Should create an error authenticated client log', async function () {
+      const now = new Date()
+
+      await server.logs.createLogClient({
+        payload: {
+          url: 'https://example.com/page1',
+          level: 'error',
+          message: 'my super client message 2',
+          userAgent: 'super user agent',
+          meta: '{hello}',
+          stackTrace: 'super stack trace'
+        }
+      })
+
+      const body = await logsCommand.getLogs({ startDate: now })
+      const logsString = JSON.stringify(body)
+
+      expect(logsString.includes('my super client message 2')).to.be.true
+      expect(logsString.includes('super user agent')).to.be.true
+      expect(logsString.includes('super stack trace')).to.be.true
+      expect(logsString.includes('{hello}')).to.be.true
+      expect(logsString.includes('https://example.com/page1')).to.be.true
+    })
+
+    it('Should refuse to create client logs', async function () {
+      await server.kill()
+
+      await server.run({
+        log: {
+          accept_client_log: false
+        }
+      })
+
+      await server.logs.createLogClient({
+        payload: {
+          level: 'warn',
+          url: 'http://example.com',
+          message: 'my super client message'
+        },
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/no-client.ts b/packages/tests/src/api/server/no-client.ts
new file mode 100644
index 000000000..0f097d50b
--- /dev/null
+++ b/packages/tests/src/api/server/no-client.ts
@@ -0,0 +1,24 @@
+import request from 'supertest'
+import { HttpStatusCode } from '@peertube/peertube-models'
+import { cleanupTests, createSingleServer, PeerTubeServer } from '@peertube/peertube-server-commands'
+
+describe('Start and stop server without web client routes', function () {
+  let server: PeerTubeServer
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1, {}, { peertubeArgs: [ '--no-client' ] })
+  })
+
+  it('Should fail getting the client', function () {
+    const req = request(server.url)
+      .get('/')
+
+    return req.expect(HttpStatusCode.NOT_FOUND_404)
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/open-telemetry.ts b/packages/tests/src/api/server/open-telemetry.ts
new file mode 100644
index 000000000..8ed3801db
--- /dev/null
+++ b/packages/tests/src/api/server/open-telemetry.ts
@@ -0,0 +1,193 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { HttpStatusCode, PlaybackMetricCreate, VideoPrivacy, VideoResolution } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  makeRawRequest,
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@peertube/peertube-server-commands'
+import { expectLogDoesNotContain, expectLogContain } from '@tests/shared/checks.js'
+import { MockHTTP } from '@tests/shared/mock-servers/mock-http.js'
+
+describe('Open Telemetry', function () {
+  let server: PeerTubeServer
+
+  describe('Metrics', function () {
+    const metricsUrl = 'http://127.0.0.1:9092/metrics'
+
+    it('Should not enable open telemetry metrics', async function () {
+      this.timeout(60000)
+
+      server = await createSingleServer(1)
+
+      let hasError = false
+      try {
+        await makeRawRequest({ url: metricsUrl, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+      } catch (err) {
+        hasError = err.message.includes('ECONNREFUSED')
+      }
+
+      expect(hasError).to.be.true
+
+      await server.kill()
+    })
+
+    it('Should enable open telemetry metrics', async function () {
+      this.timeout(120000)
+
+      await server.run({
+        open_telemetry: {
+          metrics: {
+            enabled: true
+          }
+        }
+      })
+
+      // Simulate a HTTP request
+      await server.videos.list()
+
+      const res = await makeRawRequest({ url: metricsUrl, expectedStatus: HttpStatusCode.OK_200 })
+      expect(res.text).to.contain('peertube_job_queue_total{')
+      expect(res.text).to.contain('http_request_duration_ms_bucket{')
+    })
+
+    it('Should have playback metrics', async function () {
+      await setAccessTokensToServers([ server ])
+
+      const video = await server.videos.quickUpload({ name: 'video' })
+
+      await server.metrics.addPlaybackMetric({
+        metrics: {
+          playerMode: 'p2p-media-loader',
+          resolution: VideoResolution.H_1080P,
+          fps: 30,
+          resolutionChanges: 1,
+          errors: 2,
+          downloadedBytesP2P: 0,
+          downloadedBytesHTTP: 0,
+          uploadedBytesP2P: 5,
+          p2pPeers: 1,
+          p2pEnabled: false,
+          videoId: video.uuid
+        }
+      })
+
+      const res = await makeRawRequest({ url: metricsUrl, expectedStatus: HttpStatusCode.OK_200 })
+
+      expect(res.text).to.contain('peertube_playback_http_downloaded_bytes_total{')
+      expect(res.text).to.contain('peertube_playback_p2p_peers{')
+      expect(res.text).to.contain('p2pEnabled="false"')
+    })
+
+    it('Should take the last playback metric', async function () {
+      await setAccessTokensToServers([ server ])
+
+      const video = await server.videos.quickUpload({ name: 'video' })
+
+      const metrics = {
+        playerMode: 'p2p-media-loader',
+        resolution: VideoResolution.H_1080P,
+        fps: 30,
+        resolutionChanges: 1,
+        errors: 2,
+        downloadedBytesP2P: 0,
+        downloadedBytesHTTP: 0,
+        uploadedBytesP2P: 5,
+        p2pPeers: 7,
+        p2pEnabled: false,
+        videoId: video.uuid
+      } as PlaybackMetricCreate
+
+      await server.metrics.addPlaybackMetric({ metrics })
+
+      metrics.p2pPeers = 42
+      await server.metrics.addPlaybackMetric({ metrics })
+
+      const res = await makeRawRequest({ url: metricsUrl, expectedStatus: HttpStatusCode.OK_200 })
+
+      // eslint-disable-next-line max-len
+      const label = `{videoOrigin="local",playerMode="p2p-media-loader",resolution="1080",fps="30",p2pEnabled="false",videoUUID="${video.uuid}"}`
+      expect(res.text).to.contain(`peertube_playback_p2p_peers${label} 42`)
+      expect(res.text).to.not.contain(`peertube_playback_p2p_peers${label} 7`)
+    })
+
+    it('Should disable http request duration metrics', async function () {
+      await server.kill()
+
+      await server.run({
+        open_telemetry: {
+          metrics: {
+            enabled: true,
+            http_request_duration: {
+              enabled: false
+            }
+          }
+        }
+      })
+
+      // Simulate a HTTP request
+      await server.videos.list()
+
+      const res = await makeRawRequest({ url: metricsUrl, expectedStatus: HttpStatusCode.OK_200 })
+      expect(res.text).to.not.contain('http_request_duration_ms_bucket{')
+    })
+
+    after(async function () {
+      await server.kill()
+    })
+  })
+
+  describe('Tracing', function () {
+    let mockHTTP: MockHTTP
+    let mockPort: number
+
+    before(async function () {
+      mockHTTP = new MockHTTP()
+      mockPort = await mockHTTP.initialize()
+    })
+
+    it('Should enable open telemetry tracing', async function () {
+      server = await createSingleServer(1)
+
+      await expectLogDoesNotContain(server, 'Registering Open Telemetry tracing')
+
+      await server.kill()
+    })
+
+    it('Should enable open telemetry metrics', async function () {
+      await server.run({
+        open_telemetry: {
+          tracing: {
+            enabled: true,
+            jaeger_exporter: {
+              endpoint: 'http://127.0.0.1:' + mockPort
+            }
+          }
+        }
+      })
+
+      await expectLogContain(server, 'Registering Open Telemetry tracing')
+    })
+
+    it('Should upload a video and correctly works', async function () {
+      await setAccessTokensToServers([ server ])
+
+      const { uuid } = await server.videos.quickUpload({ name: 'video', privacy: VideoPrivacy.PUBLIC })
+
+      const video = await server.videos.get({ id: uuid })
+
+      expect(video.name).to.equal('video')
+    })
+
+    after(async function () {
+      await mockHTTP.terminate()
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/plugins.ts b/packages/tests/src/api/server/plugins.ts
new file mode 100644
index 000000000..a78cea025
--- /dev/null
+++ b/packages/tests/src/api/server/plugins.ts
@@ -0,0 +1,410 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { pathExists, remove } from 'fs-extra/esm'
+import { join } from 'path'
+import { wait } from '@peertube/peertube-core-utils'
+import { HttpStatusCode, PluginType } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  killallServers,
+  makeGetRequest,
+  PeerTubeServer,
+  PluginsCommand,
+  setAccessTokensToServers
+} from '@peertube/peertube-server-commands'
+import { SQLCommand } from '@tests/shared/sql-command.js'
+import { testHelloWorldRegisteredSettings } from '@tests/shared/plugins.js'
+
+describe('Test plugins', function () {
+  let server: PeerTubeServer
+  let sqlCommand: SQLCommand
+  let command: PluginsCommand
+
+  before(async function () {
+    this.timeout(30000)
+
+    const configOverride = {
+      plugins: {
+        index: { check_latest_versions_interval: '5 seconds' }
+      }
+    }
+    server = await createSingleServer(1, configOverride)
+    await setAccessTokensToServers([ server ])
+
+    command = server.plugins
+
+    sqlCommand = new SQLCommand(server)
+  })
+
+  it('Should list and search available plugins and themes', async function () {
+    this.timeout(30000)
+
+    {
+      const body = await command.listAvailable({
+        count: 1,
+        start: 0,
+        pluginType: PluginType.THEME,
+        search: 'background-red'
+      })
+
+      expect(body.total).to.be.at.least(1)
+      expect(body.data).to.have.lengthOf(1)
+    }
+
+    {
+      const body1 = await command.listAvailable({
+        count: 2,
+        start: 0,
+        sort: 'npmName'
+      })
+      expect(body1.total).to.be.at.least(2)
+
+      const data1 = body1.data
+      expect(data1).to.have.lengthOf(2)
+
+      const body2 = await command.listAvailable({
+        count: 2,
+        start: 0,
+        sort: '-npmName'
+      })
+      expect(body2.total).to.be.at.least(2)
+
+      const data2 = body2.data
+      expect(data2).to.have.lengthOf(2)
+
+      expect(data1[0].npmName).to.not.equal(data2[0].npmName)
+    }
+
+    {
+      const body = await command.listAvailable({
+        count: 10,
+        start: 0,
+        pluginType: PluginType.THEME,
+        search: 'background-red',
+        currentPeerTubeEngine: '1.0.0'
+      })
+
+      const p = body.data.find(p => p.npmName === 'peertube-theme-background-red')
+      expect(p).to.be.undefined
+    }
+  })
+
+  it('Should install a plugin and a theme', async function () {
+    this.timeout(30000)
+
+    await command.install({ npmName: 'peertube-plugin-hello-world' })
+    await command.install({ npmName: 'peertube-theme-background-red' })
+  })
+
+  it('Should have the plugin loaded in the configuration', async function () {
+    for (const config of [ await server.config.getConfig(), await server.config.getIndexHTMLConfig() ]) {
+      const theme = config.theme.registered.find(r => r.name === 'background-red')
+      expect(theme).to.not.be.undefined
+      expect(theme.npmName).to.equal('peertube-theme-background-red')
+
+      const plugin = config.plugin.registered.find(r => r.name === 'hello-world')
+      expect(plugin).to.not.be.undefined
+      expect(plugin.npmName).to.equal('peertube-plugin-hello-world')
+    }
+  })
+
+  it('Should update the default theme in the configuration', async function () {
+    await server.config.updateCustomSubConfig({
+      newConfig: {
+        theme: { default: 'background-red' }
+      }
+    })
+
+    for (const config of [ await server.config.getConfig(), await server.config.getIndexHTMLConfig() ]) {
+      expect(config.theme.default).to.equal('background-red')
+    }
+  })
+
+  it('Should update my default theme', async function () {
+    await server.users.updateMe({ theme: 'background-red' })
+
+    const user = await server.users.getMyInfo()
+    expect(user.theme).to.equal('background-red')
+  })
+
+  it('Should list plugins and themes', async function () {
+    {
+      const body = await command.list({
+        count: 1,
+        start: 0,
+        pluginType: PluginType.THEME
+      })
+      expect(body.total).to.be.at.least(1)
+
+      const data = body.data
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].name).to.equal('background-red')
+    }
+
+    {
+      const { data } = await command.list({
+        count: 2,
+        start: 0,
+        sort: 'name'
+      })
+
+      expect(data[0].name).to.equal('background-red')
+      expect(data[1].name).to.equal('hello-world')
+    }
+
+    {
+      const body = await command.list({
+        count: 2,
+        start: 1,
+        sort: 'name'
+      })
+
+      expect(body.data[0].name).to.equal('hello-world')
+    }
+  })
+
+  it('Should get registered settings', async function () {
+    await testHelloWorldRegisteredSettings(server)
+  })
+
+  it('Should get public settings', async function () {
+    const body = await command.getPublicSettings({ npmName: 'peertube-plugin-hello-world' })
+    const publicSettings = body.publicSettings
+
+    expect(Object.keys(publicSettings)).to.have.lengthOf(1)
+    expect(Object.keys(publicSettings)).to.deep.equal([ 'user-name' ])
+    expect(publicSettings['user-name']).to.be.null
+  })
+
+  it('Should update the settings', async function () {
+    const settings = {
+      'admin-name': 'Cid'
+    }
+
+    await command.updateSettings({
+      npmName: 'peertube-plugin-hello-world',
+      settings
+    })
+  })
+
+  it('Should have watched settings changes', async function () {
+    await server.servers.waitUntilLog('Settings changed!')
+  })
+
+  it('Should get a plugin and a theme', async function () {
+    {
+      const plugin = await command.get({ npmName: 'peertube-plugin-hello-world' })
+
+      expect(plugin.type).to.equal(PluginType.PLUGIN)
+      expect(plugin.name).to.equal('hello-world')
+      expect(plugin.description).to.exist
+      expect(plugin.homepage).to.exist
+      expect(plugin.uninstalled).to.be.false
+      expect(plugin.enabled).to.be.true
+      expect(plugin.description).to.exist
+      expect(plugin.version).to.exist
+      expect(plugin.peertubeEngine).to.exist
+      expect(plugin.createdAt).to.exist
+
+      expect(plugin.settings).to.not.be.undefined
+      expect(plugin.settings['admin-name']).to.equal('Cid')
+    }
+
+    {
+      const plugin = await command.get({ npmName: 'peertube-theme-background-red' })
+
+      expect(plugin.type).to.equal(PluginType.THEME)
+      expect(plugin.name).to.equal('background-red')
+      expect(plugin.description).to.exist
+      expect(plugin.homepage).to.exist
+      expect(plugin.uninstalled).to.be.false
+      expect(plugin.enabled).to.be.true
+      expect(plugin.description).to.exist
+      expect(plugin.version).to.exist
+      expect(plugin.peertubeEngine).to.exist
+      expect(plugin.createdAt).to.exist
+
+      expect(plugin.settings).to.be.null
+    }
+  })
+
+  it('Should update the plugin and the theme', async function () {
+    this.timeout(180000)
+
+    // Wait the scheduler that get the latest plugins versions
+    await wait(6000)
+
+    async function testUpdate (type: 'plugin' | 'theme', name: string) {
+      // Fake update our plugin version
+      await sqlCommand.setPluginVersion(name, '0.0.1')
+
+      // Fake update package.json
+      const packageJSON = await command.getPackageJSON(`peertube-${type}-${name}`)
+      const oldVersion = packageJSON.version
+
+      packageJSON.version = '0.0.1'
+      await command.updatePackageJSON(`peertube-${type}-${name}`, packageJSON)
+
+      // Restart the server to take into account this change
+      await killallServers([ server ])
+      await server.run()
+
+      const checkConfig = async (version: string) => {
+        for (const config of [ await server.config.getConfig(), await server.config.getIndexHTMLConfig() ]) {
+          expect(config[type].registered.find(r => r.name === name).version).to.equal(version)
+        }
+      }
+
+      const getPluginFromAPI = async () => {
+        const body = await command.list({ pluginType: type === 'plugin' ? PluginType.PLUGIN : PluginType.THEME })
+
+        return body.data.find(p => p.name === name)
+      }
+
+      {
+        const plugin = await getPluginFromAPI()
+        expect(plugin.version).to.equal('0.0.1')
+        expect(plugin.latestVersion).to.exist
+        expect(plugin.latestVersion).to.not.equal('0.0.1')
+
+        await checkConfig('0.0.1')
+      }
+
+      {
+        await command.update({ npmName: `peertube-${type}-${name}` })
+
+        const plugin = await getPluginFromAPI()
+        expect(plugin.version).to.equal(oldVersion)
+
+        const updatedPackageJSON = await command.getPackageJSON(`peertube-${type}-${name}`)
+        expect(updatedPackageJSON.version).to.equal(oldVersion)
+
+        await checkConfig(oldVersion)
+      }
+    }
+
+    await testUpdate('theme', 'background-red')
+    await testUpdate('plugin', 'hello-world')
+  })
+
+  it('Should uninstall the plugin', async function () {
+    await command.uninstall({ npmName: 'peertube-plugin-hello-world' })
+
+    const body = await command.list({ pluginType: PluginType.PLUGIN })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
+  })
+
+  it('Should list uninstalled plugins', async function () {
+    const body = await command.list({ pluginType: PluginType.PLUGIN, uninstalled: true })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.have.lengthOf(1)
+
+    const plugin = body.data[0]
+    expect(plugin.name).to.equal('hello-world')
+    expect(plugin.enabled).to.be.false
+    expect(plugin.uninstalled).to.be.true
+  })
+
+  it('Should uninstall the theme', async function () {
+    await command.uninstall({ npmName: 'peertube-theme-background-red' })
+  })
+
+  it('Should have updated the configuration', async function () {
+    for (const config of [ await server.config.getConfig(), await server.config.getIndexHTMLConfig() ]) {
+      expect(config.theme.default).to.equal('default')
+
+      const theme = config.theme.registered.find(r => r.name === 'background-red')
+      expect(theme).to.be.undefined
+
+      const plugin = config.plugin.registered.find(r => r.name === 'hello-world')
+      expect(plugin).to.be.undefined
+    }
+  })
+
+  it('Should have updated the user theme', async function () {
+    const user = await server.users.getMyInfo()
+    expect(user.theme).to.equal('instance-default')
+  })
+
+  it('Should not install a broken plugin', async function () {
+    this.timeout(60000)
+
+    async function check () {
+      const body = await command.list({ pluginType: PluginType.PLUGIN })
+      const plugins = body.data
+      expect(plugins.find(p => p.name === 'test-broken')).to.not.exist
+    }
+
+    await command.install({
+      path: PluginsCommand.getPluginTestPath('-broken'),
+      expectedStatus: HttpStatusCode.BAD_REQUEST_400
+    })
+
+    await check()
+
+    await killallServers([ server ])
+    await server.run()
+
+    await check()
+  })
+
+  it('Should rebuild native modules on Node ABI change', async function () {
+    this.timeout(60000)
+
+    const removeNativeModule = async () => {
+      await remove(join(baseNativeModule, 'build'))
+      await remove(join(baseNativeModule, 'prebuilds'))
+    }
+
+    await command.install({ path: PluginsCommand.getPluginTestPath('-native') })
+
+    await makeGetRequest({
+      url: server.url,
+      path: '/plugins/test-native/router',
+      expectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+
+    const query = `UPDATE "application" SET "nodeABIVersion" = 1`
+    await sqlCommand.updateQuery(query)
+
+    const baseNativeModule = server.servers.buildDirectory(join('plugins', 'node_modules', 'a-native-example'))
+
+    await removeNativeModule()
+    await server.kill()
+    await server.run()
+
+    await wait(3000)
+
+    expect(await pathExists(join(baseNativeModule, 'build'))).to.be.true
+    expect(await pathExists(join(baseNativeModule, 'prebuilds'))).to.be.true
+
+    await makeGetRequest({
+      url: server.url,
+      path: '/plugins/test-native/router',
+      expectedStatus: HttpStatusCode.NO_CONTENT_204
+    })
+
+    await removeNativeModule()
+
+    await server.kill()
+    await server.run()
+
+    expect(await pathExists(join(baseNativeModule, 'build'))).to.be.false
+    expect(await pathExists(join(baseNativeModule, 'prebuilds'))).to.be.false
+
+    await makeGetRequest({
+      url: server.url,
+      path: '/plugins/test-native/router',
+      expectedStatus: HttpStatusCode.NOT_FOUND_404
+    })
+  })
+
+  after(async function () {
+    await sqlCommand.cleanup()
+
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/proxy.ts b/packages/tests/src/api/server/proxy.ts
new file mode 100644
index 000000000..c7d13f4ab
--- /dev/null
+++ b/packages/tests/src/api/server/proxy.ts
@@ -0,0 +1,173 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { HttpStatusCode, HttpStatusCodeType, VideoPrivacy } from '@peertube/peertube-models'
+import { areMockObjectStorageTestsDisabled } from '@peertube/peertube-node-utils'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  ObjectStorageCommand,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+import { FIXTURE_URLS } from '@tests/shared/tests.js'
+import { expectStartWith, expectNotStartWith } from '@tests/shared/checks.js'
+import { MockProxy } from '@tests/shared/mock-servers/mock-proxy.js'
+
+describe('Test proxy', function () {
+  let servers: PeerTubeServer[] = []
+  let proxy: MockProxy
+
+  const goodEnv = { HTTP_PROXY: '' }
+  const badEnv = { HTTP_PROXY: 'http://127.0.0.1:9000' }
+
+  before(async function () {
+    this.timeout(120000)
+
+    proxy = new MockProxy()
+
+    const proxyPort = await proxy.initialize()
+    servers = await createMultipleServers(2)
+
+    goodEnv.HTTP_PROXY = 'http://127.0.0.1:' + proxyPort
+
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  describe('Federation', function () {
+
+    it('Should succeed federation with the appropriate proxy config', async function () {
+      this.timeout(40000)
+
+      await servers[0].kill()
+      await servers[0].run({}, { env: goodEnv })
+
+      await servers[0].videos.quickUpload({ name: 'video 1' })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { total, data } = await server.videos.list()
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      }
+    })
+
+    it('Should fail federation with a wrong proxy config', async function () {
+      this.timeout(40000)
+
+      await servers[0].kill()
+      await servers[0].run({}, { env: badEnv })
+
+      await servers[0].videos.quickUpload({ name: 'video 2' })
+
+      await waitJobs(servers)
+
+      {
+        const { total, data } = await servers[0].videos.list()
+        expect(total).to.equal(2)
+        expect(data).to.have.lengthOf(2)
+      }
+
+      {
+        const { total, data } = await servers[1].videos.list()
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+      }
+    })
+  })
+
+  describe('Videos import', async function () {
+
+    function quickImport (expectedStatus: HttpStatusCodeType = HttpStatusCode.OK_200) {
+      return servers[0].imports.importVideo({
+        attributes: {
+          name: 'video import',
+          channelId: servers[0].store.channel.id,
+          privacy: VideoPrivacy.PUBLIC,
+          targetUrl: FIXTURE_URLS.peertube_long
+        },
+        expectedStatus
+      })
+    }
+
+    it('Should succeed import with the appropriate proxy config', async function () {
+      this.timeout(240000)
+
+      await servers[0].kill()
+      await servers[0].run({}, { env: goodEnv })
+
+      await quickImport()
+
+      await waitJobs(servers)
+
+      const { total, data } = await servers[0].videos.list()
+      expect(total).to.equal(3)
+      expect(data).to.have.lengthOf(3)
+    })
+
+    it('Should fail import with a wrong proxy config', async function () {
+      this.timeout(120000)
+
+      await servers[0].kill()
+      await servers[0].run({}, { env: badEnv })
+
+      await quickImport(HttpStatusCode.BAD_REQUEST_400)
+    })
+  })
+
+  describe('Object storage', function () {
+    if (areMockObjectStorageTestsDisabled()) return
+
+    const objectStorage = new ObjectStorageCommand()
+
+    before(async function () {
+      this.timeout(30000)
+
+      await objectStorage.prepareDefaultMockBuckets()
+    })
+
+    it('Should succeed to upload to object storage with the appropriate proxy config', async function () {
+      this.timeout(120000)
+
+      await servers[0].kill()
+      await servers[0].run(objectStorage.getDefaultMockConfig(), { env: goodEnv })
+
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'video' })
+      await waitJobs(servers)
+
+      const video = await servers[0].videos.get({ id: uuid })
+
+      expectStartWith(video.files[0].fileUrl, objectStorage.getMockWebVideosBaseUrl())
+    })
+
+    it('Should fail to upload to object storage with a wrong proxy config', async function () {
+      this.timeout(120000)
+
+      await servers[0].kill()
+      await servers[0].run(objectStorage.getDefaultMockConfig(), { env: badEnv })
+
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'video' })
+      await waitJobs(servers, { skipDelayed: true })
+
+      const video = await servers[0].videos.get({ id: uuid })
+
+      expectNotStartWith(video.files[0].fileUrl, objectStorage.getMockWebVideosBaseUrl())
+    })
+
+    after(async function () {
+      await objectStorage.cleanupMock()
+    })
+  })
+
+  after(async function () {
+    await proxy.terminate()
+
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/server/reverse-proxy.ts b/packages/tests/src/api/server/reverse-proxy.ts
new file mode 100644
index 000000000..7e334cc3e
--- /dev/null
+++ b/packages/tests/src/api/server/reverse-proxy.ts
@@ -0,0 +1,156 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { HttpStatusCode } from '@peertube/peertube-models'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@peertube/peertube-server-commands'
+
+describe('Test application behind a reverse proxy', function () {
+  let server: PeerTubeServer
+  let userAccessToken: string
+  let videoId: string
+
+  before(async function () {
+    this.timeout(60000)
+
+    const config = {
+      rates_limit: {
+        api: {
+          max: 50,
+          window: 5000
+        },
+        signup: {
+          max: 3,
+          window: 5000
+        },
+        login: {
+          max: 20
+        }
+      },
+      signup: {
+        limit: 20
+      }
+    }
+
+    server = await createSingleServer(1, config)
+    await setAccessTokensToServers([ server ])
+
+    userAccessToken = await server.users.generateUserAndToken('user')
+
+    const { uuid } = await server.videos.upload()
+    videoId = uuid
+  })
+
+  it('Should view a video only once with the same IP by default', async function () {
+    this.timeout(40000)
+
+    await server.views.simulateView({ id: videoId })
+    await server.views.simulateView({ id: videoId })
+
+    // Wait the repeatable job
+    await wait(8000)
+
+    const video = await server.videos.get({ id: videoId })
+    expect(video.views).to.equal(1)
+  })
+
+  it('Should view a video 2 times with the X-Forwarded-For header set', async function () {
+    this.timeout(20000)
+
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.1,127.0.0.1' })
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.2,127.0.0.1' })
+
+    // Wait the repeatable job
+    await wait(8000)
+
+    const video = await server.videos.get({ id: videoId })
+    expect(video.views).to.equal(3)
+  })
+
+  it('Should view a video only once with the same client IP in the X-Forwarded-For header', async function () {
+    this.timeout(20000)
+
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.4,0.0.0.3,::ffff:127.0.0.1' })
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.5,0.0.0.3,127.0.0.1' })
+
+    // Wait the repeatable job
+    await wait(8000)
+
+    const video = await server.videos.get({ id: videoId })
+    expect(video.views).to.equal(4)
+  })
+
+  it('Should view a video two times with a different client IP in the X-Forwarded-For header', async function () {
+    this.timeout(20000)
+
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.8,0.0.0.6,127.0.0.1' })
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.8,0.0.0.7,127.0.0.1' })
+
+    // Wait the repeatable job
+    await wait(8000)
+
+    const video = await server.videos.get({ id: videoId })
+    expect(video.views).to.equal(6)
+  })
+
+  it('Should rate limit logins', async function () {
+    const user = { username: 'root', password: 'fail' }
+
+    for (let i = 0; i < 18; i++) {
+      await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    }
+
+    await server.login.login({ user, expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
+  })
+
+  it('Should rate limit signup', async function () {
+    for (let i = 0; i < 10; i++) {
+      try {
+        await server.registrations.register({ username: 'test' + i })
+      } catch {
+        // empty
+      }
+    }
+
+    await server.registrations.register({ username: 'test42', expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
+  })
+
+  it('Should not rate limit failed signup', async function () {
+    this.timeout(30000)
+
+    await wait(7000)
+
+    for (let i = 0; i < 3; i++) {
+      await server.registrations.register({ username: 'test' + i, expectedStatus: HttpStatusCode.CONFLICT_409 })
+    }
+
+    await server.registrations.register({ username: 'test43', expectedStatus: HttpStatusCode.NO_CONTENT_204 })
+
+  })
+
+  it('Should rate limit API calls', async function () {
+    this.timeout(30000)
+
+    await wait(7000)
+
+    for (let i = 0; i < 100; i++) {
+      try {
+        await server.videos.get({ id: videoId })
+      } catch {
+        // don't care if it fails
+      }
+    }
+
+    await server.videos.get({ id: videoId, expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
+  })
+
+  it('Should rate limit API calls with a user but not with an admin', async function () {
+    await server.videos.get({ id: videoId, token: userAccessToken, expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
+
+    await server.videos.get({ id: videoId, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/services.ts b/packages/tests/src/api/server/services.ts
new file mode 100644
index 000000000..349d29a58
--- /dev/null
+++ b/packages/tests/src/api/server/services.ts
@@ -0,0 +1,143 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { Video, VideoPlaylistPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel
+} from '@peertube/peertube-server-commands'
+
+describe('Test services', function () {
+  let server: PeerTubeServer = null
+  let playlistUUID: string
+  let playlistDisplayName: string
+  let video: Video
+
+  const urlSuffixes = [
+    {
+      input: '',
+      output: ''
+    },
+    {
+      input: '?param=1',
+      output: ''
+    },
+    {
+      input: '?muted=1&warningTitle=0&toto=1',
+      output: '?muted=1&warningTitle=0'
+    }
+  ]
+
+  before(async function () {
+    this.timeout(120000)
+
+    server = await createSingleServer(1)
+
+    await setAccessTokensToServers([ server ])
+    await setDefaultVideoChannel([ server ])
+
+    {
+      const attributes = { name: 'my super name' }
+      await server.videos.upload({ attributes })
+
+      const { data } = await server.videos.list()
+      video = data[0]
+    }
+
+    {
+      const created = await server.playlists.create({
+        attributes: {
+          displayName: 'The Life and Times of Scrooge McDuck',
+          privacy: VideoPlaylistPrivacy.PUBLIC,
+          videoChannelId: server.store.channel.id
+        }
+      })
+
+      playlistUUID = created.uuid
+      playlistDisplayName = 'The Life and Times of Scrooge McDuck'
+
+      await server.playlists.addElement({
+        playlistId: created.id,
+        attributes: {
+          videoId: video.id
+        }
+      })
+    }
+  })
+
+  it('Should have a valid oEmbed video response', async function () {
+    for (const basePath of [ '/videos/watch/', '/w/' ]) {
+      for (const suffix of urlSuffixes) {
+        const oembedUrl = server.url + basePath + video.uuid + suffix.input
+
+        const res = await server.services.getOEmbed({ oembedUrl })
+        const expectedHtml = '<iframe width="560" height="315" sandbox="allow-same-origin allow-scripts allow-popups" ' +
+          `title="${video.name}" src="http://${server.host}/videos/embed/${video.uuid}${suffix.output}" ` +
+          'frameborder="0" allowfullscreen></iframe>'
+
+        const expectedThumbnailUrl = 'http://' + server.host + video.previewPath
+
+        expect(res.body.html).to.equal(expectedHtml)
+        expect(res.body.title).to.equal(video.name)
+        expect(res.body.author_name).to.equal(server.store.channel.displayName)
+        expect(res.body.width).to.equal(560)
+        expect(res.body.height).to.equal(315)
+        expect(res.body.thumbnail_url).to.equal(expectedThumbnailUrl)
+        expect(res.body.thumbnail_width).to.equal(850)
+        expect(res.body.thumbnail_height).to.equal(480)
+      }
+    }
+  })
+
+  it('Should have a valid playlist oEmbed response', async function () {
+    for (const basePath of [ '/videos/watch/playlist/', '/w/p/' ]) {
+      for (const suffix of urlSuffixes) {
+        const oembedUrl = server.url + basePath + playlistUUID + suffix.input
+
+        const res = await server.services.getOEmbed({ oembedUrl })
+        const expectedHtml = '<iframe width="560" height="315" sandbox="allow-same-origin allow-scripts allow-popups" ' +
+          `title="${playlistDisplayName}" src="http://${server.host}/video-playlists/embed/${playlistUUID}${suffix.output}" ` +
+          'frameborder="0" allowfullscreen></iframe>'
+
+        expect(res.body.html).to.equal(expectedHtml)
+        expect(res.body.title).to.equal('The Life and Times of Scrooge McDuck')
+        expect(res.body.author_name).to.equal(server.store.channel.displayName)
+        expect(res.body.width).to.equal(560)
+        expect(res.body.height).to.equal(315)
+        expect(res.body.thumbnail_url).exist
+        expect(res.body.thumbnail_width).to.equal(280)
+        expect(res.body.thumbnail_height).to.equal(157)
+      }
+    }
+  })
+
+  it('Should have a valid oEmbed response with small max height query', async function () {
+    for (const basePath of [ '/videos/watch/', '/w/' ]) {
+      const oembedUrl = 'http://' + server.host + basePath + video.uuid
+      const format = 'json'
+      const maxHeight = 50
+      const maxWidth = 50
+
+      const res = await server.services.getOEmbed({ oembedUrl, format, maxHeight, maxWidth })
+      const expectedHtml = '<iframe width="50" height="50" sandbox="allow-same-origin allow-scripts allow-popups" ' +
+        `title="${video.name}" src="http://${server.host}/videos/embed/${video.uuid}" ` +
+        'frameborder="0" allowfullscreen></iframe>'
+
+      expect(res.body.html).to.equal(expectedHtml)
+      expect(res.body.title).to.equal(video.name)
+      expect(res.body.author_name).to.equal(server.store.channel.displayName)
+      expect(res.body.height).to.equal(50)
+      expect(res.body.width).to.equal(50)
+      expect(res.body).to.not.have.property('thumbnail_url')
+      expect(res.body).to.not.have.property('thumbnail_width')
+      expect(res.body).to.not.have.property('thumbnail_height')
+    }
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/server/slow-follows.ts b/packages/tests/src/api/server/slow-follows.ts
new file mode 100644
index 000000000..d03109001
--- /dev/null
+++ b/packages/tests/src/api/server/slow-follows.ts
@@ -0,0 +1,85 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { Job } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Test slow follows', function () {
+  let servers: PeerTubeServer[] = []
+
+  let afterFollows: Date
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(3)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    await doubleFollow(servers[0], servers[1])
+    await doubleFollow(servers[0], servers[2])
+
+    afterFollows = new Date()
+
+    for (let i = 0; i < 5; i++) {
+      await servers[0].videos.quickUpload({ name: 'video ' + i })
+    }
+
+    await waitJobs(servers)
+  })
+
+  it('Should only have broadcast jobs', async function () {
+    const { data } = await servers[0].jobs.list({ jobType: 'activitypub-http-unicast', sort: '-createdAt' })
+
+    for (const job of data) {
+      expect(new Date(job.createdAt)).below(afterFollows)
+    }
+  })
+
+  it('Should process bad follower', async function () {
+    this.timeout(30000)
+
+    await servers[1].kill()
+
+    // Set server 2 as bad follower
+    await servers[0].videos.quickUpload({ name: 'video 6' })
+    await waitJobs(servers[0])
+
+    afterFollows = new Date()
+    const filter = (job: Job) => new Date(job.createdAt) > afterFollows
+
+    // Resend another broadcast job
+    await servers[0].videos.quickUpload({ name: 'video 7' })
+    await waitJobs(servers[0])
+
+    const resBroadcast = await servers[0].jobs.list({ jobType: 'activitypub-http-broadcast', sort: '-createdAt' })
+    const resUnicast = await servers[0].jobs.list({ jobType: 'activitypub-http-unicast', sort: '-createdAt' })
+
+    const broadcast = resBroadcast.data.filter(filter)
+    const unicast = resUnicast.data.filter(filter)
+
+    expect(unicast).to.have.lengthOf(2)
+    expect(broadcast).to.have.lengthOf(2)
+
+    for (const u of unicast) {
+      expect(u.data.uri).to.equal(servers[1].url + '/inbox')
+    }
+
+    for (const b of broadcast) {
+      expect(b.data.uris).to.have.lengthOf(1)
+      expect(b.data.uris[0]).to.equal(servers[2].url + '/inbox')
+    }
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/server/stats.ts b/packages/tests/src/api/server/stats.ts
new file mode 100644
index 000000000..32ab323ce
--- /dev/null
+++ b/packages/tests/src/api/server/stats.ts
@@ -0,0 +1,279 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { ActivityType, VideoPlaylistPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Test stats (excluding redundancy)', function () {
+  let servers: PeerTubeServer[] = []
+  let channelId
+  const user = {
+    username: 'user1',
+    password: 'super_password'
+  }
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(3)
+
+    await setAccessTokensToServers(servers)
+    await setDefaultChannelAvatar(servers)
+    await setDefaultAccountAvatar(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    await servers[0].users.create({ username: user.username, password: user.password })
+
+    const { uuid } = await servers[0].videos.upload({ attributes: { fixture: 'video_short.webm' } })
+
+    await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
+
+    await servers[0].views.simulateView({ id: uuid })
+
+    // Wait the video views repeatable job
+    await wait(8000)
+
+    await servers[2].follows.follow({ hosts: [ servers[0].url ] })
+    await waitJobs(servers)
+  })
+
+  it('Should have the correct stats on instance 1', async function () {
+    const data = await servers[0].stats.get()
+
+    expect(data.totalLocalVideoComments).to.equal(1)
+    expect(data.totalLocalVideos).to.equal(1)
+    expect(data.totalLocalVideoViews).to.equal(1)
+    expect(data.totalLocalVideoFilesSize).to.equal(218910)
+    expect(data.totalUsers).to.equal(2)
+    expect(data.totalVideoComments).to.equal(1)
+    expect(data.totalVideos).to.equal(1)
+    expect(data.totalInstanceFollowers).to.equal(2)
+    expect(data.totalInstanceFollowing).to.equal(1)
+    expect(data.totalLocalPlaylists).to.equal(0)
+  })
+
+  it('Should have the correct stats on instance 2', async function () {
+    const data = await servers[1].stats.get()
+
+    expect(data.totalLocalVideoComments).to.equal(0)
+    expect(data.totalLocalVideos).to.equal(0)
+    expect(data.totalLocalVideoViews).to.equal(0)
+    expect(data.totalLocalVideoFilesSize).to.equal(0)
+    expect(data.totalUsers).to.equal(1)
+    expect(data.totalVideoComments).to.equal(1)
+    expect(data.totalVideos).to.equal(1)
+    expect(data.totalInstanceFollowers).to.equal(1)
+    expect(data.totalInstanceFollowing).to.equal(1)
+    expect(data.totalLocalPlaylists).to.equal(0)
+  })
+
+  it('Should have the correct stats on instance 3', async function () {
+    const data = await servers[2].stats.get()
+
+    expect(data.totalLocalVideoComments).to.equal(0)
+    expect(data.totalLocalVideos).to.equal(0)
+    expect(data.totalLocalVideoViews).to.equal(0)
+    expect(data.totalUsers).to.equal(1)
+    expect(data.totalVideoComments).to.equal(1)
+    expect(data.totalVideos).to.equal(1)
+    expect(data.totalInstanceFollowing).to.equal(1)
+    expect(data.totalInstanceFollowers).to.equal(0)
+    expect(data.totalLocalPlaylists).to.equal(0)
+  })
+
+  it('Should have the correct total videos stats after an unfollow', async function () {
+    this.timeout(15000)
+
+    await servers[2].follows.unfollow({ target: servers[0] })
+    await waitJobs(servers)
+
+    const data = await servers[2].stats.get()
+
+    expect(data.totalVideos).to.equal(0)
+  })
+
+  it('Should have the correct active user stats', async function () {
+    const server = servers[0]
+
+    {
+      const data = await server.stats.get()
+
+      expect(data.totalDailyActiveUsers).to.equal(1)
+      expect(data.totalWeeklyActiveUsers).to.equal(1)
+      expect(data.totalMonthlyActiveUsers).to.equal(1)
+    }
+
+    {
+      await server.login.getAccessToken(user)
+
+      const data = await server.stats.get()
+
+      expect(data.totalDailyActiveUsers).to.equal(2)
+      expect(data.totalWeeklyActiveUsers).to.equal(2)
+      expect(data.totalMonthlyActiveUsers).to.equal(2)
+    }
+  })
+
+  it('Should have the correct active channel stats', async function () {
+    const server = servers[0]
+
+    {
+      const data = await server.stats.get()
+
+      expect(data.totalLocalVideoChannels).to.equal(2)
+      expect(data.totalLocalDailyActiveVideoChannels).to.equal(1)
+      expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(1)
+      expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(1)
+    }
+
+    {
+      const attributes = {
+        name: 'stats_channel',
+        displayName: 'My stats channel'
+      }
+      const created = await server.channels.create({ attributes })
+      channelId = created.id
+
+      const data = await server.stats.get()
+
+      expect(data.totalLocalVideoChannels).to.equal(3)
+      expect(data.totalLocalDailyActiveVideoChannels).to.equal(1)
+      expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(1)
+      expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(1)
+    }
+
+    {
+      await server.videos.upload({ attributes: { fixture: 'video_short.webm', channelId } })
+
+      const data = await server.stats.get()
+
+      expect(data.totalLocalVideoChannels).to.equal(3)
+      expect(data.totalLocalDailyActiveVideoChannels).to.equal(2)
+      expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(2)
+      expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(2)
+    }
+  })
+
+  it('Should have the correct playlist stats', async function () {
+    const server = servers[0]
+
+    {
+      const data = await server.stats.get()
+      expect(data.totalLocalPlaylists).to.equal(0)
+    }
+
+    {
+      await server.playlists.create({
+        attributes: {
+          displayName: 'playlist for count',
+          privacy: VideoPlaylistPrivacy.PUBLIC,
+          videoChannelId: channelId
+        }
+      })
+
+      const data = await server.stats.get()
+      expect(data.totalLocalPlaylists).to.equal(1)
+    }
+  })
+
+  it('Should correctly count video file sizes if transcoding is enabled', async function () {
+    this.timeout(120000)
+
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        transcoding: {
+          enabled: true,
+          webVideos: {
+            enabled: true
+          },
+          hls: {
+            enabled: true
+          },
+          resolutions: {
+            '0p': false,
+            '144p': false,
+            '240p': false,
+            '360p': false,
+            '480p': false,
+            '720p': false,
+            '1080p': false,
+            '1440p': false,
+            '2160p': false
+          }
+        }
+      }
+    })
+
+    await servers[0].videos.upload({ attributes: { name: 'video', fixture: 'video_short.webm' } })
+
+    await waitJobs(servers)
+
+    {
+      const data = await servers[1].stats.get()
+      expect(data.totalLocalVideoFilesSize).to.equal(0)
+    }
+
+    {
+      const data = await servers[0].stats.get()
+      expect(data.totalLocalVideoFilesSize).to.be.greaterThan(500000)
+      expect(data.totalLocalVideoFilesSize).to.be.lessThan(600000)
+    }
+  })
+
+  it('Should have the correct AP stats', async function () {
+    this.timeout(120000)
+
+    await servers[0].config.disableTranscoding()
+
+    const first = await servers[1].stats.get()
+
+    for (let i = 0; i < 10; i++) {
+      await servers[0].videos.upload({ attributes: { name: 'video' } })
+    }
+
+    await waitJobs(servers)
+
+    await wait(6000)
+
+    const second = await servers[1].stats.get()
+    expect(second.totalActivityPubMessagesProcessed).to.be.greaterThan(first.totalActivityPubMessagesProcessed)
+
+    const apTypes: ActivityType[] = [
+      'Create', 'Update', 'Delete', 'Follow', 'Accept', 'Announce', 'Undo', 'Like', 'Reject', 'View', 'Dislike', 'Flag'
+    ]
+
+    const processed = apTypes.reduce(
+      (previous, type) => previous + second['totalActivityPub' + type + 'MessagesSuccesses'],
+      0
+    )
+    expect(second.totalActivityPubMessagesProcessed).to.equal(processed)
+    expect(second.totalActivityPubMessagesSuccesses).to.equal(processed)
+
+    expect(second.totalActivityPubMessagesErrors).to.equal(0)
+
+    for (const apType of apTypes) {
+      expect(second['totalActivityPub' + apType + 'MessagesErrors']).to.equal(0)
+    }
+
+    await wait(6000)
+
+    const third = await servers[1].stats.get()
+    expect(third.totalActivityPubMessagesWaiting).to.equal(0)
+    expect(third.activityPubMessagesProcessedPerSecond).to.be.lessThan(second.activityPubMessagesProcessedPerSecond)
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/server/tracker.ts b/packages/tests/src/api/server/tracker.ts
new file mode 100644
index 000000000..4df4e4613
--- /dev/null
+++ b/packages/tests/src/api/server/tracker.ts
@@ -0,0 +1,110 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await,@typescript-eslint/no-floating-promises */
+
+import { decode as magnetUriDecode, encode as magnetUriEncode } from 'magnet-uri'
+import WebTorrent from 'webtorrent'
+import {
+  cleanupTests,
+  createSingleServer,
+  killallServers,
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@peertube/peertube-server-commands'
+
+describe('Test tracker', function () {
+  let server: PeerTubeServer
+  let badMagnet: string
+  let goodMagnet: string
+
+  before(async function () {
+    this.timeout(60000)
+    server = await createSingleServer(1)
+    await setAccessTokensToServers([ server ])
+
+    {
+      const { uuid } = await server.videos.upload()
+      const video = await server.videos.get({ id: uuid })
+      goodMagnet = video.files[0].magnetUri
+
+      const parsed = magnetUriDecode(goodMagnet)
+      parsed.infoHash = '010597bb88b1968a5693a4fa8267c592ca65f2e9'
+
+      badMagnet = magnetUriEncode(parsed)
+    }
+  })
+
+  it('Should succeed with the correct infohash', function (done) {
+    const webtorrent = new WebTorrent()
+
+    const torrent = webtorrent.add(goodMagnet)
+
+    torrent.on('error', done)
+    torrent.on('warning', warn => {
+      const message = typeof warn === 'string' ? warn : warn.message
+      if (message.includes('Unknown infoHash ')) return done(new Error('Error on infohash'))
+    })
+
+    torrent.on('done', done)
+  })
+
+  it('Should disable the tracker', function (done) {
+    this.timeout(20000)
+
+    const errCb = () => done(new Error('Tracker is enabled'))
+
+    killallServers([ server ])
+      .then(() => server.run({ tracker: { enabled: false } }))
+      .then(() => {
+        const webtorrent = new WebTorrent()
+
+        const torrent = webtorrent.add(goodMagnet)
+
+        torrent.on('error', done)
+        torrent.on('warning', warn => {
+          const message = typeof warn === 'string' ? warn : warn.message
+          if (message.includes('disabled ')) {
+            torrent.off('done', errCb)
+
+            return done()
+          }
+        })
+
+        torrent.on('done', errCb)
+      })
+  })
+
+  it('Should return an error when adding an incorrect infohash', function (done) {
+    this.timeout(20000)
+
+    killallServers([ server ])
+      .then(() => server.run())
+      .then(() => {
+        const webtorrent = new WebTorrent()
+
+        const torrent = webtorrent.add(badMagnet)
+
+        torrent.on('error', done)
+        torrent.on('warning', warn => {
+          const message = typeof warn === 'string' ? warn : warn.message
+          if (message.includes('Unknown infoHash ')) return done()
+        })
+
+        torrent.on('done', () => done(new Error('No error on infohash')))
+      })
+  })
+
+  it('Should block the IP after the failed infohash', function (done) {
+    const webtorrent = new WebTorrent()
+
+    const torrent = webtorrent.add(goodMagnet)
+
+    torrent.on('error', done)
+    torrent.on('warning', warn => {
+      const message = typeof warn === 'string' ? warn : warn.message
+      if (message.includes('Unsupported tracker protocol')) return done()
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})