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)

11 files changed, 673 insertions, 0 deletions

diff --git a/packages/tests/src/server-helpers/activitypub.ts b/packages/tests/src/server-helpers/activitypub.ts
new file mode 100644
index 000000000..dfcd0389f
--- /dev/null
+++ b/packages/tests/src/server-helpers/activitypub.ts
@@ -0,0 +1,176 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { buildAbsoluteFixturePath } from '@peertube/peertube-node-utils'
+import { signAndContextify } from '@peertube/peertube-server/server/helpers/activity-pub-utils.js'
+import {
+  isHTTPSignatureVerified,
+  isJsonLDSignatureVerified,
+  parseHTTPSignature
+} from '@peertube/peertube-server/server/helpers/peertube-crypto.js'
+import { buildRequestStub } from '@tests/shared/tests.js'
+import { expect } from 'chai'
+import { readJsonSync } from 'fs-extra/esm'
+import cloneDeep from 'lodash-es/cloneDeep.js'
+
+function fakeFilter () {
+  return (data: any) => Promise.resolve(data)
+}
+
+describe('Test activity pub helpers', function () {
+
+  describe('When checking the Linked Signature', function () {
+
+    it('Should fail with an invalid Mastodon signature', async function () {
+      const body = readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/create-bad-signature.json'))
+      const publicKey = readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/public-key.json')).publicKey
+      const fromActor = { publicKey, url: 'http://localhost:9002/accounts/peertube' }
+
+      const result = await isJsonLDSignatureVerified(fromActor as any, body)
+
+      expect(result).to.be.false
+    })
+
+    it('Should fail with an invalid public key', async function () {
+      const body = readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/create.json'))
+      const publicKey = readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/bad-public-key.json')).publicKey
+      const fromActor = { publicKey, url: 'http://localhost:9002/accounts/peertube' }
+
+      const result = await isJsonLDSignatureVerified(fromActor as any, body)
+
+      expect(result).to.be.false
+    })
+
+    it('Should succeed with a valid Mastodon signature', async function () {
+      const body = readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/create.json'))
+      const publicKey = readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/public-key.json')).publicKey
+      const fromActor = { publicKey, url: 'http://localhost:9002/accounts/peertube' }
+
+      const result = await isJsonLDSignatureVerified(fromActor as any, body)
+
+      expect(result).to.be.true
+    })
+
+    it('Should fail with an invalid PeerTube signature', async function () {
+      const keys = readJsonSync(buildAbsoluteFixturePath('./ap-json/peertube/invalid-keys.json'))
+      const body = readJsonSync(buildAbsoluteFixturePath('./ap-json/peertube/announce-without-context.json'))
+
+      const actorSignature = { url: 'http://localhost:9002/accounts/peertube', privateKey: keys.privateKey }
+      const signedBody = await signAndContextify(actorSignature as any, body, 'Announce', fakeFilter())
+
+      const fromActor = { publicKey: keys.publicKey, url: 'http://localhost:9002/accounts/peertube' }
+      const result = await isJsonLDSignatureVerified(fromActor as any, signedBody)
+
+      expect(result).to.be.false
+    })
+
+    it('Should succeed with a valid PeerTube signature', async function () {
+      const keys = readJsonSync(buildAbsoluteFixturePath('./ap-json/peertube/keys.json'))
+      const body = readJsonSync(buildAbsoluteFixturePath('./ap-json/peertube/announce-without-context.json'))
+
+      const actorSignature = { url: 'http://localhost:9002/accounts/peertube', privateKey: keys.privateKey }
+      const signedBody = await signAndContextify(actorSignature as any, body, 'Announce', fakeFilter())
+
+      const fromActor = { publicKey: keys.publicKey, url: 'http://localhost:9002/accounts/peertube' }
+      const result = await isJsonLDSignatureVerified(fromActor as any, signedBody)
+
+      expect(result).to.be.true
+    })
+  })
+
+  describe('When checking HTTP signature', function () {
+    it('Should fail with an invalid http signature', async function () {
+      const req = buildRequestStub()
+      req.method = 'POST'
+      req.url = '/accounts/ronan/inbox'
+
+      const mastodonObject = cloneDeep(readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/bad-http-signature.json')))
+      req.body = mastodonObject.body
+      req.headers = mastodonObject.headers
+
+      const parsed = parseHTTPSignature(req, 3600 * 1000 * 365 * 10)
+      const publicKey = readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/public-key.json')).publicKey
+
+      const actor = { publicKey }
+      const verified = isHTTPSignatureVerified(parsed, actor as any)
+
+      expect(verified).to.be.false
+    })
+
+    it('Should fail with an invalid public key', async function () {
+      const req = buildRequestStub()
+      req.method = 'POST'
+      req.url = '/accounts/ronan/inbox'
+
+      const mastodonObject = cloneDeep(readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/http-signature.json')))
+      req.body = mastodonObject.body
+      req.headers = mastodonObject.headers
+
+      const parsed = parseHTTPSignature(req, 3600 * 1000 * 365 * 10)
+      const publicKey = readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/bad-public-key.json')).publicKey
+
+      const actor = { publicKey }
+      const verified = isHTTPSignatureVerified(parsed, actor as any)
+
+      expect(verified).to.be.false
+    })
+
+    it('Should fail because of clock skew', async function () {
+      const req = buildRequestStub()
+      req.method = 'POST'
+      req.url = '/accounts/ronan/inbox'
+
+      const mastodonObject = cloneDeep(readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/http-signature.json')))
+      req.body = mastodonObject.body
+      req.headers = mastodonObject.headers
+
+      let errored = false
+      try {
+        parseHTTPSignature(req)
+      } catch {
+        errored = true
+      }
+
+      expect(errored).to.be.true
+    })
+
+    it('Should with a scheme', async function () {
+      const req = buildRequestStub()
+      req.method = 'POST'
+      req.url = '/accounts/ronan/inbox'
+
+      const mastodonObject = cloneDeep(readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/http-signature.json')))
+      req.body = mastodonObject.body
+      req.headers = mastodonObject.headers
+      req.headers = 'Signature ' + mastodonObject.headers
+
+      let errored = false
+      try {
+        parseHTTPSignature(req, 3600 * 1000 * 365 * 10)
+      } catch {
+        errored = true
+      }
+
+      expect(errored).to.be.true
+    })
+
+    it('Should succeed with a valid signature', async function () {
+      const req = buildRequestStub()
+      req.method = 'POST'
+      req.url = '/accounts/ronan/inbox'
+
+      const mastodonObject = cloneDeep(readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/http-signature.json')))
+      req.body = mastodonObject.body
+      req.headers = mastodonObject.headers
+
+      const parsed = parseHTTPSignature(req, 3600 * 1000 * 365 * 10)
+      const publicKey = readJsonSync(buildAbsoluteFixturePath('./ap-json/mastodon/public-key.json')).publicKey
+
+      const actor = { publicKey }
+      const verified = isHTTPSignatureVerified(parsed, actor as any)
+
+      expect(verified).to.be.true
+    })
+
+  })
+
+})
diff --git a/packages/tests/src/server-helpers/core-utils.ts b/packages/tests/src/server-helpers/core-utils.ts
new file mode 100644
index 000000000..06c78591e
--- /dev/null
+++ b/packages/tests/src/server-helpers/core-utils.ts
@@ -0,0 +1,150 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import snakeCase from 'lodash-es/snakeCase.js'
+import validator from 'validator'
+import { getAverageTheoreticalBitrate, getMaxTheoreticalBitrate } from '@peertube/peertube-core-utils'
+import { VideoResolution } from '@peertube/peertube-models'
+import { objectConverter, parseBytes, parseDurationToMs } from '@peertube/peertube-server/server/helpers/core-utils.js'
+
+describe('Parse Bytes', function () {
+
+  it('Should pass on valid value', async function () {
+    // just return it
+    expect(parseBytes(-1024)).to.equal(-1024)
+    expect(parseBytes(1024)).to.equal(1024)
+    expect(parseBytes(1048576)).to.equal(1048576)
+    expect(parseBytes('1024')).to.equal(1024)
+    expect(parseBytes('1048576')).to.equal(1048576)
+
+    // sizes
+    expect(parseBytes('1B')).to.equal(1024)
+    expect(parseBytes('1MB')).to.equal(1048576)
+    expect(parseBytes('1GB')).to.equal(1073741824)
+    expect(parseBytes('1TB')).to.equal(1099511627776)
+
+    expect(parseBytes('5GB')).to.equal(5368709120)
+    expect(parseBytes('5TB')).to.equal(5497558138880)
+
+    expect(parseBytes('1024B')).to.equal(1048576)
+    expect(parseBytes('1024MB')).to.equal(1073741824)
+    expect(parseBytes('1024GB')).to.equal(1099511627776)
+    expect(parseBytes('1024TB')).to.equal(1125899906842624)
+
+    // with whitespace
+    expect(parseBytes('1 GB')).to.equal(1073741824)
+    expect(parseBytes('1\tGB')).to.equal(1073741824)
+
+    // sum value
+    expect(parseBytes('1TB 1024MB')).to.equal(1100585369600)
+    expect(parseBytes('4GB 1024MB')).to.equal(5368709120)
+    expect(parseBytes('4TB 1024GB')).to.equal(5497558138880)
+    expect(parseBytes('4TB 1024GB 0MB')).to.equal(5497558138880)
+    expect(parseBytes('1024TB 1024GB 1024MB')).to.equal(1127000492212224)
+  })
+
+  it('Should be invalid when given invalid value', async function () {
+    expect(parseBytes('6GB 1GB')).to.equal(6)
+  })
+})
+
+describe('Parse duration', function () {
+
+  it('Should pass when given valid value', async function () {
+    expect(parseDurationToMs(35)).to.equal(35)
+    expect(parseDurationToMs(-35)).to.equal(-35)
+    expect(parseDurationToMs('35 seconds')).to.equal(35 * 1000)
+    expect(parseDurationToMs('1 minute')).to.equal(60 * 1000)
+    expect(parseDurationToMs('1 hour')).to.equal(3600 * 1000)
+    expect(parseDurationToMs('35 hours')).to.equal(3600 * 35 * 1000)
+  })
+
+  it('Should be invalid when given invalid value', async function () {
+    expect(parseBytes('35m 5s')).to.equal(35)
+  })
+})
+
+describe('Object', function () {
+
+  it('Should convert an object', async function () {
+    function keyConverter (k: string) {
+      return snakeCase(k)
+    }
+
+    function valueConverter (v: any) {
+      if (validator.default.isNumeric(v + '')) return parseInt('' + v, 10)
+
+      return v
+    }
+
+    const obj = {
+      mySuperKey: 'hello',
+      mySuper2Key: '45',
+      mySuper3Key: {
+        mySuperSubKey: '15',
+        mySuperSub2Key: 'hello',
+        mySuperSub3Key: [ '1', 'hello', 2 ],
+        mySuperSub4Key: 4
+      },
+      mySuper4Key: 45,
+      toto: {
+        super_key: '15',
+        superKey2: 'hello'
+      },
+      super_key: {
+        superKey4: 15
+      }
+    }
+
+    const res = objectConverter(obj, keyConverter, valueConverter)
+
+    expect(res.my_super_key).to.equal('hello')
+    expect(res.my_super_2_key).to.equal(45)
+    expect(res.my_super_3_key.my_super_sub_key).to.equal(15)
+    expect(res.my_super_3_key.my_super_sub_2_key).to.equal('hello')
+    expect(res.my_super_3_key.my_super_sub_3_key).to.deep.equal([ 1, 'hello', 2 ])
+    expect(res.my_super_3_key.my_super_sub_4_key).to.equal(4)
+    expect(res.toto.super_key).to.equal(15)
+    expect(res.toto.super_key_2).to.equal('hello')
+    expect(res.super_key.super_key_4).to.equal(15)
+
+    // Immutable
+    expect(res.mySuperKey).to.be.undefined
+    expect(obj['my_super_key']).to.be.undefined
+  })
+})
+
+describe('Bitrate', function () {
+
+  it('Should get appropriate max bitrate', function () {
+    const tests = [
+      { resolution: VideoResolution.H_144P, ratio: 16 / 9, fps: 24, min: 200, max: 400 },
+      { resolution: VideoResolution.H_240P, ratio: 16 / 9, fps: 24, min: 600, max: 800 },
+      { resolution: VideoResolution.H_360P, ratio: 16 / 9, fps: 24, min: 1200, max: 1600 },
+      { resolution: VideoResolution.H_480P, ratio: 16 / 9, fps: 24, min: 2000, max: 2300 },
+      { resolution: VideoResolution.H_720P, ratio: 16 / 9, fps: 24, min: 4000, max: 4400 },
+      { resolution: VideoResolution.H_1080P, ratio: 16 / 9, fps: 24, min: 8000, max: 10000 },
+      { resolution: VideoResolution.H_4K, ratio: 16 / 9, fps: 24, min: 25000, max: 30000 }
+    ]
+
+    for (const test of tests) {
+      expect(getMaxTheoreticalBitrate(test)).to.be.above(test.min * 1000).and.below(test.max * 1000)
+    }
+  })
+
+  it('Should get appropriate average bitrate', function () {
+    const tests = [
+      { resolution: VideoResolution.H_144P, ratio: 16 / 9, fps: 24, min: 50, max: 300 },
+      { resolution: VideoResolution.H_240P, ratio: 16 / 9, fps: 24, min: 350, max: 450 },
+      { resolution: VideoResolution.H_360P, ratio: 16 / 9, fps: 24, min: 700, max: 900 },
+      { resolution: VideoResolution.H_480P, ratio: 16 / 9, fps: 24, min: 1100, max: 1300 },
+      { resolution: VideoResolution.H_720P, ratio: 16 / 9, fps: 24, min: 2300, max: 2500 },
+      { resolution: VideoResolution.H_1080P, ratio: 16 / 9, fps: 24, min: 4700, max: 5000 },
+      { resolution: VideoResolution.H_4K, ratio: 16 / 9, fps: 24, min: 15000, max: 17000 }
+    ]
+
+    for (const test of tests) {
+      expect(getAverageTheoreticalBitrate(test)).to.be.above(test.min * 1000).and.below(test.max * 1000)
+    }
+  })
+})
diff --git a/packages/tests/src/server-helpers/crypto.ts b/packages/tests/src/server-helpers/crypto.ts
new file mode 100644
index 000000000..4bf5b8a45
--- /dev/null
+++ b/packages/tests/src/server-helpers/crypto.ts
@@ -0,0 +1,33 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { decrypt, encrypt } from '@peertube/peertube-server/server/helpers/peertube-crypto.js'
+
+describe('Encrypt/Descrypt', function () {
+
+  it('Should encrypt and decrypt the string', async function () {
+    const secret = 'my_secret'
+    const str = 'my super string'
+
+    const encrypted = await encrypt(str, secret)
+    const decrypted = await decrypt(encrypted, secret)
+
+    expect(str).to.equal(decrypted)
+  })
+
+  it('Should not decrypt without the same secret', async function () {
+    const str = 'my super string'
+
+    const encrypted = await encrypt(str, 'my_secret')
+
+    let error = false
+
+    try {
+      await decrypt(encrypted, 'my_sicret')
+    } catch (err) {
+      error = true
+    }
+
+    expect(error).to.be.true
+  })
+})
diff --git a/packages/tests/src/server-helpers/dns.ts b/packages/tests/src/server-helpers/dns.ts
new file mode 100644
index 000000000..64e3112a2
--- /dev/null
+++ b/packages/tests/src/server-helpers/dns.ts
@@ -0,0 +1,16 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { isResolvingToUnicastOnly } from '@peertube/peertube-server/server/helpers/dns.js'
+
+describe('DNS helpers', function () {
+
+  it('Should correctly check unicast IPs', async function () {
+    expect(await isResolvingToUnicastOnly('cpy.re')).to.be.true
+    expect(await isResolvingToUnicastOnly('framasoft.org')).to.be.true
+    expect(await isResolvingToUnicastOnly('8.8.8.8')).to.be.true
+
+    expect(await isResolvingToUnicastOnly('127.0.0.1')).to.be.false
+    expect(await isResolvingToUnicastOnly('127.0.0.1.cpy.re')).to.be.false
+  })
+})
diff --git a/packages/tests/src/server-helpers/image.ts b/packages/tests/src/server-helpers/image.ts
new file mode 100644
index 000000000..34675d385
--- /dev/null
+++ b/packages/tests/src/server-helpers/image.ts
@@ -0,0 +1,97 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { remove } from 'fs-extra/esm'
+import { readFile } from 'fs/promises'
+import { join } from 'path'
+import { buildAbsoluteFixturePath, root } from '@peertube/peertube-node-utils'
+import { execPromise } from '@peertube/peertube-server/server/helpers/core-utils.js'
+import { processImage } from '@peertube/peertube-server/server/helpers/image-utils.js'
+
+async function checkBuffers (path1: string, path2: string, equals: boolean) {
+  const [ buf1, buf2 ] = await Promise.all([
+    readFile(path1),
+    readFile(path2)
+  ])
+
+  if (equals) {
+    expect(buf1.equals(buf2)).to.be.true
+  } else {
+    expect(buf1.equals(buf2)).to.be.false
+  }
+}
+
+async function hasTitleExif (path: string) {
+  const result = JSON.parse(await execPromise(`exiftool -json ${path}`))
+
+  return result[0]?.Title === 'should be removed'
+}
+
+describe('Image helpers', function () {
+  const imageDestDir = join(root(), 'test-images')
+
+  const imageDestJPG = join(imageDestDir, 'test.jpg')
+  const imageDestPNG = join(imageDestDir, 'test.png')
+
+  const thumbnailSize = { width: 280, height: 157 }
+
+  it('Should skip processing if the source image is okay', async function () {
+    const input = buildAbsoluteFixturePath('custom-thumbnail.jpg')
+    await processImage({ path: input, destination: imageDestJPG, newSize: thumbnailSize, keepOriginal: true })
+
+    await checkBuffers(input, imageDestJPG, true)
+  })
+
+  it('Should not skip processing if the source image does not have the appropriate extension', async function () {
+    const input = buildAbsoluteFixturePath('custom-thumbnail.png')
+    await processImage({ path: input, destination: imageDestJPG, newSize: thumbnailSize, keepOriginal: true })
+
+    await checkBuffers(input, imageDestJPG, false)
+  })
+
+  it('Should not skip processing if the source image does not have the appropriate size', async function () {
+    const input = buildAbsoluteFixturePath('custom-preview.jpg')
+    await processImage({ path: input, destination: imageDestJPG, newSize: thumbnailSize, keepOriginal: true })
+
+    await checkBuffers(input, imageDestJPG, false)
+  })
+
+  it('Should not skip processing if the source image does not have the appropriate size', async function () {
+    const input = buildAbsoluteFixturePath('custom-thumbnail-big.jpg')
+    await processImage({ path: input, destination: imageDestJPG, newSize: thumbnailSize, keepOriginal: true })
+
+    await checkBuffers(input, imageDestJPG, false)
+  })
+
+  it('Should strip exif for a jpg file that can not be copied', async function () {
+    const input = buildAbsoluteFixturePath('exif.jpg')
+    expect(await hasTitleExif(input)).to.be.true
+
+    await processImage({ path: input, destination: imageDestJPG, newSize: { width: 100, height: 100 }, keepOriginal: true })
+    await checkBuffers(input, imageDestJPG, false)
+
+    expect(await hasTitleExif(imageDestJPG)).to.be.false
+  })
+
+  it('Should strip exif for a jpg file that could be copied', async function () {
+    const input = buildAbsoluteFixturePath('exif.jpg')
+    expect(await hasTitleExif(input)).to.be.true
+
+    await processImage({ path: input, destination: imageDestJPG, newSize: thumbnailSize, keepOriginal: true })
+    await checkBuffers(input, imageDestJPG, false)
+
+    expect(await hasTitleExif(imageDestJPG)).to.be.false
+  })
+
+  it('Should strip exif for png', async function () {
+    const input = buildAbsoluteFixturePath('exif.png')
+    expect(await hasTitleExif(input)).to.be.true
+
+    await processImage({ path: input, destination: imageDestPNG, newSize: thumbnailSize, keepOriginal: true })
+    expect(await hasTitleExif(imageDestPNG)).to.be.false
+  })
+
+  after(async function () {
+    await remove(imageDestDir)
+  })
+})
diff --git a/packages/tests/src/server-helpers/index.ts b/packages/tests/src/server-helpers/index.ts
new file mode 100644
index 000000000..04a26560c
--- /dev/null
+++ b/packages/tests/src/server-helpers/index.ts
@@ -0,0 +1,10 @@
+import './activitypub.js'
+import './core-utils.js'
+import './crypto.js'
+import './dns.js'
+import './image.js'
+import './markdown.js'
+import './mentions.js'
+import './request.js'
+import './validator.js'
+import './version.js'
diff --git a/packages/tests/src/server-helpers/markdown.ts b/packages/tests/src/server-helpers/markdown.ts
new file mode 100644
index 000000000..96e3c34dc
--- /dev/null
+++ b/packages/tests/src/server-helpers/markdown.ts
@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { mdToOneLinePlainText } from '@peertube/peertube-server/server/helpers/markdown.js'
+import { expect } from 'chai'
+
+describe('Markdown helpers', function () {
+
+  describe('Plain text', function () {
+
+    it('Should convert a list to plain text', function () {
+      const result = mdToOneLinePlainText(`* list 1
+* list 2
+* list 3`)
+
+      expect(result).to.equal('list 1, list 2, list 3')
+    })
+
+    it('Should convert a list with indentation to plain text', function () {
+      const result = mdToOneLinePlainText(`Hello:
+  * list 1
+  * list 2
+  * list 3`)
+
+      expect(result).to.equal('Hello: list 1, list 2, list 3')
+    })
+
+    it('Should convert HTML to plain text', function () {
+      const result = mdToOneLinePlainText(`**Hello** <strong>coucou</strong>`)
+
+      expect(result).to.equal('Hello coucou')
+    })
+
+    it('Should convert tags to plain text', function () {
+      const result = mdToOneLinePlainText(`#déconversion\n#newage\n#histoire`)
+
+      expect(result).to.equal('#déconversion #newage #histoire')
+    })
+  })
+})
diff --git a/packages/tests/src/server-helpers/mentions.ts b/packages/tests/src/server-helpers/mentions.ts
new file mode 100644
index 000000000..153931d60
--- /dev/null
+++ b/packages/tests/src/server-helpers/mentions.ts
@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { extractMentions } from '@peertube/peertube-server/server/helpers/mentions.js'
+
+describe('Comment model', function () {
+  it('Should correctly extract mentions', async function () {
+    const text = '@florian @jean@localhost:9000 @flo @another@localhost:9000 @flo2@jean.com hello ' +
+      'email@localhost:9000 coucou.com no? @chocobozzz @chocobozzz @end'
+
+    const isOwned = true
+
+    const result = extractMentions(text, isOwned).sort((a, b) => a.localeCompare(b))
+
+    expect(result).to.deep.equal([ 'another', 'chocobozzz', 'end', 'flo', 'florian', 'jean' ])
+  })
+})
diff --git a/packages/tests/src/server-helpers/request.ts b/packages/tests/src/server-helpers/request.ts
new file mode 100644
index 000000000..f4b9af52e
--- /dev/null
+++ b/packages/tests/src/server-helpers/request.ts
@@ -0,0 +1,64 @@
+/* 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 { root } from '@peertube/peertube-node-utils'
+import { doRequest, doRequestAndSaveToFile } from '@peertube/peertube-server/server/helpers/requests.js'
+import { Mock429 } from '@tests/shared/mock-servers/mock-429.js'
+import { FIXTURE_URLS } from '@tests/shared/tests.js'
+
+describe('Request helpers', function () {
+  const destPath1 = join(root(), 'test-output-1.txt')
+  const destPath2 = join(root(), 'test-output-2.txt')
+
+  it('Should throw an error when the bytes limit is exceeded for request', async function () {
+    try {
+      await doRequest(FIXTURE_URLS.file4K, { bodyKBLimit: 3 })
+    } catch {
+      return
+    }
+
+    throw new Error('No error thrown by do request')
+  })
+
+  it('Should throw an error when the bytes limit is exceeded for request and save file', async function () {
+    try {
+      await doRequestAndSaveToFile(FIXTURE_URLS.file4K, destPath1, { bodyKBLimit: 3 })
+    } catch {
+
+      await wait(500)
+      expect(await pathExists(destPath1)).to.be.false
+      return
+    }
+
+    throw new Error('No error thrown by do request and save to file')
+  })
+
+  it('Should correctly retry on 429 error', async function () {
+    this.timeout(25000)
+
+    const mock = new Mock429()
+    const port = await mock.initialize()
+
+    const before = new Date().getTime()
+    await doRequest('http://127.0.0.1:' + port)
+
+    expect(new Date().getTime() - before).to.be.greaterThan(2000)
+
+    await mock.terminate()
+  })
+
+  it('Should succeed if the file is below the limit', async function () {
+    await doRequest(FIXTURE_URLS.file4K, { bodyKBLimit: 5 })
+    await doRequestAndSaveToFile(FIXTURE_URLS.file4K, destPath2, { bodyKBLimit: 5 })
+
+    expect(await pathExists(destPath2)).to.be.true
+  })
+
+  after(async function () {
+    await remove(destPath1)
+    await remove(destPath2)
+  })
+})
diff --git a/packages/tests/src/server-helpers/validator.ts b/packages/tests/src/server-helpers/validator.ts
new file mode 100644
index 000000000..792bd501c
--- /dev/null
+++ b/packages/tests/src/server-helpers/validator.ts
@@ -0,0 +1,35 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import {
+  isPluginStableOrUnstableVersionValid,
+  isPluginStableVersionValid
+} from '@peertube/peertube-server/server/helpers/custom-validators/plugins.js'
+
+describe('Validators', function () {
+
+  it('Should correctly check stable plugin versions', async function () {
+    expect(isPluginStableVersionValid('3.4.0')).to.be.true
+    expect(isPluginStableVersionValid('0.4.0')).to.be.true
+    expect(isPluginStableVersionValid('0.1.0')).to.be.true
+
+    expect(isPluginStableVersionValid('0.1.0-beta-1')).to.be.false
+    expect(isPluginStableVersionValid('hello')).to.be.false
+    expect(isPluginStableVersionValid('0.x.a')).to.be.false
+  })
+
+  it('Should correctly check unstable plugin versions', async function () {
+    expect(isPluginStableOrUnstableVersionValid('3.4.0')).to.be.true
+    expect(isPluginStableOrUnstableVersionValid('0.4.0')).to.be.true
+    expect(isPluginStableOrUnstableVersionValid('0.1.0')).to.be.true
+
+    expect(isPluginStableOrUnstableVersionValid('0.1.0-beta.1')).to.be.true
+    expect(isPluginStableOrUnstableVersionValid('0.1.0-alpha.45')).to.be.true
+    expect(isPluginStableOrUnstableVersionValid('0.1.0-rc.45')).to.be.true
+
+    expect(isPluginStableOrUnstableVersionValid('hello')).to.be.false
+    expect(isPluginStableOrUnstableVersionValid('0.x.a')).to.be.false
+    expect(isPluginStableOrUnstableVersionValid('0.1.0-rc-45')).to.be.false
+    expect(isPluginStableOrUnstableVersionValid('0.1.0-rc.45d')).to.be.false
+  })
+})
diff --git a/packages/tests/src/server-helpers/version.ts b/packages/tests/src/server-helpers/version.ts
new file mode 100644
index 000000000..76892d1e7
--- /dev/null
+++ b/packages/tests/src/server-helpers/version.ts
@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { compareSemVer } from '@peertube/peertube-core-utils'
+
+describe('Version', function () {
+
+  it('Should correctly compare two stable versions', async function () {
+    expect(compareSemVer('3.4.0', '3.5.0')).to.be.below(0)
+    expect(compareSemVer('3.5.0', '3.4.0')).to.be.above(0)
+
+    expect(compareSemVer('3.4.0', '4.1.0')).to.be.below(0)
+    expect(compareSemVer('4.1.0', '3.4.0')).to.be.above(0)
+
+    expect(compareSemVer('3.4.0', '3.4.1')).to.be.below(0)
+    expect(compareSemVer('3.4.1', '3.4.0')).to.be.above(0)
+  })
+
+  it('Should correctly compare two unstable version', async function () {
+    expect(compareSemVer('3.4.0-alpha', '3.4.0-beta.1')).to.be.below(0)
+    expect(compareSemVer('3.4.0-alpha.1', '3.4.0-beta.1')).to.be.below(0)
+    expect(compareSemVer('3.4.0-beta.1', '3.4.0-beta.2')).to.be.below(0)
+    expect(compareSemVer('3.4.0-beta.1', '3.5.0-alpha.1')).to.be.below(0)
+
+    expect(compareSemVer('3.4.0-alpha.1', '3.4.0-nightly.4')).to.be.below(0)
+    expect(compareSemVer('3.4.0-nightly.3', '3.4.0-nightly.4')).to.be.below(0)
+    expect(compareSemVer('3.3.0-nightly.5', '3.4.0-nightly.4')).to.be.below(0)
+  })
+
+  it('Should correctly compare a stable and unstable versions', async function () {
+    expect(compareSemVer('3.4.0', '3.4.1-beta.1')).to.be.below(0)
+    expect(compareSemVer('3.4.0-beta.1', '3.4.0-beta.2')).to.be.below(0)
+    expect(compareSemVer('3.4.0-beta.1', '3.4.0')).to.be.below(0)
+    expect(compareSemVer('3.4.0-nightly.4', '3.4.0')).to.be.below(0)
+  })
+})