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 an non authenticated user', async function () {
 468       const fields = {
 469         videoQuota: 42
 470       }
 471
 472       await makePutBodyRequest({ url: server.url, path: path + userId, token: 'super token', fields, statusCodeExpected: 401 })
 473     })
 474
 475     it('Should fail when updating root role', async function () {
 476       const fields = {
 477         role: UserRole.MODERATOR
 478       }
 479
 480       await makePutBodyRequest({ url: server.url, path: path + rootId, token: server.accessToken, fields })
 481     })
 482
 483     it('Should succeed with the correct params', async function () {
 484       const fields = {
 485         email: 'email@example.com',
 486         emailVerified: true,
 487         videoQuota: 42,
 488         role: UserRole.MODERATOR
 489       }
 490
 491       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields, statusCodeExpected: 204 })
 492       userAccessToken = await userLogin(server, user)
 493     })
 494   })
 495
 496   describe('When getting my information', function () {
 497     it('Should fail with a non authenticated user', async function () {
 498       await getMyUserInformation(server.url, 'fake_token', 401)
 499     })
 500
 501     it('Should success with the correct parameters', async function () {
 502       await getMyUserInformation(server.url, userAccessToken)
 503     })
 504   })
 505
 506   describe('When getting my video rating', function () {
 507     it('Should fail with a non authenticated user', async function () {
 508       await getMyUserVideoRating(server.url, 'fake_token', videoId, 401)
 509     })
 510
 511     it('Should fail with an incorrect video uuid', async function () {
 512       await getMyUserVideoRating(server.url, server.accessToken, 'blabla', 400)
 513     })
 514
 515     it('Should fail with an unknown video', async function () {
 516       await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
 517     })
 518
 519     it('Should succeed with the correct parameters', async function () {
 520       await getMyUserVideoRating(server.url, server.accessToken, videoId)
 521     })
 522   })
 523
 524   describe('When blocking/unblocking/removing user', function () {
 525     it('Should fail with an incorrect id', async function () {
 526       await removeUser(server.url, 'blabla', server.accessToken, 400)
 527       await blockUser(server.url, 'blabla', server.accessToken, 400)
 528       await unblockUser(server.url, 'blabla', server.accessToken, 400)
 529     })
 530
 531     it('Should fail with the root user', async function () {
 532       await removeUser(server.url, rootId, server.accessToken, 400)
 533       await blockUser(server.url, rootId, server.accessToken, 400)
 534       await unblockUser(server.url, rootId, server.accessToken, 400)
 535     })
 536
 537     it('Should return 404 with a non existing id', async function () {
 538       await removeUser(server.url, 4545454, server.accessToken, 404)
 539       await blockUser(server.url, 4545454, server.accessToken, 404)
 540       await unblockUser(server.url, 4545454, server.accessToken, 404)
 541     })
 542
 543     it('Should fail with a non admin user', async function () {
 544       await removeUser(server.url, userId, userAccessToken, 403)
 545       await blockUser(server.url, userId, userAccessToken, 403)
 546       await unblockUser(server.url, userId, userAccessToken, 403)
 547     })
 548   })
 549
 550   describe('When deleting our account', function () {
 551     it('Should fail with with the root account', async function () {
 552       await deleteMe(server.url, server.accessToken, 400)
 553     })
 554   })
 555
 556   describe('When register a new user', function () {
 557     const registrationPath = path + '/register'
 558     const baseCorrectParams = {
 559       username: 'user3',
 560       email: 'test3@example.com',
 561       password: 'my super password'
 562     }
 563
 564     it('Should fail with a too small username', async function () {
 565       const fields = immutableAssign(baseCorrectParams, { username: '' })
 566
 567       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 568     })
 569
 570     it('Should fail with a too long username', async function () {
 571       const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
 572
 573       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 574     })
 575
 576     it('Should fail with an incorrect username', async function () {
 577       const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
 578
 579       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 580     })
 581
 582     it('Should fail with a missing email', async function () {
 583       const fields = omit(baseCorrectParams, 'email')
 584
 585       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 586     })
 587
 588     it('Should fail with an invalid email', async function () {
 589       const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
 590
 591       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 592     })
 593
 594     it('Should fail with a too small password', async function () {
 595       const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
 596
 597       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 598     })
 599
 600     it('Should fail with a too long password', async function () {
 601       const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
 602
 603       await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
 604     })
 605
 606     it('Should fail if we register a user with the same username', async function () {
 607       const fields = immutableAssign(baseCorrectParams, { username: 'root' })
 608
 609       await makePostBodyRequest({
 610         url: server.url,
 611         path: registrationPath,
 612         token: server.accessToken,
 613         fields,
 614         statusCodeExpected: 409
 615       })
 616     })
 617
 618     it('Should fail with a "peertube" username', async function () {
 619       const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
 620
 621       await makePostBodyRequest({
 622         url: server.url,
 623         path: registrationPath,
 624         token: server.accessToken,
 625         fields,
 626         statusCodeExpected: 409
 627       })
 628     })
 629
 630     it('Should fail if we register a user with the same email', async function () {
 631       const fields = immutableAssign(baseCorrectParams, { email: 'admin1@example.com' })
 632
 633       await makePostBodyRequest({
 634         url: server.url,
 635         path: registrationPath,
 636         token: server.accessToken,
 637         fields,
 638         statusCodeExpected: 409
 639       })
 640     })
 641
 642     it('Should succeed with the correct params', async function () {
 643       await makePostBodyRequest({
 644         url: server.url,
 645         path: registrationPath,
 646         token: server.accessToken,
 647         fields: baseCorrectParams,
 648         statusCodeExpected: 204
 649       })
 650     })
 651
 652     it('Should fail on a server with registration disabled', async function () {
 653       const fields = {
 654         username: 'user4',
 655         email: 'test4@example.com',
 656         password: 'my super password 4'
 657       }
 658
 659       await makePostBodyRequest({
 660         url: serverWithRegistrationDisabled.url,
 661         path: registrationPath,
 662         token: serverWithRegistrationDisabled.accessToken,
 663         fields,
 664         statusCodeExpected: 403
 665       })
 666     })
 667   })
 668
 669   describe('When registering multiple users on a server with users limit', function () {
 670     it('Should fail when after 3 registrations', async function () {
 671       await registerUser(server.url, 'user42', 'super password', 403)
 672     })
 673   })
 674
 675   describe('When having a video quota', function () {
 676     it('Should fail with a user having too many videos', async function () {
 677       await updateUser({
 678         url: server.url,
 679         userId: rootId,
 680         accessToken: server.accessToken,
 681         videoQuota: 42
 682       })
 683
 684       await uploadVideo(server.url, server.accessToken, {}, 403)
 685     })
 686
 687     it('Should fail with a registered user having too many videos', async function () {
 688       this.timeout(30000)
 689
 690       const user = {
 691         username: 'user3',
 692         password: 'my super password'
 693       }
 694       userAccessToken = await userLogin(server, user)
 695
 696       const videoAttributes = { fixture: 'video_short2.webm' }
 697       await uploadVideo(server.url, userAccessToken, videoAttributes)
 698       await uploadVideo(server.url, userAccessToken, videoAttributes)
 699       await uploadVideo(server.url, userAccessToken, videoAttributes)
 700       await uploadVideo(server.url, userAccessToken, videoAttributes)
 701       await uploadVideo(server.url, userAccessToken, videoAttributes)
 702       await uploadVideo(server.url, userAccessToken, videoAttributes, 403)
 703     })
 704
 705     it('Should fail to import with HTTP/Torrent/magnet', async function () {
 706       this.timeout(120000)
 707
 708       const baseAttributes = {
 709         channelId: 1,
 710         privacy: VideoPrivacy.PUBLIC
 711       }
 712       await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() }))
 713       await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
 714       await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' }))
 715
 716       await waitJobs([ server ])
 717
 718       const res = await getMyVideoImports(server.url, server.accessToken)
 719
 720       expect(res.body.total).to.equal(3)
 721       const videoImports: VideoImport[] = res.body.data
 722       expect(videoImports).to.have.lengthOf(3)
 723
 724       for (const videoImport of videoImports) {
 725         expect(videoImport.state.id).to.equal(VideoImportState.FAILED)
 726         expect(videoImport.error).not.to.be.undefined
 727         expect(videoImport.error).to.contain('user video quota is exceeded')
 728       }
 729     })
 730   })
 731
 732   describe('When having a daily video quota', function () {
 733     it('Should fail with a user having too many videos', async function () {
 734       await updateUser({
 735         url: server.url,
 736         userId: rootId,
 737         accessToken: server.accessToken,
 738         videoQuotaDaily: 42
 739       })
 740
 741       await uploadVideo(server.url, server.accessToken, {}, 403)
 742     })
 743   })
 744
 745   describe('When having an absolute and daily video quota', function () {
 746     it('Should fail if exceeding total quota', async function () {
 747       await updateUser({
 748         url: server.url,
 749         userId: rootId,
 750         accessToken: server.accessToken,
 751         videoQuota: 42,
 752         videoQuotaDaily: 1024 * 1024 * 1024
 753       })
 754
 755       await uploadVideo(server.url, server.accessToken, {}, 403)
 756     })
 757
 758     it('Should fail if exceeding daily quota', async function () {
 759       await updateUser({
 760         url: server.url,
 761         userId: rootId,
 762         accessToken: server.accessToken,
 763         videoQuota: 1024 * 1024 * 1024,
 764         videoQuotaDaily: 42
 765       })
 766
 767       await uploadVideo(server.url, server.accessToken, {}, 403)
 768     })
 769   })
 770
 771   describe('When asking a password reset', function () {
 772     const path = '/api/v1/users/ask-reset-password'
 773
 774     it('Should fail with a missing email', async function () {
 775       const fields = {}
 776
 777       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 778     })
 779
 780     it('Should fail with an invalid email', async function () {
 781       const fields = { email: 'hello' }
 782
 783       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 784     })
 785
 786     it('Should success with the correct params', async function () {
 787       const fields = { email: 'admin@example.com' }
 788
 789       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
 790     })
 791   })
 792
 793   describe('When asking for an account verification email', function () {
 794     const path = '/api/v1/users/ask-send-verify-email'
 795
 796     it('Should fail with a missing email', async function () {
 797       const fields = {}
 798
 799       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 800     })
 801
 802     it('Should fail with an invalid email', async function () {
 803       const fields = { email: 'hello' }
 804
 805       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 806     })
 807
 808     it('Should succeed with the correct params', async function () {
 809       const fields = { email: 'admin@example.com' }
 810
 811       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
 812     })
 813   })
 814
 815   after(async function () {
 816     killallServers([ server, serverWithRegistrationDisabled ])
 817
 818     // Keep the logs if the test failed
 819     if (this['ok']) {
 820       await flushTests()
 821     }
 822   })
 823 })