server/tests/api/server/plugins.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 { HttpStatusCode } from '@shared/core-utils'
   6 import {
   7   cleanupTests,
   8   flushAndRunServer,
   9   getMyUserInformation,
  10   killallServers,
  11   PluginsCommand,
  12   reRunServer,
  13   ServerInfo,
  14   setAccessTokensToServers,
  15   testHelloWorldRegisteredSettings,
  16   updateMyUser,
  17   wait,
  18   waitUntilLog
  19 } from '@shared/extra-utils'
  20 import { PluginType, User } from '@shared/models'
  21
  22 const expect = chai.expect
  23
  24 describe('Test plugins', function () {
  25   let server: ServerInfo = null
  26   let command: PluginsCommand
  27
  28   before(async function () {
  29     this.timeout(30000)
  30
  31     const configOverride = {
  32       plugins: {
  33         index: { check_latest_versions_interval: '5 seconds' }
  34       }
  35     }
  36     server = await flushAndRunServer(1, configOverride)
  37     await setAccessTokensToServers([ server ])
  38
  39     command = server.pluginsCommand
  40   })
  41
  42   it('Should list and search available plugins and themes', async function () {
  43     this.timeout(30000)
  44
  45     {
  46       const body = await command.listAvailable({
  47         count: 1,
  48         start: 0,
  49         pluginType: PluginType.THEME,
  50         search: 'background-red'
  51       })
  52
  53       expect(body.total).to.be.at.least(1)
  54       expect(body.data).to.have.lengthOf(1)
  55     }
  56
  57     {
  58       const body1 = await command.listAvailable({
  59         count: 2,
  60         start: 0,
  61         sort: 'npmName'
  62       })
  63       expect(body1.total).to.be.at.least(2)
  64
  65       const data1 = body1.data
  66       expect(data1).to.have.lengthOf(2)
  67
  68       const body2 = await command.listAvailable({
  69         count: 2,
  70         start: 0,
  71         sort: '-npmName'
  72       })
  73       expect(body2.total).to.be.at.least(2)
  74
  75       const data2 = body2.data
  76       expect(data2).to.have.lengthOf(2)
  77
  78       expect(data1[0].npmName).to.not.equal(data2[0].npmName)
  79     }
  80
  81     {
  82       const body = await command.listAvailable({
  83         count: 10,
  84         start: 0,
  85         pluginType: PluginType.THEME,
  86         search: 'background-red',
  87         currentPeerTubeEngine: '1.0.0'
  88       })
  89
  90       const p = body.data.find(p => p.npmName === 'peertube-theme-background-red')
  91       expect(p).to.be.undefined
  92     }
  93   })
  94
  95   it('Should install a plugin and a theme', async function () {
  96     this.timeout(30000)
  97
  98     await command.install({ npmName: 'peertube-plugin-hello-world' })
  99     await command.install({ npmName: 'peertube-theme-background-red' })
 100   })
 101
 102   it('Should have the plugin loaded in the configuration', async function () {
 103     const config = await server.configCommand.getConfig()
 104
 105     const theme = config.theme.registered.find(r => r.name === 'background-red')
 106     expect(theme).to.not.be.undefined
 107
 108     const plugin = config.plugin.registered.find(r => r.name === 'hello-world')
 109     expect(plugin).to.not.be.undefined
 110   })
 111
 112   it('Should update the default theme in the configuration', async function () {
 113     await server.configCommand.updateCustomSubConfig({
 114       newConfig: {
 115         theme: { default: 'background-red' }
 116       }
 117     })
 118
 119     const config = await server.configCommand.getConfig()
 120     expect(config.theme.default).to.equal('background-red')
 121   })
 122
 123   it('Should update my default theme', async function () {
 124     await updateMyUser({
 125       url: server.url,
 126       accessToken: server.accessToken,
 127       theme: 'background-red'
 128     })
 129
 130     const res = await getMyUserInformation(server.url, server.accessToken)
 131     expect((res.body as User).theme).to.equal('background-red')
 132   })
 133
 134   it('Should list plugins and themes', async function () {
 135     {
 136       const body = await command.list({
 137         count: 1,
 138         start: 0,
 139         pluginType: PluginType.THEME
 140       })
 141       expect(body.total).to.be.at.least(1)
 142
 143       const data = body.data
 144       expect(data).to.have.lengthOf(1)
 145       expect(data[0].name).to.equal('background-red')
 146     }
 147
 148     {
 149       const { data } = await command.list({
 150         count: 2,
 151         start: 0,
 152         sort: 'name'
 153       })
 154
 155       expect(data[0].name).to.equal('background-red')
 156       expect(data[1].name).to.equal('hello-world')
 157     }
 158
 159     {
 160       const body = await command.list({
 161         count: 2,
 162         start: 1,
 163         sort: 'name'
 164       })
 165
 166       expect(body.data[0].name).to.equal('hello-world')
 167     }
 168   })
 169
 170   it('Should get registered settings', async function () {
 171     await testHelloWorldRegisteredSettings(server)
 172   })
 173
 174   it('Should get public settings', async function () {
 175     const body = await command.getPublicSettings({ npmName: 'peertube-plugin-hello-world' })
 176     const publicSettings = body.publicSettings
 177
 178     expect(Object.keys(publicSettings)).to.have.lengthOf(1)
 179     expect(Object.keys(publicSettings)).to.deep.equal([ 'user-name' ])
 180     expect(publicSettings['user-name']).to.be.null
 181   })
 182
 183   it('Should update the settings', async function () {
 184     const settings = {
 185       'admin-name': 'Cid'
 186     }
 187
 188     await command.updateSettings({
 189       npmName: 'peertube-plugin-hello-world',
 190       settings
 191     })
 192   })
 193
 194   it('Should have watched settings changes', async function () {
 195     this.timeout(10000)
 196
 197     await waitUntilLog(server, 'Settings changed!')
 198   })
 199
 200   it('Should get a plugin and a theme', async function () {
 201     {
 202       const plugin = await command.get({ npmName: 'peertube-plugin-hello-world' })
 203
 204       expect(plugin.type).to.equal(PluginType.PLUGIN)
 205       expect(plugin.name).to.equal('hello-world')
 206       expect(plugin.description).to.exist
 207       expect(plugin.homepage).to.exist
 208       expect(plugin.uninstalled).to.be.false
 209       expect(plugin.enabled).to.be.true
 210       expect(plugin.description).to.exist
 211       expect(plugin.version).to.exist
 212       expect(plugin.peertubeEngine).to.exist
 213       expect(plugin.createdAt).to.exist
 214
 215       expect(plugin.settings).to.not.be.undefined
 216       expect(plugin.settings['admin-name']).to.equal('Cid')
 217     }
 218
 219     {
 220       const plugin = await command.get({ npmName: 'peertube-theme-background-red' })
 221
 222       expect(plugin.type).to.equal(PluginType.THEME)
 223       expect(plugin.name).to.equal('background-red')
 224       expect(plugin.description).to.exist
 225       expect(plugin.homepage).to.exist
 226       expect(plugin.uninstalled).to.be.false
 227       expect(plugin.enabled).to.be.true
 228       expect(plugin.description).to.exist
 229       expect(plugin.version).to.exist
 230       expect(plugin.peertubeEngine).to.exist
 231       expect(plugin.createdAt).to.exist
 232
 233       expect(plugin.settings).to.be.null
 234     }
 235   })
 236
 237   it('Should update the plugin and the theme', async function () {
 238     this.timeout(90000)
 239
 240     // Wait the scheduler that get the latest plugins versions
 241     await wait(6000)
 242
 243     // Fake update our plugin version
 244     await server.sqlCommand.setPluginVersion('hello-world', '0.0.1')
 245
 246     // Fake update package.json
 247     const packageJSON = await command.getPackageJSON('peertube-plugin-hello-world')
 248     const oldVersion = packageJSON.version
 249
 250     packageJSON.version = '0.0.1'
 251     await command.updatePackageJSON('peertube-plugin-hello-world', packageJSON)
 252
 253     // Restart the server to take into account this change
 254     await killallServers([ server ])
 255     await reRunServer(server)
 256
 257     {
 258       const body = await command.list({ pluginType: PluginType.PLUGIN })
 259
 260       const plugin = body.data[0]
 261       expect(plugin.version).to.equal('0.0.1')
 262       expect(plugin.latestVersion).to.exist
 263       expect(plugin.latestVersion).to.not.equal('0.0.1')
 264     }
 265
 266     {
 267       await command.update({ npmName: 'peertube-plugin-hello-world' })
 268
 269       const body = await command.list({ pluginType: PluginType.PLUGIN })
 270
 271       const plugin = body.data[0]
 272       expect(plugin.version).to.equal(oldVersion)
 273
 274       const updatedPackageJSON = await command.getPackageJSON('peertube-plugin-hello-world')
 275       expect(updatedPackageJSON.version).to.equal(oldVersion)
 276     }
 277   })
 278
 279   it('Should uninstall the plugin', async function () {
 280     await command.uninstall({ npmName: 'peertube-plugin-hello-world' })
 281
 282     const body = await command.list({ pluginType: PluginType.PLUGIN })
 283     expect(body.total).to.equal(0)
 284     expect(body.data).to.have.lengthOf(0)
 285   })
 286
 287   it('Should list uninstalled plugins', async function () {
 288     const body = await command.list({ pluginType: PluginType.PLUGIN, uninstalled: true })
 289     expect(body.total).to.equal(1)
 290     expect(body.data).to.have.lengthOf(1)
 291
 292     const plugin = body.data[0]
 293     expect(plugin.name).to.equal('hello-world')
 294     expect(plugin.enabled).to.be.false
 295     expect(plugin.uninstalled).to.be.true
 296   })
 297
 298   it('Should uninstall the theme', async function () {
 299     await command.uninstall({ npmName: 'peertube-theme-background-red' })
 300   })
 301
 302   it('Should have updated the configuration', async function () {
 303     const config = await server.configCommand.getConfig()
 304
 305     expect(config.theme.default).to.equal('default')
 306
 307     const theme = config.theme.registered.find(r => r.name === 'background-red')
 308     expect(theme).to.be.undefined
 309
 310     const plugin = config.plugin.registered.find(r => r.name === 'hello-world')
 311     expect(plugin).to.be.undefined
 312   })
 313
 314   it('Should have updated the user theme', async function () {
 315     const res = await getMyUserInformation(server.url, server.accessToken)
 316     expect((res.body as User).theme).to.equal('instance-default')
 317   })
 318
 319   it('Should not install a broken plugin', async function () {
 320     this.timeout(60000)
 321
 322     async function check () {
 323       const body = await command.list({ pluginType: PluginType.PLUGIN })
 324       const plugins = body.data
 325       expect(plugins.find(p => p.name === 'test-broken')).to.not.exist
 326     }
 327
 328     await command.install({
 329       path: PluginsCommand.getPluginTestPath('-broken'),
 330       expectedStatus: HttpStatusCode.BAD_REQUEST_400
 331     })
 332
 333     await check()
 334
 335     await killallServers([ server ])
 336     await reRunServer(server)
 337
 338     await check()
 339   })
 340
 341   after(async function () {
 342     await cleanupTests([ server ])
 343   })
 344 })