server/tests/api/check-params/video-channels.ts

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