1 /* tslint:disable:no-unused-expression */
3 import { omit } from 'lodash'
5 import { join } from 'path'
6 import { UserRole, VideoImport, VideoImportState } from '../../../../shared'
26 setAccessTokensToServers,
31 } from '../../../../shared/extra-utils'
33 checkBadCountPagination,
34 checkBadSortPagination,
35 checkBadStartPagination
36 } from '../../../../shared/extra-utils/requests/check-api-params'
37 import { getMagnetURI, getMyVideoImports, getYoutubeVideoUrl, importVideo } from '../../../../shared/extra-utils/videos/video-imports'
38 import { VideoPrivacy } from '../../../../shared/models/videos'
39 import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
40 import { expect } from 'chai'
41 import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
43 describe('Test users API validators', function () {
44 const path = '/api/v1/users/'
48 let server: ServerInfo
49 let serverWithRegistrationDisabled: ServerInfo
50 let userAccessToken = ''
54 password: 'my super password'
57 // ---------------------------------------------------------------
59 before(async function () {
62 server = await flushAndRunServer(1)
63 serverWithRegistrationDisabled = await flushAndRunServer(2)
65 await setAccessTokensToServers([ server ])
67 const videoQuota = 42000000
70 accessToken: server.accessToken,
71 username: user.username,
72 password: user.password,
73 videoQuota: videoQuota
75 userAccessToken = await userLogin(server, user)
78 const res = await getMyUserInformation(server.url, server.accessToken)
79 channelId = res.body.videoChannels[ 0 ].id
83 const res = await uploadVideo(server.url, server.accessToken, {})
84 videoId = res.body.video.id
88 describe('When listing users', function () {
89 it('Should fail with a bad start pagination', async function () {
90 await checkBadStartPagination(server.url, path, server.accessToken)
93 it('Should fail with a bad count pagination', async function () {
94 await checkBadCountPagination(server.url, path, server.accessToken)
97 it('Should fail with an incorrect sort', async function () {
98 await checkBadSortPagination(server.url, path, server.accessToken)
101 it('Should fail with a non authenticated user', async function () {
102 await makeGetRequest({
105 statusCodeExpected: 401
109 it('Should fail with a non admin user', async function () {
110 await makeGetRequest({
113 token: userAccessToken,
114 statusCodeExpected: 403
119 describe('When adding a new user', function () {
120 const baseCorrectParams = {
122 email: 'test@example.com',
123 password: 'my super password',
127 adminFlags: UserAdminFlag.BY_PASS_VIDEO_AUTO_BLACKLIST
130 it('Should fail with a too small username', async function () {
131 const fields = immutableAssign(baseCorrectParams, { username: '' })
133 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
136 it('Should fail with a too long username', async function () {
137 const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
139 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
142 it('Should fail with a not lowercase username', async function () {
143 const fields = immutableAssign(baseCorrectParams, { username: 'Toto' })
145 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
148 it('Should fail with an incorrect username', async function () {
149 const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
151 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
154 it('Should fail with a missing email', async function () {
155 const fields = omit(baseCorrectParams, 'email')
157 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
160 it('Should fail with an invalid email', async function () {
161 const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
163 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
166 it('Should fail with a too small password', async function () {
167 const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
169 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
172 it('Should fail with a too long password', async function () {
173 const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
175 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
178 it('Should fail with invalid admin flags', async function () {
179 const fields = immutableAssign(baseCorrectParams, { adminFlags: 'toto' })
181 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
184 it('Should fail with an non authenticated user', async function () {
185 await makePostBodyRequest({
188 token: 'super token',
189 fields: baseCorrectParams,
190 statusCodeExpected: 401
194 it('Should fail if we add a user with the same username', async function () {
195 const fields = immutableAssign(baseCorrectParams, { username: 'user1' })
197 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 })
200 it('Should fail if we add a user with the same email', async function () {
201 const fields = immutableAssign(baseCorrectParams, { email: 'user1@example.com' })
203 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 })
206 it('Should fail without a videoQuota', async function () {
207 const fields = omit(baseCorrectParams, 'videoQuota')
209 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
212 it('Should fail without a videoQuotaDaily', async function () {
213 const fields = omit(baseCorrectParams, 'videoQuotaDaily')
215 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
218 it('Should fail with an invalid videoQuota', async function () {
219 const fields = immutableAssign(baseCorrectParams, { videoQuota: -5 })
221 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
224 it('Should fail with an invalid videoQuotaDaily', async function () {
225 const fields = immutableAssign(baseCorrectParams, { videoQuotaDaily: -7 })
227 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
230 it('Should fail without a user role', async function () {
231 const fields = omit(baseCorrectParams, 'role')
233 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
236 it('Should fail with an invalid user role', async function () {
237 const fields = immutableAssign(baseCorrectParams, { role: 88989 })
239 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
242 it('Should fail with a "peertube" username', async function () {
243 const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
245 await makePostBodyRequest({
248 token: server.accessToken,
250 statusCodeExpected: 409
254 it('Should succeed with the correct params', async function () {
255 await makePostBodyRequest({
258 token: server.accessToken,
259 fields: baseCorrectParams,
260 statusCodeExpected: 200
264 it('Should fail with a non admin user', async function () {
267 password: 'my super password'
269 userAccessToken = await userLogin(server, user)
273 email: 'test@example.com',
274 password: 'my super password',
277 await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: 403 })
281 describe('When updating my account', function () {
282 it('Should fail with an invalid email attribute', async function () {
287 await makePutBodyRequest({ url: server.url, path: path + 'me', token: server.accessToken, fields })
290 it('Should fail with a too small password', async function () {
292 currentPassword: 'my super password',
296 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
299 it('Should fail with a too long password', async function () {
301 currentPassword: 'my super password',
302 password: 'super'.repeat(61)
305 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
308 it('Should fail without the current password', async function () {
310 currentPassword: 'my super password',
311 password: 'super'.repeat(61)
314 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
317 it('Should fail with an invalid current password', async function () {
319 currentPassword: 'my super password fail',
320 password: 'super'.repeat(61)
323 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 401 })
326 it('Should fail with an invalid NSFW policy attribute', async function () {
331 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
334 it('Should fail with an invalid autoPlayVideo attribute', async function () {
339 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
342 it('Should fail with an invalid videosHistoryEnabled attribute', async function () {
344 videosHistoryEnabled: -1
347 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
350 it('Should fail with an non authenticated user', async function () {
352 currentPassword: 'my super password',
353 password: 'my super password'
356 await makePutBodyRequest({ url: server.url, path: path + 'me', token: 'super token', fields, statusCodeExpected: 401 })
359 it('Should fail with a too long description', async function () {
361 description: 'super'.repeat(201)
364 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
367 it('Should succeed to change password with the correct params', async function () {
369 currentPassword: 'my super password',
370 password: 'my super password',
372 autoPlayVideo: false,
373 email: 'super_email@example.com'
376 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
379 it('Should succeed without password change with the correct params', async function () {
382 autoPlayVideo: false,
383 email: 'super_email@example.com'
386 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
390 describe('When updating my avatar', function () {
391 it('Should fail without an incorrect input file', async function () {
394 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
396 await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
399 it('Should fail with a big file', async function () {
402 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar-big.png')
404 await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
407 it('Should fail with an unauthenticated user', async function () {
410 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
412 await makeUploadRequest({
414 path: path + '/me/avatar/pick',
417 statusCodeExpected: 401
421 it('Should succeed with the correct params', async function () {
424 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
426 await makeUploadRequest({
428 path: path + '/me/avatar/pick',
429 token: server.accessToken,
432 statusCodeExpected: 200
437 describe('When getting a user', function () {
438 before(async function () {
439 const res = await getUsersList(server.url, server.accessToken)
441 userId = res.body.data[1].id
444 it('Should fail with an non authenticated user', async function () {
445 await makeGetRequest({ url: server.url, path: path + userId, token: 'super token', statusCodeExpected: 401 })
448 it('Should fail with a non admin user', async function () {
449 await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 403 })
452 it('Should succeed with the correct params', async function () {
453 await makeGetRequest({ url: server.url, path: path + userId, token: server.accessToken, statusCodeExpected: 200 })
457 describe('When updating a user', function () {
459 before(async function () {
460 const res = await getUsersList(server.url, server.accessToken)
462 userId = res.body.data[1].id
463 rootId = res.body.data[2].id
466 it('Should fail with an invalid email attribute', async function () {
471 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
474 it('Should fail with an invalid emailVerified attribute', async function () {
479 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
482 it('Should fail with an invalid videoQuota attribute', async function () {
487 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
490 it('Should fail with an invalid user role attribute', async function () {
495 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
498 it('Should fail with a too small password', async function () {
500 currentPassword: 'my super password',
504 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
507 it('Should fail with a too long password', async function () {
509 currentPassword: 'my super password',
510 password: 'super'.repeat(61)
513 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
516 it('Should fail with an non authenticated user', async function () {
521 await makePutBodyRequest({ url: server.url, path: path + userId, token: 'super token', fields, statusCodeExpected: 401 })
524 it('Should fail when updating root role', async function () {
526 role: UserRole.MODERATOR
529 await makePutBodyRequest({ url: server.url, path: path + rootId, token: server.accessToken, fields })
532 it('Should fail with invalid admin flags', async function () {
533 const fields = { adminFlags: 'toto' }
535 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
538 it('Should succeed with the correct params', async function () {
540 email: 'email@example.com',
546 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields, statusCodeExpected: 204 })
550 describe('When getting my information', function () {
551 it('Should fail with a non authenticated user', async function () {
552 await getMyUserInformation(server.url, 'fake_token', 401)
555 it('Should success with the correct parameters', async function () {
556 await getMyUserInformation(server.url, userAccessToken)
560 describe('When getting my video rating', function () {
561 it('Should fail with a non authenticated user', async function () {
562 await getMyUserVideoRating(server.url, 'fake_token', videoId, 401)
565 it('Should fail with an incorrect video uuid', async function () {
566 await getMyUserVideoRating(server.url, server.accessToken, 'blabla', 400)
569 it('Should fail with an unknown video', async function () {
570 await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
573 it('Should succeed with the correct parameters', async function () {
574 await getMyUserVideoRating(server.url, server.accessToken, videoId)
578 describe('When retrieving my global ratings', function () {
579 const path = '/api/v1/accounts/user1/ratings'
581 it('Should fail with a bad start pagination', async function () {
582 await checkBadStartPagination(server.url, path, userAccessToken)
585 it('Should fail with a bad count pagination', async function () {
586 await checkBadCountPagination(server.url, path, userAccessToken)
589 it('Should fail with an incorrect sort', async function () {
590 await checkBadSortPagination(server.url, path, userAccessToken)
593 it('Should fail with a unauthenticated user', async function () {
594 await makeGetRequest({ url: server.url, path, statusCodeExpected: 401 })
597 it('Should fail with a another user', async function () {
598 await makeGetRequest({ url: server.url, path, token: server.accessToken, statusCodeExpected: 403 })
601 it('Should fail with a bad type', async function () {
602 await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { rating: 'toto ' }, statusCodeExpected: 400 })
605 it('Should succeed with the correct params', async function () {
606 await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 200 })
610 describe('When blocking/unblocking/removing user', function () {
611 it('Should fail with an incorrect id', async function () {
612 await removeUser(server.url, 'blabla', server.accessToken, 400)
613 await blockUser(server.url, 'blabla', server.accessToken, 400)
614 await unblockUser(server.url, 'blabla', server.accessToken, 400)
617 it('Should fail with the root user', async function () {
618 await removeUser(server.url, rootId, server.accessToken, 400)
619 await blockUser(server.url, rootId, server.accessToken, 400)
620 await unblockUser(server.url, rootId, server.accessToken, 400)
623 it('Should return 404 with a non existing id', async function () {
624 await removeUser(server.url, 4545454, server.accessToken, 404)
625 await blockUser(server.url, 4545454, server.accessToken, 404)
626 await unblockUser(server.url, 4545454, server.accessToken, 404)
629 it('Should fail with a non admin user', async function () {
630 await removeUser(server.url, userId, userAccessToken, 403)
631 await blockUser(server.url, userId, userAccessToken, 403)
632 await unblockUser(server.url, userId, userAccessToken, 403)
636 describe('When deleting our account', function () {
637 it('Should fail with with the root account', async function () {
638 await deleteMe(server.url, server.accessToken, 400)
642 describe('When registering a new user', function () {
643 const registrationPath = path + '/register'
644 const baseCorrectParams = {
646 displayName: 'super user',
647 email: 'test3@example.com',
648 password: 'my super password'
651 it('Should fail with a too small username', async function () {
652 const fields = immutableAssign(baseCorrectParams, { username: '' })
654 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
657 it('Should fail with a too long username', async function () {
658 const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
660 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
663 it('Should fail with an incorrect username', async function () {
664 const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
666 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
669 it('Should fail with a missing email', async function () {
670 const fields = omit(baseCorrectParams, 'email')
672 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
675 it('Should fail with an invalid email', async function () {
676 const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
678 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
681 it('Should fail with a too small password', async function () {
682 const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
684 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
687 it('Should fail with a too long password', async function () {
688 const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
690 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
693 it('Should fail if we register a user with the same username', async function () {
694 const fields = immutableAssign(baseCorrectParams, { username: 'root' })
696 await makePostBodyRequest({
698 path: registrationPath,
699 token: server.accessToken,
701 statusCodeExpected: 409
705 it('Should fail with a "peertube" username', async function () {
706 const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
708 await makePostBodyRequest({
710 path: registrationPath,
711 token: server.accessToken,
713 statusCodeExpected: 409
717 it('Should fail if we register a user with the same email', async function () {
718 const fields = immutableAssign(baseCorrectParams, { email: 'admin' + server.internalServerNumber + '@example.com' })
720 await makePostBodyRequest({
722 path: registrationPath,
723 token: server.accessToken,
725 statusCodeExpected: 409
729 it('Should fail with a bad display name', async function () {
730 const fields = immutableAssign(baseCorrectParams, { displayName: 'a'.repeat(150) })
732 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
735 it('Should fail with a bad channel name', async function () {
736 const fields = immutableAssign(baseCorrectParams, { channel: { name: '[]azf', displayName: 'toto' } })
738 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
741 it('Should fail with a bad channel display name', async function () {
742 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'toto', displayName: '' } })
744 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
747 it('Should fail with a channel name that is the same than user username', async function () {
748 const source = { username: 'super_user', channel: { name: 'super_user', displayName: 'display name' } }
749 const fields = immutableAssign(baseCorrectParams, source)
751 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
754 it('Should fail with an existing channel', async function () {
755 const videoChannelAttributesArg = { name: 'existing_channel', displayName: 'hello', description: 'super description' }
756 await addVideoChannel(server.url, server.accessToken, videoChannelAttributesArg)
758 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'existing_channel', displayName: 'toto' } })
760 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields, statusCodeExpected: 409 })
763 it('Should succeed with the correct params', async function () {
764 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'super_channel', displayName: 'toto' } })
766 await makePostBodyRequest({
768 path: registrationPath,
769 token: server.accessToken,
771 statusCodeExpected: 204
775 it('Should fail on a server with registration disabled', async function () {
778 email: 'test4@example.com',
779 password: 'my super password 4'
782 await makePostBodyRequest({
783 url: serverWithRegistrationDisabled.url,
784 path: registrationPath,
785 token: serverWithRegistrationDisabled.accessToken,
787 statusCodeExpected: 403
792 describe('When registering multiple users on a server with users limit', function () {
793 it('Should fail when after 3 registrations', async function () {
794 await registerUser(server.url, 'user42', 'super password', 403)
798 describe('When having a video quota', function () {
799 it('Should fail with a user having too many videos', async function () {
803 accessToken: server.accessToken,
807 await uploadVideo(server.url, server.accessToken, {}, 403)
810 it('Should fail with a registered user having too many videos', async function () {
815 password: 'my super password'
817 userAccessToken = await userLogin(server, user)
819 const videoAttributes = { fixture: 'video_short2.webm' }
820 await uploadVideo(server.url, userAccessToken, videoAttributes)
821 await uploadVideo(server.url, userAccessToken, videoAttributes)
822 await uploadVideo(server.url, userAccessToken, videoAttributes)
823 await uploadVideo(server.url, userAccessToken, videoAttributes)
824 await uploadVideo(server.url, userAccessToken, videoAttributes)
825 await uploadVideo(server.url, userAccessToken, videoAttributes, 403)
828 it('Should fail to import with HTTP/Torrent/magnet', async function () {
831 const baseAttributes = {
833 privacy: VideoPrivacy.PUBLIC
835 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() }))
836 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
837 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' }))
839 await waitJobs([ server ])
841 const res = await getMyVideoImports(server.url, server.accessToken)
843 expect(res.body.total).to.equal(3)
844 const videoImports: VideoImport[] = res.body.data
845 expect(videoImports).to.have.lengthOf(3)
847 for (const videoImport of videoImports) {
848 expect(videoImport.state.id).to.equal(VideoImportState.FAILED)
849 expect(videoImport.error).not.to.be.undefined
850 expect(videoImport.error).to.contain('user video quota is exceeded')
855 describe('When having a daily video quota', function () {
856 it('Should fail with a user having too many videos', async function () {
860 accessToken: server.accessToken,
864 await uploadVideo(server.url, server.accessToken, {}, 403)
868 describe('When having an absolute and daily video quota', function () {
869 it('Should fail if exceeding total quota', async function () {
873 accessToken: server.accessToken,
875 videoQuotaDaily: 1024 * 1024 * 1024
878 await uploadVideo(server.url, server.accessToken, {}, 403)
881 it('Should fail if exceeding daily quota', async function () {
885 accessToken: server.accessToken,
886 videoQuota: 1024 * 1024 * 1024,
890 await uploadVideo(server.url, server.accessToken, {}, 403)
894 describe('When asking a password reset', function () {
895 const path = '/api/v1/users/ask-reset-password'
897 it('Should fail with a missing email', async function () {
900 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
903 it('Should fail with an invalid email', async function () {
904 const fields = { email: 'hello' }
906 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
909 it('Should success with the correct params', async function () {
910 const fields = { email: 'admin@example.com' }
912 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
916 describe('When asking for an account verification email', function () {
917 const path = '/api/v1/users/ask-send-verify-email'
919 it('Should fail with a missing email', async function () {
922 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
925 it('Should fail with an invalid email', async function () {
926 const fields = { email: 'hello' }
928 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
931 it('Should succeed with the correct params', async function () {
932 const fields = { email: 'admin@example.com' }
934 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
938 after(async function () {
939 await cleanupTests([ server, serverWithRegistrationDisabled ])