overleaf/services/document-updater/test/unit/js/HttpController/HttpControllerTests.js

949 lines
28 KiB
JavaScript
Raw Normal View History

const sinon = require('sinon')
const modulePath = '../../../../app/js/HttpController.js'
const SandboxedModule = require('sandboxed-module')
const Errors = require('../../../../app/js/Errors.js')
describe('HttpController', function () {
beforeEach(function () {
this.HttpController = SandboxedModule.require(modulePath, {
requires: {
'./DocumentManager': (this.DocumentManager = {}),
'./HistoryManager': (this.HistoryManager = {
2021-07-13 07:04:42 -04:00
flushProjectChangesAsync: sinon.stub(),
}),
'./ProjectManager': (this.ProjectManager = {}),
'./ProjectFlusher': { flushAllProjects() {} },
'./DeleteQueueManager': (this.DeleteQueueManager = {}),
'./RedisManager': (this.RedisManager = {}),
'./Metrics': (this.Metrics = {}),
2021-07-13 07:04:42 -04:00
'./Errors': Errors,
'@overleaf/settings': { max_doc_length: 2 * 1024 * 1024 },
2021-07-13 07:04:42 -04:00
},
})
2020-05-11 11:24:07 -04:00
this.Metrics.Timer = class Timer {}
2020-05-11 11:26:05 -04:00
this.Metrics.Timer.prototype.done = sinon.stub()
2020-05-11 11:24:07 -04:00
this.project_id = 'project-id-123'
this.doc_id = 'doc-id-123'
this.source = 'editor'
this.next = sinon.stub()
2020-05-11 11:20:55 -04:00
this.res = {
send: sinon.stub(),
sendStatus: sinon.stub(),
2021-07-13 07:04:42 -04:00
json: sinon.stub(),
2020-05-11 11:20:55 -04:00
}
})
describe('getDoc', function () {
beforeEach(function () {
this.lines = ['one', 'two', 'three']
this.ops = ['mock-op-1', 'mock-op-2']
this.version = 42
this.fromVersion = 42
this.ranges = { changes: 'mock', comments: 'mock' }
this.pathname = '/a/b/c'
2020-05-11 11:20:55 -04:00
this.req = {
params: {
project_id: this.project_id,
2021-07-13 07:04:42 -04:00
doc_id: this.doc_id,
},
query: {},
2021-07-13 07:04:42 -04:00
body: {},
2020-05-11 11:20:55 -04:00
}
})
describe('when the document exists and no recent ops are requested', function () {
beforeEach(function () {
this.DocumentManager.getDocAndRecentOpsWithLock = sinon
.stub()
.callsArgWith(
3,
null,
this.lines,
this.version,
[],
this.ranges,
this.pathname
)
2020-05-11 11:20:55 -04:00
this.HttpController.getDoc(this.req, this.res, this.next)
})
it('should get the doc', function () {
2020-05-11 11:20:55 -04:00
this.DocumentManager.getDocAndRecentOpsWithLock
.calledWith(this.project_id, this.doc_id, -1)
.should.equal(true)
})
it('should return the doc as JSON', function () {
2020-05-11 11:20:55 -04:00
this.res.json
.calledWith({
id: this.doc_id,
lines: this.lines,
version: this.version,
ops: [],
ranges: this.ranges,
2021-07-13 07:04:42 -04:00
pathname: this.pathname,
})
.should.equal(true)
})
it('should log the request', function () {
this.logger.debug
.calledWith(
{ docId: this.doc_id, projectId: this.project_id },
'getting doc via http'
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
describe('when recent ops are requested', function () {
beforeEach(function () {
this.DocumentManager.getDocAndRecentOpsWithLock = sinon
.stub()
.callsArgWith(
3,
null,
this.lines,
this.version,
this.ops,
this.ranges,
this.pathname
)
this.req.query = { fromVersion: `${this.fromVersion}` }
2020-05-11 11:20:55 -04:00
this.HttpController.getDoc(this.req, this.res, this.next)
})
it('should get the doc', function () {
2020-05-11 11:20:55 -04:00
this.DocumentManager.getDocAndRecentOpsWithLock
.calledWith(this.project_id, this.doc_id, this.fromVersion)
.should.equal(true)
})
it('should return the doc as JSON', function () {
2020-05-11 11:20:55 -04:00
this.res.json
.calledWith({
id: this.doc_id,
lines: this.lines,
version: this.version,
ops: this.ops,
ranges: this.ranges,
2021-07-13 07:04:42 -04:00
pathname: this.pathname,
})
.should.equal(true)
})
it('should log the request', function () {
this.logger.debug
.calledWith(
{ docId: this.doc_id, projectId: this.project_id },
'getting doc via http'
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
describe('when the document does not exist', function () {
beforeEach(function () {
this.DocumentManager.getDocAndRecentOpsWithLock = sinon
.stub()
.callsArgWith(3, null, null, null)
2020-05-11 11:20:55 -04:00
this.HttpController.getDoc(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should call next with NotFoundError', function () {
this.next
2020-05-15 14:29:49 -04:00
.calledWith(sinon.match.instanceOf(Errors.NotFoundError))
.should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when an errors occurs', function () {
beforeEach(function () {
this.DocumentManager.getDocAndRecentOpsWithLock = sinon
.stub()
.callsArgWith(3, new Error('oops'), null, null)
2020-05-11 11:20:55 -04:00
this.HttpController.getDoc(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
})
describe('setDoc', function () {
beforeEach(function () {
this.lines = ['one', 'two', 'three']
this.source = 'dropbox'
this.user_id = 'user-id-123'
2020-05-11 11:20:55 -04:00
this.req = {
headers: {},
params: {
project_id: this.project_id,
2021-07-13 07:04:42 -04:00
doc_id: this.doc_id,
},
query: {},
body: {
lines: this.lines,
source: this.source,
user_id: this.user_id,
2021-07-13 07:04:42 -04:00
undoing: (this.undoing = true),
},
2020-05-11 11:20:55 -04:00
}
})
describe('successfully', function () {
beforeEach(function () {
this.DocumentManager.setDocWithLock = sinon
.stub()
.callsArgWith(6, null, { rev: '123' })
2020-05-11 11:20:55 -04:00
this.HttpController.setDoc(this.req, this.res, this.next)
})
it('should set the doc', function () {
2020-05-11 11:20:55 -04:00
this.DocumentManager.setDocWithLock
.calledWith(
this.project_id,
this.doc_id,
this.lines,
this.source,
this.user_id,
this.undoing
)
.should.equal(true)
})
it('should return a json response with the document rev from web', function () {
this.res.json.calledWithMatch({ rev: '123' }).should.equal(true)
})
it('should log the request', function () {
this.logger.debug
.calledWith(
{
docId: this.doc_id,
projectId: this.project_id,
lines: this.lines,
source: this.source,
userId: this.user_id,
2021-07-13 07:04:42 -04:00
undoing: this.undoing,
},
'setting doc via http'
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
describe('when an errors occurs', function () {
beforeEach(function () {
this.DocumentManager.setDocWithLock = sinon
.stub()
.callsArgWith(6, new Error('oops'))
2020-05-11 11:20:55 -04:00
this.HttpController.setDoc(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when the payload is too large', function () {
beforeEach(function () {
const lines = []
for (let _ = 0; _ <= 200000; _++) {
lines.push('test test test')
}
this.req.body.lines = lines
this.DocumentManager.setDocWithLock = sinon.stub().callsArgWith(6)
2020-05-11 11:20:55 -04:00
this.HttpController.setDoc(this.req, this.res, this.next)
})
it('should send back a 406 response', function () {
2020-05-11 11:20:55 -04:00
this.res.sendStatus.calledWith(406).should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should not call setDocWithLock', function () {
this.DocumentManager.setDocWithLock.callCount.should.equal(0)
})
})
})
describe('flushProject', function () {
beforeEach(function () {
2020-05-11 11:20:55 -04:00
this.req = {
params: {
2021-07-13 07:04:42 -04:00
project_id: this.project_id,
},
query: {},
2021-07-13 07:04:42 -04:00
body: {},
2020-05-11 11:20:55 -04:00
}
})
describe('successfully', function () {
beforeEach(function () {
this.ProjectManager.flushProjectWithLocks = sinon.stub().callsArgWith(1)
2020-05-11 11:20:55 -04:00
this.HttpController.flushProject(this.req, this.res, this.next)
})
it('should flush the project', function () {
2020-05-11 11:20:55 -04:00
this.ProjectManager.flushProjectWithLocks
.calledWith(this.project_id)
.should.equal(true)
})
it('should return a successful No Content response', function () {
2020-05-11 11:20:55 -04:00
this.res.sendStatus.calledWith(204).should.equal(true)
})
it('should log the request', function () {
this.logger.debug
.calledWith(
{ projectId: this.project_id },
'flushing project via http'
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when an errors occurs', function () {
beforeEach(function () {
this.ProjectManager.flushProjectWithLocks = sinon
.stub()
.callsArgWith(1, new Error('oops'))
2020-05-11 11:20:55 -04:00
this.HttpController.flushProject(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
})
describe('flushDocIfLoaded', function () {
beforeEach(function () {
this.lines = ['one', 'two', 'three']
this.version = 42
2020-05-11 11:20:55 -04:00
this.req = {
params: {
project_id: this.project_id,
2021-07-13 07:04:42 -04:00
doc_id: this.doc_id,
},
query: {},
2021-07-13 07:04:42 -04:00
body: {},
2020-05-11 11:20:55 -04:00
}
})
describe('successfully', function () {
beforeEach(function () {
this.DocumentManager.flushDocIfLoadedWithLock = sinon
.stub()
.callsArgWith(2)
2020-05-11 11:20:55 -04:00
this.HttpController.flushDocIfLoaded(this.req, this.res, this.next)
})
it('should flush the doc', function () {
2020-05-11 11:20:55 -04:00
this.DocumentManager.flushDocIfLoadedWithLock
.calledWith(this.project_id, this.doc_id)
.should.equal(true)
})
it('should return a successful No Content response', function () {
2020-05-11 11:20:55 -04:00
this.res.sendStatus.calledWith(204).should.equal(true)
})
it('should log the request', function () {
this.logger.debug
.calledWith(
{ docId: this.doc_id, projectId: this.project_id },
'flushing doc via http'
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when an errors occurs', function () {
beforeEach(function () {
this.DocumentManager.flushDocIfLoadedWithLock = sinon
.stub()
.callsArgWith(2, new Error('oops'))
2020-05-11 11:20:55 -04:00
this.HttpController.flushDocIfLoaded(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
})
describe('deleteDoc', function () {
beforeEach(function () {
2020-05-11 11:20:55 -04:00
this.req = {
params: {
project_id: this.project_id,
2021-07-13 07:04:42 -04:00
doc_id: this.doc_id,
},
query: {},
2021-07-13 07:04:42 -04:00
body: {},
2020-05-11 11:20:55 -04:00
}
})
describe('successfully', function () {
beforeEach(function () {
this.DocumentManager.flushAndDeleteDocWithLock = sinon
.stub()
.callsArgWith(3)
2020-05-11 11:20:55 -04:00
this.HttpController.deleteDoc(this.req, this.res, this.next)
})
it('should flush and delete the doc', function () {
2020-05-11 11:20:55 -04:00
this.DocumentManager.flushAndDeleteDocWithLock
.calledWith(this.project_id, this.doc_id, {
2021-07-13 07:04:42 -04:00
ignoreFlushErrors: false,
})
.should.equal(true)
})
it('should flush project history', function () {
2020-05-11 11:20:55 -04:00
this.HistoryManager.flushProjectChangesAsync
.calledWithExactly(this.project_id)
.should.equal(true)
})
it('should return a successful No Content response', function () {
2020-05-11 11:20:55 -04:00
this.res.sendStatus.calledWith(204).should.equal(true)
})
it('should log the request', function () {
this.logger.debug
.calledWith(
{ docId: this.doc_id, projectId: this.project_id },
'deleting doc via http'
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
describe('ignoring errors', function () {
beforeEach(function () {
this.req.query.ignore_flush_errors = 'true'
this.DocumentManager.flushAndDeleteDocWithLock = sinon.stub().yields()
2020-05-11 11:20:55 -04:00
this.HttpController.deleteDoc(this.req, this.res, this.next)
})
it('should delete the doc', function () {
2020-05-11 11:20:55 -04:00
this.DocumentManager.flushAndDeleteDocWithLock
.calledWith(this.project_id, this.doc_id, { ignoreFlushErrors: true })
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should return a successful No Content response', function () {
this.res.sendStatus.calledWith(204).should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when an errors occurs', function () {
beforeEach(function () {
this.DocumentManager.flushAndDeleteDocWithLock = sinon
.stub()
.callsArgWith(3, new Error('oops'))
2020-05-11 11:20:55 -04:00
this.HttpController.deleteDoc(this.req, this.res, this.next)
})
it('should flush project history', function () {
2020-05-11 11:20:55 -04:00
this.HistoryManager.flushProjectChangesAsync
.calledWithExactly(this.project_id)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
})
describe('deleteProject', function () {
beforeEach(function () {
2020-05-11 11:20:55 -04:00
this.req = {
params: {
2021-07-13 07:04:42 -04:00
project_id: this.project_id,
},
query: {},
2021-07-13 07:04:42 -04:00
body: {},
2020-05-11 11:20:55 -04:00
}
})
describe('successfully', function () {
beforeEach(function () {
this.ProjectManager.flushAndDeleteProjectWithLocks = sinon
.stub()
.callsArgWith(2)
2020-05-11 11:20:55 -04:00
this.HttpController.deleteProject(this.req, this.res, this.next)
})
it('should delete the project', function () {
2020-05-11 11:20:55 -04:00
this.ProjectManager.flushAndDeleteProjectWithLocks
.calledWith(this.project_id)
.should.equal(true)
})
it('should return a successful No Content response', function () {
2020-05-11 11:20:55 -04:00
this.res.sendStatus.calledWith(204).should.equal(true)
})
it('should log the request', function () {
this.logger.debug
.calledWith(
{ projectId: this.project_id },
'deleting project via http'
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
describe('with the background=true option from realtime', function () {
beforeEach(function () {
this.ProjectManager.queueFlushAndDeleteProject = sinon
.stub()
.callsArgWith(1)
this.req.query = { background: true, shutdown: true }
2020-05-11 11:20:55 -04:00
this.HttpController.deleteProject(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should queue the flush and delete', function () {
this.ProjectManager.queueFlushAndDeleteProject
.calledWith(this.project_id)
.should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when an errors occurs', function () {
beforeEach(function () {
this.ProjectManager.flushAndDeleteProjectWithLocks = sinon
.stub()
.callsArgWith(2, new Error('oops'))
2020-05-11 11:20:55 -04:00
this.HttpController.deleteProject(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
})
describe('acceptChanges', function () {
beforeEach(function () {
2020-05-11 11:20:55 -04:00
this.req = {
params: {
project_id: this.project_id,
doc_id: this.doc_id,
2021-07-13 07:04:42 -04:00
change_id: (this.change_id = 'mock-change-od-1'),
},
query: {},
2021-07-13 07:04:42 -04:00
body: {},
2020-05-11 11:20:55 -04:00
}
})
describe('successfully with a single change', function () {
beforeEach(function () {
this.DocumentManager.acceptChangesWithLock = sinon
.stub()
.callsArgWith(3)
2020-05-11 11:20:55 -04:00
this.HttpController.acceptChanges(this.req, this.res, this.next)
})
it('should accept the change', function () {
2020-05-11 11:20:55 -04:00
this.DocumentManager.acceptChangesWithLock
.calledWith(this.project_id, this.doc_id, [this.change_id])
.should.equal(true)
})
it('should return a successful No Content response', function () {
2020-05-11 11:20:55 -04:00
this.res.sendStatus.calledWith(204).should.equal(true)
})
it('should log the request', function () {
this.logger.debug
.calledWith(
{ projectId: this.project_id, docId: this.doc_id },
'accepting 1 changes via http'
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
describe('succesfully with with multiple changes', function () {
beforeEach(function () {
this.change_ids = [
'mock-change-od-1',
'mock-change-od-2',
'mock-change-od-3',
2021-07-13 07:04:42 -04:00
'mock-change-od-4',
]
this.req.body = { change_ids: this.change_ids }
this.DocumentManager.acceptChangesWithLock = sinon
.stub()
.callsArgWith(3)
2020-05-11 11:20:55 -04:00
this.HttpController.acceptChanges(this.req, this.res, this.next)
})
it('should accept the changes in the body payload', function () {
2020-05-11 11:20:55 -04:00
this.DocumentManager.acceptChangesWithLock
.calledWith(this.project_id, this.doc_id, this.change_ids)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should log the request with the correct number of changes', function () {
this.logger.debug
.calledWith(
{ projectId: this.project_id, docId: this.doc_id },
`accepting ${this.change_ids.length} changes via http`
)
.should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when an errors occurs', function () {
beforeEach(function () {
this.DocumentManager.acceptChangesWithLock = sinon
.stub()
.callsArgWith(3, new Error('oops'))
2020-05-11 11:20:55 -04:00
this.HttpController.acceptChanges(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
})
describe('deleteComment', function () {
beforeEach(function () {
2020-05-11 11:20:55 -04:00
this.req = {
params: {
project_id: this.project_id,
doc_id: this.doc_id,
2021-07-13 07:04:42 -04:00
comment_id: (this.comment_id = 'mock-comment-id'),
},
query: {},
2021-07-13 07:04:42 -04:00
body: {},
2020-05-11 11:20:55 -04:00
}
})
describe('successfully', function () {
beforeEach(function () {
this.DocumentManager.deleteCommentWithLock = sinon
.stub()
.callsArgWith(3)
2020-05-11 11:20:55 -04:00
this.HttpController.deleteComment(this.req, this.res, this.next)
})
it('should accept the change', function () {
2020-05-11 11:20:55 -04:00
this.DocumentManager.deleteCommentWithLock
.calledWith(this.project_id, this.doc_id, this.comment_id)
.should.equal(true)
})
it('should return a successful No Content response', function () {
2020-05-11 11:20:55 -04:00
this.res.sendStatus.calledWith(204).should.equal(true)
})
it('should log the request', function () {
this.logger.debug
.calledWith(
{
projectId: this.project_id,
docId: this.doc_id,
2021-07-13 07:04:42 -04:00
commentId: this.comment_id,
},
'deleting comment via http'
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when an errors occurs', function () {
beforeEach(function () {
this.DocumentManager.deleteCommentWithLock = sinon
.stub()
.callsArgWith(3, new Error('oops'))
2020-05-11 11:20:55 -04:00
this.HttpController.deleteComment(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
})
describe('getProjectDocsAndFlushIfOld', function () {
beforeEach(function () {
this.state = '01234567890abcdef'
this.docs = [
{ _id: '1234', lines: 'hello', v: 23 },
2021-07-13 07:04:42 -04:00
{ _id: '4567', lines: 'world', v: 45 },
]
2020-05-11 11:20:55 -04:00
this.req = {
params: {
2021-07-13 07:04:42 -04:00
project_id: this.project_id,
},
query: {
2021-07-13 07:04:42 -04:00
state: this.state,
},
2021-07-13 07:04:42 -04:00
body: {},
2020-05-11 11:20:55 -04:00
}
})
describe('successfully', function () {
beforeEach(function () {
this.ProjectManager.getProjectDocsAndFlushIfOld = sinon
.stub()
.callsArgWith(3, null, this.docs)
2020-05-11 11:20:55 -04:00
this.HttpController.getProjectDocsAndFlushIfOld(
this.req,
this.res,
this.next
)
})
it('should get docs from the project manager', function () {
2020-05-11 11:20:55 -04:00
this.ProjectManager.getProjectDocsAndFlushIfOld
.calledWith(this.project_id, this.state, {})
.should.equal(true)
})
it('should return a successful response', function () {
2020-05-11 11:20:55 -04:00
this.res.send.calledWith(this.docs).should.equal(true)
})
it('should log the request', function () {
this.logger.debug
.calledWith(
{ projectId: this.project_id, exclude: [] },
'getting docs via http'
)
.should.equal(true)
})
it('should log the response', function () {
this.logger.debug
.calledWith(
{ projectId: this.project_id, result: ['1234:23', '4567:45'] },
'got docs via http'
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
describe('when there is a conflict', function () {
beforeEach(function () {
this.ProjectManager.getProjectDocsAndFlushIfOld = sinon
.stub()
.callsArgWith(
3,
new Errors.ProjectStateChangedError('project state changed')
)
2020-05-11 11:20:55 -04:00
this.HttpController.getProjectDocsAndFlushIfOld(
this.req,
this.res,
this.next
)
})
2020-05-11 11:20:55 -04:00
it('should return an HTTP 409 Conflict response', function () {
this.res.sendStatus.calledWith(409).should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when an error occurs', function () {
beforeEach(function () {
this.ProjectManager.getProjectDocsAndFlushIfOld = sinon
.stub()
.callsArgWith(3, new Error('oops'))
2020-05-11 11:20:55 -04:00
this.HttpController.getProjectDocsAndFlushIfOld(
this.req,
this.res,
this.next
)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
})
describe('updateProject', function () {
beforeEach(function () {
this.projectHistoryId = 'history-id-123'
this.userId = 'user-id-123'
this.updates = [
{
type: 'rename-doc',
id: 1,
pathname: 'thesis.tex',
2021-07-13 07:04:42 -04:00
newPathname: 'book.tex',
},
{ type: 'add-doc', id: 2, pathname: 'article.tex', docLines: 'hello' },
{
type: 'rename-file',
id: 3,
pathname: 'apple.png',
2021-07-13 07:04:42 -04:00
newPathname: 'banana.png',
},
2021-07-13 07:04:42 -04:00
{ type: 'add-file', id: 4, url: 'filestore.example.com/4' },
]
this.version = 1234567
this.req = {
query: {},
body: {
projectHistoryId: this.projectHistoryId,
userId: this.userId,
updates: this.updates,
2021-07-13 07:04:42 -04:00
version: this.version,
source: this.source,
},
params: {
2021-07-13 07:04:42 -04:00
project_id: this.project_id,
},
}
})
describe('successfully', function () {
beforeEach(function () {
this.ProjectManager.updateProjectWithLocks = sinon.stub().yields()
2020-05-11 11:20:55 -04:00
this.HttpController.updateProject(this.req, this.res, this.next)
})
it('should accept the change', function () {
2020-05-11 11:20:55 -04:00
this.ProjectManager.updateProjectWithLocks
.calledWith(
this.project_id,
this.projectHistoryId,
this.userId,
this.updates,
this.version,
this.source
)
.should.equal(true)
})
it('should return a successful No Content response', function () {
2020-05-11 11:20:55 -04:00
this.res.sendStatus.calledWith(204).should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should time the request', function () {
this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when an errors occurs', function () {
beforeEach(function () {
this.ProjectManager.updateProjectWithLocks = sinon
.stub()
.yields(new Error('oops'))
2020-05-11 11:20:55 -04:00
this.HttpController.updateProject(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
})
2020-05-11 11:20:55 -04:00
describe('resyncProjectHistory', function () {
beforeEach(function () {
this.projectHistoryId = 'history-id-123'
this.docs = sinon.stub()
this.files = sinon.stub()
this.fileUpdates = sinon.stub()
2020-05-11 11:20:55 -04:00
this.req = {
query: {},
body: {
projectHistoryId: this.projectHistoryId,
docs: this.docs,
2021-07-13 07:04:42 -04:00
files: this.files,
},
params: {
2021-07-13 07:04:42 -04:00
project_id: this.project_id,
},
2020-05-11 11:20:55 -04:00
}
})
describe('successfully', function () {
beforeEach(function () {
this.HistoryManager.resyncProjectHistory = sinon.stub().callsArgWith(4)
2020-05-11 11:20:55 -04:00
this.HttpController.resyncProjectHistory(this.req, this.res, this.next)
})
it('should accept the change', function () {
2020-05-11 11:20:55 -04:00
this.HistoryManager.resyncProjectHistory
.calledWith(
this.project_id,
this.projectHistoryId,
this.docs,
this.files
)
.should.equal(true)
})
2020-05-11 11:20:55 -04:00
it('should return a successful No Content response', function () {
this.res.sendStatus.calledWith(204).should.equal(true)
})
})
2020-05-11 11:20:55 -04:00
describe('when an errors occurs', function () {
beforeEach(function () {
this.HistoryManager.resyncProjectHistory = sinon
.stub()
.callsArgWith(4, new Error('oops'))
2020-05-11 11:20:55 -04:00
this.HttpController.resyncProjectHistory(this.req, this.res, this.next)
})
2020-05-11 11:20:55 -04:00
it('should call next with the error', function () {
2020-05-15 14:29:49 -04:00
this.next.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
})
})
})
})