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

   1 /* tslint:disable:no-unused-expression */
   2
   3 import * as chai from 'chai'
   4 import { omit } from 'lodash'
   5 import 'mocha'
   6 import { join } from 'path'
   7 import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
   8 import {
   9   createUser, flushTests, getMyUserInformation, getVideo, getVideosList, immutableAssign, killallServers, makeDeleteRequest,
  10   makeGetRequest, makeUploadRequest, makePutBodyRequest, removeVideo, runServer, ServerInfo, setAccessTokensToServers, userLogin
  11 } from '../../utils'
  12 import { checkBadCountPagination, checkBadSortPagination, checkBadStartPagination } from '../../utils/requests/check-api-params'
  13
  14 const expect = chai.expect
  15
  16 describe('Test videos API validator', function () {
  17   const path = '/api/v1/videos/'
  18   let server: ServerInfo
  19   let channelId: number
  20
  21   // ---------------------------------------------------------------
  22
  23   before(async function () {
  24     this.timeout(30000)
  25
  26     await flushTests()
  27
  28     server = await runServer(1)
  29
  30     await setAccessTokensToServers([ server ])
  31
  32     const res = await getMyUserInformation(server.url, server.accessToken)
  33     channelId = res.body.videoChannels[0].id
  34   })
  35
  36   describe('When listing a video', function () {
  37     it('Should fail with a bad start pagination', async function () {
  38       await checkBadStartPagination(server.url, path)
  39     })
  40
  41     it('Should fail with a bad count pagination', async function () {
  42       await checkBadCountPagination(server.url, path)
  43     })
  44
  45     it('Should fail with an incorrect sort', async function () {
  46       await checkBadSortPagination(server.url, path)
  47     })
  48   })
  49
  50   describe('When searching a video', function () {
  51
  52     it('Should fail with nothing', async function () {
  53       await makeGetRequest({
  54         url: server.url,
  55         path: join(path, 'search'),
  56         statusCodeExpected: 400
  57       })
  58     })
  59
  60     it('Should fail with a bad start pagination', async function () {
  61       await checkBadStartPagination(server.url, join(path, 'search', 'test'))
  62     })
  63
  64     it('Should fail with a bad count pagination', async function () {
  65       await checkBadCountPagination(server.url, join(path, 'search', 'test'))
  66     })
  67
  68     it('Should fail with an incorrect sort', async function () {
  69       await checkBadSortPagination(server.url, join(path, 'search', 'test'))
  70     })
  71   })
  72
  73   describe('When listing my videos', function () {
  74     const path = '/api/v1/users/me/videos'
  75
  76     it('Should fail with a bad start pagination', async function () {
  77       await checkBadStartPagination(server.url, path, server.accessToken)
  78     })
  79
  80     it('Should fail with a bad count pagination', async function () {
  81       await checkBadCountPagination(server.url, path, server.accessToken)
  82     })
  83
  84     it('Should fail with an incorrect sort', async function () {
  85       await checkBadSortPagination(server.url, path, server.accessToken)
  86     })
  87   })
  88
  89   describe('When adding a video', function () {
  90     let baseCorrectParams
  91     const baseCorrectAttaches = {
  92       'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
  93     }
  94
  95     before(function () {
  96       // Put in before to have channelId
  97       baseCorrectParams = {
  98         name: 'my super name',
  99         category: 5,
 100         licence: 1,
 101         language: 6,
 102         nsfw: false,
 103         commentsEnabled: true,
 104         description: 'my super description',
 105         tags: [ 'tag1', 'tag2' ],
 106         privacy: VideoPrivacy.PUBLIC,
 107         channelId
 108       }
 109     })
 110
 111     it('Should fail with nothing', async function () {
 112       const fields = {}
 113       const attaches = {}
 114       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 115     })
 116
 117     it('Should fail without name', async function () {
 118       const fields = omit(baseCorrectParams, 'name')
 119       const attaches = baseCorrectAttaches
 120
 121       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 122     })
 123
 124     it('Should fail with a long name', async function () {
 125       const fields = immutableAssign(baseCorrectParams, { name: 'super'.repeat(65) })
 126       const attaches = baseCorrectAttaches
 127
 128       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 129     })
 130
 131     it('Should fail with a bad category', async function () {
 132       const fields = immutableAssign(baseCorrectParams, { category: 125 })
 133       const attaches = baseCorrectAttaches
 134
 135       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 136     })
 137
 138     it('Should fail with a bad licence', async function () {
 139       const fields = immutableAssign(baseCorrectParams, { licence: 125 })
 140       const attaches = baseCorrectAttaches
 141
 142       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 143     })
 144
 145     it('Should fail with a bad language', async function () {
 146       const fields = immutableAssign(baseCorrectParams, { language: 125 })
 147       const attaches = baseCorrectAttaches
 148
 149       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 150     })
 151
 152     it('Should fail without nsfw attribute', async function () {
 153       const fields = omit(baseCorrectParams, 'nsfw')
 154       const attaches = baseCorrectAttaches
 155
 156       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 157     })
 158
 159     it('Should fail with a bad nsfw attribute', async function () {
 160       const fields = immutableAssign(baseCorrectParams, { nsfw: 2 })
 161       const attaches = baseCorrectAttaches
 162
 163       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 164     })
 165
 166     it('Should fail without commentsEnabled attribute', async function () {
 167       const fields = omit(baseCorrectParams, 'commentsEnabled')
 168       const attaches = baseCorrectAttaches
 169
 170       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 171     })
 172
 173     it('Should fail with a bad commentsEnabled attribute', async function () {
 174       const fields = immutableAssign(baseCorrectParams, { commentsEnabled: 2 })
 175       const attaches = baseCorrectAttaches
 176
 177       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 178     })
 179
 180     it('Should fail with a long description', async function () {
 181       const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(1500) })
 182       const attaches = baseCorrectAttaches
 183
 184       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 185     })
 186
 187     it('Should fail without a channel', async function () {
 188       const fields = omit(baseCorrectParams, 'channelId')
 189       const attaches = baseCorrectAttaches
 190
 191       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 192     })
 193
 194     it('Should fail with a bad channel', async function () {
 195       const fields = immutableAssign(baseCorrectParams, { channelId: 545454 })
 196       const attaches = baseCorrectAttaches
 197
 198       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 199     })
 200
 201     it('Should fail with another user channel', async function () {
 202       const user = {
 203         username: 'fake',
 204         password: 'fake_password'
 205       }
 206       await createUser(server.url, server.accessToken, user.username, user.password)
 207
 208       const accessTokenUser = await userLogin(server, user)
 209       const res = await getMyUserInformation(server.url, accessTokenUser)
 210       const customChannelId = res.body.videoChannels[0].id
 211
 212       const fields = immutableAssign(baseCorrectParams, { channelId: customChannelId })
 213       const attaches = baseCorrectAttaches
 214
 215       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 216     })
 217
 218     it('Should fail with too many tags', async function () {
 219       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] })
 220       const attaches = baseCorrectAttaches
 221
 222       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 223     })
 224
 225     it('Should fail with a tag length too low', async function () {
 226       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 't' ] })
 227       const attaches = baseCorrectAttaches
 228
 229       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 230     })
 231
 232     it('Should fail with a tag length too big', async function () {
 233       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] })
 234       const attaches = baseCorrectAttaches
 235
 236       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 237     })
 238
 239     it('Should fail without an input file', async function () {
 240       const fields = baseCorrectParams
 241       const attaches = {}
 242       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 243     })
 244
 245     it('Should fail without an incorrect input file', async function () {
 246       const fields = baseCorrectParams
 247       const attaches = {
 248         'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
 249       }
 250       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 251     })
 252
 253     it('Should fail with an incorrect thumbnail file', async function () {
 254       const fields = baseCorrectParams
 255       const attaches = {
 256         'thumbnailfile': join(__dirname, '..', 'fixtures', 'avatar.png'),
 257         'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
 258       }
 259
 260       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 261     })
 262
 263     it('Should fail with a big thumbnail file', async function () {
 264       const fields = baseCorrectParams
 265       const attaches = {
 266         'thumbnailfile': join(__dirname, '..', 'fixtures', 'avatar-big.png'),
 267         'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
 268       }
 269
 270       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 271     })
 272
 273     it('Should fail with an incorrect preview file', async function () {
 274       const fields = baseCorrectParams
 275       const attaches = {
 276         'previewfile': join(__dirname, '..', 'fixtures', 'avatar.png'),
 277         'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
 278       }
 279
 280       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 281     })
 282
 283     it('Should fail with a big preview file', async function () {
 284       const fields = baseCorrectParams
 285       const attaches = {
 286         'previewfile': join(__dirname, '..', 'fixtures', 'avatar-big.png'),
 287         'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
 288       }
 289
 290       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 291     })
 292
 293     it('Should succeed with the correct parameters', async function () {
 294       this.timeout(10000)
 295
 296       const fields = baseCorrectParams
 297
 298       {
 299         const attaches = baseCorrectAttaches
 300         await makeUploadRequest({
 301           url: server.url,
 302           path: path + '/upload',
 303           token: server.accessToken,
 304           fields,
 305           attaches,
 306           statusCodeExpected: 200
 307         })
 308       }
 309
 310       {
 311         const attaches = immutableAssign(baseCorrectAttaches, {
 312           videofile: join(__dirname, '..', 'fixtures', 'video_short.mp4')
 313         })
 314
 315         await makeUploadRequest({
 316           url: server.url,
 317           path: path + '/upload',
 318           token: server.accessToken,
 319           fields,
 320           attaches,
 321           statusCodeExpected: 200
 322         })
 323       }
 324
 325       {
 326         const attaches = immutableAssign(baseCorrectAttaches, {
 327           videofile: join(__dirname, '..', 'fixtures', 'video_short.ogv')
 328         })
 329
 330         await makeUploadRequest({
 331           url: server.url,
 332           path: path + '/upload',
 333           token: server.accessToken,
 334           fields,
 335           attaches,
 336           statusCodeExpected: 200
 337         })
 338       }
 339     })
 340   })
 341
 342   describe('When updating a video', function () {
 343     const baseCorrectParams = {
 344       name: 'my super name',
 345       category: 5,
 346       licence: 2,
 347       language: 6,
 348       nsfw: false,
 349       commentsEnabled: false,
 350       description: 'my super description',
 351       privacy: VideoPrivacy.PUBLIC,
 352       tags: [ 'tag1', 'tag2' ]
 353     }
 354     let videoId
 355
 356     before(async function () {
 357       const res = await getVideosList(server.url)
 358       videoId = res.body.data[0].id
 359     })
 360
 361     it('Should fail with nothing', async function () {
 362       const fields = {}
 363       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 364     })
 365
 366     it('Should fail without a valid uuid', async function () {
 367       const fields = baseCorrectParams
 368       await makePutBodyRequest({ url: server.url, path: path + 'blabla', token: server.accessToken, fields })
 369     })
 370
 371     it('Should fail with an unknown id', async function () {
 372       const fields = baseCorrectParams
 373
 374       await makePutBodyRequest({
 375         url: server.url,
 376         path: path + '4da6fde3-88f7-4d16-b119-108df5630b06',
 377         token: server.accessToken,
 378         fields,
 379         statusCodeExpected: 404
 380       })
 381     })
 382
 383     it('Should fail with a long name', async function () {
 384       const fields = immutableAssign(baseCorrectParams, { name: 'super'.repeat(65) })
 385
 386       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 387     })
 388
 389     it('Should fail with a bad category', async function () {
 390       const fields = immutableAssign(baseCorrectParams, { category: 125 })
 391
 392       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 393     })
 394
 395     it('Should fail with a bad licence', async function () {
 396       const fields = immutableAssign(baseCorrectParams, { licence: 125 })
 397
 398       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 399     })
 400
 401     it('Should fail with a bad language', async function () {
 402       const fields = immutableAssign(baseCorrectParams, { language: 125 })
 403
 404       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 405     })
 406
 407     it('Should fail with a bad nsfw attribute', async function () {
 408       const fields = immutableAssign(baseCorrectParams, { nsfw: 2 })
 409
 410       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 411     })
 412
 413     it('Should fail with a bad commentsEnabled attribute', async function () {
 414       const fields = immutableAssign(baseCorrectParams, { commentsEnabled: 2 })
 415
 416       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 417     })
 418
 419     it('Should fail with a long description', async function () {
 420       const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(1500) })
 421
 422       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 423     })
 424
 425     it('Should fail with too many tags', async function () {
 426       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] })
 427
 428       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 429     })
 430
 431     it('Should fail with a tag length too low', async function () {
 432       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 't' ] })
 433
 434       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 435     })
 436
 437     it('Should fail with a tag length too big', async function () {
 438       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] })
 439
 440       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 441     })
 442
 443     it('Should fail with an incorrect thumbnail file', async function () {
 444       const fields = baseCorrectParams
 445       const attaches = {
 446         'thumbnailfile': join(__dirname, '..', 'fixtures', 'avatar.png')
 447       }
 448
 449       await makeUploadRequest({
 450         url: server.url,
 451         method: 'PUT',
 452         path: path + videoId,
 453         token: server.accessToken,
 454         fields,
 455         attaches
 456       })
 457     })
 458
 459     it('Should fail with a big thumbnail file', async function () {
 460       const fields = baseCorrectParams
 461       const attaches = {
 462         'thumbnailfile': join(__dirname, '..', 'fixtures', 'avatar-big.png')
 463       }
 464
 465       await makeUploadRequest({
 466         url: server.url,
 467         method: 'PUT',
 468         path: path + videoId,
 469         token: server.accessToken,
 470         fields,
 471         attaches
 472       })
 473     })
 474
 475     it('Should fail with an incorrect preview file', async function () {
 476       const fields = baseCorrectParams
 477       const attaches = {
 478         'previewfile': join(__dirname, '..', 'fixtures', 'avatar.png')
 479       }
 480
 481       await makeUploadRequest({
 482         url: server.url,
 483         method: 'PUT',
 484         path: path + videoId,
 485         token: server.accessToken,
 486         fields,
 487         attaches
 488       })
 489     })
 490
 491     it('Should fail with a big preview file', async function () {
 492       const fields = baseCorrectParams
 493       const attaches = {
 494         'previewfile': join(__dirname, '..', 'fixtures', 'avatar-big.png')
 495       }
 496
 497       await makeUploadRequest({
 498         url: server.url,
 499         method: 'PUT',
 500         path: path + videoId,
 501         token: server.accessToken,
 502         fields,
 503         attaches
 504       })
 505     })
 506
 507     it('Should fail with a video of another user')
 508
 509     it('Should fail with a video of another server')
 510
 511     it('Should succeed with the correct parameters', async function () {
 512       const fields = baseCorrectParams
 513
 514       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields, statusCodeExpected: 204 })
 515     })
 516   })
 517
 518   describe('When getting a video', function () {
 519     it('Should return the list of the videos with nothing', async function () {
 520       const res = await makeGetRequest({
 521         url: server.url,
 522         path,
 523         statusCodeExpected: 200
 524       })
 525
 526       expect(res.body.data).to.be.an('array')
 527       expect(res.body.data.length).to.equal(3)
 528     })
 529
 530     it('Should fail without a correct uuid', async function () {
 531       await getVideo(server.url, 'coucou', 400)
 532     })
 533
 534     it('Should return 404 with an incorrect video', async function () {
 535       await getVideo(server.url, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
 536     })
 537
 538     it('Should succeed with the correct parameters')
 539   })
 540
 541   describe('When rating a video', function () {
 542     let videoId
 543
 544     before(async function () {
 545       const res = await getVideosList(server.url)
 546       videoId = res.body.data[0].id
 547     })
 548
 549     it('Should fail without a valid uuid', async function () {
 550       const fields = {
 551         rating: 'like'
 552       }
 553       await makePutBodyRequest({ url: server.url, path: path + 'blabla/rate', token: server.accessToken, fields })
 554     })
 555
 556     it('Should fail with an unknown id', async function () {
 557       const fields = {
 558         rating: 'like'
 559       }
 560       await makePutBodyRequest({
 561         url: server.url,
 562         path: path + '4da6fde3-88f7-4d16-b119-108df5630b06/rate',
 563         token: server.accessToken,
 564         fields,
 565         statusCodeExpected: 404
 566       })
 567     })
 568
 569     it('Should fail with a wrong rating', async function () {
 570       const fields = {
 571         rating: 'likes'
 572       }
 573       await makePutBodyRequest({ url: server.url, path: path + videoId + '/rate', token: server.accessToken, fields })
 574     })
 575
 576     it('Should succeed with the correct parameters', async function () {
 577       const fields = {
 578         rating: 'like'
 579       }
 580       await makePutBodyRequest({
 581         url: server.url,
 582         path: path + videoId + '/rate',
 583         token: server.accessToken,
 584         fields,
 585         statusCodeExpected: 204
 586       })
 587     })
 588   })
 589
 590   describe('When removing a video', function () {
 591     it('Should have 404 with nothing', async function () {
 592       await makeDeleteRequest({
 593         url: server.url,
 594         path,
 595         statusCodeExpected: 400
 596       })
 597     })
 598
 599     it('Should fail without a correct uuid', async function () {
 600       await removeVideo(server.url, server.accessToken, 'hello', 400)
 601     })
 602
 603     it('Should fail with a video which does not exist', async function () {
 604       await removeVideo(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
 605     })
 606
 607     it('Should fail with a video of another user')
 608
 609     it('Should fail with a video of another server')
 610
 611     it('Should succeed with the correct parameters')
 612   })
 613
 614   after(async function () {
 615     killallServers([ server ])
 616
 617     // Keep the logs if the test failed
 618     if (this['ok']) {
 619       await flushTests()
 620     }
 621   })
 622 })