X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Ftests%2Fapi%2Fserver%2Ffollows-moderation.ts;h=45e56518a2196713c033153e3af8fe5bd56b7336;hb=7b97127e8ba718d673b8a43afa964d136723e6a2;hp=cee85cc4b22a50cc34bf052bc8074fa904466e06;hpb=818c449b3c34e9f324ac744120c8774e724ab25e;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/tests/api/server/follows-moderation.ts b/server/tests/api/server/follows-moderation.ts
index cee85cc4b..45e56518a 100644
--- a/server/tests/api/server/follows-moderation.ts
+++ b/server/tests/api/server/follows-moderation.ts
@@ -1,192 +1,369 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
-import * as chai from 'chai'
-import 'mocha'
+import { expect } from 'chai'
+import { expectStartWith } from '@server/tests/shared'
+import { ActorFollow, FollowState } from '@shared/models'
 import {
-  acceptFollower,
   cleanupTests,
-  flushAndRunMultipleServers,
-  ServerInfo,
+  createMultipleServers,
+  FollowsCommand,
+  PeerTubeServer,
   setAccessTokensToServers,
-  updateCustomSubConfig
-} from '../../../../shared/extra-utils/index'
-import {
-  follow,
-  getFollowersListPaginationAndSort,
-  getFollowingListPaginationAndSort,
-  rejectFollower,
-  removeFollower
-} from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { ActorFollow } from '../../../../shared/models/actors'
-
-const expect = chai.expect
-
-async function checkServer1And2HasFollowers (servers: ServerInfo[], state = 'accepted') {
-  {
-    const res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 5, sort: 'createdAt' })
-    expect(res.body.total).to.equal(1)
+  waitJobs
+} from '@shared/server-commands'
 
-    const follow = res.body.data[0] as ActorFollow
-    expect(follow.state).to.equal(state)
-    expect(follow.follower.url).to.equal('http://localhost:' + servers[0].port + '/accounts/peertube')
-    expect(follow.following.url).to.equal('http://localhost:' + servers[1].port + '/accounts/peertube')
-  }
+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)
+  ]
 
-  {
-    const res = await getFollowersListPaginationAndSort({ url: servers[1].url, start: 0, count: 5, sort: 'createdAt' })
-    expect(res.body.total).to.equal(1)
+  for (const fn of fns) {
+    const body = await fn({ start: 0, count: 5, sort: 'createdAt' })
+    expect(body.total).to.equal(1)
 
-    const follow = res.body.data[0] as ActorFollow
+    const follow = body.data[0]
     expect(follow.state).to.equal(state)
-    expect(follow.follower.url).to.equal('http://localhost:' + servers[0].port + '/accounts/peertube')
-    expect(follow.following.url).to.equal('http://localhost:' + servers[1].port + '/accounts/peertube')
+    expect(follow.follower.url).to.equal(servers[0].url + '/accounts/peertube')
+    expect(follow.following.url).to.equal(servers[1].url + '/accounts/peertube')
   }
 }
 
-async function checkNoFollowers (servers: ServerInfo[]) {
+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 res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 5, sort: 'createdAt' })
-    expect(res.body.total).to.equal(0)
+    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 res = await getFollowersListPaginationAndSort({ url: servers[1].url, start: 0, count: 5, sort: 'createdAt' })
-    expect(res.body.total).to.equal(0)
+    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: ServerInfo[] = []
+  let servers: PeerTubeServer[] = []
+  let commands: FollowsCommand[]
 
   before(async function () {
-    this.timeout(30000)
+    this.timeout(240000)
 
-    servers = await flushAndRunMultipleServers(3)
+    servers = await createMultipleServers(3)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
+
+    commands = servers.map(s => s.follows)
   })
 
