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

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
        })
      })
    })
  })
})