server/tests/plugins/plugin-helpers.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import { expect } from 'chai'
   5 import { pathExists } from 'fs-extra'
   6 import { HttpStatusCode, ThumbnailType } from '@shared/models'
   7 import {
   8   cleanupTests,
   9   createMultipleServers,
  10   doubleFollow,
  11   makeGetRequest,
  12   makePostBodyRequest,
  13   makeRawRequest,
  14   PeerTubeServer,
  15   PluginsCommand,
  16   setAccessTokensToServers,
  17   waitJobs
  18 } from '@shared/server-commands'
  19 import { checkVideoFilesWereRemoved } from '../shared'
  20
  21 function postCommand (server: PeerTubeServer, command: string, bodyArg?: object) {
  22   const body = { command }
  23   if (bodyArg) Object.assign(body, bodyArg)
  24
  25   return makePostBodyRequest({
  26     url: server.url,
  27     path: '/plugins/test-four/router/commander',
  28     fields: body,
  29     expectedStatus: HttpStatusCode.NO_CONTENT_204
  30   })
  31 }
  32
  33 describe('Test plugin helpers', function () {
  34   let servers: PeerTubeServer[]
  35
  36   before(async function () {
  37     this.timeout(60000)
  38
  39     servers = await createMultipleServers(2)
  40     await setAccessTokensToServers(servers)
  41
  42     await doubleFollow(servers[0], servers[1])
  43
  44     await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath('-four') })
  45   })
  46
  47   describe('Logger', function () {
  48
  49     it('Should have logged things', async function () {
  50       await servers[0].servers.waitUntilLog('localhost:' + servers[0].port + ' peertube-plugin-test-four', 1, false)
  51       await servers[0].servers.waitUntilLog('Hello world from plugin four', 1)
  52     })
  53   })
  54
  55   describe('Database', function () {
  56
  57     it('Should have made a query', async function () {
  58       await servers[0].servers.waitUntilLog(`root email is admin${servers[0].internalServerNumber}@example.com`)
  59     })
  60   })
  61
  62   describe('Config', function () {
  63
  64     it('Should have the correct webserver url', async function () {
  65       await servers[0].servers.waitUntilLog(`server url is http://localhost:${servers[0].port}`)
  66     })
  67
  68     it('Should have the correct config', async function () {
  69       const res = await makeGetRequest({
  70         url: servers[0].url,
  71         path: '/plugins/test-four/router/server-config',
  72         expectedStatus: HttpStatusCode.OK_200
  73       })
  74
  75       expect(res.body.serverConfig).to.exist
  76       expect(res.body.serverConfig.instance.name).to.equal('PeerTube')
  77     })
  78   })
  79
  80   describe('Server', function () {
  81
  82     it('Should get the server actor', async function () {
  83       await servers[0].servers.waitUntilLog('server actor name is peertube')
  84     })
  85   })
  86
  87   describe('Plugin', function () {
  88
  89     it('Should get the base static route', async function () {
  90       const res = await makeGetRequest({
  91         url: servers[0].url,
  92         path: '/plugins/test-four/router/static-route',
  93         expectedStatus: HttpStatusCode.OK_200
  94       })
  95
  96       expect(res.body.staticRoute).to.equal('/plugins/test-four/0.0.1/static/')
  97     })
  98
  99     it('Should get the base static route', async function () {
 100       const baseRouter = '/plugins/test-four/0.0.1/router/'
 101
 102       const res = await makeGetRequest({
 103         url: servers[0].url,
 104         path: baseRouter + 'router-route',
 105         expectedStatus: HttpStatusCode.OK_200
 106       })
 107
 108       expect(res.body.routerRoute).to.equal(baseRouter)
 109     })
 110   })
 111
 112   describe('User', function () {
 113     let rootId: number
 114
 115     it('Should not get a user if not authenticated', async function () {
 116       await makeGetRequest({
 117         url: servers[0].url,
 118         path: '/plugins/test-four/router/user',
 119         expectedStatus: HttpStatusCode.NOT_FOUND_404
 120       })
 121     })
 122
 123     it('Should get a user if authenticated', async function () {
 124       const res = await makeGetRequest({
 125         url: servers[0].url,
 126         token: servers[0].accessToken,
 127         path: '/plugins/test-four/router/user',
 128         expectedStatus: HttpStatusCode.OK_200
 129       })
 130
 131       expect(res.body.username).to.equal('root')
 132       expect(res.body.displayName).to.equal('root')
 133       expect(res.body.isAdmin).to.be.true
 134       expect(res.body.isModerator).to.be.false
 135       expect(res.body.isUser).to.be.false
 136
 137       rootId = res.body.id
 138     })
 139
 140     it('Should load a user by id', async function () {
 141       {
 142         const res = await makeGetRequest({
 143           url: servers[0].url,
 144           path: '/plugins/test-four/router/user/' + rootId,
 145           expectedStatus: HttpStatusCode.OK_200
 146         })
 147
 148         expect(res.body.username).to.equal('root')
 149       }
 150
 151       {
 152         await makeGetRequest({
 153           url: servers[0].url,
 154           path: '/plugins/test-four/router/user/42',
 155           expectedStatus: HttpStatusCode.NOT_FOUND_404
 156         })
 157       }
 158     })
 159   })
 160
 161   describe('Moderation', function () {
 162     let videoUUIDServer1: string
 163
 164     before(async function () {
 165       this.timeout(60000)
 166
 167       {
 168         const res = await servers[0].videos.quickUpload({ name: 'video server 1' })
 169         videoUUIDServer1 = res.uuid
 170       }
 171
 172       {
 173         await servers[1].videos.quickUpload({ name: 'video server 2' })
 174       }
 175
 176       await waitJobs(servers)
 177
 178       const { data } = await servers[0].videos.list()
 179
 180       expect(data).to.have.lengthOf(2)
 181     })
 182
 183     it('Should mute server 2', async function () {
 184       this.timeout(10000)
 185       await postCommand(servers[0], 'blockServer', { hostToBlock: `localhost:${servers[1].port}` })
 186
 187       const { data } = await servers[0].videos.list()
 188
 189       expect(data).to.have.lengthOf(1)
 190       expect(data[0].name).to.equal('video server 1')
 191     })
 192
 193     it('Should unmute server 2', async function () {
 194       await postCommand(servers[0], 'unblockServer', { hostToUnblock: `localhost:${servers[1].port}` })
 195
 196       const { data } = await servers[0].videos.list()
 197
 198       expect(data).to.have.lengthOf(2)
 199     })
 200
 201     it('Should mute account of server 2', async function () {
 202       await postCommand(servers[0], 'blockAccount', { handleToBlock: `root@localhost:${servers[1].port}` })
 203
 204       const { data } = await servers[0].videos.list()
 205
 206       expect(data).to.have.lengthOf(1)
 207       expect(data[0].name).to.equal('video server 1')
 208     })
 209
 210     it('Should unmute account of server 2', async function () {
 211       await postCommand(servers[0], 'unblockAccount', { handleToUnblock: `root@localhost:${servers[1].port}` })
 212
 213       const { data } = await servers[0].videos.list()
 214
 215       expect(data).to.have.lengthOf(2)
 216     })
 217
 218     it('Should blacklist video', async function () {
 219       this.timeout(10000)
 220
 221       await postCommand(servers[0], 'blacklist', { videoUUID: videoUUIDServer1, unfederate: true })
 222
 223       await waitJobs(servers)
 224
 225       for (const server of servers) {
 226         const { data } = await server.videos.list()
 227
 228         expect(data).to.have.lengthOf(1)
 229         expect(data[0].name).to.equal('video server 2')
 230       }
 231     })
 232
 233     it('Should unblacklist video', async function () {
 234       this.timeout(10000)
 235
 236       await postCommand(servers[0], 'unblacklist', { videoUUID: videoUUIDServer1 })
 237
 238       await waitJobs(servers)
 239
 240       for (const server of servers) {
 241         const { data } = await server.videos.list()
 242
 243         expect(data).to.have.lengthOf(2)
 244       }
 245     })
 246   })
 247
 248   describe('Videos', function () {
 249     let videoUUID: string
 250     let videoPath: string
 251
 252     before(async () => {
 253       this.timeout(240000)
 254
 255       await servers[0].config.enableTranscoding()
 256
 257       const res = await servers[0].videos.quickUpload({ name: 'video1' })
 258       videoUUID = res.uuid
 259
 260       await waitJobs(servers)
 261     })
 262
 263     it('Should get video files', async function () {
 264       const { body } = await makeGetRequest({
 265         url: servers[0].url,
 266         path: '/plugins/test-four/router/video-files/' + videoUUID,
 267         expectedStatus: HttpStatusCode.OK_200
 268       })
 269
 270       // Video files check
 271       {
 272         expect(body.webtorrent.videoFiles).to.be.an('array')
 273         expect(body.hls.videoFiles).to.be.an('array')
 274
 275         for (const resolution of [ 144, 240, 360, 480, 720 ]) {
 276           for (const files of [ body.webtorrent.videoFiles, body.hls.videoFiles ]) {
 277             const file = files.find(f => f.resolution === resolution)
 278             expect(file).to.exist
 279
 280             expect(file.size).to.be.a('number')
 281             expect(file.fps).to.equal(25)
 282
 283             expect(await pathExists(file.path)).to.be.true
 284             await makeRawRequest(file.url, HttpStatusCode.OK_200)
 285           }
 286         }
 287
 288         videoPath = body.webtorrent.videoFiles[0].path
 289       }
 290
 291       // Thumbnails check
 292       {
 293         expect(body.thumbnails).to.be.an('array')
 294
 295         const miniature = body.thumbnails.find(t => t.type === ThumbnailType.MINIATURE)
 296         expect(miniature).to.exist
 297         expect(await pathExists(miniature.path)).to.be.true
 298         await makeRawRequest(miniature.url, HttpStatusCode.OK_200)
 299
 300         const preview = body.thumbnails.find(t => t.type === ThumbnailType.PREVIEW)
 301         expect(preview).to.exist
 302         expect(await pathExists(preview.path)).to.be.true
 303         await makeRawRequest(preview.url, HttpStatusCode.OK_200)
 304       }
 305     })
 306
 307     it('Should probe a file', async function () {
 308       const { body } = await makeGetRequest({
 309         url: servers[0].url,
 310         path: '/plugins/test-four/router/ffprobe',
 311         query: {
 312           path: videoPath
 313         },
 314         expectedStatus: HttpStatusCode.OK_200
 315       })
 316
 317       expect(body.streams).to.be.an('array')
 318       expect(body.streams).to.have.lengthOf(2)
 319     })
 320
 321     it('Should remove a video after a view', async function () {
 322       this.timeout(40000)
 323
 324       // Should not throw -> video exists
 325       const video = await servers[0].videos.get({ id: videoUUID })
 326       // Should delete the video
 327       await servers[0].views.simulateView({ id: videoUUID })
 328
 329       await servers[0].servers.waitUntilLog('Video deleted by plugin four.')
 330
 331       try {
 332         // Should throw because the video should have been deleted
 333         await servers[0].videos.get({ id: videoUUID })
 334         throw new Error('Video exists')
 335       } catch (err) {
 336         if (err.message.includes('exists')) throw err
 337       }
 338
 339       await checkVideoFilesWereRemoved({ server: servers[0], video })
 340     })
 341
 342     it('Should have fetched the video by URL', async function () {
 343       await servers[0].servers.waitUntilLog(`video from DB uuid is ${videoUUID}`)
 344     })
 345   })
 346
 347   after(async function () {
 348     await cleanupTests(servers)
 349   })
 350 })