-  it('Should have server 1 following server 2', async function () {
-    this.timeout(30000)
+  describe('Default behaviour', function () {
 
-    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
+    it('Should have server 1 following server 2', async function () {
+      this.timeout(30000)
 
-    await waitJobs(servers)
-  })
+      await commands[0].follow({ hosts: [ servers[1].url ] })
 
-  it('Should have correct follows', async function () {
-    await checkServer1And2HasFollowers(servers)
-  })
+      await waitJobs(servers)
+    })
 
-  it('Should remove follower on server 2', async function () {
-    await removeFollower(servers[1].url, servers[1].accessToken, servers[0])
+    it('Should have correct follows', async function () {
+      await checkServer1And2HasFollowers(servers)
+    })
 
-    await waitJobs(servers)
-  })
+    it('Should remove follower on server 2', async function () {
+      this.timeout(10000)
+
+      await commands[1].removeFollower({ follower: servers[0] })
+
+      await waitJobs(servers)
+    })
 
-  it('Should not not have follows anymore', async function () {
-    await checkNoFollowers(servers)
+    it('Should not not have follows anymore', async function () {
+      await checkNoFollowers(servers)
+    })
   })
 
-  it('Should disable followers on server 2', async function () {
-    const subConfig = {
-      followers: {
-        instance: {
-          enabled: false,
-          manualApproval: false
+  describe('Disabled/Enabled followers', function () {
+
+    it('Should disable followers on server 2', async function () {
+      this.timeout(10000)
+
+      const subConfig = {
+        followers: {
+          instance: {
+            enabled: false,
+            manualApproval: false
+          }
         }
       }
-    }
 
-    await updateCustomSubConfig(servers[1].url, servers[1].accessToken, subConfig)
+      await servers[1].config.updateCustomSubConfig({ newConfig: subConfig })
 
-    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
-    await waitJobs(servers)
+      await commands[0].follow({ hosts: [ servers[1].url ] })
+      await waitJobs(servers)
 
-    await checkNoFollowers(servers)
-  })
+      await checkNoFollowers(servers)
+    })
 
-  it('Should re enable followers on server 2', async function () {
-    const subConfig = {
-      followers: {
-        instance: {
-          enabled: true,
-          manualApproval: false
+    it('Should re enable followers on server 2', async function () {
+      this.timeout(10000)
+
+      const subConfig = {
+        followers: {
+          instance: {
+            enabled: true,
+            manualApproval: false
+          }
         }
       }
-    }
 
-    await updateCustomSubConfig(servers[1].url, servers[1].accessToken, subConfig)
+      await servers[1].config.updateCustomSubConfig({ newConfig: subConfig })
 
-    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
-    await waitJobs(servers)
+      await commands[0].follow({ hosts: [ servers[1].url ] })
+      await waitJobs(servers)
 
-    await checkServer1And2HasFollowers(servers)
+      await checkServer1And2HasFollowers(servers)
+    })
   })
 
-  it('Should manually approve followers', async function () {
-    this.timeout(20000)
+  describe('Manual approbation', function () {
 
-    await removeFollower(servers[1].url, servers[1].accessToken, servers[0])
-    await waitJobs(servers)
+    it('Should manually approve followers', async function () {
+      this.timeout(20000)
 
-    const subConfig = {
-      followers: {
-        instance: {
-          enabled: true,
-          manualApproval: true
+      await commands[0].unfollow({ target: servers[1] })
+      await waitJobs(servers)
+
+      const subConfig = {
+        followers: {
+          instance: {
+            enabled: true,
+            manualApproval: true
+          }
         }
       }
-    }
 
-    await updateCustomSubConfig(servers[1].url, servers[1].accessToken, subConfig)
-    await updateCustomSubConfig(servers[2].url, servers[2].accessToken, subConfig)
+      await servers[1].config.updateCustomSubConfig({ newConfig: subConfig })
+      await servers[2].config.updateCustomSubConfig({ newConfig: subConfig })
 
-    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
-    await waitJobs(servers)
+      await commands[0].follow({ hosts: [ servers[1].url ] })
+      await waitJobs(servers)
 
-    await checkServer1And2HasFollowers(servers, 'pending')
-  })
+      await checkServer1And2HasFollowers(servers, 'pending')
+    })
+
+    it('Should accept a follower', async function () {
+      this.timeout(10000)
+
+      await commands[1].acceptFollower({ follower: 'peertube@' + servers[0].host })
+      await waitJobs(servers)
 
-  it('Should accept a follower', async function () {
-    await acceptFollower(servers[1].url, servers[1].accessToken, 'peertube@localhost:' + servers[0].port)
-    await waitJobs(servers)
+      await checkServer1And2HasFollowers(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')
+    })
   })
 
-  it('Should reject another follower', async function () {
-    this.timeout(20000)
+  describe('Accept/reject state', function () {
 
-    await follow(servers[0].url, [ servers[2].url ], servers[0].accessToken)
-    await waitJobs(servers)
+    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)
 
-    {
-      const res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 5, sort: 'createdAt' })
-      expect(res.body.total).to.equal(2)
-    }
+        await checkFollows({
+          follower: servers[0],
+          followerState: 'rejected',
+          following: servers[2],
+          followingState: 'rejected'
+        })
+      }
 
-    {
-      const res = await getFollowersListPaginationAndSort({ url: servers[1].url, start: 0, count: 5, sort: 'createdAt' })
-      expect(res.body.total).to.equal(1)
-    }
+      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'
+      })
+    })
+  })
 
-    {
-      const res = await getFollowersListPaginationAndSort({ url: servers[2].url, start: 0, count: 5, sort: 'createdAt' })
-      expect(res.body.total).to.equal(1)
-    }
+  describe('Muted servers', function () {
 
-    await rejectFollower(servers[2].url, servers[2].accessToken, 'peertube@localhost:' + servers[0].port)
-    await waitJobs(servers)
+    it('Should ignore follow requests of muted servers', async function () {
+      await servers[1].blocklist.addToServerBlocklist({ server: servers[0].host })
 
-    await checkServer1And2HasFollowers(servers)
+      await commands[0].unfollow({ target: servers[1] })
 
-    {
-      const res = await getFollowersListPaginationAndSort({ url: servers[2].url, start: 0, count: 5, sort: 'createdAt' })
-      expect(res.body.total).to.equal(0)
-    }
+      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 () {