mirror of
https://github.com/yu-i-i/overleaf-cep.git
synced 2026-05-27 11:01:56 +02:00
396 lines
11 KiB
JavaScript
396 lines
11 KiB
JavaScript
import { vi, expect } from 'vitest'
|
|
import sinon from 'sinon'
|
|
import { RequestFailedError } from '@overleaf/fetch-utils'
|
|
import Errors from '../../../../app/src/Features/Errors/Errors.js'
|
|
import mongodb from 'mongodb-legacy'
|
|
|
|
const { ObjectId } = mongodb
|
|
|
|
const modulePath = '../../../../app/src/Features/History/HistoryController.mjs'
|
|
|
|
describe('HistoryController', function () {
|
|
beforeEach(async function (ctx) {
|
|
ctx.callback = sinon.stub()
|
|
ctx.user_id = 'user-id-123'
|
|
ctx.project_id = '000000000000000012345678'
|
|
ctx.blobHash = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
|
|
ctx.stream = sinon.stub()
|
|
ctx.fetchResponse = {
|
|
headers: {
|
|
get: sinon.stub(),
|
|
},
|
|
}
|
|
ctx.next = sinon.stub()
|
|
|
|
ctx.SessionManager = {
|
|
getLoggedInUserId: sinon.stub().returns(ctx.user_id),
|
|
}
|
|
|
|
ctx.Stream = {
|
|
pipeline: sinon.stub().resolves(),
|
|
}
|
|
|
|
ctx.HistoryManager = {
|
|
promises: {
|
|
injectUserDetails: sinon.stub(),
|
|
requestBlobWithProjectId: sinon.stub(),
|
|
},
|
|
}
|
|
|
|
ctx.ProjectEntityUpdateHandler = {
|
|
promises: {
|
|
resyncProjectHistory: sinon.stub().resolves(),
|
|
},
|
|
}
|
|
|
|
ctx.fetchJson = sinon.stub()
|
|
ctx.fetchStream = sinon.stub().resolves(ctx.stream)
|
|
ctx.fetchStreamWithResponse = sinon
|
|
.stub()
|
|
.resolves({ stream: ctx.stream, response: ctx.fetchResponse })
|
|
ctx.fetchNothing = sinon.stub().resolves()
|
|
|
|
vi.mock('../../../../app/src/Features/Errors/Errors.js', () =>
|
|
vi.importActual('../../../../app/src/Features/Errors/Errors.js')
|
|
)
|
|
|
|
vi.doMock('stream/promises', () => ctx.Stream)
|
|
|
|
vi.doMock('@overleaf/settings', () => ({
|
|
default: (ctx.settings = {}),
|
|
}))
|
|
|
|
vi.doMock('@overleaf/fetch-utils', () => ({
|
|
fetchJson: ctx.fetchJson,
|
|
fetchStream: ctx.fetchStream,
|
|
fetchStreamWithResponse: ctx.fetchStreamWithResponse,
|
|
fetchNothing: ctx.fetchNothing,
|
|
}))
|
|
|
|
vi.doMock('../../../../app/src/infrastructure/mongodb.mjs', () => ({
|
|
default: { ObjectId },
|
|
}))
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/Authentication/SessionManager.mjs',
|
|
() => ({
|
|
default: ctx.SessionManager,
|
|
})
|
|
)
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/History/HistoryManager.mjs',
|
|
() => ({
|
|
default: ctx.HistoryManager,
|
|
})
|
|
)
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/Project/ProjectDetailsHandler.mjs',
|
|
() => ({
|
|
default: (ctx.ProjectDetailsHandler = {}),
|
|
})
|
|
)
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/Project/ProjectEntityUpdateHandler.mjs',
|
|
() => ({
|
|
default: ctx.ProjectEntityUpdateHandler,
|
|
})
|
|
)
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/Project/ProjectAuditLogHandler.mjs',
|
|
() => ({
|
|
default: (ctx.ProjectAuditLogHandler = {
|
|
addEntryIfManagedInBackground: sinon.stub(),
|
|
}),
|
|
})
|
|
)
|
|
|
|
vi.doMock('../../../../app/src/Features/User/UserGetter.mjs', () => ({
|
|
default: (ctx.UserGetter = {}),
|
|
}))
|
|
|
|
vi.doMock('../../../../app/src/Features/Project/ProjectGetter.mjs', () => ({
|
|
default: (ctx.ProjectGetter = {}),
|
|
}))
|
|
|
|
vi.doMock(
|
|
'../../../../app/src/Features/History/RestoreManager.mjs',
|
|
() => ({
|
|
default: (ctx.RestoreManager = {}),
|
|
})
|
|
)
|
|
|
|
vi.doMock('../../../../app/src/infrastructure/Features.mjs', () => ({
|
|
default: (ctx.Features = sinon.stub().withArgs('saas').returns(true)),
|
|
}))
|
|
|
|
ctx.HistoryController = (await import(modulePath)).default
|
|
ctx.settings.apis = {
|
|
project_history: {
|
|
url: 'http://project_history.example.com',
|
|
},
|
|
}
|
|
})
|
|
|
|
describe('proxyToHistoryApi', function () {
|
|
beforeEach(async function (ctx) {
|
|
ctx.req = { url: '/mock/url', method: 'POST', session: sinon.stub() }
|
|
ctx.res = {
|
|
set: sinon.stub(),
|
|
}
|
|
ctx.contentType = 'application/json'
|
|
ctx.contentLength = 212
|
|
ctx.fetchResponse.headers.get
|
|
.withArgs('Content-Type')
|
|
.returns(ctx.contentType)
|
|
ctx.fetchResponse.headers.get
|
|
.withArgs('Content-Length')
|
|
.returns(ctx.contentLength)
|
|
await ctx.HistoryController.proxyToHistoryApi(ctx.req, ctx.res, ctx.next)
|
|
})
|
|
|
|
it('should get the user id', function (ctx) {
|
|
ctx.SessionManager.getLoggedInUserId.should.have.been.calledWith(
|
|
ctx.req.session
|
|
)
|
|
})
|
|
|
|
it('should call the project history api', function (ctx) {
|
|
ctx.fetchStreamWithResponse.should.have.been.calledWith(
|
|
`${ctx.settings.apis.project_history.url}${ctx.req.url}`,
|
|
{
|
|
method: ctx.req.method,
|
|
headers: {
|
|
'X-User-Id': ctx.user_id,
|
|
},
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should pipe the response to the client', function (ctx) {
|
|
expect(ctx.Stream.pipeline).to.have.been.calledWith(ctx.stream, ctx.res)
|
|
})
|
|
|
|
it('should propagate the appropriate headers', function (ctx) {
|
|
expect(ctx.res.set).to.have.been.calledWith(
|
|
'Content-Type',
|
|
ctx.contentType
|
|
)
|
|
expect(ctx.res.set).to.have.been.calledWith(
|
|
'Content-Length',
|
|
ctx.contentLength
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('proxyToHistoryApiAndInjectUserDetails', function () {
|
|
beforeEach(async function (ctx) {
|
|
ctx.req = { url: '/mock/url', method: 'POST' }
|
|
ctx.res = { json: sinon.stub() }
|
|
ctx.data = 'mock-data'
|
|
ctx.dataWithUsers = 'mock-injected-data'
|
|
ctx.fetchJson.resolves(ctx.data)
|
|
ctx.HistoryManager.promises.injectUserDetails.resolves(ctx.dataWithUsers)
|
|
await ctx.HistoryController.proxyToHistoryApiAndInjectUserDetails(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.next
|
|
)
|
|
})
|
|
|
|
it('should get the user id', function (ctx) {
|
|
ctx.SessionManager.getLoggedInUserId.should.have.been.calledWith(
|
|
ctx.req.session
|
|
)
|
|
})
|
|
|
|
it('should call the project history api', function (ctx) {
|
|
ctx.fetchJson.should.have.been.calledWith(
|
|
`${ctx.settings.apis.project_history.url}${ctx.req.url}`,
|
|
{
|
|
method: ctx.req.method,
|
|
headers: {
|
|
'X-User-Id': ctx.user_id,
|
|
},
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should inject the user data', function (ctx) {
|
|
ctx.HistoryManager.promises.injectUserDetails.should.have.been.calledWith(
|
|
ctx.data
|
|
)
|
|
})
|
|
|
|
it('should return the data with users to the client', function (ctx) {
|
|
ctx.res.json.should.have.been.calledWith(ctx.dataWithUsers)
|
|
})
|
|
})
|
|
|
|
describe('proxyToHistoryApiAndInjectUserDetails (with the history API failing)', function () {
|
|
beforeEach(async function (ctx) {
|
|
ctx.url = '/mock/url'
|
|
ctx.req = { url: ctx.url, method: 'POST' }
|
|
ctx.res = { json: sinon.stub() }
|
|
ctx.err = new RequestFailedError(ctx.url, {}, { status: 500 })
|
|
ctx.fetchJson.rejects(ctx.err)
|
|
await ctx.HistoryController.proxyToHistoryApiAndInjectUserDetails(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.next
|
|
)
|
|
})
|
|
|
|
it('should not inject the user data', function (ctx) {
|
|
ctx.HistoryManager.promises.injectUserDetails.should.not.have.been.called
|
|
})
|
|
|
|
it('should not return the data with users to the client', function (ctx) {
|
|
ctx.res.json.should.not.have.been.called
|
|
})
|
|
|
|
it('should throw an error', function (ctx) {
|
|
ctx.next.should.have.been.calledWith(ctx.err)
|
|
})
|
|
})
|
|
|
|
describe('resyncProjectHistory', function () {
|
|
describe('for a project without project-history enabled', function () {
|
|
beforeEach(async function (ctx) {
|
|
ctx.req = { params: { Project_id: ctx.project_id }, body: {} }
|
|
ctx.res = { setTimeout: sinon.stub(), sendStatus: sinon.stub() }
|
|
|
|
ctx.error = new Errors.ProjectHistoryDisabledError()
|
|
ctx.ProjectEntityUpdateHandler.promises.resyncProjectHistory.rejects(
|
|
ctx.error
|
|
)
|
|
|
|
await ctx.HistoryController.resyncProjectHistory(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.next
|
|
)
|
|
})
|
|
|
|
it('response with a 404', function (ctx) {
|
|
ctx.res.sendStatus.should.have.been.calledWith(404)
|
|
})
|
|
})
|
|
|
|
describe('for a project with project-history enabled', function () {
|
|
beforeEach(async function (ctx) {
|
|
ctx.req = { params: { Project_id: ctx.project_id }, body: {} }
|
|
ctx.res = { setTimeout: sinon.stub(), sendStatus: sinon.stub() }
|
|
|
|
await ctx.HistoryController.resyncProjectHistory(
|
|
ctx.req,
|
|
ctx.res,
|
|
ctx.next
|
|
)
|
|
})
|
|
|
|
it('sets an extended response timeout', function (ctx) {
|
|
ctx.res.setTimeout.should.have.been.calledWith(6 * 60 * 1000)
|
|
})
|
|
|
|
it('resyncs the project', function (ctx) {
|
|
ctx.ProjectEntityUpdateHandler.promises.resyncProjectHistory.should.have.been.calledWith(
|
|
ctx.project_id
|
|
)
|
|
})
|
|
|
|
it('responds with a 204', function (ctx) {
|
|
ctx.res.sendStatus.should.have.been.calledWith(204)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('requestBlob', function () {
|
|
describe('With Range header', function () {
|
|
beforeEach(async function (ctx) {
|
|
ctx.req = {
|
|
params: {
|
|
project_id: ctx.project_id,
|
|
hash: ctx.blobHash,
|
|
},
|
|
query: {},
|
|
body: {},
|
|
get: sinon.stub(),
|
|
}
|
|
ctx.req.get.withArgs('Range').returns('bytes=0-42')
|
|
ctx.res = { setHeader: sinon.stub(), status: sinon.stub() }
|
|
ctx.HistoryManager.promises.requestBlobWithProjectId.resolves({
|
|
stream: null,
|
|
contentLength: '43',
|
|
contentRange: 'bytes 0-42/100',
|
|
})
|
|
await ctx.HistoryController.getBlob(ctx.req, ctx.res, ctx.next)
|
|
})
|
|
|
|
it('should forward the range request', function (ctx) {
|
|
ctx.HistoryManager.promises.requestBlobWithProjectId.should.have.been.calledWith(
|
|
sinon.match(val => val.toString() === ctx.project_id),
|
|
ctx.blobHash,
|
|
'GET',
|
|
'bytes=0-42'
|
|
)
|
|
})
|
|
|
|
it('should forward the Content-Range header', function (ctx) {
|
|
ctx.res.setHeader.should.have.been.calledWith(
|
|
'Content-Range',
|
|
'bytes 0-42/100'
|
|
)
|
|
})
|
|
|
|
it('should forward the Content-Length header', function (ctx) {
|
|
ctx.res.setHeader.should.have.been.calledWith('Content-Length', '43')
|
|
})
|
|
|
|
it('should have status 206', function (ctx) {
|
|
ctx.res.status.should.have.been.calledWith(206)
|
|
})
|
|
})
|
|
|
|
describe('Without Range header', function () {
|
|
beforeEach(async function (ctx) {
|
|
ctx.req = {
|
|
params: {
|
|
project_id: ctx.project_id,
|
|
hash: ctx.blobHash,
|
|
},
|
|
query: {},
|
|
body: {},
|
|
get: sinon.stub(),
|
|
}
|
|
ctx.req.get.withArgs('Range').returns(null)
|
|
ctx.res = { setHeader: sinon.stub(), status: sinon.stub() }
|
|
ctx.HistoryManager.promises.requestBlobWithProjectId.resolves({
|
|
stream: null,
|
|
contentLength: '100',
|
|
range: null,
|
|
})
|
|
await ctx.HistoryController.getBlob(ctx.req, ctx.res, ctx.next)
|
|
})
|
|
|
|
it('should not have a Content-Range header', function (ctx) {
|
|
expect(ctx.res.setHeader).to.not.have.been.calledWith(
|
|
'Content-Range',
|
|
sinon.match.string
|
|
)
|
|
})
|
|
|
|
it('should forward the Content-Length header', function (ctx) {
|
|
ctx.res.setHeader.should.have.been.calledWith('Content-Length', '100')
|
|
})
|
|
|
|
it('should not have status 206', function (ctx) {
|
|
ctx.res.status.should.not.have.been.calledWith(206)
|
|
})
|
|
})
|
|
})
|
|
})
|