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 succeed to change password with the correct params', async function () {
481 currentPassword: 'my super password',
482 password: 'my super password',
484 autoPlayVideo: false,
485 email: 'super_email@example.com',
489 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
492 it('Should succeed without password change with the correct params', async function () {
498 await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields, statusCodeExpected: 204 })
502 describe('When updating my avatar', function () {
503 it('Should fail without an incorrect input file', async function () {
506 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
508 await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
511 it('Should fail with a big file', async function () {
514 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar-big.png')
516 await makeUploadRequest({ url: server.url, path: path + '/me/avatar/pick', token: server.accessToken, fields, attaches })
519 it('Should fail with an unauthenticated user', async function () {
522 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
524 await makeUploadRequest({
526 path: path + '/me/avatar/pick',
529 statusCodeExpected: 401
533 it('Should succeed with the correct params', async function () {
536 'avatarfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
538 await makeUploadRequest({
540 path: path + '/me/avatar/pick',
541 token: server.accessToken,
544 statusCodeExpected: 200
549 describe('When getting a user', function () {
551 it('Should fail with an non authenticated user', async function () {
552 await makeGetRequest({ url: server.url, path: path + userId, token: 'super token', statusCodeExpected: 401 })
555 it('Should fail with a non admin user', async function () {
556 await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 403 })
559 it('Should succeed with the correct params', async function () {
560 await makeGetRequest({ url: server.url, path: path + userId, token: server.accessToken, statusCodeExpected: 200 })
564 describe('When updating a user', function () {
566 it('Should fail with an invalid email attribute', async function () {
571 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
574 it('Should fail with an invalid emailVerified attribute', async function () {
579 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
582 it('Should fail with an invalid videoQuota attribute', async function () {
587 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
590 it('Should fail with an invalid user role attribute', async function () {
595 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
598 it('Should fail with a too small password', async function () {
600 currentPassword: 'my super password',
604 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
607 it('Should fail with a too long password', async function () {
609 currentPassword: 'my super password',
610 password: 'super'.repeat(61)
613 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
616 it('Should fail with an non authenticated user', async function () {
621 await makePutBodyRequest({ url: server.url, path: path + userId, token: 'super token', fields, statusCodeExpected: 401 })
624 it('Should fail when updating root role', async function () {
626 role: UserRole.MODERATOR
629 await makePutBodyRequest({ url: server.url, path: path + rootId, token: server.accessToken, fields })
632 it('Should fail with invalid admin flags', async function () {
633 const fields = { adminFlags: 'toto' }
635 await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
638 it('Should fail to update an admin with a moderator', async function () {
643 await makePutBodyRequest({
645 path: path + moderatorId,
646 token: moderatorAccessToken,
648 statusCodeExpected: 403
652 it('Should succeed to update a user with a moderator', async function () {
657 await makePutBodyRequest({
660 token: moderatorAccessToken,
662 statusCodeExpected: 204
666 it('Should succeed with the correct params', async function () {
668 email: 'email@example.com',
674 await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields, statusCodeExpected: 204 })
678 describe('When getting my information', function () {
679 it('Should fail with a non authenticated user', async function () {
680 await getMyUserInformation(server.url, 'fake_token', 401)
683 it('Should success with the correct parameters', async function () {
684 await getMyUserInformation(server.url, userAccessToken)
688 describe('When getting my video rating', function () {
689 it('Should fail with a non authenticated user', async function () {
690 await getMyUserVideoRating(server.url, 'fake_token', videoId, 401)
693 it('Should fail with an incorrect video uuid', async function () {
694 await getMyUserVideoRating(server.url, server.accessToken, 'blabla', 400)
697 it('Should fail with an unknown video', async function () {
698 await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
701 it('Should succeed with the correct parameters', async function () {
702 await getMyUserVideoRating(server.url, server.accessToken, videoId)
706 describe('When retrieving my global ratings', function () {
707 const path = '/api/v1/accounts/user1/ratings'
709 it('Should fail with a bad start pagination', async function () {
710 await checkBadStartPagination(server.url, path, userAccessToken)
713 it('Should fail with a bad count pagination', async function () {
714 await checkBadCountPagination(server.url, path, userAccessToken)
717 it('Should fail with an incorrect sort', async function () {
718 await checkBadSortPagination(server.url, path, userAccessToken)
721 it('Should fail with a unauthenticated user', async function () {
722 await makeGetRequest({ url: server.url, path, statusCodeExpected: 401 })
725 it('Should fail with a another user', async function () {
726 await makeGetRequest({ url: server.url, path, token: server.accessToken, statusCodeExpected: 403 })
729 it('Should fail with a bad type', async function () {
730 await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { rating: 'toto ' }, statusCodeExpected: 400 })
733 it('Should succeed with the correct params', async function () {
734 await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 200 })
738 describe('When blocking/unblocking/removing user', function () {
739 it('Should fail with an incorrect id', async function () {
740 await removeUser(server.url, 'blabla', server.accessToken, 400)
741 await blockUser(server.url, 'blabla', server.accessToken, 400)
742 await unblockUser(server.url, 'blabla', server.accessToken, 400)
745 it('Should fail with the root user', async function () {
746 await removeUser(server.url, rootId, server.accessToken, 400)
747 await blockUser(server.url, rootId, server.accessToken, 400)
748 await unblockUser(server.url, rootId, server.accessToken, 400)
751 it('Should return 404 with a non existing id', async function () {
752 await removeUser(server.url, 4545454, server.accessToken, 404)
753 await blockUser(server.url, 4545454, server.accessToken, 404)
754 await unblockUser(server.url, 4545454, server.accessToken, 404)
757 it('Should fail with a non admin user', async function () {
758 await removeUser(server.url, userId, userAccessToken, 403)
759 await blockUser(server.url, userId, userAccessToken, 403)
760 await unblockUser(server.url, userId, userAccessToken, 403)
763 it('Should fail on a moderator with a moderator', async function () {
764 await removeUser(server.url, moderatorId, moderatorAccessToken, 403)
765 await blockUser(server.url, moderatorId, moderatorAccessToken, 403)
766 await unblockUser(server.url, moderatorId, moderatorAccessToken, 403)
769 it('Should succeed on a user with a moderator', async function () {
770 await blockUser(server.url, userId, moderatorAccessToken)
771 await unblockUser(server.url, userId, moderatorAccessToken)
775 describe('When deleting our account', function () {
776 it('Should fail with with the root account', async function () {
777 await deleteMe(server.url, server.accessToken, 400)
781 describe('When registering a new user', function () {
782 const registrationPath = path + '/register'
783 const baseCorrectParams = {
785 displayName: 'super user',
786 email: 'test3@example.com',
787 password: 'my super password'
790 it('Should fail with a too small username', async function () {
791 const fields = immutableAssign(baseCorrectParams, { username: '' })
793 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
796 it('Should fail with a too long username', async function () {
797 const fields = immutableAssign(baseCorrectParams, { username: 'super'.repeat(50) })
799 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
802 it('Should fail with an incorrect username', async function () {
803 const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
805 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
808 it('Should fail with a missing email', async function () {
809 const fields = omit(baseCorrectParams, 'email')
811 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
814 it('Should fail with an invalid email', async function () {
815 const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
817 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
820 it('Should fail with a too small password', async function () {
821 const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
823 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
826 it('Should fail with a too long password', async function () {
827 const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
829 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
832 it('Should fail if we register a user with the same username', async function () {
833 const fields = immutableAssign(baseCorrectParams, { username: 'root' })
835 await makePostBodyRequest({
837 path: registrationPath,
838 token: server.accessToken,
840 statusCodeExpected: 409
844 it('Should fail with a "peertube" username', async function () {
845 const fields = immutableAssign(baseCorrectParams, { username: 'peertube' })
847 await makePostBodyRequest({
849 path: registrationPath,
850 token: server.accessToken,
852 statusCodeExpected: 409
856 it('Should fail if we register a user with the same email', async function () {
857 const fields = immutableAssign(baseCorrectParams, { email: 'admin' + server.internalServerNumber + '@example.com' })
859 await makePostBodyRequest({
861 path: registrationPath,
862 token: server.accessToken,
864 statusCodeExpected: 409
868 it('Should fail with a bad display name', async function () {
869 const fields = immutableAssign(baseCorrectParams, { displayName: 'a'.repeat(150) })
871 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
874 it('Should fail with a bad channel name', async function () {
875 const fields = immutableAssign(baseCorrectParams, { channel: { name: '[]azf', displayName: 'toto' } })
877 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
880 it('Should fail with a bad channel display name', async function () {
881 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'toto', displayName: '' } })
883 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
886 it('Should fail with a channel name that is the same than user username', async function () {
887 const source = { username: 'super_user', channel: { name: 'super_user', displayName: 'display name' } }
888 const fields = immutableAssign(baseCorrectParams, source)
890 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
893 it('Should fail with an existing channel', async function () {
894 const videoChannelAttributesArg = { name: 'existing_channel', displayName: 'hello', description: 'super description' }
895 await addVideoChannel(server.url, server.accessToken, videoChannelAttributesArg)
897 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'existing_channel', displayName: 'toto' } })
899 await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields, statusCodeExpected: 409 })
902 it('Should succeed with the correct params', async function () {
903 const fields = immutableAssign(baseCorrectParams, { channel: { name: 'super_channel', displayName: 'toto' } })
905 await makePostBodyRequest({
907 path: registrationPath,
908 token: server.accessToken,
910 statusCodeExpected: 204
914 it('Should fail on a server with registration disabled', async function () {
917 email: 'test4@example.com',
918 password: 'my super password 4'
921 await makePostBodyRequest({
922 url: serverWithRegistrationDisabled.url,
923 path: registrationPath,
924 token: serverWithRegistrationDisabled.accessToken,
926 statusCodeExpected: 403
931 describe('When registering multiple users on a server with users limit', function () {
932 it('Should fail when after 3 registrations', async function () {
933 await registerUser(server.url, 'user42', 'super password', 403)
937 describe('When having a video quota', function () {
938 it('Should fail with a user having too many videos', async function () {
942 accessToken: server.accessToken,
946 await uploadVideo(server.url, server.accessToken, {}, 403)
949 it('Should fail with a registered user having too many videos', async function () {
954 password: 'my super password'
956 userAccessToken = await userLogin(server, user)
958 const videoAttributes = { fixture: 'video_short2.webm' }
959 await uploadVideo(server.url, userAccessToken, videoAttributes)
960 await uploadVideo(server.url, userAccessToken, videoAttributes)
961 await uploadVideo(server.url, userAccessToken, videoAttributes)
962 await uploadVideo(server.url, userAccessToken, videoAttributes)
963 await uploadVideo(server.url, userAccessToken, videoAttributes)
964 await uploadVideo(server.url, userAccessToken, videoAttributes, 403)
967 it('Should fail to import with HTTP/Torrent/magnet', async function () {
970 const baseAttributes = {
972 privacy: VideoPrivacy.PUBLIC
974 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() }))
975 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
976 await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' }))
978 await waitJobs([ server ])
980 const res = await getMyVideoImports(server.url, server.accessToken)
982 expect(res.body.total).to.equal(3)
983 const videoImports: VideoImport[] = res.body.data
984 expect(videoImports).to.have.lengthOf(3)
986 for (const videoImport of videoImports) {
987 expect(videoImport.state.id).to.equal(VideoImportState.FAILED)
988 expect(videoImport.error).not.to.be.undefined
989 expect(videoImport.error).to.contain('user video quota is exceeded')
994 describe('When having a daily video quota', function () {
995 it('Should fail with a user having too many videos', async function () {
999 accessToken: server.accessToken,
1003 await uploadVideo(server.url, server.accessToken, {}, 403)
1007 describe('When having an absolute and daily video quota', function () {
1008 it('Should fail if exceeding total quota', async function () {
1012 accessToken: server.accessToken,
1014 videoQuotaDaily: 1024 * 1024 * 1024
1017 await uploadVideo(server.url, server.accessToken, {}, 403)
1020 it('Should fail if exceeding daily quota', async function () {
1024 accessToken: server.accessToken,
1025 videoQuota: 1024 * 1024 * 1024,
1029 await uploadVideo(server.url, server.accessToken, {}, 403)
1033 describe('When asking a password reset', function () {
1034 const path = '/api/v1/users/ask-reset-password'
1036 it('Should fail with a missing email', async function () {
1039 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1042 it('Should fail with an invalid email', async function () {
1043 const fields = { email: 'hello' }
1045 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1048 it('Should success with the correct params', async function () {
1049 const fields = { email: 'admin@example.com' }
1051 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
1055 describe('When asking for an account verification email', function () {
1056 const path = '/api/v1/users/ask-send-verify-email'
1058 it('Should fail with a missing email', async function () {
1061 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1064 it('Should fail with an invalid email', async function () {
1065 const fields = { email: 'hello' }
1067 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
1070 it('Should succeed with the correct params', async function () {
1071 const fields = { email: 'admin@example.com' }
1073 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
1077 after(async function () {
1078 await cleanupTests([ server, serverWithRegistrationDisabled ])