server/tests/api/videos/multiple-servers.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 request from 'supertest'
   6 import {
   7   checkTmpIsEmpty,
   8   checkVideoFilesWereRemoved,
   9   completeVideoCheck,
  10   dateIsValid,
  11   saveVideoInServers,
  12   testImage
  13 } from '@server/tests/shared'
  14 import { buildAbsoluteFixturePath, wait } from '@shared/core-utils'
  15 import { HttpStatusCode, VideoCommentThreadTree, VideoPrivacy } from '@shared/models'
  16 import {
  17   cleanupTests,
  18   createMultipleServers,
  19   doubleFollow,
  20   makeGetRequest,
  21   PeerTubeServer,
  22   setAccessTokensToServers,
  23   setDefaultAccountAvatar,
  24   setDefaultChannelAvatar,
  25   waitJobs,
  26   webtorrentAdd
  27 } from '@shared/server-commands'
  28
  29 const expect = chai.expect
  30
  31 describe('Test multiple servers', function () {
  32   let servers: PeerTubeServer[] = []
  33   const toRemove = []
  34   let videoUUID = ''
  35   let videoChannelId: number
  36
  37   before(async function () {
  38     this.timeout(120000)
  39
  40     servers = await createMultipleServers(3)
  41
  42     // Get the access tokens
  43     await setAccessTokensToServers(servers)
  44
  45     {
  46       const videoChannel = {
  47         name: 'super_channel_name',
  48         displayName: 'my channel',
  49         description: 'super channel'
  50       }
  51       await servers[0].channels.create({ attributes: videoChannel })
  52       await setDefaultChannelAvatar(servers[0], videoChannel.name)
  53       await setDefaultAccountAvatar(servers)
  54
  55       const { data } = await servers[0].channels.list({ start: 0, count: 1 })
  56       videoChannelId = data[0].id
  57     }
  58
  59     // Server 1 and server 2 follow each other
  60     await doubleFollow(servers[0], servers[1])
  61     // Server 1 and server 3 follow each other
  62     await doubleFollow(servers[0], servers[2])
  63     // Server 2 and server 3 follow each other
  64     await doubleFollow(servers[1], servers[2])
  65   })
  66
  67   it('Should not have videos for all servers', async function () {
  68     for (const server of servers) {
  69       const { data } = await server.videos.list()
  70       expect(data).to.be.an('array')
  71       expect(data.length).to.equal(0)
  72     }
  73   })
  74
  75   describe('Should upload the video and propagate on each server', function () {
  76     it('Should upload the video on server 1 and propagate on each server', async function () {
  77       this.timeout(25000)
  78
  79       const attributes = {
  80         name: 'my super name for server 1',
  81         category: 5,
  82         licence: 4,
  83         language: 'ja',
  84         nsfw: true,
  85         description: 'my super description for server 1',
  86         support: 'my super support text for server 1',
  87         originallyPublishedAt: '2019-02-10T13:38:14.449Z',
  88         tags: [ 'tag1p1', 'tag2p1' ],
  89         channelId: videoChannelId,
  90         fixture: 'video_short1.webm'
  91       }
  92       await servers[0].videos.upload({ attributes })
  93
  94       await waitJobs(servers)
  95
  96       // All servers should have this video
  97       let publishedAt: string = null
  98       for (const server of servers) {
  99         const isLocal = server.port === servers[0].port
 100         const checkAttributes = {
 101           name: 'my super name for server 1',
 102           category: 5,
 103           licence: 4,
 104           language: 'ja',
 105           nsfw: true,
 106           description: 'my super description for server 1',
 107           support: 'my super support text for server 1',
 108           originallyPublishedAt: '2019-02-10T13:38:14.449Z',
 109           account: {
 110             name: 'root',
 111             host: 'localhost:' + servers[0].port
 112           },
 113           isLocal,
 114           publishedAt,
 115           duration: 10,
 116           tags: [ 'tag1p1', 'tag2p1' ],
 117           privacy: VideoPrivacy.PUBLIC,
 118           commentsEnabled: true,
 119           downloadEnabled: true,
 120           channel: {
 121             displayName: 'my channel',
 122             name: 'super_channel_name',
 123             description: 'super channel',
 124             isLocal
 125           },
 126           fixture: 'video_short1.webm',
 127           files: [
 128             {
 129               resolution: 720,
 130               size: 572456
 131             }
 132           ]
 133         }
 134
 135         const { data } = await server.videos.list()
 136         expect(data).to.be.an('array')
 137         expect(data.length).to.equal(1)
 138         const video = data[0]
 139
 140         await completeVideoCheck(server, video, checkAttributes)
 141         publishedAt = video.publishedAt as string
 142
 143         expect(video.channel.avatars).to.have.lengthOf(2)
 144         expect(video.account.avatars).to.have.lengthOf(2)
 145
 146         for (const image of [ ...video.channel.avatars, ...video.account.avatars ]) {
 147           expect(image.createdAt).to.exist
 148           expect(image.updatedAt).to.exist
 149           expect(image.width).to.be.above(20).and.below(1000)
 150           expect(image.path).to.exist
 151
 152           await makeGetRequest({
 153             url: server.url,
 154             path: image.path,
 155             expectedStatus: HttpStatusCode.OK_200
 156           })
 157         }
 158       }
 159     })
 160
 161     it('Should upload the video on server 2 and propagate on each server', async function () {
 162       this.timeout(100000)
 163
 164       const user = {
 165         username: 'user1',
 166         password: 'super_password'
 167       }
 168       await servers[1].users.create({ username: user.username, password: user.password })
 169       const userAccessToken = await servers[1].login.getAccessToken(user)
 170
 171       const attributes = {
 172         name: 'my super name for server 2',
 173         category: 4,
 174         licence: 3,
 175         language: 'de',
 176         nsfw: true,
 177         description: 'my super description for server 2',
 178         support: 'my super support text for server 2',
 179         tags: [ 'tag1p2', 'tag2p2', 'tag3p2' ],
 180         fixture: 'video_short2.webm',
 181         thumbnailfile: 'thumbnail.jpg',
 182         previewfile: 'preview.jpg'
 183       }
 184       await servers[1].videos.upload({ token: userAccessToken, attributes, mode: 'resumable' })
 185
 186       // Transcoding
 187       await waitJobs(servers)
 188
 189       // All servers should have this video
 190       for (const server of servers) {
 191         const isLocal = server.url === 'http://localhost:' + servers[1].port
 192         const checkAttributes = {
 193           name: 'my super name for server 2',
 194           category: 4,
 195           licence: 3,
 196           language: 'de',
 197           nsfw: true,
 198           description: 'my super description for server 2',
 199           support: 'my super support text for server 2',
 200           account: {
 201             name: 'user1',
 202             host: 'localhost:' + servers[1].port
 203           },
 204           isLocal,
 205           commentsEnabled: true,
 206           downloadEnabled: true,
 207           duration: 5,
 208           tags: [ 'tag1p2', 'tag2p2', 'tag3p2' ],
 209           privacy: VideoPrivacy.PUBLIC,
 210           channel: {
 211             displayName: 'Main user1 channel',
 212             name: 'user1_channel',
 213             description: 'super channel',
 214             isLocal
 215           },
 216           fixture: 'video_short2.webm',
 217           files: [
 218             {
 219               resolution: 240,
 220               size: 270000
 221             },
 222             {
 223               resolution: 360,
 224               size: 359000
 225             },
 226             {
 227               resolution: 480,
 228               size: 465000
 229             },
 230             {
 231               resolution: 720,
 232               size: 750000
 233             }
 234           ],
 235           thumbnailfile: 'thumbnail',
 236           previewfile: 'preview'
 237         }
 238
 239         const { data } = await server.videos.list()
 240         expect(data).to.be.an('array')
 241         expect(data.length).to.equal(2)
 242         const video = data[1]
 243
 244         await completeVideoCheck(server, video, checkAttributes)
 245       }
 246     })
 247
 248     it('Should upload two videos on server 3 and propagate on each server', async function () {
 249       this.timeout(45000)
 250
 251       {
 252         const attributes = {
 253           name: 'my super name for server 3',
 254           category: 6,
 255           licence: 5,
 256           language: 'de',
 257           nsfw: true,
 258           description: 'my super description for server 3',
 259           support: 'my super support text for server 3',
 260           tags: [ 'tag1p3' ],
 261           fixture: 'video_short3.webm'
 262         }
 263         await servers[2].videos.upload({ attributes })
 264       }
 265
 266       {
 267         const attributes = {
 268           name: 'my super name for server 3-2',
 269           category: 7,
 270           licence: 6,
 271           language: 'ko',
 272           nsfw: false,
 273           description: 'my super description for server 3-2',
 274           support: 'my super support text for server 3-2',
 275           tags: [ 'tag2p3', 'tag3p3', 'tag4p3' ],
 276           fixture: 'video_short.webm'
 277         }
 278         await servers[2].videos.upload({ attributes })
 279       }
 280
 281       await waitJobs(servers)
 282
 283       // All servers should have this video
 284       for (const server of servers) {
 285         const isLocal = server.url === 'http://localhost:' + servers[2].port
 286         const { data } = await server.videos.list()
 287
 288         expect(data).to.be.an('array')
 289         expect(data.length).to.equal(4)
 290
 291         // We not sure about the order of the two last uploads
 292         let video1 = null
 293         let video2 = null
 294         if (data[2].name === 'my super name for server 3') {
 295           video1 = data[2]
 296           video2 = data[3]
 297         } else {
 298           video1 = data[3]
 299           video2 = data[2]
 300         }
 301
 302         const checkAttributesVideo1 = {
 303           name: 'my super name for server 3',
 304           category: 6,
 305           licence: 5,
 306           language: 'de',
 307           nsfw: true,
 308           description: 'my super description for server 3',
 309           support: 'my super support text for server 3',
 310           account: {
 311             name: 'root',
 312             host: 'localhost:' + servers[2].port
 313           },
 314           isLocal,
 315           duration: 5,
 316           commentsEnabled: true,
 317           downloadEnabled: true,
 318           tags: [ 'tag1p3' ],
 319           privacy: VideoPrivacy.PUBLIC,
 320           channel: {
 321             displayName: 'Main root channel',
 322             name: 'root_channel',
 323             description: '',
 324             isLocal
 325           },
 326           fixture: 'video_short3.webm',
 327           files: [
 328             {
 329               resolution: 720,
 330               size: 292677
 331             }
 332           ]
 333         }
 334         await completeVideoCheck(server, video1, checkAttributesVideo1)
 335
 336         const checkAttributesVideo2 = {
 337           name: 'my super name for server 3-2',
 338           category: 7,
 339           licence: 6,
 340           language: 'ko',
 341           nsfw: false,
 342           description: 'my super description for server 3-2',
 343           support: 'my super support text for server 3-2',
 344           account: {
 345             name: 'root',
 346             host: 'localhost:' + servers[2].port
 347           },
 348           commentsEnabled: true,
 349           downloadEnabled: true,
 350           isLocal,
 351           duration: 5,
 352           tags: [ 'tag2p3', 'tag3p3', 'tag4p3' ],
 353           privacy: VideoPrivacy.PUBLIC,
 354           channel: {
 355             displayName: 'Main root channel',
 356             name: 'root_channel',
 357             description: '',
 358             isLocal
 359           },
 360           fixture: 'video_short.webm',
 361           files: [
 362             {
 363               resolution: 720,
 364               size: 218910
 365             }
 366           ]
 367         }
 368         await completeVideoCheck(server, video2, checkAttributesVideo2)
 369       }
 370     })
 371   })
 372
 373   describe('It should list local videos', function () {
 374     it('Should list only local videos on server 1', async function () {
 375       const { data, total } = await servers[0].videos.list({ isLocal: true })
 376
 377       expect(total).to.equal(1)
 378       expect(data).to.be.an('array')
 379       expect(data.length).to.equal(1)
 380       expect(data[0].name).to.equal('my super name for server 1')
 381     })
 382
 383     it('Should list only local videos on server 2', async function () {
 384       const { data, total } = await servers[1].videos.list({ isLocal: true })
 385
 386       expect(total).to.equal(1)
 387       expect(data).to.be.an('array')
 388       expect(data.length).to.equal(1)
 389       expect(data[0].name).to.equal('my super name for server 2')
 390     })
 391
 392     it('Should list only local videos on server 3', async function () {
 393       const { data, total } = await servers[2].videos.list({ isLocal: true })
 394
 395       expect(total).to.equal(2)
 396       expect(data).to.be.an('array')
 397       expect(data.length).to.equal(2)
 398       expect(data[0].name).to.equal('my super name for server 3')
 399       expect(data[1].name).to.equal('my super name for server 3-2')
 400     })
 401   })
 402
 403   describe('Should seed the uploaded video', function () {
 404     it('Should add the file 1 by asking server 3', async function () {
 405       this.timeout(30000)
 406
 407       const { data } = await servers[2].videos.list()
 408
 409       const video = data[0]
 410       toRemove.push(data[2])
 411       toRemove.push(data[3])
 412
 413       const videoDetails = await servers[2].videos.get({ id: video.id })
 414       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
 415       expect(torrent.files).to.be.an('array')
 416       expect(torrent.files.length).to.equal(1)
 417       expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 418     })
 419
 420     it('Should add the file 2 by asking server 1', async function () {
 421       this.timeout(30000)
 422
 423       const { data } = await servers[0].videos.list()
 424
 425       const video = data[1]
 426       const videoDetails = await servers[0].videos.get({ id: video.id })
 427
 428       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
 429       expect(torrent.files).to.be.an('array')
 430       expect(torrent.files.length).to.equal(1)
 431       expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 432     })
 433
 434     it('Should add the file 3 by asking server 2', async function () {
 435       this.timeout(30000)
 436
 437       const { data } = await servers[1].videos.list()
 438
 439       const video = data[2]
 440       const videoDetails = await servers[1].videos.get({ id: video.id })
 441
 442       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
 443       expect(torrent.files).to.be.an('array')
 444       expect(torrent.files.length).to.equal(1)
 445       expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 446     })
 447
 448     it('Should add the file 3-2 by asking server 1', async function () {
 449       this.timeout(30000)
 450
 451       const { data } = await servers[0].videos.list()
 452
 453       const video = data[3]
 454       const videoDetails = await servers[0].videos.get({ id: video.id })
 455
 456       const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
 457       expect(torrent.files).to.be.an('array')
 458       expect(torrent.files.length).to.equal(1)
 459       expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 460     })
 461
 462     it('Should add the file 2 in 360p by asking server 1', async function () {
 463       this.timeout(30000)
 464
 465       const { data } = await servers[0].videos.list()
 466
 467       const video = data.find(v => v.name === 'my super name for server 2')
 468       const videoDetails = await servers[0].videos.get({ id: video.id })
 469
 470       const file = videoDetails.files.find(f => f.resolution.id === 360)
 471       expect(file).not.to.be.undefined
 472
 473       const torrent = await webtorrentAdd(file.magnetUri)
 474       expect(torrent.files).to.be.an('array')
 475       expect(torrent.files.length).to.equal(1)
 476       expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 477     })
 478   })
 479
 480   describe('Should update video views, likes and dislikes', function () {
 481     let localVideosServer3 = []
 482     let remoteVideosServer1 = []
 483     let remoteVideosServer2 = []
 484     let remoteVideosServer3 = []
 485
 486     before(async function () {
 487       {
 488         const { data } = await servers[0].videos.list()
 489         remoteVideosServer1 = data.filter(video => video.isLocal === false).map(video => video.uuid)
 490       }
 491
 492       {
 493         const { data } = await servers[1].videos.list()
 494         remoteVideosServer2 = data.filter(video => video.isLocal === false).map(video => video.uuid)
 495       }
 496
 497       {
 498         const { data } = await servers[2].videos.list()
 499         localVideosServer3 = data.filter(video => video.isLocal === true).map(video => video.uuid)
 500         remoteVideosServer3 = data.filter(video => video.isLocal === false).map(video => video.uuid)
 501       }
 502     })
 503
 504     it('Should view multiple videos on owned servers', async function () {
 505       this.timeout(30000)
 506
 507       await servers[2].views.simulateView({ id: localVideosServer3[0] })
 508       await wait(1000)
 509
 510       await servers[2].views.simulateView({ id: localVideosServer3[0] })
 511       await servers[2].views.simulateView({ id: localVideosServer3[1] })
 512
 513       await wait(1000)
 514
 515       await servers[2].views.simulateView({ id: localVideosServer3[0] })
 516       await servers[2].views.simulateView({ id: localVideosServer3[0] })
 517
 518       await waitJobs(servers)
 519
 520       for (const server of servers) {
 521         await server.debug.sendCommand({ body: { command: 'process-video-views-buffer' } })
 522       }
 523
 524       await waitJobs(servers)
 525
 526       for (const server of servers) {
 527         const { data } = await server.videos.list()
 528
 529         const video0 = data.find(v => v.uuid === localVideosServer3[0])
 530         const video1 = data.find(v => v.uuid === localVideosServer3[1])
 531
 532         expect(video0.views).to.equal(3)
 533         expect(video1.views).to.equal(1)
 534       }
 535     })
 536
 537     it('Should view multiple videos on each servers', async function () {
 538       this.timeout(45000)
 539
 540       const tasks: Promise<any>[] = []
 541       tasks.push(servers[0].views.simulateView({ id: remoteVideosServer1[0] }))
 542       tasks.push(servers[1].views.simulateView({ id: remoteVideosServer2[0] }))
 543       tasks.push(servers[1].views.simulateView({ id: remoteVideosServer2[0] }))
 544       tasks.push(servers[2].views.simulateView({ id: remoteVideosServer3[0] }))
 545       tasks.push(servers[2].views.simulateView({ id: remoteVideosServer3[1] }))
 546       tasks.push(servers[2].views.simulateView({ id: remoteVideosServer3[1] }))
 547       tasks.push(servers[2].views.simulateView({ id: remoteVideosServer3[1] }))
 548       tasks.push(servers[2].views.simulateView({ id: localVideosServer3[1] }))
 549       tasks.push(servers[2].views.simulateView({ id: localVideosServer3[1] }))
 550       tasks.push(servers[2].views.simulateView({ id: localVideosServer3[1] }))
 551
 552       await Promise.all(tasks)
 553
 554       await waitJobs(servers)
 555
 556       for (const server of servers) {
 557         await server.debug.sendCommand({ body: { command: 'process-video-views-buffer' } })
 558       }
 559
 560       await waitJobs(servers)
 561
 562       let baseVideos = null
 563
 564       for (const server of servers) {
 565         const { data } = await server.videos.list()
 566
 567         // Initialize base videos for future comparisons
 568         if (baseVideos === null) {
 569           baseVideos = data
 570           continue
 571         }
 572
 573         for (const baseVideo of baseVideos) {
 574           const sameVideo = data.find(video => video.name === baseVideo.name)
 575           expect(baseVideo.views).to.equal(sameVideo.views)
 576         }
 577       }
 578     })
 579
 580     it('Should like and dislikes videos on different services', async function () {
 581       this.timeout(50000)
 582
 583       await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'like' })
 584       await wait(500)
 585       await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'dislike' })
 586       await wait(500)
 587       await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'like' })
 588       await servers[2].videos.rate({ id: localVideosServer3[1], rating: 'like' })
 589       await wait(500)
 590       await servers[2].videos.rate({ id: localVideosServer3[1], rating: 'dislike' })
 591       await servers[2].videos.rate({ id: remoteVideosServer3[1], rating: 'dislike' })
 592       await wait(500)
 593       await servers[2].videos.rate({ id: remoteVideosServer3[0], rating: 'like' })
 594
 595       await waitJobs(servers)
 596       await wait(5000)
 597       await waitJobs(servers)
 598
 599       let baseVideos = null
 600       for (const server of servers) {
 601         const { data } = await server.videos.list()
 602
 603         // Initialize base videos for future comparisons
 604         if (baseVideos === null) {
 605           baseVideos = data
 606           continue
 607         }
 608
 609         for (const baseVideo of baseVideos) {
 610           const sameVideo = data.find(video => video.name === baseVideo.name)
 611           expect(baseVideo.likes).to.equal(sameVideo.likes, `Likes of ${sameVideo.uuid} do not correspond`)
 612           expect(baseVideo.dislikes).to.equal(sameVideo.dislikes, `Dislikes of ${sameVideo.uuid} do not correspond`)
 613         }
 614       }
 615     })
 616   })
 617
 618   describe('Should manipulate these videos', function () {
 619     let updatedAtMin: Date
 620
 621     it('Should update video 3', async function () {
 622       this.timeout(30000)
 623
 624       const attributes = {
 625         name: 'my super video updated',
 626         category: 10,
 627         licence: 7,
 628         language: 'fr',
 629         nsfw: true,
 630         description: 'my super description updated',
 631         support: 'my super support text updated',
 632         tags: [ 'tag_up_1', 'tag_up_2' ],
 633         thumbnailfile: 'thumbnail.jpg',
 634         originallyPublishedAt: '2019-02-11T13:38:14.449Z',
 635         previewfile: 'preview.jpg'
 636       }
 637
 638       updatedAtMin = new Date()
 639       await servers[2].videos.update({ id: toRemove[0].id, attributes })
 640
 641       await waitJobs(servers)
 642     })
 643
 644     it('Should have the video 3 updated on each server', async function () {
 645       this.timeout(30000)
 646
 647       for (const server of servers) {
 648         const { data } = await server.videos.list()
 649
 650         const videoUpdated = data.find(video => video.name === 'my super video updated')
 651         expect(!!videoUpdated).to.be.true
 652
 653         expect(new Date(videoUpdated.updatedAt)).to.be.greaterThan(updatedAtMin)
 654
 655         const isLocal = server.url === 'http://localhost:' + servers[2].port
 656         const checkAttributes = {
 657           name: 'my super video updated',
 658           category: 10,
 659           licence: 7,
 660           language: 'fr',
 661           nsfw: true,
 662           description: 'my super description updated',
 663           support: 'my super support text updated',
 664           originallyPublishedAt: '2019-02-11T13:38:14.449Z',
 665           account: {
 666             name: 'root',
 667             host: 'localhost:' + servers[2].port
 668           },
 669           isLocal,
 670           duration: 5,
 671           commentsEnabled: true,
 672           downloadEnabled: true,
 673           tags: [ 'tag_up_1', 'tag_up_2' ],
 674           privacy: VideoPrivacy.PUBLIC,
 675           channel: {
 676             displayName: 'Main root channel',
 677             name: 'root_channel',
 678             description: '',
 679             isLocal
 680           },
 681           fixture: 'video_short3.webm',
 682           files: [
 683             {
 684               resolution: 720,
 685               size: 292677
 686             }
 687           ],
 688           thumbnailfile: 'thumbnail',
 689           previewfile: 'preview'
 690         }
 691         await completeVideoCheck(server, videoUpdated, checkAttributes)
 692       }
 693     })
 694
 695     it('Should only update thumbnail and update updatedAt attribute', async function () {
 696       this.timeout(30000)
 697
 698       const attributes = {
 699         thumbnailfile: 'thumbnail.jpg'
 700       }
 701
 702       updatedAtMin = new Date()
 703       await servers[2].videos.update({ id: toRemove[0].id, attributes })
 704
 705       await waitJobs(servers)
 706
 707       for (const server of servers) {
 708         const { data } = await server.videos.list()
 709
 710         const videoUpdated = data.find(video => video.name === 'my super video updated')
 711         expect(new Date(videoUpdated.updatedAt)).to.be.greaterThan(updatedAtMin)
 712       }
 713     })
 714
 715     it('Should remove the videos 3 and 3-2 by asking server 3 and correctly delete files', async function () {
 716       this.timeout(30000)
 717
 718       for (const id of [ toRemove[0].id, toRemove[1].id ]) {
 719         await saveVideoInServers(servers, id)
 720
 721         await servers[2].videos.remove({ id })
 722
 723         await waitJobs(servers)
 724
 725         for (const server of servers) {
 726           await checkVideoFilesWereRemoved({ server, video: server.store.videoDetails })
 727         }
 728       }
 729     })
 730
 731     it('Should have videos 1 and 3 on each server', async function () {
 732       for (const server of servers) {
 733         const { data } = await server.videos.list()
 734
 735         expect(data).to.be.an('array')
 736         expect(data.length).to.equal(2)
 737         expect(data[0].name).not.to.equal(data[1].name)
 738         expect(data[0].name).not.to.equal(toRemove[0].name)
 739         expect(data[1].name).not.to.equal(toRemove[0].name)
 740         expect(data[0].name).not.to.equal(toRemove[1].name)
 741         expect(data[1].name).not.to.equal(toRemove[1].name)
 742
 743         videoUUID = data.find(video => video.name === 'my super name for server 1').uuid
 744       }
 745     })
 746
 747     it('Should get the same video by UUID on each server', async function () {
 748       let baseVideo = null
 749       for (const server of servers) {
 750         const video = await server.videos.get({ id: videoUUID })
 751
 752         if (baseVideo === null) {
 753           baseVideo = video
 754           continue
 755         }
 756
 757         expect(baseVideo.name).to.equal(video.name)
 758         expect(baseVideo.uuid).to.equal(video.uuid)
 759         expect(baseVideo.category.id).to.equal(video.category.id)
 760         expect(baseVideo.language.id).to.equal(video.language.id)
 761         expect(baseVideo.licence.id).to.equal(video.licence.id)
 762         expect(baseVideo.nsfw).to.equal(video.nsfw)
 763         expect(baseVideo.account.name).to.equal(video.account.name)
 764         expect(baseVideo.account.displayName).to.equal(video.account.displayName)
 765         expect(baseVideo.account.url).to.equal(video.account.url)
 766         expect(baseVideo.account.host).to.equal(video.account.host)
 767         expect(baseVideo.tags).to.deep.equal(video.tags)
 768       }
 769     })
 770
 771     it('Should get the preview from each server', async function () {
 772       for (const server of servers) {
 773         const video = await server.videos.get({ id: videoUUID })
 774
 775         await testImage(server.url, 'video_short1-preview.webm', video.previewPath)
 776       }
 777     })
 778   })
 779
 780   describe('Should comment these videos', function () {
 781     let childOfFirstChild: VideoCommentThreadTree
 782
 783     it('Should add comment (threads and replies)', async function () {
 784       this.timeout(25000)
 785
 786       {
 787         const text = 'my super first comment'
 788         await servers[0].comments.createThread({ videoId: videoUUID, text })
 789       }
 790
 791       {
 792         const text = 'my super second comment'
 793         await servers[2].comments.createThread({ videoId: videoUUID, text })
 794       }
 795
 796       await waitJobs(servers)
 797
 798       {
 799         const threadId = await servers[1].comments.findCommentId({ videoId: videoUUID, text: 'my super first comment' })
 800
 801         const text = 'my super answer to thread 1'
 802         await servers[1].comments.addReply({ videoId: videoUUID, toCommentId: threadId, text })
 803       }
 804
 805       await waitJobs(servers)
 806
 807       {
 808         const threadId = await servers[2].comments.findCommentId({ videoId: videoUUID, text: 'my super first comment' })
 809
 810         const body = await servers[2].comments.getThread({ videoId: videoUUID, threadId })
 811         const childCommentId = body.children[0].comment.id
 812
 813         const text3 = 'my second answer to thread 1'
 814         await servers[2].comments.addReply({ videoId: videoUUID, toCommentId: threadId, text: text3 })
 815
 816         const text2 = 'my super answer to answer of thread 1'
 817         await servers[2].comments.addReply({ videoId: videoUUID, toCommentId: childCommentId, text: text2 })
 818       }
 819
 820       await waitJobs(servers)
 821     })
 822
 823     it('Should have these threads', async function () {
 824       for (const server of servers) {
 825         const body = await server.comments.listThreads({ videoId: videoUUID })
 826
 827         expect(body.total).to.equal(2)
 828         expect(body.data).to.be.an('array')
 829         expect(body.data).to.have.lengthOf(2)
 830
 831         {
 832           const comment = body.data.find(c => c.text === 'my super first comment')
 833           expect(comment).to.not.be.undefined
 834           expect(comment.inReplyToCommentId).to.be.null
 835           expect(comment.account.name).to.equal('root')
 836           expect(comment.account.host).to.equal('localhost:' + servers[0].port)
 837           expect(comment.totalReplies).to.equal(3)
 838           expect(dateIsValid(comment.createdAt as string)).to.be.true
 839           expect(dateIsValid(comment.updatedAt as string)).to.be.true
 840         }
 841
 842         {
 843           const comment = body.data.find(c => c.text === 'my super second comment')
 844           expect(comment).to.not.be.undefined
 845           expect(comment.inReplyToCommentId).to.be.null
 846           expect(comment.account.name).to.equal('root')
 847           expect(comment.account.host).to.equal('localhost:' + servers[2].port)
 848           expect(comment.totalReplies).to.equal(0)
 849           expect(dateIsValid(comment.createdAt as string)).to.be.true
 850           expect(dateIsValid(comment.updatedAt as string)).to.be.true
 851         }
 852       }
 853     })
 854
 855     it('Should have these comments', async function () {
 856       for (const server of servers) {
 857         const body = await server.comments.listThreads({ videoId: videoUUID })
 858         const threadId = body.data.find(c => c.text === 'my super first comment').id
 859
 860         const tree = await server.comments.getThread({ videoId: videoUUID, threadId })
 861
 862         expect(tree.comment.text).equal('my super first comment')
 863         expect(tree.comment.account.name).equal('root')
 864         expect(tree.comment.account.host).equal('localhost:' + servers[0].port)
 865         expect(tree.children).to.have.lengthOf(2)
 866
 867         const firstChild = tree.children[0]
 868         expect(firstChild.comment.text).to.equal('my super answer to thread 1')
 869         expect(firstChild.comment.account.name).equal('root')
 870         expect(firstChild.comment.account.host).equal('localhost:' + servers[1].port)
 871         expect(firstChild.children).to.have.lengthOf(1)
 872
 873         childOfFirstChild = firstChild.children[0]
 874         expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
 875         expect(childOfFirstChild.comment.account.name).equal('root')
 876         expect(childOfFirstChild.comment.account.host).equal('localhost:' + servers[2].port)
 877         expect(childOfFirstChild.children).to.have.lengthOf(0)
 878
 879         const secondChild = tree.children[1]
 880         expect(secondChild.comment.text).to.equal('my second answer to thread 1')
 881         expect(secondChild.comment.account.name).equal('root')
 882         expect(secondChild.comment.account.host).equal('localhost:' + servers[2].port)
 883         expect(secondChild.children).to.have.lengthOf(0)
 884       }
 885     })
 886
 887     it('Should delete a reply', async function () {
 888       this.timeout(30000)
 889
 890       await servers[2].comments.delete({ videoId: videoUUID, commentId: childOfFirstChild.comment.id })
 891
 892       await waitJobs(servers)
 893     })
 894
 895     it('Should have this comment marked as deleted', async function () {
 896       for (const server of servers) {
 897         const { data } = await server.comments.listThreads({ videoId: videoUUID })
 898         const threadId = data.find(c => c.text === 'my super first comment').id
 899
 900         const tree = await server.comments.getThread({ videoId: videoUUID, threadId })
 901         expect(tree.comment.text).equal('my super first comment')
 902
 903         const firstChild = tree.children[0]
 904         expect(firstChild.comment.text).to.equal('my super answer to thread 1')
 905         expect(firstChild.children).to.have.lengthOf(1)
 906
 907         const deletedComment = firstChild.children[0].comment
 908         expect(deletedComment.isDeleted).to.be.true
 909         expect(deletedComment.deletedAt).to.not.be.null
 910         expect(deletedComment.account).to.be.null
 911         expect(deletedComment.text).to.equal('')
 912
 913         const secondChild = tree.children[1]
 914         expect(secondChild.comment.text).to.equal('my second answer to thread 1')
 915       }
 916     })
 917
 918     it('Should delete the thread comments', async function () {
 919       this.timeout(30000)
 920
 921       const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
 922       const commentId = data.find(c => c.text === 'my super first comment').id
 923       await servers[0].comments.delete({ videoId: videoUUID, commentId })
 924
 925       await waitJobs(servers)
 926     })
 927
 928     it('Should have the threads marked as deleted on other servers too', async function () {
 929       for (const server of servers) {
 930         const body = await server.comments.listThreads({ videoId: videoUUID })
 931
 932         expect(body.total).to.equal(2)
 933         expect(body.data).to.be.an('array')
 934         expect(body.data).to.have.lengthOf(2)
 935
 936         {
 937           const comment = body.data[0]
 938           expect(comment).to.not.be.undefined
 939           expect(comment.inReplyToCommentId).to.be.null
 940           expect(comment.account.name).to.equal('root')
 941           expect(comment.account.host).to.equal('localhost:' + servers[2].port)
 942           expect(comment.totalReplies).to.equal(0)
 943           expect(dateIsValid(comment.createdAt as string)).to.be.true
 944           expect(dateIsValid(comment.updatedAt as string)).to.be.true
 945         }
 946
 947         {
 948           const deletedComment = body.data[1]
 949           expect(deletedComment).to.not.be.undefined
 950           expect(deletedComment.isDeleted).to.be.true
 951           expect(deletedComment.deletedAt).to.not.be.null
 952           expect(deletedComment.text).to.equal('')
 953           expect(deletedComment.inReplyToCommentId).to.be.null
 954           expect(deletedComment.account).to.be.null
 955           expect(deletedComment.totalReplies).to.equal(2)
 956           expect(dateIsValid(deletedComment.createdAt as string)).to.be.true
 957           expect(dateIsValid(deletedComment.updatedAt as string)).to.be.true
 958           expect(dateIsValid(deletedComment.deletedAt as string)).to.be.true
 959         }
 960       }
 961     })
 962
 963     it('Should delete a remote thread by the origin server', async function () {
 964       this.timeout(5000)
 965
 966       const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
 967       const commentId = data.find(c => c.text === 'my super second comment').id
 968       await servers[0].comments.delete({ videoId: videoUUID, commentId })
 969
 970       await waitJobs(servers)
 971     })
 972
 973     it('Should have the threads marked as deleted on other servers too', async function () {
 974       for (const server of servers) {
 975         const body = await server.comments.listThreads({ videoId: videoUUID })
 976
 977         expect(body.total).to.equal(2)
 978         expect(body.data).to.have.lengthOf(2)
 979
 980         {
 981           const comment = body.data[0]
 982           expect(comment.text).to.equal('')
 983           expect(comment.isDeleted).to.be.true
 984           expect(comment.createdAt).to.not.be.null
 985           expect(comment.deletedAt).to.not.be.null
 986           expect(comment.account).to.be.null
 987           expect(comment.totalReplies).to.equal(0)
 988         }
 989
 990         {
 991           const comment = body.data[1]
 992           expect(comment.text).to.equal('')
 993           expect(comment.isDeleted).to.be.true
 994           expect(comment.createdAt).to.not.be.null
 995           expect(comment.deletedAt).to.not.be.null
 996           expect(comment.account).to.be.null
 997           expect(comment.totalReplies).to.equal(2)
 998         }
 999       }
1000     })
1001
1002     it('Should disable comments and download', async function () {
1003       this.timeout(20000)
1004
1005       const attributes = {
1006         commentsEnabled: false,
1007         downloadEnabled: false
1008       }
1009
1010       await servers[0].videos.update({ id: videoUUID, attributes })
1011
1012       await waitJobs(servers)
1013
1014       for (const server of servers) {
1015         const video = await server.videos.get({ id: videoUUID })
1016         expect(video.commentsEnabled).to.be.false
1017         expect(video.downloadEnabled).to.be.false
1018
1019         const text = 'my super forbidden comment'
1020         await server.comments.createThread({ videoId: videoUUID, text, expectedStatus: HttpStatusCode.CONFLICT_409 })
1021       }
1022     })
1023   })
1024
1025   describe('With minimum parameters', function () {
1026     it('Should upload and propagate the video', async function () {
1027       this.timeout(60000)
1028
1029       const path = '/api/v1/videos/upload'
1030
1031       const req = request(servers[1].url)
1032         .post(path)
1033         .set('Accept', 'application/json')
1034         .set('Authorization', 'Bearer ' + servers[1].accessToken)
1035         .field('name', 'minimum parameters')
1036         .field('privacy', '1')
1037         .field('channelId', '1')
1038
1039       await req.attach('videofile', buildAbsoluteFixturePath('video_short.webm'))
1040                .expect(HttpStatusCode.OK_200)
1041
1042       await waitJobs(servers)
1043
1044       for (const server of servers) {
1045         const { data } = await server.videos.list()
1046         const video = data.find(v => v.name === 'minimum parameters')
1047
1048         const isLocal = server.url === 'http://localhost:' + servers[1].port
1049         const checkAttributes = {
1050           name: 'minimum parameters',
1051           category: null,
1052           licence: null,
1053           language: null,
1054           nsfw: false,
1055           description: null,
1056           support: null,
1057           account: {
1058             name: 'root',
1059             host: 'localhost:' + servers[1].port
1060           },
1061           isLocal,
1062           duration: 5,
1063           commentsEnabled: true,
1064           downloadEnabled: true,
1065           tags: [],
1066           privacy: VideoPrivacy.PUBLIC,
1067           channel: {
1068             displayName: 'Main root channel',
1069             name: 'root_channel',
1070             description: '',
1071             isLocal
1072           },
1073           fixture: 'video_short.webm',
1074           files: [
1075             {
1076               resolution: 720,
1077               size: 61000
1078             },
1079             {
1080               resolution: 480,
1081               size: 40000
1082             },
1083             {
1084               resolution: 360,
1085               size: 32000
1086             },
1087             {
1088               resolution: 240,
1089               size: 23000
1090             }
1091           ]
1092         }
1093         await completeVideoCheck(server, video, checkAttributes)
1094       }
1095     })
1096   })
1097
1098   describe('TMP directory', function () {
1099     it('Should have an empty tmp directory', async function () {
1100       for (const server of servers) {
1101         await checkTmpIsEmpty(server)
1102       }
1103     })
1104   })
1105
1106   after(async function () {
1107     await cleanupTests(servers)
1108   })
1109 })