overleaf/services/document-updater/test/unit/js/UpdateManager/UpdateManagerTests.js

690 lines
21 KiB
JavaScript
Raw Normal View History

/* eslint-disable
no-return-assign,
no-unused-vars,
*/
// TODO: This file was created by bulk-decaffeinate.
// Fix any style issues and re-enable lint.
/*
* decaffeinate suggestions:
* DS101: Remove unnecessary use of Array.from
* DS102: Remove unnecessary code created because of implicit returns
* DS206: Consider reworking classes to avoid initClass
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
*/
const sinon = require('sinon')
const modulePath = '../../../../app/js/UpdateManager.js'
const SandboxedModule = require('sandboxed-module')
describe('UpdateManager', function () {
beforeEach(function () {
let Profiler, Timer
this.project_id = 'project-id-123'
this.projectHistoryId = 'history-id-123'
this.doc_id = 'document-id-123'
this.callback = sinon.stub()
return (this.UpdateManager = SandboxedModule.require(modulePath, {
requires: {
'./LockManager': (this.LockManager = {}),
'./RedisManager': (this.RedisManager = {}),
'./RealTimeRedisManager': (this.RealTimeRedisManager = {}),
'./ShareJsUpdateManager': (this.ShareJsUpdateManager = {}),
'./HistoryManager': (this.HistoryManager = {}),
'./Metrics': (this.Metrics = {
Timer: (Timer = (function () {
Timer = class Timer {
static initClass() {
this.prototype.done = sinon.stub()
}
}
Timer.initClass()
return Timer
2021-07-13 07:04:42 -04:00
})()),
}),
'@overleaf/settings': (this.Settings = {}),
'./DocumentManager': (this.DocumentManager = {}),
'./RangesManager': (this.RangesManager = {}),
'./SnapshotManager': (this.SnapshotManager = {}),
'./Profiler': (Profiler = (function () {
Profiler = class Profiler {
static initClass() {
this.prototype.log = sinon.stub().returns({ end: sinon.stub() })
this.prototype.end = sinon.stub()
}
}
Profiler.initClass()
return Profiler
2021-07-13 07:04:42 -04:00
})()),
},
}))
})
describe('processOutstandingUpdates', function () {
beforeEach(function () {
this.UpdateManager.fetchAndApplyUpdates = sinon.stub().callsArg(2)
return this.UpdateManager.processOutstandingUpdates(
this.project_id,
this.doc_id,
this.callback
)
})
it('should apply the updates', function () {
return this.UpdateManager.fetchAndApplyUpdates
.calledWith(this.project_id, this.doc_id)
.should.equal(true)
})
it('should call the callback', function () {
return this.callback.called.should.equal(true)
})
return it('should time the execution', function () {
return this.Metrics.Timer.prototype.done.called.should.equal(true)
})
})
describe('processOutstandingUpdatesWithLock', function () {
describe('when the lock is free', function () {
beforeEach(function () {
this.LockManager.tryLock = sinon
.stub()
.callsArgWith(1, null, true, (this.lockValue = 'mock-lock-value'))
this.LockManager.releaseLock = sinon.stub().callsArg(2)
this.UpdateManager.continueProcessingUpdatesWithLock = sinon
.stub()
.callsArg(2)
return (this.UpdateManager.processOutstandingUpdates = sinon
.stub()
.callsArg(2))
})
describe('successfully', function () {
beforeEach(function () {
return this.UpdateManager.processOutstandingUpdatesWithLock(
this.project_id,
this.doc_id,
this.callback
)
})
it('should acquire the lock', function () {
return this.LockManager.tryLock
.calledWith(this.doc_id)
.should.equal(true)
})
it('should free the lock', function () {
return this.LockManager.releaseLock
.calledWith(this.doc_id, this.lockValue)
.should.equal(true)
})
it('should process the outstanding updates', function () {
return this.UpdateManager.processOutstandingUpdates
.calledWith(this.project_id, this.doc_id)
.should.equal(true)
})
it('should do everything with the lock acquired', function () {
this.UpdateManager.processOutstandingUpdates
.calledAfter(this.LockManager.tryLock)
.should.equal(true)
return this.UpdateManager.processOutstandingUpdates
.calledBefore(this.LockManager.releaseLock)
.should.equal(true)
})
it('should continue processing new updates that may have come in', function () {
return this.UpdateManager.continueProcessingUpdatesWithLock
.calledWith(this.project_id, this.doc_id)
.should.equal(true)
})
return it('should return the callback', function () {
return this.callback.called.should.equal(true)
})
})
return describe('when processOutstandingUpdates returns an error', function () {
beforeEach(function () {
this.UpdateManager.processOutstandingUpdates = sinon
.stub()
.callsArgWith(2, (this.error = new Error('Something went wrong')))
return this.UpdateManager.processOutstandingUpdatesWithLock(
this.project_id,
this.doc_id,
this.callback
)
})
it('should free the lock', function () {
return this.LockManager.releaseLock
.calledWith(this.doc_id, this.lockValue)
.should.equal(true)
})
return it('should return the error in the callback', function () {
return this.callback.calledWith(this.error).should.equal(true)
})
})
})
return describe('when the lock is taken', function () {
beforeEach(function () {
this.LockManager.tryLock = sinon.stub().callsArgWith(1, null, false)
this.UpdateManager.processOutstandingUpdates = sinon.stub().callsArg(2)
return this.UpdateManager.processOutstandingUpdatesWithLock(
this.project_id,
this.doc_id,
this.callback
)
})
it('should return the callback', function () {
return this.callback.called.should.equal(true)
})
return it('should not process the updates', function () {
return this.UpdateManager.processOutstandingUpdates.called.should.equal(
false
)
})
})
})
describe('continueProcessingUpdatesWithLock', function () {
describe('when there are outstanding updates', function () {
beforeEach(function () {
this.RealTimeRedisManager.getUpdatesLength = sinon
.stub()
.callsArgWith(1, null, 3)
this.UpdateManager.processOutstandingUpdatesWithLock = sinon
.stub()
.callsArg(2)
return this.UpdateManager.continueProcessingUpdatesWithLock(
this.project_id,
this.doc_id,
this.callback
)
})
it('should process the outstanding updates', function () {
return this.UpdateManager.processOutstandingUpdatesWithLock
.calledWith(this.project_id, this.doc_id)
.should.equal(true)
})
return it('should return the callback', function () {
return this.callback.called.should.equal(true)
})
})
return describe('when there are no outstanding updates', function () {
beforeEach(function () {
this.RealTimeRedisManager.getUpdatesLength = sinon
.stub()
.callsArgWith(1, null, 0)
this.UpdateManager.processOutstandingUpdatesWithLock = sinon
.stub()
.callsArg(2)
return this.UpdateManager.continueProcessingUpdatesWithLock(
this.project_id,
this.doc_id,
this.callback
)
})
it('should not try to process the outstanding updates', function () {
return this.UpdateManager.processOutstandingUpdatesWithLock.called.should.equal(
false
)
})
return it('should return the callback', function () {
return this.callback.called.should.equal(true)
})
})
})
describe('fetchAndApplyUpdates', function () {
describe('with updates', function () {
beforeEach(function () {
this.updates = [{ p: 1, t: 'foo' }]
this.updatedDocLines = ['updated', 'lines']
this.version = 34
this.RealTimeRedisManager.getPendingUpdatesForDoc = sinon
.stub()
.callsArgWith(1, null, this.updates)
this.UpdateManager.applyUpdate = sinon
.stub()
.callsArgWith(3, null, this.updatedDocLines, this.version)
return this.UpdateManager.fetchAndApplyUpdates(
this.project_id,
this.doc_id,
this.callback
)
})
it('should get the pending updates', function () {
return this.RealTimeRedisManager.getPendingUpdatesForDoc
.calledWith(this.doc_id)
.should.equal(true)
})
it('should apply the updates', function () {
2021-07-13 07:04:42 -04:00
return Array.from(this.updates).map(update =>
this.UpdateManager.applyUpdate
.calledWith(this.project_id, this.doc_id, update)
.should.equal(true)
)
})
return it('should call the callback', function () {
return this.callback.called.should.equal(true)
})
})
return describe('when there are no updates', function () {
beforeEach(function () {
this.updates = []
this.RealTimeRedisManager.getPendingUpdatesForDoc = sinon
.stub()
.callsArgWith(1, null, this.updates)
this.UpdateManager.applyUpdate = sinon.stub()
this.RedisManager.setDocument = sinon.stub()
return this.UpdateManager.fetchAndApplyUpdates(
this.project_id,
this.doc_id,
this.callback
)
})
it('should not call applyUpdate', function () {
return this.UpdateManager.applyUpdate.called.should.equal(false)
})
return it('should call the callback', function () {
return this.callback.called.should.equal(true)
})
})
})
describe('applyUpdate', function () {
beforeEach(function () {
this.updateMeta = { user_id: 'last-author-fake-id' }
this.update = { op: [{ p: 42, i: 'foo' }], meta: this.updateMeta }
this.updatedDocLines = ['updated', 'lines']
this.version = 34
this.lines = ['original', 'lines']
this.ranges = { entries: 'mock', comments: 'mock' }
this.updated_ranges = { entries: 'updated', comments: 'updated' }
this.appliedOps = [
{ v: 42, op: 'mock-op-42' },
2021-07-13 07:04:42 -04:00
{ v: 45, op: 'mock-op-45' },
]
this.doc_ops_length = sinon.stub()
this.project_ops_length = sinon.stub()
this.pathname = '/a/b/c.tex'
this.DocumentManager.getDoc = sinon
.stub()
.yields(
null,
this.lines,
this.version,
this.ranges,
this.pathname,
this.projectHistoryId
)
this.RangesManager.applyUpdate = sinon
.stub()
.yields(null, this.updated_ranges, false)
this.ShareJsUpdateManager.applyUpdate = sinon
.stub()
.yields(null, this.updatedDocLines, this.version, this.appliedOps)
this.RedisManager.updateDocument = sinon
.stub()
.yields(null, this.doc_ops_length, this.project_ops_length)
this.RealTimeRedisManager.sendData = sinon.stub()
this.UpdateManager._addProjectHistoryMetadataToOps = sinon.stub()
return (this.HistoryManager.recordAndFlushHistoryOps = sinon
.stub()
.callsArg(5))
})
describe('normally', function () {
beforeEach(function () {
return this.UpdateManager.applyUpdate(
this.project_id,
this.doc_id,
this.update,
this.callback
)
})
it('should apply the updates via ShareJS', function () {
return this.ShareJsUpdateManager.applyUpdate
.calledWith(
this.project_id,
this.doc_id,
this.update,
this.lines,
this.version
)
.should.equal(true)
})
it('should update the ranges', function () {
return this.RangesManager.applyUpdate
.calledWith(
this.project_id,
this.doc_id,
this.ranges,
this.appliedOps,
this.updatedDocLines
)
.should.equal(true)
})
it('should save the document', function () {
return this.RedisManager.updateDocument
.calledWith(
this.project_id,
this.doc_id,
this.updatedDocLines,
this.version,
this.appliedOps,
this.updated_ranges,
this.updateMeta
)
.should.equal(true)
})
it('should add metadata to the ops', function () {
return this.UpdateManager._addProjectHistoryMetadataToOps
.calledWith(
this.appliedOps,
this.pathname,
this.projectHistoryId,
this.lines
)
.should.equal(true)
})
it('should push the applied ops into the history queue', function () {
return this.HistoryManager.recordAndFlushHistoryOps
.calledWith(
this.project_id,
this.doc_id,
this.appliedOps,
this.doc_ops_length,
this.project_ops_length
)
.should.equal(true)
})
return it('should call the callback', function () {
return this.callback.called.should.equal(true)
})
})
describe('with UTF-16 surrogate pairs in the update', function () {
beforeEach(function () {
this.update = { op: [{ p: 42, i: '\uD835\uDC00' }] }
return this.UpdateManager.applyUpdate(
this.project_id,
this.doc_id,
this.update,
this.callback
)
})
return it('should apply the update but with surrogate pairs removed', function () {
this.ShareJsUpdateManager.applyUpdate
.calledWith(this.project_id, this.doc_id, this.update)
.should.equal(true)
// \uFFFD is 'replacement character'
return this.update.op[0].i.should.equal('\uFFFD\uFFFD')
})
})
describe('with an error', function () {
beforeEach(function () {
this.error = new Error('something went wrong')
this.ShareJsUpdateManager.applyUpdate = sinon.stub().yields(this.error)
return this.UpdateManager.applyUpdate(
this.project_id,
this.doc_id,
this.update,
this.callback
)
})
it('should call RealTimeRedisManager.sendData with the error', function () {
return this.RealTimeRedisManager.sendData
.calledWith({
project_id: this.project_id,
doc_id: this.doc_id,
2021-07-13 07:04:42 -04:00
error: this.error.message,
})
.should.equal(true)
})
return it('should call the callback with the error', function () {
return this.callback.calledWith(this.error).should.equal(true)
})
})
return describe('when ranges get collapsed', function () {
beforeEach(function () {
this.RangesManager.applyUpdate = sinon
.stub()
.yields(null, this.updated_ranges, true)
this.SnapshotManager.recordSnapshot = sinon.stub().yields()
return this.UpdateManager.applyUpdate(
this.project_id,
this.doc_id,
this.update,
this.callback
)
})
return it('should call SnapshotManager.recordSnapshot', function () {
return this.SnapshotManager.recordSnapshot
.calledWith(
this.project_id,
this.doc_id,
this.version,
this.pathname,
this.lines,
this.ranges
)
.should.equal(true)
})
})
})
describe('_addProjectHistoryMetadataToOps', function () {
return it('should add projectHistoryId, pathname and doc_length metadata to the ops', function () {
const lines = ['some', 'test', 'data']
const appliedOps = [
{
v: 42,
op: [
{ i: 'foo', p: 4 },
2021-07-13 07:04:42 -04:00
{ i: 'bar', p: 6 },
],
},
{
v: 45,
op: [
{ d: 'qux', p: 4 },
2021-07-13 07:04:42 -04:00
{ i: 'bazbaz', p: 14 },
],
},
2021-07-13 07:04:42 -04:00
{ v: 49, op: [{ i: 'penguin', p: 18 }] },
]
this.UpdateManager._addProjectHistoryMetadataToOps(
appliedOps,
this.pathname,
this.projectHistoryId,
lines
)
return appliedOps.should.deep.equal([
{
projectHistoryId: this.projectHistoryId,
v: 42,
op: [
{ i: 'foo', p: 4 },
2021-07-13 07:04:42 -04:00
{ i: 'bar', p: 6 },
],
meta: {
pathname: this.pathname,
2021-07-13 07:04:42 -04:00
doc_length: 14,
},
},
{
projectHistoryId: this.projectHistoryId,
v: 45,
op: [
{ d: 'qux', p: 4 },
2021-07-13 07:04:42 -04:00
{ i: 'bazbaz', p: 14 },
],
meta: {
pathname: this.pathname,
2021-07-13 07:04:42 -04:00
doc_length: 20,
}, // 14 + 'foo' + 'bar'
},
{
projectHistoryId: this.projectHistoryId,
v: 49,
op: [{ i: 'penguin', p: 18 }],
meta: {
pathname: this.pathname,
2021-07-13 07:04:42 -04:00
doc_length: 23,
}, // 14 - 'qux' + 'bazbaz'
},
])
})
})
return describe('lockUpdatesAndDo', function () {
beforeEach(function () {
this.method = sinon.stub().callsArgWith(3, null, this.response_arg1)
this.callback = sinon.stub()
this.arg1 = 'argument 1'
this.response_arg1 = 'response argument 1'
this.lockValue = 'mock-lock-value'
this.LockManager.getLock = sinon
.stub()
.callsArgWith(1, null, this.lockValue)
return (this.LockManager.releaseLock = sinon.stub().callsArg(2))
})
describe('successfully', function () {
beforeEach(function () {
this.UpdateManager.continueProcessingUpdatesWithLock = sinon.stub()
this.UpdateManager.processOutstandingUpdates = sinon.stub().callsArg(2)
return this.UpdateManager.lockUpdatesAndDo(
this.method,
this.project_id,
this.doc_id,
this.arg1,
this.callback
)
})
it('should lock the doc', function () {
return this.LockManager.getLock
.calledWith(this.doc_id)
.should.equal(true)
})
it('should process any outstanding updates', function () {
return this.UpdateManager.processOutstandingUpdates
.calledWith(this.project_id, this.doc_id)
.should.equal(true)
})
it('should call the method', function () {
return this.method
.calledWith(this.project_id, this.doc_id, this.arg1)
.should.equal(true)
})
it('should return the method response to the callback', function () {
return this.callback
.calledWith(null, this.response_arg1)
.should.equal(true)
})
it('should release the lock', function () {
return this.LockManager.releaseLock
.calledWith(this.doc_id, this.lockValue)
.should.equal(true)
})
return it('should continue processing updates', function () {
return this.UpdateManager.continueProcessingUpdatesWithLock
.calledWith(this.project_id, this.doc_id)
.should.equal(true)
})
})
describe('when processOutstandingUpdates returns an error', function () {
beforeEach(function () {
this.UpdateManager.processOutstandingUpdates = sinon
.stub()
.callsArgWith(2, (this.error = new Error('Something went wrong')))
return this.UpdateManager.lockUpdatesAndDo(
this.method,
this.project_id,
this.doc_id,
this.arg1,
this.callback
)
})
it('should free the lock', function () {
return this.LockManager.releaseLock
.calledWith(this.doc_id, this.lockValue)
.should.equal(true)
})
return it('should return the error in the callback', function () {
return this.callback.calledWith(this.error).should.equal(true)
})
})
return describe('when the method returns an error', function () {
beforeEach(function () {
this.UpdateManager.processOutstandingUpdates = sinon.stub().callsArg(2)
this.method = sinon
.stub()
.callsArgWith(
3,
(this.error = new Error('something went wrong')),
this.response_arg1
)
return this.UpdateManager.lockUpdatesAndDo(
this.method,
this.project_id,
this.doc_id,
this.arg1,
this.callback
)
})
it('should free the lock', function () {
return this.LockManager.releaseLock
.calledWith(this.doc_id, this.lockValue)
.should.equal(true)
})
return it('should return the error in the callback', function () {
return this.callback.calledWith(this.error).should.equal(true)
})
})
})
})