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 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 channel name', async function () {
729 const fields = immutableAssign(baseCorrectParams, { channel: { name: '[]azf', displayName: 'toto' } })
731 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
734 it('Should fail with a bad channel display name', async function () {
735 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'toto', displayName: '' } })
737 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
740 it('Should fail with a channel name that is the same than user username', async function () {
741 const source = { username: 'super_user', channel: { name: 'super_user', displayName: 'display name' } }
742 const fields = immutableAssign(baseCorrectParams, source)
744 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
747 it('Should fail with an existing channel', async function () {
748 const videoChannelAttributesArg = { name: 'existing_channel', displayName: 'hello', description: 'super description' }
749 await addVideoChannel(server.url, server.accessToken, videoChannelAttributesArg)
751 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'existing_channel', displayName: 'toto' } })
753 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields, statusCodeExpected: 409 })
756 it('Should succeed with the correct params', async function () {
757 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'super_channel', displayName: 'toto' } })
759 await makePostBodyRequest({
761 path: registrationPath,
762 token: server.accessToken,
764 statusCodeExpected: 204
768 it('Should fail on a server with registration disabled', async function () {
771 email: 'test4@example.com',
772 password: 'my super password 4'
775 await makePostBodyRequest({
776 url: serverWithRegistrationDisabled.url,
777 path: registrationPath,
778 token: serverWithRegistrationDisabled.accessToken,
780 statusCodeExpected: 403
785 describe('When registering multiple users on a server with users limit', function () {
786 it('Should fail when after 3 registrations', async function () {
787 await registerUser(server.url, 'user42', 'super password', 403)
791 describe('When having a video quota', function () {
792 it('Should fail with a user having too many videos', async function () {
796 accessToken: server.accessToken,
800 await uploadVideo(server.url, server.accessToken, {}, 403)
803 it('Should fail with a registered user having too many videos', async function () {
808 password: 'my super password'
810 userAccessToken = await userLogin(server, user)
812 const videoAttributes = { fixture: 'video_short2.webm' }
813 await uploadVideo(server.url, userAccessToken, videoAttributes)
814 await uploadVideo(server.url, userAccessToken, videoAttributes)
815 await uploadVideo(server.url, userAccessToken, videoAttributes)
816 await uploadVideo(server.url, userAccessToken, videoAttributes)
817 await uploadVideo(server.url, userAccessToken, videoAttributes)
818 await uploadVideo(server.url, userAccessToken, videoAttributes, 403)
821 it('Should fail to import with HTTP/Torrent/magnet', async function () {
824 const baseAttributes = {
826 privacy: VideoPrivacy.PUBLIC
828 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() }))
829 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
830 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' }))
832 await waitJobs([ server ])
834 const res = await getMyVideoImports(server.url, server.accessToken)
836 expect(res.body.total).to.equal(3)
837 const videoImports: VideoImport[] = res.body.data
838 expect(videoImports).to.have.lengthOf(3)
840 for (const videoImport of videoImports) {
841 expect(videoImport.state.id).to.equal(VideoImportState.FAILED)
842 expect(videoImport.error).not.to.be.undefined
843 expect(videoImport.error).to.contain('user video quota is exceeded')
848 describe('When having a daily video quota', function () {
849 it('Should fail with a user having too many videos', async function () {
853 accessToken: server.accessToken,
857 await uploadVideo(server.url, server.accessToken, {}, 403)
861 describe('When having an absolute and daily video quota', function () {
862 it('Should fail if exceeding total quota', async function () {
866 accessToken: server.accessToken,
868 videoQuotaDaily: 1024 * 1024 * 1024
871 await uploadVideo(server.url, server.accessToken, {}, 403)
874 it('Should fail if exceeding daily quota', async function () {
878 accessToken: server.accessToken,
879 videoQuota: 1024 * 1024 * 1024,
883 await uploadVideo(server.url, server.accessToken, {}, 403)
887 describe('When asking a password reset', function () {
888 const path = '/api/v1/users/ask-reset-password'
890 it('Should fail with a missing email', async function () {
893 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
896 it('Should fail with an invalid email', async function () {
897 const fields = { email: 'hello' }
899 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
902 it('Should success with the correct params', async function () {
903 const fields = { email: 'admin@example.com' }
905 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
909 describe('When asking for an account verification email', function () {
910 const path = '/api/v1/users/ask-send-verify-email'
912 it('Should fail with a missing email', async function () {
915 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
918 it('Should fail with an invalid email', async function () {
919 const fields = { email: 'hello' }
921 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
924 it('Should succeed with the correct params', async function () {
925 const fields = { email: 'admin@example.com' }
927 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
931 after(async function () {
932 await cleanupTests([ server, serverWithRegistrationDisabled ])