mirror of
https://github.com/overleaf/overleaf.git
synced 2024-12-29 12:53:15 +00:00
d9e0215aee
Camel case variables in real-time GitOrigin-RevId: 0a35d2e39d54c258bed017ea4dcdbf9a19a2a9b1
256 lines
8.2 KiB
JavaScript
256 lines
8.2 KiB
JavaScript
/* eslint-disable
|
|
no-return-assign,
|
|
*/
|
|
// 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
|
|
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
|
|
*/
|
|
const SandboxedModule = require('sandboxed-module')
|
|
const sinon = require('sinon')
|
|
const modulePath = require('path').join(
|
|
__dirname,
|
|
'../../../app/js/DocumentUpdaterController'
|
|
)
|
|
const MockClient = require('./helpers/MockClient')
|
|
|
|
describe('DocumentUpdaterController', function () {
|
|
beforeEach(function () {
|
|
this.project_id = 'project-id-123'
|
|
this.doc_id = 'doc-id-123'
|
|
this.callback = sinon.stub()
|
|
this.io = { mock: 'socket.io' }
|
|
this.rclient = []
|
|
this.RoomEvents = { on: sinon.stub() }
|
|
this.EditorUpdatesController = SandboxedModule.require(modulePath, {
|
|
requires: {
|
|
'@overleaf/settings': (this.settings = {
|
|
redis: {
|
|
documentupdater: {
|
|
key_schema: {
|
|
pendingUpdates({ doc_id: docId }) {
|
|
return `PendingUpdates:${docId}`
|
|
},
|
|
},
|
|
},
|
|
pubsub: null,
|
|
},
|
|
}),
|
|
'./RedisClientManager': {
|
|
createClientList: () => {
|
|
this.redis = {
|
|
createClient: name => {
|
|
let rclientStub
|
|
this.rclient.push((rclientStub = { name }))
|
|
return rclientStub
|
|
},
|
|
}
|
|
},
|
|
},
|
|
'./SafeJsonParse': (this.SafeJsonParse = {
|
|
parse: (data, cb) => cb(null, JSON.parse(data)),
|
|
}),
|
|
'./EventLogger': (this.EventLogger = { checkEventOrder: sinon.stub() }),
|
|
'./HealthCheckManager': { check: sinon.stub() },
|
|
'@overleaf/metrics': (this.metrics = { inc: sinon.stub() }),
|
|
'./RoomManager': (this.RoomManager = {
|
|
eventSource: sinon.stub().returns(this.RoomEvents),
|
|
}),
|
|
'./ChannelManager': (this.ChannelManager = {}),
|
|
},
|
|
})
|
|
})
|
|
|
|
describe('listenForUpdatesFromDocumentUpdater', function () {
|
|
beforeEach(function () {
|
|
this.rclient.length = 0 // clear any existing clients
|
|
this.EditorUpdatesController.rclientList = [
|
|
this.redis.createClient('first'),
|
|
this.redis.createClient('second'),
|
|
]
|
|
this.rclient[0].subscribe = sinon.stub()
|
|
this.rclient[0].on = sinon.stub()
|
|
this.rclient[1].subscribe = sinon.stub()
|
|
this.rclient[1].on = sinon.stub()
|
|
this.EditorUpdatesController.listenForUpdatesFromDocumentUpdater()
|
|
})
|
|
|
|
it('should subscribe to the doc-updater stream', function () {
|
|
this.rclient[0].subscribe.calledWith('applied-ops').should.equal(true)
|
|
})
|
|
|
|
it('should register a callback to handle updates', function () {
|
|
this.rclient[0].on.calledWith('message').should.equal(true)
|
|
})
|
|
|
|
it('should subscribe to any additional doc-updater stream', function () {
|
|
this.rclient[1].subscribe.calledWith('applied-ops').should.equal(true)
|
|
this.rclient[1].on.calledWith('message').should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('_processMessageFromDocumentUpdater', function () {
|
|
describe('with bad JSON', function () {
|
|
beforeEach(function () {
|
|
this.SafeJsonParse.parse = sinon
|
|
.stub()
|
|
.callsArgWith(1, new Error('oops'))
|
|
return this.EditorUpdatesController._processMessageFromDocumentUpdater(
|
|
this.io,
|
|
'applied-ops',
|
|
'blah'
|
|
)
|
|
})
|
|
|
|
it('should log an error', function () {
|
|
return this.logger.error.called.should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('with update', function () {
|
|
beforeEach(function () {
|
|
this.message = {
|
|
doc_id: this.doc_id,
|
|
op: { t: 'foo', p: 12 },
|
|
}
|
|
this.EditorUpdatesController._applyUpdateFromDocumentUpdater =
|
|
sinon.stub()
|
|
return this.EditorUpdatesController._processMessageFromDocumentUpdater(
|
|
this.io,
|
|
'applied-ops',
|
|
JSON.stringify(this.message)
|
|
)
|
|
})
|
|
|
|
it('should apply the update', function () {
|
|
return this.EditorUpdatesController._applyUpdateFromDocumentUpdater
|
|
.calledWith(this.io, this.doc_id, this.message.op)
|
|
.should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('with error', function () {
|
|
beforeEach(function () {
|
|
this.message = {
|
|
doc_id: this.doc_id,
|
|
error: 'Something went wrong',
|
|
}
|
|
this.EditorUpdatesController._processErrorFromDocumentUpdater =
|
|
sinon.stub()
|
|
return this.EditorUpdatesController._processMessageFromDocumentUpdater(
|
|
this.io,
|
|
'applied-ops',
|
|
JSON.stringify(this.message)
|
|
)
|
|
})
|
|
|
|
return it('should process the error', function () {
|
|
return this.EditorUpdatesController._processErrorFromDocumentUpdater
|
|
.calledWith(this.io, this.doc_id, this.message.error)
|
|
.should.equal(true)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('_applyUpdateFromDocumentUpdater', function () {
|
|
beforeEach(function () {
|
|
this.sourceClient = new MockClient()
|
|
this.otherClients = [new MockClient(), new MockClient()]
|
|
this.update = {
|
|
op: [{ t: 'foo', p: 12 }],
|
|
meta: { source: this.sourceClient.publicId },
|
|
v: (this.version = 42),
|
|
doc: this.doc_id,
|
|
}
|
|
return (this.io.sockets = {
|
|
clients: sinon
|
|
.stub()
|
|
.returns([
|
|
this.sourceClient,
|
|
...Array.from(this.otherClients),
|
|
this.sourceClient,
|
|
]),
|
|
})
|
|
}) // include a duplicate client
|
|
|
|
describe('normally', function () {
|
|
beforeEach(function () {
|
|
return this.EditorUpdatesController._applyUpdateFromDocumentUpdater(
|
|
this.io,
|
|
this.doc_id,
|
|
this.update
|
|
)
|
|
})
|
|
|
|
it('should send a version bump to the source client', function () {
|
|
this.sourceClient.emit
|
|
.calledWith('otUpdateApplied', { v: this.version, doc: this.doc_id })
|
|
.should.equal(true)
|
|
return this.sourceClient.emit.calledOnce.should.equal(true)
|
|
})
|
|
|
|
it('should get the clients connected to the document', function () {
|
|
return this.io.sockets.clients
|
|
.calledWith(this.doc_id)
|
|
.should.equal(true)
|
|
})
|
|
|
|
return it('should send the full update to the other clients', function () {
|
|
return Array.from(this.otherClients).map(client =>
|
|
client.emit
|
|
.calledWith('otUpdateApplied', this.update)
|
|
.should.equal(true)
|
|
)
|
|
})
|
|
})
|
|
|
|
return describe('with a duplicate op', function () {
|
|
beforeEach(function () {
|
|
this.update.dup = true
|
|
return this.EditorUpdatesController._applyUpdateFromDocumentUpdater(
|
|
this.io,
|
|
this.doc_id,
|
|
this.update
|
|
)
|
|
})
|
|
|
|
it('should send a version bump to the source client as usual', function () {
|
|
return this.sourceClient.emit
|
|
.calledWith('otUpdateApplied', { v: this.version, doc: this.doc_id })
|
|
.should.equal(true)
|
|
})
|
|
|
|
return it("should not send anything to the other clients (they've already had the op)", function () {
|
|
return Array.from(this.otherClients).map(client =>
|
|
client.emit.calledWith('otUpdateApplied').should.equal(false)
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
return describe('_processErrorFromDocumentUpdater', function () {
|
|
beforeEach(function () {
|
|
this.clients = [new MockClient(), new MockClient()]
|
|
this.io.sockets = { clients: sinon.stub().returns(this.clients) }
|
|
return this.EditorUpdatesController._processErrorFromDocumentUpdater(
|
|
this.io,
|
|
this.doc_id,
|
|
'Something went wrong'
|
|
)
|
|
})
|
|
|
|
it('should log a warning', function () {
|
|
return this.logger.warn.called.should.equal(true)
|
|
})
|
|
|
|
return it('should disconnect all clients in that document', function () {
|
|
this.io.sockets.clients.calledWith(this.doc_id).should.equal(true)
|
|
return Array.from(this.clients).map(client =>
|
|
client.disconnect.called.should.equal(true)
|
|
)
|
|
})
|
|
})
|
|
})
|