1 /* tslint:disable:no-unused-expression */
3 import { omit } from 'lodash'
5 import { join } from 'path'
6 import { User, 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/'
47 let moderatorId: number
49 let server: ServerInfo
50 let serverWithRegistrationDisabled: ServerInfo
51 let userAccessToken = ''
52 let moderatorAccessToken = ''
55 // ---------------------------------------------------------------
57 before(async function () {
61 const res = await Promise.all([
62 flushAndRunServer(1, { signup: { limit: 7 } }),
67 serverWithRegistrationDisabled = res[1]
69 await setAccessTokensToServers([ server ])
75 password: 'my super password'
78 const videoQuota = 42000000
81 accessToken: server.accessToken,
82 username: user.username,
83 password: user.password,
84 videoQuota: videoQuota
86 userAccessToken = await userLogin(server, user)
91 username: 'moderator1',
92 password: 'super password'
97 accessToken: server.accessToken,
98 username: moderator.username,
99 password: moderator.password,
100 role: UserRole.MODERATOR
103 moderatorAccessToken = await userLogin(server, moderator)
108 username: 'moderator2',
109 password: 'super password'
114 accessToken: server.accessToken,
115 username: moderator.username,
116 password: moderator.password,
117 role: UserRole.MODERATOR
122 const res = await getMyUserInformation(server.url, server.accessToken)
123 channelId = res.body.videoChannels[ 0 ].id
127 const res = await uploadVideo(server.url, server.accessToken, {})
128 videoId = res.body.video.id
132 const res = await getUsersList(server.url, server.accessToken)
133 const users: User[] = res.body.data
135 userId = users.find(u => u.username === 'user1').id
136 rootId = users.find(u => u.username === 'root').id
137 moderatorId = users.find(u => u.username === 'moderator2').id
141 describe('When listing users', function () {
142 it('Should fail with a bad start pagination', async function () {
143 await checkBadStartPagination(server.url, path, server.accessToken)
146 it('Should fail with a bad count pagination', async function () {
147 await checkBadCountPagination(server.url, path, server.accessToken)
150 it('Should fail with an incorrect sort', async function () {
151 await checkBadSortPagination(server.url, path, server.accessToken)
154 it('Should fail with a non authenticated user', async function () {
155 await makeGetRequest({
158 statusCodeExpected: 401
162 it('Should fail with a non admin user', async function () {
163 await makeGetRequest({
166 token: userAccessToken,
167 statusCodeExpected: 403
172 describe('When adding a new user', function () {
173 const baseCorrectParams = {
175 email: 'test@example.com',
176 password: 'my super password',
180 adminFlags: UserAdminFlag.BY_PASS_VIDEO_AUTO_BLACKLIST
183 it('Should fail with a too small username', async function () {
184 const fields = immutableAssign(baseCorrectParams, { username: '' })
186 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
189 it('Should fail with a too long username', async function () {
190 const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
192 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
195 it('Should fail with a not lowercase username', async function () {
196 const fields = immutableAssign(baseCorrectParams, { username: 'Toto' })
198 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
201 it('Should fail with an incorrect username', async function () {
202 const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
204 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
207 it('Should fail with a missing email', async function () {
208 const fields = omit(baseCorrectParams, 'email')
210 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
213 it('Should fail with an invalid email', async function () {
214 const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
216 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
219 it('Should fail with a too small password', async function () {
220 const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
222 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
225 it('Should fail with a too long password', async function () {
226 const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
228 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
231 it('Should fail with invalid admin flags', async function () {
232 const fields = immutableAssign(baseCorrectParams, { adminFlags: 'toto' })
234 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
237 it('Should fail with an non authenticated user', async function () {
238 await makePostBodyRequest({
241 token: 'super token',
242 fields: baseCorrectParams,
243 statusCodeExpected: 401
247 it('Should fail if we add a user with the same username', async function () {
248 const fields = immutableAssign(baseCorrectParams, { username: 'user1' })
250 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 })
253 it('Should fail if we add a user with the same email', async function () {
254 const fields = immutableAssign(baseCorrectParams, { email: 'user1@example.com' })
256 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 })
259 it('Should fail without a videoQuota', async function () {
260 const fields = omit(baseCorrectParams, 'videoQuota')
262 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
265 it('Should fail without a videoQuotaDaily', async function () {
266 const fields = omit(baseCorrectParams, 'videoQuotaDaily')
268 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
271 it('Should fail with an invalid videoQuota', async function () {
272 const fields = immutableAssign(baseCorrectParams, { videoQuota: -5 })
274 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
277 it('Should fail with an invalid videoQuotaDaily', async function () {
278 const fields = immutableAssign(baseCorrectParams, { videoQuotaDaily: -7 })
280 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
283 it('Should fail without a user role', async function () {
284 const fields = omit(baseCorrectParams, 'role')
286 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
289 it('Should fail with an invalid user role', async function () {
290 const fields = immutableAssign(baseCorrectParams, { role: 88989 })
292 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
295 it('Should fail with a "peertube" username', async function () {
296 const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
298 await makePostBodyRequest({
301 token: server.accessToken,
303 statusCodeExpected: 409
307 it('Should fail to create a moderator or an admin with a moderator', async function () {
308 for (const role of [ UserRole.MODERATOR, UserRole.ADMINISTRATOR ]) {
309 const fields = immutableAssign(baseCorrectParams, { role })
311 await makePostBodyRequest({
314 token: moderatorAccessToken,
316 statusCodeExpected: 403
321 it('Should succeed to create a user with a moderator', async function () {
322 const fields = immutableAssign(baseCorrectParams, { username: 'a4656', email: 'a4656@example.com', role: UserRole.USER })
324 await makePostBodyRequest({
327 token: moderatorAccessToken,
329 statusCodeExpected: 200
333 it('Should succeed with the correct params', async function () {
334 await makePostBodyRequest({
337 token: server.accessToken,
338 fields: baseCorrectParams,
339 statusCodeExpected: 200
343 it('Should fail with a non admin user', async function () {
346 password: 'my super password'
348 userAccessToken = await userLogin(server, user)
352 email: 'test@example.com',
353 password: 'my super password',
356 await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: 403 })
360 describe('When updating my account', function () {
361 it('Should fail with an invalid email attribute', async function () {
366 await makePutBodyRequest({ url: server.url, path: path + 'me', token: server.accessToken, fields })
369 it('Should fail with a too small password', async function () {
371 currentPassword: 'my super password',
375 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
378 it('Should fail with a too long password', async function () {
380 currentPassword: 'my super password',
381 password: 'super'.repeat(61)
384 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
387 it('Should fail without the current password', async function () {
389 currentPassword: 'my super password',
390 password: 'super'.repeat(61)
393 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
396 it('Should fail with an invalid current password', async function () {
398 currentPassword: 'my super password fail',
399 password: 'super'.repeat(61)
402 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 401 })
405 it('Should fail with an invalid NSFW policy attribute', async function () {
410 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
413 it('Should fail with an invalid autoPlayVideo attribute', async function () {
418 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
421 it('Should fail with an invalid videosHistoryEnabled attribute', async function () {
423 videosHistoryEnabled: -1
426 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
429 it('Should fail with an non authenticated user', async function () {
431 currentPassword: 'my super password',
432 password: 'my super password'
435 await makePutBodyRequest({ url: server.url, path: path + 'me', token: 'super token', fields, statusCodeExpected: 401 })
438 it('Should fail with a too long description', async function () {
440 description: 'super'.repeat(201)
443 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
446 it('Should fail with an invalid videoLanguages attribute', async function () {
449 videoLanguages: 'toto'
452 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
457 for (let i = 0; i < 1000; i++) {
462 videoLanguages: languages
465 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
469 it('Should fail with an invalid theme', async function () {
470 const fields = { theme: 'invalid' }
471 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
474 it('Should fail with an unknown theme', async function () {
475 const fields = { theme: 'peertube-theme-unknown' }
476 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
479 it('Should fail with an invalid noInstanceConfigWarningModal attribute', async function () {
481 noInstanceConfigWarningModal: -1
484 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
487 it('Should fail with an invalid noWelcomeModal attribute', async function () {
492 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
495 it('Should succeed to change password with the correct params', async function () {
497 currentPassword: 'my super password',
498 password: 'my super password',
500 autoPlayVideo: false,
501 email: 'super_email@example.com',
503 noInstanceConfigWarningModal: true,
507 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
510 it('Should succeed without password change with the correct params', async function () {
516 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
520 describe('When updating my avatar', function () {
521 it('Should fail without an incorrect input file', async function () {
524 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
526 await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
529 it('Should fail with a big file', async function () {
532 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar-big.png')
534 await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
537 it('Should fail with an unauthenticated user', async function () {
540 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
542 await makeUploadRequest({
544 path: path + '/me/avatar/pick',
547 statusCodeExpected: 401
551 it('Should succeed with the correct params', async function () {
554 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
556 await makeUploadRequest({
558 path: path + '/me/avatar/pick',
559 token: server.accessToken,
562 statusCodeExpected: 200
567 describe('When getting a user', function () {
569 it('Should fail with an non authenticated user', async function () {
570 await makeGetRequest({ url: server.url, path: path + userId, token: 'super token', statusCodeExpected: 401 })
573 it('Should fail with a non admin user', async function () {
574 await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 403 })
577 it('Should succeed with the correct params', async function () {
578 await makeGetRequest({ url: server.url, path: path + userId, token: server.accessToken, statusCodeExpected: 200 })
582 describe('When updating a user', function () {
584 it('Should fail with an invalid email attribute', async function () {
589 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
592 it('Should fail with an invalid emailVerified attribute', async function () {
597 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
600 it('Should fail with an invalid videoQuota attribute', async function () {
605 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
608 it('Should fail with an invalid user role attribute', async function () {
613 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
616 it('Should fail with a too small password', async function () {
618 currentPassword: 'my super password',
622 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
625 it('Should fail with a too long password', async function () {
627 currentPassword: 'my super password',
628 password: 'super'.repeat(61)
631 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
634 it('Should fail with an non authenticated user', async function () {
639 await makePutBodyRequest({ url: server.url, path: path + userId, token: 'super token', fields, statusCodeExpected: 401 })
642 it('Should fail when updating root role', async function () {
644 role: UserRole.MODERATOR
647 await makePutBodyRequest({ url: server.url, path: path + rootId, token: server.accessToken, fields })
650 it('Should fail with invalid admin flags', async function () {
651 const fields = { adminFlags: 'toto' }
653 await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
656 it('Should fail to update an admin with a moderator', async function () {
661 await makePutBodyRequest({
663 path: path + moderatorId,
664 token: moderatorAccessToken,
666 statusCodeExpected: 403
670 it('Should succeed to update a user with a moderator', async function () {
675 await makePutBodyRequest({
678 token: moderatorAccessToken,
680 statusCodeExpected: 204
684 it('Should succeed with the correct params', async function () {
686 email: 'email@example.com',
692 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields, statusCodeExpected: 204 })
696 describe('When getting my information', function () {
697 it('Should fail with a non authenticated user', async function () {
698 await getMyUserInformation(server.url, 'fake_token', 401)
701 it('Should success with the correct parameters', async function () {
702 await getMyUserInformation(server.url, userAccessToken)
706 describe('When getting my video rating', function () {
707 it('Should fail with a non authenticated user', async function () {
708 await getMyUserVideoRating(server.url, 'fake_token', videoId, 401)
711 it('Should fail with an incorrect video uuid', async function () {
712 await getMyUserVideoRating(server.url, server.accessToken, 'blabla', 400)
715 it('Should fail with an unknown video', async function () {
716 await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
719 it('Should succeed with the correct parameters', async function () {
720 await getMyUserVideoRating(server.url, server.accessToken, videoId)
724 describe('When retrieving my global ratings', function () {
725 const path = '/api/v1/accounts/user1/ratings'
727 it('Should fail with a bad start pagination', async function () {
728 await checkBadStartPagination(server.url, path, userAccessToken)
731 it('Should fail with a bad count pagination', async function () {
732 await checkBadCountPagination(server.url, path, userAccessToken)
735 it('Should fail with an incorrect sort', async function () {
736 await checkBadSortPagination(server.url, path, userAccessToken)
739 it('Should fail with a unauthenticated user', async function () {
740 await makeGetRequest({ url: server.url, path, statusCodeExpected: 401 })
743 it('Should fail with a another user', async function () {
744 await makeGetRequest({ url: server.url, path, token: server.accessToken, statusCodeExpected: 403 })
747 it('Should fail with a bad type', async function () {
748 await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { rating: 'toto ' }, statusCodeExpected: 400 })
751 it('Should succeed with the correct params', async function () {
752 await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 200 })
756 describe('When blocking/unblocking/removing user', function () {
757 it('Should fail with an incorrect id', async function () {
758 await removeUser(server.url, 'blabla', server.accessToken, 400)
759 await blockUser(server.url, 'blabla', server.accessToken, 400)
760 await unblockUser(server.url, 'blabla', server.accessToken, 400)
763 it('Should fail with the root user', async function () {
764 await removeUser(server.url, rootId, server.accessToken, 400)
765 await blockUser(server.url, rootId, server.accessToken, 400)
766 await unblockUser(server.url, rootId, server.accessToken, 400)
769 it('Should return 404 with a non existing id', async function () {
770 await removeUser(server.url, 4545454, server.accessToken, 404)
771 await blockUser(server.url, 4545454, server.accessToken, 404)
772 await unblockUser(server.url, 4545454, server.accessToken, 404)
775 it('Should fail with a non admin user', async function () {
776 await removeUser(server.url, userId, userAccessToken, 403)
777 await blockUser(server.url, userId, userAccessToken, 403)
778 await unblockUser(server.url, userId, userAccessToken, 403)
781 it('Should fail on a moderator with a moderator', async function () {
782 await removeUser(server.url, moderatorId, moderatorAccessToken, 403)
783 await blockUser(server.url, moderatorId, moderatorAccessToken, 403)
784 await unblockUser(server.url, moderatorId, moderatorAccessToken, 403)
787 it('Should succeed on a user with a moderator', async function () {
788 await blockUser(server.url, userId, moderatorAccessToken)
789 await unblockUser(server.url, userId, moderatorAccessToken)
793 describe('When deleting our account', function () {
794 it('Should fail with with the root account', async function () {
795 await deleteMe(server.url, server.accessToken, 400)
799 describe('When registering a new user', function () {
800 const registrationPath = path + '/register'
801 const baseCorrectParams = {
803 displayName: 'super user',
804 email: 'test3@example.com',
805 password: 'my super password'
808 it('Should fail with a too small username', async function () {
809 const fields = immutableAssign(baseCorrectParams, { username: '' })
811 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
814 it('Should fail with a too long username', async function () {
815 const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
817 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
820 it('Should fail with an incorrect username', async function () {
821 const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
823 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
826 it('Should fail with a missing email', async function () {
827 const fields = omit(baseCorrectParams, 'email')
829 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
832 it('Should fail with an invalid email', async function () {
833 const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
835 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
838 it('Should fail with a too small password', async function () {
839 const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
841 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
844 it('Should fail with a too long password', async function () {
845 const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
847 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
850 it('Should fail if we register a user with the same username', async function () {
851 const fields = immutableAssign(baseCorrectParams, { username: 'root' })
853 await makePostBodyRequest({
855 path: registrationPath,
856 token: server.accessToken,
858 statusCodeExpected: 409
862 it('Should fail with a "peertube" username', async function () {
863 const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
865 await makePostBodyRequest({
867 path: registrationPath,
868 token: server.accessToken,
870 statusCodeExpected: 409
874 it('Should fail if we register a user with the same email', async function () {
875 const fields = immutableAssign(baseCorrectParams, { email: 'admin' + server.internalServerNumber + '@example.com' })
877 await makePostBodyRequest({
879 path: registrationPath,
880 token: server.accessToken,
882 statusCodeExpected: 409
886 it('Should fail with a bad display name', async function () {
887 const fields = immutableAssign(baseCorrectParams, { displayName: 'a'.repeat(150) })
889 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
892 it('Should fail with a bad channel name', async function () {
893 const fields = immutableAssign(baseCorrectParams, { channel: { name: '[]azf', displayName: 'toto' } })
895 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
898 it('Should fail with a bad channel display name', async function () {
899 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'toto', displayName: '' } })
901 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
904 it('Should fail with a channel name that is the same than user username', async function () {
905 const source = { username: 'super_user', channel: { name: 'super_user', displayName: 'display name' } }
906 const fields = immutableAssign(baseCorrectParams, source)
908 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
911 it('Should fail with an existing channel', async function () {
912 const videoChannelAttributesArg = { name: 'existing_channel', displayName: 'hello', description: 'super description' }
913 await addVideoChannel(server.url, server.accessToken, videoChannelAttributesArg)
915 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'existing_channel', displayName: 'toto' } })
917 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields, statusCodeExpected: 409 })
920 it('Should succeed with the correct params', async function () {
921 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'super_channel', displayName: 'toto' } })
923 await makePostBodyRequest({
925 path: registrationPath,
926 token: server.accessToken,
928 statusCodeExpected: 204
932 it('Should fail on a server with registration disabled', async function () {
935 email: 'test4@example.com',
936 password: 'my super password 4'
939 await makePostBodyRequest({
940 url: serverWithRegistrationDisabled.url,
941 path: registrationPath,
942 token: serverWithRegistrationDisabled.accessToken,
944 statusCodeExpected: 403
949 describe('When registering multiple users on a server with users limit', function () {
950 it('Should fail when after 3 registrations', async function () {
951 await registerUser(server.url, 'user42', 'super password', 403)
955 describe('When having a video quota', function () {
956 it('Should fail with a user having too many videos', async function () {
960 accessToken: server.accessToken,
964 await uploadVideo(server.url, server.accessToken, {}, 403)
967 it('Should fail with a registered user having too many videos', async function () {
972 password: 'my super password'
974 userAccessToken = await userLogin(server, user)
976 const videoAttributes = { fixture: 'video_short2.webm' }
977 await uploadVideo(server.url, userAccessToken, videoAttributes)
978 await uploadVideo(server.url, userAccessToken, videoAttributes)
979 await uploadVideo(server.url, userAccessToken, videoAttributes)
980 await uploadVideo(server.url, userAccessToken, videoAttributes)
981 await uploadVideo(server.url, userAccessToken, videoAttributes)
982 await uploadVideo(server.url, userAccessToken, videoAttributes, 403)
985 it('Should fail to import with HTTP/Torrent/magnet', async function () {
988 const baseAttributes = {
990 privacy: VideoPrivacy.PUBLIC
992 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() }))
993 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
994 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' }))
996 await waitJobs([ server ])
998 const res = await getMyVideoImports(server.url, server.accessToken)
1000 expect(res.body.total).to.equal(3)
1001 const videoImports: VideoImport[] = res.body.data
1002 expect(videoImports).to.have.lengthOf(3)
1004 for (const videoImport of videoImports) {
1005 expect(videoImport.state.id).to.equal(VideoImportState.FAILED)
1006 expect(videoImport.error).not.to.be.undefined
1007 expect(videoImport.error).to.contain('user video quota is exceeded')
1012 describe('When having a daily video quota', function () {
1013 it('Should fail with a user having too many videos', async function () {
1017 accessToken: server.accessToken,
1021 await uploadVideo(server.url, server.accessToken, {}, 403)
1025 describe('When having an absolute and daily video quota', function () {
1026 it('Should fail if exceeding total quota', async function () {
1030 accessToken: server.accessToken,
1032 videoQuotaDaily: 1024 * 1024 * 1024
1035 await uploadVideo(server.url, server.accessToken, {}, 403)
1038 it('Should fail if exceeding daily quota', async function () {
1042 accessToken: server.accessToken,
1043 videoQuota: 1024 * 1024 * 1024,
1047 await uploadVideo(server.url, server.accessToken, {}, 403)
1051 describe('When asking a password reset', function () {
1052 const path = '/api/v1/users/ask-reset-password'
1054 it('Should fail with a missing email', async function () {
1057 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1060 it('Should fail with an invalid email', async function () {
1061 const fields = { email: 'hello' }
1063 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1066 it('Should success with the correct params', async function () {
1067 const fields = { email: 'admin@example.com' }
1069 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
1073 describe('When asking for an account verification email', function () {
1074 const path = '/api/v1/users/ask-send-verify-email'
1076 it('Should fail with a missing email', async function () {
1079 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1082 it('Should fail with an invalid email', async function () {
1083 const fields = { email: 'hello' }
1085 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1088 it('Should succeed with the correct params', async function () {
1089 const fields = { email: 'admin@example.com' }
1091 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
1095 after(async function () {
1096 await cleanupTests([ server, serverWithRegistrationDisabled ])