server/tests/cli/peertube.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import { expect } from 'chai'
   5 import { areHttpImportTestsDisabled, buildAbsoluteFixturePath } from '@shared/core-utils'
   6 import {
   7   cleanupTests,
   8   CLICommand,
   9   createSingleServer,
  10   doubleFollow,
  11   PeerTubeServer,
  12   setAccessTokensToServers,
  13   waitJobs
  14 } from '@shared/server-commands'
  15 import { FIXTURE_URLS, testHelloWorldRegisteredSettings } from '../shared'
  16
  17 describe('Test CLI wrapper', function () {
  18   let server: PeerTubeServer
  19   let userAccessToken: string
  20
  21   let cliCommand: CLICommand
  22
  23   const cmd = 'node ./dist/server/tools/peertube.js'
  24
  25   before(async function () {
  26     this.timeout(30000)
  27
  28     server = await createSingleServer(1)
  29     await setAccessTokensToServers([ server ])
  30
  31     await server.users.create({ username: 'user_1', password: 'super_password' })
  32
  33     userAccessToken = await server.login.getAccessToken({ username: 'user_1', password: 'super_password' })
  34
  35     {
  36       const attributes = { name: 'user_channel', displayName: 'User channel', support: 'super support text' }
  37       await server.channels.create({ token: userAccessToken, attributes })
  38     }
  39
  40     cliCommand = server.cli
  41   })
  42
  43   describe('Authentication and instance selection', function () {
  44
  45     it('Should get an access token', async function () {
  46       const stdout = await cliCommand.execWithEnv(`${cmd} token --url ${server.url} --username user_1 --password super_password`)
  47       const token = stdout.trim()
  48
  49       const body = await server.users.getMyInfo({ token })
  50       expect(body.username).to.equal('user_1')
  51     })
  52
  53     it('Should display no selected instance', async function () {
  54       this.timeout(60000)
  55
  56       const stdout = await cliCommand.execWithEnv(`${cmd} --help`)
  57       expect(stdout).to.contain('no instance selected')
  58     })
  59
  60     it('Should add a user', async function () {
  61       this.timeout(60000)
  62
  63       await cliCommand.execWithEnv(`${cmd} auth add -u ${server.url} -U user_1 -p super_password`)
  64     })
  65
  66     it('Should not fail to add a user if there is a slash at the end of the instance URL', async function () {
  67       this.timeout(60000)
  68
  69       let fullServerURL = server.url + '/'
  70
  71       await cliCommand.execWithEnv(`${cmd} auth add -u ${fullServerURL} -U user_1 -p super_password`)
  72
  73       fullServerURL = server.url + '/asdfasdf'
  74       await cliCommand.execWithEnv(`${cmd} auth add -u ${fullServerURL} -U user_1 -p super_password`)
  75     })
  76
  77     it('Should default to this user', async function () {
  78       this.timeout(60000)
  79
  80       const stdout = await cliCommand.execWithEnv(`${cmd} --help`)
  81       expect(stdout).to.contain(`instance ${server.url} selected`)
  82     })
  83
  84     it('Should remember the user', async function () {
  85       this.timeout(60000)
  86
  87       const stdout = await cliCommand.execWithEnv(`${cmd} auth list`)
  88       expect(stdout).to.contain(server.url)
  89     })
  90   })
  91
  92   describe('Video upload/import', function () {
  93
  94     it('Should upload a video', async function () {
  95       this.timeout(60000)
  96
  97       const fixture = buildAbsoluteFixturePath('60fps_720p_small.mp4')
  98       const params = `-f ${fixture} --video-name 'test upload' --channel-name user_channel --support 'support_text'`
  99
 100       await cliCommand.execWithEnv(`${cmd} upload ${params}`)
 101     })
 102
 103     it('Should have the video uploaded', async function () {
 104       const { total, data } = await server.videos.list()
 105       expect(total).to.equal(1)
 106
 107       const video = await server.videos.get({ id: data[0].uuid })
 108       expect(video.name).to.equal('test upload')
 109       expect(video.support).to.equal('support_text')
 110       expect(video.channel.name).to.equal('user_channel')
 111     })
 112
 113     it('Should import a video', async function () {
 114       if (areHttpImportTestsDisabled()) return
 115
 116       this.timeout(60000)
 117
 118       const params = `--target-url ${FIXTURE_URLS.youtube} --channel-name user_channel`
 119       await cliCommand.execWithEnv(`${cmd} import ${params}`)
 120     })
 121
 122     it('Should have imported the video', async function () {
 123       if (areHttpImportTestsDisabled()) return
 124
 125       this.timeout(60000)
 126
 127       await waitJobs([ server ])
 128
 129       const { total, data } = await server.videos.list()
 130       expect(total).to.equal(2)
 131
 132       const video = data.find(v => v.name === 'small video - youtube')
 133       expect(video).to.not.be.undefined
 134
 135       const videoDetails = await server.videos.get({ id: video.id })
 136       expect(videoDetails.channel.name).to.equal('user_channel')
 137       expect(videoDetails.support).to.equal('super support text')
 138       expect(videoDetails.nsfw).to.be.false
 139
 140       // So we can reimport it
 141       await server.videos.remove({ token: userAccessToken, id: video.id })
 142     })
 143
 144     it('Should import and override some imported attributes', async function () {
 145       if (areHttpImportTestsDisabled()) return
 146
 147       this.timeout(60000)
 148
 149       const params = `--target-url ${FIXTURE_URLS.youtube} ` +
 150                      `--channel-name user_channel --video-name toto --nsfw --support support`
 151       await cliCommand.execWithEnv(`${cmd} import ${params}`)
 152
 153       await waitJobs([ server ])
 154
 155       {
 156         const { total, data } = await server.videos.list()
 157         expect(total).to.equal(2)
 158
 159         const video = data.find(v => v.name === 'toto')
 160         expect(video).to.not.be.undefined
 161
 162         const videoDetails = await server.videos.get({ id: video.id })
 163         expect(videoDetails.channel.name).to.equal('user_channel')
 164         expect(videoDetails.support).to.equal('support')
 165         expect(videoDetails.nsfw).to.be.true
 166         expect(videoDetails.commentsEnabled).to.be.true
 167       }
 168     })
 169   })
 170
 171   describe('Admin auth', function () {
 172
 173     it('Should remove the auth user', async function () {
 174       await cliCommand.execWithEnv(`${cmd} auth del ${server.url}`)
 175
 176       const stdout = await cliCommand.execWithEnv(`${cmd} --help`)
 177       expect(stdout).to.contain('no instance selected')
 178     })
 179
 180     it('Should add the admin user', async function () {
 181       await cliCommand.execWithEnv(`${cmd} auth add -u ${server.url} -U root -p test${server.internalServerNumber}`)
 182     })
 183   })
 184
 185   describe('Manage plugins', function () {
 186
 187     it('Should install a plugin', async function () {
 188       this.timeout(60000)
 189
 190       await cliCommand.execWithEnv(`${cmd} plugins install --npm-name peertube-plugin-hello-world`)
 191     })
 192
 193     it('Should have registered settings', async function () {
 194       await testHelloWorldRegisteredSettings(server)
 195     })
 196
 197     it('Should list installed plugins', async function () {
 198       const res = await cliCommand.execWithEnv(`${cmd} plugins list`)
 199
 200       expect(res).to.contain('peertube-plugin-hello-world')
 201     })
 202
 203     it('Should uninstall the plugin', async function () {
 204       const res = await cliCommand.execWithEnv(`${cmd} plugins uninstall --npm-name peertube-plugin-hello-world`)
 205
 206       expect(res).to.not.contain('peertube-plugin-hello-world')
 207     })
 208
 209     it('Should install a plugin in requested version', async function () {
 210       this.timeout(60000)
 211
 212       await cliCommand.execWithEnv(`${cmd} plugins install --npm-name peertube-plugin-hello-world --plugin-version 0.0.17`)
 213     })
 214
 215     it('Should list installed plugins, in correct version', async function () {
 216       const res = await cliCommand.execWithEnv(`${cmd} plugins list`)
 217
 218       expect(res).to.contain('peertube-plugin-hello-world')
 219       expect(res).to.contain('0.0.17')
 220     })
 221
 222     it('Should uninstall the plugin again', async function () {
 223       const res = await cliCommand.execWithEnv(`${cmd} plugins uninstall --npm-name peertube-plugin-hello-world`)
 224
 225       expect(res).to.not.contain('peertube-plugin-hello-world')
 226     })
 227   })
 228
 229   describe('Manage video redundancies', function () {
 230     let anotherServer: PeerTubeServer
 231     let video1Server2: number
 232     let servers: PeerTubeServer[]
 233
 234     before(async function () {
 235       this.timeout(120000)
 236
 237       anotherServer = await createSingleServer(2)
 238       await setAccessTokensToServers([ anotherServer ])
 239
 240       await doubleFollow(server, anotherServer)
 241
 242       servers = [ server, anotherServer ]
 243       await waitJobs(servers)
 244
 245       const { uuid } = await anotherServer.videos.quickUpload({ name: 'super video' })
 246       await waitJobs(servers)
 247
 248       video1Server2 = await server.videos.getId({ uuid })
 249     })
 250
 251     it('Should add a redundancy', async function () {
 252       this.timeout(60000)
 253
 254       const params = `add --video ${video1Server2}`
 255       await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
 256
 257       await waitJobs(servers)
 258     })
 259
 260     it('Should list redundancies', async function () {
 261       this.timeout(60000)
 262
 263       {
 264         const params = 'list-my-redundancies'
 265         const stdout = await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
 266
 267         expect(stdout).to.contain('super video')
 268         expect(stdout).to.contain(`localhost:${server.port}`)
 269       }
 270     })
 271
 272     it('Should remove a redundancy', async function () {
 273       this.timeout(60000)
 274
 275       const params = `remove --video ${video1Server2}`
 276       await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
 277
 278       await waitJobs(servers)
 279
 280       {
 281         const params = 'list-my-redundancies'
 282         const stdout = await cliCommand.execWithEnv(`${cmd} redundancy ${params}`)
 283
 284         expect(stdout).to.not.contain('super video')
 285       }
 286     })
 287
 288     after(async function () {
 289       this.timeout(10000)
 290
 291       await cleanupTests([ anotherServer ])
 292     })
 293   })
 294
 295   after(async function () {
 296     this.timeout(10000)
 297
 298     await cleanupTests([ server ])
 299   })
 300 })