mirror of
https://github.com/overleaf/overleaf.git
synced 2024-10-24 21:12:38 -04:00
bd541b4c2d
record metrics for docupdater range operations GitOrigin-RevId: 41c500630dd81670d2798d388f2961a19df76b63
694 lines
21 KiB
JavaScript
694 lines
21 KiB
JavaScript
/* 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 = {
|
|
inc: sinon.stub(),
|
|
Timer: (Timer = (function () {
|
|
Timer = class Timer {
|
|
static initClass() {
|
|
this.prototype.done = sinon.stub()
|
|
}
|
|
}
|
|
Timer.initClass()
|
|
return Timer
|
|
})()),
|
|
}),
|
|
'@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
|
|
})()),
|
|
},
|
|
}))
|
|
})
|
|
|
|
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 () {
|
|
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' },
|
|
{ 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,
|
|
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
|
|
)
|
|
})
|
|
|
|
it('should increment the doc-snapshot metric', function () {
|
|
this.Metrics.inc.calledWith('doc-snapshot').should.equal(true)
|
|
})
|
|
|
|
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 },
|
|
{ i: 'bar', p: 6 },
|
|
],
|
|
},
|
|
{
|
|
v: 45,
|
|
op: [
|
|
{ d: 'qux', p: 4 },
|
|
{ i: 'bazbaz', p: 14 },
|
|
],
|
|
},
|
|
{ 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 },
|
|
{ i: 'bar', p: 6 },
|
|
],
|
|
meta: {
|
|
pathname: this.pathname,
|
|
doc_length: 14,
|
|
},
|
|
},
|
|
{
|
|
projectHistoryId: this.projectHistoryId,
|
|
v: 45,
|
|
op: [
|
|
{ d: 'qux', p: 4 },
|
|
{ i: 'bazbaz', p: 14 },
|
|
],
|
|
meta: {
|
|
pathname: this.pathname,
|
|
doc_length: 20,
|
|
}, // 14 + 'foo' + 'bar'
|
|
},
|
|
{
|
|
projectHistoryId: this.projectHistoryId,
|
|
v: 49,
|
|
op: [{ i: 'penguin', p: 18 }],
|
|
meta: {
|
|
pathname: this.pathname,
|
|
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)
|
|
})
|
|
})
|
|
})
|
|
})
|