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: '' })
 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: 'super'.repeat(50) })
 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 invalid videosHistoryEnabled attribute', async function () {
 312       const fields = {
 313         videosHistoryEnabled: -1
 314       }
 315
 316       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
 317     })
 318
 319     it('Should fail with an non authenticated user', async function () {
 320       const fields = {
 321         currentPassword: 'my super password',
 322         password: 'my super password'
 323       }
 324
 325       await makePutBodyRequest({ url: server.url, path: path + 'me', token: 'super token', fields, statusCodeExpected: 401 })
 326     })
 327
 328     it('Should fail with a too long description', async function () {
 329       const fields = {
 330         description: 'super'.repeat(201)
 331       }
 332
 333       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
 334     })
 335
 336     it('Should succeed to change password with the correct params', async function () {
 337       const fields = {
 338         currentPassword: 'my super password',
 339         password: 'my super password',
 340         nsfwPolicy: 'blur',
 341         autoPlayVideo: false,
 342         email: 'super_email@example.com'
 343       }
 344
 345       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
 346     })
 347
 348     it('Should succeed without password change with the correct params', async function () {
 349       const fields = {
 350         nsfwPolicy: 'blur',
 351         autoPlayVideo: false,
 352         email: 'super_email@example.com'
 353       }
 354
 355       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
 356     })
 357   })
 358
 359   describe('When updating my avatar', function () {
 360     it('Should fail without an incorrect input file', async function () {
 361       const fields = {}
 362       const attaches = {
 363         'avatarfile': join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
 364       }
 365       await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
 366     })
 367
 368     it('Should fail with a big file', async function () {
 369       const fields = {}
 370       const attaches = {
 371         'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar-big.png')
 372       }
 373       await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
 374     })
 375
 376     it('Should fail with an unauthenticated user', async function () {
 377       const fields = {}
 378       const attaches = {
 379         'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
 380       }
 381       await makeUploadRequest({
 382         url: server.url,
 383         path: path + '/me/avatar/pick',
 384         fields,
 385         attaches,
 386         statusCodeExpected: 401
 387       })
 388     })
 389
 390     it('Should succeed with the correct params', async function () {
 391       const fields = {}
 392       const attaches = {
 393         'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
 394       }
 395       await makeUploadRequest({
 396         url: server.url,
 397         path: path + '/me/avatar/pick',
 398         token: server.accessToken,
 399         fields,
 400         attaches,
 401         statusCodeExpected: 200
 402       })
 403     })
 404   })
 405
 406   describe('When getting a user', function () {
 407     before(async function () {
 408       const res = await getUsersList(server.url, server.accessToken)
 409
 410       userId = res.body.data[1].id
 411     })
 412
 413     it('Should fail with an non authenticated user', async function () {
 414       await makeGetRequest({ url: server.url, path: path + userId, token: 'super token', statusCodeExpected: 401 })
 415     })
 416
 417     it('Should fail with a non admin user', async function () {
 418       await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 403 })
 419     })
 420
 421     it('Should succeed with the correct params', async function () {
 422       await makeGetRequest({ url: server.url, path: path + userId, token: server.accessToken, statusCodeExpected: 200 })
 423     })
 424   })
 425
 426   describe('When updating a user', function () {
 427
 428     before(async function () {
 429       const res = await getUsersList(server.url, server.accessToken)
 430
 431       userId = res.body.data[1].id
 432       rootId = res.body.data[2].id
 433     })
 434
 435     it('Should fail with an invalid email attribute', async function () {
 436       const fields = {
 437         email: 'blabla'
 438       }
 439
 440       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
 441     })
 442
 443     it('Should fail with an invalid emailVerified attribute', async function () {
 444       const fields = {
 445         emailVerified: 'yes'
 446       }
 447
 448       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
 449     })
 450
 451     it('Should fail with an invalid videoQuota attribute', async function () {
 452       const fields = {
 453         videoQuota: -90
 454       }
 455
 456       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
 457     })
 458
 459     it('Should fail with an invalid user role attribute', async function () {
 460       const fields = {
 461         role: 54878
 462       }
 463
 464       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
 465     })
 466
 467     it('Should fail with a too small password', async function () {
 468       const fields = {
 469         currentPassword: 'my super password',
 470         password: 'bla'
 471       }
 472
 473       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
 474     })
 475
 476     it('Should fail with a too long password', async function () {
 477       const fields = {
 478         currentPassword: 'my super password',
 479         password: 'super'.repeat(61)
 480       }
 481
 482       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
 483     })
 484
 485     it('Should fail with an non authenticated user', async function () {
 486       const fields = {
 487         videoQuota: 42
 488       }
 489
 490       await makePutBodyRequest({ url: server.url, path: path + userId, token: 'super token', fields, statusCodeExpected: 401 })
 491     })
 492
 493     it('Should fail when updating root role', async function () {
 494       const fields = {
 495         role: UserRole.MODERATOR
 496       }
 497
 498       await makePutBodyRequest({ url: server.url, path: path + rootId, token: server.accessToken, fields })
 499     })
 500
 501     it('Should succeed with the correct params', async function () {
 502       const fields = {
 503         email: 'email@example.com',
 504         emailVerified: true,
 505         videoQuota: 42,
 506         role: UserRole.USER
 507       }
 508
 509       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields, statusCodeExpected: 204 })
 510     })
 511   })
 512
 513   describe('When getting my information', function () {
 514     it('Should fail with a non authenticated user', async function () {
 515       await getMyUserInformation(server.url, 'fake_token', 401)
 516     })
 517
 518     it('Should success with the correct parameters', async function () {
 519       await getMyUserInformation(server.url, userAccessToken)
 520     })
 521   })
 522
 523   describe('When getting my video rating', function () {
 524     it('Should fail with a non authenticated user', async function () {
 525       await getMyUserVideoRating(server.url, 'fake_token', videoId, 401)
 526     })
 527
 528     it('Should fail with an incorrect video uuid', async function () {
 529       await getMyUserVideoRating(server.url, server.accessToken, 'blabla', 400)
 530     })
 531
 532     it('Should fail with an unknown video', async function () {
 533       await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
 534     })
 535
 536     it('Should succeed with the correct parameters', async function () {
 537       await getMyUserVideoRating(server.url, server.accessToken, videoId)
 538     })
 539   })
 540
 541   describe('When blocking/unblocking/removing user', function () {
 542     it('Should fail with an incorrect id', async function () {
 543       await removeUser(server.url, 'blabla', server.accessToken, 400)
 544       await blockUser(server.url, 'blabla', server.accessToken, 400)
 545       await unblockUser(server.url, 'blabla', server.accessToken, 400)
 546     })
 547
 548     it('Should fail with the root user', async function () {
 549       await removeUser(server.url, rootId, server.accessToken, 400)
 550       await blockUser(server.url, rootId, server.accessToken, 400)
 551       await unblockUser(server.url, rootId, server.accessToken, 400)
 552     })
 553
 554     it('Should return 404 with a non existing id', async function () {
 555       await removeUser(server.url, 4545454, server.accessToken, 404)
 556       await blockUser(server.url, 4545454, server.accessToken, 404)
 557       await unblockUser(server.url, 4545454, server.accessToken, 404)
 558     })
 559
 560     it('Should fail with a non admin user', async function () {
 561       await removeUser(server.url, userId, userAccessToken, 403)
 562       await blockUser(server.url, userId, userAccessToken, 403)
 563       await unblockUser(server.url, userId, userAccessToken, 403)
 564     })
 565   })
 566
 567   describe('When deleting our account', function () {
 568     it('Should fail with with the root account', async function () {
 569       await deleteMe(server.url, server.accessToken, 400)
 570     })
 571   })
 572
 573   describe('When register a new user', function () {
 574     const registrationPath = path + '/register'
 575     const baseCorrectParams = {
 576       username: 'user3',
 577       email: 'test3@example.com',
 578       password: 'my super password'
 579     }
 580
 581     it('Should fail with a too small username', async function () {
 582       const fields = immutableAssign(baseCorrectParams, { username: '' })
 583
 584       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 585     })
 586
 587     it('Should fail with a too long username', async function () {
 588       const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
 589
 590       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 591     })
 592
 593     it('Should fail with an incorrect username', async function () {
 594       const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
 595
 596       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 597     })
 598
 599     it('Should fail with a missing email', async function () {
 600       const fields = omit(baseCorrectParams, 'email')
 601
 602       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 603     })
 604
 605     it('Should fail with an invalid email', async function () {
 606       const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
 607
 608       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 609     })
 610
 611     it('Should fail with a too small password', async function () {
 612       const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
 613
 614       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 615     })
 616
 617     it('Should fail with a too long password', async function () {
 618       const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
 619
 620       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 621     })
 622
 623     it('Should fail if we register a user with the same username', async function () {
 624       const fields = immutableAssign(baseCorrectParams, { username: 'root' })
 625
 626       await makePostBodyRequest({
 627         url: server.url,
 628         path: registrationPath,
 629         token: server.accessToken,
 630         fields,
 631         statusCodeExpected: 409
 632       })
 633     })
 634
 635     it('Should fail with a "peertube" username', async function () {
 636       const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
 637
 638       await makePostBodyRequest({
 639         url: server.url,
 640         path: registrationPath,
 641         token: server.accessToken,
 642         fields,
 643         statusCodeExpected: 409
 644       })
 645     })
 646
 647     it('Should fail if we register a user with the same email', async function () {
 648       const fields = immutableAssign(baseCorrectParams, { email: 'admin1@example.com' })
 649
 650       await makePostBodyRequest({
 651         url: server.url,
 652         path: registrationPath,
 653         token: server.accessToken,
 654         fields,
 655         statusCodeExpected: 409
 656       })
 657     })
 658
 659     it('Should succeed with the correct params', async function () {
 660       await makePostBodyRequest({
 661         url: server.url,
 662         path: registrationPath,
 663         token: server.accessToken,
 664         fields: baseCorrectParams,
 665         statusCodeExpected: 204
 666       })
 667     })
 668
 669     it('Should fail on a server with registration disabled', async function () {
 670       const fields = {
 671         username: 'user4',
 672         email: 'test4@example.com',
 673         password: 'my super password 4'
 674       }
 675
 676       await makePostBodyRequest({
 677         url: serverWithRegistrationDisabled.url,
 678         path: registrationPath,
 679         token: serverWithRegistrationDisabled.accessToken,
 680         fields,
 681         statusCodeExpected: 403
 682       })
 683     })
 684   })
 685
 686   describe('When registering multiple users on a server with users limit', function () {
 687     it('Should fail when after 3 registrations', async function () {
 688       await registerUser(server.url, 'user42', 'super password', 403)
 689     })
 690   })
 691
 692   describe('When having a video quota', function () {
 693     it('Should fail with a user having too many videos', async function () {
 694       await updateUser({
 695         url: server.url,
 696         userId: rootId,
 697         accessToken: server.accessToken,
 698         videoQuota: 42
 699       })
 700
 701       await uploadVideo(server.url, server.accessToken, {}, 403)
 702     })
 703
 704     it('Should fail with a registered user having too many videos', async function () {
 705       this.timeout(30000)
 706
 707       const user = {
 708         username: 'user3',
 709         password: 'my super password'
 710       }
 711       userAccessToken = await userLogin(server, user)
 712
 713       const videoAttributes = { fixture: 'video_short2.webm' }
 714       await uploadVideo(server.url, userAccessToken, videoAttributes)
 715       await uploadVideo(server.url, userAccessToken, videoAttributes)
 716       await uploadVideo(server.url, userAccessToken, videoAttributes)
 717       await uploadVideo(server.url, userAccessToken, videoAttributes)
 718       await uploadVideo(server.url, userAccessToken, videoAttributes)
 719       await uploadVideo(server.url, userAccessToken, videoAttributes, 403)
 720     })
 721
 722     it('Should fail to import with HTTP/Torrent/magnet', async function () {
 723       this.timeout(120000)
 724
 725       const baseAttributes = {
 726         channelId: 1,
 727         privacy: VideoPrivacy.PUBLIC
 728       }
 729       await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() }))
 730       await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
 731       await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' }))
 732
 733       await waitJobs([ server ])
 734
 735       const res = await getMyVideoImports(server.url, server.accessToken)
 736
 737       expect(res.body.total).to.equal(3)
 738       const videoImports: VideoImport[] = res.body.data
 739       expect(videoImports).to.have.lengthOf(3)
 740
 741       for (const videoImport of videoImports) {
 742         expect(videoImport.state.id).to.equal(VideoImportState.FAILED)
 743         expect(videoImport.error).not.to.be.undefined
 744         expect(videoImport.error).to.contain('user video quota is exceeded')
 745       }
 746     })
 747   })
 748
 749   describe('When having a daily video quota', function () {
 750     it('Should fail with a user having too many videos', async function () {
 751       await updateUser({
 752         url: server.url,
 753         userId: rootId,
 754         accessToken: server.accessToken,
 755         videoQuotaDaily: 42
 756       })
 757
 758       await uploadVideo(server.url, server.accessToken, {}, 403)
 759     })
 760   })
 761
 762   describe('When having an absolute and daily video quota', function () {
 763     it('Should fail if exceeding total quota', async function () {
 764       await updateUser({
 765         url: server.url,
 766         userId: rootId,
 767         accessToken: server.accessToken,
 768         videoQuota: 42,
 769         videoQuotaDaily: 1024 * 1024 * 1024
 770       })
 771
 772       await uploadVideo(server.url, server.accessToken, {}, 403)
 773     })
 774
 775     it('Should fail if exceeding daily quota', async function () {
 776       await updateUser({
 777         url: server.url,
 778         userId: rootId,
 779         accessToken: server.accessToken,
 780         videoQuota: 1024 * 1024 * 1024,
 781         videoQuotaDaily: 42
 782       })
 783
 784       await uploadVideo(server.url, server.accessToken, {}, 403)
 785     })
 786   })
 787
 788   describe('When asking a password reset', function () {
 789     const path = '/api/v1/users/ask-reset-password'
 790
 791     it('Should fail with a missing email', async function () {
 792       const fields = {}
 793
 794       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 795     })
 796
 797     it('Should fail with an invalid email', async function () {
 798       const fields = { email: 'hello' }
 799
 800       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 801     })
 802
 803     it('Should success with the correct params', async function () {
 804       const fields = { email: 'admin@example.com' }
 805
 806       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
 807     })
 808   })
 809
 810   describe('When asking for an account verification email', function () {
 811     const path = '/api/v1/users/ask-send-verify-email'
 812
 813     it('Should fail with a missing email', async function () {
 814       const fields = {}
 815
 816       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 817     })
 818
 819     it('Should fail with an invalid email', async function () {
 820       const fields = { email: 'hello' }
 821
 822       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 823     })
 824
 825     it('Should succeed with the correct params', async function () {
 826       const fields = { email: 'admin@example.com' }
 827
 828       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
 829     })
 830   })
 831
 832   after(async function () {
 833     killallServers([ server, serverWithRegistrationDisabled ])
 834
 835     // Keep the logs if the test failed
 836     if (this['ok']) {
 837       await flushTests()
 838     }
 839   })
 840 })