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 () {
385 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
389 describe('When updating my avatar', function () {
390 it('Should fail without an incorrect input file', async function () {
393 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
395 await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
398 it('Should fail with a big file', async function () {
401 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar-big.png')
403 await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
406 it('Should fail with an unauthenticated user', async function () {
409 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
411 await makeUploadRequest({
413 path: path + '/me/avatar/pick',
416 statusCodeExpected: 401
420 it('Should succeed with the correct params', async function () {
423 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
425 await makeUploadRequest({
427 path: path + '/me/avatar/pick',
428 token: server.accessToken,
431 statusCodeExpected: 200
436 describe('When getting a user', function () {
437 before(async function () {
438 const res = await getUsersList(server.url, server.accessToken)
440 userId = res.body.data[1].id
443 it('Should fail with an non authenticated user', async function () {
444 await makeGetRequest({ url: server.url, path: path + userId, token: 'super token', statusCodeExpected: 401 })
447 it('Should fail with a non admin user', async function () {
448 await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 403 })
451 it('Should succeed with the correct params', async function () {
452 await makeGetRequest({ url: server.url, path: path + userId, token: server.accessToken, statusCodeExpected: 200 })
456 describe('When updating a user', function () {
458 before(async function () {
459 const res = await getUsersList(server.url, server.accessToken)
461 userId = res.body.data[1].id
462 rootId = res.body.data[2].id
465 it('Should fail with an invalid email attribute', async function () {
470 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
473 it('Should fail with an invalid emailVerified attribute', async function () {
478 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
481 it('Should fail with an invalid videoQuota attribute', async function () {
486 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
489 it('Should fail with an invalid user role attribute', async function () {
494 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
497 it('Should fail with a too small password', async function () {
499 currentPassword: 'my super password',
503 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
506 it('Should fail with a too long password', async function () {
508 currentPassword: 'my super password',
509 password: 'super'.repeat(61)
512 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
515 it('Should fail with an non authenticated user', async function () {
520 await makePutBodyRequest({ url: server.url, path: path + userId, token: 'super token', fields, statusCodeExpected: 401 })
523 it('Should fail when updating root role', async function () {
525 role: UserRole.MODERATOR
528 await makePutBodyRequest({ url: server.url, path: path + rootId, token: server.accessToken, fields })
531 it('Should fail with invalid admin flags', async function () {
532 const fields = { adminFlags: 'toto' }
534 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
537 it('Should succeed with the correct params', async function () {
539 email: 'email@example.com',
545 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields, statusCodeExpected: 204 })
549 describe('When getting my information', function () {
550 it('Should fail with a non authenticated user', async function () {
551 await getMyUserInformation(server.url, 'fake_token', 401)
554 it('Should success with the correct parameters', async function () {
555 await getMyUserInformation(server.url, userAccessToken)
559 describe('When getting my video rating', function () {
560 it('Should fail with a non authenticated user', async function () {
561 await getMyUserVideoRating(server.url, 'fake_token', videoId, 401)
564 it('Should fail with an incorrect video uuid', async function () {
565 await getMyUserVideoRating(server.url, server.accessToken, 'blabla', 400)
568 it('Should fail with an unknown video', async function () {
569 await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
572 it('Should succeed with the correct parameters', async function () {
573 await getMyUserVideoRating(server.url, server.accessToken, videoId)
577 describe('When retrieving my global ratings', function () {
578 const path = '/api/v1/accounts/user1/ratings'
580 it('Should fail with a bad start pagination', async function () {
581 await checkBadStartPagination(server.url, path, userAccessToken)
584 it('Should fail with a bad count pagination', async function () {
585 await checkBadCountPagination(server.url, path, userAccessToken)
588 it('Should fail with an incorrect sort', async function () {
589 await checkBadSortPagination(server.url, path, userAccessToken)
592 it('Should fail with a unauthenticated user', async function () {
593 await makeGetRequest({ url: server.url, path, statusCodeExpected: 401 })
596 it('Should fail with a another user', async function () {
597 await makeGetRequest({ url: server.url, path, token: server.accessToken, statusCodeExpected: 403 })
600 it('Should fail with a bad type', async function () {
601 await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { rating: 'toto ' }, statusCodeExpected: 400 })
604 it('Should succeed with the correct params', async function () {
605 await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 200 })
609 describe('When blocking/unblocking/removing user', function () {
610 it('Should fail with an incorrect id', async function () {
611 await removeUser(server.url, 'blabla', server.accessToken, 400)
612 await blockUser(server.url, 'blabla', server.accessToken, 400)
613 await unblockUser(server.url, 'blabla', server.accessToken, 400)
616 it('Should fail with the root user', async function () {
617 await removeUser(server.url, rootId, server.accessToken, 400)
618 await blockUser(server.url, rootId, server.accessToken, 400)
619 await unblockUser(server.url, rootId, server.accessToken, 400)
622 it('Should return 404 with a non existing id', async function () {
623 await removeUser(server.url, 4545454, server.accessToken, 404)
624 await blockUser(server.url, 4545454, server.accessToken, 404)
625 await unblockUser(server.url, 4545454, server.accessToken, 404)
628 it('Should fail with a non admin user', async function () {
629 await removeUser(server.url, userId, userAccessToken, 403)
630 await blockUser(server.url, userId, userAccessToken, 403)
631 await unblockUser(server.url, userId, userAccessToken, 403)
635 describe('When deleting our account', function () {
636 it('Should fail with with the root account', async function () {
637 await deleteMe(server.url, server.accessToken, 400)
641 describe('When registering a new user', function () {
642 const registrationPath = path + '/register'
643 const baseCorrectParams = {
645 displayName: 'super user',
646 email: 'test3@example.com',
647 password: 'my super password'
650 it('Should fail with a too small username', async function () {
651 const fields = immutableAssign(baseCorrectParams, { username: '' })
653 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
656 it('Should fail with a too long username', async function () {
657 const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
659 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
662 it('Should fail with an incorrect username', async function () {
663 const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
665 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
668 it('Should fail with a missing email', async function () {
669 const fields = omit(baseCorrectParams, 'email')
671 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
674 it('Should fail with an invalid email', async function () {
675 const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
677 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
680 it('Should fail with a too small password', async function () {
681 const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
683 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
686 it('Should fail with a too long password', async function () {
687 const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
689 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
692 it('Should fail if we register a user with the same username', async function () {
693 const fields = immutableAssign(baseCorrectParams, { username: 'root' })
695 await makePostBodyRequest({
697 path: registrationPath,
698 token: server.accessToken,
700 statusCodeExpected: 409
704 it('Should fail with a "peertube" username', async function () {
705 const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
707 await makePostBodyRequest({
709 path: registrationPath,
710 token: server.accessToken,
712 statusCodeExpected: 409
716 it('Should fail if we register a user with the same email', async function () {
717 const fields = immutableAssign(baseCorrectParams, { email: 'admin' + server.internalServerNumber + '@example.com' })
719 await makePostBodyRequest({
721 path: registrationPath,
722 token: server.accessToken,
724 statusCodeExpected: 409
728 it('Should fail with a bad display name', async function () {
729 const fields = immutableAssign(baseCorrectParams, { displayName: 'a'.repeat(150) })
731 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
734 it('Should fail with a bad channel name', async function () {
735 const fields = immutableAssign(baseCorrectParams, { channel: { name: '[]azf', displayName: 'toto' } })
737 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
740 it('Should fail with a bad channel display name', async function () {
741 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'toto', displayName: '' } })
743 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
746 it('Should fail with a channel name that is the same than user username', async function () {
747 const source = { username: 'super_user', channel: { name: 'super_user', displayName: 'display name' } }
748 const fields = immutableAssign(baseCorrectParams, source)
750 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
753 it('Should fail with an existing channel', async function () {
754 const videoChannelAttributesArg = { name: 'existing_channel', displayName: 'hello', description: 'super description' }
755 await addVideoChannel(server.url, server.accessToken, videoChannelAttributesArg)
757 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'existing_channel', displayName: 'toto' } })
759 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields, statusCodeExpected: 409 })
762 it('Should succeed with the correct params', async function () {
763 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'super_channel', displayName: 'toto' } })
765 await makePostBodyRequest({
767 path: registrationPath,
768 token: server.accessToken,
770 statusCodeExpected: 204
774 it('Should fail on a server with registration disabled', async function () {
777 email: 'test4@example.com',
778 password: 'my super password 4'
781 await makePostBodyRequest({
782 url: serverWithRegistrationDisabled.url,
783 path: registrationPath,
784 token: serverWithRegistrationDisabled.accessToken,
786 statusCodeExpected: 403
791 describe('When registering multiple users on a server with users limit', function () {
792 it('Should fail when after 3 registrations', async function () {
793 await registerUser(server.url, 'user42', 'super password', 403)
797 describe('When having a video quota', function () {
798 it('Should fail with a user having too many videos', async function () {
802 accessToken: server.accessToken,
806 await uploadVideo(server.url, server.accessToken, {}, 403)
809 it('Should fail with a registered user having too many videos', async function () {
814 password: 'my super password'
816 userAccessToken = await userLogin(server, user)
818 const videoAttributes = { fixture: 'video_short2.webm' }
819 await uploadVideo(server.url, userAccessToken, videoAttributes)
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, 403)
827 it('Should fail to import with HTTP/Torrent/magnet', async function () {
830 const baseAttributes = {
832 privacy: VideoPrivacy.PUBLIC
834 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() }))
835 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
836 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' }))
838 await waitJobs([ server ])
840 const res = await getMyVideoImports(server.url, server.accessToken)
842 expect(res.body.total).to.equal(3)
843 const videoImports: VideoImport[] = res.body.data
844 expect(videoImports).to.have.lengthOf(3)
846 for (const videoImport of videoImports) {
847 expect(videoImport.state.id).to.equal(VideoImportState.FAILED)
848 expect(videoImport.error).not.to.be.undefined
849 expect(videoImport.error).to.contain('user video quota is exceeded')
854 describe('When having a daily video quota', function () {
855 it('Should fail with a user having too many videos', async function () {
859 accessToken: server.accessToken,
863 await uploadVideo(server.url, server.accessToken, {}, 403)
867 describe('When having an absolute and daily video quota', function () {
868 it('Should fail if exceeding total quota', async function () {
872 accessToken: server.accessToken,
874 videoQuotaDaily: 1024 * 1024 * 1024
877 await uploadVideo(server.url, server.accessToken, {}, 403)
880 it('Should fail if exceeding daily quota', async function () {
884 accessToken: server.accessToken,
885 videoQuota: 1024 * 1024 * 1024,
889 await uploadVideo(server.url, server.accessToken, {}, 403)
893 describe('When asking a password reset', function () {
894 const path = '/api/v1/users/ask-reset-password'
896 it('Should fail with a missing email', async function () {
899 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
902 it('Should fail with an invalid email', async function () {
903 const fields = { email: 'hello' }
905 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
908 it('Should success with the correct params', async function () {
909 const fields = { email: 'admin@example.com' }
911 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
915 describe('When asking for an account verification email', function () {
916 const path = '/api/v1/users/ask-send-verify-email'
918 it('Should fail with a missing email', async function () {
921 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
924 it('Should fail with an invalid email', async function () {
925 const fields = { email: 'hello' }
927 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
930 it('Should succeed with the correct params', async function () {
931 const fields = { email: 'admin@example.com' }
933 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
937 after(async function () {
938 await cleanupTests([ server, serverWithRegistrationDisabled ])