server/tests/plugins/plugin-helpers.ts

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