server/tests/api/check-params/video-channels.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 { omit } from 'lodash'
   6 import { HttpStatusCode } from '@shared/core-utils'
   7 import {
   8   buildAbsoluteFixturePath,
   9   ChannelsCommand,
  10   checkBadCountPagination,
  11   checkBadSortPagination,
  12   checkBadStartPagination,
  13   cleanupTests,
  14   createUser,
  15   flushAndRunServer,
  16   makeGetRequest,
  17   makePostBodyRequest,
  18   makePutBodyRequest,
  19   makeUploadRequest,
  20   ServerInfo,
  21   setAccessTokensToServers,
  22   userLogin
  23 } from '@shared/extra-utils'
  24 import { VideoChannelUpdate } from '@shared/models'
  25
  26 const expect = chai.expect
  27
  28 describe('Test video channels API validator', function () {
  29   const videoChannelPath = '/api/v1/video-channels'
  30   let server: ServerInfo
  31   let accessTokenUser: string
  32   let command: ChannelsCommand
  33
  34   // ---------------------------------------------------------------
  35
  36   before(async function () {
  37     this.timeout(30000)
  38
  39     server = await flushAndRunServer(1)
  40
  41     await setAccessTokensToServers([ server ])
  42
  43     const user = {
  44       username: 'fake',
  45       password: 'fake_password'
  46     }
  47
  48     {
  49       await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
  50       accessTokenUser = await userLogin(server, user)
  51     }
  52
  53     command = server.channelsCommand
  54   })
  55
  56   describe('When listing a video channels', function () {
  57     it('Should fail with a bad start pagination', async function () {
  58       await checkBadStartPagination(server.url, videoChannelPath, server.accessToken)
  59     })
  60
  61     it('Should fail with a bad count pagination', async function () {
  62       await checkBadCountPagination(server.url, videoChannelPath, server.accessToken)
  63     })
  64
  65     it('Should fail with an incorrect sort', async function () {
  66       await checkBadSortPagination(server.url, videoChannelPath, server.accessToken)
  67     })
  68   })
  69
  70   describe('When listing account video channels', function () {
  71     const accountChannelPath = '/api/v1/accounts/fake/video-channels'
  72
  73     it('Should fail with a bad start pagination', async function () {
  74       await checkBadStartPagination(server.url, accountChannelPath, server.accessToken)
  75     })
  76
  77     it('Should fail with a bad count pagination', async function () {
  78       await checkBadCountPagination(server.url, accountChannelPath, server.accessToken)
  79     })
  80
  81     it('Should fail with an incorrect sort', async function () {
  82       await checkBadSortPagination(server.url, accountChannelPath, server.accessToken)
  83     })
  84
  85     it('Should fail with a unknown account', async function () {
  86       await server.channelsCommand.listByAccount({ accountName: 'unknown', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
  87     })
  88
  89     it('Should succeed with the correct parameters', async function () {
  90       await makeGetRequest({
  91         url: server.url,
  92         path: accountChannelPath,
  93         statusCodeExpected: HttpStatusCode.OK_200
  94       })
  95     })
  96   })
  97
  98   describe('When adding a video channel', function () {
  99     const baseCorrectParams = {
 100       name: 'super_channel',
 101       displayName: 'hello',
 102       description: 'super description',
 103       support: 'super support text'
 104     }
 105
 106     it('Should fail with a non authenticated user', async function () {
 107       await makePostBodyRequest({
 108         url: server.url,
 109         path: videoChannelPath,
 110         token: 'none',
 111         fields: baseCorrectParams,
 112         statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
 113       })
 114     })
 115
 116     it('Should fail with nothing', async function () {
 117       const fields = {}
 118       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
 119     })
 120
 121     it('Should fail without a name', async function () {
 122       const fields = omit(baseCorrectParams, 'name')
 123       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
 124     })
 125
 126     it('Should fail with a bad name', async function () {
 127       const fields = { ...baseCorrectParams, name: 'super name' }
 128       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
 129     })
 130
 131     it('Should fail without a name', async function () {
 132       const fields = omit(baseCorrectParams, 'displayName')
 133       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
 134     })
 135
 136     it('Should fail with a long name', async function () {
 137       const fields = { ...baseCorrectParams, displayName: 'super'.repeat(25) }
 138       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
 139     })
 140
 141     it('Should fail with a long description', async function () {
 142       const fields = { ...baseCorrectParams, description: 'super'.repeat(201) }
 143       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
 144     })
 145
 146     it('Should fail with a long support text', async function () {
 147       const fields = { ...baseCorrectParams, support: 'super'.repeat(201) }
 148       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
 149     })
 150
 151     it('Should succeed with the correct parameters', async function () {
 152       await makePostBodyRequest({
 153         url: server.url,
 154         path: videoChannelPath,
 155         token: server.accessToken,
 156         fields: baseCorrectParams,
 157         statusCodeExpected: HttpStatusCode.OK_200
 158       })
 159     })
 160
 161     it('Should fail when adding a channel with the same username', async function () {
 162       await makePostBodyRequest({
 163         url: server.url,
 164         path: videoChannelPath,
 165         token: server.accessToken,
 166         fields: baseCorrectParams,
 167         statusCodeExpected: HttpStatusCode.CONFLICT_409
 168       })
 169     })
 170   })
 171
 172   describe('When updating a video channel', function () {
 173     const baseCorrectParams: VideoChannelUpdate = {
 174       displayName: 'hello',
 175       description: 'super description',
 176       support: 'toto',
 177       bulkVideosSupportUpdate: false
 178     }
 179     let path: string
 180
 181     before(async function () {
 182       path = videoChannelPath + '/super_channel'
 183     })
 184
 185     it('Should fail with a non authenticated user', async function () {
 186       await makePutBodyRequest({
 187         url: server.url,
 188         path,
 189         token: 'hi',
 190         fields: baseCorrectParams,
 191         statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
 192       })
 193     })
 194
 195     it('Should fail with another authenticated user', async function () {
 196       await makePutBodyRequest({
 197         url: server.url,
 198         path,
 199         token: accessTokenUser,
 200         fields: baseCorrectParams,
 201         statusCodeExpected: HttpStatusCode.FORBIDDEN_403
 202       })
 203     })
 204
 205     it('Should fail with a long name', async function () {
 206       const fields = { ...baseCorrectParams, displayName: 'super'.repeat(25) }
 207       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 208     })
 209
 210     it('Should fail with a long description', async function () {
 211       const fields = { ...baseCorrectParams, description: 'super'.repeat(201) }
 212       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 213     })
 214
 215     it('Should fail with a long support text', async function () {
 216       const fields = { ...baseCorrectParams, support: 'super'.repeat(201) }
 217       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 218     })
 219
 220     it('Should fail with a bad bulkVideosSupportUpdate field', async function () {
 221       const fields = { ...baseCorrectParams, bulkVideosSupportUpdate: 'super' }
 222       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 223     })
 224
 225     it('Should succeed with the correct parameters', async function () {
 226       await makePutBodyRequest({
 227         url: server.url,
 228         path,
 229         token: server.accessToken,
 230         fields: baseCorrectParams,
 231         statusCodeExpected: HttpStatusCode.NO_CONTENT_204
 232       })
 233     })
 234   })
 235
 236   describe('When updating video channel avatar/banner', function () {
 237     const types = [ 'avatar', 'banner' ]
 238     let path: string
 239
 240     before(async function () {
 241       path = videoChannelPath + '/super_channel'
 242     })
 243
 244     it('Should fail with an incorrect input file', async function () {
 245       for (const type of types) {
 246         const fields = {}
 247         const attaches = {
 248           [type + 'file']: buildAbsoluteFixturePath('video_short.mp4')
 249         }
 250
 251         await makeUploadRequest({ url: server.url, path: `${path}/${type}/pick`, token: server.accessToken, fields, attaches })
 252       }
 253     })
 254
 255     it('Should fail with a big file', async function () {
 256       for (const type of types) {
 257         const fields = {}
 258         const attaches = {
 259           [type + 'file']: buildAbsoluteFixturePath('avatar-big.png')
 260         }
 261         await makeUploadRequest({ url: server.url, path: `${path}/${type}/pick`, token: server.accessToken, fields, attaches })
 262       }
 263     })
 264
 265     it('Should fail with an unauthenticated user', async function () {
 266       for (const type of types) {
 267         const fields = {}
 268         const attaches = {
 269           [type + 'file']: buildAbsoluteFixturePath('avatar.png')
 270         }
 271         await makeUploadRequest({
 272           url: server.url,
 273           path: `${path}/${type}/pick`,
 274           fields,
 275           attaches,
 276           statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
 277         })
 278       }
 279     })
 280
 281     it('Should succeed with the correct params', async function () {
 282       for (const type of types) {
 283         const fields = {}
 284         const attaches = {
 285           [type + 'file']: buildAbsoluteFixturePath('avatar.png')
 286         }
 287         await makeUploadRequest({
 288           url: server.url,
 289           path: `${path}/${type}/pick`,
 290           token: server.accessToken,
 291           fields,
 292           attaches,
 293           statusCodeExpected: HttpStatusCode.OK_200
 294         })
 295       }
 296     })
 297   })
 298
 299   describe('When getting a video channel', function () {
 300     it('Should return the list of the video channels with nothing', async function () {
 301       const res = await makeGetRequest({
 302         url: server.url,
 303         path: videoChannelPath,
 304         statusCodeExpected: HttpStatusCode.OK_200
 305       })
 306
 307       expect(res.body.data).to.be.an('array')
 308     })
 309
 310     it('Should return 404 with an incorrect video channel', async function () {
 311       await makeGetRequest({
 312         url: server.url,
 313         path: videoChannelPath + '/super_channel2',
 314         statusCodeExpected: HttpStatusCode.NOT_FOUND_404
 315       })
 316     })
 317
 318     it('Should succeed with the correct parameters', async function () {
 319       await makeGetRequest({
 320         url: server.url,
 321         path: videoChannelPath + '/super_channel',
 322         statusCodeExpected: HttpStatusCode.OK_200
 323       })
 324     })
 325   })
 326
 327   describe('When deleting a video channel', function () {
 328     it('Should fail with a non authenticated user', async function () {
 329       await command.delete({ token: 'coucou', channelName: 'super_channel', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 330     })
 331
 332     it('Should fail with another authenticated user', async function () {
 333       await command.delete({ token: accessTokenUser, channelName: 'super_channel', expectedStatus: HttpStatusCode.FORBIDDEN_403 })
 334     })
 335
 336     it('Should fail with an unknown video channel id', async function () {
 337       await command.delete({ channelName: 'super_channel2', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 338     })
 339
 340     it('Should succeed with the correct parameters', async function () {
 341       await command.delete({ channelName: 'super_channel' })
 342     })
 343
 344     it('Should fail to delete the last user video channel', async function () {
 345       await command.delete({ channelName: 'root_channel', expectedStatus: HttpStatusCode.CONFLICT_409 })
 346     })
 347   })
 348
 349   after(async function () {
 350     await cleanupTests([ server ])
 351   })
 352 })