server/tests/api/check-params/config.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import { omit } from 'lodash'
   4 import 'mocha'
   5 import { CustomConfig } from '../../../../shared/models/server/custom-config.model'
   6
   7 import {
   8   cleanupTests,
   9   createUser,
  10   flushAndRunServer,
  11   immutableAssign,
  12   makeDeleteRequest,
  13   makeGetRequest,
  14   makePutBodyRequest,
  15   ServerInfo,
  16   setAccessTokensToServers,
  17   userLogin
  18 } from '../../../../shared/extra-utils'
  19
  20 describe('Test config API validators', function () {
  21   const path = '/api/v1/config/custom'
  22   let server: ServerInfo
  23   let userAccessToken: string
  24   const updateParams: CustomConfig = {
  25     instance: {
  26       name: 'PeerTube updated',
  27       shortDescription: 'my short description',
  28       description: 'my super description',
  29       terms: 'my super terms',
  30       codeOfConduct: 'my super coc',
  31
  32       creationReason: 'my super reason',
  33       moderationInformation: 'my super moderation information',
  34       administrator: 'Kuja',
  35       maintenanceLifetime: 'forever',
  36       businessModel: 'my super business model',
  37       hardwareInformation: '2vCore 3GB RAM',
  38
  39       languages: [ 'en', 'es' ],
  40       categories: [ 1, 2 ],
  41
  42       isNSFW: true,
  43       defaultClientRoute: '/videos/recently-added',
  44       defaultNSFWPolicy: 'blur',
  45       customizations: {
  46         javascript: 'alert("coucou")',
  47         css: 'body { background-color: red; }'
  48       }
  49     },
  50     theme: {
  51       default: 'default'
  52     },
  53     services: {
  54       twitter: {
  55         username: '@MySuperUsername',
  56         whitelisted: true
  57       }
  58     },
  59     cache: {
  60       previews: {
  61         size: 2
  62       },
  63       captions: {
  64         size: 3
  65       }
  66     },
  67     signup: {
  68       enabled: false,
  69       limit: 5,
  70       requiresEmailVerification: false
  71     },
  72     admin: {
  73       email: 'superadmin1@example.com'
  74     },
  75     contactForm: {
  76       enabled: false
  77     },
  78     user: {
  79       videoQuota: 5242881,
  80       videoQuotaDaily: 318742
  81     },
  82     transcoding: {
  83       enabled: true,
  84       allowAdditionalExtensions: true,
  85       allowAudioFiles: true,
  86       threads: 1,
  87       resolutions: {
  88         '0p': false,
  89         '240p': false,
  90         '360p': true,
  91         '480p': true,
  92         '720p': false,
  93         '1080p': false,
  94         '2160p': false
  95       },
  96       webtorrent: {
  97         enabled: true
  98       },
  99       hls: {
 100         enabled: false
 101       }
 102     },
 103     live: {
 104       enabled: true,
 105
 106       allowReplay: false,
 107       maxDuration: null,
 108       maxInstanceLives: -1,
 109       maxUserLives: 50,
 110
 111       transcoding: {
 112         enabled: true,
 113         threads: 4,
 114         resolutions: {
 115           '240p': true,
 116           '360p': true,
 117           '480p': true,
 118           '720p': true,
 119           '1080p': true,
 120           '2160p': true
 121         }
 122       }
 123     },
 124     import: {
 125       videos: {
 126         http: {
 127           enabled: false
 128         },
 129         torrent: {
 130           enabled: false
 131         }
 132       }
 133     },
 134     autoBlacklist: {
 135       videos: {
 136         ofUsers: {
 137           enabled: false
 138         }
 139       }
 140     },
 141     followers: {
 142       instance: {
 143         enabled: false,
 144         manualApproval: true
 145       }
 146     },
 147     followings: {
 148       instance: {
 149         autoFollowBack: {
 150           enabled: true
 151         },
 152         autoFollowIndex: {
 153           enabled: true,
 154           indexUrl: 'https://index.example.com'
 155         }
 156       }
 157     },
 158     broadcastMessage: {
 159       enabled: true,
 160       dismissable: true,
 161       message: 'super message',
 162       level: 'warning'
 163     },
 164     search: {
 165       remoteUri: {
 166         users: true,
 167         anonymous: true
 168       },
 169       searchIndex: {
 170         enabled: true,
 171         url: 'https://search.joinpeertube.org',
 172         disableLocalSearch: true,
 173         isDefaultSearch: true
 174       }
 175     }
 176   }
 177
 178   // ---------------------------------------------------------------
 179
 180   before(async function () {
 181     this.timeout(30000)
 182
 183     server = await flushAndRunServer(1)
 184
 185     await setAccessTokensToServers([ server ])
 186
 187     const user = {
 188       username: 'user1',
 189       password: 'password'
 190     }
 191     await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
 192     userAccessToken = await userLogin(server, user)
 193   })
 194
 195   describe('When getting the configuration', function () {
 196     it('Should fail without token', async function () {
 197       await makeGetRequest({
 198         url: server.url,
 199         path,
 200         statusCodeExpected: 401
 201       })
 202     })
 203
 204     it('Should fail if the user is not an administrator', async function () {
 205       await makeGetRequest({
 206         url: server.url,
 207         path,
 208         token: userAccessToken,
 209         statusCodeExpected: 403
 210       })
 211     })
 212   })
 213
 214   describe('When updating the configuration', function () {
 215     it('Should fail without token', async function () {
 216       await makePutBodyRequest({
 217         url: server.url,
 218         path,
 219         fields: updateParams,
 220         statusCodeExpected: 401
 221       })
 222     })
 223
 224     it('Should fail if the user is not an administrator', async function () {
 225       await makePutBodyRequest({
 226         url: server.url,
 227         path,
 228         fields: updateParams,
 229         token: userAccessToken,
 230         statusCodeExpected: 403
 231       })
 232     })
 233
 234     it('Should fail if it misses a key', async function () {
 235       const newUpdateParams = omit(updateParams, 'admin.email')
 236
 237       await makePutBodyRequest({
 238         url: server.url,
 239         path,
 240         fields: newUpdateParams,
 241         token: server.accessToken,
 242         statusCodeExpected: 400
 243       })
 244     })
 245
 246     it('Should fail with a bad default NSFW policy', async function () {
 247       const newUpdateParams = immutableAssign(updateParams, {
 248         instance: {
 249           defaultNSFWPolicy: 'hello'
 250         }
 251       })
 252
 253       await makePutBodyRequest({
 254         url: server.url,
 255         path,
 256         fields: newUpdateParams,
 257         token: server.accessToken,
 258         statusCodeExpected: 400
 259       })
 260     })
 261
 262     it('Should fail if email disabled and signup requires email verification', async function () {
 263       // opposite scenario - success when enable enabled - covered via tests/api/users/user-verification.ts
 264       const newUpdateParams = immutableAssign(updateParams, {
 265         signup: {
 266           enabled: true,
 267           limit: 5,
 268           requiresEmailVerification: true
 269         }
 270       })
 271
 272       await makePutBodyRequest({
 273         url: server.url,
 274         path,
 275         fields: newUpdateParams,
 276         token: server.accessToken,
 277         statusCodeExpected: 400
 278       })
 279     })
 280
 281     it('Should fail with a disabled webtorrent & hls transcoding', async function () {
 282       const newUpdateParams = immutableAssign(updateParams, {
 283         transcoding: {
 284           hls: {
 285             enabled: false
 286           },
 287           webtorrent: {
 288             enabled: false
 289           }
 290         }
 291       })
 292
 293       await makePutBodyRequest({
 294         url: server.url,
 295         path,
 296         fields: newUpdateParams,
 297         token: server.accessToken,
 298         statusCodeExpected: 400
 299       })
 300     })
 301
 302     it('Should success with the correct parameters', async function () {
 303       await makePutBodyRequest({
 304         url: server.url,
 305         path,
 306         fields: updateParams,
 307         token: server.accessToken,
 308         statusCodeExpected: 200
 309       })
 310     })
 311   })
 312
 313   describe('When deleting the configuration', function () {
 314     it('Should fail without token', async function () {
 315       await makeDeleteRequest({
 316         url: server.url,
 317         path,
 318         statusCodeExpected: 401
 319       })
 320     })
 321
 322     it('Should fail if the user is not an administrator', async function () {
 323       await makeDeleteRequest({
 324         url: server.url,
 325         path,
 326         token: userAccessToken,
 327         statusCodeExpected: 403
 328       })
 329     })
 330   })
 331
 332   after(async function () {
 333     await cleanupTests([ server ])
 334   })
 335 })