server/tests/api/server/follows.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import * as chai from 'chai'
   5 import {
   6   cleanupTests,
   7   completeVideoCheck,
   8   createUser,
   9   dateIsValid,
  10   expectAccountFollows,
  11   flushAndRunMultipleServers,
  12   FollowsCommand,
  13   getVideosList,
  14   rateVideo,
  15   ServerInfo,
  16   setAccessTokensToServers,
  17   testCaptionFile,
  18   uploadVideo,
  19   waitJobs
  20 } from '@shared/extra-utils'
  21 import { Video, VideoPrivacy } from '@shared/models'
  22
  23 const expect = chai.expect
  24
  25 describe('Test follows', function () {
  26   let servers: ServerInfo[] = []
  27   let followsCommands: FollowsCommand[]
  28
  29   before(async function () {
  30     this.timeout(30000)
  31
  32     servers = await flushAndRunMultipleServers(3)
  33     followsCommands = servers.map(s => s.followsCommand)
  34
  35     // Get the access tokens
  36     await setAccessTokensToServers(servers)
  37   })
  38
  39   it('Should not have followers', async function () {
  40     for (const server of servers) {
  41       const body = await server.followsCommand.getFollowers({ start: 0, count: 5, sort: 'createdAt' })
  42       expect(body.total).to.equal(0)
  43
  44       const follows = body.data
  45       expect(follows).to.be.an('array')
  46       expect(follows.length).to.equal(0)
  47     }
  48   })
  49
  50   it('Should not have following', async function () {
  51     for (const server of servers) {
  52       const body = await server.followsCommand.getFollowings({ start: 0, count: 5, sort: 'createdAt' })
  53       expect(body.total).to.equal(0)
  54
  55       const follows = body.data
  56       expect(follows).to.be.an('array')
  57       expect(follows.length).to.equal(0)
  58     }
  59   })
  60
  61   it('Should have server 1 following server 2 and 3', async function () {
  62     this.timeout(30000)
  63
  64     await followsCommands[0].follow({ targets: [ servers[1].url, servers[2].url ] })
  65
  66     await waitJobs(servers)
  67   })
  68
  69   it('Should have 2 followings on server 1', async function () {
  70     const body = await followsCommands[0].getFollowings({ start: 0, count: 1, sort: 'createdAt' })
  71     expect(body.total).to.equal(2)
  72
  73     let follows = body.data
  74     expect(follows).to.be.an('array')
  75     expect(follows.length).to.equal(1)
  76
  77     const body2 = await followsCommands[0].getFollowings({ start: 1, count: 1, sort: 'createdAt' })
  78     follows = follows.concat(body2.data)
  79
  80     const server2Follow = follows.find(f => f.following.host === 'localhost:' + servers[1].port)
  81     const server3Follow = follows.find(f => f.following.host === 'localhost:' + servers[2].port)
  82
  83     expect(server2Follow).to.not.be.undefined
  84     expect(server3Follow).to.not.be.undefined
  85     expect(server2Follow.state).to.equal('accepted')
  86     expect(server3Follow.state).to.equal('accepted')
  87   })
  88
  89   it('Should search/filter followings on server 1', async function () {
  90     const sort = 'createdAt'
  91     const start = 0
  92     const count = 1
  93
  94     {
  95       const search = ':' + servers[1].port
  96
  97       {
  98         const body = await followsCommands[0].getFollowings({ start, count, sort, search })
  99         expect(body.total).to.equal(1)
 100
 101         const follows = body.data
 102         expect(follows.length).to.equal(1)
 103         expect(follows[0].following.host).to.equal('localhost:' + servers[1].port)
 104       }
 105
 106       {
 107         const body = await followsCommands[0].getFollowings({ start, count, sort, search, state: 'accepted' })
 108         expect(body.total).to.equal(1)
 109         expect(body.data).to.have.lengthOf(1)
 110       }
 111
 112       {
 113         const body = await followsCommands[0].getFollowings({ start, count, sort, search, state: 'accepted', actorType: 'Person' })
 114         expect(body.total).to.equal(0)
 115         expect(body.data).to.have.lengthOf(0)
 116       }
 117
 118       {
 119         const body = await followsCommands[0].getFollowings({
 120           start,
 121           count,
 122           sort,
 123           search,
 124           state: 'accepted',
 125           actorType: 'Application'
 126         })
 127         expect(body.total).to.equal(1)
 128         expect(body.data).to.have.lengthOf(1)
 129       }
 130
 131       {
 132         const body = await followsCommands[0].getFollowings({ start, count, sort, search, state: 'pending' })
 133         expect(body.total).to.equal(0)
 134         expect(body.data).to.have.lengthOf(0)
 135       }
 136     }
 137
 138     {
 139       const body = await followsCommands[0].getFollowings({ start, count, sort, search: 'bla' })
 140       expect(body.total).to.equal(0)
 141
 142       expect(body.data.length).to.equal(0)
 143     }
 144   })
 145
 146   it('Should have 0 followings on server 2 and 3', async function () {
 147     for (const server of [ servers[1], servers[2] ]) {
 148       const body = await server.followsCommand.getFollowings({ start: 0, count: 5, sort: 'createdAt' })
 149       expect(body.total).to.equal(0)
 150
 151       const follows = body.data
 152       expect(follows).to.be.an('array')
 153       expect(follows.length).to.equal(0)
 154     }
 155   })
 156
 157   it('Should have 1 followers on server 2 and 3', async function () {
 158     for (const server of [ servers[1], servers[2] ]) {
 159       const body = await server.followsCommand.getFollowers({ start: 0, count: 1, sort: 'createdAt' })
 160       expect(body.total).to.equal(1)
 161
 162       const follows = body.data
 163       expect(follows).to.be.an('array')
 164       expect(follows.length).to.equal(1)
 165       expect(follows[0].follower.host).to.equal('localhost:' + servers[0].port)
 166     }
 167   })
 168
 169   it('Should search/filter followers on server 2', async function () {
 170     const start = 0
 171     const count = 5
 172     const sort = 'createdAt'
 173
 174     {
 175       const search = servers[0].port + ''
 176
 177       {
 178         const body = await followsCommands[2].getFollowers({ start, count, sort, search })
 179         expect(body.total).to.equal(1)
 180
 181         const follows = body.data
 182         expect(follows.length).to.equal(1)
 183         expect(follows[0].following.host).to.equal('localhost:' + servers[2].port)
 184       }
 185
 186       {
 187         const body = await followsCommands[2].getFollowers({ start, count, sort, search, state: 'accepted' })
 188         expect(body.total).to.equal(1)
 189         expect(body.data).to.have.lengthOf(1)
 190       }
 191
 192       {
 193         const body = await followsCommands[2].getFollowers({ start, count, sort, search, state: 'accepted', actorType: 'Person' })
 194         expect(body.total).to.equal(0)
 195         expect(body.data).to.have.lengthOf(0)
 196       }
 197
 198       {
 199         const body = await followsCommands[2].getFollowers({
 200           start,
 201           count,
 202           sort,
 203           search,
 204           state: 'accepted',
 205           actorType: 'Application'
 206         })
 207         expect(body.total).to.equal(1)
 208         expect(body.data).to.have.lengthOf(1)
 209       }
 210
 211       {
 212         const body = await followsCommands[2].getFollowers({ start, count, sort, search, state: 'pending' })
 213         expect(body.total).to.equal(0)
 214         expect(body.data).to.have.lengthOf(0)
 215       }
 216     }
 217
 218     {
 219       const body = await followsCommands[2].getFollowers({ start, count, sort, search: 'bla' })
 220       expect(body.total).to.equal(0)
 221
 222       const follows = body.data
 223       expect(follows.length).to.equal(0)
 224     }
 225   })
 226
 227   it('Should have 0 followers on server 1', async function () {
 228     const body = await followsCommands[0].getFollowers({ start: 0, count: 5, sort: 'createdAt' })
 229     expect(body.total).to.equal(0)
 230
 231     const follows = body.data
 232     expect(follows).to.be.an('array')
 233     expect(follows.length).to.equal(0)
 234   })
 235
 236   it('Should have the correct follows counts', async function () {
 237     await expectAccountFollows({ server: servers[0], handle: 'peertube@localhost:' + servers[0].port, followers: 0, following: 2 })
 238     await expectAccountFollows({ server: servers[0], handle: 'peertube@localhost:' + servers[1].port, followers: 1, following: 0 })
 239     await expectAccountFollows({ server: servers[0], handle: 'peertube@localhost:' + servers[2].port, followers: 1, following: 0 })
 240
 241     // Server 2 and 3 does not know server 1 follow another server (there was not a refresh)
 242     await expectAccountFollows({ server: servers[1], handle: 'peertube@localhost:' + servers[0].port, followers: 0, following: 1 })
 243     await expectAccountFollows({ server: servers[1], handle: 'peertube@localhost:' + servers[1].port, followers: 1, following: 0 })
 244
 245     await expectAccountFollows({ server: servers[2], handle: 'peertube@localhost:' + servers[0].port, followers: 0, following: 1 })
 246     await expectAccountFollows({ server: servers[2], handle: 'peertube@localhost:' + servers[2].port, followers: 1, following: 0 })
 247   })
 248
 249   it('Should unfollow server 3 on server 1', async function () {
 250     this.timeout(5000)
 251
 252     await followsCommands[0].unfollow({ target: servers[2] })
 253
 254     await waitJobs(servers)
 255   })
 256
 257   it('Should not follow server 3 on server 1 anymore', async function () {
 258     const body = await followsCommands[0].getFollowings({ start: 0, count: 2, sort: 'createdAt' })
 259     expect(body.total).to.equal(1)
 260
 261     const follows = body.data
 262     expect(follows).to.be.an('array')
 263     expect(follows.length).to.equal(1)
 264
 265     expect(follows[0].following.host).to.equal('localhost:' + servers[1].port)
 266   })
 267
 268   it('Should not have server 1 as follower on server 3 anymore', async function () {
 269     const body = await followsCommands[2].getFollowers({ start: 0, count: 1, sort: 'createdAt' })
 270     expect(body.total).to.equal(0)
 271
 272     const follows = body.data
 273     expect(follows).to.be.an('array')
 274     expect(follows.length).to.equal(0)
 275   })
 276
 277   it('Should have the correct follows counts 2', async function () {
 278     await expectAccountFollows({ server: servers[0], handle: 'peertube@localhost:' + servers[0].port, followers: 0, following: 1 })
 279     await expectAccountFollows({ server: servers[0], handle: 'peertube@localhost:' + servers[1].port, followers: 1, following: 0 })
 280
 281     await expectAccountFollows({ server: servers[1], handle: 'peertube@localhost:' + servers[0].port, followers: 0, following: 1 })
 282     await expectAccountFollows({ server: servers[1], handle: 'peertube@localhost:' + servers[1].port, followers: 1, following: 0 })
 283
 284     await expectAccountFollows({ server: servers[2], handle: 'peertube@localhost:' + servers[0].port, followers: 0, following: 0 })
 285     await expectAccountFollows({ server: servers[2], handle: 'peertube@localhost:' + servers[2].port, followers: 0, following: 0 })
 286   })
 287
 288   it('Should upload a video on server 2 and 3 and propagate only the video of server 2', async function () {
 289     this.timeout(60000)
 290
 291     await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'server2' })
 292     await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3' })
 293
 294     await waitJobs(servers)
 295
 296     let res = await getVideosList(servers[0].url)
 297     expect(res.body.total).to.equal(1)
 298     expect(res.body.data[0].name).to.equal('server2')
 299
 300     res = await getVideosList(servers[1].url)
 301     expect(res.body.total).to.equal(1)
 302     expect(res.body.data[0].name).to.equal('server2')
 303
 304     res = await getVideosList(servers[2].url)
 305     expect(res.body.total).to.equal(1)
 306     expect(res.body.data[0].name).to.equal('server3')
 307   })
 308
 309   describe('Should propagate data on a new following', function () {
 310     let video4: Video
 311
 312     before(async function () {
 313       this.timeout(50000)
 314
 315       const video4Attributes = {
 316         name: 'server3-4',
 317         category: 2,
 318         nsfw: true,
 319         licence: 6,
 320         tags: [ 'tag1', 'tag2', 'tag3' ]
 321       }
 322
 323       await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-2' })
 324       await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-3' })
 325       await uploadVideo(servers[2].url, servers[2].accessToken, video4Attributes)
 326       await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-5' })
 327       await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-6' })
 328
 329       {
 330         const user = { username: 'captain', password: 'password' }
 331         await createUser({ url: servers[2].url, accessToken: servers[2].accessToken, username: user.username, password: user.password })
 332         const userAccessToken = await servers[2].loginCommand.getAccessToken(user)
 333
 334         const resVideos = await getVideosList(servers[2].url)
 335         video4 = resVideos.body.data.find(v => v.name === 'server3-4')
 336
 337         {
 338           await rateVideo(servers[2].url, servers[2].accessToken, video4.id, 'like')
 339           await rateVideo(servers[2].url, userAccessToken, video4.id, 'dislike')
 340         }
 341
 342         {
 343           {
 344             const text = 'my super first comment'
 345             const created = await servers[2].commentsCommand.createThread({ videoId: video4.id, text })
 346             const threadId = created.id
 347
 348             const text1 = 'my super answer to thread 1'
 349             const childComment = await servers[2].commentsCommand.addReply({ videoId: video4.id, toCommentId: threadId, text: text1 })
 350
 351             const text2 = 'my super answer to answer of thread 1'
 352             await servers[2].commentsCommand.addReply({ videoId: video4.id, toCommentId: childComment.id, text: text2 })
 353
 354             const text3 = 'my second answer to thread 1'
 355             await servers[2].commentsCommand.addReply({ videoId: video4.id, toCommentId: threadId, text: text3 })
 356           }
 357
 358           {
 359             const text = 'will be deleted'
 360             const created = await servers[2].commentsCommand.createThread({ videoId: video4.id, text })
 361             const threadId = created.id
 362
 363             const text1 = 'answer to deleted'
 364             await servers[2].commentsCommand.addReply({ videoId: video4.id, toCommentId: threadId, text: text1 })
 365
 366             const text2 = 'will also be deleted'
 367             const childComment = await servers[2].commentsCommand.addReply({ videoId: video4.id, toCommentId: threadId, text: text2 })
 368
 369             const text3 = 'my second answer to deleted'
 370             await servers[2].commentsCommand.addReply({ videoId: video4.id, toCommentId: childComment.id, text: text3 })
 371
 372             await servers[2].commentsCommand.delete({ videoId: video4.id, commentId: threadId })
 373             await servers[2].commentsCommand.delete({ videoId: video4.id, commentId: childComment.id })
 374           }
 375         }
 376
 377         {
 378           await servers[2].captionsCommand.createVideoCaption({
 379             language: 'ar',
 380             videoId: video4.id,
 381             fixture: 'subtitle-good2.vtt'
 382           })
 383         }
 384       }
 385
 386       await waitJobs(servers)
 387
 388       // Server 1 follows server 3
 389       await followsCommands[0].follow({ targets: [ servers[2].url ] })
 390
 391       await waitJobs(servers)
 392     })
 393
 394     it('Should have the correct follows counts 3', async function () {
 395       await expectAccountFollows({ server: servers[0], handle: 'peertube@localhost:' + servers[0].port, followers: 0, following: 2 })
 396       await expectAccountFollows({ server: servers[0], handle: 'peertube@localhost:' + servers[1].port, followers: 1, following: 0 })
 397       await expectAccountFollows({ server: servers[0], handle: 'peertube@localhost:' + servers[2].port, followers: 1, following: 0 })
 398
 399       await expectAccountFollows({ server: servers[1], handle: 'peertube@localhost:' + servers[0].port, followers: 0, following: 1 })
 400       await expectAccountFollows({ server: servers[1], handle: 'peertube@localhost:' + servers[1].port, followers: 1, following: 0 })
 401
 402       await expectAccountFollows({ server: servers[2], handle: 'peertube@localhost:' + servers[0].port, followers: 0, following: 1 })
 403       await expectAccountFollows({ server: servers[2], handle: 'peertube@localhost:' + servers[2].port, followers: 1, following: 0 })
 404     })
 405
 406     it('Should have propagated videos', async function () {
 407       const res = await getVideosList(servers[0].url)
 408       expect(res.body.total).to.equal(7)
 409
 410       const video2 = res.body.data.find(v => v.name === 'server3-2')
 411       video4 = res.body.data.find(v => v.name === 'server3-4')
 412       const video6 = res.body.data.find(v => v.name === 'server3-6')
 413
 414       expect(video2).to.not.be.undefined
 415       expect(video4).to.not.be.undefined
 416       expect(video6).to.not.be.undefined
 417
 418       const isLocal = false
 419       const checkAttributes = {
 420         name: 'server3-4',
 421         category: 2,
 422         licence: 6,
 423         language: 'zh',
 424         nsfw: true,
 425         description: 'my super description',
 426         support: 'my super support text',
 427         account: {
 428           name: 'root',
 429           host: 'localhost:' + servers[2].port
 430         },
 431         isLocal,
 432         commentsEnabled: true,
 433         downloadEnabled: true,
 434         duration: 5,
 435         tags: [ 'tag1', 'tag2', 'tag3' ],
 436         privacy: VideoPrivacy.PUBLIC,
 437         likes: 1,
 438         dislikes: 1,
 439         channel: {
 440           displayName: 'Main root channel',
 441           name: 'root_channel',
 442           description: '',
 443           isLocal
 444         },
 445         fixture: 'video_short.webm',
 446         files: [
 447           {
 448             resolution: 720,
 449             size: 218910
 450           }
 451         ]
 452       }
 453       await completeVideoCheck(servers[0].url, video4, checkAttributes)
 454     })
 455
 456     it('Should have propagated comments', async function () {
 457       const { total, data } = await servers[0].commentsCommand.listThreads({ videoId: video4.id, sort: 'createdAt' })
 458
 459       expect(total).to.equal(2)
 460       expect(data).to.be.an('array')
 461       expect(data).to.have.lengthOf(2)
 462
 463       {
 464         const comment = data[0]
 465         expect(comment.inReplyToCommentId).to.be.null
 466         expect(comment.text).equal('my super first comment')
 467         expect(comment.videoId).to.equal(video4.id)
 468         expect(comment.id).to.equal(comment.threadId)
 469         expect(comment.account.name).to.equal('root')
 470         expect(comment.account.host).to.equal('localhost:' + servers[2].port)
 471         expect(comment.totalReplies).to.equal(3)
 472         expect(dateIsValid(comment.createdAt as string)).to.be.true
 473         expect(dateIsValid(comment.updatedAt as string)).to.be.true
 474
 475         const threadId = comment.threadId
 476
 477         const tree = await servers[0].commentsCommand.getThread({ videoId: video4.id, threadId })
 478         expect(tree.comment.text).equal('my super first comment')
 479         expect(tree.children).to.have.lengthOf(2)
 480
 481         const firstChild = tree.children[0]
 482         expect(firstChild.comment.text).to.equal('my super answer to thread 1')
 483         expect(firstChild.children).to.have.lengthOf(1)
 484
 485         const childOfFirstChild = firstChild.children[0]
 486         expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
 487         expect(childOfFirstChild.children).to.have.lengthOf(0)
 488
 489         const secondChild = tree.children[1]
 490         expect(secondChild.comment.text).to.equal('my second answer to thread 1')
 491         expect(secondChild.children).to.have.lengthOf(0)
 492       }
 493
 494       {
 495         const deletedComment = data[1]
 496         expect(deletedComment).to.not.be.undefined
 497         expect(deletedComment.isDeleted).to.be.true
 498         expect(deletedComment.deletedAt).to.not.be.null
 499         expect(deletedComment.text).to.equal('')
 500         expect(deletedComment.inReplyToCommentId).to.be.null
 501         expect(deletedComment.account).to.be.null
 502         expect(deletedComment.totalReplies).to.equal(2)
 503         expect(dateIsValid(deletedComment.deletedAt as string)).to.be.true
 504
 505         const tree = await servers[0].commentsCommand.getThread({ videoId: video4.id, threadId: deletedComment.threadId })
 506         const [ commentRoot, deletedChildRoot ] = tree.children
 507
 508         expect(deletedChildRoot).to.not.be.undefined
 509         expect(deletedChildRoot.comment.isDeleted).to.be.true
 510         expect(deletedChildRoot.comment.deletedAt).to.not.be.null
 511         expect(deletedChildRoot.comment.text).to.equal('')
 512         expect(deletedChildRoot.comment.inReplyToCommentId).to.equal(deletedComment.id)
 513         expect(deletedChildRoot.comment.account).to.be.null
 514         expect(deletedChildRoot.children).to.have.lengthOf(1)
 515
 516         const answerToDeletedChild = deletedChildRoot.children[0]
 517         expect(answerToDeletedChild.comment).to.not.be.undefined
 518         expect(answerToDeletedChild.comment.inReplyToCommentId).to.equal(deletedChildRoot.comment.id)
 519         expect(answerToDeletedChild.comment.text).to.equal('my second answer to deleted')
 520         expect(answerToDeletedChild.comment.account.name).to.equal('root')
 521
 522         expect(commentRoot.comment).to.not.be.undefined
 523         expect(commentRoot.comment.inReplyToCommentId).to.equal(deletedComment.id)
 524         expect(commentRoot.comment.text).to.equal('answer to deleted')
 525         expect(commentRoot.comment.account.name).to.equal('root')
 526       }
 527     })
 528
 529     it('Should have propagated captions', async function () {
 530       const body = await servers[0].captionsCommand.listVideoCaptions({ videoId: video4.id })
 531       expect(body.total).to.equal(1)
 532       expect(body.data).to.have.lengthOf(1)
 533
 534       const caption1 = body.data[0]
 535       expect(caption1.language.id).to.equal('ar')
 536       expect(caption1.language.label).to.equal('Arabic')
 537       expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/.+-ar.vtt$'))
 538       await testCaptionFile(servers[0].url, caption1.captionPath, 'Subtitle good 2.')
 539     })
 540
 541     it('Should unfollow server 3 on server 1 and does not list server 3 videos', async function () {
 542       this.timeout(5000)
 543
 544       await followsCommands[0].unfollow({ target: servers[2] })
 545
 546       await waitJobs(servers)
 547
 548       const res = await getVideosList(servers[0].url)
 549       expect(res.body.total).to.equal(1)
 550     })
 551
 552   })
 553
 554   after(async function () {
 555     await cleanupTests(servers)
 556   })
 557 })