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 accountUUID: 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       accountUUID = res.body.account.uuid
  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/' + accountUUID + '/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         description: 'my super description',
 179         support: 'my super support text',
 180         tags: [ 'tag1', 'tag2' ],
 181         privacy: VideoPrivacy.PUBLIC,
 182         channelId: channelId
 183       }
 184     })
 185
 186     it('Should fail with nothing', async function () {
 187       const fields = {}
 188       const attaches = {}
 189       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 190     })
 191
 192     it('Should fail without name', async function () {
 193       const fields = omit(baseCorrectParams, 'name')
 194       const attaches = baseCorrectAttaches
 195
 196       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 197     })
 198
 199     it('Should fail with a long name', async function () {
 200       const fields = immutableAssign(baseCorrectParams, { name: 'super'.repeat(65) })
 201       const attaches = baseCorrectAttaches
 202
 203       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 204     })
 205
 206     it('Should fail with a bad category', async function () {
 207       const fields = immutableAssign(baseCorrectParams, { category: 125 })
 208       const attaches = baseCorrectAttaches
 209
 210       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 211     })
 212
 213     it('Should fail with a bad licence', async function () {
 214       const fields = immutableAssign(baseCorrectParams, { licence: 125 })
 215       const attaches = baseCorrectAttaches
 216
 217       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 218     })
 219
 220     it('Should fail with a bad language', async function () {
 221       const fields = immutableAssign(baseCorrectParams, { language: 'a'.repeat(15) })
 222       const attaches = baseCorrectAttaches
 223
 224       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 225     })
 226
 227     it('Should fail without nsfw attribute', async function () {
 228       const fields = omit(baseCorrectParams, 'nsfw')
 229       const attaches = baseCorrectAttaches
 230
 231       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 232     })
 233
 234     it('Should fail without commentsEnabled attribute', async function () {
 235       const fields = omit(baseCorrectParams, 'commentsEnabled')
 236       const attaches = baseCorrectAttaches
 237
 238       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 239     })
 240
 241     it('Should fail with a long description', async function () {
 242       const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(2500) })
 243       const attaches = baseCorrectAttaches
 244
 245       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 246     })
 247
 248     it('Should fail with a long support text', async function () {
 249       const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(150) })
 250       const attaches = baseCorrectAttaches
 251
 252       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 253     })
 254
 255     it('Should fail without a channel', async function () {
 256       const fields = omit(baseCorrectParams, 'channelId')
 257       const attaches = baseCorrectAttaches
 258
 259       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 260     })
 261
 262     it('Should fail with a bad channel', async function () {
 263       const fields = immutableAssign(baseCorrectParams, { channelId: 545454 })
 264       const attaches = baseCorrectAttaches
 265
 266       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 267     })
 268
 269     it('Should fail with another user channel', async function () {
 270       const user = {
 271         username: 'fake',
 272         password: 'fake_password'
 273       }
 274       await createUser(server.url, server.accessToken, user.username, user.password)
 275
 276       const accessTokenUser = await userLogin(server, user)
 277       const res = await getMyUserInformation(server.url, accessTokenUser)
 278       const customChannelId = res.body.videoChannels[0].id
 279
 280       const fields = immutableAssign(baseCorrectParams, { channelId: customChannelId })
 281       const attaches = baseCorrectAttaches
 282
 283       await makeUploadRequest({ url: server.url, path: path + '/upload', token: userAccessToken, fields, attaches })
 284     })
 285
 286     it('Should fail with too many tags', async function () {
 287       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] })
 288       const attaches = baseCorrectAttaches
 289
 290       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 291     })
 292
 293     it('Should fail with a tag length too low', async function () {
 294       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 't' ] })
 295       const attaches = baseCorrectAttaches
 296
 297       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 298     })
 299
 300     it('Should fail with a tag length too big', async function () {
 301       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] })
 302       const attaches = baseCorrectAttaches
 303
 304       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 305     })
 306
 307     it('Should fail without an input file', async function () {
 308       const fields = baseCorrectParams
 309       const attaches = {}
 310       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 311     })
 312
 313     it('Should fail without an incorrect input file', async function () {
 314       const fields = baseCorrectParams
 315       const attaches = {
 316         'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
 317       }
 318       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 319     })
 320
 321     it('Should fail with an incorrect thumbnail file', async function () {
 322       const fields = baseCorrectParams
 323       const attaches = {
 324         'thumbnailfile': join(__dirname, '..', 'fixtures', 'avatar.png'),
 325         'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
 326       }
 327
 328       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 329     })
 330
 331     it('Should fail with a big thumbnail file', async function () {
 332       const fields = baseCorrectParams
 333       const attaches = {
 334         'thumbnailfile': join(__dirname, '..', 'fixtures', 'avatar-big.png'),
 335         'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
 336       }
 337
 338       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 339     })
 340
 341     it('Should fail with an incorrect preview file', async function () {
 342       const fields = baseCorrectParams
 343       const attaches = {
 344         'previewfile': join(__dirname, '..', 'fixtures', 'avatar.png'),
 345         'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
 346       }
 347
 348       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 349     })
 350
 351     it('Should fail with a big preview file', async function () {
 352       const fields = baseCorrectParams
 353       const attaches = {
 354         'previewfile': join(__dirname, '..', 'fixtures', 'avatar-big.png'),
 355         'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
 356       }
 357
 358       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 359     })
 360
 361     it('Should succeed with the correct parameters', async function () {
 362       this.timeout(10000)
 363
 364       const fields = baseCorrectParams
 365
 366       {
 367         const attaches = baseCorrectAttaches
 368         await makeUploadRequest({
 369           url: server.url,
 370           path: path + '/upload',
 371           token: server.accessToken,
 372           fields,
 373           attaches,
 374           statusCodeExpected: 200
 375         })
 376       }
 377
 378       {
 379         const attaches = immutableAssign(baseCorrectAttaches, {
 380           videofile: join(__dirname, '..', 'fixtures', 'video_short.mp4')
 381         })
 382
 383         await makeUploadRequest({
 384           url: server.url,
 385           path: path + '/upload',
 386           token: server.accessToken,
 387           fields,
 388           attaches,
 389           statusCodeExpected: 200
 390         })
 391       }
 392
 393       {
 394         const attaches = immutableAssign(baseCorrectAttaches, {
 395           videofile: join(__dirname, '..', 'fixtures', 'video_short.ogv')
 396         })
 397
 398         await makeUploadRequest({
 399           url: server.url,
 400           path: path + '/upload',
 401           token: server.accessToken,
 402           fields,
 403           attaches,
 404           statusCodeExpected: 200
 405         })
 406       }
 407     })
 408   })
 409
 410   describe('When updating a video', function () {
 411     const baseCorrectParams = {
 412       name: 'my super name',
 413       category: 5,
 414       licence: 2,
 415       language: 'pt',
 416       nsfw: false,
 417       commentsEnabled: false,
 418       description: 'my super description',
 419       privacy: VideoPrivacy.PUBLIC,
 420       tags: [ 'tag1', 'tag2' ]
 421     }
 422
 423     before(async function () {
 424       const res = await getVideosList(server.url)
 425       videoId = res.body.data[0].uuid
 426     })
 427
 428     it('Should fail with nothing', async function () {
 429       const fields = {}
 430       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 431     })
 432
 433     it('Should fail without a valid uuid', async function () {
 434       const fields = baseCorrectParams
 435       await makePutBodyRequest({ url: server.url, path: path + 'blabla', token: server.accessToken, fields })
 436     })
 437
 438     it('Should fail with an unknown id', async function () {
 439       const fields = baseCorrectParams
 440
 441       await makePutBodyRequest({
 442         url: server.url,
 443         path: path + '4da6fde3-88f7-4d16-b119-108df5630b06',
 444         token: server.accessToken,
 445         fields,
 446         statusCodeExpected: 404
 447       })
 448     })
 449
 450     it('Should fail with a long name', async function () {
 451       const fields = immutableAssign(baseCorrectParams, { name: 'super'.repeat(65) })
 452
 453       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 454     })
 455
 456     it('Should fail with a bad category', async function () {
 457       const fields = immutableAssign(baseCorrectParams, { category: 125 })
 458
 459       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 460     })
 461
 462     it('Should fail with a bad licence', async function () {
 463       const fields = immutableAssign(baseCorrectParams, { licence: 125 })
 464
 465       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 466     })
 467
 468     it('Should fail with a bad language', async function () {
 469       const fields = immutableAssign(baseCorrectParams, { language: 'a'.repeat(15) })
 470
 471       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 472     })
 473
 474     it('Should fail with a long description', async function () {
 475       const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(2500) })
 476
 477       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 478     })
 479
 480     it('Should fail with a long support text', async function () {
 481       const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(150) })
 482
 483       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 484     })
 485
 486     it('Should fail with a bad channel', async function () {
 487       const fields = immutableAssign(baseCorrectParams, { channelId: 545454 })
 488
 489       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 490     })
 491
 492     it('Should fail with too many tags', async function () {
 493       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] })
 494
 495       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 496     })
 497
 498     it('Should fail with a tag length too low', async function () {
 499       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 't' ] })
 500
 501       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 502     })
 503
 504     it('Should fail with a tag length too big', async function () {
 505       const fields = immutableAssign(baseCorrectParams, { tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] })
 506
 507       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
 508     })
 509
 510     it('Should fail with an incorrect thumbnail file', async function () {
 511       const fields = baseCorrectParams
 512       const attaches = {
 513         'thumbnailfile': join(__dirname, '..', 'fixtures', 'avatar.png')
 514       }
 515
 516       await makeUploadRequest({
 517         url: server.url,
 518         method: 'PUT',
 519         path: path + videoId,
 520         token: server.accessToken,
 521         fields,
 522         attaches
 523       })
 524     })
 525
 526     it('Should fail with a big thumbnail file', async function () {
 527       const fields = baseCorrectParams
 528       const attaches = {
 529         'thumbnailfile': join(__dirname, '..', 'fixtures', 'avatar-big.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 an incorrect preview file', async function () {
 543       const fields = baseCorrectParams
 544       const attaches = {
 545         'previewfile': join(__dirname, '..', 'fixtures', 'avatar.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 a big preview file', async function () {
 559       const fields = baseCorrectParams
 560       const attaches = {
 561         'previewfile': join(__dirname, '..', 'fixtures', 'avatar-big.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 video of another user without the appropriate right', async function () {
 575       const fields = baseCorrectParams
 576
 577       await makePutBodyRequest({ url: server.url, path: path + videoId, token: userAccessToken, fields, statusCodeExpected: 403 })
 578     })
 579
 580     it('Should fail with a video of another server')
 581
 582     it('Should succeed with the correct parameters', async function () {
 583       const fields = baseCorrectParams
 584
 585       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields, statusCodeExpected: 204 })
 586     })
 587   })
 588
 589   describe('When getting a video', function () {
 590     it('Should return the list of the videos with nothing', async function () {
 591       const res = await makeGetRequest({
 592         url: server.url,
 593         path,
 594         statusCodeExpected: 200
 595       })
 596
 597       expect(res.body.data).to.be.an('array')
 598       expect(res.body.data.length).to.equal(3)
 599     })
 600
 601     it('Should fail without a correct uuid', async function () {
 602       await getVideo(server.url, 'coucou', 400)
 603     })
 604
 605     it('Should return 404 with an incorrect video', async function () {
 606       await getVideo(server.url, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
 607     })
 608
 609     it('Should succeed with the correct parameters', async function () {
 610       await getVideo(server.url, videoId)
 611     })
 612   })
 613
 614   describe('When rating a video', function () {
 615     let videoId
 616
 617     before(async function () {
 618       const res = await getVideosList(server.url)
 619       videoId = res.body.data[0].id
 620     })
 621
 622     it('Should fail without a valid uuid', async function () {
 623       const fields = {
 624         rating: 'like'
 625       }
 626       await makePutBodyRequest({ url: server.url, path: path + 'blabla/rate', token: server.accessToken, fields })
 627     })
 628
 629     it('Should fail with an unknown id', async function () {
 630       const fields = {
 631         rating: 'like'
 632       }
 633       await makePutBodyRequest({
 634         url: server.url,
 635         path: path + '4da6fde3-88f7-4d16-b119-108df5630b06/rate',
 636         token: server.accessToken,
 637         fields,
 638         statusCodeExpected: 404
 639       })
 640     })
 641
 642     it('Should fail with a wrong rating', async function () {
 643       const fields = {
 644         rating: 'likes'
 645       }
 646       await makePutBodyRequest({ url: server.url, path: path + videoId + '/rate', token: server.accessToken, fields })
 647     })
 648
 649     it('Should succeed with the correct parameters', async function () {
 650       const fields = {
 651         rating: 'like'
 652       }
 653       await makePutBodyRequest({
 654         url: server.url,
 655         path: path + videoId + '/rate',
 656         token: server.accessToken,
 657         fields,
 658         statusCodeExpected: 204
 659       })
 660     })
 661   })
 662
 663   describe('When removing a video', function () {
 664     it('Should have 404 with nothing', async function () {
 665       await makeDeleteRequest({
 666         url: server.url,
 667         path,
 668         statusCodeExpected: 400
 669       })
 670     })
 671
 672     it('Should fail without a correct uuid', async function () {
 673       await removeVideo(server.url, server.accessToken, 'hello', 400)
 674     })
 675
 676     it('Should fail with a video which does not exist', async function () {
 677       await removeVideo(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
 678     })
 679
 680     it('Should fail with a video of another user without the appropriate right', async function () {
 681       await removeVideo(server.url, userAccessToken, videoId, 403)
 682     })
 683
 684     it('Should fail with a video of another server')
 685
 686     it('Should succeed with the correct parameters', async function () {
 687       await removeVideo(server.url, server.accessToken, videoId)
 688     })
 689   })
 690
 691   after(async function () {
 692     killallServers([ server ])
 693
 694     // Keep the logs if the test failed
 695     if (this['ok']) {
 696       await flushTests()
 697     }
 698   })
 699 })