1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
4 import { expect } from 'chai'
5 import { omit } from 'lodash'
6 import { join } from 'path'
7 import { User, UserRole, VideoImport, VideoImportState } from '../../../../shared'
28 setAccessTokensToServers,
33 } from '../../../../shared/extra-utils'
34 import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
36 checkBadCountPagination,
37 checkBadSortPagination,
38 checkBadStartPagination
39 } from '../../../../shared/extra-utils/requests/check-api-params'
40 import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
41 import { getMagnetURI, getMyVideoImports, getGoodVideoUrl, importVideo } from '../../../../shared/extra-utils/videos/video-imports'
42 import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
43 import { VideoPrivacy } from '../../../../shared/models/videos'
45 describe('Test users API validators', function () {
46 const path = '/api/v1/users/'
49 let moderatorId: number
51 let server: ServerInfo
52 let serverWithRegistrationDisabled: ServerInfo
53 let userAccessToken = ''
54 let moderatorAccessToken = ''
56 let overrideConfig: Object
58 // ---------------------------------------------------------------
60 before(async function () {
63 const emails: object[] = []
64 emailPort = await MockSmtpServer.Instance.collectEmails(emails)
66 overrideConfig = { signup: { limit: 8 } }
69 const res = await Promise.all([
70 flushAndRunServer(1, overrideConfig),
75 serverWithRegistrationDisabled = res[1]
77 await setAccessTokensToServers([ server ])
83 password: 'my super password'
86 const videoQuota = 42000000
89 accessToken: server.accessToken,
90 username: user.username,
91 password: user.password,
92 videoQuota: videoQuota
94 userAccessToken = await userLogin(server, user)
99 username: 'moderator1',
100 password: 'super password'
105 accessToken: server.accessToken,
106 username: moderator.username,
107 password: moderator.password,
108 role: UserRole.MODERATOR
111 moderatorAccessToken = await userLogin(server, moderator)
116 username: 'moderator2',
117 password: 'super password'
122 accessToken: server.accessToken,
123 username: moderator.username,
124 password: moderator.password,
125 role: UserRole.MODERATOR
130 const res = await uploadVideo(server.url, server.accessToken, {})
131 videoId = res.body.video.id
135 const res = await getUsersList(server.url, server.accessToken)
136 const users: User[] = res.body.data
138 userId = users.find(u => u.username === 'user1').id
139 rootId = users.find(u => u.username === 'root').id
140 moderatorId = users.find(u => u.username === 'moderator2').id
144 describe('When listing users', function () {
145 it('Should fail with a bad start pagination', async function () {
146 await checkBadStartPagination(server.url, path, server.accessToken)
149 it('Should fail with a bad count pagination', async function () {
150 await checkBadCountPagination(server.url, path, server.accessToken)
153 it('Should fail with an incorrect sort', async function () {
154 await checkBadSortPagination(server.url, path, server.accessToken)
157 it('Should fail with a non authenticated user', async function () {
158 await makeGetRequest({
161 statusCodeExpected: 401
165 it('Should fail with a non admin user', async function () {
166 await makeGetRequest({
169 token: userAccessToken,
170 statusCodeExpected: 403
175 describe('When adding a new user', function () {
176 const baseCorrectParams = {
178 email: 'test@example.com',
179 password: 'my super password',
183 adminFlags: UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST
186 it('Should fail with a too small username', async function () {
187 const fields = immutableAssign(baseCorrectParams, { username: '' })
189 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
192 it('Should fail with a too long username', async function () {
193 const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
195 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
198 it('Should fail with a not lowercase username', async function () {
199 const fields = immutableAssign(baseCorrectParams, { username: 'Toto' })
201 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
204 it('Should fail with an incorrect username', async function () {
205 const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
207 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
210 it('Should fail with a missing email', async function () {
211 const fields = omit(baseCorrectParams, 'email')
213 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
216 it('Should fail with an invalid email', async function () {
217 const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
219 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
222 it('Should fail with a too small password', async function () {
223 const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
225 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
228 it('Should fail with a too long password', async function () {
229 const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
231 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
234 it('Should fail with empty password and no smtp configured', async function () {
235 const fields = immutableAssign(baseCorrectParams, { password: '' })
237 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
240 it('Should succeed with no password on a server with smtp enabled', async function () {
243 killallServers([ server ])
245 const config = immutableAssign(overrideConfig, {
247 hostname: 'localhost',
251 await reRunServer(server, config)
253 const fields = immutableAssign(baseCorrectParams, {
255 username: 'create_password',
256 email: 'create_password@example.com'
259 await makePostBodyRequest({
262 token: server.accessToken,
264 statusCodeExpected: 200
268 it('Should fail with invalid admin flags', async function () {
269 const fields = immutableAssign(baseCorrectParams, { adminFlags: 'toto' })
271 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
274 it('Should fail with an non authenticated user', async function () {
275 await makePostBodyRequest({
278 token: 'super token',
279 fields: baseCorrectParams,
280 statusCodeExpected: 401
284 it('Should fail if we add a user with the same username', async function () {
285 const fields = immutableAssign(baseCorrectParams, { username: 'user1' })
287 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 })
290 it('Should fail if we add a user with the same email', async function () {
291 const fields = immutableAssign(baseCorrectParams, { email: 'user1@example.com' })
293 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 })
296 it('Should fail without a videoQuota', async function () {
297 const fields = omit(baseCorrectParams, 'videoQuota')
299 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
302 it('Should fail without a videoQuotaDaily', async function () {
303 const fields = omit(baseCorrectParams, 'videoQuotaDaily')
305 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
308 it('Should fail with an invalid videoQuota', async function () {
309 const fields = immutableAssign(baseCorrectParams, { videoQuota: -5 })
311 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
314 it('Should fail with an invalid videoQuotaDaily', async function () {
315 const fields = immutableAssign(baseCorrectParams, { videoQuotaDaily: -7 })
317 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
320 it('Should fail without a user role', async function () {
321 const fields = omit(baseCorrectParams, 'role')
323 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
326 it('Should fail with an invalid user role', async function () {
327 const fields = immutableAssign(baseCorrectParams, { role: 88989 })
329 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
332 it('Should fail with a "peertube" username', async function () {
333 const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
335 await makePostBodyRequest({
338 token: server.accessToken,
340 statusCodeExpected: 409
344 it('Should fail to create a moderator or an admin with a moderator', async function () {
345 for (const role of [ UserRole.MODERATOR, UserRole.ADMINISTRATOR ]) {
346 const fields = immutableAssign(baseCorrectParams, { role })
348 await makePostBodyRequest({
351 token: moderatorAccessToken,
353 statusCodeExpected: 403
358 it('Should succeed to create a user with a moderator', async function () {
359 const fields = immutableAssign(baseCorrectParams, { username: 'a4656', email: 'a4656@example.com', role: UserRole.USER })
361 await makePostBodyRequest({
364 token: moderatorAccessToken,
366 statusCodeExpected: 200
370 it('Should succeed with the correct params', async function () {
371 await makePostBodyRequest({
374 token: server.accessToken,
375 fields: baseCorrectParams,
376 statusCodeExpected: 200
380 it('Should fail with a non admin user', async function () {
383 password: 'my super password'
385 userAccessToken = await userLogin(server, user)
389 email: 'test@example.com',
390 password: 'my super password',
393 await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: 403 })
397 describe('When updating my account', function () {
398 it('Should fail with an invalid email attribute', async function () {
403 await makePutBodyRequest({ url: server.url, path: path + 'me', token: server.accessToken, fields })
406 it('Should fail with a too small password', async function () {
408 currentPassword: 'my super password',
412 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
415 it('Should fail with a too long password', async function () {
417 currentPassword: 'my super password',
418 password: 'super'.repeat(61)
421 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
424 it('Should fail without the current password', async function () {
426 currentPassword: 'my super password',
427 password: 'super'.repeat(61)
430 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
433 it('Should fail with an invalid current password', async function () {
435 currentPassword: 'my super password fail',
436 password: 'super'.repeat(61)
439 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 401 })
442 it('Should fail with an invalid NSFW policy attribute', async function () {
447 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
450 it('Should fail with an invalid autoPlayVideo attribute', async function () {
455 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
458 it('Should fail with an invalid autoPlayNextVideo attribute', async function () {
460 autoPlayNextVideo: -1
463 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
466 it('Should fail with an invalid videosHistoryEnabled attribute', async function () {
468 videosHistoryEnabled: -1
471 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
474 it('Should fail with an non authenticated user', async function () {
476 currentPassword: 'my super password',
477 password: 'my super password'
480 await makePutBodyRequest({ url: server.url, path: path + 'me', token: 'super token', fields, statusCodeExpected: 401 })
483 it('Should fail with a too long description', async function () {
485 description: 'super'.repeat(201)
488 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
491 it('Should fail with an invalid videoLanguages attribute', async function () {
494 videoLanguages: 'toto'
497 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
502 for (let i = 0; i < 1000; i++) {
507 videoLanguages: languages
510 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
514 it('Should fail with an invalid theme', async function () {
515 const fields = { theme: 'invalid' }
516 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
519 it('Should fail with an unknown theme', async function () {
520 const fields = { theme: 'peertube-theme-unknown' }
521 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
524 it('Should fail with an invalid noInstanceConfigWarningModal attribute', async function () {
526 noInstanceConfigWarningModal: -1
529 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
532 it('Should fail with an invalid noWelcomeModal attribute', async function () {
537 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
540 it('Should succeed to change password with the correct params', async function () {
542 currentPassword: 'my super password',
543 password: 'my super password',
545 autoPlayVideo: false,
546 email: 'super_email@example.com',
548 noInstanceConfigWarningModal: true,
552 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
555 it('Should succeed without password change with the correct params', async function () {
561 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
565 describe('When updating my avatar', function () {
566 it('Should fail without an incorrect input file', async function () {
569 avatarfile: join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
571 await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
574 it('Should fail with a big file', async function () {
577 avatarfile: join(__dirname, '..', '..', 'fixtures', 'avatar-big.png')
579 await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
582 it('Should fail with an unauthenticated user', async function () {
585 avatarfile: join(__dirname, '..', '..', 'fixtures', 'avatar.png')
587 await makeUploadRequest({
589 path: path + '/me/avatar/pick',
592 statusCodeExpected: 401
596 it('Should succeed with the correct params', async function () {
599 avatarfile: join(__dirname, '..', '..', 'fixtures', 'avatar.png')
601 await makeUploadRequest({
603 path: path + '/me/avatar/pick',
604 token: server.accessToken,
607 statusCodeExpected: 200
612 describe('When getting a user', function () {
614 it('Should fail with an non authenticated user', async function () {
615 await makeGetRequest({ url: server.url, path: path + userId, token: 'super token', statusCodeExpected: 401 })
618 it('Should fail with a non admin user', async function () {
619 await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 403 })
622 it('Should succeed with the correct params', async function () {
623 await makeGetRequest({ url: server.url, path: path + userId, token: server.accessToken, statusCodeExpected: 200 })
627 describe('When updating a user', function () {
629 it('Should fail with an invalid email attribute', async function () {
634 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
637 it('Should fail with an invalid emailVerified attribute', async function () {
642 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
645 it('Should fail with an invalid videoQuota attribute', async function () {
650 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
653 it('Should fail with an invalid user role attribute', async function () {
658 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
661 it('Should fail with a too small password', async function () {
663 currentPassword: 'my super password',
667 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
670 it('Should fail with a too long password', async function () {
672 currentPassword: 'my super password',
673 password: 'super'.repeat(61)
676 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
679 it('Should fail with an non authenticated user', async function () {
684 await makePutBodyRequest({ url: server.url, path: path + userId, token: 'super token', fields, statusCodeExpected: 401 })
687 it('Should fail when updating root role', async function () {
689 role: UserRole.MODERATOR
692 await makePutBodyRequest({ url: server.url, path: path + rootId, token: server.accessToken, fields })
695 it('Should fail with invalid admin flags', async function () {
696 const fields = { adminFlags: 'toto' }
698 await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
701 it('Should fail to update an admin with a moderator', async function () {
706 await makePutBodyRequest({
708 path: path + moderatorId,
709 token: moderatorAccessToken,
711 statusCodeExpected: 403
715 it('Should succeed to update a user with a moderator', async function () {
720 await makePutBodyRequest({
723 token: moderatorAccessToken,
725 statusCodeExpected: 204
729 it('Should succeed with the correct params', async function () {
731 email: 'email@example.com',
737 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields, statusCodeExpected: 204 })
741 describe('When getting my information', function () {
742 it('Should fail with a non authenticated user', async function () {
743 await getMyUserInformation(server.url, 'fake_token', 401)
746 it('Should success with the correct parameters', async function () {
747 await getMyUserInformation(server.url, userAccessToken)
751 describe('When getting my video rating', function () {
752 it('Should fail with a non authenticated user', async function () {
753 await getMyUserVideoRating(server.url, 'fake_token', videoId, 401)
756 it('Should fail with an incorrect video uuid', async function () {
757 await getMyUserVideoRating(server.url, server.accessToken, 'blabla', 400)
760 it('Should fail with an unknown video', async function () {
761 await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
764 it('Should succeed with the correct parameters', async function () {
765 await getMyUserVideoRating(server.url, server.accessToken, videoId)
769 describe('When retrieving my global ratings', function () {
770 const path = '/api/v1/accounts/user1/ratings'
772 it('Should fail with a bad start pagination', async function () {
773 await checkBadStartPagination(server.url, path, userAccessToken)
776 it('Should fail with a bad count pagination', async function () {
777 await checkBadCountPagination(server.url, path, userAccessToken)
780 it('Should fail with an incorrect sort', async function () {
781 await checkBadSortPagination(server.url, path, userAccessToken)
784 it('Should fail with a unauthenticated user', async function () {
785 await makeGetRequest({ url: server.url, path, statusCodeExpected: 401 })
788 it('Should fail with a another user', async function () {
789 await makeGetRequest({ url: server.url, path, token: server.accessToken, statusCodeExpected: 403 })
792 it('Should fail with a bad type', async function () {
793 await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { rating: 'toto ' }, statusCodeExpected: 400 })
796 it('Should succeed with the correct params', async function () {
797 await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 200 })
801 describe('When blocking/unblocking/removing user', function () {
802 it('Should fail with an incorrect id', async function () {
803 await removeUser(server.url, 'blabla', server.accessToken, 400)
804 await blockUser(server.url, 'blabla', server.accessToken, 400)
805 await unblockUser(server.url, 'blabla', server.accessToken, 400)
808 it('Should fail with the root user', async function () {
809 await removeUser(server.url, rootId, server.accessToken, 400)
810 await blockUser(server.url, rootId, server.accessToken, 400)
811 await unblockUser(server.url, rootId, server.accessToken, 400)
814 it('Should return 404 with a non existing id', async function () {
815 await removeUser(server.url, 4545454, server.accessToken, 404)
816 await blockUser(server.url, 4545454, server.accessToken, 404)
817 await unblockUser(server.url, 4545454, server.accessToken, 404)
820 it('Should fail with a non admin user', async function () {
821 await removeUser(server.url, userId, userAccessToken, 403)
822 await blockUser(server.url, userId, userAccessToken, 403)
823 await unblockUser(server.url, userId, userAccessToken, 403)
826 it('Should fail on a moderator with a moderator', async function () {
827 await removeUser(server.url, moderatorId, moderatorAccessToken, 403)
828 await blockUser(server.url, moderatorId, moderatorAccessToken, 403)
829 await unblockUser(server.url, moderatorId, moderatorAccessToken, 403)
832 it('Should succeed on a user with a moderator', async function () {
833 await blockUser(server.url, userId, moderatorAccessToken)
834 await unblockUser(server.url, userId, moderatorAccessToken)
838 describe('When deleting our account', function () {
839 it('Should fail with with the root account', async function () {
840 await deleteMe(server.url, server.accessToken, 400)
844 describe('When registering a new user', function () {
845 const registrationPath = path + '/register'
846 const baseCorrectParams = {
848 displayName: 'super user',
849 email: 'test3@example.com',
850 password: 'my super password'
853 it('Should fail with a too small username', async function () {
854 const fields = immutableAssign(baseCorrectParams, { username: '' })
856 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
859 it('Should fail with a too long username', async function () {
860 const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
862 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
865 it('Should fail with an incorrect username', async function () {
866 const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
868 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
871 it('Should fail with a missing email', async function () {
872 const fields = omit(baseCorrectParams, 'email')
874 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
877 it('Should fail with an invalid email', async function () {
878 const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
880 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
883 it('Should fail with a too small password', async function () {
884 const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
886 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
889 it('Should fail with a too long password', async function () {
890 const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
892 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
895 it('Should fail if we register a user with the same username', async function () {
896 const fields = immutableAssign(baseCorrectParams, { username: 'root' })
898 await makePostBodyRequest({
900 path: registrationPath,
901 token: server.accessToken,
903 statusCodeExpected: 409
907 it('Should fail with a "peertube" username', async function () {
908 const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
910 await makePostBodyRequest({
912 path: registrationPath,
913 token: server.accessToken,
915 statusCodeExpected: 409
919 it('Should fail if we register a user with the same email', async function () {
920 const fields = immutableAssign(baseCorrectParams, { email: 'admin' + server.internalServerNumber + '@example.com' })
922 await makePostBodyRequest({
924 path: registrationPath,
925 token: server.accessToken,
927 statusCodeExpected: 409
931 it('Should fail with a bad display name', async function () {
932 const fields = immutableAssign(baseCorrectParams, { displayName: 'a'.repeat(150) })
934 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
937 it('Should fail with a bad channel name', async function () {
938 const fields = immutableAssign(baseCorrectParams, { channel: { name: '[]azf', displayName: 'toto' } })
940 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
943 it('Should fail with a bad channel display name', async function () {
944 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'toto', displayName: '' } })
946 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
949 it('Should fail with a channel name that is the same as username', async function () {
950 const source = { username: 'super_user', channel: { name: 'super_user', displayName: 'display name' } }
951 const fields = immutableAssign(baseCorrectParams, source)
953 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
956 it('Should fail with an existing channel', async function () {
957 const videoChannelAttributesArg = { name: 'existing_channel', displayName: 'hello', description: 'super description' }
958 await addVideoChannel(server.url, server.accessToken, videoChannelAttributesArg)
960 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'existing_channel', displayName: 'toto' } })
962 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields, statusCodeExpected: 409 })
965 it('Should succeed with the correct params', async function () {
966 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'super_channel', displayName: 'toto' } })
968 await makePostBodyRequest({
970 path: registrationPath,
971 token: server.accessToken,
973 statusCodeExpected: 204
977 it('Should fail on a server with registration disabled', async function () {
980 email: 'test4@example.com',
981 password: 'my super password 4'
984 await makePostBodyRequest({
985 url: serverWithRegistrationDisabled.url,
986 path: registrationPath,
987 token: serverWithRegistrationDisabled.accessToken,
989 statusCodeExpected: 403
994 describe('When registering multiple users on a server with users limit', function () {
995 it('Should fail when after 3 registrations', async function () {
996 await registerUser(server.url, 'user42', 'super password', 403)
1000 describe('When having a video quota', function () {
1001 it('Should fail with a user having too many videos', async function () {
1005 accessToken: server.accessToken,
1009 await uploadVideo(server.url, server.accessToken, {}, 403)
1012 it('Should fail with a registered user having too many videos', async function () {
1017 password: 'my super password'
1019 userAccessToken = await userLogin(server, user)
1021 const videoAttributes = { fixture: 'video_short2.webm' }
1022 await uploadVideo(server.url, userAccessToken, videoAttributes)
1023 await uploadVideo(server.url, userAccessToken, videoAttributes)
1024 await uploadVideo(server.url, userAccessToken, videoAttributes)
1025 await uploadVideo(server.url, userAccessToken, videoAttributes)
1026 await uploadVideo(server.url, userAccessToken, videoAttributes)
1027 await uploadVideo(server.url, userAccessToken, videoAttributes, 403)
1030 it('Should fail to import with HTTP/Torrent/magnet', async function () {
1031 this.timeout(120000)
1033 const baseAttributes = {
1035 privacy: VideoPrivacy.PUBLIC
1037 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getGoodVideoUrl() }))
1038 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
1039 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' as any }))
1041 await waitJobs([ server ])
1043 const res = await getMyVideoImports(server.url, server.accessToken)
1045 expect(res.body.total).to.equal(3)
1046 const videoImports: VideoImport[] = res.body.data
1047 expect(videoImports).to.have.lengthOf(3)
1049 for (const videoImport of videoImports) {
1050 expect(videoImport.state.id).to.equal(VideoImportState.FAILED)
1051 expect(videoImport.error).not.to.be.undefined
1052 expect(videoImport.error).to.contain('user video quota is exceeded')
1057 describe('When having a daily video quota', function () {
1058 it('Should fail with a user having too many videos', async function () {
1062 accessToken: server.accessToken,
1066 await uploadVideo(server.url, server.accessToken, {}, 403)
1070 describe('When having an absolute and daily video quota', function () {
1071 it('Should fail if exceeding total quota', async function () {
1075 accessToken: server.accessToken,
1077 videoQuotaDaily: 1024 * 1024 * 1024
1080 await uploadVideo(server.url, server.accessToken, {}, 403)
1083 it('Should fail if exceeding daily quota', async function () {
1087 accessToken: server.accessToken,
1088 videoQuota: 1024 * 1024 * 1024,
1092 await uploadVideo(server.url, server.accessToken, {}, 403)
1096 describe('When asking a password reset', function () {
1097 const path = '/api/v1/users/ask-reset-password'
1099 it('Should fail with a missing email', async function () {
1102 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1105 it('Should fail with an invalid email', async function () {
1106 const fields = { email: 'hello' }
1108 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1111 it('Should success with the correct params', async function () {
1112 const fields = { email: 'admin@example.com' }
1114 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
1118 describe('When asking for an account verification email', function () {
1119 const path = '/api/v1/users/ask-send-verify-email'
1121 it('Should fail with a missing email', async function () {
1124 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1127 it('Should fail with an invalid email', async function () {
1128 const fields = { email: 'hello' }
1130 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1133 it('Should succeed with the correct params', async function () {
1134 const fields = { email: 'admin@example.com' }
1136 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
1140 after(async function () {
1141 MockSmtpServer.Instance.kill()
1143 await cleanupTests([ server, serverWithRegistrationDisabled ])