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

   1 /* tslint:disable:no-unused-expression */
   2
   3 import { omit } from 'lodash'
   4 import 'mocha'
   5 import { join } from 'path'
   6 import { UserRole, VideoImport, VideoImportState } from '../../../../shared'
   7
   8 import {
   9   createUser, flushTests, getMyUserInformation, getMyUserVideoRating, getUsersList, immutableAssign, killallServers, makeGetRequest,
  10   makePostBodyRequest, makeUploadRequest, makePutBodyRequest, registerUser, removeUser, runServer, ServerInfo, setAccessTokensToServers,
  11   updateUser, uploadVideo, userLogin, deleteMe, unblockUser, blockUser
  12 } from '../../../../shared/utils'
  13 import {
  14   checkBadCountPagination,
  15   checkBadSortPagination,
  16   checkBadStartPagination
  17 } from '../../../../shared/utils/requests/check-api-params'
  18 import { getMagnetURI, getMyVideoImports, getYoutubeVideoUrl, importVideo } from '../../../../shared/utils/videos/video-imports'
  19 import { VideoPrivacy } from '../../../../shared/models/videos'
  20 import { waitJobs } from '../../../../shared/utils/server/jobs'
  21 import { expect } from 'chai'
  22
  23 describe('Test users API validators', function () {
  24   const path = '/api/v1/users/'
  25   let userId: number
  26   let rootId: number
  27   let videoId: number
  28   let server: ServerInfo
  29   let serverWithRegistrationDisabled: ServerInfo
  30   let userAccessToken = ''
  31   let channelId: number
  32   const user = {
  33     username: 'user1',
  34     password: 'my super password'
  35   }
  36
  37   // ---------------------------------------------------------------
  38
  39   before(async function () {
  40     this.timeout(30000)
  41
  42     await flushTests()
  43
  44     server = await runServer(1)
  45     serverWithRegistrationDisabled = await runServer(2)
  46
  47     await setAccessTokensToServers([ server ])
  48
  49     const videoQuota = 42000000
  50     await createUser(server.url, server.accessToken, user.username, user.password, videoQuota)
  51     userAccessToken = await userLogin(server, user)
  52
  53     {
  54       const res = await getMyUserInformation(server.url, server.accessToken)
  55       channelId = res.body.videoChannels[ 0 ].id
  56     }
  57
  58     {
  59       const res = await uploadVideo(server.url, server.accessToken, {})
  60       videoId = res.body.video.id
  61     }
  62   })
  63
  64   describe('When listing users', function () {
  65     it('Should fail with a bad start pagination', async function () {
  66       await checkBadStartPagination(server.url, path, server.accessToken)
  67     })
  68
  69     it('Should fail with a bad count pagination', async function () {
  70       await checkBadCountPagination(server.url, path, server.accessToken)
  71     })
  72
  73     it('Should fail with an incorrect sort', async function () {
  74       await checkBadSortPagination(server.url, path, server.accessToken)
  75     })
  76
  77     it('Should fail with a non authenticated user', async function () {
  78       await makeGetRequest({
  79         url: server.url,
  80         path,
  81         statusCodeExpected: 401
  82       })
  83     })
  84
  85     it('Should fail with a non admin user', async function () {
  86       await makeGetRequest({
  87         url: server.url,
  88         path,
  89         token: userAccessToken,
  90         statusCodeExpected: 403
  91       })
  92     })
  93   })
  94
  95   describe('When adding a new user', function () {
  96     const baseCorrectParams = {
  97       username: 'user2',
  98       email: 'test@example.com',
  99       password: 'my super password',
 100       videoQuota: -1,
 101       videoQuotaDaily: -1,
 102       role: UserRole.USER
 103     }
 104
 105     it('Should fail with a too small username', async function () {
 106       const fields = immutableAssign(baseCorrectParams, { username: 'fi' })
 107
 108       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 109     })
 110
 111     it('Should fail with a too long username', async function () {
 112       const fields = immutableAssign(baseCorrectParams, { username: 'my_super_username_which_is_very_long' })
 113
 114       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 115     })
 116
 117     it('Should fail with a not lowercase username', async function () {
 118       const fields = immutableAssign(baseCorrectParams, { username: 'Toto' })
 119
 120       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 121     })
 122
 123     it('Should fail with an incorrect username', async function () {
 124       const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
 125
 126       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 127     })
 128
 129     it('Should fail with a missing email', async function () {
 130       const fields = omit(baseCorrectParams, 'email')
 131
 132       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 133     })
 134
 135     it('Should fail with an invalid email', async function () {
 136       const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
 137
 138       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 139     })
 140
 141     it('Should fail with a too small password', async function () {
 142       const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
 143
 144       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 145     })
 146
 147     it('Should fail with a too long password', async function () {
 148       const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
 149
 150       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 151     })
 152
 153     it('Should fail with an non authenticated user', async function () {
 154       await makePostBodyRequest({
 155         url: server.url,
 156         path,
 157         token: 'super token',
 158         fields: baseCorrectParams,
 159         statusCodeExpected: 401
 160       })
 161     })
 162
 163     it('Should fail if we add a user with the same username', async function () {
 164       const fields = immutableAssign(baseCorrectParams, { username: 'user1' })
 165
 166       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 })
 167     })
 168
 169     it('Should fail if we add a user with the same email', async function () {
 170       const fields = immutableAssign(baseCorrectParams, { email: 'user1@example.com' })
 171
 172       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 })
 173     })
 174
 175     it('Should fail without a videoQuota', async function () {
 176       const fields = omit(baseCorrectParams, 'videoQuota')
 177
 178       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 179     })
 180
 181     it('Should fail without a videoQuotaDaily', async function () {
 182       const fields = omit(baseCorrectParams, 'videoQuotaDaily')
 183
 184       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 185     })
 186
 187     it('Should fail with an invalid videoQuota', async function () {
 188       const fields = immutableAssign(baseCorrectParams, { videoQuota: -5 })
 189
 190       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 191     })
 192
 193     it('Should fail with an invalid videoQuotaDaily', async function () {
 194       const fields = immutableAssign(baseCorrectParams, { videoQuotaDaily: -7 })
 195
 196       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 197     })
 198
 199     it('Should fail without a user role', async function () {
 200       const fields = omit(baseCorrectParams, 'role')
 201
 202       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 203     })
 204
 205     it('Should fail with an invalid user role', async function () {
 206       const fields = immutableAssign(baseCorrectParams, { role: 88989 })
 207
 208       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 209     })
 210
 211     it('Should fail with a "peertube" username', async function () {
 212       const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
 213
 214       await makePostBodyRequest({
 215         url: server.url,
 216         path,
 217         token: server.accessToken,
 218         fields,
 219         statusCodeExpected: 409
 220       })
 221     })
 222
 223     it('Should succeed with the correct params', async function () {
 224       await makePostBodyRequest({
 225         url: server.url,
 226         path,
 227         token: server.accessToken,
 228         fields: baseCorrectParams,
 229         statusCodeExpected: 200
 230       })
 231     })
 232
 233     it('Should fail with a non admin user', async function () {
 234       const user = {
 235         username: 'user1',
 236         password: 'my super password'
 237       }
 238       userAccessToken = await userLogin(server, user)
 239
 240       const fields = {
 241         username: 'user3',
 242         email: 'test@example.com',
 243         password: 'my super password',
 244         videoQuota: 42000000
 245       }
 246       await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: 403 })
 247     })
 248   })
 249
 250   describe('When updating my account', function () {
 251     it('Should fail with an invalid email attribute', async function () {
 252       const fields = {
 253         email: 'blabla'
 254       }
 255
 256       await makePutBodyRequest({ url: server.url, path: path + 'me', token: server.accessToken, fields })
 257     })
 258
 259     it('Should fail with a too small password', async function () {
 260       const fields = {
 261         currentPassword: 'my super password',
 262         password: 'bla'
 263       }
 264
 265       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
 266     })
 267
 268     it('Should fail with a too long password', async function () {
 269       const fields = {
 270         currentPassword: 'my super password',
 271         password: 'super'.repeat(61)
 272       }
 273
 274       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
 275     })
 276
 277     it('Should fail without the current password', async function () {
 278       const fields = {
 279         currentPassword: 'my super password',
 280         password: 'super'.repeat(61)
 281       }
 282
 283       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
 284     })
 285
 286     it('Should fail with an invalid current password', async function () {
 287       const fields = {
 288         currentPassword: 'my super password fail',
 289         password: 'super'.repeat(61)
 290       }
 291
 292       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 401 })
 293     })
 294
 295     it('Should fail with an invalid NSFW policy attribute', async function () {
 296       const fields = {
 297         nsfwPolicy: 'hello'
 298       }
 299
 300       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
 301     })
 302
 303     it('Should fail with an invalid autoPlayVideo attribute', async function () {
 304       const fields = {
 305         autoPlayVideo: -1
 306       }
 307
 308       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
 309     })
 310
 311     it('Should fail with an non authenticated user', async function () {
 312       const fields = {
 313         currentPassword: 'my super password',
 314         password: 'my super password'
 315       }
 316
 317       await makePutBodyRequest({ url: server.url, path: path + 'me', token: 'super token', fields, statusCodeExpected: 401 })
 318     })
 319
 320     it('Should fail with a too long description', async function () {
 321       const fields = {
 322         description: 'super'.repeat(201)
 323       }
 324
 325       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
 326     })
 327
 328     it('Should succeed to change password with the correct params', async function () {
 329       const fields = {
 330         currentPassword: 'my super password',
 331         password: 'my super password',
 332         nsfwPolicy: 'blur',
 333         autoPlayVideo: false,
 334         email: 'super_email@example.com'
 335       }
 336
 337       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
 338     })
 339
 340     it('Should succeed without password change with the correct params', async function () {
 341       const fields = {
 342         nsfwPolicy: 'blur',
 343         autoPlayVideo: false,
 344         email: 'super_email@example.com'
 345       }
 346
 347       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
 348     })
 349   })
 350
 351   describe('When updating my avatar', function () {
 352     it('Should fail without an incorrect input file', async function () {
 353       const fields = {}
 354       const attaches = {
 355         'avatarfile': join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
 356       }
 357       await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
 358     })
 359
 360     it('Should fail with a big file', async function () {
 361       const fields = {}
 362       const attaches = {
 363         'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar-big.png')
 364       }
 365       await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
 366     })
 367
 368     it('Should fail with an unauthenticated user', async function () {
 369       const fields = {}
 370       const attaches = {
 371         'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
 372       }
 373       await makeUploadRequest({
 374         url: server.url,
 375         path: path + '/me/avatar/pick',
 376         fields,
 377         attaches,
 378         statusCodeExpected: 401
 379       })
 380     })
 381
 382     it('Should succeed with the correct params', async function () {
 383       const fields = {}
 384       const attaches = {
 385         'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
 386       }
 387       await makeUploadRequest({
 388         url: server.url,
 389         path: path + '/me/avatar/pick',
 390         token: server.accessToken,
 391         fields,
 392         attaches,
 393         statusCodeExpected: 200
 394       })
 395     })
 396   })
 397
 398   describe('When getting a user', function () {
 399     before(async function () {
 400       const res = await getUsersList(server.url, server.accessToken)
 401
 402       userId = res.body.data[1].id
 403     })
 404
 405     it('Should fail with an non authenticated user', async function () {
 406       await makeGetRequest({ url: server.url, path: path + userId, token: 'super token', statusCodeExpected: 401 })
 407     })
 408
 409     it('Should fail with a non admin user', async function () {
 410       await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 403 })
 411     })
 412
 413     it('Should succeed with the correct params', async function () {
 414       await makeGetRequest({ url: server.url, path: path + userId, token: server.accessToken, statusCodeExpected: 200 })
 415     })
 416   })
 417
 418   describe('When updating a user', function () {
 419
 420     before(async function () {
 421       const res = await getUsersList(server.url, server.accessToken)
 422
 423       userId = res.body.data[1].id
 424       rootId = res.body.data[2].id
 425     })
 426
 427     it('Should fail with an invalid email attribute', async function () {
 428       const fields = {
 429         email: 'blabla'
 430       }
 431
 432       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
 433     })
 434
 435     it('Should fail with an invalid videoQuota attribute', async function () {
 436       const fields = {
 437         videoQuota: -90
 438       }
 439
 440       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
 441     })
 442
 443     it('Should fail with an invalid user role attribute', async function () {
 444       const fields = {
 445         role: 54878
 446       }
 447
 448       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
 449     })
 450
 451     it('Should fail with an non authenticated user', async function () {
 452       const fields = {
 453         videoQuota: 42
 454       }
 455
 456       await makePutBodyRequest({ url: server.url, path: path + userId, token: 'super token', fields, statusCodeExpected: 401 })
 457     })
 458
 459     it('Should fail when updating root role', async function () {
 460       const fields = {
 461         role: UserRole.MODERATOR
 462       }
 463
 464       await makePutBodyRequest({ url: server.url, path: path + rootId, token: server.accessToken, fields })
 465     })
 466
 467     it('Should succeed with the correct params', async function () {
 468       const fields = {
 469         email: 'email@example.com',
 470         videoQuota: 42,
 471         role: UserRole.MODERATOR
 472       }
 473
 474       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields, statusCodeExpected: 204 })
 475       userAccessToken = await userLogin(server, user)
 476     })
 477   })
 478
 479   describe('When getting my information', function () {
 480     it('Should fail with a non authenticated user', async function () {
 481       await getMyUserInformation(server.url, 'fake_token', 401)
 482     })
 483
 484     it('Should success with the correct parameters', async function () {
 485       await getMyUserInformation(server.url, userAccessToken)
 486     })
 487   })
 488
 489   describe('When getting my video rating', function () {
 490     it('Should fail with a non authenticated user', async function () {
 491       await getMyUserVideoRating(server.url, 'fake_token', videoId, 401)
 492     })
 493
 494     it('Should fail with an incorrect video uuid', async function () {
 495       await getMyUserVideoRating(server.url, server.accessToken, 'blabla', 400)
 496     })
 497
 498     it('Should fail with an unknown video', async function () {
 499       await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
 500     })
 501
 502     it('Should succeed with the correct parameters', async function () {
 503       await getMyUserVideoRating(server.url, server.accessToken, videoId)
 504     })
 505   })
 506
 507   describe('When blocking/unblocking/removing user', function () {
 508     it('Should fail with an incorrect id', async function () {
 509       await removeUser(server.url, 'blabla', server.accessToken, 400)
 510       await blockUser(server.url, 'blabla', server.accessToken, 400)
 511       await unblockUser(server.url, 'blabla', server.accessToken, 400)
 512     })
 513
 514     it('Should fail with the root user', async function () {
 515       await removeUser(server.url, rootId, server.accessToken, 400)
 516       await blockUser(server.url, rootId, server.accessToken, 400)
 517       await unblockUser(server.url, rootId, server.accessToken, 400)
 518     })
 519
 520     it('Should return 404 with a non existing id', async function () {
 521       await removeUser(server.url, 4545454, server.accessToken, 404)
 522       await blockUser(server.url, 4545454, server.accessToken, 404)
 523       await unblockUser(server.url, 4545454, server.accessToken, 404)
 524     })
 525
 526     it('Should fail with a non admin user', async function () {
 527       await removeUser(server.url, userId, userAccessToken, 403)
 528       await blockUser(server.url, userId, userAccessToken, 403)
 529       await unblockUser(server.url, userId, userAccessToken, 403)
 530     })
 531   })
 532
 533   describe('When deleting our account', function () {
 534     it('Should fail with with the root account', async function () {
 535       await deleteMe(server.url, server.accessToken, 400)
 536     })
 537   })
 538
 539   describe('When register a new user', function () {
 540     const registrationPath = path + '/register'
 541     const baseCorrectParams = {
 542       username: 'user3',
 543       email: 'test3@example.com',
 544       password: 'my super password'
 545     }
 546
 547     it('Should fail with a too small username', async function () {
 548       const fields = immutableAssign(baseCorrectParams, { username: 'ji' })
 549
 550       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 551     })
 552
 553     it('Should fail with a too long username', async function () {
 554       const fields = immutableAssign(baseCorrectParams, { username: 'my_super_username_which_is_very_long' })
 555
 556       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 557     })
 558
 559     it('Should fail with an incorrect username', async function () {
 560       const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
 561
 562       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 563     })
 564
 565     it('Should fail with a missing email', async function () {
 566       const fields = omit(baseCorrectParams, 'email')
 567
 568       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 569     })
 570
 571     it('Should fail with an invalid email', async function () {
 572       const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
 573
 574       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 575     })
 576
 577     it('Should fail with a too small password', async function () {
 578       const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
 579
 580       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 581     })
 582
 583     it('Should fail with a too long password', async function () {
 584       const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
 585
 586       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 587     })
 588
 589     it('Should fail if we register a user with the same username', async function () {
 590       const fields = immutableAssign(baseCorrectParams, { username: 'root' })
 591
 592       await makePostBodyRequest({
 593         url: server.url,
 594         path: registrationPath,
 595         token: server.accessToken,
 596         fields,
 597         statusCodeExpected: 409
 598       })
 599     })
 600
 601     it('Should fail with a "peertube" username', async function () {
 602       const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
 603
 604       await makePostBodyRequest({
 605         url: server.url,
 606         path: registrationPath,
 607         token: server.accessToken,
 608         fields,
 609         statusCodeExpected: 409
 610       })
 611     })
 612
 613     it('Should fail if we register a user with the same email', async function () {
 614       const fields = immutableAssign(baseCorrectParams, { email: 'admin1@example.com' })
 615
 616       await makePostBodyRequest({
 617         url: server.url,
 618         path: registrationPath,
 619         token: server.accessToken,
 620         fields,
 621         statusCodeExpected: 409
 622       })
 623     })
 624
 625     it('Should succeed with the correct params', async function () {
 626       await makePostBodyRequest({
 627         url: server.url,
 628         path: registrationPath,
 629         token: server.accessToken,
 630         fields: baseCorrectParams,
 631         statusCodeExpected: 204
 632       })
 633     })
 634
 635     it('Should fail on a server with registration disabled', async function () {
 636       const fields = {
 637         username: 'user4',
 638         email: 'test4@example.com',
 639         password: 'my super password 4'
 640       }
 641
 642       await makePostBodyRequest({
 643         url: serverWithRegistrationDisabled.url,
 644         path: registrationPath,
 645         token: serverWithRegistrationDisabled.accessToken,
 646         fields,
 647         statusCodeExpected: 403
 648       })
 649     })
 650   })
 651
 652   describe('When registering multiple users on a server with users limit', function () {
 653     it('Should fail when after 3 registrations', async function () {
 654       await registerUser(server.url, 'user42', 'super password', 403)
 655     })
 656   })
 657
 658   describe('When having a video quota', function () {
 659     it('Should fail with a user having too many videos', async function () {
 660       await updateUser({
 661         url: server.url,
 662         userId: rootId,
 663         accessToken: server.accessToken,
 664         videoQuota: 42
 665       })
 666
 667       await uploadVideo(server.url, server.accessToken, {}, 403)
 668     })
 669
 670     it('Should fail with a registered user having too many videos', async function () {
 671       this.timeout(30000)
 672
 673       const user = {
 674         username: 'user3',
 675         password: 'my super password'
 676       }
 677       userAccessToken = await userLogin(server, user)
 678
 679       const videoAttributes = { fixture: 'video_short2.webm' }
 680       await uploadVideo(server.url, userAccessToken, videoAttributes)
 681       await uploadVideo(server.url, userAccessToken, videoAttributes)
 682       await uploadVideo(server.url, userAccessToken, videoAttributes)
 683       await uploadVideo(server.url, userAccessToken, videoAttributes)
 684       await uploadVideo(server.url, userAccessToken, videoAttributes)
 685       await uploadVideo(server.url, userAccessToken, videoAttributes, 403)
 686     })
 687
 688     it('Should fail to import with HTTP/Torrent/magnet', async function () {
 689       this.timeout(120000)
 690
 691       const baseAttributes = {
 692         channelId: 1,
 693         privacy: VideoPrivacy.PUBLIC
 694       }
 695       await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() }))
 696       await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
 697       await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' }))
 698
 699       await waitJobs([ server ])
 700
 701       const res = await getMyVideoImports(server.url, server.accessToken)
 702
 703       expect(res.body.total).to.equal(3)
 704       const videoImports: VideoImport[] = res.body.data
 705       expect(videoImports).to.have.lengthOf(3)
 706
 707       for (const videoImport of videoImports) {
 708         expect(videoImport.state.id).to.equal(VideoImportState.FAILED)
 709         expect(videoImport.error).not.to.be.undefined
 710         expect(videoImport.error).to.contain('user video quota is exceeded')
 711       }
 712     })
 713   })
 714
 715   describe('When having a daily video quota', function () {
 716     it('Should fail with a user having too many videos', async function () {
 717       await updateUser({
 718         url: server.url,
 719         userId: rootId,
 720         accessToken: server.accessToken,
 721         videoQuotaDaily: 42
 722       })
 723
 724       await uploadVideo(server.url, server.accessToken, {}, 403)
 725     })
 726   })
 727
 728   describe('When having an absolute and daily video quota', function () {
 729     it('Should fail if exceeding total quota', async function () {
 730       await updateUser({
 731         url: server.url,
 732         userId: rootId,
 733         accessToken: server.accessToken,
 734         videoQuota: 42,
 735         videoQuotaDaily: 1024 * 1024 * 1024
 736       })
 737
 738       await uploadVideo(server.url, server.accessToken, {}, 403)
 739     })
 740
 741     it('Should fail if exceeding daily quota', async function () {
 742       await updateUser({
 743         url: server.url,
 744         userId: rootId,
 745         accessToken: server.accessToken,
 746         videoQuota: 1024 * 1024 * 1024,
 747         videoQuotaDaily: 42
 748       })
 749
 750       await uploadVideo(server.url, server.accessToken, {}, 403)
 751     })
 752   })
 753
 754   describe('When asking a password reset', function () {
 755     const path = '/api/v1/users/ask-reset-password'
 756
 757     it('Should fail with a missing email', async function () {
 758       const fields = {}
 759
 760       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 761     })
 762
 763     it('Should fail with an invalid email', async function () {
 764       const fields = { email: 'hello' }
 765
 766       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 767     })
 768
 769     it('Should success with the correct params', async function () {
 770       const fields = { email: 'admin@example.com' }
 771
 772       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
 773     })
 774   })
 775
 776   describe('When asking for an account verification email', function () {
 777     const path = '/api/v1/users/ask-send-verify-email'
 778
 779     it('Should fail with a missing email', async function () {
 780       const fields = {}
 781
 782       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 783     })
 784
 785     it('Should fail with an invalid email', async function () {
 786       const fields = { email: 'hello' }
 787
 788       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 789     })
 790
 791     it('Should succeed with the correct params', async function () {
 792       const fields = { email: 'admin@example.com' }
 793
 794       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
 795     })
 796   })
 797
 798   after(async function () {
 799     killallServers([ server, serverWithRegistrationDisabled ])
 800
 801     // Keep the logs if the test failed
 802     if (this['ok']) {
 803       await flushTests()
 804     }
 805   })
 806 })