overleaf/services/project-history/test/unit/js/SyncManager/SyncManagerTests.js

1075 lines
33 KiB
JavaScript
Raw Normal View History

import sinon from 'sinon'
import { expect } from 'chai'
import mongodb from 'mongodb-legacy'
import tk from 'timekeeper'
import { strict as esmock } from 'esmock'
const { ObjectId } = mongodb
const MODULE_PATH = '../../../../app/js/SyncManager.js'
const timestamp = new Date()
const resyncProjectStructureUpdate = (docs, files) => ({
resyncProjectStructure: { docs, files },
meta: {
ts: timestamp,
},
})
const docContentSyncUpdate = (doc, content) => ({
path: doc.path,
doc: doc.doc,
resyncDocContent: {
content,
},
meta: {
ts: timestamp,
},
})
describe('SyncManager', function () {
beforeEach(async function () {
this.now = new Date()
tk.freeze(this.now)
this.projectId = new ObjectId().toString()
this.historyId = 'mock-overleaf-id'
this.syncState = { origin: { kind: 'history-resync' } }
this.db = {
projectHistorySyncState: {
findOne: sinon.stub().yields(null, this.syncState),
updateOne: sinon.stub().yields(),
},
}
this.callback = sinon.stub()
this.extendLock = sinon.stub().yields()
this.LockManager = {
runWithLock: sinon.spy((key, runner, callback) => {
runner(this.extendLock, callback)
}),
}
this.UpdateCompressor = {
diffAsShareJsOps: sinon.stub(),
}
this.UpdateTranslator = {
isTextUpdate: sinon.stub(),
_convertPathname: sinon.stub(),
}
this.WebApiManager = {
getHistoryId: sinon.stub(),
requestResync: sinon.stub().yields(),
}
this.WebApiManager.getHistoryId
.withArgs(this.projectId)
.yields(null, this.historyId)
this.ErrorRecorder = {
record: sinon.stub().yields(),
recordSyncStart: sinon.stub().yields(),
}
this.RedisManager = {}
this.SnapshotManager = {
getLatestSnapshot: sinon.stub(),
}
this.HistoryStoreManager = {
getBlobStore: sinon.stub(),
_getBlobHashFromString: sinon.stub().returns('random-hash'),
}
this.HashManager = {
_getBlobHashFromString: sinon.stub(),
}
this.Metrics = { inc: sinon.stub() }
this.Settings = {
redis: {
lock: {
key_schema: {
projectHistoryLock({ project_id: projectId }) {
return `ProjectHistoryLock:${projectId}`
},
},
},
},
}
this.SyncManager = await esmock(MODULE_PATH, {
'../../../../app/js/LockManager.js': this.LockManager,
'../../../../app/js/UpdateCompressor.js': this.UpdateCompressor,
'../../../../app/js/UpdateTranslator.js': this.UpdateTranslator,
'../../../../app/js/mongodb.js': { ObjectId, db: this.db },
'../../../../app/js/WebApiManager.js': this.WebApiManager,
'../../../../app/js/ErrorRecorder.js': this.ErrorRecorder,
'../../../../app/js/RedisManager.js': this.RedisManager,
'../../../../app/js/SnapshotManager.js': this.SnapshotManager,
'../../../../app/js/HistoryStoreManager.js': this.HistoryStoreManager,
'../../../../app/js/HashManager.js': this.HashManager,
'@overleaf/metrics': this.Metrics,
'@overleaf/settings': this.Settings,
})
})
afterEach(function () {
tk.reset()
})
describe('startResync', function () {
describe('if a sync is not in progress', function () {
beforeEach(function () {
this.db.projectHistorySyncState.findOne.yields(null, {})
this.SyncManager.startResync(this.projectId, this.callback)
})
it('takes the project lock', function () {
expect(this.LockManager.runWithLock).to.have.been.calledWith(
`ProjectHistoryLock:${this.projectId}`
)
})
it('gets the sync state from mongo', function () {
expect(this.db.projectHistorySyncState.findOne).to.have.been.calledWith(
{ project_id: new ObjectId(this.projectId) }
)
})
it('requests a resync from web', function () {
expect(this.WebApiManager.requestResync).to.have.been.calledWith(
this.projectId
)
})
it('sets the sync state in mongo and prevents it expiring', function () {
expect(
this.db.projectHistorySyncState.updateOne
).to.have.been.calledWith(
{
project_id: new ObjectId(this.projectId),
},
sinon.match({
$set: {
resyncProjectStructure: true,
resyncDocContents: [],
origin: { kind: 'history-resync' },
},
$currentDate: { lastUpdated: true },
$inc: { resyncCount: 1 },
$unset: { expiresAt: true },
}),
{
upsert: true,
}
)
})
it('calls the callback', function () {
expect(this.callback).to.have.been.called
})
})
describe('if project structure sync is in progress', function () {
beforeEach(function () {
const syncState = { resyncProjectStructure: true }
this.db.projectHistorySyncState.findOne.yields(null, syncState)
this.SyncManager.startResync(this.projectId, this.callback)
})
it('returns an error if already syncing', function () {
expect(this.callback).to.have.been.calledWithMatch({
message: 'sync ongoing',
})
})
})
describe('if doc content sync in is progress', function () {
beforeEach(function () {
const syncState = { resyncDocContents: ['/foo.tex'] }
this.db.projectHistorySyncState.findOne.yields(null, syncState)
this.SyncManager.startResync(this.projectId, this.callback)
})
it('returns an error if already syncing', function () {
expect(this.callback).to.have.been.calledWithMatch({
message: 'sync ongoing',
})
})
})
})
describe('setResyncState', function () {
describe('when the sync is starting', function () {
beforeEach(function () {
this.syncState = {
toRaw() {
return {
resyncProjectStructure: true,
resyncDocContents: [],
origin: { kind: 'history-resync' },
}
},
isSyncOngoing: sinon.stub().returns(true),
}
})
it('sets the sync state in mongo and prevents it expiring', function (done) {
// SyncState is a private class of SyncManager
// we know the interface however:
this.SyncManager.setResyncState(
this.projectId,
this.syncState,
error => {
expect(error).to.be.undefined
expect(
this.db.projectHistorySyncState.updateOne
).to.have.been.calledWith(
{
project_id: new ObjectId(this.projectId),
},
sinon.match({
$set: this.syncState.toRaw(),
$currentDate: { lastUpdated: true },
$inc: { resyncCount: 1 },
$unset: { expiresAt: true },
}),
{
upsert: true,
}
)
done()
}
)
})
})
describe('when the sync is ending', function () {
beforeEach(function () {
this.syncState = {
toRaw() {
return {
resyncProjectStructure: false,
resyncDocContents: [],
origin: { kind: 'history-resync' },
}
},
isSyncOngoing: sinon.stub().returns(false),
}
})
it('sets the sync state entry in mongo to expire', function (done) {
this.SyncManager.setResyncState(
this.projectId,
this.syncState,
error => {
expect(error).to.be.undefined
expect(
this.db.projectHistorySyncState.updateOne
).to.have.been.calledWith(
{
project_id: new ObjectId(this.projectId),
},
sinon.match({
$set: {
resyncProjectStructure: false,
resyncDocContents: [],
origin: { kind: 'history-resync' },
expiresAt: new Date(
this.now.getTime() + 90 * 24 * 3600 * 1000
),
},
$currentDate: { lastUpdated: true },
}),
{
upsert: true,
}
)
done()
}
)
})
})
describe('when the new sync state is null', function () {
it('does not update the sync state in mongo', function (done) {
// SyncState is a private class of SyncManager
// we know the interface however:
this.SyncManager.setResyncState(this.projectId, null, error => {
expect(error).to.be.undefined
expect(this.db.projectHistorySyncState.updateOne).to.not.have.been
.called
done()
})
})
})
})
describe('skipUpdatesDuringSync', function () {
describe('if a sync is not in progress', function () {
beforeEach(function () {
this.db.projectHistorySyncState.findOne.yields(null, {})
this.updates = ['some', 'mock', 'updates']
this.SyncManager.skipUpdatesDuringSync(
this.projectId,
this.updates,
this.callback
)
})
it('returns all updates', function () {
expect(this.callback).to.have.been.calledWith(null, this.updates)
})
it('should not return any newSyncState', function () {
expect(this.callback).to.have.been.calledWithExactly(null, this.updates)
})
})
describe('if a sync in is progress', function () {
beforeEach(function () {
this.renameUpdate = {
pathname: 'old.tex',
newPathname: 'new.tex',
}
this.projectStructureSyncUpdate = {
resyncProjectStructure: {
docs: [{ path: 'new.tex' }],
files: [],
},
}
this.textUpdate = {
doc: new ObjectId(),
op: [{ i: 'a', p: 4 }],
meta: {
pathname: 'new.tex',
doc_length: 4,
},
}
this.docContentSyncUpdate = {
path: 'new.tex',
resyncDocContent: {
content: 'a',
},
}
this.UpdateTranslator.isTextUpdate
.withArgs(this.renameUpdate)
.returns(false)
this.UpdateTranslator.isTextUpdate
.withArgs(this.projectStructureSyncUpdate)
.returns(false)
this.UpdateTranslator.isTextUpdate
.withArgs(this.docContentSyncUpdate)
.returns(false)
this.UpdateTranslator.isTextUpdate
.withArgs(this.textUpdate)
.returns(true)
const syncState = {
resyncProjectStructure: true,
resyncDocContents: [],
origin: { kind: 'history-resync' },
}
this.db.projectHistorySyncState.findOne.yields(null, syncState)
})
it('remove updates before a project structure sync update', function () {
const updates = [
this.renameUpdate,
this.textUpdate,
this.projectStructureSyncUpdate,
]
this.SyncManager.skipUpdatesDuringSync(
this.projectId,
updates,
(error, filteredUpdates, syncState) => {
expect(error).to.be.null
expect(filteredUpdates).to.deep.equal([
this.projectStructureSyncUpdate,
])
expect(syncState.toRaw()).to.deep.equal({
resyncProjectStructure: false,
resyncDocContents: ['new.tex'],
origin: { kind: 'history-resync' },
})
}
)
})
it('allow project structure updates after project structure sync update', function () {
const updates = [this.projectStructureSyncUpdate, this.renameUpdate]
this.SyncManager.skipUpdatesDuringSync(
this.projectId,
updates,
(error, filteredUpdates, syncState) => {
expect(error).to.be.null
expect(filteredUpdates).to.deep.equal([
this.projectStructureSyncUpdate,
this.renameUpdate,
])
expect(syncState.toRaw()).to.deep.equal({
resyncProjectStructure: false,
resyncDocContents: ['new.tex'],
origin: { kind: 'history-resync' },
})
}
)
})
it('remove text updates for a doc before doc sync update', function () {
const updates = [
this.projectStructureSyncUpdate,
this.textUpdate,
this.docContentSyncUpdate,
]
this.SyncManager.skipUpdatesDuringSync(
this.projectId,
updates,
(error, filteredUpdates, syncState) => {
expect(error).to.be.null
expect(filteredUpdates).to.deep.equal([
this.projectStructureSyncUpdate,
this.docContentSyncUpdate,
])
expect(syncState.toRaw()).to.deep.equal({
resyncProjectStructure: false,
resyncDocContents: [],
origin: { kind: 'history-resync' },
})
}
)
})
it('allow text updates for a doc after doc sync update', function () {
const updates = [
this.projectStructureSyncUpdate,
this.docContentSyncUpdate,
this.textUpdate,
]
this.SyncManager.skipUpdatesDuringSync(
this.projectId,
updates,
(error, filteredUpdates, syncState) => {
expect(error).to.be.null
expect(filteredUpdates).to.deep.equal([
this.projectStructureSyncUpdate,
this.docContentSyncUpdate,
this.textUpdate,
])
expect(syncState.toRaw()).to.deep.equal({
resyncProjectStructure: false,
resyncDocContents: [],
origin: { kind: 'history-resync' },
})
}
)
})
})
})
describe('expandSyncUpdates', function () {
beforeEach(function () {
this.persistedDoc = {
doc: { data: { hash: 'abcdef' } },
path: 'main.tex',
content: 'asdf',
}
this.persistedFile = {
file: { data: { hash: '123456789a' } },
path: '1.png',
}
this.fileMap = {
'main.tex': {
isEditable: sinon.stub().returns(true),
content: this.persistedDoc.content,
},
'1.png': {
isEditable: sinon.stub().returns(false),
data: { hash: this.persistedFile.file.data.hash },
},
}
this.UpdateTranslator._convertPathname
.withArgs('main.tex')
.returns('main.tex')
this.UpdateTranslator._convertPathname
.withArgs('/main.tex')
.returns('main.tex')
this.UpdateTranslator._convertPathname
.withArgs('another.tex')
.returns('another.tex')
this.UpdateTranslator._convertPathname.withArgs('1.png').returns('1.png')
this.UpdateTranslator._convertPathname.withArgs('2.png').returns('2.png')
this.SnapshotManager.getLatestSnapshot.yields(null, this.fileMap)
})
it('returns updates if no sync updates are queued', function () {
const updates = ['some', 'mock', 'updates']
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.equal(updates)
expect(this.SnapshotManager.getLatestSnapshot).to.not.have.been.called
expect(this.extendLock).to.not.have.been.called
}
)
})
describe('expanding project structure sync updates', function () {
it('queues nothing for expected docs and files', function () {
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc],
[this.persistedFile]
),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([])
expect(this.extendLock).to.have.been.called
}
)
})
it('queues file removes for unexpected files', function () {
const updates = [resyncProjectStructureUpdate([this.persistedDoc], [])]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([
{
pathname: this.persistedFile.path,
new_pathname: '',
meta: {
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
])
expect(this.extendLock).to.have.been.called
}
)
})
it('queues doc removes for unexpected docs', function () {
const updates = [resyncProjectStructureUpdate([], [this.persistedFile])]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([
{
pathname: this.persistedDoc.path,
new_pathname: '',
meta: {
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
])
expect(this.extendLock).to.have.been.called
}
)
})
it('queues file additions for missing files', function () {
const newFile = {
path: '2.png',
file: {},
url: 'filestore/2.png',
}
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc],
[this.persistedFile, newFile]
),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([
{
pathname: newFile.path,
file: newFile.file,
url: newFile.url,
meta: {
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
])
expect(this.extendLock).to.have.been.called
}
)
})
it('queues blank doc additions for missing docs', function () {
const newDoc = {
path: 'another.tex',
doc: new ObjectId().toString(),
}
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc, newDoc],
[this.persistedFile]
),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([
{
pathname: newDoc.path,
doc: newDoc.doc,
docLines: '',
meta: {
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
])
expect(this.extendLock).to.have.been.called
}
)
})
it('removes and re-adds files if whether they are binary differs', function () {
const fileWichWasADoc = {
path: this.persistedDoc.path,
url: 'filestore/2.png',
_hash: 'other-hash',
}
const updates = [
resyncProjectStructureUpdate(
[],
[fileWichWasADoc, this.persistedFile]
),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([
{
pathname: fileWichWasADoc.path,
new_pathname: '',
meta: {
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
{
pathname: fileWichWasADoc.path,
file: fileWichWasADoc.file,
url: fileWichWasADoc.url,
meta: {
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
])
expect(this.extendLock).to.have.been.called
}
)
})
it("does not remove and re-add files if the expected file doesn't have a hash", function () {
const fileWichWasADoc = {
path: this.persistedDoc.path,
url: 'filestore/2.png',
}
const updates = [
resyncProjectStructureUpdate(
[],
[fileWichWasADoc, this.persistedFile]
),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([])
expect(this.extendLock).to.have.been.called
}
)
})
it('does not remove and re-add editable files if there is a binary file with same hash', function () {
const binaryFile = {
file: Object().toString(),
// The paths in the resyncProjectStructureUpdate must have a leading slash ('/')
// The other unit tests in this file are incorrectly missing the leading slash.
// The leading slash is present in web where the paths are created with
// ProjectEntityHandler.getAllEntitiesFromProject in ProjectEntityUpdateHandler.resyncProjectHistory.
path: '/' + this.persistedDoc.path,
url: 'filestore/12345',
_hash: 'abcdef',
}
this.fileMap['main.tex'].data = { hash: 'abcdef' }
const updates = [
resyncProjectStructureUpdate([], [binaryFile, this.persistedFile]),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([])
expect(this.extendLock).to.have.been.called
}
)
})
it('removes and re-adds binary files if they do not have same hash', function () {
const persistedFileWithNewContent = {
_hash: 'anotherhashvalue',
hello: 'world',
path: '1.png',
url: 'filestore-new-url',
}
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc],
[persistedFileWithNewContent]
),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([
{
pathname: persistedFileWithNewContent.path,
new_pathname: '',
meta: {
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
{
pathname: persistedFileWithNewContent.path,
file: persistedFileWithNewContent.file,
url: persistedFileWithNewContent.url,
meta: {
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
])
expect(this.extendLock).to.have.been.called
}
)
})
it('preserves other updates', function () {
const update = 'mock-update'
const updates = [
update,
resyncProjectStructureUpdate(
[this.persistedDoc],
[this.persistedFile]
),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([update])
expect(this.extendLock).to.have.been.called
}
)
})
})
describe('expanding doc contents sync updates', function () {
it('returns errors from diffAsShareJsOps', function () {
const diffError = new Error('test')
this.UpdateCompressor.diffAsShareJsOps.throws(diffError)
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc],
[this.persistedFile]
),
docContentSyncUpdate(this.persistedDoc, this.persistedDoc.content),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.equal(diffError)
expect(this.extendLock).to.have.been.called
}
)
})
it('handles an update for a file that is missing from the snapshot', function () {
const updates = [docContentSyncUpdate('not-in-snapshot.txt', 'test')]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.exist
expect(error.message).to.equal('unrecognised file: not in snapshot')
}
)
})
it('queues nothing for in docs whose contents is in sync', function () {
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc],
[this.persistedFile]
),
docContentSyncUpdate(this.persistedDoc, this.persistedDoc.content),
]
this.UpdateCompressor.diffAsShareJsOps.returns([])
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([])
expect(this.extendLock).to.have.been.called
}
)
})
it('queues text updates for docs whose contents is out of sync', function () {
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc],
[this.persistedFile]
),
docContentSyncUpdate(this.persistedDoc, 'a'),
]
this.UpdateCompressor.diffAsShareJsOps.returns([{ d: 'sdf', p: 1 }])
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([
{
doc: this.persistedDoc.doc,
op: [{ d: 'sdf', p: 1 }],
meta: {
pathname: this.persistedDoc.path,
doc_length: 4,
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
])
expect(this.extendLock).to.have.been.called
}
)
})
it('queues text updates for docs created by project structure sync', function () {
this.UpdateCompressor.diffAsShareJsOps.returns([{ i: 'a', p: 0 }])
const newDoc = {
path: 'another.tex',
doc: new ObjectId().toString(),
content: 'a',
}
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc, newDoc],
[this.persistedFile]
),
docContentSyncUpdate(newDoc, newDoc.content),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([
{
pathname: newDoc.path,
doc: newDoc.doc,
docLines: '',
meta: {
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
{
doc: newDoc.doc,
op: [{ i: 'a', p: 0 }],
meta: {
pathname: newDoc.path,
doc_length: 0,
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
])
expect(this.extendLock).to.have.been.called
}
)
})
it('skips text updates for docs when hashes match', function () {
this.fileMap['main.tex'].getHash = sinon.stub().returns('special-hash')
this.HashManager._getBlobHashFromString.returns('special-hash')
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc],
[this.persistedFile]
),
docContentSyncUpdate(this.persistedDoc, 'hello'),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([])
expect(this.extendLock).to.have.been.called
}
)
})
it('computes text updates for docs when hashes differ', function () {
this.fileMap['main.tex'].getHash = sinon.stub().returns('first-hash')
this.HashManager._getBlobHashFromString.returns('second-hash')
this.UpdateCompressor.diffAsShareJsOps.returns([
{ i: 'test diff', p: 0 },
])
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc],
[this.persistedFile]
),
docContentSyncUpdate(this.persistedDoc, 'hello'),
]
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
expect(error).to.be.null
expect(expandedUpdates).to.deep.equal([
{
doc: this.persistedDoc.doc,
op: [{ i: 'test diff', p: 0 }],
meta: {
pathname: this.persistedDoc.path,
doc_length: 4,
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
])
expect(this.extendLock).to.have.been.called
}
)
})
describe('for docs whose contents is out of sync', function () {
beforeEach(function (done) {
const updates = [
resyncProjectStructureUpdate(
[this.persistedDoc],
[this.persistedFile]
),
docContentSyncUpdate(this.persistedDoc, 'a'),
]
const file = { getContent: sinon.stub().returns('stored content') }
this.fileMap['main.tex'].load = sinon.stub().resolves(file)
this.UpdateCompressor.diffAsShareJsOps.returns([{ d: 'sdf', p: 1 }])
this.SyncManager.expandSyncUpdates(
this.projectId,
this.historyId,
updates,
this.extendLock,
(error, expandedUpdates) => {
this.error = error
this.expandedUpdates = expandedUpdates
done()
}
)
})
it('loads content from the history service when needed', function () {
expect(this.error).to.be.null
expect(this.expandedUpdates).to.deep.equal([
{
doc: this.persistedDoc.doc,
op: [{ d: 'sdf', p: 1 }],
meta: {
pathname: this.persistedDoc.path,
doc_length: 'stored content'.length,
resync: true,
ts: timestamp,
origin: { kind: 'history-resync' },
},
},
])
expect(this.extendLock).to.have.been.called
})
})
})
})
})