Merge branch 'feature/esm-and-nx' into develop

5 files changed, 664 insertions, 0 deletions

diff --git a/packages/tests/src/external-plugins/akismet.ts b/packages/tests/src/external-plugins/akismet.ts
new file mode 100644
index 000000000..c6d3b7752
--- /dev/null
+++ b/packages/tests/src/external-plugins/akismet.ts
@@ -0,0 +1,160 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { HttpStatusCode } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Official plugin Akismet', function () {
+  let servers: PeerTubeServer[]
+  let videoUUID: string
+
+  before(async function () {
+    this.timeout(30000)
+
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    await servers[0].plugins.install({
+      npmName: 'peertube-plugin-akismet'
+    })
+
+    if (!process.env.AKISMET_KEY) throw new Error('Missing AKISMET_KEY from env')
+
+    await servers[0].plugins.updateSettings({
+      npmName: 'peertube-plugin-akismet',
+      settings: {
+        'akismet-api-key': process.env.AKISMET_KEY
+      }
+    })
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  describe('Local threads/replies', function () {
+
+    before(async function () {
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'video 1' })
+      videoUUID = uuid
+    })
+
+    it('Should not detect a thread as spam', async function () {
+      await servers[0].comments.createThread({ videoId: videoUUID, text: 'comment' })
+    })
+
+    it('Should not detect a reply as spam', async function () {
+      await servers[0].comments.addReplyToLastThread({ text: 'reply' })
+    })
+
+    it('Should detect a thread as spam', async function () {
+      await servers[0].comments.createThread({
+        videoId: videoUUID,
+        text: 'akismet-guaranteed-spam',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should detect a thread as spam', async function () {
+      await servers[0].comments.createThread({ videoId: videoUUID, text: 'comment' })
+      await servers[0].comments.addReplyToLastThread({ text: 'akismet-guaranteed-spam', expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+    })
+  })
+
+  describe('Remote threads/replies', function () {
+
+    before(async function () {
+      this.timeout(60000)
+
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'video 1' })
+      videoUUID = uuid
+
+      await waitJobs(servers)
+    })
+
+    it('Should not detect a thread as spam', async function () {
+      this.timeout(30000)
+
+      await servers[1].comments.createThread({ videoId: videoUUID, text: 'remote comment 1' })
+      await waitJobs(servers)
+
+      const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
+      expect(data).to.have.lengthOf(1)
+    })
+
+    it('Should not detect a reply as spam', async function () {
+      this.timeout(30000)
+
+      await servers[1].comments.addReplyToLastThread({ text: 'I agree with you' })
+      await waitJobs(servers)
+
+      const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
+      expect(data).to.have.lengthOf(1)
+
+      const tree = await servers[0].comments.getThread({ videoId: videoUUID, threadId: data[0].id })
+      expect(tree.children).to.have.lengthOf(1)
+    })
+
+    it('Should detect a thread as spam', async function () {
+      this.timeout(30000)
+
+      await servers[1].comments.createThread({ videoId: videoUUID, text: 'akismet-guaranteed-spam' })
+      await waitJobs(servers)
+
+      const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
+      expect(data).to.have.lengthOf(1)
+    })
+
+    it('Should detect a thread as spam', async function () {
+      this.timeout(30000)
+
+      await servers[1].comments.addReplyToLastThread({ text: 'akismet-guaranteed-spam' })
+      await waitJobs(servers)
+
+      const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
+      expect(data).to.have.lengthOf(1)
+
+      const thread = data[0]
+      const tree = await servers[0].comments.getThread({ videoId: videoUUID, threadId: thread.id })
+      expect(tree.children).to.have.lengthOf(1)
+    })
+  })
+
+  describe('Signup', function () {
+
+    before(async function () {
+      await servers[0].config.updateExistingSubConfig({
+        newConfig: {
+          signup: {
+            enabled: true
+          }
+        }
+      })
+    })
+
+    it('Should allow signup', async function () {
+      await servers[0].registrations.register({
+        username: 'user1',
+        displayName: 'user 1'
+      })
+    })
+
+    it('Should detect a signup as SPAM', async function () {
+      await servers[0].registrations.register({
+        username: 'user2',
+        displayName: 'user 2',
+        email: 'akismet-guaranteed-spam@example.com',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/external-plugins/auth-ldap.ts b/packages/tests/src/external-plugins/auth-ldap.ts
new file mode 100644
index 000000000..ad058110c
--- /dev/null
+++ b/packages/tests/src/external-plugins/auth-ldap.ts
@@ -0,0 +1,117 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@peertube/peertube-server-commands'
+import { HttpStatusCode } from '@peertube/peertube-models'
+
+describe('Official plugin auth-ldap', function () {
+  let server: PeerTubeServer
+  let accessToken: string
+  let userId: number
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1)
+    await setAccessTokensToServers([ server ])
+
+    await server.plugins.install({ npmName: 'peertube-plugin-auth-ldap' })
+  })
+
+  it('Should not login with without LDAP settings', async function () {
+    await server.login.login({ user: { username: 'fry', password: 'fry' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+  })
+
+  it('Should not login with bad LDAP settings', async function () {
+    await server.plugins.updateSettings({
+      npmName: 'peertube-plugin-auth-ldap',
+      settings: {
+        'bind-credentials': 'GoodNewsEveryone',
+        'bind-dn': 'cn=admin,dc=planetexpress,dc=com',
+        'insecure-tls': false,
+        'mail-property': 'mail',
+        'search-base': 'ou=people,dc=planetexpress,dc=com',
+        'search-filter': '(|(mail={{username}})(uid={{username}}))',
+        'url': 'ldap://127.0.0.1:390',
+        'username-property': 'uid'
+      }
+    })
+
+    await server.login.login({ user: { username: 'fry', password: 'fry' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+  })
+
+  it('Should not login with good LDAP settings but wrong username/password', async function () {
+    await server.plugins.updateSettings({
+      npmName: 'peertube-plugin-auth-ldap',
+      settings: {
+        'bind-credentials': 'GoodNewsEveryone',
+        'bind-dn': 'cn=admin,dc=planetexpress,dc=com',
+        'insecure-tls': false,
+        'mail-property': 'mail',
+        'search-base': 'ou=people,dc=planetexpress,dc=com',
+        'search-filter': '(|(mail={{username}})(uid={{username}}))',
+        'url': 'ldap://127.0.0.1:10389',
+        'username-property': 'uid'
+      }
+    })
+
+    await server.login.login({ user: { username: 'fry', password: 'bad password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    await server.login.login({ user: { username: 'fryr', password: 'fry' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+  })
+
+  it('Should login with the appropriate username/password', async function () {
+    accessToken = await server.login.getAccessToken({ username: 'fry', password: 'fry' })
+  })
+
+  it('Should login with the appropriate email/password', async function () {
+    accessToken = await server.login.getAccessToken({ username: 'fry@planetexpress.com', password: 'fry' })
+  })
+
+  it('Should login get my profile', async function () {
+    const body = await server.users.getMyInfo({ token: accessToken })
+    expect(body.username).to.equal('fry')
+    expect(body.email).to.equal('fry@planetexpress.com')
+
+    userId = body.id
+  })
+
+  it('Should upload a video', async function () {
+    await server.videos.upload({ token: accessToken, attributes: { name: 'my super video' } })
+  })
+
+  it('Should not be able to login if the user is banned', async function () {
+    await server.users.banUser({ userId })
+
+    await server.login.login({
+      user: { username: 'fry@planetexpress.com', password: 'fry' },
+      expectedStatus: HttpStatusCode.BAD_REQUEST_400
+    })
+  })
+
+  it('Should be able to login if the user is unbanned', async function () {
+    await server.users.unbanUser({ userId })
+
+    await server.login.login({ user: { username: 'fry@planetexpress.com', password: 'fry' } })
+  })
+
+  it('Should not be able to ask password reset', async function () {
+    await server.users.askResetPassword({ email: 'fry@planetexpress.com', expectedStatus: HttpStatusCode.CONFLICT_409 })
+  })
+
+  it('Should not be able to ask email verification', async function () {
+    await server.users.askSendVerifyEmail({ email: 'fry@planetexpress.com', expectedStatus: HttpStatusCode.CONFLICT_409 })
+  })
+
+  it('Should not login if the plugin is uninstalled', async function () {
+    await server.plugins.uninstall({ npmName: 'peertube-plugin-auth-ldap' })
+
+    await server.login.login({
+      user: { username: 'fry@planetexpress.com', password: 'fry' },
+      expectedStatus: HttpStatusCode.BAD_REQUEST_400
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/external-plugins/auto-block-videos.ts b/packages/tests/src/external-plugins/auto-block-videos.ts
new file mode 100644
index 000000000..6146c827c
--- /dev/null
+++ b/packages/tests/src/external-plugins/auto-block-videos.ts
@@ -0,0 +1,167 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { Video } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  killallServers,
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@peertube/peertube-server-commands'
+import { MockBlocklist } from '../shared/mock-servers/index.js'
+
+async function check (server: PeerTubeServer, videoUUID: string, exists = true) {
+  const { data } = await server.videos.list()
+
+  const video = data.find(v => v.uuid === videoUUID)
+
+  if (exists) expect(video).to.not.be.undefined
+  else expect(video).to.be.undefined
+}
+
+describe('Official plugin auto-block videos', function () {
+  let servers: PeerTubeServer[]
+  let blocklistServer: MockBlocklist
+  let server1Videos: Video[] = []
+  let server2Videos: Video[] = []
+  let port: number
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    for (const server of servers) {
+      await server.plugins.install({ npmName: 'peertube-plugin-auto-block-videos' })
+    }
+
+    blocklistServer = new MockBlocklist()
+    port = await blocklistServer.initialize()
+
+    await servers[0].videos.quickUpload({ name: 'video server 1' })
+    await servers[1].videos.quickUpload({ name: 'video server 2' })
+    await servers[1].videos.quickUpload({ name: 'video 2 server 2' })
+    await servers[1].videos.quickUpload({ name: 'video 3 server 2' })
+
+    {
+      const { data } = await servers[0].videos.list()
+      server1Videos = data.map(v => Object.assign(v, { url: servers[0].url + '/videos/watch/' + v.uuid }))
+    }
+
+    {
+      const { data } = await servers[1].videos.list()
+      server2Videos = data.map(v => Object.assign(v, { url: servers[1].url + '/videos/watch/' + v.uuid }))
+    }
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  it('Should update plugin settings', async function () {
+    await servers[0].plugins.updateSettings({
+      npmName: 'peertube-plugin-auto-block-videos',
+      settings: {
+        'blocklist-urls': `http://127.0.0.1:${port}/blocklist`,
+        'check-seconds-interval': 1
+      }
+    })
+  })
+
+  it('Should auto block a video', async function () {
+    await check(servers[0], server2Videos[0].uuid, true)
+
+    blocklistServer.replace({
+      data: [
+        {
+          value: server2Videos[0].url
+        }
+      ]
+    })
+
+    await wait(2000)
+
+    await check(servers[0], server2Videos[0].uuid, false)
+  })
+
+  it('Should have video in blacklists', async function () {
+    const body = await servers[0].blacklist.list()
+
+    const videoBlacklists = body.data
+    expect(videoBlacklists).to.have.lengthOf(1)
+    expect(videoBlacklists[0].reason).to.contains('Automatically blocked from auto block plugin')
+    expect(videoBlacklists[0].video.name).to.equal(server2Videos[0].name)
+  })
+
+  it('Should not block a local video', async function () {
+    await check(servers[0], server1Videos[0].uuid, true)
+
+    blocklistServer.replace({
+      data: [
+        {
+          value: server1Videos[0].url
+        }
+      ]
+    })
+
+    await wait(2000)
+
+    await check(servers[0], server1Videos[0].uuid, true)
+  })
+
+  it('Should remove a video block', async function () {
+    await check(servers[0], server2Videos[0].uuid, false)
+
+    blocklistServer.replace({
+      data: [
+        {
+          value: server2Videos[0].url,
+          action: 'remove'
+        }
+      ]
+    })
+
+    await wait(2000)
+
+    await check(servers[0], server2Videos[0].uuid, true)
+  })
+
+  it('Should auto block a video, manually unblock it and do not reblock it automatically', async function () {
+    this.timeout(20000)
+
+    const video = server2Videos[1]
+
+    await check(servers[0], video.uuid, true)
+
+    blocklistServer.replace({
+      data: [
+        {
+          value: video.url,
+          updatedAt: new Date().toISOString()
+        }
+      ]
+    })
+
+    await wait(2000)
+
+    await check(servers[0], video.uuid, false)
+
+    await servers[0].blacklist.remove({ videoId: video.uuid })
+
+    await check(servers[0], video.uuid, true)
+
+    await killallServers([ servers[0] ])
+    await servers[0].run()
+    await wait(2000)
+
+    await check(servers[0], video.uuid, true)
+  })
+
+  after(async function () {
+    await blocklistServer.terminate()
+
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/external-plugins/auto-mute.ts b/packages/tests/src/external-plugins/auto-mute.ts
new file mode 100644
index 000000000..b4050e236
--- /dev/null
+++ b/packages/tests/src/external-plugins/auto-mute.ts
@@ -0,0 +1,216 @@
+/* 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,
+  createMultipleServers,
+  doubleFollow,
+  killallServers,
+  makeGetRequest,
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@peertube/peertube-server-commands'
+import { MockBlocklist } from '../shared/mock-servers/index.js'
+
+describe('Official plugin auto-mute', function () {
+  const autoMuteListPath = '/plugins/auto-mute/router/api/v1/mute-list'
+  let servers: PeerTubeServer[]
+  let blocklistServer: MockBlocklist
+  let port: number
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    for (const server of servers) {
+      await server.plugins.install({ npmName: 'peertube-plugin-auto-mute' })
+    }
+
+    blocklistServer = new MockBlocklist()
+    port = await blocklistServer.initialize()
+
+    await servers[0].videos.quickUpload({ name: 'video server 1' })
+    await servers[1].videos.quickUpload({ name: 'video server 2' })
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  it('Should update plugin settings', async function () {
+    await servers[0].plugins.updateSettings({
+      npmName: 'peertube-plugin-auto-mute',
+      settings: {
+        'blocklist-urls': `http://127.0.0.1:${port}/blocklist`,
+        'check-seconds-interval': 1
+      }
+    })
+  })
+
+  it('Should add a server blocklist', async function () {
+    blocklistServer.replace({
+      data: [
+        {
+          value: servers[1].host
+        }
+      ]
+    })
+
+    await wait(2000)
+
+    const { total } = await servers[0].videos.list()
+    expect(total).to.equal(1)
+  })
+
+  it('Should remove a server blocklist', async function () {
+    blocklistServer.replace({
+      data: [
+        {
+          value: servers[1].host,
+          action: 'remove'
+        }
+      ]
+    })
+
+    await wait(2000)
+
+    const { total } = await servers[0].videos.list()
+    expect(total).to.equal(2)
+  })
+
+  it('Should add an account blocklist', async function () {
+    blocklistServer.replace({
+      data: [
+        {
+          value: 'root@' + servers[1].host
+        }
+      ]
+    })
+
+    await wait(2000)
+
+    const { total } = await servers[0].videos.list()
+    expect(total).to.equal(1)
+  })
+
+  it('Should remove an account blocklist', async function () {
+    blocklistServer.replace({
+      data: [
+        {
+          value: 'root@' + servers[1].host,
+          action: 'remove'
+        }
+      ]
+    })
+
+    await wait(2000)
+
+    const { total } = await servers[0].videos.list()
+    expect(total).to.equal(2)
+  })
+
+  it('Should auto mute an account, manually unmute it and do not remute it automatically', async function () {
+    this.timeout(20000)
+
+    const account = 'root@' + servers[1].host
+
+    blocklistServer.replace({
+      data: [
+        {
+          value: account,
+          updatedAt: new Date().toISOString()
+        }
+      ]
+    })
+
+    await wait(2000)
+
+    {
+      const { total } = await servers[0].videos.list()
+      expect(total).to.equal(1)
+    }
+
+    await servers[0].blocklist.removeFromServerBlocklist({ account })
+
+    {
+      const { total } = await servers[0].videos.list()
+      expect(total).to.equal(2)
+    }
+
+    await killallServers([ servers[0] ])
+    await servers[0].run()
+    await wait(2000)
+
+    {
+      const { total } = await servers[0].videos.list()
+      expect(total).to.equal(2)
+    }
+  })
+
+  it('Should not expose the auto mute list', async function () {
+    await makeGetRequest({
+      url: servers[0].url,
+      path: '/plugins/auto-mute/router/api/v1/mute-list',
+      expectedStatus: HttpStatusCode.FORBIDDEN_403
+    })
+  })
+
+  it('Should enable auto mute list', async function () {
+    await servers[0].plugins.updateSettings({
+      npmName: 'peertube-plugin-auto-mute',
+      settings: {
+        'blocklist-urls': '',
+        'check-seconds-interval': 1,
+        'expose-mute-list': true
+      }
+    })
+
+    await makeGetRequest({
+      url: servers[0].url,
+      path: '/plugins/auto-mute/router/api/v1/mute-list',
+      expectedStatus: HttpStatusCode.OK_200
+    })
+  })
+
+  it('Should mute an account on server 1, and server 2 auto mutes it', async function () {
+    this.timeout(20000)
+
+    await servers[1].plugins.updateSettings({
+      npmName: 'peertube-plugin-auto-mute',
+      settings: {
+        'blocklist-urls': 'http://' + servers[0].host + autoMuteListPath,
+        'check-seconds-interval': 1,
+        'expose-mute-list': false
+      }
+    })
+
+    await servers[0].blocklist.addToServerBlocklist({ account: 'root@' + servers[1].host })
+    await servers[0].blocklist.addToMyBlocklist({ server: servers[1].host })
+
+    const res = await makeGetRequest({
+      url: servers[0].url,
+      path: '/plugins/auto-mute/router/api/v1/mute-list',
+      expectedStatus: HttpStatusCode.OK_200
+    })
+
+    const data = res.body.data
+    expect(data).to.have.lengthOf(1)
+    expect(data[0].updatedAt).to.exist
+    expect(data[0].value).to.equal('root@' + servers[1].host)
+
+    await wait(2000)
+
+    for (const server of servers) {
+      const { total } = await server.videos.list()
+      expect(total).to.equal(1)
+    }
+  })
+
+  after(async function () {
+    await blocklistServer.terminate()
+
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/external-plugins/index.ts b/packages/tests/src/external-plugins/index.ts
new file mode 100644
index 000000000..815bbf1da
--- /dev/null
+++ b/packages/tests/src/external-plugins/index.ts
@@ -0,0 +1,4 @@
+import './akismet'
+import './auth-ldap'
+import './auto-block-videos'
+import './auto-mute'