ServerInfo,
setAccessTokensToServers,
uploadVideo,
- userLogin,
waitJobs
} from '../../../../shared/extra-utils'
import { Video } from '../../../../shared/models/videos'
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
}
- const userAccessToken = await userLogin(servers[0], user)
+ const userAccessToken = await servers[0].loginCommand.getAccessToken(user)
await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video root' })
const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'bad video root' })
ServerInfo,
setAccessTokensToServers,
uploadVideo,
- userLogin,
waitJobs
} from '@shared/extra-utils'
import { AbuseCreate, AbuseState } from '@shared/models'
const username = 'user1'
const password = 'my super password'
await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
- userToken = await userLogin(server, { username, password })
+ userToken = await server.loginCommand.getAccessToken({ username, password })
userToken2 = await generateUserAccessToken(server, 'user_2')
makeGetRequest,
makePostBodyRequest,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '../../../../shared/extra-utils'
import {
checkBadCountPagination,
const user = { username: 'user1', password: 'password' }
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
await doubleFollow(servers[0], servers[1])
})
createUser,
flushAndRunServer,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '../../../../shared/extra-utils'
import { makePostBodyRequest } from '../../../../shared/extra-utils/requests/requests'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
const user = { username: 'user1', password: 'password' }
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
})
describe('When removing comments of', function () {
makeGetRequest,
makePutBodyRequest,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '@shared/extra-utils'
import { CustomConfig } from '@shared/models'
password: 'password'
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
})
describe('When getting the configuration', function () {
createUser,
flushAndRunServer,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '../../../../shared/extra-utils'
import { makeGetRequest, makePutBodyRequest } from '../../../../shared/extra-utils/requests/requests'
const user = { username: 'user1', password: 'password' }
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
})
describe('When updating instance homepage', function () {
createUser,
flushAndRunServer,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '../../../../shared/extra-utils'
import { makeGetRequest } from '../../../../shared/extra-utils/requests/requests'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
password: 'my super password'
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
})
describe('When getting debug endpoint', function () {
makeDeleteRequest, makeGetRequest,
makePostBodyRequest,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '../../../../shared/extra-utils'
import {
checkBadCountPagination,
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
})
describe('When adding follows', function () {
createUser,
flushAndRunServer,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '../../../../shared/extra-utils'
import {
checkBadCountPagination,
password: 'my super password'
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
})
describe('When listing jobs', function () {
ServerInfo,
setAccessTokensToServers,
stopFfmpeg,
- uploadVideoAndGetId,
- userLogin
+ uploadVideoAndGetId
} from '../../../../shared/extra-utils'
describe('Test video lives API validator', function () {
const username = 'user1'
const password = 'my super password'
await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
- userAccessToken = await userLogin(server, { username, password })
+ userAccessToken = await server.loginCommand.getAccessToken({ username, password })
{
const res = await getMyUserInformation(server.url, server.accessToken)
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- const accessTokenUser = await userLogin(server, user)
+ const accessTokenUser = await server.loginCommand.getAccessToken(user)
const res = await getMyUserInformation(server.url, accessTokenUser)
const customChannelId = res.body.videoChannels[0].id
createUser,
flushAndRunServer,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '../../../../shared/extra-utils'
import { makeGetRequest } from '../../../../shared/extra-utils/requests/requests'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
password: 'my super password'
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
})
describe('When getting logs', function () {
makePostBodyRequest,
makePutBodyRequest,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '@shared/extra-utils'
import { PeerTubePlugin, PluginType } from '@shared/models'
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
{
const res = await server.pluginsCommand.install({ npmName: npmPlugin })
ServerInfo,
setAccessTokensToServers,
uploadVideoAndGetId,
- userLogin,
waitJobs
} from '../../../../shared/extra-utils'
}
await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(servers[0], user)
+ userAccessToken = await servers[0].loginCommand.getAccessToken(user)
videoIdLocal = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video' })).id
setDefaultVideoChannel,
updateUser,
uploadVideo,
- userLogin,
waitJobs
} from '../../../../shared/extra-utils'
const user = { username: 'registered' + randomInt(1, 1500), password: 'password' }
await registerUser(server.url, user.username, user.password)
- const userAccessToken = await userLogin(server, user)
+ const userAccessToken = await server.loginCommand.getAccessToken(user)
const videoAttributes = { fixture: 'video_short2.webm' }
for (let i = 0; i < 5; i++) {
const user = { username: 'registered' + randomInt(1, 1500), password: 'password' }
await registerUser(server.url, user.username, user.password)
- const userAccessToken = await userLogin(server, user)
+ const userAccessToken = await server.loginCommand.getAccessToken(user)
const videoAttributes = { fixture: 'video_short2.webm' }
for (let i = 0; i < 5; i++) {
makeGetRequest,
makePostBodyRequest,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '../../../../shared/extra-utils'
import {
password: 'my super password'
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
})
describe('When listing my subscriptions', function () {
ServerInfo,
setAccessTokensToServers,
unblockUser,
- uploadVideo,
- userLogin
+ uploadVideo
} from '../../../../shared/extra-utils'
import { MockSmtpServer } from '../../../../shared/extra-utils/mock-servers/mock-email'
import {
password: user.password,
videoQuota: videoQuota
})
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
}
{
role: UserRole.MODERATOR
})
- moderatorAccessToken = await userLogin(server, moderator)
+ moderatorAccessToken = await server.loginCommand.getAccessToken(moderator)
}
{
username: 'user1',
password: 'my super password'
}
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
const fields = {
username: 'user3',
ServerInfo,
setAccessTokensToServers,
uploadVideo,
- userLogin,
waitJobs
} from '@shared/extra-utils'
import { VideoBlacklistType, VideoDetails } from '@shared/models'
const username = 'user1'
const password = 'my super password'
await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: username, password: password })
- userAccessToken1 = await userLogin(servers[0], { username, 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 })
- userAccessToken2 = await userLogin(servers[0], { username, password })
+ userAccessToken2 = await servers[0].loginCommand.getAccessToken({ username, password })
}
{
makeUploadRequest,
ServerInfo,
setAccessTokensToServers,
- uploadVideo,
- userLogin
+ uploadVideo
} from '@shared/extra-utils'
import { VideoCreateResult } from '@shared/models'
password: 'my super password'
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
}
})
makePutBodyRequest,
makeUploadRequest,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '@shared/extra-utils'
import { VideoChannelUpdate } from '@shared/models'
{
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- accessTokenUser = await userLogin(server, user)
+ accessTokenUser = await server.loginCommand.getAccessToken(user)
}
command = server.channelsCommand
makePostBodyRequest,
ServerInfo,
setAccessTokensToServers,
- uploadVideo,
- userLogin
+ uploadVideo
} from '@shared/extra-utils'
import { VideoCreateResult } from '@shared/models'
{
const user = { username: 'user1', password: 'my super password' }
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ 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 })
- userAccessToken2 = await userLogin(server, user)
+ userAccessToken2 = await server.loginCommand.getAccessToken(user)
}
})
makePostBodyRequest,
makeUploadRequest,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '@shared/extra-utils'
import { VideoPrivacy } from '@shared/models'
const username = 'user1'
const password = 'my super password'
await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
- userAccessToken = await userLogin(server, { username, password })
+ userAccessToken = await server.loginCommand.getAccessToken({ username, password })
{
const res = await getMyUserInformation(server.url, server.accessToken)
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- const accessTokenUser = await userLogin(server, user)
+ const accessTokenUser = await server.loginCommand.getAccessToken(user)
const res = await getMyUserInformation(server.url, accessTokenUser)
const customChannelId = res.body.videoChannels[0].id
makeGetRequest,
ServerInfo,
setAccessTokensToServers,
- setDefaultVideoChannel,
- userLogin
+ setDefaultVideoChannel
} from '../../../../shared/extra-utils'
import { UserRole } from '../../../../shared/models/users'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
const user = { username: 'user1', password: 'my super password' }
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
const moderator = { username: 'moderator', password: 'my super password' }
await createUser(
role: UserRole.MODERATOR
}
)
- moderatorAccessToken = await userLogin(server, moderator)
+ moderatorAccessToken = await server.loginCommand.getAccessToken(moderator)
})
describe('When setting a video filter', function () {
removeVideo,
root,
ServerInfo,
- setAccessTokensToServers,
- userLogin
+ setAccessTokensToServers
} from '../../../../shared/extra-utils'
import {
checkBadCountPagination,
const username = 'user1'
const password = 'my super password'
await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
- userAccessToken = await userLogin(server, { username, password })
+ userAccessToken = await server.loginCommand.getAccessToken({ username, password })
{
const res = await getMyUserInformation(server.url, server.accessToken)
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- const accessTokenUser = await userLogin(server, user)
+ const accessTokenUser = await server.loginCommand.getAccessToken(user)
const res = await getMyUserInformation(server.url, accessTokenUser)
const customChannelId = res.body.videoChannels[0].id
setAccessTokensToServers,
uploadVideo,
uploadVideoAndGetId,
- userLogin,
waitJobs
} from '@shared/extra-utils'
import { AbuseMessage, AbusePredefinedReasonsString, AbuseState, AdminAbuse, UserAbuse } from '@shared/models'
// 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 })
- const userAccessToken = await userLogin(servers[0], user)
+ const userAccessToken = await servers[0].loginCommand.getAccessToken(user)
// upload a third video via this user
const video3Attributes = {
ServerInfo,
setAccessTokensToServers,
uploadVideo,
- userLogin,
waitJobs
} from '@shared/extra-utils'
import { UserNotificationType } from '@shared/models'
videoQuotaDaily: -1
})
- userToken1 = await userLogin(servers[0], user)
+ userToken1 = await servers[0].loginCommand.getAccessToken(user)
await uploadVideo(servers[0].url, userToken1, { name: 'video user 1' })
}
const user = { username: 'user2', password: 'password' }
await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
- userToken2 = await userLogin(servers[0], user)
+ 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 })
- remoteUserToken = await userLogin(servers[1], user)
+ remoteUserToken = await servers[1].loginCommand.getAccessToken(user)
}
await doubleFollow(servers[0], servers[1])
ServerInfo,
setAccessTokensToServers,
uploadVideo,
- userLogin,
waitJobs
} from '@shared/extra-utils'
import { UserNotificationType, Video } from '@shared/models'
const user = { username: 'user1', password: 'password' }
await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
- userToken1 = await userLogin(servers[0], user)
+ 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 })
- userModeratorToken = await userLogin(servers[0], user)
+ 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 })
- userToken2 = await userLogin(servers[1], user)
+ userToken2 = await servers[1].loginCommand.getAccessToken(user)
await uploadVideo(servers[1].url, userToken2, { name: 'video user 2' })
}
setAccessTokensToServers,
updateVideo,
uploadVideo,
- userLogin,
waitJobs
} from '@shared/extra-utils'
import { User, UserAdminFlag, UserRole, VideoBlacklist, VideoBlacklistType } from '@shared/models'
role: UserRole.USER
})
- userWithoutFlag = await userLogin(servers[0], user)
+ userWithoutFlag = await servers[0].loginCommand.getAccessToken(user)
const res = await getMyUserInformation(servers[0].url, userWithoutFlag)
const body: User = res.body
role: UserRole.USER
})
- userWithFlag = await userLogin(servers[0], user)
+ userWithFlag = await servers[0].loginCommand.getAccessToken(user)
}
await waitJobs(servers)
updateMyUser,
updateVideo,
uploadVideo,
- userLogin,
wait,
waitJobs
} from '@shared/extra-utils'
{
const user = { username: 'user1_server2', password: 'password' }
await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
- userServer2Token = await userLogin(servers[1], user)
+ userServer2Token = await servers[1].loginCommand.getAccessToken(user)
const channel = {
name: 'channel1_server2',
import 'mocha'
import * as chai from 'chai'
-import { Video } from '@shared/models'
import {
BulkCommand,
cleanupTests,
ServerInfo,
setAccessTokensToServers,
uploadVideo,
- userLogin,
waitJobs
-} from '../../../../shared/extra-utils/index'
+} from '@shared/extra-utils'
+import { Video } from '@shared/models'
const expect = chai.expect
const user = { username: 'user1', password: 'password' }
await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
- user1Token = await userLogin(servers[0], user)
+ 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 })
- user2Token = await userLogin(servers[0], user)
+ 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 })
- user3Token = await userLogin(servers[1], user)
+ user3Token = await servers[1].loginCommand.getAccessToken(user)
}
await doubleFollow(servers[0], servers[1])
setAccessTokensToServers,
unblockUser,
uploadVideo,
- userLogin,
verifyEmail
} from '../../../../shared/extra-utils'
import { MockSmtpServer } from '../../../../shared/extra-utils/mock-servers/mock-email'
const res = await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
userId = res.body.user.id
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
}
{
it('Should login with this new password', async function () {
user.password = 'super_password2'
- await userLogin(server, user)
+ await server.loginCommand.getAccessToken(user)
})
})
})
it('Should login with this new password', async function () {
- await userLogin(server, {
+ await server.loginCommand.getAccessToken({
username: 'create_password',
password: 'newly_created_password'
})
getVideoWithToken,
ServerInfo,
setAccessTokensToServers,
- uploadVideo,
- userLogin
+ uploadVideo
} from '../../../../shared/extra-utils'
const expect = chai.expect
password: 'super_password'
}
await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(servers[0], user)
+ userAccessToken = await servers[0].loginCommand.getAccessToken(user)
await doubleFollow(servers[0], servers[1])
})
setAccessTokensToServers,
testCaptionFile,
uploadVideo,
- userLogin,
waitJobs
} from '@shared/extra-utils'
import { Video, VideoPrivacy } from '@shared/models'
{
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 userLogin(servers[2], user)
+ const userAccessToken = await servers[2].loginCommand.getAccessToken(user)
const resVideos = await getVideosList(servers[2].url)
video4 = resVideos.body.data.find(v => v.name === 'server3-4')
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-import 'mocha'
-import * as chai from 'chai'
-import { cleanupTests, getVideo, registerUser, uploadVideo, userLogin, viewVideo, wait } from '../../../../shared/extra-utils'
-import { flushAndRunServer, setAccessTokensToServers } from '../../../../shared/extra-utils/index'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-
-const expect = chai.expect
+import { expect } from 'chai'
+import { HttpStatusCode } from '@shared/core-utils'
+import {
+ cleanupTests,
+ flushAndRunServer,
+ getVideo,
+ registerUser,
+ setAccessTokensToServers,
+ uploadVideo,
+ viewVideo,
+ wait
+} from '@shared/extra-utils'
describe('Test application behind a reverse proxy', function () {
let server = null
const user = { username: 'root', password: 'fail' }
for (let i = 0; i < 19; i++) {
- await userLogin(server, user, HttpStatusCode.BAD_REQUEST_400)
+ await server.loginCommand.getAccessToken(user, HttpStatusCode.BAD_REQUEST_400)
}
- await userLogin(server, user, HttpStatusCode.TOO_MANY_REQUESTS_429)
+ await server.loginCommand.getAccessToken(user, HttpStatusCode.TOO_MANY_REQUESTS_429)
})
it('Should rate limit signup', async function () {
ServerInfo,
setAccessTokensToServers,
uploadVideo,
- userLogin,
viewVideo,
wait,
waitJobs
}
{
- await userLogin(server, user)
+ await server.loginCommand.getAccessToken(user)
const data = await server.statsCommand.get()
SubscriptionsCommand,
updateVideo,
uploadVideo,
- userLogin,
waitJobs
} from '@shared/extra-utils'
const user = { username: 'user' + server.serverNumber, password: 'password' }
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- const accessToken = await userLogin(server, user)
+ const accessToken = await server.loginCommand.getAccessToken(user)
users.push({ accessToken })
const videoName1 = 'video 1-' + server.serverNumber
updateMyAvatar,
updateMyUser,
uploadVideo,
- userLogin,
waitJobs
} from '@shared/extra-utils'
import { User } from '@shared/models'
password: user.password
})
userId = res.body.user.id
- userAccessToken = await userLogin(servers[0], user)
+ userAccessToken = await servers[0].loginCommand.getAccessToken(user)
}
{
import 'mocha'
import * as chai from 'chai'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
flushAndRunServer,
getMyUserInformation,
getUserInformation,
- login,
+ MockSmtpServer,
registerUser,
ServerInfo,
+ setAccessTokensToServers,
updateMyUser,
- userLogin,
- verifyEmail
-} from '../../../../shared/extra-utils'
-import { MockSmtpServer } from '../../../../shared/extra-utils/mock-servers/mock-email'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
-import { User } from '../../../../shared/models/users'
+ verifyEmail,
+ waitJobs
+} from '@shared/extra-utils'
+import { User } from '@shared/models'
const expect = chai.expect
})
it('Should not allow login for user with unverified email', async function () {
- const resLogin = await login(server.url, server.client, user1, HttpStatusCode.BAD_REQUEST_400)
- expect(resLogin.body.detail).to.contain('User email is not verified.')
+ const { detail } = await server.loginCommand.login({ user: user1, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+ expect(detail).to.contain('User email is not verified.')
})
it('Should verify the user via email and allow login', async function () {
await verifyEmail(server.url, userId, verificationString)
- const res = await login(server.url, server.client, user1)
- userAccessToken = res.body.access_token
+ 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
await waitJobs(server)
expect(emails).to.have.lengthOf(expectedEmailsLength)
- const accessToken = await userLogin(server, user2)
+ const accessToken = await server.loginCommand.getAccessToken(user2)
const resMyUserInfo = await getMyUserInformation(server.url, accessToken)
expect(resMyUserInfo.body.emailVerified).to.be.null
}
})
- await userLogin(server, user2)
+ await server.loginCommand.getAccessToken(user2)
})
after(async function () {
getUsersListPaginationAndSort,
getVideosList,
killallServers,
- login,
- logout,
makePutBodyRequest,
rateVideo,
- refreshToken,
registerUserWithChannel,
removeUser,
removeVideo,
updateMyUser,
updateUser,
uploadVideo,
- userLogin,
waitJobs
} from '@shared/extra-utils'
import { AbuseState, MyUser, OAuth2ErrorCode, User, UserAdminFlag, UserRole, Video, VideoPlaylistType } from '@shared/models'
it('Should not login with an invalid client id', async function () {
const client = { id: 'client', secret: server.client.secret }
- const res = await login(server.url, client, server.user, HttpStatusCode.BAD_REQUEST_400)
+ const body = await server.loginCommand.login({ client, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
- expect(res.body.code).to.equal(OAuth2ErrorCode.INVALID_CLIENT)
- expect(res.body.error).to.contain('client is invalid')
- expect(res.body.type.startsWith('https://')).to.be.true
- expect(res.body.type).to.contain(OAuth2ErrorCode.INVALID_CLIENT)
+ expect(body.code).to.equal(OAuth2ErrorCode.INVALID_CLIENT)
+ expect(body.error).to.contain('client is invalid')
+ expect(body.type.startsWith('https://')).to.be.true
+ expect(body.type).to.contain(OAuth2ErrorCode.INVALID_CLIENT)
})
it('Should not login with an invalid client secret', async function () {
const client = { id: server.client.id, secret: 'coucou' }
- const res = await login(server.url, client, server.user, HttpStatusCode.BAD_REQUEST_400)
+ const body = await server.loginCommand.login({ client, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
- expect(res.body.code).to.equal(OAuth2ErrorCode.INVALID_CLIENT)
- expect(res.body.error).to.contain('client is invalid')
- expect(res.body.type.startsWith('https://')).to.be.true
- expect(res.body.type).to.contain(OAuth2ErrorCode.INVALID_CLIENT)
+ expect(body.code).to.equal(OAuth2ErrorCode.INVALID_CLIENT)
+ expect(body.error).to.contain('client is invalid')
+ expect(body.type.startsWith('https://')).to.be.true
+ expect(body.type).to.contain(OAuth2ErrorCode.INVALID_CLIENT)
})
})
it('Should not login with an invalid username', async function () {
const user = { username: 'captain crochet', password: server.user.password }
- const res = await login(server.url, server.client, user, HttpStatusCode.BAD_REQUEST_400)
+ const body = await server.loginCommand.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
- expect(res.body.code).to.equal(OAuth2ErrorCode.INVALID_GRANT)
- expect(res.body.error).to.contain('credentials are invalid')
- expect(res.body.type.startsWith('https://')).to.be.true
- expect(res.body.type).to.contain(OAuth2ErrorCode.INVALID_GRANT)
+ expect(body.code).to.equal(OAuth2ErrorCode.INVALID_GRANT)
+ expect(body.error).to.contain('credentials are invalid')
+ expect(body.type.startsWith('https://')).to.be.true
+ expect(body.type).to.contain(OAuth2ErrorCode.INVALID_GRANT)
})
it('Should not login with an invalid password', async function () {
const user = { username: server.user.username, password: 'mew_three' }
- const res = await login(server.url, server.client, user, HttpStatusCode.BAD_REQUEST_400)
+ const body = await server.loginCommand.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
- expect(res.body.code).to.equal(OAuth2ErrorCode.INVALID_GRANT)
- expect(res.body.error).to.contain('credentials are invalid')
- expect(res.body.type.startsWith('https://')).to.be.true
- expect(res.body.type).to.contain(OAuth2ErrorCode.INVALID_GRANT)
+ expect(body.code).to.equal(OAuth2ErrorCode.INVALID_GRANT)
+ expect(body.error).to.contain('credentials are invalid')
+ expect(body.type.startsWith('https://')).to.be.true
+ expect(body.type).to.contain(OAuth2ErrorCode.INVALID_GRANT)
})
it('Should not be able to upload a video', async function () {
it('Should not be able to unfollow')
it('Should be able to login', async function () {
- const res = await login(server.url, server.client, server.user, HttpStatusCode.OK_200)
+ const body = await server.loginCommand.login({ expectedStatus: HttpStatusCode.OK_200 })
- accessToken = res.body.access_token
+ accessToken = body.access_token
})
it('Should be able to login with an insensitive username', async function () {
const user = { username: 'RoOt', password: server.user.password }
- await login(server.url, server.client, user, HttpStatusCode.OK_200)
+ await server.loginCommand.login({ user, expectedStatus: HttpStatusCode.OK_200 })
const user2 = { username: 'rOoT', password: server.user.password }
- await login(server.url, server.client, user2, HttpStatusCode.OK_200)
+ await server.loginCommand.login({ user: user2, expectedStatus: HttpStatusCode.OK_200 })
const user3 = { username: 'ROOt', password: server.user.password }
- await login(server.url, server.client, user3, HttpStatusCode.OK_200)
+ await server.loginCommand.login({ user: user3, expectedStatus: HttpStatusCode.OK_200 })
})
})
describe('Logout', function () {
it('Should logout (revoke token)', async function () {
- await logout(server.url, server.accessToken)
+ await server.loginCommand.logout({ token: server.accessToken })
})
it('Should not be able to get the user information', async function () {
})
it('Should be able to login again', async function () {
- const res = await login(server.url, server.client, server.user)
- server.accessToken = res.body.access_token
- server.refreshToken = res.body.refresh_token
+ const body = await server.loginCommand.login()
+ server.accessToken = body.access_token
+ server.refreshToken = body.refresh_token
})
it('Should be able to get my user information again', async function () {
await killallServers([ server ])
await reRunServer(server)
- await getMyUserInformation(server.url, server.accessToken, 401)
+ await getMyUserInformation(server.url, server.accessToken, HttpStatusCode.UNAUTHORIZED_401)
})
it('Should not be able to refresh an access token with an expired refresh token', async function () {
- await refreshToken(server, server.refreshToken, 400)
+ await server.loginCommand.refreshToken({ refreshToken: server.refreshToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should refresh the token', async function () {
await killallServers([ server ])
await reRunServer(server)
- const res = await refreshToken(server, server.refreshToken)
+ const res = await server.loginCommand.refreshToken({ refreshToken: server.refreshToken })
server.accessToken = res.body.access_token
server.refreshToken = res.body.refresh_token
})
})
it('Should be able to login with this user', async function () {
- accessTokenUser = await userLogin(server, user)
+ accessTokenUser = await server.loginCommand.getAccessToken(user)
})
it('Should be able to get user information', async function () {
})
describe('Update my account', function () {
+
it('Should update my password', async function () {
await updateMyUser({
url: server.url,
})
user.password = 'new password'
- await userLogin(server, user, HttpStatusCode.OK_200)
+ await server.loginCommand.login({ user })
})
it('Should be able to change the NSFW display attribute', async function () {
it('Should have removed the user token', async function () {
await getMyUserVideoQuotaUsed(server.url, accessTokenUser, HttpStatusCode.UNAUTHORIZED_401)
- accessTokenUser = await userLogin(server, user)
+ accessTokenUser = await server.loginCommand.getAccessToken(user)
})
it('Should be able to update another user password', async function () {
await getMyUserVideoQuotaUsed(server.url, accessTokenUser, HttpStatusCode.UNAUTHORIZED_401)
- await userLogin(server, user, HttpStatusCode.BAD_REQUEST_400)
+ await server.loginCommand.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
user.password = 'password updated'
- accessTokenUser = await userLogin(server, user)
+ accessTokenUser = await server.loginCommand.getAccessToken(user)
})
})
})
it('Should not be able to login with this user', async function () {
- await userLogin(server, user, HttpStatusCode.BAD_REQUEST_400)
+ await server.loginCommand.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should not have videos of this user', async function () {
password: 'my super password'
}
- user15AccessToken = await userLogin(server, user15)
+ user15AccessToken = await server.loginCommand.getAccessToken(user15)
})
it('Should have the correct display name', async function () {
})
user16Id = resUser.body.user.id
- user16AccessToken = await userLogin(server, user16)
+ user16AccessToken = await server.loginCommand.getAccessToken(user16)
await getMyUserInformation(server.url, user16AccessToken, HttpStatusCode.OK_200)
await blockUser(server.url, user16Id, server.accessToken)
await getMyUserInformation(server.url, user16AccessToken, HttpStatusCode.UNAUTHORIZED_401)
- await userLogin(server, user16, HttpStatusCode.BAD_REQUEST_400)
+ await server.loginCommand.login({ user: user16, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should search user by banned status', async function () {
it('Should unblock a user', async function () {
await unblockUser(server.url, user16Id, server.accessToken)
- user16AccessToken = await userLogin(server, user16)
+ user16AccessToken = await server.loginCommand.getAccessToken(user16)
await getMyUserInformation(server.url, user16AccessToken, HttpStatusCode.OK_200)
})
})
})
user17Id = resUser.body.user.id
- user17AccessToken = await userLogin(server, user17)
+ user17AccessToken = await server.loginCommand.getAccessToken(user17)
const res = await getUserInformation(server.url, server.accessToken, user17Id, true)
const user: User = res.body
testImage,
updateVideo,
uploadVideo,
- userLogin,
viewVideo,
wait,
waitJobs,
password: 'super_password'
}
await createUser({ url: servers[1].url, accessToken: servers[1].accessToken, username: user.username, password: user.password })
- const userAccessToken = await userLogin(servers[1], user)
+ const userAccessToken = await servers[1].loginCommand.getAccessToken(user)
const videoAttributes = {
name: 'my super name for server 2',
ServerInfo,
setAccessTokensToServers,
setDefaultVideoChannel,
- uploadVideo,
- userLogin
+ uploadVideo
} from '../../../../shared/extra-utils'
import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
import { User } from '../../../../shared/models/users'
videoQuota: videoQuota
})
- firstUserToken = await userLogin(servers[0], firstUser)
- secondUserToken = await userLogin(servers[0], secondUser)
+ firstUserToken = await servers[0].loginCommand.getAccessToken(firstUser)
+ secondUserToken = await servers[0].loginCommand.getAccessToken(secondUser)
{
const res = await getMyUserInformation(servers[0].url, firstUserToken)
videoQuota: limitedVideoQuota
})
- firstUserToken = await userLogin(server, firstUser)
- secondUserToken = await userLogin(server, secondUser)
+ firstUserToken = await server.loginCommand.getAccessToken(firstUser)
+ secondUserToken = await server.loginCommand.getAccessToken(secondUser)
// Upload some videos on the server
const video1Attributes = {
testImage,
updateVideo,
uploadVideo,
- userLogin,
wait
} from '../../../../shared/extra-utils'
import { getMyUserInformation, ServerInfo, setAccessTokensToServers, viewVideo } from '../../../../shared/extra-utils/index'
{
await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: 'toto', password: 'password' })
- const accessToken = await userLogin(servers[0], { 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]
createUser,
dateIsValid,
flushAndRunServer,
- getAccessToken,
ServerInfo,
setAccessTokensToServers,
testImage,
username: 'user1',
password: 'password'
})
- userAccessTokenServer1 = await getAccessToken(server.url, 'user1', 'password')
+ userAccessTokenServer1 = await server.loginCommand.getAccessToken('user1', 'password')
command = server.commentsCommand
})
ServerInfo,
setAccessTokensToServers,
updateMyUser,
- uploadVideo,
- userLogin
+ uploadVideo
} from '@shared/extra-utils'
import { BooleanBothQuery, CustomConfig, ResultList, User, Video, VideosOverview } from '@shared/models'
const password = 'my super password'
await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
- userAccessToken = await userLogin(server, { username, password })
+ userAccessToken = await server.loginCommand.getAccessToken({ username, password })
const res = await getMyUserInformation(server.url, userAccessToken)
const user = res.body
doubleFollow,
flushAndRunMultipleServers,
generateUserAccessToken,
- getAccessToken,
getMyUserInformation,
PlaylistsCommand,
removeUser,
updateVideo,
uploadVideo,
uploadVideoAndGetId,
- userLogin,
wait,
waitJobs
} from '@shared/extra-utils'
username: 'user1',
password: 'password'
})
- userTokenServer1 = await getAccessToken(servers[0].url, 'user1', 'password')
+ userTokenServer1 = await servers[0].loginCommand.getAccessToken('user1', 'password')
}
await waitJobs(servers)
})
const userId = res.body.user.id
- const userAccessToken = await userLogin(servers[0], user)
+ const userAccessToken = await servers[0].loginCommand.getAccessToken(user)
const resChannel = await getMyUserInformation(servers[0].url, userAccessToken)
const userChannel = (resChannel.body as User).videoChannels[0]
import 'mocha'
import * as chai from 'chai'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
-import { Video, VideoCreateResult } from '@shared/models'
+import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
+ createUser,
+ doubleFollow,
flushAndRunServer,
+ getMyVideos,
+ getVideo,
getVideosList,
getVideosListWithToken,
+ getVideoWithToken,
ServerInfo,
setAccessTokensToServers,
- uploadVideo
-} from '../../../../shared/extra-utils/index'
-import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
-import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { userLogin } from '../../../../shared/extra-utils/users/login'
-import { createUser } from '../../../../shared/extra-utils/users/users'
-import { getMyVideos, getVideo, getVideoWithToken, updateVideo } from '../../../../shared/extra-utils/videos/videos'
-import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
+ updateVideo,
+ uploadVideo,
+ waitJobs
+} from '@shared/extra-utils'
+import { Video, VideoCreateResult, VideoPrivacy } from '@shared/models'
const expect = chai.expect
}
await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
- anotherUserToken = await userLogin(servers[0], user)
+ anotherUserToken = await servers[0].loginCommand.getAccessToken(user)
await getVideoWithToken(servers[0].url, anotherUserToken, privateVideoUUID, HttpStatusCode.FORBIDDEN_403)
})
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-import * as chai from 'chai'
import 'mocha'
+import * as chai from 'chai'
+import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
cleanupTests,
createUser,
makeGetRequest,
ServerInfo,
setAccessTokensToServers,
- uploadVideo,
- userLogin
+ uploadVideo
} from '../../../../shared/extra-utils'
-import { Video, VideoPrivacy } from '../../../../shared/models/videos'
import { UserRole } from '../../../../shared/models/users'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { Video, VideoPrivacy } from '../../../../shared/models/videos'
const expect = chai.expect
role: UserRole.MODERATOR
}
)
- server['moderatorAccessToken'] = await userLogin(server, moderator)
+ server['moderatorAccessToken'] = await server.loginCommand.getAccessToken(moderator)
await uploadVideo(server.url, server.accessToken, { name: 'public ' + server.serverNumber })
setAccessTokensToServers,
updateMyUser,
uploadVideo,
- userLogin,
wait
} from '@shared/extra-utils'
import { Video, VideoDetails } from '@shared/models'
password: 'super password'
}
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
- userAccessToken = await userLogin(server, user)
+ userAccessToken = await server.loginCommand.getAccessToken(user)
})
it('Should get videos, without watching history', async function () {
setAccessTokensToServers,
testHelloWorldRegisteredSettings,
uploadVideoAndGetId,
- userLogin,
waitJobs
} from '../../../shared/extra-utils'
await createUser({ url: server.url, accessToken: server.accessToken, username: 'user_1', password: 'super_password' })
- userAccessToken = await userLogin(server, { username: 'user_1', password: 'super_password' })
+ userAccessToken = await server.loginCommand.getAccessToken({ username: 'user_1', password: 'super_password' })
{
const attributes = { name: 'user_channel', displayName: 'User channel', support: 'super support text' }
import 'mocha'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import {
- cleanupTests,
- CLICommand,
- createUser,
- flushAndRunServer,
- login,
- ServerInfo,
- setAccessTokensToServers
-} from '../../../shared/extra-utils'
+import { cleanupTests, CLICommand, createUser, flushAndRunServer, ServerInfo, setAccessTokensToServers } from '../../../shared/extra-utils'
describe('Test reset password scripts', function () {
let server: ServerInfo
const env = server.cliCommand.getEnv()
await CLICommand.exec(`echo coucou | ${env} npm run reset-password -- -u user_1`)
- await login(server.url, server.client, { username: 'user_1', password: 'coucou' }, HttpStatusCode.OK_200)
+ await server.loginCommand.login({ user: { username: 'user_1', password: 'coucou' } })
})
after(async function () {
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, userLogin } from '../../../shared/extra-utils'
+import { blockUser, getMyUserInformation, setAccessTokensToServers, unblockUser, uploadVideo } from '../../../shared/extra-utils'
import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
describe('Official plugin auth-ldap', function () {
})
it('Should not login with without LDAP settings', async function () {
- await userLogin(server, { username: 'fry', password: 'fry' }, 400)
+ await server.loginCommand.login({ user: { username: 'fry', password: 'fry' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should not login with bad LDAP settings', async function () {
}
})
- await userLogin(server, { username: 'fry', password: 'fry' }, 400)
+ await server.loginCommand.login({ user: { username: 'fry', password: 'fry' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should not login with good LDAP settings but wrong username/password', async function () {
}
})
- await userLogin(server, { username: 'fry', password: 'bad password' }, 400)
- await userLogin(server, { username: 'fryr', password: 'fry' }, 400)
+ await server.loginCommand.login({ user: { username: 'fry', password: 'bad password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+ await server.loginCommand.login({ user: { username: 'fryr', password: 'fry' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should login with the appropriate username/password', async function () {
- accessToken = await userLogin(server, { username: 'fry', password: 'fry' })
+ accessToken = await server.loginCommand.getAccessToken({ username: 'fry', password: 'fry' })
})
it('Should login with the appropriate email/password', async function () {
- accessToken = await userLogin(server, { username: 'fry@planetexpress.com', password: 'fry' })
+ accessToken = await server.loginCommand.getAccessToken({ username: 'fry@planetexpress.com', password: 'fry' })
})
it('Should login get my profile', async function () {
it('Should not be able to login if the user is banned', async function () {
await blockUser(server.url, userId, server.accessToken)
- await userLogin(server, { username: 'fry@planetexpress.com', password: 'fry' }, 400)
+ await server.loginCommand.login({
+ user: { username: 'fry@planetexpress.com', password: 'fry' },
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400
+ })
})
it('Should be able to login if the user is unbanned', async function () {
await unblockUser(server.url, userId, server.accessToken)
- await userLogin(server, { username: 'fry@planetexpress.com', password: 'fry' })
+ await server.loginCommand.login({ user: { username: 'fry@planetexpress.com', password: 'fry' } })
})
it('Should not login if the plugin is uninstalled', async function () {
await server.pluginsCommand.uninstall({ npmName: 'peertube-plugin-auth-ldap' })
- await userLogin(server, { username: 'fry@planetexpress.com', password: 'fry' }, 400)
+ await server.loginCommand.login({
+ user: { username: 'fry@planetexpress.com', password: 'fry' },
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400
+ })
})
after(async function () {
setAccessTokensToServers,
uploadVideo,
uploadVideoAndGetId,
- userLogin,
waitJobs
} from '@shared/extra-utils'
import { User, VideoPrivacy } from '@shared/models'
{
const attr = { username: 'john', password: 'password' }
await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: attr.username, password: attr.password })
- userAccessToken = await userLogin(servers[0], attr)
+ userAccessToken = await servers[0].loginCommand.getAccessToken(attr)
const res = await getMyUserInformation(servers[0].url, userAccessToken)
const user: User = res.body
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 })
- const feeduserAccessToken = await userLogin(servers[0], attr)
+ const feeduserAccessToken = await servers[0].loginCommand.getAccessToken(attr)
{
const res = await getMyUserInformation(servers[0].url, feeduserAccessToken)
updateUser,
updateVideo,
uploadVideo,
- userLogin,
viewVideo
} from '../../../shared/extra-utils'
import {
})
it('Should run action:api.user.oauth2-got-token', async function () {
- await userLogin(servers[0], { username: 'created_user', password: 'super_password' })
+ await servers[0].loginCommand.getAccessToken('created_user', 'super_password')
await checkHook('action:api.user.oauth2-got-token')
})
decodeQueryString,
flushAndRunServer,
getMyUserInformation,
- loginUsingExternalToken,
- logout,
PluginsCommand,
- refreshToken,
ServerInfo,
setAccessTokensToServers,
updateMyUser,
- userLogin,
wait
} from '@shared/extra-utils'
import { User, UserRole } from '@shared/models'
const location = res.header.location
const { externalAuthToken } = decodeQueryString(location)
- const resLogin = await loginUsingExternalToken(
- options.server,
- options.username,
- externalAuthToken as string,
- options.statusCodeExpectedStep2
- )
+ const resLogin = await options.server.loginCommand.loginUsingExternalToken({
+ username: options.username,
+ externalAuthToken: externalAuthToken as string,
+ expectedStatus: options.statusCodeExpectedStep2
+ })
return resLogin.body
}
})
it('Should reject auto external login with a missing or invalid token', async function () {
- await loginUsingExternalToken(server, 'cyan', '', HttpStatusCode.BAD_REQUEST_400)
- await loginUsingExternalToken(server, 'cyan', 'blabla', HttpStatusCode.BAD_REQUEST_400)
+ const command = server.loginCommand
+
+ await command.loginUsingExternalToken({ username: 'cyan', externalAuthToken: '', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+ await command.loginUsingExternalToken({ username: 'cyan', externalAuthToken: 'blabla', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should reject auto external login with a missing or invalid username', async function () {
- await loginUsingExternalToken(server, '', externalAuthToken, HttpStatusCode.BAD_REQUEST_400)
- await loginUsingExternalToken(server, '', externalAuthToken, HttpStatusCode.BAD_REQUEST_400)
+ const command = server.loginCommand
+
+ await command.loginUsingExternalToken({ username: '', externalAuthToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+ await command.loginUsingExternalToken({ username: '', externalAuthToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should reject auto external login with an expired token', async function () {
await wait(5000)
- await loginUsingExternalToken(server, 'cyan', externalAuthToken, HttpStatusCode.BAD_REQUEST_400)
+ await server.loginCommand.loginUsingExternalToken({
+ username: 'cyan',
+ externalAuthToken,
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400
+ })
await server.serversCommand.waitUntilLog('expired external auth token', 2)
})
it('Should refresh Cyan token, but not Kefka token', async function () {
{
- const resRefresh = await refreshToken(server, cyanRefreshToken)
+ const resRefresh = await server.loginCommand.refreshToken({ refreshToken: cyanRefreshToken })
cyanAccessToken = resRefresh.body.access_token
cyanRefreshToken = resRefresh.body.refresh_token
}
{
- await refreshToken(server, kefkaRefreshToken, HttpStatusCode.BAD_REQUEST_400)
+ await server.loginCommand.refreshToken({ refreshToken: kefkaRefreshToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}
})
})
it('Should logout Cyan', async function () {
- await logout(server.url, cyanAccessToken)
+ await server.loginCommand.logout({ token: cyanAccessToken })
})
it('Should have logged out Cyan', async function () {
settings: { disableKefka: true }
})
- await userLogin(server, { username: 'kefka', password: 'fake' }, HttpStatusCode.BAD_REQUEST_400)
+ await server.loginCommand.login({ user: { username: 'kefka', password: 'fake' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
await loginExternal({
server,
statusCodeExpected: HttpStatusCode.NOT_FOUND_404
})
- await userLogin(server, { username: 'cyan', password: null }, HttpStatusCode.BAD_REQUEST_400)
- await userLogin(server, { username: 'cyan', password: '' }, HttpStatusCode.BAD_REQUEST_400)
- await userLogin(server, { username: 'cyan', password: 'fake' }, HttpStatusCode.BAD_REQUEST_400)
+ await server.loginCommand.login({ user: { username: 'cyan', password: null }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+ await server.loginCommand.login({ user: { username: 'cyan', password: '' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+ await server.loginCommand.login({ user: { username: 'cyan', password: 'fake' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should not login kefka with another plugin', async function () {
username: 'cid'
})
- const resLogout = await logout(server.url, resLogin.access_token)
-
- expect(resLogout.body.redirectUrl).to.equal('https://example.com/redirectUrl')
+ const { redirectUrl } = await server.loginCommand.logout({ token: resLogin.access_token })
+ expect(redirectUrl).to.equal('https://example.com/redirectUrl')
})
it('Should call the plugin\'s onLogout method with the request', async function () {
username: 'cid'
})
- const resLogout = await logout(server.url, resLogin.access_token)
-
- expect(resLogout.body.redirectUrl).to.equal('https://example.com/redirectUrl?access_token=' + resLogin.access_token)
+ const { redirectUrl } = await server.loginCommand.logout({ token: resLogin.access_token })
+ expect(redirectUrl).to.equal('https://example.com/redirectUrl?access_token=' + resLogin.access_token)
})
})
import 'mocha'
import { expect } from 'chai'
+import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
flushAndRunServer,
getMyUserInformation,
getUsersList,
- login,
- logout,
PluginsCommand,
- refreshToken,
ServerInfo,
setAccessTokensToServers,
updateMyUser,
- userLogin,
wait
} from '@shared/extra-utils'
import { User, UserRole } from '@shared/models'
})
it('Should not login', async function () {
- await userLogin(server, { username: 'toto', password: 'password' }, 400)
+ await server.loginCommand.login({ user: { username: 'toto', password: 'password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should login Spyro, create the user and use the token', async function () {
- const accessToken = await userLogin(server, { username: 'spyro', password: 'spyro password' })
+ const accessToken = await server.loginCommand.getAccessToken({ username: 'spyro', password: 'spyro password' })
const res = await getMyUserInformation(server.url, accessToken)
it('Should login Crash, create the user and use the token', async function () {
{
- const res = await login(server.url, server.client, { username: 'crash', password: 'crash password' })
- crashAccessToken = res.body.access_token
- crashRefreshToken = res.body.refresh_token
+ const body = await server.loginCommand.login({ user: { username: 'crash', password: 'crash password' } })
+ crashAccessToken = body.access_token
+ crashRefreshToken = body.refresh_token
}
{
it('Should login the first Laguna, create the user and use the token', async function () {
{
- const res = await login(server.url, server.client, { username: 'laguna', password: 'laguna password' })
- lagunaAccessToken = res.body.access_token
- lagunaRefreshToken = res.body.refresh_token
+ const body = await server.loginCommand.login({ user: { username: 'laguna', password: 'laguna password' } })
+ lagunaAccessToken = body.access_token
+ lagunaRefreshToken = body.refresh_token
}
{
it('Should refresh crash token, but not laguna token', async function () {
{
- const resRefresh = await refreshToken(server, crashRefreshToken)
+ const resRefresh = await server.loginCommand.refreshToken({ refreshToken: crashRefreshToken })
crashAccessToken = resRefresh.body.access_token
crashRefreshToken = resRefresh.body.refresh_token
}
{
- await refreshToken(server, lagunaRefreshToken, 400)
+ await server.loginCommand.refreshToken({ refreshToken: lagunaRefreshToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}
})
})
it('Should logout Crash', async function () {
- await logout(server.url, crashAccessToken)
+ await server.loginCommand.logout({ token: crashAccessToken })
})
it('Should have logged out Crash', async function () {
})
it('Should login Crash and keep the old existing profile', async function () {
- crashAccessToken = await userLogin(server, { username: 'crash', password: 'crash password' })
+ crashAccessToken = await server.loginCommand.getAccessToken({ username: 'crash', password: 'crash password' })
const res = await getMyUserInformation(server.url, crashAccessToken)
})
it('Should reject an invalid username, email, role or display name', async function () {
- await userLogin(server, { username: 'ward', password: 'ward password' }, 400)
+ const command = server.loginCommand
+
+ await command.login({ user: { username: 'ward', password: 'ward password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
await server.serversCommand.waitUntilLog('valid username')
- await userLogin(server, { username: 'kiros', password: 'kiros password' }, 400)
+ await command.login({ user: { username: 'kiros', password: 'kiros password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
await server.serversCommand.waitUntilLog('valid display name')
- await userLogin(server, { username: 'raine', password: 'raine password' }, 400)
+ await command.login({ user: { username: 'raine', password: 'raine password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
await server.serversCommand.waitUntilLog('valid role')
- await userLogin(server, { username: 'ellone', password: 'elonne password' }, 400)
+ await command.login({ user: { username: 'ellone', password: 'elonne password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
await server.serversCommand.waitUntilLog('valid email')
})
settings: { disableSpyro: true }
})
- await userLogin(server, { username: 'spyro', password: 'spyro password' }, 400)
- await userLogin(server, { username: 'spyro', password: 'fake' }, 400)
+ const command = server.loginCommand
+ await command.login({ user: { username: 'spyro', password: 'spyro password' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+ await command.login({ user: { username: 'spyro', password: 'fake' }, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
})
it('Should have disabled this auth', async function () {
it('Should uninstall the plugin one and do not login existing Crash', async function () {
await server.pluginsCommand.uninstall({ npmName: 'peertube-plugin-test-id-pass-auth-one' })
- await userLogin(server, { username: 'crash', password: 'crash password' }, 400)
+ await server.loginCommand.login({
+ user: { username: 'crash', password: 'crash password' },
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400
+ })
})
it('Should display the correct configuration', async function () {
range?: string
redirects?: number
accept?: string
+ host?: string
}) {
if (!options.statusCodeExpected) options.statusCodeExpected = HttpStatusCode.BAD_REQUEST_400
if (options.contentType === undefined) options.contentType = 'application/json'
if (options.query) req.query(options.query)
if (options.range) req.set('Range', options.range)
if (options.accept) req.set('Accept', options.accept)
+ if (options.host) req.set('Host', options.host)
if (options.redirects) req.redirects(options.redirects)
return req.expect(options.statusCodeExpected)
path: string
token?: string
fields?: { [ fieldName: string ]: any }
+ type?: string
statusCodeExpected?: HttpStatusCode
}) {
if (!options.fields) options.fields = {}
.set('Accept', 'application/json')
if (options.token) req.set('Authorization', 'Bearer ' + options.token)
+ if (options.type) req.type(options.type)
return req.send(options.fields)
.expect(options.statusCodeExpected)
+++ /dev/null
-import * as request from 'supertest'
-import { URL } from 'url'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getClient (url: string) {
- const path = '/api/v1/oauth-clients/local'
-
- return request(url)
- .get(path)
- .set('Host', new URL(url).host)
- .set('Accept', 'application/json')
- .expect(HttpStatusCode.OK_200)
- .expect('Content-Type', /json/)
-}
-
-// ---------------------------------------------------------------------------
-
-export {
- getClient
-}
import { OverviewsCommand } from '../overviews'
import { SearchCommand } from '../search'
import { SocketIOCommand } from '../socket'
-import { AccountsCommand, BlocklistCommand, NotificationsCommand, SubscriptionsCommand } from '../users'
+import { AccountsCommand, BlocklistCommand, LoginCommand, NotificationsCommand, SubscriptionsCommand } from '../users'
import {
BlacklistCommand,
CaptionsCommand,
sqlCommand?: SQLCommand
notificationsCommand?: NotificationsCommand
serversCommand?: ServersCommand
+ loginCommand?: LoginCommand
}
function flushAndRunMultipleServers (totalServers: number, configOverride?: Object) {
server.sqlCommand = new SQLCommand(server)
server.notificationsCommand = new NotificationsCommand(server)
server.serversCommand = new ServersCommand(server)
+ server.loginCommand = new LoginCommand(server)
}
async function reRunServer (server: ServerInfo, configOverride?: any) {
accept?: string
redirects?: number
range?: string
+ host?: string
}
abstract class AbstractCommand {
}
protected getRequest (options: InternalGetCommandOptions) {
- const { redirects, query, contentType, accept, range } = options
+ const { redirects, query, contentType, accept, range, host } = options
return makeGetRequest({
...this.buildCommonRequestOptions(options),
query,
contentType,
range,
+ host,
accept
})
}
protected postBodyRequest (options: InternalCommonCommandOptions & {
fields?: { [ fieldName: string ]: any }
+ type?: string
}) {
- const { fields } = options
+ const { type, fields } = options
return makePostBodyRequest({
...this.buildCommonRequestOptions(options),
- fields
+ fields,
+ type
})
}
export * from './accounts'
export * from './blocklist-command'
export * from './login'
+export * from './login-command'
export * from './notifications'
export * from './notifications-command'
export * from './subscriptions-command'
--- /dev/null
+import { PeerTubeRequestError } from '@server/helpers/requests'
+import { HttpStatusCode } from '@shared/core-utils'
+import { PeerTubeProblemDocument } from '@shared/models'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class LoginCommand extends AbstractCommand {
+
+ login (options: OverrideCommandOptions & {
+ client?: { id?: string, secret?: string }
+ user?: { username: string, password: string }
+ } = {}) {
+ const { client = this.server.client, user = this.server.user } = options
+ const path = '/api/v1/users/token'
+
+ const body = {
+ client_id: client.id,
+ client_secret: client.secret,
+ username: user.username,
+ password: user.password,
+ response_type: 'code',
+ grant_type: 'password',
+ scope: 'upload'
+ }
+
+ return unwrapBody<{ access_token: string, refresh_token: string } & PeerTubeProblemDocument>(this.postBodyRequest({
+ ...options,
+
+ path,
+ type: 'form',
+ fields: body,
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ }))
+ }
+
+ getAccessToken (user?: { username: string, password: string }): Promise<string>
+ getAccessToken (username: 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
+ else user = { username: arg1, password }
+
+ try {
+ const body = await this.login({ user })
+
+ return body.access_token
+ } catch (err) {
+ throw new Error('Cannot authenticate. Please check your username/password.')
+ }
+ }
+
+ loginUsingExternalToken (options: OverrideCommandOptions & {
+ username: string
+ externalAuthToken: string
+ }) {
+ const { username, externalAuthToken } = options
+ const path = '/api/v1/users/token'
+
+ const body = {
+ client_id: this.server.client.id,
+ client_secret: this.server.client.secret,
+ username: username,
+ response_type: 'code',
+ grant_type: 'password',
+ scope: 'upload',
+ externalAuthToken
+ }
+
+ return this.postBodyRequest({
+ ...options,
+
+ path,
+ type: 'form',
+ fields: body,
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ logout (options: OverrideCommandOptions & {
+ token: string
+ }) {
+ const path = '/api/v1/users/revoke-token'
+
+ return unwrapBody<{ redirectUrl: string }>(this.postBodyRequest({
+ ...options,
+
+ path,
+ type: 'form',
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ }))
+ }
+
+ refreshToken (options: OverrideCommandOptions & {
+ refreshToken: string
+ }) {
+ const path = '/api/v1/users/token'
+
+ const body = {
+ client_id: this.server.client.id,
+ client_secret: this.server.client.secret,
+ refresh_token: options.refreshToken,
+ response_type: 'code',
+ grant_type: 'refresh_token'
+ }
+
+ return this.postBodyRequest({
+ ...options,
+
+ path,
+ type: 'form',
+ fields: body,
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ getClient (options: OverrideCommandOptions = {}) {
+ const path = '/api/v1/oauth-clients/local'
+
+ return this.getRequestBody<{ client_id: string, client_secret: string }>({
+ ...options,
+
+ path,
+ host: this.server.host,
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+}
-import * as request from 'supertest'
-
import { ServerInfo } from '../server/servers'
-import { getClient } from '../server/clients'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-type Client = { id?: string, secret?: string }
-type User = { username: string, password: string }
-type Server = { url?: string, client?: Client, user?: User }
-
-function login (url: string, client: Client, user: User, expectedStatus = HttpStatusCode.OK_200) {
- const path = '/api/v1/users/token'
-
- const body = {
- client_id: client.id,
- client_secret: client.secret,
- username: user.username,
- password: user.password,
- response_type: 'code',
- grant_type: 'password',
- scope: 'upload'
- }
-
- return request(url)
- .post(path)
- .type('form')
- .send(body)
- .expect(expectedStatus)
-}
-
-function logout (url: string, token: string, expectedStatus = HttpStatusCode.OK_200) {
- const path = '/api/v1/users/revoke-token'
-
- return request(url)
- .post(path)
- .set('Authorization', 'Bearer ' + token)
- .type('form')
- .expect(expectedStatus)
-}
-
-async function serverLogin (server: Server) {
- const res = await login(server.url, server.client, server.user, HttpStatusCode.OK_200)
-
- return res.body.access_token as string
-}
-
-function refreshToken (server: ServerInfo, refreshToken: string, expectedStatus = HttpStatusCode.OK_200) {
- const path = '/api/v1/users/token'
-
- const body = {
- client_id: server.client.id,
- client_secret: server.client.secret,
- refresh_token: refreshToken,
- response_type: 'code',
- grant_type: 'refresh_token'
- }
-
- return request(server.url)
- .post(path)
- .type('form')
- .send(body)
- .expect(expectedStatus)
-}
-
-async function userLogin (server: Server, user: User, expectedStatus = HttpStatusCode.OK_200) {
- const res = await login(server.url, server.client, user, expectedStatus)
-
- return res.body.access_token as string
-}
-
-async function getAccessToken (url: string, username: string, password: string) {
- const resClient = await getClient(url)
- const client = {
- id: resClient.body.client_id,
- secret: resClient.body.client_secret
- }
-
- const user = { username, password }
-
- try {
- const res = await login(url, client, user)
- return res.body.access_token
- } catch (err) {
- throw new Error('Cannot authenticate. Please check your username/password.')
- }
-}
function setAccessTokensToServers (servers: ServerInfo[]) {
const tasks: Promise<any>[] = []
for (const server of servers) {
- const p = serverLogin(server).then(t => { server.accessToken = t })
+ const p = server.loginCommand.getAccessToken()
+ .then(t => { server.accessToken = t })
tasks.push(p)
}
return Promise.all(tasks)
}
-function loginUsingExternalToken (server: Server, username: string, externalAuthToken: string, expectedStatus = HttpStatusCode.OK_200) {
- const path = '/api/v1/users/token'
-
- const body = {
- client_id: server.client.id,
- client_secret: server.client.secret,
- username: username,
- response_type: 'code',
- grant_type: 'password',
- scope: 'upload',
- externalAuthToken
- }
-
- return request(server.url)
- .post(path)
- .type('form')
- .send(body)
- .expect(expectedStatus)
-}
-
// ---------------------------------------------------------------------------
export {
- login,
- logout,
- serverLogin,
- refreshToken,
- userLogin,
- getAccessToken,
- setAccessTokensToServers,
- Server,
- Client,
- User,
- loginUsingExternalToken
+ setAccessTokensToServers
}
import { MockSmtpServer } from '../mock-servers/mock-email'
import { doubleFollow } from '../server/follows'
import { flushAndRunMultipleServers, ServerInfo } from '../server/servers'
-import { setAccessTokensToServers, userLogin } from './login'
+import { setAccessTokensToServers } from './login'
import { createUser, getMyUserInformation } from './users'
function getAllNotificationsSettings (): UserNotificationSetting {
password: user.password,
videoQuota: 10 * 1000 * 1000
})
- const userAccessToken = await userLogin(servers[0], user)
+ const userAccessToken = await servers[0].loginCommand.getAccessToken(user)
await servers[0].notificationsCommand.updateMySettings({ token: userAccessToken, settings: getAllNotificationsSettings() })
await servers[0].notificationsCommand.updateMySettings({ settings: getAllNotificationsSettings() })
import { UserRole } from '../../models/users/user-role'
import { makeGetRequest, makePostBodyRequest, makePutBodyRequest, updateImageRequest } from '../requests/requests'
import { ServerInfo } from '../server/servers'
-import { userLogin } from './login'
function createUser (parameters: {
url: string
const password = 'my super password'
const resCreate = await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
- const token = await userLogin(server, { username, password })
+ const token = await server.loginCommand.getAccessToken({ username, password })
const resMe = await getMyUserInformation(server.url, token)
const password = 'my super password'
await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
- return userLogin(server, { username, password })
+ return server.loginCommand.getAccessToken({ username, password })
}
function registerUser (url: string, username: string, password: string, specialStatus = HttpStatusCode.NO_CONTENT_204) {
projects / github / Chocobozzz / PeerTube.git / commitdiff
