interesting
/
PeerTube
mirror of https://github.com/Chocobozzz/PeerTube.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Improve check users parameters tests

This commit is contained in:
Chocobozzz 2017-12-28 15:25:31 +01:00
parent 331128ed35
commit 26d21b7867
No known key found for this signature in database
GPG Key ID: 583A612D890159BE
5 changed files with 170 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
server/tests/api/check-params/services.ts
View File

@ -102,7 +102,6 @@ function checkParamEmbed (server: ServerInfo, embedUrl: string, statusCodeExpect
url: server.url, url: server.url,
path, path,
query: Object.assign(query, { url: embedUrl }), query: Object.assign(query, { url: embedUrl }),
token: server.accessToken,
statusCodeExpected statusCodeExpected
}) })
} }

423
server/tests/api/check-params/users.ts
View File

@ -1,25 +1,15 @@
/* tslint:disable:no-unused-expression */ /* tslint:disable:no-unused-expression */
import * as request from 'supertest' import { omit } from 'lodash'
import 'mocha' import 'mocha'
import { UserRole } from '../../../../shared'
import { import {
ServerInfo, createUser, flushTests, getMyUserInformation, getMyUserVideoRating, getUsersList, immutableAssign, killallServers, makeGetRequest,
flushTests, makePostBodyRequest, makePutBodyRequest, registerUser, removeUser, runServer, ServerInfo, setAccessTokensToServers, updateUser,
runServer, uploadVideo, userLogin
uploadVideo,
getVideosList,
makePutBodyRequest,
createUser,
serverLogin,
getUsersList,
registerUser,
setAccessTokensToServers,
killallServers,
makePostBodyRequest,
userLogin
} from '../../utils' } from '../../utils'
import { UserRole } from '../../../../shared' import { checkBadCountPagination, checkBadSortPagination, checkBadStartPagination } from '../../utils/requests/check-api-params'
describe('Test users API validators', function () { describe('Test users API validators', function () {
const path = '/api/v1/users/' const path = '/api/v1/users/'
@ -42,269 +32,169 @@ describe('Test users API validators', function () {
await setAccessTokensToServers([ server ]) await setAccessTokensToServers([ server ])
const username = 'user1'
const password = 'my super password'
const videoQuota = 42000000
await createUser(server.url, server.accessToken, username, password, videoQuota)
const videoAttributes = {}
await uploadVideo(server.url, server.accessToken, videoAttributes)
const res = await getVideosList(server.url)
const videos = res.body.data
videoId = videos[0].id
const user = { const user = {
username: 'user1', username: 'user1',
password: 'my super password' password: 'my super password'
} }
const videoQuota = 42000000
await createUser(server.url, server.accessToken, user.username, user.password, videoQuota)
userAccessToken = await userLogin(server, user) userAccessToken = await userLogin(server, user)
const res = await uploadVideo(server.url, server.accessToken, {})
videoId = res.body.video.id
}) })
describe('When listing users', function () { describe('When listing users', function () {
it('Should fail with a bad start pagination', async function () { it('Should fail with a bad start pagination', async function () {
await request(server.url) await checkBadStartPagination(server.url, path, server.accessToken)
.get(path)
.query({ start: 'hello' })
.set('Accept', 'application/json')
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(400)
}) })
it('Should fail with a bad count pagination', async function () { it('Should fail with a bad count pagination', async function () {
await request(server.url) await checkBadCountPagination(server.url, path, server.accessToken)
.get(path)
.query({ count: 'hello' })
.set('Accept', 'application/json')
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(400)
}) })
it('Should fail with an incorrect sort', async function () { it('Should fail with an incorrect sort', async function () {
await request(server.url) await checkBadSortPagination(server.url, path, server.accessToken)
.get(path)
.query({ sort: 'hello' })
.set('Accept', 'application/json')
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(400)
}) })
it('Should fail with a non authenticated user', async function () { it('Should fail with a non authenticated user', async function () {
await request(server.url) await makeGetRequest({
.get(path) url: server.url,
.set('Accept', 'application/json') path,
.expect(401) statusCodeExpected: 401
})
}) })
it('Should fail with a non admin user', async function () { it('Should fail with a non admin user', async function () {
await request(server.url) await makeGetRequest({
.get(path) url: server.url,
.set('Accept', 'application/json') path,
.set('Authorization', 'Bearer ' + userAccessToken) token: userAccessToken,
.expect(403) statusCodeExpected: 403
})
}) })
}) })
describe('When adding a new user', function () { describe('When adding a new user', function () {
const baseCorrectParams = {
username: 'user2',
email: 'test@example.com',
password: 'my super password',
videoQuota: -1,
role: UserRole.USER
}
it('Should fail with a too small username', async function () { it('Should fail with a too small username', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { username: 'fi' })
username: 'ji',
email: 'test@example.com',
password: 'my_super_password',
role: UserRole.USER,
videoQuota: 42000000
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail with a too long username', async function () { it('Should fail with a too long username', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { username: 'my_super_username_which_is_very_long' })
username: 'my_super_username_which_is_very_long',
email: 'test@example.com',
password: 'my_super_password',
videoQuota: 42000000,
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail with a not lowercase username', async function () { it('Should fail with a not lowercase username', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { username: 'Toto' })
username: 'Toto',
email: 'test@example.com',
password: 'my_super_password',
videoQuota: 42000000,
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail with an incorrect username', async function () { it('Should fail with an incorrect username', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
username: 'my username',
email: 'test@example.com',
password: 'my_super_password',
videoQuota: 42000000,
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail with a missing email', async function () { it('Should fail with a missing email', async function () {
const fields = { const fields = omit(baseCorrectParams, 'email')
username: 'ji',
password: 'my_super_password',
videoQuota: 42000000,
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail with an invalid email', async function () { it('Should fail with an invalid email', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
username: 'my_super_username_which_is_very_long',
email: 'test_example.com',
password: 'my_super_password',
videoQuota: 42000000,
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail with a too small password', async function () { it('Should fail with a too small password', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
username: 'my_username',
email: 'test@example.com',
password: 'bla',
videoQuota: 42000000,
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail with a too long password', async function () { it('Should fail with a too long password', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
username: 'my_username',
email: 'test@example.com',
password: 'my super long password which is very very very very very very very very very very very very very very' +
'very very very very very very very very very very very very very very very veryv very very very very' +
'very very very very very very very very very very very very very very very very very very very very long',
videoQuota: 42000000,
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail with an non authenticated user', async function () { it('Should fail with an non authenticated user', async function () {
const fields = { await makePostBodyRequest({
username: 'my_username', url: server.url,
email: 'test@example.com', path,
password: 'my super password', token: 'super token',
videoQuota: 42000000, fields: baseCorrectParams,
role: UserRole.USER statusCodeExpected: 401
} })
await makePostBodyRequest({ url: server.url, path, token: 'super token', fields, statusCodeExpected: 401 })
}) })
it('Should fail if we add a user with the same username', async function () { it('Should fail if we add a user with the same username', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { username: 'user1' })
username: 'user1',
email: 'test@example.com',
password: 'my super password',
videoQuota: 42000000,
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 })
}) })
it('Should fail if we add a user with the same email', async function () { it('Should fail if we add a user with the same email', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { email: 'user1@example.com' })
username: 'my_username',
email: 'user1@example.com',
password: 'my super password',
videoQuota: 42000000,
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 409 })
}) })
it('Should fail without a videoQuota', async function () { it('Should fail without a videoQuota', async function () {
const fields = { const fields = omit(baseCorrectParams, 'videoQuota')
username: 'my_username',
email: 'user1@example.com',
password: 'my super password',
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail with an invalid videoQuota', async function () { it('Should fail with an invalid videoQuota', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { videoQuota: -5 })
username: 'my_username',
email: 'user1@example.com',
password: 'my super password',
videoQuota: -5,
role: UserRole.USER
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail without a user role', async function () { it('Should fail without a user role', async function () {
const fields = { const fields = omit(baseCorrectParams, 'role')
username: 'my_username',
email: 'user1@example.com',
password: 'my super password',
videoQuota: 0
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should fail with an invalid user role', async function () { it('Should fail with an invalid user role', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { role: 88989 })
username: 'my_username',
email: 'user1@example.com',
password: 'my super password',
videoQuota: 0,
role: 88989
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
}) })
it('Should succeed with the correct params', async function () { it('Should succeed with the correct params', async function () {
const fields = { await makePostBodyRequest({
username: 'user2', url: server.url,
email: 'test@example.com', path,
password: 'my super password', token: server.accessToken,
videoQuota: -1, fields: baseCorrectParams,
role: UserRole.USER statusCodeExpected: 204
} })
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
}) })
it('Should fail with a non admin user', async function () { it('Should fail with a non admin user', async function () {
server.user = { const user = {
username: 'user1', username: 'user1',
email: 'test@example.com',
password: 'my super password' password: 'my super password'
} }
userAccessToken = await userLogin(server, user)
userAccessToken = await serverLogin(server)
const fields = { const fields = {
username: 'user3', username: 'user3',
email: 'test@example.com', email: 'test@example.com',
@ -334,9 +224,7 @@ describe('Test users API validators', function () {
it('Should fail with a too long password', async function () { it('Should fail with a too long password', async function () {
const fields = { const fields = {
password: 'my super long password which is very very very very very very very very very very very very very very' + password: 'super'.repeat(61)
'very very very very very very very very very very very very very very very veryv very very very very' +
'very very very very very very very very very very very very very very very very very very very very long'
} }
await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields }) await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
@ -432,204 +320,128 @@ describe('Test users API validators', function () {
describe('When getting my information', function () { describe('When getting my information', function () {
it('Should fail with a non authenticated user', async function () { it('Should fail with a non authenticated user', async function () {
await request(server.url) await getMyUserInformation(server.url, 'fake_token', 401)
.get(path + 'me')
.set('Authorization', 'Bearer fake_token')
.set('Accept', 'application/json')
.expect(401)
}) })
it('Should success with the correct parameters', async function () { it('Should success with the correct parameters', async function () {
await request(server.url) await getMyUserInformation(server.url, userAccessToken)
.get(path + 'me')
.set('Authorization', 'Bearer ' + userAccessToken)
.set('Accept', 'application/json')
.expect(200)
}) })
}) })
describe('When getting my video rating', function () { describe('When getting my video rating', function () {
it('Should fail with a non authenticated user', async function () { it('Should fail with a non authenticated user', async function () {
await request(server.url) await getMyUserVideoRating(server.url, 'fake_token', videoId, 401)
.get(path + 'me/videos/' + videoId + '/rating')
.set('Authorization', 'Bearer fake_token')
.set('Accept', 'application/json')
.expect(401)
}) })
it('Should fail with an incorrect video uuid', async function () { it('Should fail with an incorrect video uuid', async function () {
await request(server.url) await getMyUserVideoRating(server.url, server.accessToken, 'blabla', 400)
.get(path + 'me/videos/blabla/rating')
.set('Authorization', 'Bearer ' + userAccessToken)
.set('Accept', 'application/json')
.expect(400)
}) })
it('Should fail with an unknown video', async function () { it('Should fail with an unknown video', async function () {
await request(server.url) await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', 404)
.get(path + 'me/videos/4da6fde3-88f7-4d16-b119-108df5630b06/rating')
.set('Authorization', 'Bearer ' + userAccessToken)
.set('Accept', 'application/json')
.expect(404)
}) })
it('Should success with the correct parameters', async function () { it('Should succeed with the correct parameters', async function () {
await request(server.url) await getMyUserVideoRating(server.url, server.accessToken, videoId)
.get(path + 'me/videos/' + videoId + '/rating')
.set('Authorization', 'Bearer ' + userAccessToken)
.set('Accept', 'application/json')
.expect(200)
}) })
}) })
describe('When removing an user', function () { describe('When removing an user', function () {
it('Should fail with an incorrect id', async function () { it('Should fail with an incorrect id', async function () {
await request(server.url) await removeUser(server.url, 'blabla', server.accessToken, 400)
.delete(path + 'bla-bla')
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(400)
}) })
it('Should fail with the root user', async function () { it('Should fail with the root user', async function () {
await request(server.url) await removeUser(server.url, rootId, server.accessToken, 400)
.delete(path + rootId)
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(400)
}) })
it('Should return 404 with a non existing id', async function () { it('Should return 404 with a non existing id', async function () {
await request(server.url) await removeUser(server.url, 4545454, server.accessToken, 404)
.delete(path + '45')
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(404)
})
})
describe('When removing an user', function () {
it('Should fail with an incorrect id', async function () {
await request(server.url)
.delete(path + 'bla-bla')
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(400)
})
it('Should fail with the root user', async function () {
await request(server.url)
.delete(path + rootId)
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(400)
})
it('Should return 404 with a non existing id', async function () {
await request(server.url)
.delete(path + '45')
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(404)
}) })
}) })
describe('When register a new user', function () { describe('When register a new user', function () {
const registrationPath = path + '/register' const registrationPath = path + '/register'
const baseCorrectParams = {
username: 'user3',
email: 'test3@example.com',
password: 'my super password'
}
it('Should fail with a too small username', async function () { it('Should fail with a too small username', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { username: 'ji' })
username: 'ji',
email: 'test@example.com',
password: 'my_super_password'
}
await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
}) })
it('Should fail with a too long username', async function () { it('Should fail with a too long username', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { username: 'my_super_username_which_is_very_long' })
username: 'my_super_username_which_is_very_long',
email: 'test@example.com',
password: 'my_super_password'
}
await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
}) })
it('Should fail with an incorrect username', async function () { it('Should fail with an incorrect username', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { username: 'my username' })
username: 'my username',
email: 'test@example.com',
password: 'my_super_password'
}
await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
}) })
it('Should fail with a missing email', async function () { it('Should fail with a missing email', async function () {
const fields = { const fields = omit(baseCorrectParams, 'email')
username: 'ji',
password: 'my_super_password'
}
await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
}) })
it('Should fail with an invalid email', async function () { it('Should fail with an invalid email', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { email: 'test_example.com' })
username: 'my_super_username_which_is_very_long',
email: 'test_example.com',
password: 'my_super_password'
}
await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
}) })
it('Should fail with a too small password', async function () { it('Should fail with a too small password', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { password: 'bla' })
username: 'my_username',
email: 'test@example.com',
password: 'bla'
}
await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
}) })
it('Should fail with a too long password', async function () { it('Should fail with a too long password', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { password: 'super'.repeat(61) })
username: 'my_username',
email: 'test@example.com',
password: 'my super long password which is very very very very very very very very very very very very very very' +
'very very very very very very very very very very very very very very very veryv very very very very' +
'very very very very very very very very very very very very very very very very very very very very long'
}
await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields }) await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields })
}) })
it('Should fail if we register a user with the same username', async function () { it('Should fail if we register a user with the same username', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { username: 'root' })
username: 'root',
email: 'test@example.com',
password: 'my super password'
}
await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields, statusCodeExpected: 409 }) await makePostBodyRequest({
url: server.url,
path: registrationPath,
token: server.accessToken,
fields,
statusCodeExpected: 409
})
}) })
it('Should fail if we register a user with the same email', async function () { it('Should fail if we register a user with the same email', async function () {
const fields = { const fields = immutableAssign(baseCorrectParams, { email: 'admin1@example.com' })
username: 'my_username',
email: 'admin1@example.com',
password: 'my super password'
}
await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields, statusCodeExpected: 409 }) await makePostBodyRequest({
url: server.url,
path: registrationPath,
token: server.accessToken,
fields,
statusCodeExpected: 409
})
}) })
it('Should succeed with the correct params', async function () { it('Should succeed with the correct params', async function () {
const fields = { await makePostBodyRequest({
username: 'user3', url: server.url,
email: 'test3@example.com', path: registrationPath,
password: 'my super password' token: server.accessToken,
} fields: baseCorrectParams,
statusCodeExpected: 204
await makePostBodyRequest({ url: server.url, path: registrationPath, token: server.accessToken, fields, statusCodeExpected: 204 }) })
}) })
it('Should fail on a server with registration disabled', async function () { it('Should fail on a server with registration disabled', async function () {
@ -657,25 +469,24 @@ describe('Test users API validators', function () {
describe('When having a video quota', function () { describe('When having a video quota', function () {
it('Should fail with a user having too many video', async function () { it('Should fail with a user having too many video', async function () {
const fields = { await updateUser({
url: server.url,
userId: rootId,
accessToken: server.accessToken,
videoQuota: 42 videoQuota: 42
} })
await makePutBodyRequest({ url: server.url, path: path + rootId, token: server.accessToken, fields, statusCodeExpected: 204 }) await uploadVideo(server.url, server.accessToken, {}, 403)
const videoAttributes = {}
await uploadVideo(server.url, server.accessToken, videoAttributes, 403)
}) })
it('Should fail with a registered user having too many video', async function () { it('Should fail with a registered user having too many video', async function () {
this.timeout(10000) this.timeout(10000)
server.user = { const user = {
username: 'user3', username: 'user3',
email: 'test3@example.com',
password: 'my super password' password: 'my super password'
} }
userAccessToken = await serverLogin(server) userAccessToken = await userLogin(server, user)
const videoAttributes = { fixture: 'video_short2.webm' } const videoAttributes = { fixture: 'video_short2.webm' }
await uploadVideo(server.url, userAccessToken, videoAttributes) await uploadVideo(server.url, userAccessToken, videoAttributes)

4
server/tests/api/users/users.ts
View File

@ -11,7 +11,7 @@ import {
getUserInformation, getUserInformation,
getUsersList, getUsersList,
getUsersListPaginationAndSort, getUsersListPaginationAndSort,
getUserVideoRating, getMyUserVideoRating,
getVideosList, getVideosList,
killallServers, killallServers,
login, login,
@ -130,7 +130,7 @@ describe('Test users', function () {
it('Should retrieve a video rating', async function () { it('Should retrieve a video rating', async function () {
await rateVideo(server.url, accessToken, videoId, 'like') await rateVideo(server.url, accessToken, videoId, 'like')
const res = await getUserVideoRating(server.url, accessToken, videoId) const res = await getMyUserVideoRating(server.url, accessToken, videoId)
const rating = res.body const rating = res.body
expect(rating.videoId) expect(rating.videoId)

7
server/tests/utils/miscs/miscs.ts
View File

@ -3,6 +3,10 @@ import { readFile, readdir } from 'fs'
let webtorrent = new WebTorrent() let webtorrent = new WebTorrent()
function immutableAssign <T, U> (target: T, source: U) {
return Object.assign<{}, T, U>({}, target, source)
}
function readFilePromise (path: string) { function readFilePromise (path: string) {
return new Promise<Buffer>((res, rej) => { return new Promise<Buffer>((res, rej) => {
readFile(path, (err, data) => { readFile(path, (err, data) => {
@ -48,5 +52,6 @@ export {
readdirPromise, readdirPromise,
dateIsValid, dateIsValid,
wait, wait,
webtorrentAdd webtorrentAdd,
immutableAssign
} }

74
server/tests/utils/users/users.ts
View File

@ -1,4 +1,5 @@
import * as request from 'supertest' import * as request from 'supertest'
import { makePutBodyRequest } from '../'
import { UserRole } from '../../../../shared/index' import { UserRole } from '../../../../shared/index'
@ -43,14 +44,14 @@ function registerUser (url: string, username: string, password: string, specialS
.expect(specialStatus) .expect(specialStatus)
} }
function getMyUserInformation (url: string, accessToken: string) { function getMyUserInformation (url: string, accessToken: string, specialStatus = 200) {
const path = '/api/v1/users/me' const path = '/api/v1/users/me'
return request(url) return request(url)
.get(path) .get(path)
.set('Accept', 'application/json') .set('Accept', 'application/json')
.set('Authorization', 'Bearer ' + accessToken) .set('Authorization', 'Bearer ' + accessToken)
.expect(200) .expect(specialStatus)
.expect('Content-Type', /json/) .expect('Content-Type', /json/)
} }
@ -65,14 +66,14 @@ function getUserInformation (url: string, accessToken: string, userId: number) {
.expect('Content-Type', /json/) .expect('Content-Type', /json/)
} }
function getUserVideoRating (url: string, accessToken: string, videoId: number) { function getMyUserVideoRating (url: string, accessToken: string, videoId: number | string, specialStatus = 200) {
const path = '/api/v1/users/me/videos/' + videoId + '/rating' const path = '/api/v1/users/me/videos/' + videoId + '/rating'
return request(url) return request(url)
.get(path) .get(path)
.set('Accept', 'application/json') .set('Accept', 'application/json')
.set('Authorization', 'Bearer ' + accessToken) .set('Authorization', 'Bearer ' + accessToken)
.expect(200) .expect(specialStatus)
.expect('Content-Type', /json/) .expect('Content-Type', /json/)
} }
@ -101,7 +102,7 @@ function getUsersListPaginationAndSort (url: string, accessToken: string, start:
.expect('Content-Type', /json/) .expect('Content-Type', /json/)
} }
function removeUser (url: string, userId: number, accessToken: string, expectedStatus = 204) { function removeUser (url: string, userId: number | string, accessToken: string, expectedStatus = 204) {
const path = '/api/v1/users' const path = '/api/v1/users'
return request(url) return request(url)
@ -111,38 +112,53 @@ function removeUser (url: string, userId: number, accessToken: string, expectedS
.expect(expectedStatus) .expect(expectedStatus)
} }
function updateMyUser (url: string, accessToken: string, newPassword: string, displayNSFW?: boolean, function updateMyUser (options: {
email?: string, autoPlayVideo?: boolean) { url: string
accessToken: string,
newPassword?: string,
displayNSFW?: boolean,
email?: string,
autoPlayVideo?: boolean
}) {
const path = '/api/v1/users/me' const path = '/api/v1/users/me'
const toSend = {} const toSend = {}
if (newPassword !== undefined && newPassword !== null) toSend['password'] = newPassword if (options.newPassword !== undefined && options.newPassword !== null) toSend['password'] = options.newPassword
if (displayNSFW !== undefined && displayNSFW !== null) toSend['displayNSFW'] = displayNSFW if (options.displayNSFW !== undefined && options.displayNSFW !== null) toSend['displayNSFW'] = options.displayNSFW
if (autoPlayVideo !== undefined && autoPlayVideo !== null) toSend['autoPlayVideo'] = autoPlayVideo if (options.autoPlayVideo !== undefined && options.autoPlayVideo !== null) toSend['autoPlayVideo'] = options.autoPlayVideo
if (email !== undefined && email !== null) toSend['email'] = email if (options.email !== undefined && options.email !== null) toSend['email'] = options.email
return request(url) return makePutBodyRequest({
.put(path) url: options.url,
.set('Accept', 'application/json') path,
.set('Authorization', 'Bearer ' + accessToken) token: options.accessToken,
.send(toSend) fields: toSend,
.expect(204) statusCodeExpected: 204
})
} }
function updateUser (url: string, userId: number, accessToken: string, email: string, videoQuota: number, role: UserRole) { function updateUser (options: {
const path = '/api/v1/users/' + userId url: string
userId: number,
accessToken: string,
email?: string,
videoQuota?: number,
role?: UserRole
}) {
const path = '/api/v1/users/' + options.userId
const toSend = {} const toSend = {}
if (email !== undefined && email !== null) toSend['email'] = email if (options.email !== undefined && options.email !== null) toSend['email'] = options.email
if (videoQuota !== undefined && videoQuota !== null) toSend['videoQuota'] = videoQuota if (options.videoQuota !== undefined && options.videoQuota !== null) toSend['videoQuota'] = options.videoQuota
if (role !== undefined && role !== null) toSend['role'] = role if (options.role !== undefined && options.role !== null) toSend['role'] = options.role
return request(url) return makePutBodyRequest({
.put(path) url: options.url,
.set('Accept', 'application/json') path,
.set('Authorization', 'Bearer ' + accessToken) token: options.accessToken,
.send(toSend) fields: toSend,
.expect(204) statusCodeExpected: 204
})
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -151,7 +167,7 @@ export {
createUser, createUser,
registerUser, registerUser,
getMyUserInformation, getMyUserInformation,
getUserVideoRating, getMyUserVideoRating,
getUsersList, getUsersList,
getUsersListPaginationAndSort, getUsersListPaginationAndSort,
removeUser, removeUser,