server/tests/api/server/handle-down.ts

   1 /* tslint:disable:no-unused-expression */
   2
   3 import * as chai from 'chai'
   4 import 'mocha'
   5 import { JobState } from '../../../../shared/models'
   6 import { VideoPrivacy } from '../../../../shared/models/videos'
   7 import { VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
   8 import { completeVideoCheck, getVideo, immutableAssign, reRunServer, viewVideo } from '../../utils'
   9
  10 import {
  11   flushAndRunMultipleServers, flushTests, getVideosList, killallServers, ServerInfo, setAccessTokensToServers, uploadVideo,
  12   wait
  13 } from '../../utils/index'
  14 import { follow, getFollowersListPaginationAndSort } from '../../utils/server/follows'
  15 import { getJobsListPaginationAndSort, waitJobs } from '../../utils/server/jobs'
  16 import {
  17   addVideoCommentReply, addVideoCommentThread, getVideoCommentThreads,
  18   getVideoThreadComments
  19 } from '../../utils/videos/video-comments'
  20
  21 const expect = chai.expect
  22
  23 describe('Test handle downs', function () {
  24   let servers: ServerInfo[] = []
  25   const videos = []
  26   let threadIdServer1: number
  27   let threadIdServer2: number
  28   let commentIdServer1: number
  29   let commentIdServer2: number
  30
  31   const videoAttributes = {
  32     name: 'my super name for server 1',
  33     category: 5,
  34     licence: 4,
  35     language: 'ja',
  36     nsfw: true,
  37     privacy: VideoPrivacy.PUBLIC,
  38     description: 'my super description for server 1',
  39     support: 'my super support text for server 1',
  40     tags: [ 'tag1p1', 'tag2p1' ],
  41     fixture: 'video_short1.webm'
  42   }
  43
  44   const unlistedVideoAttributes = immutableAssign(videoAttributes, {
  45     privacy: VideoPrivacy.UNLISTED
  46   })
  47
  48   const checkAttributes = {
  49     name: 'my super name for server 1',
  50     category: 5,
  51     licence: 4,
  52     language: 'ja',
  53     nsfw: true,
  54     description: 'my super description for server 1',
  55     support: 'my super support text for server 1',
  56     account: {
  57       name: 'root',
  58       host: 'localhost:9001'
  59     },
  60     isLocal: false,
  61     duration: 10,
  62     tags: [ 'tag1p1', 'tag2p1' ],
  63     privacy: VideoPrivacy.PUBLIC,
  64     commentsEnabled: true,
  65     channel: {
  66       name: 'Default root channel',
  67       description: '',
  68       isLocal: false
  69     },
  70     fixture: 'video_short1.webm',
  71     files: [
  72       {
  73         resolution: 720,
  74         size: 572456
  75       }
  76     ]
  77   }
  78
  79   const unlistedCheckAttributes = immutableAssign(checkAttributes, {
  80     privacy: VideoPrivacy.UNLISTED
  81   })
  82
  83   before(async function () {
  84     this.timeout(30000)
  85
  86     servers = await flushAndRunMultipleServers(2)
  87
  88     // Get the access tokens
  89     await setAccessTokensToServers(servers)
  90   })
  91
  92   it('Should remove followers that are often down', async function () {
  93     this.timeout(60000)
  94
  95     await follow(servers[1].url, [ servers[0].url ], servers[1].accessToken)
  96
  97     await waitJobs(servers)
  98
  99     await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
 100
 101     await waitJobs(servers)
 102
 103     for (const server of servers) {
 104       const res = await getVideosList(server.url)
 105       expect(res.body.data).to.be.an('array')
 106       expect(res.body.data).to.have.lengthOf(1)
 107     }
 108
 109     // Kill server 1
 110     killallServers([ servers[1] ])
 111
 112     let resVideo = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, unlistedVideoAttributes)
 113     videos.push(resVideo.body.video)
 114
 115     // Remove server 2 follower
 116     for (let i = 0; i < 10; i++) {
 117       resVideo = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, videoAttributes)
 118       videos.push(resVideo.body.video)
 119     }
 120
 121     await waitJobs(servers[0])
 122
 123     await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, videoAttributes)
 124
 125     // Add comments to video 2
 126     {
 127       const text = 'thread 1'
 128       let resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, videos[1].uuid, text)
 129       let comment = resComment.body.comment
 130       threadIdServer1 = comment.id
 131
 132       resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, videos[1].uuid, comment.id, 'comment 1-1')
 133       comment = resComment.body.comment
 134
 135       resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, videos[1].uuid, comment.id, 'comment 1-2')
 136       commentIdServer1 = resComment.body.comment.id
 137     }
 138
 139     await waitJobs(servers[0])
 140     // Wait scheduler
 141     await wait(11000)
 142
 143     const res = await getFollowersListPaginationAndSort(servers[0].url, 0, 1, 'createdAt')
 144     expect(res.body.data).to.be.an('array')
 145     expect(res.body.data).to.have.lengthOf(0)
 146   })
 147
 148   it('Should not have pending/processing jobs anymore', async function () {
 149     const states: JobState[] = [ 'inactive', 'active' ]
 150
 151     for (const state of states) {
 152       const res = await getJobsListPaginationAndSort(servers[ 0 ].url, servers[ 0 ].accessToken, state,0, 50, '-createdAt')
 153       expect(res.body.data).to.have.length(0)
 154     }
 155   })
 156
 157   it('Should follow server 1', async function () {
 158     this.timeout(15000)
 159
 160     await reRunServer(servers[1])
 161
 162     await follow(servers[1].url, [ servers[0].url ], servers[1].accessToken)
 163
 164     await waitJobs(servers)
 165
 166     const res = await getFollowersListPaginationAndSort(servers[0].url, 0, 1, 'createdAt')
 167     expect(res.body.data).to.be.an('array')
 168     expect(res.body.data).to.have.lengthOf(1)
 169   })
 170
 171   it('Should send a view to server 2, and automatically fetch the video', async function () {
 172     this.timeout(15000)
 173
 174     await viewVideo(servers[0].url, videos[0].uuid)
 175
 176     await waitJobs(servers)
 177
 178     const res = await getVideosList(servers[1].url)
 179     expect(res.body.data).to.be.an('array')
 180     // Video is unlisted
 181     expect(res.body.data).to.have.lengthOf(1)
 182
 183     const resVideo = await getVideo(servers[1].url, videos[0].uuid)
 184     expect(resVideo.body).not.to.be.undefined
 185
 186     await completeVideoCheck(servers[1].url, resVideo.body, unlistedCheckAttributes)
 187   })
 188
 189   it('Should send comments on a video to server 2, and automatically fetch the video', async function () {
 190     this.timeout(25000)
 191
 192     await addVideoCommentReply(servers[0].url, servers[0].accessToken, videos[1].uuid, commentIdServer1, 'comment 1-3')
 193
 194     await waitJobs(servers)
 195
 196     const resVideo = await getVideo(servers[1].url, videos[0].uuid)
 197     expect(resVideo.body).not.to.be.undefined
 198
 199     await completeVideoCheck(servers[1].url, resVideo.body, unlistedCheckAttributes)
 200
 201     {
 202       let resComment = await getVideoCommentThreads(servers[1].url, videos[1].uuid, 0, 5)
 203       expect(resComment.body.data).to.be.an('array')
 204       expect(resComment.body.data).to.have.lengthOf(1)
 205
 206       threadIdServer2 = resComment.body.data[0].id
 207
 208       resComment = await getVideoThreadComments(servers[1].url, videos[1].uuid, threadIdServer2)
 209
 210       const tree: VideoCommentThreadTree = resComment.body
 211       expect(tree.comment.text).equal('thread 1')
 212       expect(tree.children).to.have.lengthOf(1)
 213
 214       const firstChild = tree.children[0]
 215       expect(firstChild.comment.text).to.equal('comment 1-1')
 216       expect(firstChild.children).to.have.lengthOf(1)
 217
 218       const childOfFirstChild = firstChild.children[0]
 219       expect(childOfFirstChild.comment.text).to.equal('comment 1-2')
 220       expect(childOfFirstChild.children).to.have.lengthOf(1)
 221
 222       const childOfChildFirstChild = childOfFirstChild.children[0]
 223       expect(childOfChildFirstChild.comment.text).to.equal('comment 1-3')
 224       expect(childOfChildFirstChild.children).to.have.lengthOf(0)
 225
 226       commentIdServer2 = childOfChildFirstChild.comment.id
 227     }
 228   })
 229
 230   it('Should correctly reply to the comment', async function () {
 231     this.timeout(15000)
 232
 233     await addVideoCommentReply(servers[1].url, servers[1].accessToken, videos[1].uuid, commentIdServer2, 'comment 1-4')
 234
 235     await waitJobs(servers)
 236
 237     {
 238       const resComment = await getVideoThreadComments(servers[0].url, videos[1].uuid, threadIdServer1)
 239
 240       const tree: VideoCommentThreadTree = resComment.body
 241       expect(tree.comment.text).equal('thread 1')
 242       expect(tree.children).to.have.lengthOf(1)
 243
 244       const firstChild = tree.children[0]
 245       expect(firstChild.comment.text).to.equal('comment 1-1')
 246       expect(firstChild.children).to.have.lengthOf(1)
 247
 248       const childOfFirstChild = firstChild.children[0]
 249       expect(childOfFirstChild.comment.text).to.equal('comment 1-2')
 250       expect(childOfFirstChild.children).to.have.lengthOf(1)
 251
 252       const childOfChildFirstChild = childOfFirstChild.children[0]
 253       expect(childOfChildFirstChild.comment.text).to.equal('comment 1-3')
 254       expect(childOfChildFirstChild.children).to.have.lengthOf(1)
 255
 256       const childOfChildOfChildOfFirstChild = childOfChildFirstChild.children[0]
 257       expect(childOfChildOfChildOfFirstChild.comment.text).to.equal('comment 1-4')
 258       expect(childOfChildOfChildOfFirstChild.children).to.have.lengthOf(0)
 259     }
 260   })
 261
 262   after(async function () {
 263     killallServers(servers)
 264   })
 265 })