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
  29 const expect = chai.expect
  30
  31 describe('Test video channels API validator', function () {
  32   const videoChannelPath = '/api/v1/video-channels'
  33   let server: ServerInfo
  34   let accessTokenUser: string
  35
  36   // ---------------------------------------------------------------
  37
  38   before(async function () {
  39     this.timeout(30000)
  40
  41     server = await flushAndRunServer(1)
  42
  43     await setAccessTokensToServers([ server ])
  44
  45     const user = {
  46       username: 'fake',
  47       password: 'fake_password'
  48     }
  49
  50     {
  51       await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
  52       accessTokenUser = await userLogin(server, user)
  53     }
  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 getAccountVideoChannelsList({ url: server.url, accountName: 'unknown', specialStatus: 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: 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: 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 = immutableAssign(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 = immutableAssign(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 = immutableAssign(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 = immutableAssign(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: 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: 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: 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: 403
 202       })
 203     })
 204
 205     it('Should fail with a long name', async function () {
 206       const fields = immutableAssign(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 = immutableAssign(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 = immutableAssign(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 = immutableAssign(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: 204
 232       })
 233     })
 234   })
 235
 236   describe('When updating video channel avatar', function () {
 237     let path: string
 238
 239     before(async function () {
 240       path = videoChannelPath + '/super_channel'
 241     })
 242
 243     it('Should fail with an incorrect input file', async function () {
 244       const fields = {}
 245       const attaches = {
 246         avatarfile: join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
 247       }
 248       await makeUploadRequest({ url: server.url, path: path + '/avatar/pick', token: server.accessToken, fields, attaches })
 249     })
 250
 251     it('Should fail with a big file', async function () {
 252       const fields = {}
 253       const attaches = {
 254         avatarfile: join(__dirname, '..', '..', 'fixtures', 'avatar-big.png')
 255       }
 256       await makeUploadRequest({ url: server.url, path: path + '/avatar/pick', token: server.accessToken, fields, attaches })
 257     })
 258
 259     it('Should fail with an unauthenticated user', async function () {
 260       const fields = {}
 261       const attaches = {
 262         avatarfile: join(__dirname, '..', '..', 'fixtures', 'avatar.png')
 263       }
 264       await makeUploadRequest({
 265         url: server.url,
 266         path: path + '/avatar/pick',
 267         fields,
 268         attaches,
 269         statusCodeExpected: 401
 270       })
 271     })
 272
 273     it('Should succeed with the correct params', async function () {
 274       const fields = {}
 275       const attaches = {
 276         avatarfile: join(__dirname, '..', '..', 'fixtures', 'avatar.png')
 277       }
 278       await makeUploadRequest({
 279         url: server.url,
 280         path: path + '/avatar/pick',
 281         token: server.accessToken,
 282         fields,
 283         attaches,
 284         statusCodeExpected: 200
 285       })
 286     })
 287   })
 288
 289   describe('When getting a video channel', function () {
 290     it('Should return the list of the video channels with nothing', async function () {
 291       const res = await makeGetRequest({
 292         url: server.url,
 293         path: videoChannelPath,
 294         statusCodeExpected: 200
 295       })
 296
 297       expect(res.body.data).to.be.an('array')
 298     })
 299
 300     it('Should return 404 with an incorrect video channel', async function () {
 301       await makeGetRequest({
 302         url: server.url,
 303         path: videoChannelPath + '/super_channel2',
 304         statusCodeExpected: 404
 305       })
 306     })
 307
 308     it('Should succeed with the correct parameters', async function () {
 309       await makeGetRequest({
 310         url: server.url,
 311         path: videoChannelPath + '/super_channel',
 312         statusCodeExpected: 200
 313       })
 314     })
 315   })
 316
 317   describe('When deleting a video channel', function () {
 318     it('Should fail with a non authenticated user', async function () {
 319       await deleteVideoChannel(server.url, 'coucou', 'super_channel', 401)
 320     })
 321
 322     it('Should fail with another authenticated user', async function () {
 323       await deleteVideoChannel(server.url, accessTokenUser, 'super_channel', 403)
 324     })
 325
 326     it('Should fail with an unknown video channel id', async function () {
 327       await deleteVideoChannel(server.url, server.accessToken, 'super_channel2', 404)
 328     })
 329
 330     it('Should succeed with the correct parameters', async function () {
 331       await deleteVideoChannel(server.url, server.accessToken, 'super_channel')
 332     })
 333
 334     it('Should fail to delete the last user video channel', async function () {
 335       await deleteVideoChannel(server.url, server.accessToken, 'root_channel', 409)
 336     })
 337   })
 338
 339   after(async function () {
 340     await cleanupTests([ server ])
 341   })
 342 })