server/tests/api/server/plugins.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import { expect } from 'chai'
   4 import { pathExists, remove } from 'fs-extra'
   5 import { join } from 'path'
   6 import { SQLCommand, testHelloWorldRegisteredSettings } from '@server/tests/shared'
   7 import { wait } from '@shared/core-utils'
   8 import { HttpStatusCode, PluginType } from '@shared/models'
   9 import {
  10   cleanupTests,
  11   createSingleServer,
  12   killallServers,
  13   makeGetRequest,
  14   PeerTubeServer,
  15   PluginsCommand,
  16   setAccessTokensToServers
  17 } from '@shared/server-commands'
  18
  19 describe('Test plugins', function () {
  20   let server: PeerTubeServer
  21   let sqlCommand: SQLCommand
  22   let command: PluginsCommand
  23
  24   before(async function () {
  25     this.timeout(30000)
  26
  27     const configOverride = {
  28       plugins: {
  29         index: { check_latest_versions_interval: '5 seconds' }
  30       }
  31     }
  32     server = await createSingleServer(1, configOverride)
  33     await setAccessTokensToServers([ server ])
  34
  35     command = server.plugins
  36
  37     sqlCommand = new SQLCommand(server)
  38   })
  39
  40   it('Should list and search available plugins and themes', async function () {
  41     this.timeout(30000)
  42
  43     {
  44       const body = await command.listAvailable({
  45         count: 1,
  46         start: 0,
  47         pluginType: PluginType.THEME,
  48         search: 'background-red'
  49       })
  50
  51       expect(body.total).to.be.at.least(1)
  52       expect(body.data).to.have.lengthOf(1)
  53     }
  54
  55     {
  56       const body1 = await command.listAvailable({
  57         count: 2,
  58         start: 0,
  59         sort: 'npmName'
  60       })
  61       expect(body1.total).to.be.at.least(2)
  62
  63       const data1 = body1.data
  64       expect(data1).to.have.lengthOf(2)
  65
  66       const body2 = await command.listAvailable({
  67         count: 2,
  68         start: 0,
  69         sort: '-npmName'
  70       })
  71       expect(body2.total).to.be.at.least(2)
  72
  73       const data2 = body2.data
  74       expect(data2).to.have.lengthOf(2)
  75
  76       expect(data1[0].npmName).to.not.equal(data2[0].npmName)
  77     }
  78
  79     {
  80       const body = await command.listAvailable({
  81         count: 10,
  82         start: 0,
  83         pluginType: PluginType.THEME,
  84         search: 'background-red',
  85         currentPeerTubeEngine: '1.0.0'
  86       })
  87
  88       const p = body.data.find(p => p.npmName === 'peertube-theme-background-red')
  89       expect(p).to.be.undefined
  90     }
  91   })
  92
  93   it('Should install a plugin and a theme', async function () {
  94     this.timeout(30000)
  95
  96     await command.install({ npmName: 'peertube-plugin-hello-world' })
  97     await command.install({ npmName: 'peertube-theme-background-red' })
  98   })
  99
 100   it('Should have the plugin loaded in the configuration', async function () {
 101     for (const config of [ await server.config.getConfig(), await server.config.getIndexHTMLConfig() ]) {
 102       const theme = config.theme.registered.find(r => r.name === 'background-red')
 103       expect(theme).to.not.be.undefined
 104       expect(theme.npmName).to.equal('peertube-theme-background-red')
 105
 106       const plugin = config.plugin.registered.find(r => r.name === 'hello-world')
 107       expect(plugin).to.not.be.undefined
 108       expect(plugin.npmName).to.equal('peertube-plugin-hello-world')
 109     }
 110   })
 111
 112   it('Should update the default theme in the configuration', async function () {
 113     await server.config.updateCustomSubConfig({
 114       newConfig: {
 115         theme: { default: 'background-red' }
 116       }
 117     })
 118
 119     for (const config of [ await server.config.getConfig(), await server.config.getIndexHTMLConfig() ]) {
 120       expect(config.theme.default).to.equal('background-red')
 121     }
 122   })
 123
 124   it('Should update my default theme', async function () {
 125     await server.users.updateMe({ theme: 'background-red' })
 126
 127     const user = await server.users.getMyInfo()
 128     expect(user.theme).to.equal('background-red')
 129   })
 130
 131   it('Should list plugins and themes', async function () {
 132     {
 133       const body = await command.list({
 134         count: 1,
 135         start: 0,
 136         pluginType: PluginType.THEME
 137       })
 138       expect(body.total).to.be.at.least(1)
 139
 140       const data = body.data
 141       expect(data).to.have.lengthOf(1)
 142       expect(data[0].name).to.equal('background-red')
 143     }
 144
 145     {
 146       const { data } = await command.list({
 147         count: 2,
 148         start: 0,
 149         sort: 'name'
 150       })
 151
 152       expect(data[0].name).to.equal('background-red')
 153       expect(data[1].name).to.equal('hello-world')
 154     }
 155
 156     {
 157       const body = await command.list({
 158         count: 2,
 159         start: 1,
 160         sort: 'name'
 161       })
 162
 163       expect(body.data[0].name).to.equal('hello-world')
 164     }
 165   })
 166
 167   it('Should get registered settings', async function () {
 168     await testHelloWorldRegisteredSettings(server)
 169   })
 170
 171   it('Should get public settings', async function () {
 172     const body = await command.getPublicSettings({ npmName: 'peertube-plugin-hello-world' })
 173     const publicSettings = body.publicSettings
 174
 175     expect(Object.keys(publicSettings)).to.have.lengthOf(1)
 176     expect(Object.keys(publicSettings)).to.deep.equal([ 'user-name' ])
 177     expect(publicSettings['user-name']).to.be.null
 178   })
 179
 180   it('Should update the settings', async function () {
 181     const settings = {
 182       'admin-name': 'Cid'
 183     }
 184
 185     await command.updateSettings({
 186       npmName: 'peertube-plugin-hello-world',
 187       settings
 188     })
 189   })
 190
 191   it('Should have watched settings changes', async function () {
 192     await server.servers.waitUntilLog('Settings changed!')
 193   })
 194
 195   it('Should get a plugin and a theme', async function () {
 196     {
 197       const plugin = await command.get({ npmName: 'peertube-plugin-hello-world' })
 198
 199       expect(plugin.type).to.equal(PluginType.PLUGIN)
 200       expect(plugin.name).to.equal('hello-world')
 201       expect(plugin.description).to.exist
 202       expect(plugin.homepage).to.exist
 203       expect(plugin.uninstalled).to.be.false
 204       expect(plugin.enabled).to.be.true
 205       expect(plugin.description).to.exist
 206       expect(plugin.version).to.exist
 207       expect(plugin.peertubeEngine).to.exist
 208       expect(plugin.createdAt).to.exist
 209
 210       expect(plugin.settings).to.not.be.undefined
 211       expect(plugin.settings['admin-name']).to.equal('Cid')
 212     }
 213
 214     {
 215       const plugin = await command.get({ npmName: 'peertube-theme-background-red' })
 216
 217       expect(plugin.type).to.equal(PluginType.THEME)
 218       expect(plugin.name).to.equal('background-red')
 219       expect(plugin.description).to.exist
 220       expect(plugin.homepage).to.exist
 221       expect(plugin.uninstalled).to.be.false
 222       expect(plugin.enabled).to.be.true
 223       expect(plugin.description).to.exist
 224       expect(plugin.version).to.exist
 225       expect(plugin.peertubeEngine).to.exist
 226       expect(plugin.createdAt).to.exist
 227
 228       expect(plugin.settings).to.be.null
 229     }
 230   })
 231
 232   it('Should update the plugin and the theme', async function () {
 233     this.timeout(180000)
 234
 235     // Wait the scheduler that get the latest plugins versions
 236     await wait(6000)
 237
 238     async function testUpdate (type: 'plugin' | 'theme', name: string) {
 239       // Fake update our plugin version
 240       await sqlCommand.setPluginVersion(name, '0.0.1')
 241
 242       // Fake update package.json
 243       const packageJSON = await command.getPackageJSON(`peertube-${type}-${name}`)
 244       const oldVersion = packageJSON.version
 245
 246       packageJSON.version = '0.0.1'
 247       await command.updatePackageJSON(`peertube-${type}-${name}`, packageJSON)
 248
 249       // Restart the server to take into account this change
 250       await killallServers([ server ])
 251       await server.run()
 252
 253       const checkConfig = async (version: string) => {
 254         for (const config of [ await server.config.getConfig(), await server.config.getIndexHTMLConfig() ]) {
 255           expect(config[type].registered.find(r => r.name === name).version).to.equal(version)
 256         }
 257       }
 258
 259       const getPluginFromAPI = async () => {
 260         const body = await command.list({ pluginType: type === 'plugin' ? PluginType.PLUGIN : PluginType.THEME })
 261
 262         return body.data.find(p => p.name === name)
 263       }
 264
 265       {
 266         const plugin = await getPluginFromAPI()
 267         expect(plugin.version).to.equal('0.0.1')
 268         expect(plugin.latestVersion).to.exist
 269         expect(plugin.latestVersion).to.not.equal('0.0.1')
 270
 271         await checkConfig('0.0.1')
 272       }
 273
 274       {
 275         await command.update({ npmName: `peertube-${type}-${name}` })
 276
 277         const plugin = await getPluginFromAPI()
 278         expect(plugin.version).to.equal(oldVersion)
 279
 280         const updatedPackageJSON = await command.getPackageJSON(`peertube-${type}-${name}`)
 281         expect(updatedPackageJSON.version).to.equal(oldVersion)
 282
 283         await checkConfig(oldVersion)
 284       }
 285     }
 286
 287     await testUpdate('theme', 'background-red')
 288     await testUpdate('plugin', 'hello-world')
 289   })
 290
 291   it('Should uninstall the plugin', async function () {
 292     await command.uninstall({ npmName: 'peertube-plugin-hello-world' })
 293
 294     const body = await command.list({ pluginType: PluginType.PLUGIN })
 295     expect(body.total).to.equal(0)
 296     expect(body.data).to.have.lengthOf(0)
 297   })
 298
 299   it('Should list uninstalled plugins', async function () {
 300     const body = await command.list({ pluginType: PluginType.PLUGIN, uninstalled: true })
 301     expect(body.total).to.equal(1)
 302     expect(body.data).to.have.lengthOf(1)
 303
 304     const plugin = body.data[0]
 305     expect(plugin.name).to.equal('hello-world')
 306     expect(plugin.enabled).to.be.false
 307     expect(plugin.uninstalled).to.be.true
 308   })
 309
 310   it('Should uninstall the theme', async function () {
 311     await command.uninstall({ npmName: 'peertube-theme-background-red' })
 312   })
 313
 314   it('Should have updated the configuration', async function () {
 315     for (const config of [ await server.config.getConfig(), await server.config.getIndexHTMLConfig() ]) {
 316       expect(config.theme.default).to.equal('default')
 317
 318       const theme = config.theme.registered.find(r => r.name === 'background-red')
 319       expect(theme).to.be.undefined
 320
 321       const plugin = config.plugin.registered.find(r => r.name === 'hello-world')
 322       expect(plugin).to.be.undefined
 323     }
 324   })
 325
 326   it('Should have updated the user theme', async function () {
 327     const user = await server.users.getMyInfo()
 328     expect(user.theme).to.equal('instance-default')
 329   })
 330
 331   it('Should not install a broken plugin', async function () {
 332     this.timeout(60000)
 333
 334     async function check () {
 335       const body = await command.list({ pluginType: PluginType.PLUGIN })
 336       const plugins = body.data
 337       expect(plugins.find(p => p.name === 'test-broken')).to.not.exist
 338     }
 339
 340     await command.install({
 341       path: PluginsCommand.getPluginTestPath('-broken'),
 342       expectedStatus: HttpStatusCode.BAD_REQUEST_400
 343     })
 344
 345     await check()
 346
 347     await killallServers([ server ])
 348     await server.run()
 349
 350     await check()
 351   })
 352
 353   it('Should rebuild native modules on Node ABI change', async function () {
 354     this.timeout(60000)
 355
 356     const removeNativeModule = async () => {
 357       await remove(join(baseNativeModule, 'build'))
 358       await remove(join(baseNativeModule, 'prebuilds'))
 359     }
 360
 361     await command.install({ path: PluginsCommand.getPluginTestPath('-native') })
 362
 363     await makeGetRequest({
 364       url: server.url,
 365       path: '/plugins/test-native/router',
 366       expectedStatus: HttpStatusCode.NO_CONTENT_204
 367     })
 368
 369     const query = `UPDATE "application" SET "nodeABIVersion" = 1`
 370     await sqlCommand.updateQuery(query)
 371
 372     const baseNativeModule = server.servers.buildDirectory(join('plugins', 'node_modules', 'a-native-example'))
 373
 374     await removeNativeModule()
 375     await server.kill()
 376     await server.run()
 377
 378     await wait(3000)
 379
 380     expect(await pathExists(join(baseNativeModule, 'build'))).to.be.true
 381     expect(await pathExists(join(baseNativeModule, 'prebuilds'))).to.be.true
 382
 383     await makeGetRequest({
 384       url: server.url,
 385       path: '/plugins/test-native/router',
 386       expectedStatus: HttpStatusCode.NO_CONTENT_204
 387     })
 388
 389     await removeNativeModule()
 390
 391     await server.kill()
 392     await server.run()
 393
 394     expect(await pathExists(join(baseNativeModule, 'build'))).to.be.false
 395     expect(await pathExists(join(baseNativeModule, 'prebuilds'))).to.be.false
 396
 397     await makeGetRequest({
 398       url: server.url,
 399       path: '/plugins/test-native/router',
 400       expectedStatus: HttpStatusCode.NOT_FOUND_404
 401     })
 402   })
 403
 404   after(async function () {
 405     await sqlCommand.cleanup()
 406
 407     await cleanupTests([ server ])
 408   })
 409 })