mirror of
https://github.com/yu-i-i/overleaf-cep.git
synced 2026-05-25 18:20:09 +02:00
626 lines
17 KiB
JavaScript
626 lines
17 KiB
JavaScript
import { expect, vi } from 'vitest'
|
|
import assert from 'assert'
|
|
import sinon from 'sinon'
|
|
import MockResponse from '../helpers/MockResponse.js'
|
|
import MockRequest from '../helpers/MockRequest.js'
|
|
|
|
const modulePath = '../../../../app/src/Features/User/UserPagesController'
|
|
|
|
describe('UserPagesController', function () {
|
|
beforeEach(async function (ctx) {
|
|
ctx.settings = {
|
|
apis: {
|
|
v1: {
|
|
url: 'some.host',
|
|
user: 'one',
|
|
pass: 'two',
|
|
},
|
|
},
|
|
}
|
|
ctx.user = {
|
|
_id: (ctx.user_id = 'kwjewkl'),
|
|
features: {},
|
|
email: 'joe@example.com',
|
|
ip_address: '1.1.1.1',
|
|
session_created: 'timestamp',
|
|
thirdPartyIdentifiers: [
|
|
{
|
|
providerId: 'google',
|
|
externalUserId: 'testId',
|
|
},
|
|
],
|
|
refProviders: {
|
|
mendeley: { encrypted: 'aaaa' },
|
|
zotero: { encrypted: 'bbbb' },
|
|
papers: { encrypted: 'cccc' },
|
|
},
|
|
}
|
|
ctx.adminEmail = 'group-admin-email@overleaf.com'
|
|
ctx.subscriptionViewModel = {
|
|
memberGroupSubscriptions: [],
|
|
}
|
|
|
|
ctx.UserGetter = {
|
|
getUser: sinon.stub(),
|
|
promises: { getUser: sinon.stub() },
|
|
}
|
|
ctx.UserSessionsManager = { getAllUserSessions: sinon.stub() }
|
|
ctx.dropboxStatus = {}
|
|
ctx.ErrorController = { notFound: sinon.stub() }
|
|
ctx.SessionManager = {
|
|
getLoggedInUserId: sinon.stub().returns(ctx.user._id),
|
|
getSessionUser: sinon.stub().returns(ctx.user),
|
|
}
|
|
ctx.NewsletterManager = {
|
|
subscribed: sinon.stub().yields(),
|
|
}
|
|
ctx.AuthenticationController = {
|
|
getRedirectFromSession: sinon.stub(),
|
|
setRedirectInSession: sinon.stub(),
|
|
}
|
|
ctx.Features = {
|
|
hasFeature: sinon.stub().returns(false),
|
|
}
|
|
ctx.PersonalAccessTokenManager = {
|
|
listTokens: sinon.stub().returns([]),
|
|
}
|
|
ctx.SubscriptionLocator = {
|
|
promises: {
|
|
getAdminEmail: sinon.stub().returns(ctx.adminEmail),
|
|
getMemberSubscriptions: sinon.stub().resolves(),
|
|
},
|
|
}
|
|
ctx.SplitTestHandler = {
|
|
promises: {
|
|
getAssignment: sinon.stub().returns('default'),
|
|
},
|
|
}
|
|
ctx.Modules = {
|
|
promises: {
|
|
hooks: {
|
|
fire: sinon.stub().resolves(),
|
|
},
|
|
},
|
|
}
|
|
|
|
vi.doMock('@overleaf/settings', () => ({
|
|
default: ctx.settings,
|
|
}))
|
|
|
|
vi.doMock('../../../../app/src/Features/User/UserGetter', () => ({
|
|
default: ctx.UserGetter,
|
|
}))
|
|
|
|
vi.doMock('../../../../app/src/Features/User/UserSessionsManager', () => ({
|
|
default: ctx.UserSessionsManager,
|
|
}))
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/Newsletter/NewsletterManager',
|
|
() => ({
|
|
default: ctx.NewsletterManager,
|
|
})
|
|
)
|
|
|
|
vi.doMock('../../../../app/src/Features/Errors/ErrorController', () => ({
|
|
default: ctx.ErrorController,
|
|
}))
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/Authentication/AuthenticationController',
|
|
() => ({
|
|
default: ctx.AuthenticationController,
|
|
})
|
|
)
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/Subscription/SubscriptionLocator',
|
|
() => ({
|
|
default: ctx.SubscriptionLocator,
|
|
})
|
|
)
|
|
|
|
vi.doMock('../../../../app/src/infrastructure/Features', () => ({
|
|
default: ctx.Features,
|
|
}))
|
|
|
|
vi.doMock(
|
|
'../../../../modules/oauth2-server/app/src/OAuthPersonalAccessTokenManager',
|
|
() => ({
|
|
default: ctx.PersonalAccessTokenManager,
|
|
})
|
|
)
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/Authentication/SessionManager',
|
|
() => ({
|
|
default: ctx.SessionManager,
|
|
})
|
|
)
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/SplitTests/SplitTestHandler',
|
|
() => ({
|
|
default: ctx.SplitTestHandler,
|
|
})
|
|
)
|
|
|
|
vi.doMock('../../../../app/src/infrastructure/Modules', () => ({
|
|
default: ctx.Modules,
|
|
}))
|
|
ctx.request = sinon.stub()
|
|
vi.doMock('request', () => ({
|
|
default: ctx.request,
|
|
}))
|
|
|
|
ctx.UserPagesController = (await import(modulePath)).default
|
|
ctx.req = new MockRequest()
|
|
ctx.req.capabilitySet = new Set()
|
|
ctx.req.session.user = ctx.user
|
|
ctx.res = new MockResponse()
|
|
})
|
|
|
|
describe('registerPage', function () {
|
|
it('should render the register page', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedTemplate.should.equal('user/register')
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.registerPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('should set sharedProjectData', async function (ctx) {
|
|
ctx.req.session.sharedProjectData = {
|
|
project_name: 'myProject',
|
|
user_first_name: 'user_first_name_here',
|
|
}
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedVariables.sharedProjectData.project_name.should.equal(
|
|
'myProject'
|
|
)
|
|
ctx.res.renderedVariables.sharedProjectData.user_first_name.should.equal(
|
|
'user_first_name_here'
|
|
)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.registerPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('should set newTemplateData', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.req.session.templateData = { templateName: 'templateName' }
|
|
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedVariables.newTemplateData.templateName.should.equal(
|
|
'templateName'
|
|
)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.registerPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('should not set the newTemplateData if there is nothing in the session', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
assert.equal(
|
|
ctx.res.renderedVariables.newTemplateData.templateName,
|
|
undefined
|
|
)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.registerPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('loginForm', function () {
|
|
it('should render the login page', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedTemplate.should.equal('user/login')
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.loginPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('when an explicit redirect is set via query string', function () {
|
|
beforeEach(function (ctx) {
|
|
ctx.AuthenticationController.getRedirectFromSession = sinon
|
|
.stub()
|
|
.returns(null)
|
|
ctx.AuthenticationController.setRedirectInSession = sinon.stub()
|
|
ctx.req.query.redir = '/somewhere/in/particular'
|
|
})
|
|
|
|
it('should set a redirect', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = page => {
|
|
ctx.AuthenticationController.setRedirectInSession.callCount.should.equal(
|
|
1
|
|
)
|
|
expect(
|
|
ctx.AuthenticationController.setRedirectInSession.lastCall.args[1]
|
|
).to.equal(ctx.req.query.redir)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.loginPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('sessionsPage', function () {
|
|
beforeEach(function (ctx) {
|
|
ctx.UserSessionsManager.getAllUserSessions.callsArgWith(2, null, [])
|
|
})
|
|
|
|
it('should render user/sessions', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedTemplate.should.equal('user/sessions')
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.sessionsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('should include current session data in the view', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
expect(ctx.res.renderedVariables.currentSession).to.deep.equal({
|
|
ip_address: '1.1.1.1',
|
|
session_created: 'timestamp',
|
|
})
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.sessionsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('should have called getAllUserSessions', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = page => {
|
|
ctx.UserSessionsManager.getAllUserSessions.callCount.should.equal(1)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.sessionsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('when getAllUserSessions produces an error', function () {
|
|
beforeEach(function (ctx) {
|
|
ctx.UserSessionsManager.getAllUserSessions.callsArgWith(
|
|
2,
|
|
new Error('woops')
|
|
)
|
|
})
|
|
|
|
it('should call next with an error', async function (ctx) {
|
|
await new Promise(resolve => {
|
|
ctx.next = err => {
|
|
assert(err !== null)
|
|
assert(err instanceof Error)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.sessionsPage(ctx.req, ctx.res, ctx.next)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('emailPreferencesPage', function () {
|
|
beforeEach(function (ctx) {
|
|
ctx.UserGetter.getUser = sinon.stub().yields(null, ctx.user)
|
|
})
|
|
|
|
it('render page with subscribed status', async function (ctx) {
|
|
ctx.NewsletterManager.subscribed.yields(null, true)
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedTemplate.should.equal('user/email-preferences')
|
|
ctx.res.renderedVariables.title.should.equal('newsletter_info_title')
|
|
ctx.res.renderedVariables.subscribed.should.equal(true)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.emailPreferencesPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('render page with unsubscribed status', async function (ctx) {
|
|
ctx.NewsletterManager.subscribed.yields(null, false)
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedTemplate.should.equal('user/email-preferences')
|
|
ctx.res.renderedVariables.title.should.equal('newsletter_info_title')
|
|
ctx.res.renderedVariables.subscribed.should.equal(false)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.emailPreferencesPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('settingsPage', function () {
|
|
beforeEach(function (ctx) {
|
|
ctx.request.get = sinon
|
|
.stub()
|
|
.callsArgWith(1, null, { statusCode: 200 }, { has_password: true })
|
|
ctx.UserGetter.promises.getUser = sinon.stub().resolves(ctx.user)
|
|
})
|
|
|
|
it('should render user/settings', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedTemplate.should.equal('user/settings')
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.settingsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('should send user', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedVariables.user.id.should.equal(ctx.user._id)
|
|
ctx.res.renderedVariables.user.email.should.equal(ctx.user.email)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.settingsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it("should set 'shouldAllowEditingDetails' to true", async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedVariables.shouldAllowEditingDetails.should.equal(true)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.settingsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('should restructure thirdPartyIdentifiers data for template use', async function (ctx) {
|
|
const expectedResult = {
|
|
google: 'testId',
|
|
}
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
expect(ctx.res.renderedVariables.thirdPartyIds).to.include(
|
|
expectedResult
|
|
)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.settingsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it("should set and clear 'projectSyncSuccessMessage'", async function (ctx) {
|
|
ctx.req.session.projectSyncSuccessMessage = 'Some Sync Success'
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedVariables.projectSyncSuccessMessage.should.equal(
|
|
'Some Sync Success'
|
|
)
|
|
expect(ctx.req.session.projectSyncSuccessMessage).to.not.exist
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.settingsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('should cast refProviders to booleans', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
expect(ctx.res.renderedVariables.user.refProviders).to.deep.equal({
|
|
mendeley: true,
|
|
papers: true,
|
|
zotero: true,
|
|
})
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.settingsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('should send the correct managed user admin email', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
expect(
|
|
ctx.res.renderedVariables.currentManagedUserAdminEmail
|
|
).to.equal(ctx.adminEmail)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.settingsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
it('should send info for groups with SSO enabled', async function (ctx) {
|
|
ctx.user.enrollment = {
|
|
sso: [
|
|
{
|
|
groupId: 'abc123abc123',
|
|
primary: true,
|
|
linkedAt: new Date(),
|
|
},
|
|
],
|
|
}
|
|
const group1 = {
|
|
_id: 'abc123abc123',
|
|
teamName: 'Group SSO Rulz',
|
|
admin_id: {
|
|
email: 'admin.email@ssolove.com',
|
|
},
|
|
linked: true,
|
|
}
|
|
const group2 = {
|
|
_id: 'def456def456',
|
|
admin_id: {
|
|
email: 'someone.else@noname.co.uk',
|
|
},
|
|
linked: false,
|
|
}
|
|
|
|
ctx.Modules.promises.hooks.fire
|
|
.withArgs('getUserGroupsSSOEnrollmentStatus')
|
|
.resolves([[group1, group2]])
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
expect(
|
|
ctx.res.renderedVariables.memberOfSSOEnabledGroups
|
|
).to.deep.equal([
|
|
{
|
|
groupId: 'abc123abc123',
|
|
groupName: 'Group SSO Rulz',
|
|
adminEmail: 'admin.email@ssolove.com',
|
|
linked: true,
|
|
},
|
|
{
|
|
groupId: 'def456def456',
|
|
groupName: undefined,
|
|
adminEmail: 'someone.else@noname.co.uk',
|
|
linked: false,
|
|
},
|
|
])
|
|
resolve()
|
|
}
|
|
|
|
ctx.UserPagesController.settingsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('when ldap.updateUserDetailsOnLogin is true', function () {
|
|
beforeEach(function (ctx) {
|
|
ctx.settings.ldap = { updateUserDetailsOnLogin: true }
|
|
})
|
|
|
|
afterEach(function (ctx) {
|
|
delete ctx.settings.ldap
|
|
})
|
|
|
|
it('should set "shouldAllowEditingDetails" to false', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedVariables.shouldAllowEditingDetails.should.equal(
|
|
false
|
|
)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.settingsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('when saml.updateUserDetailsOnLogin is true', function () {
|
|
beforeEach(function (ctx) {
|
|
ctx.settings.saml = { updateUserDetailsOnLogin: true }
|
|
})
|
|
|
|
afterEach(function (ctx) {
|
|
delete ctx.settings.saml
|
|
})
|
|
|
|
it('should set "shouldAllowEditingDetails" to false', async function (ctx) {
|
|
await new Promise((resolve, reject) => {
|
|
ctx.res.callback = () => {
|
|
ctx.res.renderedVariables.shouldAllowEditingDetails.should.equal(
|
|
false
|
|
)
|
|
resolve()
|
|
}
|
|
ctx.UserPagesController.settingsPage(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.rejectOnError(reject)
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|