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