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 body = await command.list({
 150         count: 2,
 151         start: 0,
 152         sort: 'name'
 153       })
 154
 155       const data = body
 156       expect(data[0].name).to.equal('background-red')
 157       expect(data[1].name).to.equal('hello-world')
 158     }
 159
 160     {
 161       const body = await command.list({
 162         count: 2,
 163         start: 1,
 164         sort: 'name'
 165       })
 166
 167       expect(body.data[0].name).to.equal('hello-world')
 168     }
 169   })
 170
 171   it('Should get registered settings', async function () {
 172     await testHelloWorldRegisteredSettings(server)
 173   })
 174
 175   it('Should get public settings', async function () {
 176     const body = await command.getPublicSettings({ npmName: 'peertube-plugin-hello-world' })
 177     const publicSettings = body.publicSettings
 178
 179     expect(Object.keys(publicSettings)).to.have.lengthOf(1)
 180     expect(Object.keys(publicSettings)).to.deep.equal([ 'user-name' ])
 181     expect(publicSettings['user-name']).to.be.null
 182   })
 183
 184   it('Should update the settings', async function () {
 185     const settings = {
 186       'admin-name': 'Cid'
 187     }
 188
 189     await command.updateSettings({
 190       npmName: 'peertube-plugin-hello-world',
 191       settings
 192     })
 193   })
 194
 195   it('Should have watched settings changes', async function () {
 196     this.timeout(10000)
 197
 198     await waitUntilLog(server, 'Settings changed!')
 199   })
 200
 201   it('Should get a plugin and a theme', async function () {
 202     {
 203       const plugin = await command.get({ npmName: 'peertube-plugin-hello-world' })
 204
 205       expect(plugin.type).to.equal(PluginType.PLUGIN)
 206       expect(plugin.name).to.equal('hello-world')
 207       expect(plugin.description).to.exist
 208       expect(plugin.homepage).to.exist
 209       expect(plugin.uninstalled).to.be.false
 210       expect(plugin.enabled).to.be.true
 211       expect(plugin.description).to.exist
 212       expect(plugin.version).to.exist
 213       expect(plugin.peertubeEngine).to.exist
 214       expect(plugin.createdAt).to.exist
 215
 216       expect(plugin.settings).to.not.be.undefined
 217       expect(plugin.settings['admin-name']).to.equal('Cid')
 218     }
 219
 220     {
 221       const plugin = await command.get({ npmName: 'peertube-theme-background-red' })
 222
 223       expect(plugin.type).to.equal(PluginType.THEME)
 224       expect(plugin.name).to.equal('background-red')
 225       expect(plugin.description).to.exist
 226       expect(plugin.homepage).to.exist
 227       expect(plugin.uninstalled).to.be.false
 228       expect(plugin.enabled).to.be.true
 229       expect(plugin.description).to.exist
 230       expect(plugin.version).to.exist
 231       expect(plugin.peertubeEngine).to.exist
 232       expect(plugin.createdAt).to.exist
 233
 234       expect(plugin.settings).to.be.null
 235     }
 236   })
 237
 238   it('Should update the plugin and the theme', async function () {
 239     this.timeout(90000)
 240
 241     // Wait the scheduler that get the latest plugins versions
 242     await wait(6000)
 243
 244     // Fake update our plugin version
 245     await server.sqlCommand.setPluginVersion('hello-world', '0.0.1')
 246
 247     // Fake update package.json
 248     const packageJSON = await command.getPackageJSON('peertube-plugin-hello-world')
 249     const oldVersion = packageJSON.version
 250
 251     packageJSON.version = '0.0.1'
 252     await command.updatePackageJSON('peertube-plugin-hello-world', packageJSON)
 253
 254     // Restart the server to take into account this change
 255     await killallServers([ server ])
 256     await reRunServer(server)
 257
 258     {
 259       const body = await command.list({ pluginType: PluginType.PLUGIN })
 260
 261       const plugin = body.data[0]
 262       expect(plugin.version).to.equal('0.0.1')
 263       expect(plugin.latestVersion).to.exist
 264       expect(plugin.latestVersion).to.not.equal('0.0.1')
 265     }
 266
 267     {
 268       await command.update({ npmName: 'peertube-plugin-hello-world' })
 269
 270       const body = await command.list({ pluginType: PluginType.PLUGIN })
 271
 272       const plugin = body.data[0]
 273       expect(plugin.version).to.equal(oldVersion)
 274
 275       const updatedPackageJSON = await command.getPackageJSON('peertube-plugin-hello-world')
 276       expect(updatedPackageJSON.version).to.equal(oldVersion)
 277     }
 278   })
 279
 280   it('Should uninstall the plugin', async function () {
 281     await command.uninstall({ npmName: 'peertube-plugin-hello-world' })
 282
 283     const body = await command.list({ pluginType: PluginType.PLUGIN })
 284     expect(body.total).to.equal(0)
 285     expect(body.data).to.have.lengthOf(0)
 286   })
 287
 288   it('Should list uninstalled plugins', async function () {
 289     const body = await command.list({ pluginType: PluginType.PLUGIN, uninstalled: true })
 290     expect(body.total).to.equal(1)
 291     expect(body.data).to.have.lengthOf(1)
 292
 293     const plugin = body.data[0]
 294     expect(plugin.name).to.equal('hello-world')
 295     expect(plugin.enabled).to.be.false
 296     expect(plugin.uninstalled).to.be.true
 297   })
 298
 299   it('Should uninstall the theme', async function () {
 300     await command.uninstall({ npmName: 'peertube-theme-background-red' })
 301   })
 302
 303   it('Should have updated the configuration', async function () {
 304     const config = await server.configCommand.getConfig()
 305
 306     expect(config.theme.default).to.equal('default')
 307
 308     const theme = config.theme.registered.find(r => r.name === 'background-red')
 309     expect(theme).to.be.undefined
 310
 311     const plugin = config.plugin.registered.find(r => r.name === 'hello-world')
 312     expect(plugin).to.be.undefined
 313   })
 314
 315   it('Should have updated the user theme', async function () {
 316     const res = await getMyUserInformation(server.url, server.accessToken)
 317     expect((res.body as User).theme).to.equal('instance-default')
 318   })
 319
 320   it('Should not install a broken plugin', async function () {
 321     this.timeout(60000)
 322
 323     async function check () {
 324       const body = await command.list({ pluginType: PluginType.PLUGIN })
 325       const plugins = body.data
 326       expect(plugins.find(p => p.name === 'test-broken')).to.not.exist
 327     }
 328
 329     await command.install({
 330       path: PluginsCommand.getPluginTestPath('-broken'),
 331       expectedStatus: HttpStatusCode.BAD_REQUEST_400
 332     })
 333
 334     await check()
 335
 336     await killallServers([ server ])
 337     await reRunServer(server)
 338
 339     await check()
 340   })
 341
 342   after(async function () {
 343     await cleanupTests([ server ])
 344   })
 345 })