X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;ds=sidebyside;f=server%2Ftests%2Fapi%2Fserver%2Ffollows.ts;h=1ae1adb2d86cf33bec5de45a0b5fd54548cfd0e4;hb=8b381422b88a02a971f5e50422b5b4b79b1101e5;hp=527b54e1ed0a9b86e5724c2524746ae3321e45b1;hpb=94565d52bb2883e09f16d1363170ac9c0dccb7a1;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/tests/api/server/follows.ts b/server/tests/api/server/follows.ts
index 527b54e1e..1ae1adb2d 100644
--- a/server/tests/api/server/follows.ts
+++ b/server/tests/api/server/follows.ts
@@ -1,14 +1,13 @@
-/* tslint:disable:no-unused-expression */
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import * as chai from 'chai'
 import 'mocha'
 import { Video, VideoPrivacy } from '../../../../shared/models/videos'
 import { VideoComment, VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
-import { completeVideoCheck } from '../../../../shared/extra-utils'
+import { cleanupTests, completeVideoCheck, deleteVideoComment } from '../../../../shared/extra-utils'
 import {
   flushAndRunMultipleServers,
   getVideosList,
-  killallServers,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
@@ -50,7 +49,7 @@ describe('Test follows', function () {
 
   it('Should not have followers', async function () {
     for (const server of servers) {
-      const res = await getFollowersListPaginationAndSort(server.url, 0, 5, 'createdAt')
+      const res = await getFollowersListPaginationAndSort({ url: server.url, start: 0, count: 5, sort: 'createdAt' })
       const follows = res.body.data
 
       expect(res.body.total).to.equal(0)
@@ -61,7 +60,7 @@ describe('Test follows', function () {
 
   it('Should not have following', async function () {
     for (const server of servers) {
-      const res = await getFollowingListPaginationAndSort(server.url, 0, 5, 'createdAt')
+      const res = await getFollowingListPaginationAndSort({ url: server.url, start: 0, count: 5, sort: 'createdAt' })
       const follows = res.body.data
 
       expect(res.body.total).to.equal(0)
@@ -79,18 +78,18 @@ describe('Test follows', function () {
   })
 
   it('Should have 2 followings on server 1', async function () {
-    let res = await getFollowingListPaginationAndSort(servers[0].url, 0, 1, 'createdAt')
+    let res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 1, sort: 'createdAt' })
     let follows = res.body.data
 
     expect(res.body.total).to.equal(2)
     expect(follows).to.be.an('array')
     expect(follows.length).to.equal(1)
 
-    res = await getFollowingListPaginationAndSort(servers[0].url, 1, 1, 'createdAt')
+    res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 1, count: 1, sort: 'createdAt' })
     follows = follows.concat(res.body.data)
 
-    const server2Follow = follows.find(f => f.following.host === 'localhost:9002')
-    const server3Follow = follows.find(f => f.following.host === 'localhost:9003')
+    const server2Follow = follows.find(f => f.following.host === 'localhost:' + servers[1].port)
+    const server3Follow = follows.find(f => f.following.host === 'localhost:' + servers[2].port)
 
     expect(server2Follow).to.not.be.undefined
     expect(server3Follow).to.not.be.undefined
@@ -98,18 +97,59 @@ describe('Test follows', function () {
     expect(server3Follow.state).to.equal('accepted')
   })
 
-  it('Should search followings on server 1', async function () {
+  it('Should search/filter followings on server 1', async function () {
+    const sort = 'createdAt'
+    const start = 0
+    const count = 1
+    const url = servers[0].url
+
     {
-      const res = await getFollowingListPaginationAndSort(servers[ 0 ].url, 0, 1, 'createdAt', ':9002')
-      const follows = res.body.data
+      const search = ':' + servers[1].port
 
-      expect(res.body.total).to.equal(1)
-      expect(follows.length).to.equal(1)
-      expect(follows[ 0 ].following.host).to.equal('localhost:9002')
+      {
+        const res = await getFollowingListPaginationAndSort({ url, start, count, sort, search })
+        const follows = res.body.data
+
+        expect(res.body.total).to.equal(1)
+        expect(follows.length).to.equal(1)
+        expect(follows[0].following.host).to.equal('localhost:' + servers[1].port)
+      }
+
+      {
+        const res = await getFollowingListPaginationAndSort({ url, start, count, sort, search, state: 'accepted' })
+        expect(res.body.total).to.equal(1)
+        expect(res.body.data).to.have.lengthOf(1)
+      }
+
+      {
+        const res = await getFollowingListPaginationAndSort({ url, start, count, sort, search, state: 'accepted', actorType: 'Person' })
+        expect(res.body.total).to.equal(0)
+        expect(res.body.data).to.have.lengthOf(0)
+      }
+
+      {
+        const res = await getFollowingListPaginationAndSort({
+          url,
+          start,
+          count,
+          sort,
+          search,
+          state: 'accepted',
+          actorType: 'Application'
+        })
+        expect(res.body.total).to.equal(1)
+        expect(res.body.data).to.have.lengthOf(1)
+      }
+
+      {
+        const res = await getFollowingListPaginationAndSort({ url, start, count, sort, search, state: 'pending' })
+        expect(res.body.total).to.equal(0)
+        expect(res.body.data).to.have.lengthOf(0)
+      }
     }
 
     {
-      const res = await getFollowingListPaginationAndSort(servers[ 0 ].url, 0, 1, 'createdAt', 'bla')
+      const res = await getFollowingListPaginationAndSort({ url, start, count, sort, search: 'bla' })
       const follows = res.body.data
 
       expect(res.body.total).to.equal(0)
@@ -119,7 +159,7 @@ describe('Test follows', function () {
 
   it('Should have 0 followings on server 2 and 3', async function () {
     for (const server of [ servers[1], servers[2] ]) {
-      const res = await getFollowingListPaginationAndSort(server.url, 0, 5, 'createdAt')
+      const res = await getFollowingListPaginationAndSort({ url: server.url, start: 0, count: 5, sort: 'createdAt' })
       const follows = res.body.data
 
       expect(res.body.total).to.equal(0)
@@ -130,28 +170,69 @@ describe('Test follows', function () {
 
   it('Should have 1 followers on server 2 and 3', async function () {
     for (const server of [ servers[1], servers[2] ]) {
-      let res = await getFollowersListPaginationAndSort(server.url, 0, 1, 'createdAt')
+      const res = await getFollowersListPaginationAndSort({ url: server.url, start: 0, count: 1, sort: 'createdAt' })
 
-      let follows = res.body.data
+      const follows = res.body.data
       expect(res.body.total).to.equal(1)
       expect(follows).to.be.an('array')
       expect(follows.length).to.equal(1)
-      expect(follows[0].follower.host).to.equal('localhost:9001')
+      expect(follows[0].follower.host).to.equal('localhost:' + servers[0].port)
     }
   })
 
-  it('Should search followers on server 2', async function () {
+  it('Should search/filter followers on server 2', async function () {
+    const url = servers[2].url
+    const start = 0
+    const count = 5
+    const sort = 'createdAt'
+
     {
-      const res = await getFollowersListPaginationAndSort(servers[ 2 ].url, 0, 5, 'createdAt', '9001')
-      const follows = res.body.data
+      const search = servers[0].port + ''
 
-      expect(res.body.total).to.equal(1)
-      expect(follows.length).to.equal(1)
-      expect(follows[ 0 ].following.host).to.equal('localhost:9003')
+      {
+        const res = await getFollowersListPaginationAndSort({ url, start, count, sort, search })
+        const follows = res.body.data
+
+        expect(res.body.total).to.equal(1)
+        expect(follows.length).to.equal(1)
+        expect(follows[0].following.host).to.equal('localhost:' + servers[2].port)
+      }
+
+      {
+        const res = await getFollowersListPaginationAndSort({ url, start, count, sort, search, state: 'accepted' })
+        expect(res.body.total).to.equal(1)
+        expect(res.body.data).to.have.lengthOf(1)
+      }
+
+      {
+        const res = await getFollowersListPaginationAndSort({ url, start, count, sort, search, state: 'accepted', actorType: 'Person' })
+        expect(res.body.total).to.equal(0)
+        expect(res.body.data).to.have.lengthOf(0)
+      }
+
+      {
+        const res = await getFollowersListPaginationAndSort({
+          url,
+          start,
+          count,
+          sort,
+          search,
+          state: 'accepted',
+          actorType: 'Application'
+        })
+        expect(res.body.total).to.equal(1)
+        expect(res.body.data).to.have.lengthOf(1)
+      }
+
+      {
+        const res = await getFollowersListPaginationAndSort({ url, start, count, sort, search, state: 'pending' })
+        expect(res.body.total).to.equal(0)
+        expect(res.body.data).to.have.lengthOf(0)
+      }
     }
 
     {
-      const res = await getFollowersListPaginationAndSort(servers[ 2 ].url, 0, 5, 'createdAt', 'bla')
+      const res = await getFollowersListPaginationAndSort({ url, start, count, sort, search: 'bla' })
       const follows = res.body.data
 
       expect(res.body.total).to.equal(0)
@@ -160,7 +241,7 @@ describe('Test follows', function () {
   })
 
   it('Should have 0 followers on server 1', async function () {
-    const res = await getFollowersListPaginationAndSort(servers[0].url, 0, 5, 'createdAt')
+    const res = await getFollowersListPaginationAndSort({ url: servers[0].url, start: 0, count: 5, sort: 'createdAt' })
     const follows = res.body.data
 
     expect(res.body.total).to.equal(0)
@@ -169,16 +250,16 @@ describe('Test follows', function () {
   })
 
   it('Should have the correct follows counts', async function () {
-    await expectAccountFollows(servers[0].url, 'peertube@localhost:9001', 0, 2)
-    await expectAccountFollows(servers[0].url, 'peertube@localhost:9002', 1, 0)
-    await expectAccountFollows(servers[0].url, 'peertube@localhost:9003', 1, 0)
+    await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[0].port, 0, 2)
+    await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[1].port, 1, 0)
+    await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[2].port, 1, 0)
 
     // Server 2 and 3 does not know server 1 follow another server (there was not a refresh)
-    await expectAccountFollows(servers[1].url, 'peertube@localhost:9001', 0, 1)
-    await expectAccountFollows(servers[1].url, 'peertube@localhost:9002', 1, 0)
+    await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[0].port, 0, 1)
+    await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[1].port, 1, 0)
 
-    await expectAccountFollows(servers[2].url, 'peertube@localhost:9001', 0, 1)
-    await expectAccountFollows(servers[2].url, 'peertube@localhost:9003', 1, 0)
+    await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[0].port, 0, 1)
+    await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[2].port, 1, 0)
   })
 
   it('Should unfollow server 3 on server 1', async function () {
@@ -190,34 +271,34 @@ describe('Test follows', function () {
   })
 
   it('Should not follow server 3 on server 1 anymore', async function () {
-    const res = await getFollowingListPaginationAndSort(servers[0].url, 0, 2, 'createdAt')
-    let follows = res.body.data
+    const res = await getFollowingListPaginationAndSort({ url: servers[0].url, start: 0, count: 2, sort: 'createdAt' })
+    const follows = res.body.data
 
     expect(res.body.total).to.equal(1)
     expect(follows).to.be.an('array')
     expect(follows.length).to.equal(1)
 
-    expect(follows[0].following.host).to.equal('localhost:9002')
+    expect(follows[0].following.host).to.equal('localhost:' + servers[1].port)
   })
 
   it('Should not have server 1 as follower on server 3 anymore', async function () {
-    const res = await getFollowersListPaginationAndSort(servers[2].url, 0, 1, 'createdAt')
+    const res = await getFollowersListPaginationAndSort({ url: servers[2].url, start: 0, count: 1, sort: 'createdAt' })
 
-    let follows = res.body.data
+    const follows = res.body.data
     expect(res.body.total).to.equal(0)
     expect(follows).to.be.an('array')
     expect(follows.length).to.equal(0)
   })
 
   it('Should have the correct follows counts 2', async function () {
-    await expectAccountFollows(servers[0].url, 'peertube@localhost:9001', 0, 1)
-    await expectAccountFollows(servers[0].url, 'peertube@localhost:9002', 1, 0)
+    await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[0].port, 0, 1)
+    await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[1].port, 1, 0)
 
-    await expectAccountFollows(servers[1].url, 'peertube@localhost:9001', 0, 1)
-    await expectAccountFollows(servers[1].url, 'peertube@localhost:9002', 1, 0)
+    await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[0].port, 0, 1)
+    await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[1].port, 1, 0)
 
-    await expectAccountFollows(servers[2].url, 'peertube@localhost:9001', 0, 0)
-    await expectAccountFollows(servers[2].url, 'peertube@localhost:9003', 0, 0)
+    await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[0].port, 0, 0)
+    await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[2].port, 0, 0)
   })
 
   it('Should upload a video on server 2 and 3 and propagate only the video of server 2', async function () {
@@ -245,7 +326,7 @@ describe('Test follows', function () {
     let video4: Video
 
     before(async function () {
-      this.timeout(20000)
+      this.timeout(50000)
 
       const video4Attributes = {
         name: 'server3-4',
@@ -255,39 +336,60 @@ describe('Test follows', function () {
         tags: [ 'tag1', 'tag2', 'tag3' ]
       }
 
-      await uploadVideo(servers[ 2 ].url, servers[ 2 ].accessToken, { name: 'server3-2' })
-      await uploadVideo(servers[ 2 ].url, servers[ 2 ].accessToken, { name: 'server3-3' })
-      await uploadVideo(servers[ 2 ].url, servers[ 2 ].accessToken, video4Attributes)
-      await uploadVideo(servers[ 2 ].url, servers[ 2 ].accessToken, { name: 'server3-5' })
-      await uploadVideo(servers[ 2 ].url, servers[ 2 ].accessToken, { name: 'server3-6' })
+      await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-2' })
+      await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-3' })
+      await uploadVideo(servers[2].url, servers[2].accessToken, video4Attributes)
+      await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-5' })
+      await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-6' })
 
       {
         const user = { username: 'captain', password: 'password' }
-        await createUser({ url: servers[ 2 ].url, accessToken: servers[ 2 ].accessToken, username: user.username, password: user.password })
-        const userAccessToken = await userLogin(servers[ 2 ], user)
+        await createUser({ url: servers[2].url, accessToken: servers[2].accessToken, username: user.username, password: user.password })
+        const userAccessToken = await userLogin(servers[2], user)
 
-        const resVideos = await getVideosList(servers[ 2 ].url)
+        const resVideos = await getVideosList(servers[2].url)
         video4 = resVideos.body.data.find(v => v.name === 'server3-4')
 
         {
-          await rateVideo(servers[ 2 ].url, servers[ 2 ].accessToken, video4.id, 'like')
-          await rateVideo(servers[ 2 ].url, userAccessToken, video4.id, 'dislike')
+          await rateVideo(servers[2].url, servers[2].accessToken, video4.id, 'like')
+          await rateVideo(servers[2].url, userAccessToken, video4.id, 'dislike')
         }
 
         {
-          const text = 'my super first comment'
-          const res = await addVideoCommentThread(servers[ 2 ].url, servers[ 2 ].accessToken, video4.id, text)
-          const threadId = res.body.comment.id
+          {
+            const text = 'my super first comment'
+            const res = await addVideoCommentThread(servers[2].url, servers[2].accessToken, video4.id, text)
+            const threadId = res.body.comment.id
 
-          const text1 = 'my super answer to thread 1'
-          const childCommentRes = await addVideoCommentReply(servers[ 2 ].url, servers[ 2 ].accessToken, video4.id, threadId, text1)
-          const childCommentId = childCommentRes.body.comment.id
+            const text1 = 'my super answer to thread 1'
+            const childCommentRes = await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, threadId, text1)
+            const childCommentId = childCommentRes.body.comment.id
 
-          const text2 = 'my super answer to answer of thread 1'
-          await addVideoCommentReply(servers[ 2 ].url, servers[ 2 ].accessToken, video4.id, childCommentId, text2)
+            const text2 = 'my super answer to answer of thread 1'
+            await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, childCommentId, text2)
 
-          const text3 = 'my second answer to thread 1'
-          await addVideoCommentReply(servers[ 2 ].url, servers[ 2 ].accessToken, video4.id, threadId, text3)
+            const text3 = 'my second answer to thread 1'
+            await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, threadId, text3)
+          }
+
+          {
+            const text = 'will be deleted'
+            const res = await addVideoCommentThread(servers[2].url, servers[2].accessToken, video4.id, text)
+            const threadId = res.body.comment.id
+
+            const text1 = 'answer to deleted'
+            await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, threadId, text1)
+
+            const text2 = 'will also be deleted'
+            const childCommentRes = await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, threadId, text2)
+            const childCommentId = childCommentRes.body.comment.id
+
+            const text3 = 'my second answer to deleted'
+            await addVideoCommentReply(servers[2].url, servers[2].accessToken, video4.id, childCommentId, text3)
+
+            await deleteVideoComment(servers[2].url, servers[2].accessToken, video4.id, threadId)
+            await deleteVideoComment(servers[2].url, servers[2].accessToken, video4.id, childCommentId)
+          }
         }
 
         {
@@ -304,25 +406,25 @@ describe('Test follows', function () {
       await waitJobs(servers)
 
       // Server 1 follows server 3
-      await follow(servers[ 0 ].url, [ servers[ 2 ].url ], servers[ 0 ].accessToken)
+      await follow(servers[0].url, [ servers[2].url ], servers[0].accessToken)
 
       await waitJobs(servers)
     })
 
     it('Should have the correct follows counts 3', async function () {
-      await expectAccountFollows(servers[0].url, 'peertube@localhost:9001', 0, 2)
-      await expectAccountFollows(servers[0].url, 'peertube@localhost:9002', 1, 0)
-      await expectAccountFollows(servers[0].url, 'peertube@localhost:9003', 1, 0)
+      await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[0].port, 0, 2)
+      await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[1].port, 1, 0)
+      await expectAccountFollows(servers[0].url, 'peertube@localhost:' + servers[2].port, 1, 0)
 
-      await expectAccountFollows(servers[1].url, 'peertube@localhost:9001', 0, 1)
-      await expectAccountFollows(servers[1].url, 'peertube@localhost:9002', 1, 0)
+      await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[0].port, 0, 1)
+      await expectAccountFollows(servers[1].url, 'peertube@localhost:' + servers[1].port, 1, 0)
 
-      await expectAccountFollows(servers[2].url, 'peertube@localhost:9001', 0, 2)
-      await expectAccountFollows(servers[2].url, 'peertube@localhost:9003', 1, 0)
+      await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[0].port, 0, 1)
+      await expectAccountFollows(servers[2].url, 'peertube@localhost:' + servers[2].port, 1, 0)
     })
 
     it('Should have propagated videos', async function () {
-      const res = await getVideosList(servers[ 0 ].url)
+      const res = await getVideosList(servers[0].url)
       expect(res.body.total).to.equal(7)
 
       const video2 = res.body.data.find(v => v.name === 'server3-2')
@@ -344,7 +446,7 @@ describe('Test follows', function () {
         support: 'my super support text',
         account: {
           name: 'root',
-          host: 'localhost:9003'
+          host: 'localhost:' + servers[2].port
         },
         isLocal,
         commentsEnabled: true,
@@ -368,46 +470,84 @@ describe('Test follows', function () {
           }
         ]
       }
-      await completeVideoCheck(servers[ 0 ].url, video4, checkAttributes)
+      await completeVideoCheck(servers[0].url, video4, checkAttributes)
     })
 
     it('Should have propagated comments', async function () {
-      const res1 = await getVideoCommentThreads(servers[0].url, video4.id, 0, 5)
+      const res1 = await getVideoCommentThreads(servers[0].url, video4.id, 0, 5, 'createdAt')
 
-      expect(res1.body.total).to.equal(1)
+      expect(res1.body.total).to.equal(2)
       expect(res1.body.data).to.be.an('array')
-      expect(res1.body.data).to.have.lengthOf(1)
-
-      const comment: VideoComment = res1.body.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('localhost:9003')
-      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 res2 = await getVideoThreadComments(servers[0].url, video4.id, threadId)
-
-      const tree: VideoCommentThreadTree = res2.body
-      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)
+      expect(res1.body.data).to.have.lengthOf(2)
+
+      {
+        const comment: VideoComment = res1.body.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('localhost:' + servers[2].port)
+        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 res2 = await getVideoThreadComments(servers[0].url, video4.id, threadId)
+
+        const tree: VideoCommentThreadTree = res2.body
+        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: VideoComment = res1.body.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(3)
+        expect(dateIsValid(deletedComment.deletedAt as string)).to.be.true
+
+        const res2 = await getVideoThreadComments(servers[0].url, video4.id, deletedComment.threadId)
+
+        const tree: VideoCommentThreadTree = res2.body
+        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 () {
@@ -429,13 +569,13 @@ describe('Test follows', function () {
 
       await waitJobs(servers)
 
-      let res = await getVideosList(servers[ 0 ].url)
+      const res = await getVideosList(servers[0].url)
       expect(res.body.total).to.equal(1)
     })
 
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })