import { Hooks } from '@server/lib/plugins/hooks'
import { OAuthTokenModel } from '@server/models/oauth/oauth-token'
import { MUser, MUserAccountDefault } from '@server/types/models'
-import { UserCreate, UserRight, UserRole, UserUpdate } from '../../../../shared'
+import { UserCreate, UserCreateResult, UserRight, UserRole, UserUpdate } from '../../../../shared'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
import { UserRegister } from '../../../../shared/models/users/user-register.model'
account: {
id: account.id
}
- }
+ } as UserCreateResult
})
}
import * as chai from 'chai'
import {
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
getVideosListSort,
const user = { username: 'user1', password: 'password' }
for (const server of servers) {
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
}
const userAccessToken = await servers[0].loginCommand.getAccessToken(user)
cleanupTests,
doubleFollow,
flushAndRunMultipleServers,
- generateUserAccessToken,
getVideo,
killallServers,
reRunServer,
}
{
- const a1 = await generateUserAccessToken(servers[1], 'user1')
+ const a1 = await servers[1].usersCommand.generateUserAndToken('user1')
await uploadVideo(servers[1].url, a1, { name: 'video4' })
- const a2 = await generateUserAccessToken(servers[1], 'user2')
+ const a2 = await servers[1].usersCommand.generateUserAndToken('user2')
await uploadVideo(servers[1].url, a2, { name: 'video5' })
}
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- createUser,
doubleFollow,
flushAndRunServer,
- generateUserAccessToken,
getVideoIdFromUUID,
makeGetRequest,
makePostBodyRequest,
const username = 'user1'
const password = 'my super password'
- await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
+ await server.usersCommand.create({ username: username, password: password })
userToken = await server.loginCommand.getAccessToken({ username, password })
- userToken2 = await generateUserAccessToken(server, 'user_2')
+ userToken2 = await server.usersCommand.generateUserAndToken('user_2')
const res = await uploadVideo(server.url, server.accessToken, {})
server.video = res.body.video
import {
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
makeDeleteRequest,
server = servers[0]
const user = { username: 'user1', password: 'password' }
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
import 'mocha'
import {
cleanupTests,
- createUser,
flushAndRunServer,
ServerInfo,
setAccessTokensToServers
await setAccessTokensToServers([ server ])
const user = { username: 'user1', password: 'password' }
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
})
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- createUser,
flushAndRunServer,
makeDeleteRequest,
makeGetRequest,
username: 'user1',
password: 'password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
})
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
cleanupTests,
- createUser,
flushAndRunServer,
ServerInfo,
setAccessTokensToServers
await setAccessTokensToServers([ server ])
const user = { username: 'user1', password: 'password' }
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
})
import {
cleanupTests,
- createUser,
flushAndRunServer,
ServerInfo,
setAccessTokensToServers
username: 'user1',
password: 'my super password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
})
import {
cleanupTests,
- createUser,
flushAndRunServer,
makeDeleteRequest, makeGetRequest,
makePostBodyRequest,
password: 'password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
})
import {
cleanupTests,
- createUser,
flushAndRunServer,
ServerInfo,
setAccessTokensToServers
username: 'user1',
password: 'my super password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
})
import 'mocha'
import { omit } from 'lodash'
-import { VideoCreateResult, VideoPrivacy } from '@shared/models'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '@shared/core-utils'
import {
buildAbsoluteFixturePath,
cleanupTests,
- createUser,
flushAndRunServer,
- getMyUserInformation,
LiveCommand,
makePostBodyRequest,
makeUploadRequest,
setAccessTokensToServers,
stopFfmpeg,
uploadVideoAndGetId
-} from '../../../../shared/extra-utils'
+} from '@shared/extra-utils'
+import { VideoCreateResult, VideoPrivacy } from '@shared/models'
describe('Test video lives API validator', function () {
const path = '/api/v1/videos/live'
const username = 'user1'
const password = 'my super password'
- await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
+ await server.usersCommand.create({ username: username, password: password })
userAccessToken = await server.loginCommand.getAccessToken({ username, password })
{
- const res = await getMyUserInformation(server.url, server.accessToken)
- channelId = res.body.videoChannels[0].id
+ const { videoChannels } = await server.usersCommand.getMyInfo()
+ channelId = videoChannels[0].id
}
{
username: 'fake',
password: 'fake_password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
const accessTokenUser = await server.loginCommand.getAccessToken(user)
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const customChannelId = res.body.videoChannels[0].id
+ const { videoChannels } = await server.usersCommand.getMyInfo({ token: accessTokenUser })
+ const customChannelId = videoChannels[0].id
const fields = { ...baseCorrectParams, channelId: customChannelId }
import {
cleanupTests,
- createUser,
flushAndRunServer,
ServerInfo,
setAccessTokensToServers
username: 'user1',
password: 'my super password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
})
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- createUser,
flushAndRunServer,
makeGetRequest,
makePostBodyRequest,
password: 'password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
{
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
getVideo,
password: 'password'
}
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+ await servers[0].usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await servers[0].loginCommand.getAccessToken(user)
videoIdLocal = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video' })).id
import 'mocha'
import { expect } from 'chai'
import { HttpStatusCode, randomInt } from '@shared/core-utils'
-import { MyUser, VideoImportState, VideoPrivacy } from '@shared/models'
+import { VideoImportState, VideoPrivacy } from '@shared/models'
import {
cleanupTests,
flushAndRunServer,
- getMyUserInformation,
ImportsCommand,
- registerUser,
ServerInfo,
setAccessTokensToServers,
setDefaultVideoChannel,
- updateUser,
uploadVideo,
waitJobs
} from '../../../../shared/extra-utils'
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
- const res = await getMyUserInformation(server.url, server.accessToken)
- rootId = (res.body as MyUser).id
+ const user = await server.usersCommand.getMyInfo()
+ rootId = user.id
- await updateUser({
- url: server.url,
- userId: rootId,
- accessToken: server.accessToken,
- videoQuota: 42
- })
+ await server.usersCommand.update({ userId: rootId, videoQuota: 42 })
})
describe('When having a video quota', function () {
this.timeout(30000)
const user = { username: 'registered' + randomInt(1, 1500), password: 'password' }
- await registerUser(server.url, user.username, user.password)
+ await server.usersCommand.register(user)
const userAccessToken = await server.loginCommand.getAccessToken(user)
const videoAttributes = { fixture: 'video_short2.webm' }
this.timeout(30000)
const user = { username: 'registered' + randomInt(1, 1500), password: 'password' }
- await registerUser(server.url, user.username, user.password)
+ await server.usersCommand.register(user)
const userAccessToken = await server.loginCommand.getAccessToken(user)
const videoAttributes = { fixture: 'video_short2.webm' }
describe('When having a daily video quota', function () {
it('Should fail with a user having too many videos daily', async function () {
- await updateUser({
- url: server.url,
- userId: rootId,
- accessToken: server.accessToken,
- videoQuotaDaily: 42
- })
+ await server.usersCommand.update({ userId: rootId, videoQuotaDaily: 42 })
await uploadVideo(server.url, server.accessToken, {}, HttpStatusCode.PAYLOAD_TOO_LARGE_413, 'legacy')
await uploadVideo(server.url, server.accessToken, {}, HttpStatusCode.PAYLOAD_TOO_LARGE_413, 'resumable')
describe('When having an absolute and daily video quota', function () {
it('Should fail if exceeding total quota', async function () {
- await updateUser({
- url: server.url,
+ await server.usersCommand.update({
userId: rootId,
- accessToken: server.accessToken,
videoQuota: 42,
videoQuotaDaily: 1024 * 1024 * 1024
})
})
it('Should fail if exceeding daily quota', async function () {
- await updateUser({
- url: server.url,
+ await server.usersCommand.update({
userId: rootId,
- accessToken: server.accessToken,
videoQuota: 1024 * 1024 * 1024,
videoQuotaDaily: 42
})
import {
cleanupTests,
- createUser,
flushAndRunServer,
makeDeleteRequest,
makeGetRequest,
username: 'user1',
password: 'my super password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
})
import 'mocha'
import { omit } from 'lodash'
-import { User, UserRole, VideoCreateResult } from '../../../../shared'
+import { UserRole, VideoCreateResult } from '../../../../shared'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
- blockUser,
buildAbsoluteFixturePath,
cleanupTests,
- createUser,
- deleteMe,
flushAndRunServer,
- getMyUserInformation,
- getMyUserVideoRating,
- getUserScopedTokens,
- getUsersList,
killallServers,
makeGetRequest,
makePostBodyRequest,
makePutBodyRequest,
makeUploadRequest,
- registerUser,
- removeUser,
- renewUserScopedTokens,
reRunServer,
ServerInfo,
setAccessTokensToServers,
- unblockUser,
- uploadVideo
+ uploadVideo,
+ UsersCommand
} from '../../../../shared/extra-utils'
import { MockSmtpServer } from '../../../../shared/extra-utils/mock-servers/mock-email'
import {
let video: VideoCreateResult
let server: ServerInfo
let serverWithRegistrationDisabled: ServerInfo
- let userAccessToken = ''
- let moderatorAccessToken = ''
+ let userToken = ''
+ let moderatorToken = ''
let emailPort: number
let overrideConfig: Object
}
{
- const user = {
- username: 'user1',
- password: 'my super password'
- }
-
- const videoQuota = 42000000
- await createUser({
- url: server.url,
- accessToken: server.accessToken,
- username: user.username,
- password: user.password,
- videoQuota: videoQuota
- })
- userAccessToken = await server.loginCommand.getAccessToken(user)
+ const user = { username: 'user1' }
+ await server.usersCommand.create({ ...user })
+ userToken = await server.loginCommand.getAccessToken(user)
}
{
- const moderator = {
- username: 'moderator1',
- password: 'super password'
- }
-
- await createUser({
- url: server.url,
- accessToken: server.accessToken,
- username: moderator.username,
- password: moderator.password,
- role: UserRole.MODERATOR
- })
-
- moderatorAccessToken = await server.loginCommand.getAccessToken(moderator)
+ const moderator = { username: 'moderator1' }
+ await server.usersCommand.create({ ...moderator, role: UserRole.MODERATOR })
+ moderatorToken = await server.loginCommand.getAccessToken(moderator)
}
{
- const moderator = {
- username: 'moderator2',
- password: 'super password'
- }
-
- await createUser({
- url: server.url,
- accessToken: server.accessToken,
- username: moderator.username,
- password: moderator.password,
- role: UserRole.MODERATOR
- })
+ const moderator = { username: 'moderator2' }
+ await server.usersCommand.create({ ...moderator, role: UserRole.MODERATOR })
}
{
}
{
- const res = await getUsersList(server.url, server.accessToken)
- const users: User[] = res.body.data
-
- userId = users.find(u => u.username === 'user1').id
- rootId = users.find(u => u.username === 'root').id
- moderatorId = users.find(u => u.username === 'moderator2').id
+ const { data } = await server.usersCommand.list()
+ userId = data.find(u => u.username === 'user1').id
+ rootId = data.find(u => u.username === 'root').id
+ moderatorId = data.find(u => u.username === 'moderator2').id
}
})
await makeGetRequest({
url: server.url,
path,
- token: userAccessToken,
+ token: userToken,
statusCodeExpected: HttpStatusCode.FORBIDDEN_403
})
})
await makePostBodyRequest({
url: server.url,
path,
- token: moderatorAccessToken,
+ token: moderatorToken,
fields,
statusCodeExpected: HttpStatusCode.FORBIDDEN_403
})
await makePostBodyRequest({
url: server.url,
path,
- token: moderatorAccessToken,
+ token: moderatorToken,
fields,
statusCodeExpected: HttpStatusCode.OK_200
})
})
it('Should fail with a non admin user', async function () {
- const user = {
- username: 'user1',
- password: 'my super password'
- }
- userAccessToken = await server.loginCommand.getAccessToken(user)
+ const user = { username: 'user1' }
+ userToken = await server.loginCommand.getAccessToken(user)
const fields = {
username: 'user3',
password: 'my super password',
videoQuota: 42000000
}
- await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
+ await makePostBodyRequest({ url: server.url, path, token: userToken, fields, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
})
})
describe('When updating my account', function () {
+
it('Should fail with an invalid email attribute', async function () {
const fields = {
email: 'blabla'
it('Should fail with a too small password', async function () {
const fields = {
- currentPassword: 'my super password',
+ currentPassword: 'password',
password: 'bla'
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail with a too long password', async function () {
const fields = {
- currentPassword: 'my super password',
+ currentPassword: 'password',
password: 'super'.repeat(61)
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail without the current password', async function () {
const fields = {
- currentPassword: 'my super password',
+ currentPassword: 'password',
password: 'super'.repeat(61)
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail with an invalid current password', async function () {
await makePutBodyRequest({
url: server.url,
path: path + 'me',
- token: userAccessToken,
+ token: userToken,
fields,
statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
})
nsfwPolicy: 'hello'
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail with an invalid autoPlayVideo attribute', async function () {
autoPlayVideo: -1
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail with an invalid autoPlayNextVideo attribute', async function () {
autoPlayNextVideo: -1
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail with an invalid videosHistoryEnabled attribute', async function () {
videosHistoryEnabled: -1
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail with an non authenticated user', async function () {
const fields = {
- currentPassword: 'my super password',
+ currentPassword: 'password',
password: 'my super password'
}
description: 'super'.repeat(201)
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail with an invalid videoLanguages attribute', async function () {
videoLanguages: 'toto'
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
}
{
videoLanguages: languages
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
}
})
it('Should fail with an invalid theme', async function () {
const fields = { theme: 'invalid' }
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail with an unknown theme', async function () {
const fields = { theme: 'peertube-theme-unknown' }
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail with an invalid noInstanceConfigWarningModal attribute', async function () {
noInstanceConfigWarningModal: -1
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should fail with an invalid noWelcomeModal attribute', async function () {
noWelcomeModal: -1
}
- await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
+ await makePutBodyRequest({ url: server.url, path: path + 'me', token: userToken, fields })
})
it('Should succeed to change password with the correct params', async function () {
const fields = {
- currentPassword: 'my super password',
+ currentPassword: 'password',
password: 'my super password',
nsfwPolicy: 'blur',
autoPlayVideo: false,
await makePutBodyRequest({
url: server.url,
path: path + 'me',
- token: userAccessToken,
+ token: userToken,
fields,
statusCodeExpected: HttpStatusCode.NO_CONTENT_204
})
await makePutBodyRequest({
url: server.url,
path: path + 'me',
- token: userAccessToken,
+ token: userToken,
fields,
statusCodeExpected: HttpStatusCode.NO_CONTENT_204
})
describe('When managing my scoped tokens', function () {
it('Should fail to get my scoped tokens with an non authenticated user', async function () {
- await getUserScopedTokens(server.url, null, HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.getMyScopedTokens({ token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should fail to get my scoped tokens with a bad token', async function () {
- await getUserScopedTokens(server.url, 'bad', HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.getMyScopedTokens({ token: 'bad', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should succeed to get my scoped tokens', async function () {
- await getUserScopedTokens(server.url, server.accessToken)
+ await server.usersCommand.getMyScopedTokens()
})
it('Should fail to renew my scoped tokens with an non authenticated user', async function () {
- await renewUserScopedTokens(server.url, null, HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.renewMyScopedTokens({ token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should fail to renew my scoped tokens with a bad token', async function () {
- await renewUserScopedTokens(server.url, 'bad', HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.renewMyScopedTokens({ token: 'bad', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should succeed to renew my scoped tokens', async function () {
- await renewUserScopedTokens(server.url, server.accessToken)
+ await server.usersCommand.renewMyScopedTokens()
})
})
})
it('Should fail with a non admin user', async function () {
- await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
+ await makeGetRequest({ url: server.url, path, token: userToken, statusCodeExpected: HttpStatusCode.FORBIDDEN_403 })
})
it('Should succeed with the correct params', async function () {
it('Should fail with a too small password', async function () {
const fields = {
- currentPassword: 'my super password',
+ currentPassword: 'password',
password: 'bla'
}
it('Should fail with a too long password', async function () {
const fields = {
- currentPassword: 'my super password',
+ currentPassword: 'password',
password: 'super'.repeat(61)
}
await makePutBodyRequest({
url: server.url,
path: path + moderatorId,
- token: moderatorAccessToken,
+ token: moderatorToken,
fields,
statusCodeExpected: HttpStatusCode.FORBIDDEN_403
})
await makePutBodyRequest({
url: server.url,
path: path + userId,
- token: moderatorAccessToken,
+ token: moderatorToken,
fields,
statusCodeExpected: HttpStatusCode.NO_CONTENT_204
})
describe('When getting my information', function () {
it('Should fail with a non authenticated user', async function () {
- await getMyUserInformation(server.url, 'fake_token', HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.getMyInfo({ token: 'fake_token', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should success with the correct parameters', async function () {
- await getMyUserInformation(server.url, userAccessToken)
+ await server.usersCommand.getMyInfo({ token: userToken })
})
})
describe('When getting my video rating', function () {
+ let command: UsersCommand
+
+ before(function () {
+ command = server.usersCommand
+ })
+
it('Should fail with a non authenticated user', async function () {
- await getMyUserVideoRating(server.url, 'fake_token', video.id, HttpStatusCode.UNAUTHORIZED_401)
+ await command.getMyRating({ token: 'fake_token', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should fail with an incorrect video uuid', async function () {
- await getMyUserVideoRating(server.url, server.accessToken, 'blabla', HttpStatusCode.BAD_REQUEST_400)
+ await command.getMyRating({ videoId: 'blabla', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should fail with an unknown video', async function () {
- await getMyUserVideoRating(server.url, server.accessToken, '4da6fde3-88f7-4d16-b119-108df5630b06', HttpStatusCode.NOT_FOUND_404)
+ await command.getMyRating({ videoId: '4da6fde3-88f7-4d16-b119-108df5630b06', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
})
it('Should succeed with the correct parameters', async function () {
- await getMyUserVideoRating(server.url, server.accessToken, video.id)
- await getMyUserVideoRating(server.url, server.accessToken, video.uuid)
- await getMyUserVideoRating(server.url, server.accessToken, video.shortUUID)
+ await command.getMyRating({ videoId: video.id })
+ await command.getMyRating({ videoId: video.uuid })
+ await command.getMyRating({ videoId: video.shortUUID })
})
})
const path = '/api/v1/accounts/user1/ratings'
it('Should fail with a bad start pagination', async function () {
- await checkBadStartPagination(server.url, path, userAccessToken)
+ await checkBadStartPagination(server.url, path, userToken)
})
it('Should fail with a bad count pagination', async function () {
- await checkBadCountPagination(server.url, path, userAccessToken)
+ await checkBadCountPagination(server.url, path, userToken)
})
it('Should fail with an incorrect sort', async function () {
- await checkBadSortPagination(server.url, path, userAccessToken)
+ await checkBadSortPagination(server.url, path, userToken)
})
it('Should fail with a unauthenticated user', async function () {
await makeGetRequest({
url: server.url,
path,
- token: userAccessToken,
+ token: userToken,
query: { rating: 'toto ' },
statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
})
})
it('Should succeed with the correct params', async function () {
- await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: HttpStatusCode.OK_200 })
+ await makeGetRequest({ url: server.url, path, token: userToken, statusCodeExpected: HttpStatusCode.OK_200 })
})
})
describe('When blocking/unblocking/removing user', function () {
+
it('Should fail with an incorrect id', async function () {
- await removeUser(server.url, 'blabla', server.accessToken, HttpStatusCode.BAD_REQUEST_400)
- await blockUser(server.url, 'blabla', server.accessToken, HttpStatusCode.BAD_REQUEST_400)
- await unblockUser(server.url, 'blabla', server.accessToken, HttpStatusCode.BAD_REQUEST_400)
+ const options = { userId: 'blabla' as any, expectedStatus: HttpStatusCode.BAD_REQUEST_400 }
+
+ await server.usersCommand.remove(options)
+ await server.usersCommand.banUser({ userId: 'blabla' as any, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+ await server.usersCommand.unbanUser({ userId: 'blabla' as any, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should fail with the root user', async function () {
- await removeUser(server.url, rootId, server.accessToken, HttpStatusCode.BAD_REQUEST_400)
- await blockUser(server.url, rootId, server.accessToken, HttpStatusCode.BAD_REQUEST_400)
- await unblockUser(server.url, rootId, server.accessToken, HttpStatusCode.BAD_REQUEST_400)
+ const options = { userId: rootId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 }
+
+ await server.usersCommand.remove(options)
+ await server.usersCommand.banUser(options)
+ await server.usersCommand.unbanUser(options)
})
it('Should return 404 with a non existing id', async function () {
- await removeUser(server.url, 4545454, server.accessToken, HttpStatusCode.NOT_FOUND_404)
- await blockUser(server.url, 4545454, server.accessToken, HttpStatusCode.NOT_FOUND_404)
- await unblockUser(server.url, 4545454, server.accessToken, HttpStatusCode.NOT_FOUND_404)
+ const options = { userId: 4545454, expectedStatus: HttpStatusCode.NOT_FOUND_404 }
+
+ await server.usersCommand.remove(options)
+ await server.usersCommand.banUser(options)
+ await server.usersCommand.unbanUser(options)
})
it('Should fail with a non admin user', async function () {
- await removeUser(server.url, userId, userAccessToken, HttpStatusCode.FORBIDDEN_403)
- await blockUser(server.url, userId, userAccessToken, HttpStatusCode.FORBIDDEN_403)
- await unblockUser(server.url, userId, userAccessToken, HttpStatusCode.FORBIDDEN_403)
+ const options = { userId, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 }
+
+ await server.usersCommand.remove(options)
+ await server.usersCommand.banUser(options)
+ await server.usersCommand.unbanUser(options)
})
it('Should fail on a moderator with a moderator', async function () {
- await removeUser(server.url, moderatorId, moderatorAccessToken, HttpStatusCode.FORBIDDEN_403)
- await blockUser(server.url, moderatorId, moderatorAccessToken, HttpStatusCode.FORBIDDEN_403)
- await unblockUser(server.url, moderatorId, moderatorAccessToken, HttpStatusCode.FORBIDDEN_403)
+ const options = { userId: moderatorId, token: moderatorToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 }
+
+ await server.usersCommand.remove(options)
+ await server.usersCommand.banUser(options)
+ await server.usersCommand.unbanUser(options)
})
it('Should succeed on a user with a moderator', async function () {
- await blockUser(server.url, userId, moderatorAccessToken)
- await unblockUser(server.url, userId, moderatorAccessToken)
+ const options = { userId, token: moderatorToken }
+
+ await server.usersCommand.banUser(options)
+ await server.usersCommand.unbanUser(options)
})
})
describe('When deleting our account', function () {
it('Should fail with with the root account', async function () {
- await deleteMe(server.url, server.accessToken, HttpStatusCode.BAD_REQUEST_400)
+ await server.usersCommand.deleteMe({ expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
})
describe('When registering multiple users on a server with users limit', function () {
it('Should fail when after 3 registrations', async function () {
- await registerUser(server.url, 'user42', 'super password', HttpStatusCode.FORBIDDEN_403)
+ await server.usersCommand.register({ username: 'user42', expectedStatus: HttpStatusCode.FORBIDDEN_403 })
})
})
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
getVideo,
{
const username = 'user1'
const password = 'my super password'
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: username, password: password })
+ await servers[0].usersCommand.create({ username: username, password: password })
userAccessToken1 = await servers[0].loginCommand.getAccessToken({ username, password })
}
{
const username = 'user2'
const password = 'my super password'
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: username, password: password })
+ await servers[0].usersCommand.create({ username: username, password: password })
userAccessToken2 = await servers[0].loginCommand.getAccessToken({ username, password })
}
import {
buildAbsoluteFixturePath,
cleanupTests,
- createUser,
flushAndRunServer,
makeDeleteRequest,
makeGetRequest,
username: 'user1',
password: 'my super password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
}
})
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- createUser,
flushAndRunServer,
makeGetRequest,
makePostBodyRequest,
}
{
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
accessTokenUser = await server.loginCommand.getAccessToken(user)
}
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- createUser,
flushAndRunServer,
makeDeleteRequest,
makeGetRequest,
{
const user = { username: 'user1', password: 'my super password' }
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
}
{
const user = { username: 'user2', password: 'my super password' }
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken2 = await server.loginCommand.getAccessToken(user)
}
})
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- createUser,
flushAndRunServer,
- getMyUserInformation,
ImportsCommand,
makeGetRequest,
makePostBodyRequest,
const username = 'user1'
const password = 'my super password'
- await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
+ await server.usersCommand.create({ username: username, password: password })
userAccessToken = await server.loginCommand.getAccessToken({ username, password })
{
- const res = await getMyUserInformation(server.url, server.accessToken)
- channelId = res.body.videoChannels[0].id
+ const { videoChannels } = await server.usersCommand.getMyInfo()
+ channelId = videoChannels[0].id
}
})
username: 'fake',
password: 'fake_password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
const accessTokenUser = await server.loginCommand.getAccessToken(user)
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const customChannelId = res.body.videoChannels[0].id
+ const { videoChannels } = await server.usersCommand.getMyInfo({ token: accessTokenUser })
+ const customChannelId = videoChannels[0].id
const fields = { ...baseCorrectParams, channelId: customChannelId }
checkBadStartPagination,
cleanupTests,
flushAndRunServer,
- generateUserAccessToken,
makeGetRequest,
PlaylistsCommand,
ServerInfo,
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
- userAccessToken = await generateUserAccessToken(server, 'user1')
+ userAccessToken = await server.usersCommand.generateUserAndToken('user1')
videoId = (await uploadVideoAndGetId({ server, videoName: 'video 1' })).id
command = server.playlistsCommand
import 'mocha'
import {
cleanupTests,
- createUser,
flushAndRunServer,
makeGetRequest,
ServerInfo,
await setDefaultVideoChannel([ server ])
const user = { username: 'user1', password: 'my super password' }
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
const moderator = { username: 'moderator', password: 'my super password' }
- await createUser(
- {
- url: server.url,
- accessToken: server.accessToken,
- username: moderator.username,
- password: moderator.password,
- videoQuota: undefined,
- videoQuotaDaily: undefined,
- role: UserRole.MODERATOR
- }
- )
+ await server.usersCommand.create({ username: moderator.username, password: moderator.password, role: UserRole.MODERATOR })
+
moderatorAccessToken = await server.loginCommand.getAccessToken(moderator)
})
import {
checkUploadVideoParam,
cleanupTests,
- createUser,
flushAndRunServer,
- getMyUserInformation,
getVideo,
getVideosList,
makeDeleteRequest,
const username = 'user1'
const password = 'my super password'
- await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
+ await server.usersCommand.create({ username: username, password: password })
userAccessToken = await server.loginCommand.getAccessToken({ username, password })
{
- const res = await getMyUserInformation(server.url, server.accessToken)
- channelId = res.body.videoChannels[0].id
- channelName = res.body.videoChannels[0].name
- accountName = res.body.account.name + '@' + res.body.account.host
+ const body = await server.usersCommand.getMyInfo()
+ channelId = body.videoChannels[0].id
+ channelName = body.videoChannels[0].name
+ accountName = body.account.name + '@' + body.account.host
}
})
username: 'fake' + randomInt(0, 1500),
password: 'fake_password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
const accessTokenUser = await server.loginCommand.getAccessToken(user)
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const customChannelId = res.body.videoChannels[0].id
+ const { videoChannels } = await server.usersCommand.getMyInfo({ token: accessTokenUser })
+ const customChannelId = videoChannels[0].id
const fields = { ...baseCorrectParams, channelId: customChannelId }
const attaches = baseCorrectAttaches
ConfigCommand,
doubleFollow,
flushAndRunMultipleServers,
- generateUser,
getVideo,
ServerInfo,
setAccessTokensToServers,
setDefaultVideoChannel,
- updateUser,
wait,
waitJobs
} from '../../../../shared/extra-utils'
}
function updateQuota (options: { total: number, daily: number }) {
- return updateUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
+ return servers[0].usersCommand.update({
userId,
videoQuota: options.total,
videoQuotaDaily: options.daily
})
{
- const res = await generateUser(servers[0], 'user1')
+ const res = await servers[0].usersCommand.generate('user1')
userId = res.userId
userChannelId = res.userChannelId
userAccessToken = res.token
import {
AbusesCommand,
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
- generateUserAccessToken,
getVideoIdFromUUID,
getVideosList,
- removeUser,
removeVideo,
ServerInfo,
setAccessTokensToServers,
// register a second user to have two reporters/reportees
const user = { username: 'user2', password: 'password' }
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, ...user })
+ await servers[0].usersCommand.create({ ...user })
const userAccessToken = await servers[0].loginCommand.getAccessToken(user)
// upload a third video via this user
before(async function () {
this.timeout(50000)
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: 'user_1', password: 'donald' })
+ await servers[0].usersCommand.create({ username: 'user_1', password: 'donald' })
- const token = await generateUserAccessToken(servers[1], 'user_2')
+ const token = await servers[1].usersCommand.generateUserAndToken('user_2')
await uploadVideo(servers[1].url, token, { name: 'super video' })
await waitJobs(servers)
this.timeout(10000)
const account = await getAccountFromServer(servers[1], 'user_2', servers[1])
- await removeUser(servers[1].url, account.userId, servers[1].accessToken)
+ await servers[1].usersCommand.remove({ userId: account.userId })
await waitJobs(servers)
let userAccessToken: string
before(async function () {
- userAccessToken = await generateUserAccessToken(servers[0], 'user_42')
+ userAccessToken = await servers[0].usersCommand.generateUserAndToken('user_42')
await commands[0].report({ token: userAccessToken, videoId: servers[0].video.id, reason: 'user reason 1' })
let abuseMessageModerationId: number
before(async function () {
- userToken = await generateUserAccessToken(servers[0], 'user_43')
+ userToken = await servers[0].usersCommand.generateUserAndToken('user_43')
const body = await commands[0].report({ token: userToken, videoId: servers[0].video.id, reason: 'user 43 reason 1' })
abuseId = body.abuse.id
import * as chai from 'chai'
import {
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
ServerInfo,
{
const user = { username: 'user1', password: 'password' }
- await createUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
+ await servers[0].usersCommand.create({
username: user.username,
password: user.password,
videoQuota: -1,
{
const user = { username: 'user2', password: 'password' }
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+ await servers[0].usersCommand.create({ username: user.username, password: user.password })
userToken2 = await servers[0].loginCommand.getAccessToken(user)
}
{
const user = { username: 'user3', password: 'password' }
- await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
+ await servers[1].usersCommand.create({ username: user.username, password: user.password })
remoteUserToken = await servers[1].loginCommand.getAccessToken(user)
}
BlocklistCommand,
cleanupTests,
CommentsCommand,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
getVideosList,
{
const user = { username: 'user1', password: 'password' }
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+ await servers[0].usersCommand.create({ username: user.username, password: user.password })
userToken1 = await servers[0].loginCommand.getAccessToken(user)
await uploadVideo(servers[0].url, userToken1, { name: 'video user 1' })
{
const user = { username: 'moderator', password: 'password' }
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+ await servers[0].usersCommand.create({ username: user.username, password: user.password })
userModeratorToken = await servers[0].loginCommand.getAccessToken(user)
}
{
const user = { username: 'user2', password: 'password' }
- await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
+ await servers[1].usersCommand.create({ username: user.username, password: user.password })
userToken2 = await servers[1].loginCommand.getAccessToken(user)
await uploadVideo(servers[1].url, userToken2, { name: 'video user 2' })
import {
BlacklistCommand,
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
- getMyUserInformation,
getMyVideos,
getVideosList,
ImportsCommand,
uploadVideo,
waitJobs
} from '@shared/extra-utils'
-import { User, UserAdminFlag, UserRole, VideoBlacklist, VideoBlacklistType } from '@shared/models'
+import { UserAdminFlag, UserRole, VideoBlacklist, VideoBlacklistType } from '@shared/models'
const expect = chai.expect
{
const user = { username: 'user_without_flag', password: 'password' }
- await createUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
+ await servers[0].usersCommand.create({
username: user.username,
adminFlags: UserAdminFlag.NONE,
password: user.password,
userWithoutFlag = await servers[0].loginCommand.getAccessToken(user)
- const res = await getMyUserInformation(servers[0].url, userWithoutFlag)
- const body: User = res.body
- channelOfUserWithoutFlag = body.videoChannels[0].id
+ const { videoChannels } = await servers[0].usersCommand.getMyInfo({ token: userWithoutFlag })
+ channelOfUserWithoutFlag = videoChannels[0].id
}
{
const user = { username: 'user_with_flag', password: 'password' }
- await createUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
+ await servers[0].usersCommand.create({
username: user.username,
adminFlags: UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST,
password: user.password,
MockSmtpServer,
prepareNotificationsTest,
ServerInfo,
- updateMyUser,
uploadVideo,
waitJobs
} from '@shared/extra-utils'
token: userToken
}
- await updateMyUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- displayName: 'super root name'
- })
-
- await updateMyUser({
- url: servers[1].url,
- accessToken: servers[1].accessToken,
- displayName: 'super root 2 name'
- })
+ await servers[0].usersCommand.updateMe({ displayName: 'super root name' })
+ await servers[1].usersCommand.updateMe({ displayName: 'super root 2 name' })
})
it('Should not send a new mention comment notification if I mention the video owner', async function () {
checkVideoAutoBlacklistForModerators,
checkVideoIsPublished,
cleanupTests,
- createUser,
- generateUserAccessToken,
getVideoIdFromUUID,
MockInstancesIndex,
MockSmtpServer,
prepareNotificationsTest,
- registerUser,
ServerInfo,
uploadVideo,
wait,
this.timeout(20000)
const username = 'user' + new Date().getTime()
- const resUser = await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username, password: 'donald' })
- const accountId = resUser.body.user.account.id
+ const { account } = await servers[0].usersCommand.create({ username, password: 'donald' })
+ const accountId = account.id
await servers[0].abusesCommand.report({ accountId, reason: 'super reason' })
this.timeout(20000)
const username = 'user' + new Date().getTime()
- const tmpToken = await generateUserAccessToken(servers[0], username)
+ const tmpToken = await servers[0].usersCommand.generateUserAndToken(username)
await uploadVideo(servers[0].url, tmpToken, { name: 'super video' })
await waitJobs(servers)
it('Should send a notification only to moderators when a user registers on the instance', async function () {
this.timeout(10000)
- await registerUser(servers[0].url, 'user_45', 'password')
+ await servers[0].usersCommand.register({ username: 'user_45' })
await waitJobs(servers)
checkNewVideoFromSubscription,
cleanupTests,
getAllNotificationsSettings,
- getMyUserInformation,
MockSmtpServer,
prepareNotificationsTest,
ServerInfo,
uploadRandomVideo,
waitJobs
} from '@shared/extra-utils'
-import { User, UserNotification, UserNotificationSettingValue } from '@shared/models'
+import { UserNotification, UserNotificationSettingValue } from '@shared/models'
const expect = chai.expect
})
{
- const res = await getMyUserInformation(server.url, userToken)
- const info = res.body as User
+ const info = await server.usersCommand.getMyInfo({ token: userToken })
expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.NONE)
}
const { name, uuid } = await uploadRandomVideo(server)
const check = { web: true, mail: true }
- await checkNewVideoFromSubscription({ ...baseParams, ...check }, name, uuid, 'absence')
+ await checkNewVideoFromSubscription({ ...baseParams, check }, name, uuid, 'absence')
})
it('Should only have web notifications', async function () {
})
{
- const res = await getMyUserInformation(server.url, userToken)
- const info = res.body as User
+ const info = await server.usersCommand.getMyInfo({ token: userToken })
expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB)
}
{
const check = { mail: true, web: false }
- await checkNewVideoFromSubscription({ ...baseParams, ...check }, name, uuid, 'absence')
+ await checkNewVideoFromSubscription({ ...baseParams, check }, name, uuid, 'absence')
}
{
const check = { mail: false, web: true }
- await checkNewVideoFromSubscription({ ...baseParams, ...check }, name, uuid, 'presence')
+ await checkNewVideoFromSubscription({ ...baseParams, check }, name, uuid, 'presence')
}
})
})
{
- const res = await getMyUserInformation(server.url, userToken)
- const info = res.body as User
+ const info = await server.usersCommand.getMyInfo({ token: userToken })
expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.EMAIL)
}
{
const check = { mail: false, web: true }
- await checkNewVideoFromSubscription({ ...baseParams, ...check }, name, uuid, 'absence')
+ await checkNewVideoFromSubscription({ ...baseParams, check }, name, uuid, 'absence')
}
{
const check = { mail: true, web: false }
- await checkNewVideoFromSubscription({ ...baseParams, ...check }, name, uuid, 'presence')
+ await checkNewVideoFromSubscription({ ...baseParams, check }, name, uuid, 'presence')
}
})
})
{
- const res = await getMyUserInformation(server.url, userToken)
- const info = res.body as User
+ const info = await server.usersCommand.getMyInfo({ token: userToken })
expect(info.notificationSettings.newVideoFromSubscription).to.equal(
UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
)
MockSmtpServer,
prepareNotificationsTest,
ServerInfo,
- updateMyUser,
updateVideo,
uploadRandomVideoOnServers,
wait,
token: userAccessToken
}
- await updateMyUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- displayName: 'super root name'
- })
+ await servers[0].usersCommand.updateMe({ displayName: 'super root name' })
- await updateMyUser({
- url: servers[0].url,
- accessToken: userAccessToken,
+ await servers[0].usersCommand.updateMe({
+ token: userAccessToken,
displayName: myUserName
})
- await updateMyUser({
- url: servers[1].url,
- accessToken: servers[1].accessToken,
- displayName: 'super root 2 name'
- })
+ await servers[1].usersCommand.updateMe({ displayName: 'super root 2 name' })
await servers[0].channelsCommand.update({
token: userAccessToken,
import * as chai from 'chai'
import {
cleanupTests,
- createUser,
flushAndRunMultipleServers,
getVideoChannelVideos,
SearchCommand,
ServerInfo,
setAccessTokensToServers,
- updateMyUser,
updateVideo,
uploadVideo,
wait,
await setAccessTokensToServers(servers)
{
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: 'user1_server1', password: 'password' })
+ await servers[0].usersCommand.create({ username: 'user1_server1', password: 'password' })
const channel = {
name: 'channel1_server1',
displayName: 'Channel 1 server 1'
{
const user = { username: 'user1_server2', password: 'password' }
- await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
+ await servers[1].usersCommand.create({ username: user.username, password: user.password })
userServer2Token = await servers[1].loginCommand.getAccessToken(user)
const channel = {
channelName: 'channel1_server2',
attributes: { displayName: 'channel updated' }
})
- await updateMyUser({ url: servers[1].url, accessToken: userServer2Token, displayName: 'user updated' })
+ await servers[1].usersCommand.updateMe({ token: userServer2Token, displayName: 'user updated' })
await waitJobs(servers)
// Expire video channel
import 'mocha'
import * as chai from 'chai'
-import { cleanupTests, createUser, flushAndRunServer, SearchCommand, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import { cleanupTests, flushAndRunServer, SearchCommand, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
import { VideoChannel } from '@shared/models'
const expect = chai.expect
await setAccessTokensToServers([ server ])
{
- await createUser({ url: server.url, accessToken: server.accessToken, username: 'user1', password: 'password' })
+ await server.usersCommand.create({ username: 'user1', password: 'password' })
const channel = {
name: 'squall_channel',
displayName: 'Squall channel'
import {
BulkCommand,
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
getVideosList,
{
const user = { username: 'user1', password: 'password' }
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+ await servers[0].usersCommand.create({ username: user.username, password: user.password })
user1Token = await servers[0].loginCommand.getAccessToken(user)
}
{
const user = { username: 'user2', password: 'password' }
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+ await servers[0].usersCommand.create({ username: user.username, password: user.password })
user2Token = await servers[0].loginCommand.getAccessToken(user)
}
{
const user = { username: 'user3', password: 'password' }
- await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
+ await servers[1].usersCommand.create({ username: user.username, password: user.password })
user3Token = await servers[1].loginCommand.getAccessToken(user)
}
killallServers,
makeGetRequest,
parallelTests,
- registerUser,
reRunServer,
ServerInfo,
setAccessTokensToServers,
this.timeout(5000)
await Promise.all([
- registerUser(server.url, 'user1', 'super password'),
- registerUser(server.url, 'user2', 'super password'),
- registerUser(server.url, 'user3', 'super password')
+ server.usersCommand.register({ username: 'user1' }),
+ server.usersCommand.register({ username: 'user2' }),
+ server.usersCommand.register({ username: 'user3' })
])
const data = await server.configCommand.getConfig()
import 'mocha'
import * as chai from 'chai'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '@shared/core-utils'
import {
- askResetPassword,
- askSendVerifyEmail,
- blockUser,
cleanupTests,
- createUser,
flushAndRunServer,
- resetPassword,
+ MockSmtpServer,
ServerInfo,
setAccessTokensToServers,
- unblockUser,
uploadVideo,
- verifyEmail
-} from '../../../../shared/extra-utils'
-import { MockSmtpServer } from '../../../../shared/extra-utils/mock-servers/mock-email'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+ waitJobs
+} from '@shared/extra-utils'
const expect = chai.expect
await setAccessTokensToServers([ server ])
{
- const res = await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userId = res.body.user.id
+ const created = await server.usersCommand.create({ username: user.username, password: user.password })
+ userId = created.id
userAccessToken = await server.loginCommand.getAccessToken(user)
}
it('Should ask to reset the password', async function () {
this.timeout(10000)
- await askResetPassword(server.url, 'user_1@example.com')
+ await server.usersCommand.askResetPassword({ email: 'user_1@example.com' })
await waitJobs(server)
expect(emails).to.have.lengthOf(1)
})
it('Should not reset the password with an invalid verification string', async function () {
- await resetPassword(server.url, userId, verificationString + 'b', 'super_password2', HttpStatusCode.FORBIDDEN_403)
+ await server.usersCommand.resetPassword({
+ userId,
+ verificationString: verificationString + 'b',
+ password: 'super_password2',
+ expectedStatus: HttpStatusCode.FORBIDDEN_403
+ })
})
it('Should reset the password', async function () {
- await resetPassword(server.url, userId, verificationString, 'super_password2')
+ await server.usersCommand.resetPassword({ userId, verificationString, password: 'super_password2' })
})
it('Should not reset the password with the same verification string', async function () {
- await resetPassword(server.url, userId, verificationString, 'super_password3', HttpStatusCode.FORBIDDEN_403)
+ await server.usersCommand.resetPassword({
+ userId,
+ verificationString,
+ password: 'super_password3',
+ expectedStatus: HttpStatusCode.FORBIDDEN_403
+ })
})
it('Should login with this new password', async function () {
})
describe('When creating a user without password', function () {
+
it('Should send a create password email', async function () {
this.timeout(10000)
- await createUser({
- url: server.url,
- accessToken: server.accessToken,
- username: 'create_password',
- password: ''
- })
+ await server.usersCommand.create({ username: 'create_password', password: '' })
await waitJobs(server)
expect(emails).to.have.lengthOf(2)
})
it('Should not reset the password with an invalid verification string', async function () {
- await resetPassword(server.url, userId2, verificationString2 + 'c', 'newly_created_password', HttpStatusCode.FORBIDDEN_403)
+ await server.usersCommand.resetPassword({
+ userId: userId2,
+ verificationString: verificationString2 + 'c',
+ password: 'newly_created_password',
+ expectedStatus: HttpStatusCode.FORBIDDEN_403
+ })
})
it('Should reset the password', async function () {
- await resetPassword(server.url, userId2, verificationString2, 'newly_created_password')
+ await server.usersCommand.resetPassword({
+ userId: userId2,
+ verificationString: verificationString2,
+ password: 'newly_created_password'
+ })
})
it('Should login with this new password', async function () {
this.timeout(10000)
const reason = 'my super bad reason'
- await blockUser(server.url, userId, server.accessToken, HttpStatusCode.NO_CONTENT_204, reason)
+ await server.usersCommand.banUser({ userId, reason })
await waitJobs(server)
expect(emails).to.have.lengthOf(4)
it('Should send the notification email when unblocking a user', async function () {
this.timeout(10000)
- await unblockUser(server.url, userId, server.accessToken, HttpStatusCode.NO_CONTENT_204)
+ await server.usersCommand.unbanUser({ userId })
await waitJobs(server)
expect(emails).to.have.lengthOf(5)
it('Should ask to send the verification email', async function () {
this.timeout(10000)
- await askSendVerifyEmail(server.url, 'user_1@example.com')
+ await server.usersCommand.askSendVerifyEmail({ email: 'user_1@example.com' })
await waitJobs(server)
expect(emails).to.have.lengthOf(8)
})
it('Should not verify the email with an invalid verification string', async function () {
- await verifyEmail(server.url, userId, verificationString + 'b', false, HttpStatusCode.FORBIDDEN_403)
+ await server.usersCommand.verifyEmail({
+ userId,
+ verificationString: verificationString + 'b',
+ isPendingEmail: false,
+ expectedStatus: HttpStatusCode.FORBIDDEN_403
+ })
})
it('Should verify the email', async function () {
- await verifyEmail(server.url, userId, verificationString)
+ await server.usersCommand.verifyEmail({ userId, verificationString })
})
})
import { PeerTubeProblemDocument, ServerErrorCode } from '@shared/models'
import {
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
getAccountVideos,
username: 'user1',
password: 'super_password'
}
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+ await servers[0].usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await servers[0].loginCommand.getAccessToken(user)
await doubleFollow(servers[0], servers[1])
import {
cleanupTests,
completeVideoCheck,
- createUser,
dateIsValid,
expectAccountFollows,
flushAndRunMultipleServers,
await uploadVideo(servers[2].url, servers[2].accessToken, { name: 'server3-6' })
{
- const user = { username: 'captain', password: 'password' }
- await createUser({ url: servers[2].url, accessToken: servers[2].accessToken, username: user.username, password: user.password })
- const userAccessToken = await servers[2].loginCommand.getAccessToken(user)
+ const userAccessToken = await servers[2].usersCommand.generateUserAndToken('captain')
const resVideos = await getVideosList(servers[2].url)
video4 = resVideos.body.data.find(v => v.name === 'server3-4')
})
it('Should create some jobs', async function () {
- this.timeout(60000)
+ this.timeout(120000)
await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video1' })
await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video2' })
import {
cleanupTests,
flushAndRunServer,
- getMyUserInformation,
killallServers,
PluginsCommand,
reRunServer,
ServerInfo,
setAccessTokensToServers,
testHelloWorldRegisteredSettings,
- updateMyUser,
wait
} from '@shared/extra-utils'
-import { PluginType, User } from '@shared/models'
+import { PluginType } from '@shared/models'
const expect = chai.expect
})
it('Should update my default theme', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: server.accessToken,
- theme: 'background-red'
- })
+ await server.usersCommand.updateMe({ theme: 'background-red' })
- const res = await getMyUserInformation(server.url, server.accessToken)
- expect((res.body as User).theme).to.equal('background-red')
+ const user = await server.usersCommand.getMyInfo()
+ expect(user.theme).to.equal('background-red')
})
it('Should list plugins and themes', async function () {
})
it('Should have updated the user theme', async function () {
- const res = await getMyUserInformation(server.url, server.accessToken)
- expect((res.body as User).theme).to.equal('instance-default')
+ const user = await server.usersCommand.getMyInfo()
+ expect(user.theme).to.equal('instance-default')
})
it('Should not install a broken plugin', async function () {
cleanupTests,
flushAndRunServer,
getVideo,
- registerUser,
+ ServerInfo,
setAccessTokensToServers,
uploadVideo,
viewVideo,
} from '@shared/extra-utils'
describe('Test application behind a reverse proxy', function () {
- let server = null
- let videoId
+ let server: ServerInfo
+ let videoId: number
before(async function () {
this.timeout(30000)
const user = { username: 'root', password: 'fail' }
for (let i = 0; i < 19; i++) {
- await server.loginCommand.getAccessToken(user, HttpStatusCode.BAD_REQUEST_400)
+ await server.loginCommand.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}
- await server.loginCommand.getAccessToken(user, HttpStatusCode.TOO_MANY_REQUESTS_429)
+ await server.loginCommand.login({ user, expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
})
it('Should rate limit signup', async function () {
for (let i = 0; i < 10; i++) {
try {
- await registerUser(server.url, 'test' + i, 'password')
+ await server.usersCommand.register({ username: 'test' + i })
} catch {
// empty
}
}
- await registerUser(server.url, 'test42', 'password', HttpStatusCode.TOO_MANY_REQUESTS_429)
+ await server.usersCommand.register({ username: 'test42', expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
})
it('Should not rate limit failed signup', async function () {
await wait(7000)
for (let i = 0; i < 3; i++) {
- await registerUser(server.url, 'test' + i, 'password', HttpStatusCode.CONFLICT_409)
+ await server.usersCommand.register({ username: 'test' + i, expectedStatus: HttpStatusCode.CONFLICT_409 })
}
- await registerUser(server.url, 'test43', 'password', HttpStatusCode.NO_CONTENT_204)
+ await server.usersCommand.register({ username: 'test43', expectedStatus: HttpStatusCode.NO_CONTENT_204 })
})
import * as chai from 'chai'
import {
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
ServerInfo,
await doubleFollow(servers[0], servers[1])
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+ await servers[0].usersCommand.create({ username: user.username, password: user.password })
const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { fixture: 'video_short.webm' })
const videoUUID = resVideo.body.video.uuid
import * as chai from 'chai'
import {
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
getVideosList,
{
for (const server of servers) {
const user = { username: 'user' + server.serverNumber, password: 'password' }
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
const accessToken = await server.loginCommand.getAccessToken(user)
users.push({ accessToken })
checkTmpIsEmpty,
checkVideoFilesWereRemoved,
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
getAccountVideos,
- getMyUserInformation,
- removeUser,
ServerInfo,
setAccessTokensToServers,
testImage,
- updateMyAvatar,
- updateMyUser,
uploadVideo,
waitJobs
} from '@shared/extra-utils'
username: 'user1',
password: 'password'
}
- const res = await createUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- username: user.username,
- password: user.password
- })
- userId = res.body.user.id
+ const created = await servers[0].usersCommand.create(user)
+ userId = created.id
userAccessToken = await servers[0].loginCommand.getAccessToken(user)
}
it('Should be able to update my display name', async function () {
this.timeout(10000)
- await updateMyUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- displayName: 'my super display name'
- })
-
- const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
- user = res.body
+ await servers[0].usersCommand.updateMe({ displayName: 'my super display name' })
+ user = await servers[0].usersCommand.getMyInfo()
expect(user.account.displayName).to.equal('my super display name')
await waitJobs(servers)
it('Should be able to update my description', async function () {
this.timeout(10_000)
- await updateMyUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- description: 'my super description updated'
- })
+ await servers[0].usersCommand.updateMe({ description: 'my super description updated' })
- const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
- user = res.body
+ user = await servers[0].usersCommand.getMyInfo()
expect(user.account.displayName).to.equal('my super display name')
expect(user.account.description).to.equal('my super description updated')
const fixture = 'avatar2.png'
- await updateMyAvatar({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- fixture
- })
-
- const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
- user = res.body
+ await servers[0].usersCommand.updateMyAvatar({ fixture })
+ user = await servers[0].usersCommand.getMyInfo()
userAvatarFilename = user.account.avatar.path
await testImage(servers[0].url, 'avatar2-resized', userAvatarFilename, '.png')
expect(videoChannelDeleted).not.to.be.undefined
}
- await removeUser(servers[0].url, userId, servers[0].accessToken)
+ await servers[0].usersCommand.remove({ userId })
await waitJobs(servers)
import 'mocha'
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import {
- cleanupTests,
- flushAndRunServer,
- getMyUserInformation,
- getUserInformation,
- MockSmtpServer,
- registerUser,
- ServerInfo,
- setAccessTokensToServers,
- updateMyUser,
- verifyEmail,
- waitJobs
-} from '@shared/extra-utils'
-import { User } from '@shared/models'
+import { cleanupTests, flushAndRunServer, MockSmtpServer, ServerInfo, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
const expect = chai.expect
}
})
- await registerUser(server.url, user1.username, user1.password)
+ await server.usersCommand.register(user1)
await waitJobs(server)
expectedEmailsLength++
userId = parseInt(userIdMatches[1], 10)
- const resUserInfo = await getUserInformation(server.url, server.accessToken, userId)
- expect(resUserInfo.body.emailVerified).to.be.false
+ const body = await server.usersCommand.get({ userId })
+ expect(body.emailVerified).to.be.false
})
it('Should not allow login for user with unverified email', async function () {
})
it('Should verify the user via email and allow login', async function () {
- await verifyEmail(server.url, userId, verificationString)
+ await server.usersCommand.verifyEmail({ userId, verificationString })
const body = await server.loginCommand.login({ user: user1 })
userAccessToken = body.access_token
- const resUserVerified = await getUserInformation(server.url, server.accessToken, userId)
- expect(resUserVerified.body.emailVerified).to.be.true
+ const user = await server.usersCommand.get({ userId })
+ expect(user.emailVerified).to.be.true
})
it('Should be able to change the user email', async function () {
let updateVerificationString: string
{
- await updateMyUser({
- url: server.url,
- accessToken: userAccessToken,
+ await server.usersCommand.updateMe({
+ token: userAccessToken,
email: 'updated@example.com',
currentPassword: user1.password
})
}
{
- const res = await getMyUserInformation(server.url, userAccessToken)
- const me: User = res.body
-
+ const me = await server.usersCommand.getMyInfo({ token: userAccessToken })
expect(me.email).to.equal('user_1@example.com')
expect(me.pendingEmail).to.equal('updated@example.com')
}
{
- await verifyEmail(server.url, userId, updateVerificationString, true)
-
- const res = await getMyUserInformation(server.url, userAccessToken)
- const me: User = res.body
+ await server.usersCommand.verifyEmail({ userId, verificationString: updateVerificationString, isPendingEmail: true })
+ const me = await server.usersCommand.getMyInfo({ token: userAccessToken })
expect(me.email).to.equal('updated@example.com')
expect(me.pendingEmail).to.be.null
}
}
})
- await registerUser(server.url, user2.username, user2.password)
+ await server.usersCommand.register(user2)
await waitJobs(server)
expect(emails).to.have.lengthOf(expectedEmailsLength)
const accessToken = await server.loginCommand.getAccessToken(user2)
- const resMyUserInfo = await getMyUserInformation(server.url, accessToken)
- expect(resMyUserInfo.body.emailVerified).to.be.null
+ const user = await server.usersCommand.getMyInfo({ token: accessToken })
+ expect(user.emailVerified).to.be.null
})
it('Should allow login for user with unverified email when setting later enabled', async function () {
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
import {
- blockUser,
cleanupTests,
- createUser,
- deleteMe,
flushAndRunServer,
- getMyUserInformation,
- getMyUserVideoQuotaUsed,
- getMyUserVideoRating,
getMyVideos,
- getUserInformation,
- getUsersList,
- getUsersListPaginationAndSort,
getVideosList,
killallServers,
makePutBodyRequest,
rateVideo,
- registerUserWithChannel,
- removeUser,
removeVideo,
reRunServer,
ServerInfo,
setAccessTokensToServers,
testImage,
- unblockUser,
- updateMyAvatar,
- updateMyUser,
- updateUser,
uploadVideo,
waitJobs
} from '@shared/extra-utils'
-import { AbuseState, MyUser, OAuth2ErrorCode, User, UserAdminFlag, UserRole, Video, VideoPlaylistType } from '@shared/models'
+import { AbuseState, OAuth2ErrorCode, UserAdminFlag, UserRole, Video, VideoPlaylistType } from '@shared/models'
const expect = chai.expect
it('Should retrieve a video rating', async function () {
await rateVideo(server.url, accessToken, videoId, 'like')
- const res = await getMyUserVideoRating(server.url, accessToken, videoId)
- const rating = res.body
+ const rating = await server.usersCommand.getMyRating({ token: accessToken, videoId })
expect(rating.videoId).to.equal(videoId)
expect(rating.rating).to.equal('like')
})
it('Should not be able to get the user information', async function () {
- await getMyUserInformation(server.url, server.accessToken, HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.getMyInfo({ expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should not be able to upload a video', async function () {
})
it('Should be able to get my user information again', async function () {
- await getMyUserInformation(server.url, server.accessToken)
+ await server.usersCommand.getMyInfo()
})
it('Should have an expired access token', async function () {
await killallServers([ server ])
await reRunServer(server)
- await getMyUserInformation(server.url, server.accessToken, HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.getMyInfo({ expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should not be able to refresh an access token with an expired refresh token', async function () {
})
it('Should be able to get my user information again', async function () {
- await getMyUserInformation(server.url, server.accessToken)
+ await server.usersCommand.getMyInfo()
})
})
describe('Creating a user', function () {
it('Should be able to create a new user', async function () {
- await createUser({
- url: server.url,
- accessToken: accessToken,
- username: user.username,
- password: user.password,
- videoQuota: 2 * 1024 * 1024,
- adminFlags: UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST
- })
+ await server.usersCommand.create({ ...user, videoQuota: 2 * 1024 * 1024, adminFlags: UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST })
})
it('Should be able to login with this user', async function () {
})
it('Should be able to get user information', async function () {
- const res1 = await getMyUserInformation(server.url, accessTokenUser)
- const userMe: MyUser = res1.body
+ const userMe = await server.usersCommand.getMyInfo({ token: accessTokenUser })
- const res2 = await getUserInformation(server.url, server.accessToken, userMe.id, true)
- const userGet: User = res2.body
+ const userGet = await server.usersCommand.get({ userId: userMe.id, withStats: true })
for (const user of [ userMe, userGet ]) {
expect(user.username).to.equal('user_1')
})
it('Should have video quota updated', async function () {
- const res = await getMyUserVideoQuotaUsed(server.url, accessTokenUser)
- const data = res.body
-
- expect(data.videoQuotaUsed).to.equal(218910)
-
- const resUsers = await getUsersList(server.url, server.accessToken)
+ const quota = await server.usersCommand.getMyQuotaUsed({ token: accessTokenUser })
+ expect(quota.videoQuotaUsed).to.equal(218910)
- const users: User[] = resUsers.body.data
- const tmpUser = users.find(u => u.username === user.username)
+ const { data } = await server.usersCommand.list()
+ const tmpUser = data.find(u => u.username === user.username)
expect(tmpUser.videoQuotaUsed).to.equal(218910)
})
}
{
- const res = await getMyUserVideoQuotaUsed(server.url, accessTokenUser)
- const data = res.body
-
+ const data = await server.usersCommand.getMyQuotaUsed({ token: accessTokenUser })
expect(data.videoQuotaUsed).to.be.greaterThan(220000)
}
})
describe('Users listing', function () {
it('Should list all the users', async function () {
- const res = await getUsersList(server.url, server.accessToken)
- const result = res.body
- const total = result.total
- const users = result.data
+ const { data, total } = await server.usersCommand.list()
expect(total).to.equal(2)
- expect(users).to.be.an('array')
- expect(users.length).to.equal(2)
+ expect(data).to.be.an('array')
+ expect(data.length).to.equal(2)
- const user = users[0]
+ const user = data[0]
expect(user.username).to.equal('user_1')
expect(user.email).to.equal('user_1@example.com')
expect(user.nsfwPolicy).to.equal('display')
- const rootUser = users[1]
+ const rootUser = data[1]
expect(rootUser.username).to.equal('root')
expect(rootUser.email).to.equal('admin' + server.internalServerNumber + '@example.com')
expect(user.nsfwPolicy).to.equal('display')
})
it('Should list only the first user by username asc', async function () {
- const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, 'username')
-
- const result = res.body
- const total = result.total
- const users = result.data
+ const { total, data } = await server.usersCommand.list({ start: 0, count: 1, sort: 'username' })
expect(total).to.equal(2)
- expect(users.length).to.equal(1)
+ expect(data.length).to.equal(1)
- const user = users[0]
+ const user = data[0]
expect(user.username).to.equal('root')
expect(user.email).to.equal('admin' + server.internalServerNumber + '@example.com')
expect(user.roleLabel).to.equal('Administrator')
})
it('Should list only the first user by username desc', async function () {
- const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, '-username')
- const result = res.body
- const total = result.total
- const users = result.data
+ const { total, data } = await server.usersCommand.list({ start: 0, count: 1, sort: '-username' })
expect(total).to.equal(2)
- expect(users.length).to.equal(1)
+ expect(data.length).to.equal(1)
- const user = users[0]
+ const user = data[0]
expect(user.username).to.equal('user_1')
expect(user.email).to.equal('user_1@example.com')
expect(user.nsfwPolicy).to.equal('display')
})
it('Should list only the second user by createdAt desc', async function () {
- const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, '-createdAt')
- const result = res.body
- const total = result.total
- const users = result.data
-
+ const { data, total } = await server.usersCommand.list({ start: 0, count: 1, sort: '-createdAt' })
expect(total).to.equal(2)
- expect(users.length).to.equal(1)
- const user = users[0]
+ expect(data.length).to.equal(1)
+
+ const user = data[0]
expect(user.username).to.equal('user_1')
expect(user.email).to.equal('user_1@example.com')
expect(user.nsfwPolicy).to.equal('display')
})
it('Should list all the users by createdAt asc', async function () {
- const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt')
- const result = res.body
- const total = result.total
- const users = result.data
+ const { data, total } = await server.usersCommand.list({ start: 0, count: 2, sort: 'createdAt' })
expect(total).to.equal(2)
- expect(users.length).to.equal(2)
+ expect(data.length).to.equal(2)
- expect(users[0].username).to.equal('root')
- expect(users[0].email).to.equal('admin' + server.internalServerNumber + '@example.com')
- expect(users[0].nsfwPolicy).to.equal('display')
+ expect(data[0].username).to.equal('root')
+ expect(data[0].email).to.equal('admin' + server.internalServerNumber + '@example.com')
+ expect(data[0].nsfwPolicy).to.equal('display')
- expect(users[1].username).to.equal('user_1')
- expect(users[1].email).to.equal('user_1@example.com')
- expect(users[1].nsfwPolicy).to.equal('display')
+ expect(data[1].username).to.equal('user_1')
+ expect(data[1].email).to.equal('user_1@example.com')
+ expect(data[1].nsfwPolicy).to.equal('display')
})
it('Should search user by username', async function () {
- const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'oot')
- const users = res.body.data as User[]
-
- expect(res.body.total).to.equal(1)
- expect(users.length).to.equal(1)
-
- expect(users[0].username).to.equal('root')
+ const { data, total } = await server.usersCommand.list({ start: 0, count: 2, sort: 'createdAt', search: 'oot' })
+ expect(total).to.equal(1)
+ expect(data.length).to.equal(1)
+ expect(data[0].username).to.equal('root')
})
it('Should search user by email', async function () {
{
- const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'r_1@exam')
- const users = res.body.data as User[]
-
- expect(res.body.total).to.equal(1)
- expect(users.length).to.equal(1)
-
- expect(users[0].username).to.equal('user_1')
- expect(users[0].email).to.equal('user_1@example.com')
+ const { total, data } = await server.usersCommand.list({ start: 0, count: 2, sort: 'createdAt', search: 'r_1@exam' })
+ expect(total).to.equal(1)
+ expect(data.length).to.equal(1)
+ expect(data[0].username).to.equal('user_1')
+ expect(data[0].email).to.equal('user_1@example.com')
}
{
- const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'example')
- const users = res.body.data as User[]
-
- expect(res.body.total).to.equal(2)
- expect(users.length).to.equal(2)
-
- expect(users[0].username).to.equal('root')
- expect(users[1].username).to.equal('user_1')
+ const { total, data } = await server.usersCommand.list({ start: 0, count: 2, sort: 'createdAt', search: 'example' })
+ expect(total).to.equal(2)
+ expect(data.length).to.equal(2)
+ expect(data[0].username).to.equal('root')
+ expect(data[1].username).to.equal('user_1')
}
})
})
describe('Update my account', function () {
it('Should update my password', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: accessTokenUser,
+ await server.usersCommand.updateMe({
+ token: accessTokenUser,
currentPassword: 'super password',
password: 'new password'
})
})
it('Should be able to change the NSFW display attribute', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: accessTokenUser,
+ await server.usersCommand.updateMe({
+ token: accessTokenUser,
nsfwPolicy: 'do_not_list'
})
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const user = res.body
-
+ const user = await server.usersCommand.getMyInfo({ token: accessTokenUser })
expect(user.username).to.equal('user_1')
expect(user.email).to.equal('user_1@example.com')
expect(user.nsfwPolicy).to.equal('do_not_list')
})
it('Should be able to change the autoPlayVideo attribute', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: accessTokenUser,
+ await server.usersCommand.updateMe({
+ token: accessTokenUser,
autoPlayVideo: false
})
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const user = res.body
-
+ const user = await server.usersCommand.getMyInfo({ token: accessTokenUser })
expect(user.autoPlayVideo).to.be.false
})
it('Should be able to change the autoPlayNextVideo attribute', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: accessTokenUser,
+ await server.usersCommand.updateMe({
+ token: accessTokenUser,
autoPlayNextVideo: true
})
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const user = res.body
-
+ const user = await server.usersCommand.getMyInfo({ token: accessTokenUser })
expect(user.autoPlayNextVideo).to.be.true
})
it('Should be able to change the email attribute', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: accessTokenUser,
+ await server.usersCommand.updateMe({
+ token: accessTokenUser,
currentPassword: 'new password',
email: 'updated@example.com'
})
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const user = res.body
-
+ const user = await server.usersCommand.getMyInfo({ token: accessTokenUser })
expect(user.username).to.equal('user_1')
expect(user.email).to.equal('updated@example.com')
expect(user.nsfwPolicy).to.equal('do_not_list')
it('Should be able to update my avatar with a gif', async function () {
const fixture = 'avatar.gif'
- await updateMyAvatar({
- url: server.url,
- accessToken: accessTokenUser,
- fixture
- })
-
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const user = res.body
+ await server.usersCommand.updateMyAvatar({ token: accessTokenUser, fixture })
+ const user = await server.usersCommand.getMyInfo({ token: accessTokenUser })
await testImage(server.url, 'avatar-resized', user.account.avatar.path, '.gif')
})
for (const extension of [ '.png', '.gif' ]) {
const fixture = 'avatar' + extension
- await updateMyAvatar({
- url: server.url,
- accessToken: accessTokenUser,
- fixture
- })
-
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const user = res.body
+ await server.usersCommand.updateMyAvatar({ token: accessTokenUser, fixture })
+ const user = await server.usersCommand.getMyInfo({ token: accessTokenUser })
await testImage(server.url, 'avatar-resized', user.account.avatar.path, extension)
}
})
it('Should be able to update my display name', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: accessTokenUser,
- displayName: 'new display name'
- })
-
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const user = res.body
+ await server.usersCommand.updateMe({ token: accessTokenUser, displayName: 'new display name' })
+ const user = await server.usersCommand.getMyInfo({ token: accessTokenUser })
expect(user.username).to.equal('user_1')
expect(user.email).to.equal('updated@example.com')
expect(user.nsfwPolicy).to.equal('do_not_list')
})
it('Should be able to update my description', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: accessTokenUser,
- description: 'my super description updated'
- })
-
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const user: User = res.body
+ await server.usersCommand.updateMe({ token: accessTokenUser, description: 'my super description updated' })
+ const user = await server.usersCommand.getMyInfo({ token: accessTokenUser })
expect(user.username).to.equal('user_1')
expect(user.email).to.equal('updated@example.com')
expect(user.nsfwPolicy).to.equal('do_not_list')
it('Should be able to update my theme', async function () {
for (const theme of [ 'background-red', 'default', 'instance-default' ]) {
- await updateMyUser({
- url: server.url,
- accessToken: accessTokenUser,
- theme
- })
+ await server.usersCommand.updateMe({ token: accessTokenUser, theme })
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const body: User = res.body
-
- expect(body.theme).to.equal(theme)
+ const user = await server.usersCommand.getMyInfo({ token: accessTokenUser })
+ expect(user.theme).to.equal(theme)
}
})
it('Should be able to update my modal preferences', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: accessTokenUser,
+ await server.usersCommand.updateMe({
+ token: accessTokenUser,
noInstanceConfigWarningModal: true,
noWelcomeModal: true
})
- const res = await getMyUserInformation(server.url, accessTokenUser)
- const user: User = res.body
-
+ const user = await server.usersCommand.getMyInfo({ token: accessTokenUser })
expect(user.noWelcomeModal).to.be.true
expect(user.noInstanceConfigWarningModal).to.be.true
})
describe('Updating another user', function () {
it('Should be able to update another user', async function () {
- await updateUser({
- url: server.url,
+ await server.usersCommand.update({
userId,
- accessToken,
+ token: accessToken,
email: 'updated2@example.com',
emailVerified: true,
videoQuota: 42,
pluginAuth: 'toto'
})
- const res = await getUserInformation(server.url, accessToken, userId)
- const user = res.body as User
+ const user = await server.usersCommand.get({ token: accessToken, userId })
expect(user.username).to.equal('user_1')
expect(user.email).to.equal('updated2@example.com')
})
it('Should reset the auth plugin', async function () {
- await updateUser({ url: server.url, userId, accessToken, pluginAuth: null })
+ await server.usersCommand.update({ userId, token: accessToken, pluginAuth: null })
- const res = await getUserInformation(server.url, accessToken, userId)
- const user = res.body as User
+ const user = await server.usersCommand.get({ token: accessToken, userId })
expect(user.pluginAuth).to.be.null
})
it('Should have removed the user token', async function () {
- await getMyUserVideoQuotaUsed(server.url, accessTokenUser, HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.getMyQuotaUsed({ token: accessTokenUser, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
accessTokenUser = await server.loginCommand.getAccessToken(user)
})
it('Should be able to update another user password', async function () {
- await updateUser({
- url: server.url,
- userId,
- accessToken,
- password: 'password updated'
- })
+ await server.usersCommand.update({ userId, token: accessToken, password: 'password updated' })
- await getMyUserVideoQuotaUsed(server.url, accessTokenUser, HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.getMyQuotaUsed({ token: accessTokenUser, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
await server.loginCommand.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
describe('Remove a user', function () {
it('Should be able to remove this user', async function () {
- await removeUser(server.url, userId, accessToken)
+ await server.usersCommand.remove({ userId, token: accessToken })
})
it('Should not be able to login with this user', async function () {
const user = { displayName: 'super user 15', username: 'user_15', password: 'my super password' }
const channel = { name: 'my_user_15_channel', displayName: 'my channel rocks' }
- await registerUserWithChannel({ url: server.url, user, channel })
+ await server.usersCommand.register({ ...user, channel })
})
it('Should be able to login with this registered user', async function () {
})
it('Should have the correct display name', async function () {
- const res = await getMyUserInformation(server.url, user15AccessToken)
- const user: User = res.body
-
+ const user = await server.usersCommand.getMyInfo({ token: user15AccessToken })
expect(user.account.displayName).to.equal('super user 15')
})
it('Should have the correct video quota', async function () {
- const res = await getMyUserInformation(server.url, user15AccessToken)
- const user = res.body
-
+ const user = await server.usersCommand.getMyInfo({ token: user15AccessToken })
expect(user.videoQuota).to.equal(5 * 1024 * 1024)
})
it('Should remove me', async function () {
{
- const res = await getUsersList(server.url, server.accessToken)
- expect(res.body.data.find(u => u.username === 'user_15')).to.not.be.undefined
+ const { data } = await server.usersCommand.list()
+ expect(data.find(u => u.username === 'user_15')).to.not.be.undefined
}
- await deleteMe(server.url, user15AccessToken)
+ await server.usersCommand.deleteMe({ token: user15AccessToken })
{
- const res = await getUsersList(server.url, server.accessToken)
- expect(res.body.data.find(u => u.username === 'user_15')).to.be.undefined
+ const { data } = await server.usersCommand.list()
+ expect(data.find(u => u.username === 'user_15')).to.be.undefined
}
})
})
}
it('Should block a user', async function () {
- const resUser = await createUser({
- url: server.url,
- accessToken: server.accessToken,
- username: user16.username,
- password: user16.password
- })
- user16Id = resUser.body.user.id
+ const user = await server.usersCommand.create({ ...user16 })
+ user16Id = user.id
user16AccessToken = await server.loginCommand.getAccessToken(user16)
- await getMyUserInformation(server.url, user16AccessToken, HttpStatusCode.OK_200)
- await blockUser(server.url, user16Id, server.accessToken)
+ await server.usersCommand.getMyInfo({ token: user16AccessToken, expectedStatus: HttpStatusCode.OK_200 })
+ await server.usersCommand.banUser({ userId: user16Id })
- await getMyUserInformation(server.url, user16AccessToken, HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.getMyInfo({ token: user16AccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
await server.loginCommand.login({ user: user16, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should search user by banned status', async function () {
{
- const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', undefined, true)
- const users = res.body.data as User[]
+ const { data, total } = await server.usersCommand.list({ start: 0, count: 2, sort: 'createdAt', blocked: true })
+ expect(total).to.equal(1)
+ expect(data.length).to.equal(1)
- expect(res.body.total).to.equal(1)
- expect(users.length).to.equal(1)
-
- expect(users[0].username).to.equal(user16.username)
+ expect(data[0].username).to.equal(user16.username)
}
{
- const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', undefined, false)
- const users = res.body.data as User[]
-
- expect(res.body.total).to.equal(1)
- expect(users.length).to.equal(1)
+ const { data, total } = await server.usersCommand.list({ start: 0, count: 2, sort: 'createdAt', blocked: false })
+ expect(total).to.equal(1)
+ expect(data.length).to.equal(1)
- expect(users[0].username).to.not.equal(user16.username)
+ expect(data[0].username).to.not.equal(user16.username)
}
})
it('Should unblock a user', async function () {
- await unblockUser(server.url, user16Id, server.accessToken)
+ await server.usersCommand.unbanUser({ userId: user16Id })
user16AccessToken = await server.loginCommand.getAccessToken(user16)
- await getMyUserInformation(server.url, user16AccessToken, HttpStatusCode.OK_200)
+ await server.usersCommand.getMyInfo({ token: user16AccessToken, expectedStatus: HttpStatusCode.OK_200 })
})
})
username: 'user_17',
password: 'my super password'
}
- const resUser = await createUser({
- url: server.url,
- accessToken: server.accessToken,
- username: user17.username,
- password: user17.password
- })
+ const created = await server.usersCommand.create({ ...user17 })
- user17Id = resUser.body.user.id
+ user17Id = created.id
user17AccessToken = await server.loginCommand.getAccessToken(user17)
- const res = await getUserInformation(server.url, server.accessToken, user17Id, true)
- const user: User = res.body
-
+ const user = await server.usersCommand.get({ userId: user17Id, withStats: true })
expect(user.videosCount).to.equal(0)
expect(user.videoCommentsCount).to.equal(0)
expect(user.abusesCount).to.equal(0)
const res1 = await getVideosList(server.url)
videoId = res1.body.data.find(video => video.name === videoAttributes.name).id
- const res2 = await getUserInformation(server.url, server.accessToken, user17Id, true)
- const user: User = res2.body
-
+ const user = await server.usersCommand.get({ userId: user17Id, withStats: true })
expect(user.videosCount).to.equal(1)
})
const text = 'super comment'
await server.commentsCommand.createThread({ token: user17AccessToken, videoId, text })
- const res = await getUserInformation(server.url, server.accessToken, user17Id, true)
- const user: User = res.body
-
+ const user = await server.usersCommand.get({ userId: user17Id, withStats: true })
expect(user.videoCommentsCount).to.equal(1)
})
const body1 = await server.abusesCommand.getAdminList()
const abuseId = body1.data[0].id
- const res2 = await getUserInformation(server.url, server.accessToken, user17Id, true)
- const user2: User = res2.body
-
+ const user2 = await server.usersCommand.get({ userId: user17Id, withStats: true })
expect(user2.abusesCount).to.equal(1) // number of incriminations
expect(user2.abusesCreatedCount).to.equal(1) // number of reports created
await server.abusesCommand.update({ abuseId, body: { state: AbuseState.ACCEPTED } })
- const res3 = await getUserInformation(server.url, server.accessToken, user17Id, true)
- const user3: User = res3.body
-
+ const user3 = await server.usersCommand.get({ userId: user17Id, withStats: true })
expect(user3.abusesAcceptedCount).to.equal(1) // number of reports created accepted
})
})
checkVideoFilesWereRemoved,
cleanupTests,
completeVideoCheck,
- createUser,
dateIsValid,
doubleFollow,
flushAndRunMultipleServers,
username: 'user1',
password: 'super_password'
}
- await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
+ await servers[1].usersCommand.create({ username: user.username, password: user.password })
const userAccessToken = await servers[1].loginCommand.getAccessToken(user)
const videoAttributes = {
buildAbsoluteFixturePath,
cleanupTests,
flushAndRunServer,
- getMyUserInformation,
prepareResumableUpload,
sendResumableChunks,
ServerInfo,
setAccessTokensToServers,
- setDefaultVideoChannel,
- updateUser
+ setDefaultVideoChannel
} from '@shared/extra-utils'
-import { MyUser, VideoPrivacy } from '@shared/models'
+import { VideoPrivacy } from '@shared/models'
const expect = chai.expect
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
- const res = await getMyUserInformation(server.url, server.accessToken)
- rootId = (res.body as MyUser).id
+ const body = await server.usersCommand.getMyInfo()
+ rootId = body.id
- await updateUser({
- url: server.url,
- userId: rootId,
- accessToken: server.accessToken,
- videoQuota: 10_000_000
- })
+ await server.usersCommand.update({ userId: rootId, videoQuota: 10_000_000 })
})
describe('Directory cleaning', function () {
import {
ChangeOwnershipCommand,
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
flushAndRunServer,
- getMyUserInformation,
getVideo,
getVideosList,
ServerInfo,
uploadVideo
} from '../../../../shared/extra-utils'
import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { User } from '../../../../shared/models/users'
import { VideoDetails, VideoPrivacy } from '../../../../shared/models/videos'
const expect = chai.expect
describe('Test video change ownership - nominal', function () {
let servers: ServerInfo[] = []
- const firstUser = {
- username: 'first',
- password: 'My great password'
- }
- const secondUser = {
- username: 'second',
- password: 'My other password'
- }
+
+ const firstUser = 'first'
+ const secondUser = 'second'
let firstUserToken = ''
let firstUserChannelId: number
}
})
- const videoQuota = 42000000
- await createUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- username: firstUser.username,
- password: firstUser.password,
- videoQuota: videoQuota
- })
- await createUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- username: secondUser.username,
- password: secondUser.password,
- videoQuota: videoQuota
- })
-
- firstUserToken = await servers[0].loginCommand.getAccessToken(firstUser)
- secondUserToken = await servers[0].loginCommand.getAccessToken(secondUser)
+ firstUserToken = await servers[0].usersCommand.generateUserAndToken(firstUser)
+ secondUserToken = await servers[0].usersCommand.generateUserAndToken(secondUser)
{
- const res = await getMyUserInformation(servers[0].url, firstUserToken)
- const firstUserInformation: User = res.body
- firstUserChannelId = firstUserInformation.videoChannels[0].id
+ const { videoChannels } = await servers[0].usersCommand.getMyInfo({ token: firstUserToken })
+ firstUserChannelId = videoChannels[0].id
}
{
- const res = await getMyUserInformation(servers[0].url, secondUserToken)
- const secondUserInformation: User = res.body
- secondUserChannelId = secondUserInformation.videoChannels[0].id
+ const { videoChannels } = await servers[0].usersCommand.getMyInfo({ token: secondUserToken })
+ secondUserChannelId = videoChannels[0].id
}
{
it('Should send a request to change ownership of a video', async function () {
this.timeout(15000)
- await command.create({ token: firstUserToken, videoId: servers[0].video.id, username: secondUser.username })
+ await command.create({ token: firstUserToken, videoId: servers[0].video.id, username: secondUser })
})
it('Should only return a request to change ownership for the second user', async function () {
it('Should accept the same change ownership request without crashing', async function () {
this.timeout(10000)
- await command.create({ token: firstUserToken, videoId: servers[0].video.id, username: secondUser.username })
+ await command.create({ token: firstUserToken, videoId: servers[0].video.id, username: secondUser })
})
it('Should not create multiple change ownership requests while one is waiting', async function () {
it('Should send a new request to change ownership of a video', async function () {
this.timeout(15000)
- await command.create({ token: firstUserToken, videoId: servers[0].video.id, username: secondUser.username })
+ await command.create({ token: firstUserToken, videoId: servers[0].video.id, username: secondUser })
})
it('Should return two requests to change ownership for the second user', async function () {
it('Should send a request to change ownership of a live', async function () {
this.timeout(15000)
- await command.create({ token: firstUserToken, videoId: liveId, username: secondUser.username })
+ await command.create({ token: firstUserToken, videoId: liveId, username: secondUser })
const body = await command.list({ token: secondUserToken })
describe('Test video change ownership - quota too small', function () {
let server: ServerInfo
- const firstUser = {
- username: 'first',
- password: 'My great password'
- }
- const secondUser = {
- username: 'second',
- password: 'My other password'
- }
+ const firstUser = 'first'
+ const secondUser = 'second'
+
let firstUserToken = ''
let secondUserToken = ''
let lastRequestId: number
server = await flushAndRunServer(1)
await setAccessTokensToServers([ server ])
- const videoQuota = 42000000
- const limitedVideoQuota = 10
- await createUser({
- url: server.url,
- accessToken: server.accessToken,
- username: firstUser.username,
- password: firstUser.password,
- videoQuota: videoQuota
- })
- await createUser({
- url: server.url,
- accessToken: server.accessToken,
- username: secondUser.username,
- password: secondUser.password,
- videoQuota: limitedVideoQuota
- })
+ await server.usersCommand.create({ username: secondUser, videoQuota: 10 })
- firstUserToken = await server.loginCommand.getAccessToken(firstUser)
+ firstUserToken = await server.usersCommand.generateUserAndToken(firstUser)
secondUserToken = await server.loginCommand.getAccessToken(secondUser)
// Upload some videos on the server
it('Should send a request to change ownership of a video', async function () {
this.timeout(15000)
- await server.changeOwnershipCommand.create({ token: firstUserToken, videoId: server.video.id, username: secondUser.username })
+ await server.changeOwnershipCommand.create({ token: firstUserToken, videoId: server.video.id, username: secondUser })
})
it('Should only return a request to change ownership for the second user', async function () {
it('Should not be possible to accept the change of ownership from second user because of exceeded quota', async function () {
this.timeout(10000)
- const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserToken)
- const secondUserInformation: User = secondUserInformationResponse.body
- const channelId = secondUserInformation.videoChannels[0].id
+ const { videoChannels } = await server.usersCommand.getMyInfo({ token: secondUserToken })
+ const channelId = videoChannels[0].id
await server.changeOwnershipCommand.accept({
token: secondUserToken,
import { ACTOR_IMAGES_SIZE } from '@server/initializers/constants'
import {
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
getVideo,
getVideoChannelVideos,
+ ServerInfo,
+ setAccessTokensToServers,
setDefaultVideoChannel,
testFileExistsOrNot,
testImage,
updateVideo,
uploadVideo,
- wait
-} from '../../../../shared/extra-utils'
-import { getMyUserInformation, ServerInfo, setAccessTokensToServers, viewVideo } from '../../../../shared/extra-utils/index'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { User, Video, VideoChannel, VideoDetails } from '../../../../shared/index'
+ viewVideo,
+ wait,
+ waitJobs
+} from '@shared/extra-utils'
+import { User, Video, VideoChannel, VideoDetails } from '@shared/models'
const expect = chai.expect
})
it('Should have two video channels when getting my information', async () => {
- const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
- userInfo = res.body
+ userInfo = await servers[0].usersCommand.getMyInfo()
expect(userInfo.videoChannels).to.be.an('array')
expect(userInfo.videoChannels).to.have.lengthOf(2)
}
{
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: 'toto', password: 'password' })
+ await servers[0].usersCommand.create({ username: 'toto', password: 'password' })
const accessToken = await servers[0].loginCommand.getAccessToken({ username: 'toto', password: 'password' })
- const res = await getMyUserInformation(servers[0].url, accessToken)
- const videoChannel = res.body.videoChannels[0]
+ const { videoChannels } = await servers[0].usersCommand.getMyInfo({ token: accessToken })
+ const videoChannel = videoChannels[0]
expect(videoChannel.name).to.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/)
}
})
import {
cleanupTests,
CommentsCommand,
- createUser,
dateIsValid,
flushAndRunServer,
ServerInfo,
setAccessTokensToServers,
testImage,
- updateMyAvatar,
uploadVideo
} from '@shared/extra-utils'
videoUUID = res.body.video.uuid
videoId = res.body.video.id
- await updateMyAvatar({
- url: server.url,
- accessToken: server.accessToken,
- fixture: 'avatar.png'
- })
+ await server.usersCommand.updateMyAvatar({ fixture: 'avatar.png' })
- await createUser({
- url: server.url,
- accessToken: server.accessToken,
- username: 'user1',
- password: 'password'
- })
- userAccessTokenServer1 = await server.loginCommand.getAccessToken('user1', 'password')
+ userAccessTokenServer1 = await server.usersCommand.generateUserAndToken('user1')
command = server.commentsCommand
})
cleanupTests,
doubleFollow,
flushAndRunMultipleServers,
- getMyUserInformation,
getMyVideos,
getVideo,
getVideosList,
await setAccessTokensToServers(servers)
{
- const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
- channelIdServer1 = res.body.videoChannels[0].id
+ const { videoChannels } = await servers[0].usersCommand.getMyInfo()
+ channelIdServer1 = videoChannels[0].id
}
{
- const res = await getMyUserInformation(servers[1].url, servers[1].accessToken)
- channelIdServer2 = res.body.videoChannels[0].id
+ const { videoChannels } = await servers[1].usersCommand.getMyInfo()
+ channelIdServer2 = videoChannels[0].id
}
await doubleFollow(servers[0], servers[1])
import * as chai from 'chai'
import {
cleanupTests,
- createUser,
flushAndRunServer,
getAccountVideos,
- getMyUserInformation,
getMyVideos,
getVideoChannelVideos,
getVideosList,
getVideosListWithToken,
ServerInfo,
setAccessTokensToServers,
- updateMyUser,
uploadVideo
} from '@shared/extra-utils'
-import { BooleanBothQuery, CustomConfig, ResultList, User, Video, VideosOverview } from '@shared/models'
+import { BooleanBothQuery, CustomConfig, ResultList, Video, VideosOverview } from '@shared/models'
const expect = chai.expect
let customConfig: CustomConfig
async function getVideosFunctions (token?: string, query: { nsfw?: BooleanBothQuery } = {}) {
- const res = await getMyUserInformation(server.url, server.accessToken)
- const user: User = res.body
+ const user = await server.usersCommand.getMyInfo()
const videoChannelName = user.videoChannels[0].name
const accountName = user.account.name + '@' + user.account.host
const hasQuery = Object.keys(query).length !== 0
it('Should create a user having the default nsfw policy', async function () {
const username = 'user1'
const password = 'my super password'
- await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
+ await server.usersCommand.create({ username: username, password: password })
userAccessToken = await server.loginCommand.getAccessToken({ username, password })
- const res = await getMyUserInformation(server.url, userAccessToken)
- const user = res.body
-
+ const user = await server.usersCommand.getMyInfo({ token: userAccessToken })
expect(user.nsfwPolicy).to.equal('blur')
})
})
it('Should display NSFW videos with display user NSFW policy', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: server.accessToken,
- nsfwPolicy: 'display'
- })
+ await server.usersCommand.updateMe({ nsfwPolicy: 'display' })
for (const body of await getVideosFunctions(server.accessToken)) {
expect(body.total).to.equal(2)
})
it('Should not display NSFW videos with do_not_list user NSFW policy', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: server.accessToken,
- nsfwPolicy: 'do_not_list'
- })
+ await server.usersCommand.updateMe({ nsfwPolicy: 'do_not_list' })
for (const body of await getVideosFunctions(server.accessToken)) {
expect(body.total).to.equal(1)
import {
checkPlaylistFilesWereRemoved,
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
- generateUserAccessToken,
- getMyUserInformation,
PlaylistsCommand,
- removeUser,
ServerInfo,
setAccessTokensToServers,
setDefaultVideoChannel,
waitJobs
} from '@shared/extra-utils'
import {
- User,
VideoPlaylist,
VideoPlaylistCreateResult,
VideoPlaylistElementType,
nsfwVideoServer1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'NSFW video', nsfw: true })).id
- {
- await createUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- username: 'user1',
- password: 'password'
- })
- userTokenServer1 = await servers[0].loginCommand.getAccessToken('user1', 'password')
- }
+ userTokenServer1 = await servers[0].usersCommand.generateUserAndToken('user1')
await waitJobs(servers)
})
})
it('Should get private playlist for a classic user', async function () {
- const token = await generateUserAccessToken(servers[0], 'toto')
+ const token = await servers[0].usersCommand.generateUserAndToken('toto')
const body = await commands[0].listByAccount({ token, handle: 'toto' })
it('Should delete an account and delete its playlists', async function () {
this.timeout(30000)
- const user = { username: 'user_1', password: 'password' }
- const res = await createUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- username: user.username,
- password: user.password
- })
-
- const userId = res.body.user.id
- const userAccessToken = await servers[0].loginCommand.getAccessToken(user)
+ const { userId, token } = await servers[0].usersCommand.generate('user_1')
- const resChannel = await getMyUserInformation(servers[0].url, userAccessToken)
- const userChannel = (resChannel.body as User).videoChannels[0]
+ const { videoChannels } = await servers[0].usersCommand.getMyInfo({ token })
+ const userChannel = videoChannels[0]
await commands[0].create({
attributes: {
}
}
- await removeUser(servers[0].url, userId, servers[0].accessToken)
+ await servers[0].usersCommand.remove({ userId })
await waitJobs(servers)
{
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- createUser,
doubleFollow,
flushAndRunServer,
getMyVideos,
username: 'hello',
password: 'super password'
}
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
+ await servers[0].usersCommand.create({ username: user.username, password: user.password })
anotherUserToken = await servers[0].loginCommand.getAccessToken(user)
await getVideoWithToken(servers[0].url, anotherUserToken, privateVideoUUID, HttpStatusCode.FORBIDDEN_403)
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
makeGetRequest,
for (const server of servers) {
const moderator = { username: 'moderator', password: 'my super password' }
- await createUser(
- {
- url: server.url,
- accessToken: server.accessToken,
- username: moderator.username,
- password: moderator.password,
- videoQuota: undefined,
- videoQuotaDaily: undefined,
- role: UserRole.MODERATOR
- }
- )
+ await server.usersCommand.create({ username: moderator.username, password: moderator.password, role: UserRole.MODERATOR })
server['moderatorAccessToken'] = await server.loginCommand.getAccessToken(moderator)
await uploadVideo(server.url, server.accessToken, { name: 'public ' + server.serverNumber })
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- createUser,
flushAndRunServer,
getVideosListWithToken,
getVideoWithToken,
reRunServer,
ServerInfo,
setAccessTokensToServers,
- updateMyUser,
uploadVideo,
wait
} from '@shared/extra-utils'
username: 'user_1',
password: 'super password'
}
- await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+ await server.usersCommand.create({ username: user.username, password: user.password })
userAccessToken = await server.loginCommand.getAccessToken(user)
})
})
it('Should disable videos history', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: server.accessToken,
+ await server.usersCommand.updateMe({
videosHistoryEnabled: false
})
})
it('Should re-enable videos history', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: server.accessToken,
+ await server.usersCommand.updateMe({
videosHistoryEnabled: true
})
import 'mocha'
import * as chai from 'chai'
-import {
- cleanupTests,
- flushAndRunServer,
- generateUserAccessToken,
- ServerInfo,
- setAccessTokensToServers,
- uploadVideo,
- wait
-} from '@shared/extra-utils'
+import { cleanupTests, flushAndRunServer, ServerInfo, setAccessTokensToServers, uploadVideo, wait } from '@shared/extra-utils'
import { VideosOverview } from '@shared/models'
const expect = chai.expect
})
it('Should hide muted accounts', async function () {
- const token = await generateUserAccessToken(server, 'choco')
+ const token = await server.usersCommand.generateUserAndToken('choco')
await server.blocklistCommand.addToMyBlocklist({ token, account: 'root@' + server.host })
buildAbsoluteFixturePath,
cleanupTests,
CLICommand,
- createUser,
doubleFollow,
flushAndRunServer,
getLocalIdByUUID,
- getMyUserInformation,
getVideo,
getVideosList,
ImportsCommand,
server = await flushAndRunServer(1)
await setAccessTokensToServers([ server ])
- await createUser({ url: server.url, accessToken: server.accessToken, username: 'user_1', password: 'super_password' })
+ await server.usersCommand.create({ username: 'user_1', password: 'super_password' })
userAccessToken = await server.loginCommand.getAccessToken({ username: 'user_1', password: 'super_password' })
const stdout = await cliCommand.execWithEnv(`${cmd} token --url ${server.url} --username user_1 --password super_password`)
const token = stdout.trim()
- const res = await getMyUserInformation(server.url, token)
- expect(res.body.username).to.equal('user_1')
+ const body = await server.usersCommand.getMyInfo({ token })
+ expect(body.username).to.equal('user_1')
})
it('Should display no selected instance', async function () {
ServerInfo,
setAccessTokensToServers,
setDefaultVideoChannel,
- updateMyAvatar,
uploadVideo,
wait,
waitJobs
await uploadVideo(server.url, server.accessToken, { name: 'video 1' })
await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
- await updateMyAvatar({ url: server.url, accessToken: server.accessToken, fixture: 'avatar.png' })
+ await server.usersCommand.updateMyAvatar({ fixture: 'avatar.png' })
await server.playlistsCommand.create({
attributes: {
import 'mocha'
-import { cleanupTests, CLICommand, createUser, flushAndRunServer, ServerInfo, setAccessTokensToServers } from '../../../shared/extra-utils'
+import { cleanupTests, CLICommand, flushAndRunServer, ServerInfo, setAccessTokensToServers } from '../../../shared/extra-utils'
describe('Test reset password scripts', function () {
let server: ServerInfo
server = await flushAndRunServer(1)
await setAccessTokensToServers([ server ])
- await createUser({ url: server.url, accessToken: server.accessToken, username: 'user_1', password: 'super password' })
+ await server.usersCommand.create({ username: 'user_1', password: 'super password' })
})
it('Should change the user password from CLI', async function () {
import { expect } from 'chai'
import {
cleanupTests,
- createUser,
flushAndRunServer,
getVideo,
getVideosList,
await uploadVideo(server.url, server.accessToken, videoAttributes)
// Create a user
- await createUser({ url: server.url, accessToken: server.accessToken, username: 'toto', password: 'coucou' })
+ await server.usersCommand.create({ username: 'toto', password: 'coucou' })
// Create channel
const videoChannel = {
ServerInfo,
setAccessTokensToServers,
setDefaultVideoChannel,
- updateMyUser,
uploadVideo,
waitJobs
} from '../../shared/extra-utils'
// Account
- await updateMyUser({ url: servers[0].url, accessToken: servers[0].accessToken, description: 'my account description' })
+ await servers[0].usersCommand.updateMe({ description: 'my account description' })
account = await servers[0].accountsCommand.get({ accountName: `${servers[0].user.username}@${servers[0].host}` })
import 'mocha'
import { expect } from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { User } from '@shared/models/users/user.model'
-import { blockUser, getMyUserInformation, setAccessTokensToServers, unblockUser, uploadVideo } from '../../../shared/extra-utils'
-import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
+import { cleanupTests, flushAndRunServer, ServerInfo, setAccessTokensToServers, uploadVideo } from '@shared/extra-utils'
describe('Official plugin auth-ldap', function () {
let server: ServerInfo
})
it('Should login get my profile', async function () {
- const res = await getMyUserInformation(server.url, accessToken)
- const body: User = res.body
-
+ const body = await server.usersCommand.getMyInfo({ token: accessToken })
expect(body.username).to.equal('fry')
expect(body.email).to.equal('fry@planetexpress.com')
})
it('Should not be able to login if the user is banned', async function () {
- await blockUser(server.url, userId, server.accessToken)
+ await server.usersCommand.banUser({ userId })
await server.loginCommand.login({
user: { username: 'fry@planetexpress.com', password: 'fry' },
})
it('Should be able to login if the user is unbanned', async function () {
- await unblockUser(server.url, userId, server.accessToken)
+ await server.usersCommand.unbanUser({ userId })
await server.loginCommand.login({ user: { username: 'fry@planetexpress.com', password: 'fry' } })
})
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- createUser,
doubleFollow,
flushAndRunMultipleServers,
flushAndRunServer,
- getMyUserInformation,
- getUserScopedTokens,
- renewUserScopedTokens,
ServerInfo,
setAccessTokensToServers,
uploadVideo,
uploadVideoAndGetId,
waitJobs
} from '@shared/extra-utils'
-import { User, VideoPrivacy } from '@shared/models'
-import { ScopedToken } from '@shared/models/users/user-scoped-token'
+import { VideoPrivacy } from '@shared/models'
chai.use(require('chai-xml'))
chai.use(require('chai-json-schema'))
await doubleFollow(servers[0], servers[1])
{
- const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
- const user: User = res.body
+ const user = await servers[0].usersCommand.getMyInfo()
rootAccountId = user.account.id
rootChannelId = user.videoChannels[0].id
}
{
const attr = { username: 'john', password: 'password' }
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: attr.username, password: attr.password })
+ await servers[0].usersCommand.create({ username: attr.username, password: attr.password })
userAccessToken = await servers[0].loginCommand.getAccessToken(attr)
- const res = await getMyUserInformation(servers[0].url, userAccessToken)
- const user: User = res.body
+ const user = await servers[0].usersCommand.getMyInfo({ token: userAccessToken })
userAccountId = user.account.id
userChannelId = user.videoChannels[0].id
- const res2 = await getUserScopedTokens(servers[0].url, userAccessToken)
- const token: ScopedToken = res2.body
+ const token = await servers[0].usersCommand.getMyScopedTokens({ token: userAccessToken })
userFeedToken = token.feedToken
}
it('Should list no videos for a user with no videos and no subscriptions', async function () {
const attr = { username: 'feeduser', password: 'password' }
- await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: attr.username, password: attr.password })
+ await servers[0].usersCommand.create({ username: attr.username, password: attr.password })
const feeduserAccessToken = await servers[0].loginCommand.getAccessToken(attr)
{
- const res = await getMyUserInformation(servers[0].url, feeduserAccessToken)
- const user: User = res.body
+ const user = await servers[0].usersCommand.getMyInfo({ token: feeduserAccessToken })
feeduserAccountId = user.account.id
}
{
- const res = await getUserScopedTokens(servers[0].url, feeduserAccessToken)
- const token: ScopedToken = res.body
+ const token = await servers[0].usersCommand.getMyScopedTokens({ token: feeduserAccessToken })
feeduserFeedToken = token.feedToken
}
})
it('Should renew the token, and so have an invalid old token', async function () {
- await renewUserScopedTokens(servers[0].url, userAccessToken)
+ await servers[0].usersCommand.renewMyScopedTokens({ token: userAccessToken })
const query = { accountId: userAccountId, token: userFeedToken, version: 3 }
await servers[0].feedCommand.getJSON({ feed: 'subscriptions', query, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
})
it('Should succeed with the new token', async function () {
- const res2 = await getUserScopedTokens(servers[0].url, userAccessToken)
- const token: ScopedToken = res2.body
+ const token = await servers[0].usersCommand.getMyScopedTokens({ token: userAccessToken })
userFeedToken = token.feedToken
const query = { accountId: userAccountId, token: userFeedToken, version: 4 }
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- createUser,
flushAndRunServer,
makeGetRequest,
ServerInfo,
await server.channelsCommand.create({ attributes: { name: 'channel1', displayName: 'channel 1' } })
await server.channelsCommand.create({ attributes: { name: 'channel2', displayName: 'channel 2' } })
- await createUser({ url: server.url, accessToken: server.accessToken, username: 'user1', password: 'password' })
- await createUser({ url: server.url, accessToken: server.accessToken, username: 'user2', password: 'password' })
+ await server.usersCommand.create({ username: 'user1', password: 'password' })
+ await server.usersCommand.create({ username: 'user2', password: 'password' })
const res = await makeGetRequest({
url: server.url,
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
import 'mocha'
-import { ServerHookName, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
import {
- blockUser,
- createUser,
+ cleanupTests,
+ flushAndRunMultipleServers,
+ killallServers,
PluginsCommand,
- registerUser,
- removeUser,
+ reRunServer,
+ ServerInfo,
setAccessTokensToServers,
setDefaultVideoChannel,
- unblockUser,
- updateUser,
updateVideo,
uploadVideo,
viewVideo
-} from '../../../shared/extra-utils'
-import {
- cleanupTests,
- flushAndRunMultipleServers,
- killallServers,
- reRunServer,
- ServerInfo
-} from '../../../shared/extra-utils/server/servers'
+} from '@shared/extra-utils'
+import { ServerHookName, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
describe('Test plugin action hooks', function () {
let servers: ServerInfo[]
let userId: number
it('Should run action:api.user.registered', async function () {
- await registerUser(servers[0].url, 'registered_user', 'super_password')
+ await servers[0].usersCommand.register({ username: 'registered_user' })
await checkHook('action:api.user.registered')
})
it('Should run action:api.user.created', async function () {
- const res = await createUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- username: 'created_user',
- password: 'super_password'
- })
- userId = res.body.user.id
+ const user = await servers[0].usersCommand.create({ username: 'created_user' })
+ userId = user.id
await checkHook('action:api.user.created')
})
})
it('Should run action:api.user.blocked', async function () {
- await blockUser(servers[0].url, userId, servers[0].accessToken)
+ await servers[0].usersCommand.banUser({ userId })
await checkHook('action:api.user.blocked')
})
it('Should run action:api.user.unblocked', async function () {
- await unblockUser(servers[0].url, userId, servers[0].accessToken)
+ await servers[0].usersCommand.unbanUser({ userId })
await checkHook('action:api.user.unblocked')
})
it('Should run action:api.user.updated', async function () {
- await updateUser({ url: servers[0].url, accessToken: servers[0].accessToken, userId, videoQuota: 50 })
+ await servers[0].usersCommand.update({ userId, videoQuota: 50 })
await checkHook('action:api.user.updated')
})
it('Should run action:api.user.deleted', async function () {
- await removeUser(servers[0].url, userId, servers[0].accessToken)
+ await servers[0].usersCommand.remove({ userId })
await checkHook('action:api.user.deleted')
})
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- createUser,
decodeQueryString,
flushAndRunServer,
- getMyUserInformation,
PluginsCommand,
ServerInfo,
setAccessTokensToServers,
- updateMyUser,
wait
} from '@shared/extra-utils'
-import { User, UserRole } from '@shared/models'
+import { UserRole } from '@shared/models'
async function loginExternal (options: {
server: ServerInfo
}
{
- const res = await getMyUserInformation(server.url, cyanAccessToken)
-
- const body: User = res.body
+ const body = await server.usersCommand.getMyInfo({ token: cyanAccessToken })
expect(body.username).to.equal('cyan')
expect(body.account.displayName).to.equal('cyan')
expect(body.email).to.equal('cyan@example.com')
}
{
- const res = await getMyUserInformation(server.url, kefkaAccessToken)
-
- const body: User = res.body
+ const body = await server.usersCommand.getMyInfo({ token: kefkaAccessToken })
expect(body.username).to.equal('kefka')
expect(body.account.displayName).to.equal('Kefka Palazzo')
expect(body.email).to.equal('kefka@example.com')
cyanAccessToken = resRefresh.body.access_token
cyanRefreshToken = resRefresh.body.refresh_token
- const res = await getMyUserInformation(server.url, cyanAccessToken)
- const user: User = res.body
- expect(user.username).to.equal('cyan')
+ const body = await server.usersCommand.getMyInfo({ token: cyanAccessToken })
+ expect(body.username).to.equal('cyan')
}
{
})
it('Should update Cyan profile', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: cyanAccessToken,
+ await server.usersCommand.updateMe({
+ token: cyanAccessToken,
displayName: 'Cyan Garamonde',
description: 'Retainer to the king of Doma'
})
- const res = await getMyUserInformation(server.url, cyanAccessToken)
-
- const body: User = res.body
+ const body = await server.usersCommand.getMyInfo({ token: cyanAccessToken })
expect(body.account.displayName).to.equal('Cyan Garamonde')
expect(body.account.description).to.equal('Retainer to the king of Doma')
})
it('Should have logged out Cyan', async function () {
await server.serversCommand.waitUntilLog('On logout cyan')
- await getMyUserInformation(server.url, cyanAccessToken, HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.getMyInfo({ token: cyanAccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should login Cyan and keep the old existing profile', async function () {
cyanAccessToken = res.access_token
}
- const res = await getMyUserInformation(server.url, cyanAccessToken)
-
- const body: User = res.body
+ const body = await server.usersCommand.getMyInfo({ token: cyanAccessToken })
expect(body.username).to.equal('cyan')
expect(body.account.displayName).to.equal('Cyan Garamonde')
expect(body.account.description).to.equal('Retainer to the king of Doma')
})
it('Should not update an external auth email', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: cyanAccessToken,
+ await server.usersCommand.updateMe({
+ token: cyanAccessToken,
email: 'toto@example.com',
currentPassword: 'toto',
- statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400
})
})
await wait(5000)
- await getMyUserInformation(server.url, kefkaAccessToken, HttpStatusCode.UNAUTHORIZED_401)
+ await server.usersCommand.getMyInfo({ token: kefkaAccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should unregister external-auth-2 and do not login existing Kefka', async function () {
})
it('Should not login an existing user', async function () {
- await createUser({
- url: server.url,
- accessToken: server.accessToken,
- username: 'existing_user',
- password: 'super_password'
- })
+ await server.usersCommand.create({ username: 'existing_user', password: 'super_password' })
await loginExternal({
server,
ImportsCommand,
makeRawRequest,
PluginsCommand,
- registerUser,
ServerInfo,
setAccessTokensToServers,
setDefaultVideoChannel,
})
it('Should allow a signup', async function () {
- await registerUser(servers[0].url, 'john', 'password')
+ await servers[0].usersCommand.register({ username: 'john', password: 'password' })
})
it('Should not allow a signup', async function () {
- const res = await registerUser(servers[0].url, 'jma', 'password', HttpStatusCode.FORBIDDEN_403)
+ const res = await servers[0].usersCommand.register({
+ username: 'jma',
+ password: 'password',
+ expectedStatus: HttpStatusCode.FORBIDDEN_403
+ })
expect(res.body.error).to.equal('No jma')
})
import 'mocha'
import { expect } from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import {
- cleanupTests,
- flushAndRunServer,
- getMyUserInformation,
- getUsersList,
- PluginsCommand,
- ServerInfo,
- setAccessTokensToServers,
- updateMyUser,
- wait
-} from '@shared/extra-utils'
-import { User, UserRole } from '@shared/models'
+import { cleanupTests, flushAndRunServer, PluginsCommand, ServerInfo, setAccessTokensToServers, wait } from '@shared/extra-utils'
+import { UserRole } from '@shared/models'
describe('Test id and pass auth plugins', function () {
let server: ServerInfo
it('Should login Spyro, create the user and use the token', async function () {
const accessToken = await server.loginCommand.getAccessToken({ username: 'spyro', password: 'spyro password' })
- const res = await getMyUserInformation(server.url, accessToken)
+ const body = await server.usersCommand.getMyInfo({ token: accessToken })
- const body: User = res.body
expect(body.username).to.equal('spyro')
expect(body.account.displayName).to.equal('Spyro the Dragon')
expect(body.role).to.equal(UserRole.USER)
}
{
- const res = await getMyUserInformation(server.url, crashAccessToken)
+ const body = await server.usersCommand.getMyInfo({ token: crashAccessToken })
- const body: User = res.body
expect(body.username).to.equal('crash')
expect(body.account.displayName).to.equal('Crash Bandicoot')
expect(body.role).to.equal(UserRole.MODERATOR)
}
{
- const res = await getMyUserInformation(server.url, lagunaAccessToken)
+ const body = await server.usersCommand.getMyInfo({ token: lagunaAccessToken })
- const body: User = res.body
expect(body.username).to.equal('laguna')
expect(body.account.displayName).to.equal('laguna')
expect(body.role).to.equal(UserRole.USER)
crashAccessToken = resRefresh.body.access_token
crashRefreshToken = resRefresh.body.refresh_token
- const res = await getMyUserInformation(server.url, crashAccessToken)
- const user: User = res.body
- expect(user.username).to.equal('crash')
+ const body = await server.usersCommand.getMyInfo({ token: crashAccessToken })
+ expect(body.username).to.equal('crash')
}
{
})
it('Should update Crash profile', async function () {
- await updateMyUser({
- url: server.url,
- accessToken: crashAccessToken,
+ await server.usersCommand.updateMe({
+ token: crashAccessToken,
displayName: 'Beautiful Crash',
description: 'Mutant eastern barred bandicoot'
})
- const res = await getMyUserInformation(server.url, crashAccessToken)
+ const body = await server.usersCommand.getMyInfo({ token: crashAccessToken })
- const body: User = res.body
expect(body.account.displayName).to.equal('Beautiful Crash')
expect(body.account.description).to.equal('Mutant eastern barred bandicoot')
})
it('Should have logged out Crash', async function () {
await server.serversCommand.waitUntilLog('On logout for auth 1 - 2')
- await getMyUserInformation(server.url, crashAccessToken, 401)
+ await server.usersCommand.getMyInfo({ token: crashAccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should login Crash and keep the old existing profile', async function () {
crashAccessToken = await server.loginCommand.getAccessToken({ username: 'crash', password: 'crash password' })
- const res = await getMyUserInformation(server.url, crashAccessToken)
+ const body = await server.usersCommand.getMyInfo({ token: crashAccessToken })
- const body: User = res.body
expect(body.username).to.equal('crash')
expect(body.account.displayName).to.equal('Beautiful Crash')
expect(body.account.description).to.equal('Mutant eastern barred bandicoot')
await wait(5000)
- await getMyUserInformation(server.url, lagunaAccessToken, 401)
+ await server.usersCommand.getMyInfo({ token: lagunaAccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should reject an invalid username, email, role or display name', async function () {
})
it('Should display plugin auth information in users list', async function () {
- const res = await getUsersList(server.url, server.accessToken)
-
- const users: User[] = res.body.data
+ const { data } = await server.usersCommand.list()
- const root = users.find(u => u.username === 'root')
- const crash = users.find(u => u.username === 'crash')
- const laguna = users.find(u => u.username === 'laguna')
+ const root = data.find(u => u.username === 'root')
+ const crash = data.find(u => u.username === 'crash')
+ const laguna = data.find(u => u.username === 'laguna')
expect(root.pluginAuth).to.be.null
expect(crash.pluginAuth).to.equal('peertube-plugin-test-id-pass-auth-one')
import { join } from 'path'
import { createLogger, format, transports } from 'winston'
import { assignCommands, ServerInfo } from '@shared/extra-utils'
-import { getMyUserInformation } from '@shared/extra-utils/users/users'
-import { User, UserRole } from '@shared/models'
+import { UserRole } from '@shared/models'
import { VideoPrivacy } from '../../shared/models/videos'
import { getAppNumber, isTestInstance, root } from '../helpers/core-utils'
const version = require('../../../package.json').version
async function getAdminTokenOrDie (server: ServerInfo, username: string, password: string) {
- const accessToken = await server.loginCommand.getAccessToken(username, password)
- const resMe = await getMyUserInformation(server.url, accessToken)
- const me: User = resMe.body
+ const token = await server.loginCommand.getAccessToken(username, password)
+ const me = await server.usersCommand.getMyUserInformation({ token })
if (me.role !== UserRole.ADMINISTRATOR) {
console.error('You must be an administrator.')
process.exit(-1)
}
- return accessToken
+ return token
}
interface Settings {
import { OverviewsCommand } from '../overviews'
import { SearchCommand } from '../search'
import { SocketIOCommand } from '../socket'
-import { AccountsCommand, BlocklistCommand, LoginCommand, NotificationsCommand, SubscriptionsCommand } from '../users'
+import { AccountsCommand, BlocklistCommand, LoginCommand, NotificationsCommand, SubscriptionsCommand, UsersCommand } from '../users'
import {
BlacklistCommand,
CaptionsCommand,
notificationsCommand?: NotificationsCommand
serversCommand?: ServersCommand
loginCommand?: LoginCommand
+ usersCommand?: UsersCommand
}
function flushAndRunMultipleServers (totalServers: number, configOverride?: Object) {
server.notificationsCommand = new NotificationsCommand(server)
server.serversCommand = new ServersCommand(server)
server.loginCommand = new LoginCommand(server)
+ server.usersCommand = new UsersCommand(server)
}
async function reRunServer (server: ServerInfo, configOverride?: any) {
export * from './notifications'
export * from './notifications-command'
export * from './subscriptions-command'
+export * from './users-command'
export * from './users'
login (options: OverrideCommandOptions & {
client?: { id?: string, secret?: string }
- user?: { username: string, password: string }
+ user?: { username: string, password?: string }
} = {}) {
const { client = this.server.client, user = this.server.user } = options
const path = '/api/v1/users/token'
client_id: client.id,
client_secret: client.secret,
username: user.username,
- password: user.password,
+ password: user.password ?? 'password',
response_type: 'code',
grant_type: 'password',
scope: 'upload'
}))
}
- getAccessToken (arg1?: { username: string, password: string }): Promise<string>
- getAccessToken (arg1: string, password: string): Promise<string>
- async getAccessToken (arg1?: { username: string, password: string } | string, password?: string) {
- let user: { username: string, password: string }
+ getAccessToken (arg1?: { username: string, password?: string }): Promise<string>
+ getAccessToken (arg1: string, password?: string): Promise<string>
+ async getAccessToken (arg1?: { username: string, password?: string } | string, password?: string) {
+ let user: { username: string, password?: string }
if (!arg1) user = this.server.user
else if (typeof arg1 === 'object') user = arg1
import { doubleFollow } from '../server/follows'
import { flushAndRunMultipleServers, ServerInfo } from '../server/servers'
import { setAccessTokensToServers } from './login'
-import { createUser, getMyUserInformation } from './users'
function getAllNotificationsSettings (): UserNotificationSetting {
return {
await doubleFollow(servers[0], servers[1])
}
- const user = {
- username: 'user_1',
- password: 'super password'
- }
- await createUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- username: user.username,
- password: user.password,
- videoQuota: 10 * 1000 * 1000
- })
+ const user = { username: 'user_1', password: 'super password' }
+ await servers[0].usersCommand.create({ ...user, videoQuota: 10 * 1000 * 1000 })
const userAccessToken = await servers[0].loginCommand.getAccessToken(user)
await servers[0].notificationsCommand.updateMySettings({ token: userAccessToken, settings: getAllNotificationsSettings() })
socket.on('new-notification', n => adminNotificationsServer2.push(n))
}
- const resChannel = await getMyUserInformation(servers[0].url, servers[0].accessToken)
- const channelId = resChannel.body.videoChannels[0].id
+ const { videoChannels } = await servers[0].usersCommand.getMyInfo()
+ const channelId = videoChannels[0].id
return {
userNotifications,
--- /dev/null
+import { omit, pick } from 'lodash'
+import { HttpStatusCode } from '@shared/core-utils'
+import {
+ MyUser,
+ ResultList,
+ User,
+ UserAdminFlag,
+ UserCreateResult,
+ UserRole,
+ UserUpdate,
+ UserUpdateMe,
+ UserVideoQuota,
+ UserVideoRate
+} from '@shared/models'
+import { ScopedToken } from '@shared/models/users/user-scoped-token'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class UsersCommand extends AbstractCommand {
+
+ askResetPassword (options: OverrideCommandOptions & {
+ email: string
+ }) {
+ const { email } = options
+ const path = '/api/v1/users/ask-reset-password'
+
+ return this.postBodyRequest({
+ ...options,
+
+ path,
+ fields: { email },
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ resetPassword (options: OverrideCommandOptions & {
+ userId: number
+ verificationString: string
+ password: string
+ }) {
+ const { userId, verificationString, password } = options
+ const path = '/api/v1/users/' + userId + '/reset-password'
+
+ return this.postBodyRequest({
+ ...options,
+
+ path,
+ fields: { password, verificationString },
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ // ---------------------------------------------------------------------------
+
+ askSendVerifyEmail (options: OverrideCommandOptions & {
+ email: string
+ }) {
+ const { email } = options
+ const path = '/api/v1/users/ask-send-verify-email'
+
+ return this.postBodyRequest({
+ ...options,
+
+ path,
+ fields: { email },
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ verifyEmail (options: OverrideCommandOptions & {
+ userId: number
+ verificationString: string
+ isPendingEmail?: boolean // default false
+ }) {
+ const { userId, verificationString, isPendingEmail = false } = options
+ const path = '/api/v1/users/' + userId + '/verify-email'
+
+ return this.postBodyRequest({
+ ...options,
+
+ path,
+ fields: {
+ verificationString,
+ isPendingEmail
+ },
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ // ---------------------------------------------------------------------------
+
+ banUser (options: OverrideCommandOptions & {
+ userId: number
+ reason?: string
+ }) {
+ const { userId, reason } = options
+ const path = '/api/v1/users' + '/' + userId + '/block'
+
+ return this.postBodyRequest({
+ ...options,
+
+ path,
+ fields: { reason },
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ unbanUser (options: OverrideCommandOptions & {
+ userId: number
+ }) {
+ const { userId } = options
+ const path = '/api/v1/users' + '/' + userId + '/unblock'
+
+ return this.postBodyRequest({
+ ...options,
+
+ path,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ // ---------------------------------------------------------------------------
+
+ getMyScopedTokens (options: OverrideCommandOptions = {}) {
+ const path = '/api/v1/users/scoped-tokens'
+
+ return this.getRequestBody<ScopedToken>({
+ ...options,
+
+ path,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ renewMyScopedTokens (options: OverrideCommandOptions = {}) {
+ const path = '/api/v1/users/scoped-tokens'
+
+ return this.postBodyRequest({
+ ...options,
+
+ path,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ // ---------------------------------------------------------------------------
+
+ create (options: OverrideCommandOptions & {
+ username: string
+ password?: string
+ videoQuota?: number
+ videoQuotaDaily?: number
+ role?: UserRole
+ adminFlags?: UserAdminFlag
+ }) {
+ const {
+ username,
+ adminFlags,
+ password = 'password',
+ videoQuota = 42000000,
+ videoQuotaDaily = -1,
+ role = UserRole.USER
+ } = options
+
+ const path = '/api/v1/users'
+
+ return unwrapBody<{ user: UserCreateResult }>(this.postBodyRequest({
+ ...options,
+
+ path,
+ fields: {
+ username,
+ password,
+ role,
+ adminFlags,
+ email: username + '@example.com',
+ videoQuota,
+ videoQuotaDaily
+ },
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })).then(res => res.user)
+ }
+
+ async generate (username: string) {
+ const password = 'password'
+ const user = await this.create({ username, password })
+
+ const token = await this.server.loginCommand.getAccessToken({ username, password })
+
+ const me = await this.getMyInfo({ token })
+
+ return {
+ token,
+ userId: user.id,
+ userChannelId: me.videoChannels[0].id
+ }
+ }
+
+ async generateUserAndToken (username: string) {
+ const password = 'password'
+ await this.create({ username, password })
+
+ return this.server.loginCommand.getAccessToken({ username, password })
+ }
+
+ register (options: OverrideCommandOptions & {
+ username: string
+ password?: string
+ displayName?: string
+ channel?: {
+ name: string
+ displayName: string
+ }
+ }) {
+ const { username, password = 'password', displayName, channel } = options
+ const path = '/api/v1/users/register'
+
+ return this.postBodyRequest({
+ ...options,
+
+ path,
+ fields: {
+ username,
+ password,
+ email: username + '@example.com',
+ displayName,
+ channel
+ },
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ // ---------------------------------------------------------------------------
+
+ getMyInfo (options: OverrideCommandOptions = {}) {
+ const path = '/api/v1/users/me'
+
+ return this.getRequestBody<MyUser>({
+ ...options,
+
+ path,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ getMyQuotaUsed (options: OverrideCommandOptions = {}) {
+ const path = '/api/v1/users/me/video-quota-used'
+
+ return this.getRequestBody<UserVideoQuota>({
+ ...options,
+
+ path,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ getMyRating (options: OverrideCommandOptions & {
+ videoId: number | string
+ }) {
+ const { videoId } = options
+ const path = '/api/v1/users/me/videos/' + videoId + '/rating'
+
+ return this.getRequestBody<UserVideoRate>({
+ ...options,
+
+ path,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ deleteMe (options: OverrideCommandOptions = {}) {
+ const path = '/api/v1/users/me'
+
+ return this.deleteRequest({
+ ...options,
+
+ path,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ updateMe (options: OverrideCommandOptions & UserUpdateMe) {
+ const path = '/api/v1/users/me'
+
+ const toSend: UserUpdateMe = omit(options, 'url', 'accessToken')
+
+ return this.putBodyRequest({
+ ...options,
+
+ path,
+ fields: toSend,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ updateMyAvatar (options: OverrideCommandOptions & {
+ fixture: string
+ }) {
+ const { fixture } = options
+ const path = '/api/v1/users/me/avatar/pick'
+
+ return this.updateImageRequest({
+ ...options,
+
+ path,
+ fixture,
+ fieldname: 'avatarfile',
+
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ // ---------------------------------------------------------------------------
+
+ get (options: OverrideCommandOptions & {
+ userId: number
+ withStats?: boolean // default false
+ }) {
+ const { userId, withStats } = options
+ const path = '/api/v1/users/' + userId
+
+ return this.getRequestBody<User>({
+ ...options,
+
+ path,
+ query: { withStats },
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ list (options: OverrideCommandOptions & {
+ start?: number
+ count?: number
+ sort?: string
+ search?: string
+ blocked?: boolean
+ } = {}) {
+ const path = '/api/v1/users'
+
+ return this.getRequestBody<ResultList<User>>({
+ ...options,
+
+ path,
+ query: pick(options, [ 'start', 'count', 'sort', 'search', 'blocked' ]),
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ remove (options: OverrideCommandOptions & {
+ userId: number
+ }) {
+ const { userId } = options
+ const path = '/api/v1/users/' + userId
+
+ return this.deleteRequest({
+ ...options,
+
+ path,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ update (options: OverrideCommandOptions & {
+ userId: number
+ email?: string
+ emailVerified?: boolean
+ videoQuota?: number
+ videoQuotaDaily?: number
+ password?: string
+ adminFlags?: UserAdminFlag
+ pluginAuth?: string
+ role?: UserRole
+ }) {
+ const path = '/api/v1/users/' + options.userId
+
+ const toSend: UserUpdate = {}
+ if (options.password !== undefined && options.password !== null) toSend.password = options.password
+ if (options.email !== undefined && options.email !== null) toSend.email = options.email
+ if (options.emailVerified !== undefined && options.emailVerified !== null) toSend.emailVerified = options.emailVerified
+ if (options.videoQuota !== undefined && options.videoQuota !== null) toSend.videoQuota = options.videoQuota
+ if (options.videoQuotaDaily !== undefined && options.videoQuotaDaily !== null) toSend.videoQuotaDaily = options.videoQuotaDaily
+ if (options.role !== undefined && options.role !== null) toSend.role = options.role
+ if (options.adminFlags !== undefined && options.adminFlags !== null) toSend.adminFlags = options.adminFlags
+ if (options.pluginAuth !== undefined) toSend.pluginAuth = options.pluginAuth
+
+ return this.putBodyRequest({
+ ...options,
+
+ path,
+ fields: toSend,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+}
-import { omit } from 'lodash'
import * as request from 'supertest'
import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { UserUpdateMe } from '../../models/users'
-import { UserAdminFlag } from '../../models/users/user-flag.model'
-import { UserRegister } from '../../models/users/user-register.model'
-import { UserRole } from '../../models/users/user-role'
-import { makeGetRequest, makePostBodyRequest, makePutBodyRequest, updateImageRequest } from '../requests/requests'
-import { ServerInfo } from '../server/servers'
-function createUser (parameters: {
- url: string
- accessToken: string
- username: string
- password: string
- videoQuota?: number
- videoQuotaDaily?: number
- role?: UserRole
- adminFlags?: UserAdminFlag
- specialStatus?: number
-}) {
- const {
- url,
- accessToken,
- username,
- adminFlags,
- password = 'password',
- videoQuota = 1000000,
- videoQuotaDaily = -1,
- role = UserRole.USER,
- specialStatus = HttpStatusCode.OK_200
- } = parameters
-
- const path = '/api/v1/users'
- const body = {
- username,
- password,
- role,
- adminFlags,
- email: username + '@example.com',
- videoQuota,
- videoQuotaDaily
- }
-
- return request(url)
- .post(path)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .send(body)
- .expect(specialStatus)
-}
-
-async function generateUser (server: ServerInfo, username: string) {
- const password = 'my super password'
- const resCreate = await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
-
- const token = await server.loginCommand.getAccessToken({ username, password })
-
- const resMe = await getMyUserInformation(server.url, token)
-
- return {
- token,
- userId: resCreate.body.user.id,
- userChannelId: resMe.body.videoChannels[0].id
- }
-}
-
-async function generateUserAccessToken (server: ServerInfo, username: string) {
- const password = 'my super password'
- await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
-
- return server.loginCommand.getAccessToken({ username, password })
-}
-
-function registerUser (url: string, username: string, password: string, specialStatus = HttpStatusCode.NO_CONTENT_204) {
- const path = '/api/v1/users/register'
- const body = {
- username,
- password,
- email: username + '@example.com'
- }
-
- return request(url)
- .post(path)
- .set('Accept', 'application/json')
- .send(body)
- .expect(specialStatus)
-}
-
-function registerUserWithChannel (options: {
- url: string
- user: { username: string, password: string, displayName?: string }
- channel: { name: string, displayName: string }
-}) {
- const path = '/api/v1/users/register'
- const body: UserRegister = {
- username: options.user.username,
- password: options.user.password,
- email: options.user.username + '@example.com',
- channel: options.channel
- }
-
- if (options.user.displayName) {
- Object.assign(body, { displayName: options.user.displayName })
- }
-
- return makePostBodyRequest({
- url: options.url,
- path,
- fields: body,
- statusCodeExpected: HttpStatusCode.NO_CONTENT_204
- })
-}
-
-function getMyUserInformation (url: string, accessToken: string, specialStatus = HttpStatusCode.OK_200) {
+// FIXME: delete once videos does not use it anymore
+function xxxgetMyUserInformation (url: string, accessToken: string, specialStatus = HttpStatusCode.OK_200) {
const path = '/api/v1/users/me'
return request(url)
.expect('Content-Type', /json/)
}
-function getUserScopedTokens (url: string, token: string, statusCodeExpected = HttpStatusCode.OK_200) {
- const path = '/api/v1/users/scoped-tokens'
-
- return makeGetRequest({
- url,
- path,
- token,
- statusCodeExpected
- })
-}
-
-function renewUserScopedTokens (url: string, token: string, statusCodeExpected = HttpStatusCode.OK_200) {
- const path = '/api/v1/users/scoped-tokens'
-
- return makePostBodyRequest({
- url,
- path,
- token,
- statusCodeExpected
- })
-}
-
-function deleteMe (url: string, accessToken: string, specialStatus = HttpStatusCode.NO_CONTENT_204) {
- const path = '/api/v1/users/me'
-
- return request(url)
- .delete(path)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .expect(specialStatus)
-}
-
-function getMyUserVideoQuotaUsed (url: string, accessToken: string, specialStatus = HttpStatusCode.OK_200) {
- const path = '/api/v1/users/me/video-quota-used'
-
- return request(url)
- .get(path)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .expect(specialStatus)
- .expect('Content-Type', /json/)
-}
-
-function getUserInformation (url: string, accessToken: string, userId: number, withStats = false) {
- const path = '/api/v1/users/' + userId
-
- return request(url)
- .get(path)
- .query({ withStats })
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .expect(HttpStatusCode.OK_200)
- .expect('Content-Type', /json/)
-}
-
-function getMyUserVideoRating (url: string, accessToken: string, videoId: number | string, specialStatus = HttpStatusCode.OK_200) {
- const path = '/api/v1/users/me/videos/' + videoId + '/rating'
-
- return request(url)
- .get(path)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .expect(specialStatus)
- .expect('Content-Type', /json/)
-}
-
-function getUsersList (url: string, accessToken: string) {
- const path = '/api/v1/users'
-
- return request(url)
- .get(path)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .expect(HttpStatusCode.OK_200)
- .expect('Content-Type', /json/)
-}
-
-function getUsersListPaginationAndSort (
- url: string,
- accessToken: string,
- start: number,
- count: number,
- sort: string,
- search?: string,
- blocked?: boolean
-) {
- const path = '/api/v1/users'
-
- const query = {
- start,
- count,
- sort,
- search,
- blocked
- }
-
- return request(url)
- .get(path)
- .query(query)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .expect(HttpStatusCode.OK_200)
- .expect('Content-Type', /json/)
-}
-
-function removeUser (url: string, userId: number | string, accessToken: string, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
- const path = '/api/v1/users'
-
- return request(url)
- .delete(path + '/' + userId)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .expect(expectedStatus)
-}
-
-function blockUser (
- url: string,
- userId: number | string,
- accessToken: string,
- expectedStatus = HttpStatusCode.NO_CONTENT_204,
- reason?: string
-) {
- const path = '/api/v1/users'
- let body: any
- if (reason) body = { reason }
-
- return request(url)
- .post(path + '/' + userId + '/block')
- .send(body)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .expect(expectedStatus)
-}
-
-function unblockUser (url: string, userId: number | string, accessToken: string, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
- const path = '/api/v1/users'
-
- return request(url)
- .post(path + '/' + userId + '/unblock')
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .expect(expectedStatus)
-}
-
-function updateMyUser (options: { url: string, accessToken: string, statusCodeExpected?: HttpStatusCode } & UserUpdateMe) {
- const path = '/api/v1/users/me'
-
- const toSend: UserUpdateMe = omit(options, 'url', 'accessToken')
-
- return makePutBodyRequest({
- url: options.url,
- path,
- token: options.accessToken,
- fields: toSend,
- statusCodeExpected: options.statusCodeExpected || HttpStatusCode.NO_CONTENT_204
- })
-}
-
-function updateMyAvatar (options: {
- url: string
- accessToken: string
- fixture: string
-}) {
- const path = '/api/v1/users/me/avatar/pick'
-
- return updateImageRequest({ ...options, path, fieldname: 'avatarfile' })
-}
-
-function updateUser (options: {
- url: string
- userId: number
- accessToken: string
- email?: string
- emailVerified?: boolean
- videoQuota?: number
- videoQuotaDaily?: number
- password?: string
- adminFlags?: UserAdminFlag
- pluginAuth?: string
- role?: UserRole
-}) {
- const path = '/api/v1/users/' + options.userId
-
- const toSend = {}
- if (options.password !== undefined && options.password !== null) toSend['password'] = options.password
- if (options.email !== undefined && options.email !== null) toSend['email'] = options.email
- if (options.emailVerified !== undefined && options.emailVerified !== null) toSend['emailVerified'] = options.emailVerified
- if (options.videoQuota !== undefined && options.videoQuota !== null) toSend['videoQuota'] = options.videoQuota
- if (options.videoQuotaDaily !== undefined && options.videoQuotaDaily !== null) toSend['videoQuotaDaily'] = options.videoQuotaDaily
- if (options.role !== undefined && options.role !== null) toSend['role'] = options.role
- if (options.adminFlags !== undefined && options.adminFlags !== null) toSend['adminFlags'] = options.adminFlags
- if (options.pluginAuth !== undefined) toSend['pluginAuth'] = options.pluginAuth
-
- return makePutBodyRequest({
- url: options.url,
- path,
- token: options.accessToken,
- fields: toSend,
- statusCodeExpected: HttpStatusCode.NO_CONTENT_204
- })
-}
-
-function askResetPassword (url: string, email: string) {
- const path = '/api/v1/users/ask-reset-password'
-
- return makePostBodyRequest({
- url,
- path,
- fields: { email },
- statusCodeExpected: HttpStatusCode.NO_CONTENT_204
- })
-}
-
-function resetPassword (
- url: string,
- userId: number,
- verificationString: string,
- password: string,
- statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
- const path = '/api/v1/users/' + userId + '/reset-password'
-
- return makePostBodyRequest({
- url,
- path,
- fields: { password, verificationString },
- statusCodeExpected
- })
-}
-
-function askSendVerifyEmail (url: string, email: string) {
- const path = '/api/v1/users/ask-send-verify-email'
-
- return makePostBodyRequest({
- url,
- path,
- fields: { email },
- statusCodeExpected: HttpStatusCode.NO_CONTENT_204
- })
-}
-
-function verifyEmail (
- url: string,
- userId: number,
- verificationString: string,
- isPendingEmail = false,
- statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
- const path = '/api/v1/users/' + userId + '/verify-email'
-
- return makePostBodyRequest({
- url,
- path,
- fields: {
- verificationString,
- isPendingEmail
- },
- statusCodeExpected
- })
-}
-
// ---------------------------------------------------------------------------
export {
- createUser,
- registerUser,
- getMyUserInformation,
- getMyUserVideoRating,
- deleteMe,
- registerUserWithChannel,
- getMyUserVideoQuotaUsed,
- getUsersList,
- getUsersListPaginationAndSort,
- removeUser,
- updateUser,
- updateMyUser,
- getUserInformation,
- blockUser,
- unblockUser,
- askResetPassword,
- resetPassword,
- renewUserScopedTokens,
- updateMyAvatar,
- generateUser,
- askSendVerifyEmail,
- generateUserAccessToken,
- verifyEmail,
- getUserScopedTokens
+ xxxgetMyUserInformation
}
-import { User } from '../../models/users/user.model'
import { ServerInfo } from '../server/servers'
-import { getMyUserInformation } from '../users/users'
function setDefaultVideoChannel (servers: ServerInfo[]) {
const tasks: Promise<any>[] = []
for (const server of servers) {
- const p = getMyUserInformation(server.url, server.accessToken)
- .then(res => { server.videoChannel = (res.body as User).videoChannels[0] })
+ const p = server.usersCommand.getMyInfo()
+ .then(user => { server.videoChannel = user.videoChannels[0] })
tasks.push(p)
}
import { makeGetRequest, makePutBodyRequest, makeRawRequest, makeUploadRequest } from '../requests/requests'
import { waitJobs } from '../server/jobs'
import { ServerInfo } from '../server/servers'
-import { getMyUserInformation } from '../users/users'
+import { xxxgetMyUserInformation } from '../users'
loadLanguages()
let defaultChannelId = '1'
try {
- const res = await getMyUserInformation(url, accessToken)
+ const res = await xxxgetMyUserInformation(url, accessToken)
defaultChannelId = res.body.videoChannels[0].id
} catch (e) { /* empty */ }
+export * from './user-create-result.model'
export * from './user-create.model'
export * from './user-flag.model'
export * from './user-login.model'
--- /dev/null
+export interface UserCreateResult {
+ id: number
+
+ account: {
+ id: number
+ }
+}
projects / github / Chocobozzz / PeerTube.git / commitdiff
