Merge pull request #2383 from overleaf/em-async-await

Complete move of ProjectEntityMongoUpdateHandler to async/await

GitOrigin-RevId: ebabcbbf3ffb3e94810564b4600ef1c03f546cf1

services/web/app/src/Features/Project/ProjectEntityMongoUpdateHandler.js

@@ -1,8 +1,16 @@
+/* NOTE: this file is an async/await version of
+ * ProjectEntityMongoUpdateHandler.js. It's temporarily separate from the
+ * callback-style version so that we can test it in production for some code
+ * paths only.
+ */
+const { callbackify } = require('util')
+const { callbackifyMultiResult } = require('../../util/promises')
 const _ = require('underscore')
-const async = require('async')
 const logger = require('logger-sharelatex')
 const path = require('path')
-const settings = require('settings-sharelatex')
+const { ObjectId } = require('mongodb')
+const Settings = require('settings-sharelatex')
+const OError = require('@overleaf/o-error')
 const CooldownManager = require('../Cooldown/CooldownManager')
 const Errors = require('../Errors/Errors')
 const { Folder } = require('../../models/Folder')
@@ -11,843 +19,626 @@ const { Project } = require('../../models/Project')
 const ProjectEntityHandler = require('./ProjectEntityHandler')
 const ProjectGetter = require('./ProjectGetter')
 const ProjectLocator = require('./ProjectLocator')
+const FolderStructureBuilder = require('./FolderStructureBuilder')
 const SafePath = require('./SafePath')
 
 const LOCK_NAMESPACE = 'mongoTransaction'
+const ENTITY_TYPE_TO_MONGO_PATH_SEGMENT = {
+  doc: 'docs',
+  docs: 'docs',
+  file: 'fileRefs',
+  files: 'fileRefs',
+  fileRefs: 'fileRefs',
+  folder: 'folders',
+  folders: 'folders'
+}
+
+module.exports = {
+  LOCK_NAMESPACE,
+  addDoc: callbackifyMultiResult(wrapWithLock(addDoc), ['result', 'project']),
+  addFile: callbackifyMultiResult(wrapWithLock(addFile), ['result', 'project']),
+  addFolder: callbackifyMultiResult(wrapWithLock(addFolder), [
+    'folder',
+    'parentFolderId'
+  ]),
+  replaceFileWithNew: callbackifyMultiResult(wrapWithLock(replaceFileWithNew), [
+    'oldFileRef',
+    'project',
+    'path',
+    'newProject'
+  ]),
+  mkdirp: callbackifyMultiResult(wrapWithLock(mkdirp), [
+    'newFolders',
+    'folder'
+  ]),
+  moveEntity: callbackifyMultiResult(wrapWithLock(moveEntity), [
+    'project',
+    'startPath',
+    'endPath',
+    'rev',
+    'changes'
+  ]),
+  deleteEntity: callbackifyMultiResult(wrapWithLock(deleteEntity), [
+    'entity',
+    'path',
+    'projectBeforeDeletion',
+    'newProject'
+  ]),
+  renameEntity: callbackifyMultiResult(wrapWithLock(renameEntity), [
+    'project',
+    'startPath',
+    'endPath',
+    'rev',
+    'changes'
+  ]),
+  createNewFolderStructure: callbackify(wrapWithLock(createNewFolderStructure)),
+  _insertDeletedDocReference: callbackify(_insertDeletedDocReference),
+  _insertDeletedFileReference: callbackify(_insertDeletedFileReference),
+  _putElement: callbackifyMultiResult(_putElement, ['result', 'project']),
+  _confirmFolder,
+  promises: {
+    addDoc: wrapWithLock(addDoc),
+    addFile: wrapWithLock(addFile),
+    addFolder: wrapWithLock(addFolder),
+    replaceFileWithNew: wrapWithLock(replaceFileWithNew),
+    mkdirp: wrapWithLock(mkdirp),
+    moveEntity: wrapWithLock(moveEntity),
+    deleteEntity: wrapWithLock(deleteEntity),
+    renameEntity: wrapWithLock(renameEntity),
+    createNewFolderStructure: wrapWithLock(createNewFolderStructure),
+    _insertDeletedDocReference,
+    _insertDeletedFileReference,
+    _putElement
+  }
+}
 
 function wrapWithLock(methodWithoutLock) {
   // This lock is used whenever we read or write to an existing project's
   // structure. Some operations to project structure cannot be done atomically
   // in mongo, this lock is used to prevent reading the structure between two
   // parts of a staged update.
-  function methodWithLock(projectId, ...rest) {
-    const adjustedLength = Math.max(rest.length, 1)
-    const args = rest.slice(0, adjustedLength - 1)
-    const callback = rest[adjustedLength - 1]
-    LockManager.runWithLock(
-      LOCK_NAMESPACE,
-      projectId,
-      cb => methodWithoutLock(projectId, ...args, cb),
-      callback
+  async function methodWithLock(projectId, ...rest) {
+    return LockManager.promises.runWithLock(LOCK_NAMESPACE, projectId, () =>
+      methodWithoutLock(projectId, ...rest)
     )
   }
-  methodWithLock.withoutLock = methodWithoutLock
   return methodWithLock
 }
 
-const ProjectEntityMongoUpdateHandler = {
-  LOCK_NAMESPACE,
+async function addDoc(projectId, folderId, doc) {
+  const project = await ProjectGetter.promises.getProjectWithoutLock(
+    projectId,
+    {
+      rootFolder: true,
+      name: true,
+      overleaf: true
+    }
+  )
+  folderId = _confirmFolder(project, folderId)
+  const { result, project: newProject } = await _putElement(
+    project,
+    folderId,
+    doc,
+    'doc'
+  )
+  return { result, project: newProject }
+}
 
-  addDoc: wrapWithLock(function(projectId, folderId, doc, callback) {
-    ProjectGetter.getProjectWithoutLock(
-      projectId,
-      { rootFolder: true, name: true, overleaf: true },
-      (err, project) => {
-        if (err != null) {
-          logger.warn({ projectId, err }, 'error getting project for add doc')
-          return callback(err)
-        }
-        logger.log(
-          { projectId, folderId, doc_name: doc.name },
-          'adding doc to project with project'
-        )
-        ProjectEntityMongoUpdateHandler._confirmFolder(
-          project,
-          folderId,
-          folderId => {
-            ProjectEntityMongoUpdateHandler._putElement(
-              project,
-              folderId,
-              doc,
-              'doc',
-              callback
-            )
-          }
-        )
-      }
-    )
-  }),
-
-  addFile: wrapWithLock(function(projectId, folderId, fileRef, callback) {
-    ProjectGetter.getProjectWithoutLock(
-      projectId,
-      { rootFolder: true, name: true, overleaf: true },
-      (err, project) => {
-        if (err != null) {
-          logger.warn({ projectId, err }, 'error getting project for add file')
-          return callback(err)
-        }
-        logger.log(
-          { projectId: project._id, folderId, file_name: fileRef.name },
-          'adding file'
-        )
-        ProjectEntityMongoUpdateHandler._confirmFolder(
-          project,
-          folderId,
-          folderId =>
-            ProjectEntityMongoUpdateHandler._putElement(
-              project,
-              folderId,
-              fileRef,
-              'file',
-              callback
-            )
-        )
-      }
-    )
-  }),
-
-  replaceFileWithNew: wrapWithLock((projectId, fileId, newFileRef, callback) =>
-    ProjectGetter.getProjectWithoutLock(
-      projectId,
-      { rootFolder: true, name: true, overleaf: true },
-      (err, project) => {
-        if (err != null) {
-          return callback(err)
-        }
-        ProjectLocator.findElement(
-          { project, element_id: fileId, type: 'file' },
-          (err, fileRef, path) => {
-            if (err != null) {
-              return callback(err)
-            }
-            ProjectEntityMongoUpdateHandler._insertDeletedFileReference(
-              projectId,
-              fileRef,
-              err => {
-                if (err != null) {
-                  return callback(err)
-                }
-                const conditions = { _id: project._id }
-                const inc = {}
-                // increment the project structure version as we are adding a new file here
-                inc['version'] = 1
-                const set = {}
-                set[`${path.mongo}._id`] = newFileRef._id
-                set[`${path.mongo}.created`] = new Date()
-                set[`${path.mongo}.linkedFileData`] = newFileRef.linkedFileData
-                inc[`${path.mongo}.rev`] = 1
-                set[`${path.mongo}.hash`] = newFileRef.hash
-                const update = {
-                  $inc: inc,
-                  $set: set
-                }
-                // Note: Mongoose uses new:true to return the modified document
-                // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
-                // but Mongo uses returnNewDocument:true instead
-                // https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndUpdate/
-                // We are using Mongoose here, but if we ever switch to a direct mongo call
-                // the next line will need to be updated.
-                Project.findOneAndUpdate(
-                  conditions,
-                  update,
-                  { new: true },
-                  (err, newProject) => {
-                    if (err != null) {
-                      return callback(err)
-                    }
-                    callback(null, fileRef, project, path, newProject)
-                  }
-                )
-              }
-            )
-          }
-        )
-      }
-    )
-  ),
+async function addFile(projectId, folderId, fileRef) {
+  const project = await ProjectGetter.promises.getProjectWithoutLock(
+    projectId,
+    { rootFolder: true, name: true, overleaf: true }
+  )
+  folderId = _confirmFolder(project, folderId)
+  const { result, project: newProject } = await _putElement(
+    project,
+    folderId,
+    fileRef,
+    'file'
+  )
+  return { result, project: newProject }
+}
 
-  mkdirp: wrapWithLock(function(projectId, path, options, callback) {
-    // defaults to case insensitive paths, use options {exactCaseMatch:true}
-    // to make matching case-sensitive
-    let folders = path.split('/')
-    folders = _.select(folders, folder => folder.length !== 0)
+async function addFolder(projectId, parentFolderId, folderName) {
+  const project = await ProjectGetter.promises.getProjectWithoutLock(
+    projectId,
+    { rootFolder: true, name: true, overleaf: true }
+  )
+  parentFolderId = _confirmFolder(project, parentFolderId)
+  const folder = new Folder({ name: folderName })
+  await _putElement(project, parentFolderId, folder, 'folder')
+  return { folder, parentFolderId }
+}
 
-    ProjectGetter.getProjectWithOnlyFolders(projectId, (err, project) => {
-      if (err != null) {
-        return callback(err)
-      }
-      if (path === '/') {
-        logger.log(
-          { projectId: project._id },
-          'mkdir is only trying to make path of / so sending back root folder'
-        )
-        return callback(null, [], project.rootFolder[0])
-      }
-      logger.log({ projectId: project._id, path, folders }, 'running mkdirp')
-
-      let builtUpPath = ''
-      const procesFolder = (previousFolders, folderName, callback) => {
-        let parentFolderId
-        previousFolders = previousFolders || []
-        const parentFolder = previousFolders[previousFolders.length - 1]
-        if (parentFolder != null) {
-          parentFolderId = parentFolder._id
-        }
-        builtUpPath = `${builtUpPath}/${folderName}`
-        ProjectLocator.findElementByPath(
-          {
-            project,
-            path: builtUpPath,
-            exactCaseMatch: options != null ? options.exactCaseMatch : undefined
-          },
-          (err, foundFolder) => {
-            if (err != null) {
-              logger.log(
-                { path, projectId: project._id, folderName },
-                'making folder from mkdirp'
-              )
-              ProjectEntityMongoUpdateHandler.addFolder.withoutLock(
-                projectId,
-                parentFolderId,
-                folderName,
-                (err, newFolder, parentFolderId) => {
-                  if (err != null) {
-                    return callback(err)
-                  }
-                  newFolder.parentFolder_id = parentFolderId
-                  previousFolders.push(newFolder)
-                  callback(null, previousFolders)
-                }
-              )
-            } else {
-              foundFolder.filterOut = true
-              previousFolders.push(foundFolder)
-              callback(null, previousFolders)
-            }
-          }
-        )
+async function replaceFileWithNew(projectId, fileId, newFileRef) {
+  const project = await ProjectGetter.promises.getProjectWithoutLock(
+    projectId,
+    { rootFolder: true, name: true, overleaf: true }
+  )
+  const { element: fileRef, path } = await ProjectLocator.promises.findElement({
+    project,
+    element_id: fileId,
+    type: 'file'
+  })
+  await _insertDeletedFileReference(projectId, fileRef)
+  const newProject = await Project.findOneAndUpdate(
+    { _id: project._id },
+    {
+      $set: {
+        [`${path.mongo}._id`]: newFileRef._id,
+        [`${path.mongo}.created`]: new Date(),
+        [`${path.mongo}.linkedFileData`]: newFileRef.linkedFileData,
+        [`${path.mongo}.hash`]: newFileRef.hash
+      },
+      $inc: {
+        version: 1,
+        [`${path.mongo}.rev`]: 1
       }
+    },
+    { new: true }
+  ).exec()
+  // Note: Mongoose uses new:true to return the modified document
+  // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
+  // but Mongo uses returnNewDocument:true instead
+  // https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndUpdate/
+  // We are using Mongoose here, but if we ever switch to a direct mongo call
+  // the next line will need to be updated.
+  return { oldFileRef: fileRef, project, path, newProject }
+}
 
-      async.reduce(folders, [], procesFolder, (err, folders) => {
-        if (err != null) {
-          return callback(err)
-        }
-        const lastFolder = folders[folders.length - 1]
-        folders = _.select(folders, folder => !folder.filterOut)
-        callback(null, folders, lastFolder)
+async function mkdirp(projectId, path, options = {}) {
+  // defaults to case insensitive paths, use options {exactCaseMatch:true}
+  // to make matching case-sensitive
+  let folders = path.split('/')
+  folders = _.select(folders, folder => folder.length !== 0)
+
+  const project = await ProjectGetter.promises.getProjectWithOnlyFolders(
+    projectId
+  )
+  if (path === '/') {
+    logger.log(
+      { projectId: project._id },
+      'mkdir is only trying to make path of / so sending back root folder'
+    )
+    return { newFolders: [], folder: project.rootFolder[0] }
+  }
+
+  const newFolders = []
+  let builtUpPath = ''
+  let lastFolder = null
+  for (const folderName of folders) {
+    builtUpPath += `/${folderName}`
+    try {
+      const {
+        element: foundFolder
+      } = await ProjectLocator.promises.findElementByPath({
+        project,
+        path: builtUpPath,
+        exactCaseMatch: options.exactCaseMatch
       })
-    })
-  }),
+      lastFolder = foundFolder
+    } catch (err) {
+      // Folder couldn't be found. Create it.
+      logger.log(
+        { path, projectId: project._id, folderName },
+        'making folder from mkdirp'
+      )
+      const parentFolderId = lastFolder && lastFolder._id
+      const {
+        folder: newFolder,
+        parentFolderId: newParentFolderId
+      } = await addFolder(projectId, parentFolderId, folderName)
+      newFolder.parentFolder_id = newParentFolderId
+      lastFolder = newFolder
+      newFolders.push(newFolder)
+    }
+  }
+  return { folder: lastFolder, newFolders }
+}
 
-  moveEntity: wrapWithLock(function(
+async function moveEntity(projectId, entityId, destFolderId, entityType) {
+  const project = await ProjectGetter.promises.getProjectWithoutLock(
     projectId,
-    entityId,
+    { rootFolder: true, name: true, overleaf: true }
+  )
+  const {
+    element: entity,
+    path: entityPath
+  } = await ProjectLocator.promises.findElement({
+    project,
+    element_id: entityId,
+    type: entityType
+  })
+  // Prevent top-level docs/files with reserved names (to match v1 behaviour)
+  if (_blockedFilename(entityPath, entityType)) {
+    throw new Errors.InvalidNameError('blocked element name')
+  }
+  await _checkValidMove(project, entityType, entity, entityPath, destFolderId)
+  const {
+    docs: oldDocs,
+    files: oldFiles
+  } = await ProjectEntityHandler.promises.getAllEntitiesFromProject(project)
+  // For safety, insert the entity in the destination
+  // location first, and then remove the original.  If
+  // there is an error the entity may appear twice. This
+  // will cause some breakage but is better than being
+  // lost, which is what happens if this is done in the
+  // opposite order.
+  const { result } = await _putElement(
+    project,
     destFolderId,
-    entityType,
-    callback
+    entity,
+    entityType
+  )
+  // Note: putElement always pushes onto the end of an
+  // array so it will never change an existing mongo
+  // path. Therefore it is safe to remove an element
+  // from the project with an existing path after
+  // calling putElement. But we must be sure that we
+  // have not moved a folder subfolder of itself (which
+  // is done by _checkValidMove above) because that
+  // would lead to it being deleted.
+  const newProject = await _removeElementFromMongoArray(
+    Project,
+    projectId,
+    entityPath.mongo,
+    entityId
+  )
+  const {
+    docs: newDocs,
+    files: newFiles
+  } = await ProjectEntityHandler.promises.getAllEntitiesFromProject(newProject)
+  const startPath = entityPath.fileSystem
+  const endPath = result.path.fileSystem
+  const changes = {
+    oldDocs,
+    newDocs,
+    oldFiles,
+    newFiles,
+    newProject
+  }
+  // check that no files have been lost (or duplicated)
+  if (
+    oldFiles.length !== newFiles.length ||
+    oldDocs.length !== newDocs.length
   ) {
-    ProjectGetter.getProjectWithoutLock(
-      projectId,
-      { rootFolder: true, name: true, overleaf: true },
-      (err, project) => {
-        if (err != null) {
-          return callback(err)
-        }
-        ProjectLocator.findElement(
-          { project, element_id: entityId, type: entityType },
-          (err, entity, entityPath) => {
-            if (err != null) {
-              return callback(err)
-            }
-            // Prevent top-level docs/files with reserved names (to match v1 behaviour)
-            if (
-              ProjectEntityMongoUpdateHandler._blockedFilename(
-                entityPath,
-                entityType
-              )
-            ) {
-              return callback(
-                new Errors.InvalidNameError('blocked element name')
-              )
-            }
-            ProjectEntityMongoUpdateHandler._checkValidMove(
-              project,
-              entityType,
-              entity,
-              entityPath,
-              destFolderId,
-              error => {
-                if (error != null) {
-                  return callback(error)
-                }
-                ProjectEntityHandler.getAllEntitiesFromProject(
-                  project,
-                  (error, oldDocs, oldFiles) => {
-                    if (error != null) {
-                      return callback(error)
-                    }
-                    // For safety, insert the entity in the destination
-                    // location first, and then remove the original.  If
-                    // there is an error the entity may appear twice. This
-                    // will cause some breakage but is better than being
-                    // lost, which is what happens if this is done in the
-                    // opposite order.
-                    ProjectEntityMongoUpdateHandler._putElement(
-                      project,
-                      destFolderId,
-                      entity,
-                      entityType,
-                      (err, result) => {
-                        if (err != null) {
-                          return callback(err)
-                        }
-                        // Note: putElement always pushes onto the end of an
-                        // array so it will never change an existing mongo
-                        // path. Therefore it is safe to remove an element
-                        // from the project with an existing path after
-                        // calling putElement. But we must be sure that we
-                        // have not moved a folder subfolder of itself (which
-                        // is done by _checkValidMove above) because that
-                        // would lead to it being deleted.
-                        ProjectEntityMongoUpdateHandler._removeElementFromMongoArray(
-                          Project,
-                          projectId,
-                          entityPath.mongo,
-                          entityId,
-                          (err, newProject) => {
-                            if (err != null) {
-                              return callback(err)
-                            }
-                            ProjectEntityHandler.getAllEntitiesFromProject(
-                              newProject,
-                              (err, newDocs, newFiles) => {
-                                if (err != null) {
-                                  return callback(err)
-                                }
-                                const startPath = entityPath.fileSystem
-                                const endPath = result.path.fileSystem
-                                const changes = {
-                                  oldDocs,
-                                  newDocs,
-                                  oldFiles,
-                                  newFiles,
-                                  newProject
-                                }
-                                // check that no files have been lost (or duplicated)
-                                if (
-                                  oldFiles.length !== newFiles.length ||
-                                  oldDocs.length !== newDocs.length
-                                ) {
-                                  logger.warn(
-                                    {
-                                      projectId,
-                                      oldDocs: oldDocs.length,
-                                      newDocs: newDocs.length,
-                                      oldFiles: oldFiles.length,
-                                      newFiles: newFiles.length,
-                                      origProject: project,
-                                      newProject
-                                    },
-                                    "project corrupted moving files - shouldn't happen"
-                                  )
-                                  return callback(
-                                    new Error(
-                                      'unexpected change in project structure'
-                                    )
-                                  )
-                                }
-                                callback(
-                                  null,
-                                  project,
-                                  startPath,
-                                  endPath,
-                                  entity.rev,
-                                  changes,
-                                  callback
-                                )
-                              }
-                            )
-                          }
-                        )
-                      }
-                    )
-                  }
-                )
-              }
-            )
-          }
-        )
-      }
-    )
-  }),
-
-  deleteEntity: wrapWithLock((projectId, entityId, entityType, callback) =>
-    ProjectGetter.getProjectWithoutLock(
-      projectId,
-      { name: true, rootFolder: true, overleaf: true },
-      (error, project) => {
-        if (error != null) {
-          return callback(error)
-        }
-        ProjectLocator.findElement(
-          { project, element_id: entityId, type: entityType },
-          (error, entity, path) => {
-            if (error != null) {
-              return callback(error)
-            }
-            ProjectEntityMongoUpdateHandler._removeElementFromMongoArray(
-              Project,
-              projectId,
-              path.mongo,
-              entityId,
-              (error, newProject) => {
-                if (error != null) {
-                  return callback(error)
-                }
-                callback(null, entity, path, project, newProject)
-              }
-            )
-          }
-        )
-      }
-    )
-  ),
-
-  renameEntity: wrapWithLock(
-    (projectId, entityId, entityType, newName, callback) =>
-      ProjectGetter.getProjectWithoutLock(
+    logger.warn(
+      {
         projectId,
-        { rootFolder: true, name: true, overleaf: true },
-        (error, project) => {
-          if (error != null) {
-            return callback(error)
-          }
-          ProjectEntityHandler.getAllEntitiesFromProject(
-            project,
-            (error, oldDocs, oldFiles) => {
-              if (error != null) {
-                return callback(error)
-              }
-              ProjectLocator.findElement(
-                { project, element_id: entityId, type: entityType },
-                (error, entity, entPath, parentFolder) => {
-                  if (error != null) {
-                    return callback(error)
-                  }
-                  const endPath = path.join(
-                    path.dirname(entPath.fileSystem),
-                    newName
-                  )
-                  // Prevent top-level docs/files with reserved names (to match v1 behaviour)
-                  if (
-                    ProjectEntityMongoUpdateHandler._blockedFilename(
-                      { fileSystem: endPath },
-                      entityType
-                    )
-                  ) {
-                    return callback(
-                      new Errors.InvalidNameError('blocked element name')
-                    )
-                  }
-                  // check if the new name already exists in the current folder
-                  ProjectEntityMongoUpdateHandler._checkValidElementName(
-                    parentFolder,
-                    newName,
-                    error => {
-                      if (error != null) {
-                        return callback(error)
-                      }
-                      const conditions = { _id: projectId }
-                      const update = { $set: {}, $inc: {} }
-                      const namePath = entPath.mongo + '.name'
-                      update['$set'][namePath] = newName
-                      // we need to increment the project version number for any structure change
-                      update['$inc']['version'] = 1
-                      Project.findOneAndUpdate(
-                        conditions,
-                        update,
-                        { new: true },
-                        (error, newProject) => {
-                          if (error != null) {
-                            return callback(error)
-                          }
-                          ProjectEntityHandler.getAllEntitiesFromProject(
-                            newProject,
-                            (error, newDocs, newFiles) => {
-                              if (error != null) {
-                                return callback(error)
-                              }
-                              const startPath = entPath.fileSystem
-                              const changes = {
-                                oldDocs,
-                                newDocs,
-                                oldFiles,
-                                newFiles,
-                                newProject
-                              }
-                              callback(
-                                null,
-                                project,
-                                startPath,
-                                endPath,
-                                entity.rev,
-                                changes,
-                                callback
-                              )
-                            }
-                          )
-                        }
-                      )
-                    }
-                  )
-                }
-              )
-            }
-          )
-        }
-      )
-  ),
-
-  addFolder: wrapWithLock((projectId, parentFolderId, folderName, callback) =>
-    ProjectGetter.getProjectWithoutLock(
-      projectId,
-      { rootFolder: true, name: true, overleaf: true },
-      (err, project) => {
-        if (err != null) {
-          logger.warn(
-            { projectId, err },
-            'error getting project for add folder'
-          )
-          return callback(err)
-        }
-        ProjectEntityMongoUpdateHandler._confirmFolder(
-          project,
-          parentFolderId,
-          parentFolderId => {
-            const folder = new Folder({ name: folderName })
-            logger.log(
-              { project: project._id, parentFolderId, folderName },
-              'adding new folder'
-            )
-            ProjectEntityMongoUpdateHandler._putElement(
-              project,
-              parentFolderId,
-              folder,
-              'folder',
-              err => {
-                if (err != null) {
-                  logger.warn(
-                    { err, projectId: project._id },
-                    'error adding folder to project'
-                  )
-                  return callback(err)
-                }
-                callback(null, folder, parentFolderId)
-              }
-            )
-          }
-        )
-      }
+        oldDocs: oldDocs.length,
+        newDocs: newDocs.length,
+        oldFiles: oldFiles.length,
+        newFiles: newFiles.length,
+        origProject: project,
+        newProject
+      },
+      "project corrupted moving files - shouldn't happen"
     )
-  ),
-
-  _removeElementFromMongoArray(model, modelId, path, elementId, callback) {
-    const conditions = { _id: modelId }
-    const pullUpdate = { $pull: {}, $inc: {} }
-    const nonArrayPath = path.slice(0, path.lastIndexOf('.'))
-    // remove specific element from array by id
-    pullUpdate['$pull'][nonArrayPath] = { _id: elementId }
-    // we need to increment the project version number for any structure change
-    pullUpdate['$inc']['version'] = 1
-    model.findOneAndUpdate(conditions, pullUpdate, { new: true }, callback)
-  },
-
-  _countElements(project) {
-    function countFolder(folder) {
-      let total = 0
-
-      for (let subfolder of (folder != null ? folder.folders : undefined) ||
-        []) {
-        total += countFolder(subfolder)
-      }
-
-      if (
-        folder != null &&
-        folder.folders != null &&
-        folder.folders.length > 0
-      ) {
-        total += folder.folders.length
-      }
-
-      if (folder != null && folder.docs != null && folder.docs.length > 0) {
-        total += folder.docs.length
-      }
+    throw new Error('unexpected change in project structure')
+  }
+  return { project, startPath, endPath, rev: entity.rev, changes }
+}
 
-      if (
-        folder != null &&
-        folder.fileRefs != null &&
-        folder.fileRefs.length > 0
-      ) {
-        total += folder.fileRefs.length
-      }
+async function deleteEntity(projectId, entityId, entityType, callback) {
+  const project = await ProjectGetter.promises.getProjectWithoutLock(
+    projectId,
+    { name: true, rootFolder: true, overleaf: true }
+  )
+  const { element: entity, path } = await ProjectLocator.promises.findElement({
+    project,
+    element_id: entityId,
+    type: entityType
+  })
+  const newProject = await _removeElementFromMongoArray(
+    Project,
+    projectId,
+    path.mongo,
+    entityId
+  )
+  return { entity, path, projectBeforeDeletion: project, newProject }
+}
 
-      return total
-    }
+async function renameEntity(
+  projectId,
+  entityId,
+  entityType,
+  newName,
+  callback
+) {
+  const project = await ProjectGetter.promises.getProjectWithoutLock(
+    projectId,
+    { rootFolder: true, name: true, overleaf: true }
+  )
+  const {
+    element: entity,
+    path: entPath,
+    folder: parentFolder
+  } = await ProjectLocator.promises.findElement({
+    project,
+    element_id: entityId,
+    type: entityType
+  })
+  const startPath = entPath.fileSystem
+  const endPath = path.join(path.dirname(entPath.fileSystem), newName)
+
+  // Prevent top-level docs/files with reserved names (to match v1 behaviour)
+  if (_blockedFilename({ fileSystem: endPath }, entityType)) {
+    throw new Errors.InvalidNameError('blocked element name')
+  }
 
-    return countFolder(project.rootFolder[0])
-  },
+  // check if the new name already exists in the current folder
+  _checkValidElementName(parentFolder, newName)
+
+  const {
+    docs: oldDocs,
+    files: oldFiles
+  } = await ProjectEntityHandler.promises.getAllEntitiesFromProject(project)
+
+  // we need to increment the project version number for any structure change
+  const newProject = await Project.findOneAndUpdate(
+    { _id: projectId },
+    { $set: { [`${entPath.mongo}.name`]: newName }, $inc: { version: 1 } },
+    { new: true }
+  ).exec()
+
+  const {
+    docs: newDocs,
+    files: newFiles
+  } = await ProjectEntityHandler.promises.getAllEntitiesFromProject(newProject)
+  return {
+    project,
+    startPath,
+    endPath,
+    rev: entity.rev,
+    changes: { oldDocs, newDocs, oldFiles, newFiles, newProject }
+  }
+}
 
-  _putElement(project, folderId, element, type, callback) {
-    function sanitizeTypeOfElement(elementType) {
-      const lastChar = elementType.slice(-1)
-      if (lastChar !== 's') {
-        elementType += 's'
+async function _insertDeletedDocReference(projectId, doc) {
+  await Project.updateOne(
+    { _id: projectId },
+    {
+      $push: {
+        deletedDocs: { _id: doc._id, name: doc.name, deletedAt: new Date() }
       }
-      if (elementType === 'files') {
-        elementType = 'fileRefs'
-      }
-      return elementType
     }
+  ).exec()
+}
 
-    if (element == null || element._id == null) {
-      logger.warn(
-        { projectId: project._id, folderId, element, type },
-        'failed trying to insert element as it was null'
-      )
-      return callback(new Error('no element passed to be inserted'))
-    }
-    type = sanitizeTypeOfElement(type)
-
-    // original check path.resolve("/", element.name) isnt "/#{element.name}" or element.name.match("/")
-    // check if name is allowed
-    if (!SafePath.isCleanFilename(element.name)) {
-      logger.warn(
-        { projectId: project._id, folderId, element, type },
-        'failed trying to insert element as name was invalid'
-      )
-      return callback(new Errors.InvalidNameError('invalid element name'))
+async function _insertDeletedFileReference(projectId, fileRef) {
+  await Project.updateOne(
+    { _id: projectId },
+    {
+      $push: {
+        deletedFiles: {
+          _id: fileRef._id,
+          name: fileRef.name,
+          linkedFileData: fileRef.linkedFileData,
+          hash: fileRef.hash,
+          deletedAt: new Date()
+        }
+      }
     }
+  ).exec()
+}
 
-    if (folderId == null) {
-      folderId = project.rootFolder[0]._id
-    }
+async function _removeElementFromMongoArray(model, modelId, path, elementId) {
+  const nonArrayPath = path.slice(0, path.lastIndexOf('.'))
+  const newDoc = model
+    .findOneAndUpdate(
+      { _id: modelId },
+      {
+        $pull: { [nonArrayPath]: { _id: elementId } },
+        $inc: { version: 1 }
+      },
+      { new: true }
+    )
+    .exec()
+  return newDoc
+}
 
-    if (
-      ProjectEntityMongoUpdateHandler._countElements(project) >
-      settings.maxEntitiesPerProject
-    ) {
-      logger.warn(
-        { projectId: project._id },
-        'project too big, stopping insertions'
-      )
-      CooldownManager.putProjectOnCooldown(project._id)
-      return callback(new Error('project_has_to_many_files'))
+function _countElements(project) {
+  function countFolder(folder) {
+    if (folder == null) {
+      return 0
     }
 
-    ProjectLocator.findElement(
-      { project, element_id: folderId, type: 'folders' },
-      (err, folder, path) => {
-        if (err != null) {
-          logger.warn(
-            { err, projectId: project._id, folderId, type, element },
-            'error finding folder for _putElement'
-          )
-          return callback(err)
-        }
-        const newPath = {
-          fileSystem: `${path.fileSystem}/${element.name}`,
-          mongo: path.mongo
-        }
-        // check if the path would be too long
-        if (!SafePath.isAllowedLength(newPath.fileSystem)) {
-          return callback(new Errors.InvalidNameError('path too long'))
-        }
-        // Prevent top-level docs/files with reserved names (to match v1 behaviour)
-        if (ProjectEntityMongoUpdateHandler._blockedFilename(newPath, type)) {
-          return callback(new Errors.InvalidNameError('blocked element name'))
-        }
-        ProjectEntityMongoUpdateHandler._checkValidElementName(
-          folder,
-          element.name,
-          err => {
-            if (err != null) {
-              return callback(err)
-            }
-            const id = element._id + ''
-            element._id = require('mongoose').Types.ObjectId(id)
-            const conditions = { _id: project._id }
-            const mongopath = `${path.mongo}.${type}`
-            const update = { $push: {}, $inc: {} }
-            update['$push'][mongopath] = element
-            // we need to increment the project version number for any structure change
-            update['$inc']['version'] = 1 // increment project version number
-            logger.log(
-              {
-                projectId: project._id,
-                element_id: element._id,
-                fileType: type,
-                folderId,
-                mongopath
-              },
-              'adding element to project'
-            )
-            // We are using Mongoose here, but if we ever switch to a direct mongo call
-            // the next line will need to be updated to {returnNewDocument:true}
-            Project.findOneAndUpdate(
-              conditions,
-              update,
-              { new: true },
-              (err, newProject) => {
-                if (err != null) {
-                  logger.warn(
-                    { err, projectId: project._id },
-                    'error saving in putElement project'
-                  )
-                  return callback(err)
-                }
-                callback(err, { path: newPath }, newProject)
-              }
-            )
-          }
-        )
-      }
-    )
-  },
-
-  _blockedFilename(entityPath, entityType) {
-    // check if name would be blocked in v1
-    // javascript reserved names are forbidden for docs and files
-    // at the top-level (but folders with reserved names are allowed).
-    const isFolder = ['folder', 'folders'].includes(entityType)
-    const [dir, file] = [
-      path.dirname(entityPath.fileSystem),
-      path.basename(entityPath.fileSystem)
-    ]
-    const isTopLevel = dir === '/'
-    if (isTopLevel && !isFolder && SafePath.isBlockedFilename(file)) {
-      return true
-    } else {
-      return false
-    }
-  },
-
-  _checkValidElementName(folder, name, callback) {
-    // check if the name is already taken by a doc, file or
-    // folder. If so, return an error "file already exists".
-    const err = new Errors.InvalidNameError('file already exists')
-    for (let doc of (folder != null ? folder.docs : undefined) || []) {
-      if (doc.name === name) {
-        return callback(err)
+    let total = 0
+    if (folder.folders) {
+      total += folder.folders.length
+      for (const subfolder of folder.folders) {
+        total += countFolder(subfolder)
       }
     }
-    for (let file of (folder != null ? folder.fileRefs : undefined) || []) {
-      if (file.name === name) {
-        return callback(err)
-      }
+    if (folder.docs) {
+      total += folder.docs.length
     }
-    for (folder of (folder != null ? folder.folders : undefined) || []) {
-      if (folder.name === name) {
-        return callback(err)
-      }
+    if (folder.fileRefs) {
+      total += folder.fileRefs.length
     }
-    callback()
-  },
+    return total
+  }
 
-  _confirmFolder(project, folderId, callback) {
-    logger.log(
-      { folderId, projectId: project._id },
-      'confirming folder in project'
+  return countFolder(project.rootFolder[0])
+}
+
+async function _putElement(project, folderId, element, type) {
+  if (element == null || element._id == null) {
+    logger.warn(
+      { projectId: project._id, folderId, element, type },
+      'failed trying to insert element as it was null'
     )
-    if (folderId + '' === 'undefined') {
-      callback(project.rootFolder[0]._id)
-    } else if (folderId !== null) {
-      callback(folderId)
-    } else {
-      callback(project.rootFolder[0]._id)
-    }
-  },
+    throw new Error('no element passed to be inserted')
+  }
 
-  _checkValidMove(
-    project,
-    entityType,
-    entity,
-    entityPath,
-    destFolderId,
-    callback
-  ) {
-    ProjectLocator.findElement(
-      { project, element_id: destFolderId, type: 'folder' },
-      (err, destEntity, destFolderPath) => {
-        if (err != null) {
-          return callback(err)
-        }
-        // check if there is already a doc/file/folder with the same name
-        // in the destination folder
-        ProjectEntityMongoUpdateHandler._checkValidElementName(
-          destEntity,
-          entity.name,
-          err => {
-            if (err != null) {
-              return callback(err)
-            }
-            if (/folder/.test(entityType)) {
-              logger.log(
-                {
-                  destFolderPath: destFolderPath.fileSystem,
-                  folderPath: entityPath.fileSystem
-                },
-                'checking folder is not moving into child folder'
-              )
-              const isNestedFolder =
-                destFolderPath.fileSystem.slice(
-                  0,
-                  entityPath.fileSystem.length
-                ) === entityPath.fileSystem
-              if (isNestedFolder) {
-                return callback(
-                  new Errors.InvalidNameError(
-                    'destination folder is a child folder of me'
-                  )
-                )
-              }
-            }
-            callback()
-          }
-        )
-      }
+  const pathSegment = _getMongoPathSegmentFromType(type)
+
+  // original check path.resolve("/", element.name) isnt "/#{element.name}" or element.name.match("/")
+  // check if name is allowed
+  if (!SafePath.isCleanFilename(element.name)) {
+    logger.warn(
+      { projectId: project._id, folderId, element, type },
+      'failed trying to insert element as name was invalid'
     )
-  },
+    throw new Errors.InvalidNameError('invalid element name')
+  }
 
-  _insertDeletedDocReference(projectId, doc, callback) {
-    Project.update(
-      {
-        _id: projectId
-      },
+  if (folderId == null) {
+    folderId = project.rootFolder[0]._id
+  }
+
+  if (_countElements(project) > Settings.maxEntitiesPerProject) {
+    logger.warn(
+      { projectId: project._id },
+      'project too big, stopping insertions'
+    )
+    CooldownManager.putProjectOnCooldown(project._id)
+    throw new Error('project_has_to_many_files')
+  }
+
+  const { element: folder, path } = await ProjectLocator.promises.findElement({
+    project,
+    element_id: folderId,
+    type: 'folder'
+  })
+  const newPath = {
+    fileSystem: `${path.fileSystem}/${element.name}`,
+    mongo: path.mongo
+  }
+  // check if the path would be too long
+  if (!SafePath.isAllowedLength(newPath.fileSystem)) {
+    throw new Errors.InvalidNameError('path too long')
+  }
+  // Prevent top-level docs/files with reserved names (to match v1 behaviour)
+  if (_blockedFilename(newPath, type)) {
+    throw new Errors.InvalidNameError('blocked element name')
+  }
+  _checkValidElementName(folder, element.name)
+  element._id = ObjectId(element._id.toString())
+  const mongoPath = `${path.mongo}.${pathSegment}`
+  const newProject = await Project.findOneAndUpdate(
+    { _id: project._id },
+    { $push: { [mongoPath]: element }, $inc: { version: 1 } },
+    { new: true }
+  ).exec()
+  return { result: { path: newPath }, project: newProject }
+}
+
+function _blockedFilename(entityPath, entityType) {
+  // check if name would be blocked in v1
+  // javascript reserved names are forbidden for docs and files
+  // at the top-level (but folders with reserved names are allowed).
+  const isFolder = entityType === 'folder'
+  const dir = path.dirname(entityPath.fileSystem)
+  const file = path.basename(entityPath.fileSystem)
+  const isTopLevel = dir === '/'
+  if (isTopLevel && !isFolder && SafePath.isBlockedFilename(file)) {
+    return true
+  } else {
+    return false
+  }
+}
+
+function _getMongoPathSegmentFromType(type) {
+  const pathSegment = ENTITY_TYPE_TO_MONGO_PATH_SEGMENT[type]
+  if (pathSegment == null) {
+    throw new Error(`Unknown entity type: ${type}`)
+  }
+  return pathSegment
+}
+
+/**
+ * Check if the name is already taken by a doc, file or folder. If so, return an
+ * error "file already exists".
+ */
+function _checkValidElementName(folder, name) {
+  if (folder == null) {
+    return
+  }
+  const elements = []
+    .concat(folder.docs || [])
+    .concat(folder.fileRefs || [])
+    .concat(folder.folders || [])
+  for (const element of elements) {
+    if (element.name === name) {
+      throw new Errors.InvalidNameError('file already exists')
+    }
+  }
+}
+
+function _confirmFolder(project, folderId) {
+  if (folderId == null) {
+    return project.rootFolder[0]._id
+  } else {
+    return folderId
+  }
+}
+
+async function _checkValidMove(
+  project,
+  entityType,
+  entity,
+  entityPath,
+  destFolderId
+) {
+  const {
+    element: destEntity,
+    path: destFolderPath
+  } = await ProjectLocator.promises.findElement({
+    project,
+    element_id: destFolderId,
+    type: 'folder'
+  })
+  // check if there is already a doc/file/folder with the same name
+  // in the destination folder
+  _checkValidElementName(destEntity, entity.name)
+  if (/folder/.test(entityType)) {
+    logger.log(
       {
-        $push: {
-          deletedDocs: {
-            _id: doc._id,
-            name: doc.name,
-            deletedAt: new Date()
-          }
-        }
+        destFolderPath: destFolderPath.fileSystem,
+        folderPath: entityPath.fileSystem
       },
-      {},
-      callback
+      'checking folder is not moving into child folder'
     )
-  },
+    const isNestedFolder =
+      destFolderPath.fileSystem.slice(0, entityPath.fileSystem.length) ===
+      entityPath.fileSystem
+    if (isNestedFolder) {
+      throw new Errors.InvalidNameError(
+        'destination folder is a child folder of me'
+      )
+    }
+  }
+}
 
-  _insertDeletedFileReference(projectId, fileRef, callback) {
-    Project.update(
+async function createNewFolderStructure(projectId, docUploads, fileUploads) {
+  try {
+    const rootFolder = FolderStructureBuilder.buildFolderStructure(
+      docUploads,
+      fileUploads
+    )
+    const result = await Project.updateOne(
       {
-        _id: projectId
+        _id: projectId,
+        'rootFolder.0.folders.0': { $exists: false },
+        'rootFolder.0.docs.0': { $exists: false },
+        'rootFolder.0.files.0': { $exists: false }
       },
       {
-        $push: {
-          deletedFiles: {
-            _id: fileRef._id,
-            name: fileRef.name,
-            linkedFileData: fileRef.linkedFileData,
-            hash: fileRef.hash,
-            deletedAt: new Date()
-          }
-        }
-      },
-      {},
-      callback
-    )
+        $set: { rootFolder: [rootFolder] },
+        $inc: { version: 1 }
+      }
+    ).exec()
+    if (result.n !== 1) {
+      throw new OError({
+        message: 'project not found or folder structure already exists',
+        info: { projectId }
+      })
+    }
+  } catch (err) {
+    throw new OError({
+      message: 'failed to create folder structure',
+      info: { projectId }
+    }).withCause(err)
   }
 }
-
-module.exports = ProjectEntityMongoUpdateHandler

services/web/app/src/Features/Project/ProjectEntityMongoUpdateHandlerCanary.js

@@ -1,644 +0,0 @@
-/* NOTE: this file is an async/await version of
- * ProjectEntityMongoUpdateHandler.js. It's temporarily separate from the
- * callback-style version so that we can test it in production for some code
- * paths only.
- */
-const { callbackify } = require('util')
-const { callbackifyMultiResult } = require('../../util/promises')
-const _ = require('underscore')
-const logger = require('logger-sharelatex')
-const path = require('path')
-const { ObjectId } = require('mongodb')
-const Settings = require('settings-sharelatex')
-const OError = require('@overleaf/o-error')
-const CooldownManager = require('../Cooldown/CooldownManager')
-const Errors = require('../Errors/Errors')
-const { Folder } = require('../../models/Folder')
-const LockManager = require('../../infrastructure/LockManager')
-const { Project } = require('../../models/Project')
-const ProjectEntityHandler = require('./ProjectEntityHandler')
-const ProjectGetter = require('./ProjectGetter')
-const ProjectLocator = require('./ProjectLocator')
-const FolderStructureBuilder = require('./FolderStructureBuilder')
-const SafePath = require('./SafePath')
-
-const LOCK_NAMESPACE = 'mongoTransaction'
-const ENTITY_TYPE_TO_MONGO_PATH_SEGMENT = {
-  doc: 'docs',
-  docs: 'docs',
-  file: 'fileRefs',
-  files: 'fileRefs',
-  fileRefs: 'fileRefs',
-  folder: 'folders',
-  folders: 'folders'
-}
-
-module.exports = {
-  LOCK_NAMESPACE,
-  addDoc: callbackifyMultiResult(wrapWithLock(addDoc), ['result', 'project']),
-  addFile: callbackifyMultiResult(wrapWithLock(addFile), ['result', 'project']),
-  addFolder: callbackifyMultiResult(wrapWithLock(addFolder), [
-    'folder',
-    'parentFolderId'
-  ]),
-  replaceFileWithNew: callbackifyMultiResult(wrapWithLock(replaceFileWithNew), [
-    'oldFileRef',
-    'project',
-    'path',
-    'newProject'
-  ]),
-  mkdirp: callbackifyMultiResult(wrapWithLock(mkdirp), [
-    'newFolders',
-    'folder'
-  ]),
-  moveEntity: callbackifyMultiResult(wrapWithLock(moveEntity), [
-    'project',
-    'startPath',
-    'endPath',
-    'rev',
-    'changes'
-  ]),
-  deleteEntity: callbackifyMultiResult(wrapWithLock(deleteEntity), [
-    'entity',
-    'path',
-    'projectBeforeDeletion',
-    'newProject'
-  ]),
-  renameEntity: callbackifyMultiResult(wrapWithLock(renameEntity), [
-    'project',
-    'startPath',
-    'endPath',
-    'rev',
-    'changes'
-  ]),
-  createNewFolderStructure: callbackify(wrapWithLock(createNewFolderStructure)),
-  _insertDeletedDocReference: callbackify(_insertDeletedDocReference),
-  _insertDeletedFileReference: callbackify(_insertDeletedFileReference),
-  _putElement: callbackifyMultiResult(_putElement, ['result', 'project']),
-  _confirmFolder,
-  promises: {
-    addDoc: wrapWithLock(addDoc),
-    addFile: wrapWithLock(addFile),
-    addFolder: wrapWithLock(addFolder),
-    replaceFileWithNew: wrapWithLock(replaceFileWithNew),
-    mkdirp: wrapWithLock(mkdirp),
-    moveEntity: wrapWithLock(moveEntity),
-    deleteEntity: wrapWithLock(deleteEntity),
-    renameEntity: wrapWithLock(renameEntity),
-    createNewFolderStructure: wrapWithLock(createNewFolderStructure),
-    _insertDeletedDocReference,
-    _insertDeletedFileReference,
-    _putElement
-  }
-}
-
-function wrapWithLock(methodWithoutLock) {
-  // This lock is used whenever we read or write to an existing project's
-  // structure. Some operations to project structure cannot be done atomically
-  // in mongo, this lock is used to prevent reading the structure between two
-  // parts of a staged update.
-  async function methodWithLock(projectId, ...rest) {
-    return LockManager.promises.runWithLock(LOCK_NAMESPACE, projectId, () =>
-      methodWithoutLock(projectId, ...rest)
-    )
-  }
-  return methodWithLock
-}
-
-async function addDoc(projectId, folderId, doc) {
-  const project = await ProjectGetter.promises.getProjectWithoutLock(
-    projectId,
-    {
-      rootFolder: true,
-      name: true,
-      overleaf: true
-    }
-  )
-  folderId = _confirmFolder(project, folderId)
-  const { result, project: newProject } = await _putElement(
-    project,
-    folderId,
-    doc,
-    'doc'
-  )
-  return { result, project: newProject }
-}
-
-async function addFile(projectId, folderId, fileRef) {
-  const project = await ProjectGetter.promises.getProjectWithoutLock(
-    projectId,
-    { rootFolder: true, name: true, overleaf: true }
-  )
-  folderId = _confirmFolder(project, folderId)
-  const { result, project: newProject } = await _putElement(
-    project,
-    folderId,
-    fileRef,
-    'file'
-  )
-  return { result, project: newProject }
-}
-
-async function addFolder(projectId, parentFolderId, folderName) {
-  const project = await ProjectGetter.promises.getProjectWithoutLock(
-    projectId,
-    { rootFolder: true, name: true, overleaf: true }
-  )
-  parentFolderId = _confirmFolder(project, parentFolderId)
-  const folder = new Folder({ name: folderName })
-  await _putElement(project, parentFolderId, folder, 'folder')
-  return { folder, parentFolderId }
-}
-
-async function replaceFileWithNew(projectId, fileId, newFileRef) {
-  const project = await ProjectGetter.promises.getProjectWithoutLock(
-    projectId,
-    { rootFolder: true, name: true, overleaf: true }
-  )
-  const { element: fileRef, path } = await ProjectLocator.promises.findElement({
-    project,
-    element_id: fileId,
-    type: 'file'
-  })
-  await _insertDeletedFileReference(projectId, fileRef)
-  const newProject = await Project.findOneAndUpdate(
-    { _id: project._id },
-    {
-      $set: {
-        [`${path.mongo}._id`]: newFileRef._id,
-        [`${path.mongo}.created`]: new Date(),
-        [`${path.mongo}.linkedFileData`]: newFileRef.linkedFileData,
-        [`${path.mongo}.hash`]: newFileRef.hash
-      },
-      $inc: {
-        version: 1,
-        [`${path.mongo}.rev`]: 1
-      }
-    },
-    { new: true }
-  ).exec()
-  // Note: Mongoose uses new:true to return the modified document
-  // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
-  // but Mongo uses returnNewDocument:true instead
-  // https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndUpdate/
-  // We are using Mongoose here, but if we ever switch to a direct mongo call
-  // the next line will need to be updated.
-  return { oldFileRef: fileRef, project, path, newProject }
-}
-
-async function mkdirp(projectId, path, options = {}) {
-  // defaults to case insensitive paths, use options {exactCaseMatch:true}
-  // to make matching case-sensitive
-  let folders = path.split('/')
-  folders = _.select(folders, folder => folder.length !== 0)
-
-  const project = await ProjectGetter.promises.getProjectWithOnlyFolders(
-    projectId
-  )
-  if (path === '/') {
-    logger.log(
-      { projectId: project._id },
-      'mkdir is only trying to make path of / so sending back root folder'
-    )
-    return { newFolders: [], folder: project.rootFolder[0] }
-  }
-
-  const newFolders = []
-  let builtUpPath = ''
-  let lastFolder = null
-  for (const folderName of folders) {
-    builtUpPath += `/${folderName}`
-    try {
-      const {
-        element: foundFolder
-      } = await ProjectLocator.promises.findElementByPath({
-        project,
-        path: builtUpPath,
-        exactCaseMatch: options.exactCaseMatch
-      })
-      lastFolder = foundFolder
-    } catch (err) {
-      // Folder couldn't be found. Create it.
-      logger.log(
-        { path, projectId: project._id, folderName },
-        'making folder from mkdirp'
-      )
-      const parentFolderId = lastFolder && lastFolder._id
-      const {
-        folder: newFolder,
-        parentFolderId: newParentFolderId
-      } = await addFolder(projectId, parentFolderId, folderName)
-      newFolder.parentFolder_id = newParentFolderId
-      lastFolder = newFolder
-      newFolders.push(newFolder)
-    }
-  }
-  return { folder: lastFolder, newFolders }
-}
-
-async function moveEntity(projectId, entityId, destFolderId, entityType) {
-  const project = await ProjectGetter.promises.getProjectWithoutLock(
-    projectId,
-    { rootFolder: true, name: true, overleaf: true }
-  )
-  const {
-    element: entity,
-    path: entityPath
-  } = await ProjectLocator.promises.findElement({
-    project,
-    element_id: entityId,
-    type: entityType
-  })
-  // Prevent top-level docs/files with reserved names (to match v1 behaviour)
-  if (_blockedFilename(entityPath, entityType)) {
-    throw new Errors.InvalidNameError('blocked element name')
-  }
-  await _checkValidMove(project, entityType, entity, entityPath, destFolderId)
-  const {
-    docs: oldDocs,
-    files: oldFiles
-  } = await ProjectEntityHandler.promises.getAllEntitiesFromProject(project)
-  // For safety, insert the entity in the destination
-  // location first, and then remove the original.  If
-  // there is an error the entity may appear twice. This
-  // will cause some breakage but is better than being
-  // lost, which is what happens if this is done in the
-  // opposite order.
-  const { result } = await _putElement(
-    project,
-    destFolderId,
-    entity,
-    entityType
-  )
-  // Note: putElement always pushes onto the end of an
-  // array so it will never change an existing mongo
-  // path. Therefore it is safe to remove an element
-  // from the project with an existing path after
-  // calling putElement. But we must be sure that we
-  // have not moved a folder subfolder of itself (which
-  // is done by _checkValidMove above) because that
-  // would lead to it being deleted.
-  const newProject = await _removeElementFromMongoArray(
-    Project,
-    projectId,
-    entityPath.mongo,
-    entityId
-  )
-  const {
-    docs: newDocs,
-    files: newFiles
-  } = await ProjectEntityHandler.promises.getAllEntitiesFromProject(newProject)
-  const startPath = entityPath.fileSystem
-  const endPath = result.path.fileSystem
-  const changes = {
-    oldDocs,
-    newDocs,
-    oldFiles,
-    newFiles,
-    newProject
-  }
-  // check that no files have been lost (or duplicated)
-  if (
-    oldFiles.length !== newFiles.length ||
-    oldDocs.length !== newDocs.length
-  ) {
-    logger.warn(
-      {
-        projectId,
-        oldDocs: oldDocs.length,
-        newDocs: newDocs.length,
-        oldFiles: oldFiles.length,
-        newFiles: newFiles.length,
-        origProject: project,
-        newProject
-      },
-      "project corrupted moving files - shouldn't happen"
-    )
-    throw new Error('unexpected change in project structure')
-  }
-  return { project, startPath, endPath, rev: entity.rev, changes }
-}
-
-async function deleteEntity(projectId, entityId, entityType, callback) {
-  const project = await ProjectGetter.promises.getProjectWithoutLock(
-    projectId,
-    { name: true, rootFolder: true, overleaf: true }
-  )
-  const { element: entity, path } = await ProjectLocator.promises.findElement({
-    project,
-    element_id: entityId,
-    type: entityType
-  })
-  const newProject = await _removeElementFromMongoArray(
-    Project,
-    projectId,
-    path.mongo,
-    entityId
-  )
-  return { entity, path, projectBeforeDeletion: project, newProject }
-}
-
-async function renameEntity(
-  projectId,
-  entityId,
-  entityType,
-  newName,
-  callback
-) {
-  const project = await ProjectGetter.promises.getProjectWithoutLock(
-    projectId,
-    { rootFolder: true, name: true, overleaf: true }
-  )
-  const {
-    element: entity,
-    path: entPath,
-    folder: parentFolder
-  } = await ProjectLocator.promises.findElement({
-    project,
-    element_id: entityId,
-    type: entityType
-  })
-  const startPath = entPath.fileSystem
-  const endPath = path.join(path.dirname(entPath.fileSystem), newName)
-
-  // Prevent top-level docs/files with reserved names (to match v1 behaviour)
-  if (_blockedFilename({ fileSystem: endPath }, entityType)) {
-    throw new Errors.InvalidNameError('blocked element name')
-  }
-
-  // check if the new name already exists in the current folder
-  _checkValidElementName(parentFolder, newName)
-
-  const {
-    docs: oldDocs,
-    files: oldFiles
-  } = await ProjectEntityHandler.promises.getAllEntitiesFromProject(project)
-
-  // we need to increment the project version number for any structure change
-  const newProject = await Project.findOneAndUpdate(
-    { _id: projectId },
-    { $set: { [`${entPath.mongo}.name`]: newName }, $inc: { version: 1 } },
-    { new: true }
-  ).exec()
-
-  const {
-    docs: newDocs,
-    files: newFiles
-  } = await ProjectEntityHandler.promises.getAllEntitiesFromProject(newProject)
-  return {
-    project,
-    startPath,
-    endPath,
-    rev: entity.rev,
-    changes: { oldDocs, newDocs, oldFiles, newFiles, newProject }
-  }
-}
-
-async function _insertDeletedDocReference(projectId, doc) {
-  await Project.updateOne(
-    { _id: projectId },
-    {
-      $push: {
-        deletedDocs: { _id: doc._id, name: doc.name, deletedAt: new Date() }
-      }
-    }
-  ).exec()
-}
-
-async function _insertDeletedFileReference(projectId, fileRef) {
-  await Project.updateOne(
-    { _id: projectId },
-    {
-      $push: {
-        deletedFiles: {
-          _id: fileRef._id,
-          name: fileRef.name,
-          linkedFileData: fileRef.linkedFileData,
-          hash: fileRef.hash,
-          deletedAt: new Date()
-        }
-      }
-    }
-  ).exec()
-}
-
-async function _removeElementFromMongoArray(model, modelId, path, elementId) {
-  const nonArrayPath = path.slice(0, path.lastIndexOf('.'))
-  const newDoc = model
-    .findOneAndUpdate(
-      { _id: modelId },
-      {
-        $pull: { [nonArrayPath]: { _id: elementId } },
-        $inc: { version: 1 }
-      },
-      { new: true }
-    )
-    .exec()
-  return newDoc
-}
-
-function _countElements(project) {
-  function countFolder(folder) {
-    if (folder == null) {
-      return 0
-    }
-
-    let total = 0
-    if (folder.folders) {
-      total += folder.folders.length
-      for (const subfolder of folder.folders) {
-        total += countFolder(subfolder)
-      }
-    }
-    if (folder.docs) {
-      total += folder.docs.length
-    }
-    if (folder.fileRefs) {
-      total += folder.fileRefs.length
-    }
-    return total
-  }
-
-  return countFolder(project.rootFolder[0])
-}
-
-async function _putElement(project, folderId, element, type) {
-  if (element == null || element._id == null) {
-    logger.warn(
-      { projectId: project._id, folderId, element, type },
-      'failed trying to insert element as it was null'
-    )
-    throw new Error('no element passed to be inserted')
-  }
-
-  const pathSegment = _getMongoPathSegmentFromType(type)
-
-  // original check path.resolve("/", element.name) isnt "/#{element.name}" or element.name.match("/")
-  // check if name is allowed
-  if (!SafePath.isCleanFilename(element.name)) {
-    logger.warn(
-      { projectId: project._id, folderId, element, type },
-      'failed trying to insert element as name was invalid'
-    )
-    throw new Errors.InvalidNameError('invalid element name')
-  }
-
-  if (folderId == null) {
-    folderId = project.rootFolder[0]._id
-  }
-
-  if (_countElements(project) > Settings.maxEntitiesPerProject) {
-    logger.warn(
-      { projectId: project._id },
-      'project too big, stopping insertions'
-    )
-    CooldownManager.putProjectOnCooldown(project._id)
-    throw new Error('project_has_to_many_files')
-  }
-
-  const { element: folder, path } = await ProjectLocator.promises.findElement({
-    project,
-    element_id: folderId,
-    type: 'folder'
-  })
-  const newPath = {
-    fileSystem: `${path.fileSystem}/${element.name}`,
-    mongo: path.mongo
-  }
-  // check if the path would be too long
-  if (!SafePath.isAllowedLength(newPath.fileSystem)) {
-    throw new Errors.InvalidNameError('path too long')
-  }
-  // Prevent top-level docs/files with reserved names (to match v1 behaviour)
-  if (_blockedFilename(newPath, type)) {
-    throw new Errors.InvalidNameError('blocked element name')
-  }
-  _checkValidElementName(folder, element.name)
-  element._id = ObjectId(element._id.toString())
-  const mongoPath = `${path.mongo}.${pathSegment}`
-  const newProject = await Project.findOneAndUpdate(
-    { _id: project._id },
-    { $push: { [mongoPath]: element }, $inc: { version: 1 } },
-    { new: true }
-  ).exec()
-  return { result: { path: newPath }, project: newProject }
-}
-
-function _blockedFilename(entityPath, entityType) {
-  // check if name would be blocked in v1
-  // javascript reserved names are forbidden for docs and files
-  // at the top-level (but folders with reserved names are allowed).
-  const isFolder = entityType === 'folder'
-  const dir = path.dirname(entityPath.fileSystem)
-  const file = path.basename(entityPath.fileSystem)
-  const isTopLevel = dir === '/'
-  if (isTopLevel && !isFolder && SafePath.isBlockedFilename(file)) {
-    return true
-  } else {
-    return false
-  }
-}
-
-function _getMongoPathSegmentFromType(type) {
-  const pathSegment = ENTITY_TYPE_TO_MONGO_PATH_SEGMENT[type]
-  if (pathSegment == null) {
-    throw new Error(`Unknown entity type: ${type}`)
-  }
-  return pathSegment
-}
-
-/**
- * Check if the name is already taken by a doc, file or folder. If so, return an
- * error "file already exists".
- */
-function _checkValidElementName(folder, name) {
-  if (folder == null) {
-    return
-  }
-  const elements = []
-    .concat(folder.docs || [])
-    .concat(folder.fileRefs || [])
-    .concat(folder.folders || [])
-  for (const element of elements) {
-    if (element.name === name) {
-      throw new Errors.InvalidNameError('file already exists')
-    }
-  }
-}
-
-function _confirmFolder(project, folderId) {
-  if (folderId == null) {
-    return project.rootFolder[0]._id
-  } else {
-    return folderId
-  }
-}
-
-async function _checkValidMove(
-  project,
-  entityType,
-  entity,
-  entityPath,
-  destFolderId
-) {
-  const {
-    element: destEntity,
-    path: destFolderPath
-  } = await ProjectLocator.promises.findElement({
-    project,
-    element_id: destFolderId,
-    type: 'folder'
-  })
-  // check if there is already a doc/file/folder with the same name
-  // in the destination folder
-  _checkValidElementName(destEntity, entity.name)
-  if (/folder/.test(entityType)) {
-    logger.log(
-      {
-        destFolderPath: destFolderPath.fileSystem,
-        folderPath: entityPath.fileSystem
-      },
-      'checking folder is not moving into child folder'
-    )
-    const isNestedFolder =
-      destFolderPath.fileSystem.slice(0, entityPath.fileSystem.length) ===
-      entityPath.fileSystem
-    if (isNestedFolder) {
-      throw new Errors.InvalidNameError(
-        'destination folder is a child folder of me'
-      )
-    }
-  }
-}
-
-async function createNewFolderStructure(projectId, docUploads, fileUploads) {
-  try {
-    const rootFolder = FolderStructureBuilder.buildFolderStructure(
-      docUploads,
-      fileUploads
-    )
-    const result = await Project.updateOne(
-      {
-        _id: projectId,
-        'rootFolder.0.folders.0': { $exists: false },
-        'rootFolder.0.docs.0': { $exists: false },
-        'rootFolder.0.files.0': { $exists: false }
-      },
-      {
-        $set: { rootFolder: [rootFolder] },
-        $inc: { version: 1 }
-      }
-    ).exec()
-    if (result.n !== 1) {
-      throw new OError({
-        message: 'project not found or folder structure already exists',
-        info: { projectId }
-      })
-    }
-  } catch (err) {
-    throw new OError({
-      message: 'failed to create folder structure',
-      info: { projectId }
-    }).withCause(err)
-  }
-}

services/web/app/src/Features/Project/ProjectEntityUpdateHandler.js

@@ -82,59 +82,57 @@ const ProjectEntityUpdateHandler = {
           { projectId, folderId, originalProjectId, originalFileRef },
           'copying file in s3 with project'
         )
-        ProjectEntityMongoUpdateHandler._confirmFolder(
+        folderId = ProjectEntityMongoUpdateHandler._confirmFolder(
           project,
-          folderId,
-          folderId => {
-            if (originalFileRef == null) {
-              logger.err(
-                { projectId, folderId, originalProjectId, originalFileRef },
-                'file trying to copy is null'
-              )
-              return callback()
-            }
-            // convert any invalid characters in original file to '_'
-            const fileProperties = {
-              name: SafePath.clean(originalFileRef.name)
-            }
-            if (originalFileRef.linkedFileData != null) {
-              fileProperties.linkedFileData = originalFileRef.linkedFileData
-            }
-            if (originalFileRef.hash != null) {
-              fileProperties.hash = originalFileRef.hash
-            }
-            const fileRef = new File(fileProperties)
-            FileStoreHandler.copyFile(
-              originalProjectId,
-              originalFileRef._id,
-              project._id,
-              fileRef._id,
-              (err, fileStoreUrl) => {
-                if (err != null) {
-                  logger.warn(
-                    {
-                      err,
-                      projectId,
-                      folderId,
-                      originalProjectId,
-                      originalFileRef
-                    },
-                    'error coping file in s3'
-                  )
-                  return callback(err)
-                }
-                next(
+          folderId
+        )
+        if (originalFileRef == null) {
+          logger.err(
+            { projectId, folderId, originalProjectId, originalFileRef },
+            'file trying to copy is null'
+          )
+          return callback()
+        }
+        // convert any invalid characters in original file to '_'
+        const fileProperties = {
+          name: SafePath.clean(originalFileRef.name)
+        }
+        if (originalFileRef.linkedFileData != null) {
+          fileProperties.linkedFileData = originalFileRef.linkedFileData
+        }
+        if (originalFileRef.hash != null) {
+          fileProperties.hash = originalFileRef.hash
+        }
+        const fileRef = new File(fileProperties)
+        FileStoreHandler.copyFile(
+          originalProjectId,
+          originalFileRef._id,
+          project._id,
+          fileRef._id,
+          (err, fileStoreUrl) => {
+            if (err != null) {
+              logger.warn(
+                {
+                  err,
                   projectId,
-                  project,
                   folderId,
                   originalProjectId,
-                  originalFileRef,
-                  userId,
-                  fileRef,
-                  fileStoreUrl,
-                  callback
-                )
-              }
+                  originalFileRef
+                },
+                'error coping file in s3'
+              )
+              return callback(err)
+            }
+            next(
+              projectId,
+              project,
+              folderId,
+              originalProjectId,
+              originalFileRef,
+              userId,
+              fileRef,
+              fileStoreUrl,
+              callback
             )
           }
         )

services/web/test/unit/src/Project/ProjectEntityMongoUpdateHandlerCanaryTests.js

@@ -1,1092 +0,0 @@
-const { expect } = require('chai')
-const sinon = require('sinon')
-const tk = require('timekeeper')
-const Errors = require('../../../../app/src/Features/Errors/Errors')
-const { ObjectId } = require('mongoose').Types
-const SandboxedModule = require('sandboxed-module')
-const { Project } = require('../helpers/models/Project')
-
-const MODULE_PATH =
-  '../../../../app/src/Features/Project/ProjectEntityMongoUpdateHandlerCanary'
-
-describe('ProjectEntityMongoUpdateHandler', function() {
-  beforeEach(function() {
-    this.doc = {
-      _id: ObjectId(),
-      name: 'test-doc.txt',
-      lines: ['hello', 'world'],
-      rev: 1234
-    }
-    this.docPath = {
-      mongo: 'rootFolder.0.docs.0',
-      fileSystem: '/test-doc.txt'
-    }
-    this.file = {
-      _id: ObjectId(),
-      name: 'something.jpg',
-      linkedFileData: { provider: 'url' },
-      hash: 'some-hash'
-    }
-    this.filePath = {
-      fileSystem: '/something.png',
-      mongo: 'rootFolder.0.fileRefs.0'
-    }
-    this.subfolder = { _id: ObjectId(), name: 'test-subfolder' }
-    this.subfolderPath = {
-      fileSystem: '/test-folder/test-subfolder',
-      mongo: 'rootFolder.0.folders.0.folders.0'
-    }
-    this.folder = {
-      _id: ObjectId(),
-      name: 'test-folder',
-      folders: [this.subfolder]
-    }
-    this.folderPath = {
-      fileSystem: '/test-folder',
-      mongo: 'rootFolder.0.folders.0'
-    }
-    this.rootFolder = {
-      _id: ObjectId(),
-      folders: [this.folder],
-      docs: [this.doc],
-      fileRefs: [this.file]
-    }
-    this.rootFolderPath = {
-      fileSystem: '/',
-      mongo: 'rootFolder.0'
-    }
-    this.project = {
-      _id: ObjectId(),
-      name: 'project name',
-      rootFolder: [this.rootFolder]
-    }
-
-    this.logger = {
-      log: sinon.stub(),
-      warn: sinon.stub(),
-      error: sinon.stub(),
-      err() {}
-    }
-    this.Settings = { maxEntitiesPerProject: 100 }
-    this.CooldownManager = {}
-    this.LockManager = {
-      promises: {
-        runWithLock: sinon.spy((namespace, id, runner) => runner())
-      }
-    }
-
-    this.FolderModel = sinon.stub()
-    this.ProjectMock = sinon.mock(Project)
-    this.ProjectEntityHandler = {
-      promises: {
-        getAllEntitiesFromProject: sinon.stub()
-      }
-    }
-    this.ProjectLocator = {
-      promises: {
-        findElement: sinon.stub().rejects(new Error('not found')),
-        findElementByPath: sinon.stub().rejects(new Error('not found'))
-      }
-    }
-    this.ProjectLocator.promises.findElement
-      .withArgs({
-        project: this.project,
-        element_id: this.rootFolder._id,
-        type: 'folder'
-      })
-      .resolves({
-        element: this.rootFolder,
-        path: this.rootFolderPath
-      })
-    this.ProjectLocator.promises.findElement
-      .withArgs({
-        project: this.project,
-        element_id: this.folder._id,
-        type: 'folder'
-      })
-      .resolves({
-        element: this.folder,
-        path: this.folderPath,
-        folder: this.rootFolder
-      })
-    this.ProjectLocator.promises.findElement
-      .withArgs({
-        project: this.project,
-        element_id: this.subfolder._id,
-        type: 'folder'
-      })
-      .resolves({
-        element: this.subfolder,
-        path: this.subfolderPath,
-        folder: this.folder
-      })
-    this.ProjectLocator.promises.findElement
-      .withArgs({
-        project: this.project,
-        element_id: this.file._id,
-        type: 'file'
-      })
-      .resolves({
-        element: this.file,
-        path: this.filePath,
-        folder: this.rootFolder
-      })
-    this.ProjectLocator.promises.findElement
-      .withArgs({
-        project: this.project,
-        element_id: this.doc._id,
-        type: 'doc'
-      })
-      .resolves({
-        element: this.doc,
-        path: this.docPath,
-        folder: this.rootFolder
-      })
-    this.ProjectLocator.promises.findElementByPath
-      .withArgs(
-        sinon.match({
-          project: this.project,
-          path: '/'
-        })
-      )
-      .resolves({ element: this.rootFolder, type: 'folder' })
-    this.ProjectLocator.promises.findElementByPath
-      .withArgs(
-        sinon.match({
-          project: this.project,
-          path: '/test-folder'
-        })
-      )
-      .resolves({ element: this.folder, type: 'folder' })
-    this.ProjectLocator.promises.findElementByPath
-      .withArgs(
-        sinon.match({
-          project: this.project,
-          path: '/test-folder/test-subfolder'
-        })
-      )
-      .resolves({ element: this.subfolder, type: 'folder' })
-
-    this.ProjectGetter = {
-      promises: {
-        getProjectWithoutLock: sinon
-          .stub()
-          .withArgs(this.project._id)
-          .resolves(this.project),
-        getProjectWithOnlyFolders: sinon.stub().resolves(this.project)
-      }
-    }
-
-    this.FolderStructureBuilder = {
-      buildFolderStructure: sinon.stub()
-    }
-
-    this.subject = SandboxedModule.require(MODULE_PATH, {
-      globals: {
-        console: console
-      },
-      requires: {
-        'logger-sharelatex': this.logger,
-        'settings-sharelatex': this.Settings,
-        '../Cooldown/CooldownManager': this.CooldownManager,
-        '../../models/Folder': { Folder: this.FolderModel },
-        '../../infrastructure/LockManager': this.LockManager,
-        '../../models/Project': { Project },
-        './ProjectEntityHandler': this.ProjectEntityHandler,
-        './ProjectLocator': this.ProjectLocator,
-        './ProjectGetter': this.ProjectGetter,
-        './FolderStructureBuilder': this.FolderStructureBuilder,
-        // We need to provide Errors here to make instance check work
-        '../Errors/Errors': Errors
-      }
-    })
-  })
-
-  afterEach(function() {
-    this.ProjectMock.restore()
-  })
-
-  beforeEach(function() {
-    tk.freeze(Date.now())
-  })
-
-  afterEach(function() {
-    tk.reset()
-  })
-
-  describe('addDoc', function() {
-    beforeEach(async function() {
-      const doc = { _id: ObjectId(), name: 'other.txt' }
-      this.ProjectMock.expects('findOneAndUpdate')
-        .withArgs(
-          { _id: this.project._id },
-          {
-            $push: { 'rootFolder.0.folders.0.docs': doc },
-            $inc: { version: 1 }
-          }
-        )
-        .chain('exec')
-        .resolves(this.project)
-      this.result = await this.subject.promises.addDoc(
-        this.project._id,
-        this.folder._id,
-        doc
-      )
-    })
-
-    it('adds the document in Mongo', function() {
-      this.ProjectMock.verify()
-    })
-
-    it('returns path info and the project', function() {
-      expect(this.result).to.deep.equal({
-        result: {
-          path: {
-            mongo: 'rootFolder.0.folders.0',
-            fileSystem: '/test-folder/other.txt'
-          }
-        },
-        project: this.project
-      })
-    })
-  })
-
-  describe('addFile', function() {
-    beforeEach(function() {
-      this.newFile = { _id: ObjectId(), name: 'picture.jpg' }
-      this.ProjectMock.expects('findOneAndUpdate')
-        .withArgs(
-          { _id: this.project._id },
-          {
-            $push: { 'rootFolder.0.folders.0.fileRefs': this.newFile },
-            $inc: { version: 1 }
-          }
-        )
-        .chain('exec')
-        .resolves(this.project)
-    })
-
-    describe('happy path', function() {
-      beforeEach(async function() {
-        this.result = await this.subject.promises.addFile(
-          this.project._id,
-          this.folder._id,
-          this.newFile
-        )
-      })
-
-      it('adds the file in Mongo', function() {
-        this.ProjectMock.verify()
-      })
-
-      it('returns path info and the project', function() {
-        expect(this.result).to.deep.equal({
-          result: {
-            path: {
-              mongo: 'rootFolder.0.folders.0',
-              fileSystem: '/test-folder/picture.jpg'
-            }
-          },
-          project: this.project
-        })
-      })
-    })
-
-    describe('when entity limit is reached', function() {
-      beforeEach(function() {
-        this.savedMaxEntities = this.Settings.maxEntitiesPerProject
-        this.Settings.maxEntitiesPerProject = 3
-      })
-
-      afterEach(function() {
-        this.Settings.maxEntitiesPerProject = this.savedMaxEntities
-      })
-
-      it('should throw an error', async function() {
-        await expect(
-          this.subject.promises.addFile(
-            this.project._id,
-            this.folder._id,
-            this.newFile
-          )
-        ).to.be.rejected
-      })
-    })
-  })
-
-  describe('addFolder', function() {
-    beforeEach(async function() {
-      const folderName = 'New folder'
-      this.FolderModel.withArgs({ name: folderName }).returns({
-        _id: ObjectId(),
-        name: folderName
-      })
-      this.ProjectMock.expects('findOneAndUpdate')
-        .withArgs(
-          { _id: this.project._id },
-          {
-            $push: {
-              'rootFolder.0.folders.0.folders': sinon.match({
-                name: folderName
-              })
-            },
-            $inc: { version: 1 }
-          }
-        )
-        .chain('exec')
-        .resolves(this.project)
-      await this.subject.promises.addFolder(
-        this.project._id,
-        this.folder._id,
-        folderName
-      )
-    })
-
-    it('adds the folder in Mongo', function() {
-      this.ProjectMock.verify()
-    })
-  })
-
-  describe('replaceFileWithNew', function() {
-    beforeEach(async function() {
-      const newFile = {
-        _id: ObjectId(),
-        name: 'some-other-file.png',
-        linkedFileData: { some: 'data' },
-        hash: 'some-hash'
-      }
-      // Add a deleted file record
-      this.ProjectMock.expects('updateOne')
-        .withArgs(
-          { _id: this.project._id },
-          {
-            $push: {
-              deletedFiles: {
-                _id: this.file._id,
-                name: this.file.name,
-                linkedFileData: this.file.linkedFileData,
-                hash: this.file.hash,
-                deletedAt: sinon.match.date
-              }
-            }
-          }
-        )
-        .chain('exec')
-        .resolves()
-      // Update the file in place
-      this.ProjectMock.expects('findOneAndUpdate')
-        .withArgs(
-          { _id: this.project._id },
-          {
-            $set: {
-              'rootFolder.0.fileRefs.0._id': newFile._id,
-              'rootFolder.0.fileRefs.0.created': sinon.match.date,
-              'rootFolder.0.fileRefs.0.linkedFileData': newFile.linkedFileData,
-              'rootFolder.0.fileRefs.0.hash': newFile.hash
-            },
-            $inc: {
-              version: 1,
-              'rootFolder.0.fileRefs.0.rev': 1
-            }
-          }
-        )
-        .chain('exec')
-        .resolves(this.project)
-      await this.subject.promises.replaceFileWithNew(
-        this.project._id,
-        this.file._id,
-        newFile
-      )
-    })
-
-    it('updates the database', function() {
-      this.ProjectMock.verify()
-    })
-  })
-
-  describe('mkdirp', function() {
-    describe('when the path is just a slash', function() {
-      beforeEach(async function() {
-        this.result = await this.subject.promises.mkdirp(this.project._id, '/')
-      })
-
-      it('should return the root folder', function() {
-        expect(this.result.folder).to.deep.equal(this.rootFolder)
-      })
-
-      it('should not report a parent folder', function() {
-        expect(this.result.folder.parentFolder_id).not.to.exist
-      })
-
-      it('should not return new folders', function() {
-        expect(this.result.newFolders).to.have.length(0)
-      })
-    })
-
-    describe('when the folder already exists', function() {
-      beforeEach(async function() {
-        this.result = await this.subject.promises.mkdirp(
-          this.project._id,
-          '/test-folder'
-        )
-      })
-
-      it('should return the existing folder', function() {
-        expect(this.result.folder).to.deep.equal(this.folder)
-      })
-
-      it('should report the parent folder', function() {
-        expect(this.result.folder.parentFolder_id).not.equal(
-          this.rootFolder._id
-        )
-      })
-
-      it('should not return new folders', function() {
-        expect(this.result.newFolders).to.have.length(0)
-      })
-    })
-
-    describe('when the path is a new folder at the top level', function() {
-      beforeEach(async function() {
-        this.newFolder = { _id: ObjectId(), name: 'new-folder' }
-        this.FolderModel.returns(this.newFolder)
-        this.exactCaseMatch = false
-        this.ProjectMock.expects('findOneAndUpdate')
-          .withArgs(
-            { _id: this.project._id },
-            {
-              $push: { 'rootFolder.0.folders': this.newFolder },
-              $inc: { version: 1 }
-            }
-          )
-          .chain('exec')
-          .resolves(this.project)
-        this.result = await this.subject.promises.mkdirp(
-          this.project._id,
-          '/new-folder/',
-          { exactCaseMatch: this.exactCaseMatch }
-        )
-      })
-      it('should update the database', function() {
-        this.ProjectMock.verify()
-      })
-
-      it('should make just one folder', function() {
-        expect(this.result.newFolders).to.have.length(1)
-      })
-
-      it('should return the new folder', function() {
-        expect(this.result.folder.name).to.equal('new-folder')
-      })
-
-      it('should return the parent folder', function() {
-        expect(this.result.folder.parentFolder_id).to.equal(this.rootFolder._id)
-      })
-
-      it('should pass the exactCaseMatch option to ProjectLocator', function() {
-        expect(
-          this.ProjectLocator.promises.findElementByPath
-        ).to.have.been.calledWithMatch({ exactCaseMatch: this.exactCaseMatch })
-      })
-    })
-
-    describe('adding a subfolder', function() {
-      beforeEach(async function() {
-        this.newFolder = { _id: ObjectId(), name: 'new-folder' }
-        this.FolderModel.returns(this.newFolder)
-        this.ProjectMock.expects('findOneAndUpdate')
-          .withArgs(
-            { _id: this.project._id },
-            {
-              $push: {
-                'rootFolder.0.folders.0.folders': sinon.match({
-                  name: 'new-folder'
-                })
-              },
-              $inc: { version: 1 }
-            }
-          )
-          .chain('exec')
-          .resolves(this.project)
-        this.result = await this.subject.promises.mkdirp(
-          this.project._id,
-          '/test-folder/new-folder'
-        )
-      })
-
-      it('should update the database', function() {
-        this.ProjectMock.verify()
-      })
-
-      it('should create one folder', function() {
-        expect(this.result.newFolders).to.have.length(1)
-      })
-
-      it('should return the new folder', function() {
-        expect(this.result.folder.name).to.equal('new-folder')
-      })
-
-      it('should return the parent folder', function() {
-        expect(this.result.folder.parentFolder_id).to.equal(this.folder._id)
-      })
-    })
-
-    describe('when mutliple folders are missing', async function() {
-      beforeEach(function() {
-        this.folder1 = { _id: ObjectId(), name: 'folder1' }
-        this.folder1Path = {
-          fileSystem: '/test-folder/folder1',
-          mongo: 'rootFolder.0.folders.0.folders.0'
-        }
-        this.folder2 = { _id: ObjectId(), name: 'folder2' }
-        this.folder2Path = {
-          fileSystem: '/test-folder/folder1/folder2',
-          mongo: 'rootFolder.0.folders.0.folders.0.folders.0'
-        }
-        this.FolderModel.onFirstCall().returns(this.folder1)
-        this.FolderModel.onSecondCall().returns(this.folder2)
-        this.ProjectLocator.promises.findElement
-          .withArgs({
-            project: this.project,
-            element_id: this.folder1._id,
-            type: 'folder'
-          })
-          .resolves({
-            element: this.folder1,
-            path: this.folder1Path
-          })
-        this.ProjectLocator.promises.findElement
-          .withArgs({
-            project: this.project,
-            element_id: this.folder2._id,
-            type: 'folder'
-          })
-          .resolves({
-            element: this.folder2,
-            path: this.folder2Path
-          })
-        this.ProjectMock.expects('findOneAndUpdate')
-          .withArgs(
-            { _id: this.project._id },
-            {
-              $push: {
-                'rootFolder.0.folders.0.folders': sinon.match({
-                  name: 'folder1'
-                })
-              },
-              $inc: { version: 1 }
-            }
-          )
-          .chain('exec')
-          .resolves(this.project)
-        this.ProjectMock.expects('findOneAndUpdate')
-          .withArgs(
-            { _id: this.project._id },
-            {
-              $push: {
-                'rootFolder.0.folders.0.folders.0.folders': sinon.match({
-                  name: 'folder2'
-                })
-              },
-              $inc: { version: 1 }
-            }
-          )
-          .chain('exec')
-          .resolves(this.project)
-      })
-      ;[
-        {
-          description: 'without a trailing slash',
-          path: '/test-folder/folder1/folder2'
-        },
-        {
-          description: 'with a trailing slash',
-          path: '/test-folder/folder1/folder2/'
-        }
-      ].forEach(({ description, path }) => {
-        describe(description, function() {
-          beforeEach(async function() {
-            this.result = await this.subject.promises.mkdirp(
-              this.project._id,
-              path
-            )
-          })
-
-          it('should update the database', function() {
-            this.ProjectMock.verify()
-          })
-
-          it('should add multiple folders', function() {
-            const newFolders = this.result.newFolders
-            expect(newFolders).to.have.length(2)
-            expect(newFolders[0].name).to.equal('folder1')
-            expect(newFolders[1].name).to.equal('folder2')
-          })
-
-          it('should return the last folder', function() {
-            expect(this.result.folder.name).to.equal('folder2')
-          })
-
-          it('should return the parent folder', function() {
-            expect(this.result.folder.parentFolder_id).to.equal(
-              this.folder1._id
-            )
-          })
-        })
-      })
-    })
-  })
-
-  describe('moveEntity', function() {
-    describe('moving a doc into a different folder', function() {
-      beforeEach(async function() {
-        this.pathAfterMove = {
-          fileSystem: '/somewhere/else.txt'
-        }
-        this.oldDocs = ['old-doc']
-        this.oldFiles = ['old-file']
-        this.newDocs = ['new-doc']
-        this.newFiles = ['new-file']
-
-        this.ProjectEntityHandler.promises.getAllEntitiesFromProject
-          .onFirstCall()
-          .resolves({ docs: this.oldDocs, files: this.oldFiles })
-        this.ProjectEntityHandler.promises.getAllEntitiesFromProject
-          .onSecondCall()
-          .resolves({ docs: this.newDocs, files: this.newFiles })
-
-        this.ProjectMock.expects('findOneAndUpdate')
-          .withArgs(
-            { _id: this.project._id },
-            {
-              $push: { 'rootFolder.0.folders.0.docs': this.doc },
-              $inc: { version: 1 }
-            }
-          )
-          .chain('exec')
-          .resolves(this.project)
-        this.ProjectMock.expects('findOneAndUpdate')
-          .withArgs(
-            { _id: this.project._id },
-            {
-              $pull: { 'rootFolder.0.docs': { _id: this.doc._id } },
-              $inc: { version: 1 }
-            }
-          )
-          .chain('exec')
-          .resolves(this.project)
-        this.result = await this.subject.promises.moveEntity(
-          this.project._id,
-          this.doc._id,
-          this.folder._id,
-          'doc'
-        )
-      })
-
-      it('should update the database', function() {
-        this.ProjectMock.verify()
-      })
-
-      it('should report what changed', function() {
-        expect(this.result).to.deep.equal({
-          project: this.project,
-          startPath: '/test-doc.txt',
-          endPath: '/test-folder/test-doc.txt',
-          rev: this.doc.rev,
-          changes: {
-            oldDocs: this.oldDocs,
-            newDocs: this.newDocs,
-            oldFiles: this.oldFiles,
-            newFiles: this.newFiles,
-            newProject: this.project
-          }
-        })
-      })
-    })
-
-    describe('when moving a folder inside itself', function() {
-      it('throws an error', async function() {
-        await expect(
-          this.subject.promises.moveEntity(
-            this.project._id,
-            this.folder._id,
-            this.folder._id,
-            'folder'
-          )
-        ).to.be.rejectedWith(Errors.InvalidNameError)
-      })
-    })
-
-    describe('when moving a folder to a subfolder of itself', function() {
-      it('throws an error', async function() {
-        await expect(
-          this.subject.promises.moveEntity(
-            this.project._id,
-            this.folder._id,
-            this.subfolder._id,
-            'folder'
-          )
-        ).to.be.rejectedWith(Errors.InvalidNameError)
-      })
-    })
-  })
-
-  describe('deleteEntity', function() {
-    beforeEach(async function() {
-      this.ProjectMock.expects('findOneAndUpdate')
-        .withArgs(
-          { _id: this.project._id },
-          {
-            $pull: { 'rootFolder.0.docs': { _id: this.doc._id } },
-            $inc: { version: 1 }
-          }
-        )
-        .chain('exec')
-        .resolves(this.project)
-      await this.subject.promises.deleteEntity(
-        this.project._id,
-        this.doc._id,
-        'doc'
-      )
-    })
-
-    it('should update the database', function() {
-      this.ProjectMock.verify()
-    })
-  })
-
-  describe('renameEntity', function() {
-    describe('happy path', function() {
-      beforeEach(async function() {
-        this.newName = 'new.tex'
-        this.oldDocs = ['old-doc']
-        this.oldFiles = ['old-file']
-        this.newDocs = ['new-doc']
-        this.newFiles = ['new-file']
-
-        this.ProjectEntityHandler.promises.getAllEntitiesFromProject
-          .onFirstCall()
-          .resolves({ docs: this.oldDocs, files: this.oldFiles })
-        this.ProjectEntityHandler.promises.getAllEntitiesFromProject
-          .onSecondCall()
-          .resolves({ docs: this.newDocs, files: this.newFiles })
-
-        this.ProjectMock.expects('findOneAndUpdate')
-          .withArgs(
-            { _id: this.project._id },
-            {
-              $set: { 'rootFolder.0.docs.0.name': this.newName },
-              $inc: { version: 1 }
-            }
-          )
-          .chain('exec')
-          .resolves(this.project)
-        this.result = await this.subject.promises.renameEntity(
-          this.project._id,
-          this.doc._id,
-          'doc',
-          this.newName
-        )
-      })
-
-      it('should update the database', function() {
-        this.ProjectMock.verify()
-      })
-
-      it('returns info', function() {
-        expect(this.result).to.deep.equal({
-          project: this.project,
-          startPath: '/test-doc.txt',
-          endPath: '/new.tex',
-          rev: this.doc.rev,
-          changes: {
-            oldDocs: this.oldDocs,
-            newDocs: this.newDocs,
-            oldFiles: this.oldFiles,
-            newFiles: this.newFiles,
-            newProject: this.project
-          }
-        })
-      })
-    })
-
-    describe('name already exists', function() {
-      it('should throw an error', async function() {
-        await expect(
-          this.subject.promises.renameEntity(
-            this.project._id,
-            this.doc._id,
-            'doc',
-            this.folder.name
-          )
-        ).to.be.rejectedWith(Errors.InvalidNameError)
-      })
-    })
-  })
-
-  describe('_putElement', function() {
-    describe('updating the project', function() {
-      describe('when the parent folder is given', function() {
-        beforeEach(function() {
-          this.newFile = { _id: ObjectId(), name: 'new file.png' }
-          this.ProjectMock.expects('findOneAndUpdate')
-            .withArgs(
-              { _id: this.project._id },
-              {
-                $push: { 'rootFolder.0.folders.0.fileRefs': this.newFile },
-                $inc: { version: 1 }
-              }
-            )
-            .chain('exec')
-            .resolves(this.project)
-        })
-
-        it('should update the database', async function() {
-          await this.subject.promises._putElement(
-            this.project,
-            this.folder._id,
-            this.newFile,
-            'files'
-          )
-          this.ProjectMock.verify()
-        })
-
-        it('should add an s onto the type if not included', async function() {
-          await this.subject.promises._putElement(
-            this.project,
-            this.folder._id,
-            this.newFile,
-            'file'
-          )
-          this.ProjectMock.verify()
-        })
-      })
-
-      describe('error cases', function() {
-        it('should throw an error if element is null', async function() {
-          await expect(
-            this.subject.promises._putElement(
-              this.project,
-              this.folder._id,
-              null,
-              'file'
-            )
-          ).to.be.rejected
-        })
-
-        it('should error if the element has no _id', async function() {
-          const file = { name: 'something' }
-          await expect(
-            this.subject.promises._putElement(
-              this.project,
-              this.folder._id,
-              file,
-              'file'
-            )
-          ).to.be.rejected
-        })
-
-        it('should error if element name contains invalid characters', async function() {
-          const file = { _id: ObjectId(), name: 'something*bad' }
-          await expect(
-            this.subject.promises._putElement(
-              this.project,
-              this.folder._id,
-              file,
-              'file'
-            )
-          ).to.be.rejected
-        })
-
-        it('should error if element name is too long', async function() {
-          const file = {
-            _id: ObjectId(),
-            name: 'long-'.repeat(1000) + 'something'
-          }
-          await expect(
-            this.subject.promises._putElement(
-              this.project,
-              this.folder._id,
-              file,
-              'file'
-            )
-          ).to.be.rejectedWith(Errors.InvalidNameError)
-        })
-
-        it('should error if the folder name is too long', async function() {
-          const file = {
-            _id: ObjectId(),
-            name: 'something'
-          }
-          this.ProjectLocator.promises.findElement
-            .withArgs({
-              project: this.project,
-              element_id: this.folder._id,
-              type: 'folder'
-            })
-            .resolves({
-              element: this.folder,
-              path: { fileSystem: 'subdir/'.repeat(1000) + 'foo' }
-            })
-          await expect(
-            this.subject.promises._putElement(
-              this.project,
-              this.folder._id,
-              file,
-              'file'
-            )
-          ).to.be.rejectedWith(Errors.InvalidNameError)
-        })
-        ;['file', 'doc', 'folder'].forEach(entityType => {
-          it(`should error if a ${entityType} already exists with the same name`, async function() {
-            const file = {
-              _id: ObjectId(),
-              name: this[entityType].name
-            }
-            await expect(
-              this.subject.promises._putElement(
-                this.project,
-                null,
-                file,
-                'file'
-              )
-            ).to.be.rejectedWith(Errors.InvalidNameError)
-          })
-        })
-      })
-    })
-
-    describe('when the parent folder is not given', function() {
-      it('should default to root folder insert', async function() {
-        this.newFile = { _id: ObjectId(), name: 'new file.png' }
-        this.ProjectMock.expects('findOneAndUpdate')
-          .withArgs(
-            { _id: this.project._id },
-            {
-              $push: { 'rootFolder.0.fileRefs': this.newFile },
-              $inc: { version: 1 }
-            }
-          )
-          .chain('exec')
-          .resolves(this.project)
-        await this.subject.promises._putElement(
-          this.project,
-          this.rootFolder._id,
-          this.newFile,
-          'file'
-        )
-      })
-    })
-  })
-
-  describe('_insertDeletedDocReference', function() {
-    beforeEach(async function() {
-      this.ProjectMock.expects('updateOne')
-        .withArgs(
-          { _id: this.project._id },
-          {
-            $push: {
-              deletedDocs: {
-                _id: this.doc._id,
-                name: this.doc.name,
-                deletedAt: sinon.match.date
-              }
-            }
-          }
-        )
-        .chain('exec')
-        .resolves()
-      await this.subject.promises._insertDeletedDocReference(
-        this.project._id,
-        this.doc
-      )
-    })
-
-    it('should update the database', function() {
-      this.ProjectMock.verify()
-    })
-  })
-
-  describe('_insertDeletedFileReference', function() {
-    beforeEach(async function() {
-      this.ProjectMock.expects('updateOne')
-        .withArgs(
-          { _id: this.project._id },
-          {
-            $push: {
-              deletedFiles: {
-                _id: this.file._id,
-                name: this.file.name,
-                linkedFileData: this.file.linkedFileData,
-                hash: this.file.hash,
-                deletedAt: sinon.match.date
-              }
-            }
-          }
-        )
-        .chain('exec')
-        .resolves()
-      await this.subject.promises._insertDeletedFileReference(
-        this.project._id,
-        this.file
-      )
-    })
-
-    it('should update the database', function() {
-      this.ProjectMock.verify()
-    })
-  })
-
-  describe('createNewFolderStructure', function() {
-    beforeEach(function() {
-      this.mockRootFolder = 'MOCK_ROOT_FOLDER'
-      this.docUploads = ['MOCK_DOC_UPLOAD']
-      this.fileUploads = ['MOCK_FILE_UPLOAD']
-      this.FolderStructureBuilder.buildFolderStructure
-        .withArgs(this.docUploads, this.fileUploads)
-        .returns(this.mockRootFolder)
-      this.updateExpectation = this.ProjectMock.expects('updateOne')
-        .withArgs(
-          {
-            _id: this.project._id,
-            'rootFolder.0.folders.0': { $exists: false },
-            'rootFolder.0.docs.0': { $exists: false },
-            'rootFolder.0.files.0': { $exists: false }
-          },
-          { $set: { rootFolder: [this.mockRootFolder] }, $inc: { version: 1 } }
-        )
-        .chain('exec')
-    })
-
-    describe('happy path', function() {
-      beforeEach(async function() {
-        this.updateExpectation.resolves({ n: 1 })
-        await this.subject.promises.createNewFolderStructure(
-          this.project._id,
-          this.docUploads,
-          this.fileUploads
-        )
-      })
-
-      it('updates the database', function() {
-        this.ProjectMock.verify()
-      })
-    })
-
-    describe("when the update doesn't find a matching document", function() {
-      beforeEach(async function() {
-        this.updateExpectation.resolves({ n: 0 })
-      })
-
-      it('throws an error', async function() {
-        await expect(
-          this.subject.promises.createNewFolderStructure(
-            this.project._id,
-            this.docUploads,
-            this.fileUploads
-          )
-        ).to.be.rejected
-      })
-    })
-  })
-})

services/web/test/unit/src/Project/ProjectEntityMongoUpdateHandlerTests.js

@@ -1,1202 +1,1092 @@
-const chai = require('chai')
-const { expect } = chai
-const { assert } = require('chai')
+const { expect } = require('chai')
 const sinon = require('sinon')
 const tk = require('timekeeper')
 const Errors = require('../../../../app/src/Features/Errors/Errors')
 const { ObjectId } = require('mongoose').Types
 const SandboxedModule = require('sandboxed-module')
+const { Project } = require('../helpers/models/Project')
 
 const MODULE_PATH =
   '../../../../app/src/Features/Project/ProjectEntityMongoUpdateHandler'
 
 describe('ProjectEntityMongoUpdateHandler', function() {
-  const projectId = '4eecb1c1bffa66588e0000a1'
-  const docId = '4eecb1c1bffa66588e0000a2'
-  const fileId = '4eecb1c1bffa66588e0000a3'
-  const folderId = '4eecaffcbffa66588e000008'
-
   beforeEach(function() {
-    this.FolderModel = class Folder {
-      constructor(options) {
-        ;({ name: this.name } = options)
-        this._id = 'folder_id'
+    this.doc = {
+      _id: ObjectId(),
+      name: 'test-doc.txt',
+      lines: ['hello', 'world'],
+      rev: 1234
+    }
+    this.docPath = {
+      mongo: 'rootFolder.0.docs.0',
+      fileSystem: '/test-doc.txt'
+    }
+    this.file = {
+      _id: ObjectId(),
+      name: 'something.jpg',
+      linkedFileData: { provider: 'url' },
+      hash: 'some-hash'
+    }
+    this.filePath = {
+      fileSystem: '/something.png',
+      mongo: 'rootFolder.0.fileRefs.0'
+    }
+    this.subfolder = { _id: ObjectId(), name: 'test-subfolder' }
+    this.subfolderPath = {
+      fileSystem: '/test-folder/test-subfolder',
+      mongo: 'rootFolder.0.folders.0.folders.0'
+    }
+    this.folder = {
+      _id: ObjectId(),
+      name: 'test-folder',
+      folders: [this.subfolder]
+    }
+    this.folderPath = {
+      fileSystem: '/test-folder',
+      mongo: 'rootFolder.0.folders.0'
+    }
+    this.rootFolder = {
+      _id: ObjectId(),
+      folders: [this.folder],
+      docs: [this.doc],
+      fileRefs: [this.file]
+    }
+    this.rootFolderPath = {
+      fileSystem: '/',
+      mongo: 'rootFolder.0'
+    }
+    this.project = {
+      _id: ObjectId(),
+      name: 'project name',
+      rootFolder: [this.rootFolder]
+    }
+
+    this.logger = {
+      log: sinon.stub(),
+      warn: sinon.stub(),
+      error: sinon.stub(),
+      err() {}
+    }
+    this.Settings = { maxEntitiesPerProject: 100 }
+    this.CooldownManager = {}
+    this.LockManager = {
+      promises: {
+        runWithLock: sinon.spy((namespace, id, runner) => runner())
       }
     }
 
-    this.docName = 'doc-name'
-    this.fileName = 'something.jpg'
-    this.project = { _id: projectId, name: 'project name' }
+    this.FolderModel = sinon.stub()
+    this.ProjectMock = sinon.mock(Project)
+    this.ProjectEntityHandler = {
+      promises: {
+        getAllEntitiesFromProject: sinon.stub()
+      }
+    }
+    this.ProjectLocator = {
+      promises: {
+        findElement: sinon.stub().rejects(new Error('not found')),
+        findElementByPath: sinon.stub().rejects(new Error('not found'))
+      }
+    }
+    this.ProjectLocator.promises.findElement
+      .withArgs({
+        project: this.project,
+        element_id: this.rootFolder._id,
+        type: 'folder'
+      })
+      .resolves({
+        element: this.rootFolder,
+        path: this.rootFolderPath
+      })
+    this.ProjectLocator.promises.findElement
+      .withArgs({
+        project: this.project,
+        element_id: this.folder._id,
+        type: 'folder'
+      })
+      .resolves({
+        element: this.folder,
+        path: this.folderPath,
+        folder: this.rootFolder
+      })
+    this.ProjectLocator.promises.findElement
+      .withArgs({
+        project: this.project,
+        element_id: this.subfolder._id,
+        type: 'folder'
+      })
+      .resolves({
+        element: this.subfolder,
+        path: this.subfolderPath,
+        folder: this.folder
+      })
+    this.ProjectLocator.promises.findElement
+      .withArgs({
+        project: this.project,
+        element_id: this.file._id,
+        type: 'file'
+      })
+      .resolves({
+        element: this.file,
+        path: this.filePath,
+        folder: this.rootFolder
+      })
+    this.ProjectLocator.promises.findElement
+      .withArgs({
+        project: this.project,
+        element_id: this.doc._id,
+        type: 'doc'
+      })
+      .resolves({
+        element: this.doc,
+        path: this.docPath,
+        folder: this.rootFolder
+      })
+    this.ProjectLocator.promises.findElementByPath
+      .withArgs(
+        sinon.match({
+          project: this.project,
+          path: '/'
+        })
+      )
+      .resolves({ element: this.rootFolder, type: 'folder' })
+    this.ProjectLocator.promises.findElementByPath
+      .withArgs(
+        sinon.match({
+          project: this.project,
+          path: '/test-folder'
+        })
+      )
+      .resolves({ element: this.folder, type: 'folder' })
+    this.ProjectLocator.promises.findElementByPath
+      .withArgs(
+        sinon.match({
+          project: this.project,
+          path: '/test-folder/test-subfolder'
+        })
+      )
+      .resolves({ element: this.subfolder, type: 'folder' })
+
+    this.ProjectGetter = {
+      promises: {
+        getProjectWithoutLock: sinon
+          .stub()
+          .withArgs(this.project._id)
+          .resolves(this.project),
+        getProjectWithOnlyFolders: sinon.stub().resolves(this.project)
+      }
+    }
 
-    this.callback = sinon.stub()
+    this.FolderStructureBuilder = {
+      buildFolderStructure: sinon.stub()
+    }
 
-    tk.freeze(Date.now())
     this.subject = SandboxedModule.require(MODULE_PATH, {
       globals: {
         console: console
       },
       requires: {
-        'logger-sharelatex': (this.logger = {
-          log: sinon.stub(),
-          warn: sinon.stub(),
-          error: sinon.stub(),
-          err() {}
-        }),
-        'settings-sharelatex': (this.settings = {
-          maxEntitiesPerProject: 100
-        }),
-        '../Cooldown/CooldownManager': (this.CooldownManager = {}),
-        '../../models/Folder': {
-          Folder: this.FolderModel
-        },
-        '../../infrastructure/LockManager': (this.LockManager = {
-          runWithLock: sinon.spy((namespace, id, runner, callback) =>
-            runner(callback)
-          )
-        }),
-        '../../models/Project': {
-          Project: (this.ProjectModel = {})
-        },
-        './ProjectEntityHandler': (this.ProjectEntityHandler = {}),
-        './ProjectLocator': (this.ProjectLocator = {}),
-        './ProjectGetter': (this.ProjectGetter = {
-          getProjectWithoutLock: sinon.stub().yields(null, this.project)
-        }),
+        'logger-sharelatex': this.logger,
+        'settings-sharelatex': this.Settings,
+        '../Cooldown/CooldownManager': this.CooldownManager,
+        '../../models/Folder': { Folder: this.FolderModel },
+        '../../infrastructure/LockManager': this.LockManager,
+        '../../models/Project': { Project },
+        './ProjectEntityHandler': this.ProjectEntityHandler,
+        './ProjectLocator': this.ProjectLocator,
+        './ProjectGetter': this.ProjectGetter,
+        './FolderStructureBuilder': this.FolderStructureBuilder,
+        // We need to provide Errors here to make instance check work
         '../Errors/Errors': Errors
       }
     })
   })
 
   afterEach(function() {
-    tk.reset()
+    this.ProjectMock.restore()
   })
 
-  describe('addDoc', function() {
-    beforeEach(function() {
-      this.subject._confirmFolder = sinon.stub().yields(folderId)
-      this.subject._putElement = sinon.stub()
+  beforeEach(function() {
+    tk.freeze(Date.now())
+  })
 
-      this.doc = { _id: docId }
-      this.subject.addDoc(projectId, folderId, this.doc, this.callback)
-    })
+  afterEach(function() {
+    tk.reset()
+  })
 
-    it('gets the project', function() {
-      this.ProjectGetter.getProjectWithoutLock
-        .calledWith(projectId, {
-          rootFolder: true,
-          name: true,
-          overleaf: true
-        })
-        .should.equal(true)
+  describe('addDoc', function() {
+    beforeEach(async function() {
+      const doc = { _id: ObjectId(), name: 'other.txt' }
+      this.ProjectMock.expects('findOneAndUpdate')
+        .withArgs(
+          { _id: this.project._id },
+          {
+            $push: { 'rootFolder.0.folders.0.docs': doc },
+            $inc: { version: 1 }
+          }
+        )
+        .chain('exec')
+        .resolves(this.project)
+      this.result = await this.subject.promises.addDoc(
+        this.project._id,
+        this.folder._id,
+        doc
+      )
     })
 
-    it('checks the folder exists', function() {
-      this.subject._confirmFolder
-        .calledWith(this.project, folderId)
-        .should.equal(true)
+    it('adds the document in Mongo', function() {
+      this.ProjectMock.verify()
     })
 
-    it('puts the element in mongo', function() {
-      this.subject._putElement
-        .calledWith(this.project, folderId, this.doc, 'doc', this.callback)
-        .should.equal(true)
+    it('returns path info and the project', function() {
+      expect(this.result).to.deep.equal({
+        result: {
+          path: {
+            mongo: 'rootFolder.0.folders.0',
+            fileSystem: '/test-folder/other.txt'
+          }
+        },
+        project: this.project
+      })
     })
   })
 
   describe('addFile', function() {
     beforeEach(function() {
-      this.subject._confirmFolder = sinon.stub().yields(folderId)
-      this.subject._putElement = sinon.stub()
-
-      this.file = { _id: fileId }
-      this.subject.addFile(projectId, folderId, this.file, this.callback)
+      this.newFile = { _id: ObjectId(), name: 'picture.jpg' }
+      this.ProjectMock.expects('findOneAndUpdate')
+        .withArgs(
+          { _id: this.project._id },
+          {
+            $push: { 'rootFolder.0.folders.0.fileRefs': this.newFile },
+            $inc: { version: 1 }
+          }
+        )
+        .chain('exec')
+        .resolves(this.project)
     })
 
-    it('gets the project', function() {
-      this.ProjectGetter.getProjectWithoutLock
-        .calledWith(projectId, {
-          rootFolder: true,
-          name: true,
-          overleaf: true
+    describe('happy path', function() {
+      beforeEach(async function() {
+        this.result = await this.subject.promises.addFile(
+          this.project._id,
+          this.folder._id,
+          this.newFile
+        )
+      })
+
+      it('adds the file in Mongo', function() {
+        this.ProjectMock.verify()
+      })
+
+      it('returns path info and the project', function() {
+        expect(this.result).to.deep.equal({
+          result: {
+            path: {
+              mongo: 'rootFolder.0.folders.0',
+              fileSystem: '/test-folder/picture.jpg'
+            }
+          },
+          project: this.project
         })
-        .should.equal(true)
+      })
     })
 
-    it('checks the folder exists', function() {
-      this.subject._confirmFolder
-        .calledWith(this.project, folderId)
-        .should.equal(true)
-    })
+    describe('when entity limit is reached', function() {
+      beforeEach(function() {
+        this.savedMaxEntities = this.Settings.maxEntitiesPerProject
+        this.Settings.maxEntitiesPerProject = 3
+      })
+
+      afterEach(function() {
+        this.Settings.maxEntitiesPerProject = this.savedMaxEntities
+      })
 
-    it('puts the element in mongo', function() {
-      this.subject._putElement
-        .calledWith(this.project, folderId, this.file, 'file', this.callback)
-        .should.equal(true)
+      it('should throw an error', async function() {
+        await expect(
+          this.subject.promises.addFile(
+            this.project._id,
+            this.folder._id,
+            this.newFile
+          )
+        ).to.be.rejected
+      })
     })
   })
 
-  describe('replaceFileWithNew', function() {
-    beforeEach(function() {
-      this.file = { _id: fileId }
-      this.path = { mongo: 'file.png' }
-      this.newFile = { _id: 'new-file-id' }
-      this.newFile.linkedFileData = this.linkedFileData = { provider: 'url' }
-      this.newProject = 'new-project'
-      this.ProjectLocator.findElement = sinon
-        .stub()
-        .yields(null, this.file, this.path)
-      this.ProjectModel.findOneAndUpdate = sinon
-        .stub()
-        .yields(null, this.newProject)
-      this.ProjectModel.update = sinon.stub().yields()
-
-      this.subject.replaceFileWithNew(
-        projectId,
-        fileId,
-        this.newFile,
-        this.callback
+  describe('addFolder', function() {
+    beforeEach(async function() {
+      const folderName = 'New folder'
+      this.FolderModel.withArgs({ name: folderName }).returns({
+        _id: ObjectId(),
+        name: folderName
+      })
+      this.ProjectMock.expects('findOneAndUpdate')
+        .withArgs(
+          { _id: this.project._id },
+          {
+            $push: {
+              'rootFolder.0.folders.0.folders': sinon.match({
+                name: folderName
+              })
+            },
+            $inc: { version: 1 }
+          }
+        )
+        .chain('exec')
+        .resolves(this.project)
+      await this.subject.promises.addFolder(
+        this.project._id,
+        this.folder._id,
+        folderName
       )
     })
 
-    it('gets the project', function() {
-      this.ProjectGetter.getProjectWithoutLock
-        .calledWith(projectId, {
-          rootFolder: true,
-          name: true,
-          overleaf: true
-        })
-        .should.equal(true)
-    })
-
-    it('finds the existing element', function() {
-      this.ProjectLocator.findElement
-        .calledWith({
-          project: this.project,
-          element_id: fileId,
-          type: 'file'
-        })
-        .should.equal(true)
+    it('adds the folder in Mongo', function() {
+      this.ProjectMock.verify()
     })
+  })
 
-    it('inserts a deletedFile reference for the old file', function() {
-      this.ProjectModel.update
-        .calledWith(
-          { _id: projectId },
+  describe('replaceFileWithNew', function() {
+    beforeEach(async function() {
+      const newFile = {
+        _id: ObjectId(),
+        name: 'some-other-file.png',
+        linkedFileData: { some: 'data' },
+        hash: 'some-hash'
+      }
+      // Add a deleted file record
+      this.ProjectMock.expects('updateOne')
+        .withArgs(
+          { _id: this.project._id },
           {
             $push: {
               deletedFiles: {
-                _id: fileId,
+                _id: this.file._id,
                 name: this.file.name,
                 linkedFileData: this.file.linkedFileData,
                 hash: this.file.hash,
-                deletedAt: new Date()
+                deletedAt: sinon.match.date
               }
             }
           }
         )
-        .should.equal(true)
-    })
-
-    it('increments the project version and sets the rev and created_at', function() {
-      this.ProjectModel.findOneAndUpdate
-        .calledWith(
-          { _id: projectId },
+        .chain('exec')
+        .resolves()
+      // Update the file in place
+      this.ProjectMock.expects('findOneAndUpdate')
+        .withArgs(
+          { _id: this.project._id },
           {
-            $inc: { version: 1, 'file.png.rev': 1 },
             $set: {
-              'file.png._id': this.newFile._id,
-              'file.png.created': new Date(),
-              'file.png.linkedFileData': this.linkedFileData,
-              'file.png.hash': this.hash
+              'rootFolder.0.fileRefs.0._id': newFile._id,
+              'rootFolder.0.fileRefs.0.created': sinon.match.date,
+              'rootFolder.0.fileRefs.0.linkedFileData': newFile.linkedFileData,
+              'rootFolder.0.fileRefs.0.hash': newFile.hash
+            },
+            $inc: {
+              version: 1,
+              'rootFolder.0.fileRefs.0.rev': 1
             }
-          },
-          { new: true }
+          }
         )
-        .should.equal(true)
+        .chain('exec')
+        .resolves(this.project)
+      await this.subject.promises.replaceFileWithNew(
+        this.project._id,
+        this.file._id,
+        newFile
+      )
     })
 
-    it('calls the callback', function() {
-      this.callback
-        .calledWith(null, this.file, this.project, this.path, this.newProject)
-        .should.equal(true)
+    it('updates the database', function() {
+      this.ProjectMock.verify()
     })
   })
 
   describe('mkdirp', function() {
-    beforeEach(function() {
-      this.parentFolderId = '1jnjknjk'
-      this.newFolder = { _id: 'newFolder_id_here' }
-      this.lastFolder = { _id: '123das', folders: [] }
-
-      this.rootFolder = { _id: 'rootFolderId' }
-      this.project = { _id: projectId, rootFolder: [this.rootFolder] }
-
-      this.ProjectGetter.getProjectWithOnlyFolders = sinon
-        .stub()
-        .yields(null, this.project)
-      this.ProjectLocator.findElementByPath = function() {}
-      sinon
-        .stub(this.ProjectLocator, 'findElementByPath')
-        .callsFake((options, cb) => {
-          const { path } = options
-          this.parentFolder = { _id: 'parentFolder_id_here' }
-          const lastFolder = path.substring(path.lastIndexOf('/'))
-          if (lastFolder.indexOf('level1') === -1) {
-            cb(new Error('level1 is not the last folder'))
-          } else {
-            cb(null, this.parentFolder)
-          }
-        })
-      this.subject.addFolder = {
-        withoutLock: (projectId, parentFolderId, folderName, callback) => {
-          return callback(null, { name: folderName }, this.parentFolderId)
-        }
-      }
-    })
-
-    it('should return the root folder if the path is just a slash', function(done) {
-      const path = '/'
-      this.subject.mkdirp(projectId, path, {}, (err, folders, lastFolder) => {
-        if (err != null) {
-          return done(err)
-        }
-        lastFolder.should.deep.equal(this.rootFolder)
-        assert.equal(lastFolder.parentFolder_id, undefined)
-        done()
+    describe('when the path is just a slash', function() {
+      beforeEach(async function() {
+        this.result = await this.subject.promises.mkdirp(this.project._id, '/')
       })
-    })
 
-    it('should make just one folder', function(done) {
-      const path = '/differentFolder/'
-      this.subject.mkdirp(projectId, path, {}, (err, folders, lastFolder) => {
-        if (err != null) {
-          return done(err)
-        }
-        folders.length.should.equal(1)
-        lastFolder.name.should.equal('differentFolder')
-        lastFolder.parentFolder_id.should.equal(this.parentFolderId)
-        done()
+      it('should return the root folder', function() {
+        expect(this.result.folder).to.deep.equal(this.rootFolder)
       })
-    })
 
-    it('should make the final folder in path if it doesnt exist with one level', function(done) {
-      const path = 'level1/level2'
-      this.subject.mkdirp(projectId, path, {}, (err, folders, lastFolder) => {
-        if (err != null) {
-          return done(err)
-        }
-        folders.length.should.equal(1)
-        lastFolder.name.should.equal('level2')
-        lastFolder.parentFolder_id.should.equal(this.parentFolderId)
-        done()
+      it('should not report a parent folder', function() {
+        expect(this.result.folder.parentFolder_id).not.to.exist
       })
-    })
-
-    it('should make the final folder in path if it doesnt exist with mutliple levels', function(done) {
-      const path = 'level1/level2/level3'
 
-      this.subject.mkdirp(projectId, path, {}, (err, folders, lastFolder) => {
-        if (err != null) {
-          return done(err)
-        }
-        folders.length.should.equal(2)
-        folders[0].name.should.equal('level2')
-        folders[0].parentFolder_id.should.equal(this.parentFolderId)
-        lastFolder.name.should.equal('level3')
-        lastFolder.parentFolder_id.should.equal(this.parentFolderId)
-        done()
+      it('should not return new folders', function() {
+        expect(this.result.newFolders).to.have.length(0)
       })
     })
 
-    it('should work with slashes either side', function(done) {
-      const path = '/level1/level2/level3/'
-
-      this.subject.mkdirp(projectId, path, {}, (err, folders, lastFolder) => {
-        if (err != null) {
-          return done(err)
-        }
-        folders.length.should.equal(2)
-        folders[0].name.should.equal('level2')
-        folders[0].parentFolder_id.should.equal(this.parentFolderId)
-        lastFolder.name.should.equal('level3')
-        lastFolder.parentFolder_id.should.equal(this.parentFolderId)
-        done()
+    describe('when the folder already exists', function() {
+      beforeEach(async function() {
+        this.result = await this.subject.promises.mkdirp(
+          this.project._id,
+          '/test-folder'
+        )
       })
-    })
 
-    it('should use a case-insensitive match by default', function(done) {
-      const path = '/differentFolder/'
-      this.subject.mkdirp(projectId, path, {}, (err, folders, lastFolder) => {
-        if (err != null) {
-          return done(err)
-        }
-        this.ProjectLocator.findElementByPath
-          .calledWithMatch({ exactCaseMatch: undefined })
-          .should.equal(true)
-        done()
+      it('should return the existing folder', function() {
+        expect(this.result.folder).to.deep.equal(this.folder)
       })
-    })
 
-    it('should use a case-sensitive match if exactCaseMatch option is set', function(done) {
-      const path = '/differentFolder/'
-      this.subject.mkdirp(
-        projectId,
-        path,
-        { exactCaseMatch: true },
-        (err, folders, lastFolder) => {
-          if (err != null) {
-            return done(err)
-          }
-          this.ProjectLocator.findElementByPath
-            .calledWithMatch({ exactCaseMatch: true })
-            .should.equal(true)
-          done()
-        }
-      )
-    })
-  })
-
-  describe('moveEntity', function() {
-    beforeEach(function() {
-      this.pathAfterMove = {
-        fileSystem: '/somewhere/else.txt'
-      }
-
-      this.ProjectEntityHandler.getAllEntitiesFromProject = sinon.stub()
-      this.ProjectEntityHandler.getAllEntitiesFromProject
-        .onFirstCall()
-        .yields(
-          null,
-          (this.oldDocs = ['old-doc']),
-          (this.oldFiles = ['old-file'])
-        )
-      this.ProjectEntityHandler.getAllEntitiesFromProject
-        .onSecondCall()
-        .yields(
-          null,
-          (this.newDocs = ['new-doc']),
-          (this.newFiles = ['new-file'])
+      it('should report the parent folder', function() {
+        expect(this.result.folder.parentFolder_id).not.equal(
+          this.rootFolder._id
         )
+      })
 
-      this.doc = { lines: ['1234', '312343d'], rev: '1234' }
-      this.path = {
-        mongo: 'folders[0]',
-        fileSystem: '/old_folder/somewhere.txt'
-      }
-      this.newProject = 'new-project'
-      this.ProjectLocator.findElement = sinon
-        .stub()
-        .withArgs({
-          project: this.project,
-          element_id: this.docId,
-          type: 'docs'
-        })
-        .yields(null, this.doc, this.path)
-
-      this.subject._checkValidMove = sinon.stub().yields()
-
-      this.subject._removeElementFromMongoArray = sinon
-        .stub()
-        .yields(null, this.newProject)
-      this.subject._putElement = sinon
-        .stub()
-        .yields(null, { path: this.pathAfterMove }, this.newProject)
-
-      this.subject.moveEntity(projectId, docId, folderId, 'docs', this.callback)
-    })
-
-    it('should get the project', function() {
-      this.ProjectGetter.getProjectWithoutLock
-        .calledWith(projectId, {
-          rootFolder: true,
-          name: true,
-          overleaf: true
-        })
-        .should.equal(true)
+      it('should not return new folders', function() {
+        expect(this.result.newFolders).to.have.length(0)
+      })
     })
 
-    it('should find the doc to move', function() {
-      this.ProjectLocator.findElement
-        .calledWith({ element_id: docId, type: 'docs', project: this.project })
-        .should.equal(true)
-    })
+    describe('when the path is a new folder at the top level', function() {
+      beforeEach(async function() {
+        this.newFolder = { _id: ObjectId(), name: 'new-folder' }
+        this.FolderModel.returns(this.newFolder)
+        this.exactCaseMatch = false
+        this.ProjectMock.expects('findOneAndUpdate')
+          .withArgs(
+            { _id: this.project._id },
+            {
+              $push: { 'rootFolder.0.folders': this.newFolder },
+              $inc: { version: 1 }
+            }
+          )
+          .chain('exec')
+          .resolves(this.project)
+        this.result = await this.subject.promises.mkdirp(
+          this.project._id,
+          '/new-folder/',
+          { exactCaseMatch: this.exactCaseMatch }
+        )
+      })
+      it('should update the database', function() {
+        this.ProjectMock.verify()
+      })
 
-    it('should check this is a valid move', function() {
-      this.subject._checkValidMove
-        .calledWith(this.project, 'docs', this.doc, this.path, folderId)
-        .should.equal(true)
-    })
+      it('should make just one folder', function() {
+        expect(this.result.newFolders).to.have.length(1)
+      })
 
-    it('should put the element in the new folder', function() {
-      this.subject._putElement
-        .calledWith(this.project, folderId, this.doc, 'docs')
-        .should.equal(true)
-    })
+      it('should return the new folder', function() {
+        expect(this.result.folder.name).to.equal('new-folder')
+      })
 
-    it('should remove the element from its current position', function() {
-      this.subject._removeElementFromMongoArray
-        .calledWith(this.ProjectModel, projectId, this.path.mongo, docId)
-        .should.equal(true)
-    })
+      it('should return the parent folder', function() {
+        expect(this.result.folder.parentFolder_id).to.equal(this.rootFolder._id)
+      })
 
-    it('should remove the element from its current position after putting the element in the new folder', function() {
-      this.subject._removeElementFromMongoArray
-        .calledAfter(this.subject._putElement)
-        .should.equal(true)
+      it('should pass the exactCaseMatch option to ProjectLocator', function() {
+        expect(
+          this.ProjectLocator.promises.findElementByPath
+        ).to.have.been.calledWithMatch({ exactCaseMatch: this.exactCaseMatch })
+      })
     })
 
-    it('calls the callback', function() {
-      const changes = {
-        oldDocs: this.oldDocs,
-        newDocs: this.newDocs,
-        oldFiles: this.oldFiles,
-        newFiles: this.newFiles,
-        newProject: this.newProject
-      }
-      this.callback
-        .calledWith(
-          null,
-          this.project,
-          this.path.fileSystem,
-          this.pathAfterMove.fileSystem,
-          this.doc.rev,
-          changes
+    describe('adding a subfolder', function() {
+      beforeEach(async function() {
+        this.newFolder = { _id: ObjectId(), name: 'new-folder' }
+        this.FolderModel.returns(this.newFolder)
+        this.ProjectMock.expects('findOneAndUpdate')
+          .withArgs(
+            { _id: this.project._id },
+            {
+              $push: {
+                'rootFolder.0.folders.0.folders': sinon.match({
+                  name: 'new-folder'
+                })
+              },
+              $inc: { version: 1 }
+            }
+          )
+          .chain('exec')
+          .resolves(this.project)
+        this.result = await this.subject.promises.mkdirp(
+          this.project._id,
+          '/test-folder/new-folder'
         )
-        .should.equal(true)
-    })
-  })
-
-  describe('moveEntity must refuse to move the folder to a subfolder of itself', function() {
-    beforeEach(function() {
-      this.pathAfterMove = {
-        fileSystem: '/somewhere/else.txt'
-      }
+      })
 
-      this.doc = { lines: ['1234', '312343d'], rev: '1234' }
-      this.path = {
-        mongo: 'folders[0]',
-        fileSystem: '/old_folder/somewhere.txt'
-      }
-      this.newProject = 'new-project'
-      this.ProjectLocator.findElement = sinon
-        .stub()
-        .withArgs({
-          project: this.project,
-          element_id: this.docId,
-          type: 'docs'
-        })
-        .yields(null, this.doc, this.path)
+      it('should update the database', function() {
+        this.ProjectMock.verify()
+      })
 
-      // return an error when moving a folder to a subfolder of itself
-      this.subject._checkValidMove = sinon.stub().yields(new Error())
+      it('should create one folder', function() {
+        expect(this.result.newFolders).to.have.length(1)
+      })
 
-      this.subject._removeElementFromMongoArray = sinon
-        .stub()
-        .yields(null, this.project)
-      this.subject._putElement = sinon
-        .stub()
-        .yields(null, { path: this.pathAfterMove }, this.newProject)
+      it('should return the new folder', function() {
+        expect(this.result.folder.name).to.equal('new-folder')
+      })
 
-      this.subject.moveEntity(projectId, docId, folderId, 'docs', this.callback)
+      it('should return the parent folder', function() {
+        expect(this.result.folder.parentFolder_id).to.equal(this.folder._id)
+      })
     })
 
-    it('should get the project', function() {
-      this.ProjectGetter.getProjectWithoutLock
-        .calledWith(projectId, {
-          rootFolder: true,
-          name: true,
-          overleaf: true
+    describe('when mutliple folders are missing', async function() {
+      beforeEach(function() {
+        this.folder1 = { _id: ObjectId(), name: 'folder1' }
+        this.folder1Path = {
+          fileSystem: '/test-folder/folder1',
+          mongo: 'rootFolder.0.folders.0.folders.0'
+        }
+        this.folder2 = { _id: ObjectId(), name: 'folder2' }
+        this.folder2Path = {
+          fileSystem: '/test-folder/folder1/folder2',
+          mongo: 'rootFolder.0.folders.0.folders.0.folders.0'
+        }
+        this.FolderModel.onFirstCall().returns(this.folder1)
+        this.FolderModel.onSecondCall().returns(this.folder2)
+        this.ProjectLocator.promises.findElement
+          .withArgs({
+            project: this.project,
+            element_id: this.folder1._id,
+            type: 'folder'
+          })
+          .resolves({
+            element: this.folder1,
+            path: this.folder1Path
+          })
+        this.ProjectLocator.promises.findElement
+          .withArgs({
+            project: this.project,
+            element_id: this.folder2._id,
+            type: 'folder'
+          })
+          .resolves({
+            element: this.folder2,
+            path: this.folder2Path
+          })
+        this.ProjectMock.expects('findOneAndUpdate')
+          .withArgs(
+            { _id: this.project._id },
+            {
+              $push: {
+                'rootFolder.0.folders.0.folders': sinon.match({
+                  name: 'folder1'
+                })
+              },
+              $inc: { version: 1 }
+            }
+          )
+          .chain('exec')
+          .resolves(this.project)
+        this.ProjectMock.expects('findOneAndUpdate')
+          .withArgs(
+            { _id: this.project._id },
+            {
+              $push: {
+                'rootFolder.0.folders.0.folders.0.folders': sinon.match({
+                  name: 'folder2'
+                })
+              },
+              $inc: { version: 1 }
+            }
+          )
+          .chain('exec')
+          .resolves(this.project)
+      })
+      ;[
+        {
+          description: 'without a trailing slash',
+          path: '/test-folder/folder1/folder2'
+        },
+        {
+          description: 'with a trailing slash',
+          path: '/test-folder/folder1/folder2/'
+        }
+      ].forEach(({ description, path }) => {
+        describe(description, function() {
+          beforeEach(async function() {
+            this.result = await this.subject.promises.mkdirp(
+              this.project._id,
+              path
+            )
+          })
+
+          it('should update the database', function() {
+            this.ProjectMock.verify()
+          })
+
+          it('should add multiple folders', function() {
+            const newFolders = this.result.newFolders
+            expect(newFolders).to.have.length(2)
+            expect(newFolders[0].name).to.equal('folder1')
+            expect(newFolders[1].name).to.equal('folder2')
+          })
+
+          it('should return the last folder', function() {
+            expect(this.result.folder.name).to.equal('folder2')
+          })
+
+          it('should return the parent folder', function() {
+            expect(this.result.folder.parentFolder_id).to.equal(
+              this.folder1._id
+            )
+          })
         })
-        .should.equal(true)
-    })
-
-    it('should find the doc to move', function() {
-      this.ProjectLocator.findElement
-        .calledWith({ element_id: docId, type: 'docs', project: this.project })
-        .should.equal(true)
-    })
-
-    it('should check this is an invalid move', function() {
-      this.subject._checkValidMove
-        .calledWith(this.project, 'docs', this.doc, this.path, folderId)
-        .should.equal(true)
-    })
-
-    it('should not put the element in the new folder', function() {
-      this.subject._putElement.called.should.equal(false)
-    })
-
-    it('should not remove the element from its current position', function() {
-      this.subject._removeElementFromMongoArray.called.should.equal(false)
-    })
-
-    it('calls the callback with an error', function() {
-      this.callback.calledWith(sinon.match.instanceOf(Error)).should.equal(true)
+      })
     })
   })
 
-  describe('deleteEntity', function() {
-    beforeEach(function() {
-      this.path = { mongo: 'mongo.path', fileSystem: '/file/system/path' }
-      this.doc = { _id: docId }
-      this.ProjectLocator.findElement = sinon
-        .stub()
-        .callsArgWith(1, null, this.doc, this.path)
-      this.subject._removeElementFromMongoArray = sinon.stub().yields()
-      this.subject.deleteEntity(projectId, docId, 'doc', this.callback)
-    })
+  describe('moveEntity', function() {
+    describe('moving a doc into a different folder', function() {
+      beforeEach(async function() {
+        this.pathAfterMove = {
+          fileSystem: '/somewhere/else.txt'
+        }
+        this.oldDocs = ['old-doc']
+        this.oldFiles = ['old-file']
+        this.newDocs = ['new-doc']
+        this.newFiles = ['new-file']
+
+        this.ProjectEntityHandler.promises.getAllEntitiesFromProject
+          .onFirstCall()
+          .resolves({ docs: this.oldDocs, files: this.oldFiles })
+        this.ProjectEntityHandler.promises.getAllEntitiesFromProject
+          .onSecondCall()
+          .resolves({ docs: this.newDocs, files: this.newFiles })
+
+        this.ProjectMock.expects('findOneAndUpdate')
+          .withArgs(
+            { _id: this.project._id },
+            {
+              $push: { 'rootFolder.0.folders.0.docs': this.doc },
+              $inc: { version: 1 }
+            }
+          )
+          .chain('exec')
+          .resolves(this.project)
+        this.ProjectMock.expects('findOneAndUpdate')
+          .withArgs(
+            { _id: this.project._id },
+            {
+              $pull: { 'rootFolder.0.docs': { _id: this.doc._id } },
+              $inc: { version: 1 }
+            }
+          )
+          .chain('exec')
+          .resolves(this.project)
+        this.result = await this.subject.promises.moveEntity(
+          this.project._id,
+          this.doc._id,
+          this.folder._id,
+          'doc'
+        )
+      })
 
-    it('should get the project', function() {
-      this.ProjectGetter.getProjectWithoutLock
-        .calledWith(projectId, {
-          rootFolder: true,
-          name: true,
-          overleaf: true
-        })
-        .should.equal(true)
-    })
+      it('should update the database', function() {
+        this.ProjectMock.verify()
+      })
 
-    it('should find the element', function() {
-      this.ProjectLocator.findElement
-        .calledWith({
+      it('should report what changed', function() {
+        expect(this.result).to.deep.equal({
           project: this.project,
-          element_id: this.doc._id,
-          type: 'doc'
+          startPath: '/test-doc.txt',
+          endPath: '/test-folder/test-doc.txt',
+          rev: this.doc.rev,
+          changes: {
+            oldDocs: this.oldDocs,
+            newDocs: this.newDocs,
+            oldFiles: this.oldFiles,
+            newFiles: this.newFiles,
+            newProject: this.project
+          }
         })
-        .should.equal(true)
+      })
     })
 
-    it('should remove the element from the database', function() {
-      this.subject._removeElementFromMongoArray
-        .calledWith(this.ProjectModel, projectId, this.path.mongo, this.doc._id)
-        .should.equal(true)
+    describe('when moving a folder inside itself', function() {
+      it('throws an error', async function() {
+        await expect(
+          this.subject.promises.moveEntity(
+            this.project._id,
+            this.folder._id,
+            this.folder._id,
+            'folder'
+          )
+        ).to.be.rejectedWith(Errors.InvalidNameError)
+      })
     })
 
-    it('calls the callbck', function() {
-      this.callback
-        .calledWith(null, this.doc, this.path, this.project)
-        .should.equal(true)
+    describe('when moving a folder to a subfolder of itself', function() {
+      it('throws an error', async function() {
+        await expect(
+          this.subject.promises.moveEntity(
+            this.project._id,
+            this.folder._id,
+            this.subfolder._id,
+            'folder'
+          )
+        ).to.be.rejectedWith(Errors.InvalidNameError)
+      })
     })
   })
 
-  describe('renameEntity', function() {
-    beforeEach(function() {
-      this.newName = 'new.tex'
-      this.path = { mongo: 'mongo.path', fileSystem: '/old.tex' }
-
-      this.project = {
-        _id: ObjectId(projectId),
-        rootFolder: [{ _id: ObjectId() }]
-      }
-      this.doc = { _id: docId, name: 'old.tex', rev: 1 }
-      this.folder = { _id: folderId }
-      this.newProject = 'new-project'
-
-      this.ProjectGetter.getProjectWithoutLock = sinon
-        .stub()
-        .yields(null, this.project)
-
-      this.ProjectEntityHandler.getAllEntitiesFromProject = sinon.stub()
-      this.ProjectEntityHandler.getAllEntitiesFromProject
-        .onFirstCall()
-        .yields(
-          null,
-          (this.oldDocs = ['old-doc']),
-          (this.oldFiles = ['old-file'])
-        )
-      this.ProjectEntityHandler.getAllEntitiesFromProject
-        .onSecondCall()
-        .yields(
-          null,
-          (this.newDocs = ['new-doc']),
-          (this.newFiles = ['new-file'])
+  describe('deleteEntity', function() {
+    beforeEach(async function() {
+      this.ProjectMock.expects('findOneAndUpdate')
+        .withArgs(
+          { _id: this.project._id },
+          {
+            $pull: { 'rootFolder.0.docs': { _id: this.doc._id } },
+            $inc: { version: 1 }
+          }
         )
-
-      this.ProjectLocator.findElement = sinon
-        .stub()
-        .yields(null, this.doc, this.path, this.folder)
-      this.subject._checkValidElementName = sinon.stub().yields()
-      this.ProjectModel.findOneAndUpdate = sinon
-        .stub()
-        .callsArgWith(3, null, this.newProject)
-
-      this.subject.renameEntity(
-        projectId,
-        docId,
-        'doc',
-        this.newName,
-        this.callback
+        .chain('exec')
+        .resolves(this.project)
+      await this.subject.promises.deleteEntity(
+        this.project._id,
+        this.doc._id,
+        'doc'
       )
     })
 
-    it('should get the project', function() {
-      this.ProjectGetter.getProjectWithoutLock
-        .calledWith(projectId, {
-          rootFolder: true,
-          name: true,
-          overleaf: true
-        })
-        .should.equal(true)
-    })
-
-    it('should find the doc', function() {
-      this.ProjectLocator.findElement
-        .calledWith({ element_id: docId, type: 'doc', project: this.project })
-        .should.equal(true)
-    })
-
-    it('should check the new name is valid', function() {
-      this.subject._checkValidElementName
-        .calledWith(this.folder, this.newName)
-        .should.equal(true)
-    })
-
-    it('should update the doc name', function() {
-      this.ProjectModel.findOneAndUpdate
-        .calledWith(
-          { _id: projectId },
-          { $set: { 'mongo.path.name': this.newName }, $inc: { version: 1 } },
-          { new: true }
-        )
-        .should.equal(true)
-    })
-
-    it('calls the callback', function() {
-      const changes = {
-        oldDocs: this.oldDocs,
-        newDocs: this.newDocs,
-        oldFiles: this.oldFiles,
-        newFiles: this.newFiles,
-        newProject: this.newProject
-      }
-      this.callback
-        .calledWith(
-          null,
-          this.project,
-          '/old.tex',
-          '/new.tex',
-          this.doc.rev,
-          changes
-        )
-        .should.equal(true)
+    it('should update the database', function() {
+      this.ProjectMock.verify()
     })
   })
 
-  describe('addFolder', function() {
-    beforeEach(function() {
-      this.folderName = 'folder1234'
-      this.ProjectGetter.getProjectWithOnlyFolders = sinon
-        .stub()
-        .callsArgWith(1, null, this.project)
-      this.subject._confirmFolder = sinon.stub().yields(folderId)
-      this.subject._putElement = sinon.stub().yields()
-
-      this.subject.addFolder(
-        projectId,
-        folderId,
-        this.folderName,
-        this.callback
-      )
-    })
-
-    it('gets the project', function() {
-      this.ProjectGetter.getProjectWithoutLock
-        .calledWith(projectId, {
-          rootFolder: true,
-          name: true,
-          overleaf: true
-        })
-        .should.equal(true)
-    })
-
-    it('checks the parent folder exists', function() {
-      this.subject._confirmFolder
-        .calledWith(this.project, folderId)
-        .should.equal(true)
-    })
-
-    it('puts the element in mongo', function() {
-      const folderMatcher = sinon.match(
-        folder => folder.name === this.folderName
-      )
-
-      this.subject._putElement
-        .calledWithMatch(this.project, folderId, folderMatcher, 'folder')
-        .should.equal(true)
-    })
-
-    it('calls the callback', function() {
-      const folderMatcher = sinon.match(
-        folder => folder.name === this.folderName
-      )
-
-      this.callback
-        .calledWithMatch(null, folderMatcher, folderId)
-        .should.equal(true)
-    })
-  })
-
-  describe('_removeElementFromMongoArray ', function() {
-    beforeEach(function() {
-      this.mongoPath = 'folders[0].folders[5]'
-      this.id = '12344'
-      this.entityId = '5678'
-      this.ProjectModel.update = sinon.stub().yields()
-      this.ProjectModel.findOneAndUpdate = sinon
-        .stub()
-        .yields(null, this.project)
-      this.subject._removeElementFromMongoArray(
-        this.ProjectModel,
-        this.id,
-        this.mongoPath,
-        this.entityId,
-        this.callback
-      )
-    })
-
-    it('should pull', function() {
-      this.ProjectModel.findOneAndUpdate
-        .calledWith(
-          { _id: this.id },
-          {
-            $pull: { 'folders[0]': { _id: this.entityId } },
-            $inc: { version: 1 }
-          },
-          { new: true }
+  describe('renameEntity', function() {
+    describe('happy path', function() {
+      beforeEach(async function() {
+        this.newName = 'new.tex'
+        this.oldDocs = ['old-doc']
+        this.oldFiles = ['old-file']
+        this.newDocs = ['new-doc']
+        this.newFiles = ['new-file']
+
+        this.ProjectEntityHandler.promises.getAllEntitiesFromProject
+          .onFirstCall()
+          .resolves({ docs: this.oldDocs, files: this.oldFiles })
+        this.ProjectEntityHandler.promises.getAllEntitiesFromProject
+          .onSecondCall()
+          .resolves({ docs: this.newDocs, files: this.newFiles })
+
+        this.ProjectMock.expects('findOneAndUpdate')
+          .withArgs(
+            { _id: this.project._id },
+            {
+              $set: { 'rootFolder.0.docs.0.name': this.newName },
+              $inc: { version: 1 }
+            }
+          )
+          .chain('exec')
+          .resolves(this.project)
+        this.result = await this.subject.promises.renameEntity(
+          this.project._id,
+          this.doc._id,
+          'doc',
+          this.newName
         )
-        .should.equal(true)
-    })
+      })
 
-    it('should call the callback', function() {
-      this.callback.calledWith(null, this.project).should.equal(true)
-    })
-  })
+      it('should update the database', function() {
+        this.ProjectMock.verify()
+      })
 
-  describe('_countElements', function() {
-    beforeEach(function() {
-      this.project = {
-        _id: projectId,
-        rootFolder: [
-          {
-            docs: [{ _id: 123 }, { _id: 345 }],
-            fileRefs: [{ _id: 123 }, { _id: 345 }, { _id: 456 }],
-            folders: [
-              {
-                docs: [{ _id: 123 }, { _id: 345 }, { _id: 456 }],
-                fileRefs: {},
-                folders: [
-                  {
-                    docs: [{ _id: 1234 }],
-                    fileRefs: [{ _id: 23123 }, { _id: 123213 }, { _id: 2312 }],
-                    folders: [
-                      {
-                        docs: [{ _id: 321321 }, { _id: 123213 }],
-                        fileRefs: [{ _id: 312321 }],
-                        folders: []
-                      }
-                    ]
-                  }
-                ]
-              },
-              {
-                docs: [{ _id: 123 }, { _id: 32131 }],
-                fileRefs: [],
-                folders: [
-                  {
-                    docs: [{ _id: 3123 }],
-                    fileRefs: [
-                      { _id: 321321 },
-                      { _id: 321321 },
-                      { _id: 313122 }
-                    ],
-                    folders: 0
-                  }
-                ]
-              }
-            ]
+      it('returns info', function() {
+        expect(this.result).to.deep.equal({
+          project: this.project,
+          startPath: '/test-doc.txt',
+          endPath: '/new.tex',
+          rev: this.doc.rev,
+          changes: {
+            oldDocs: this.oldDocs,
+            newDocs: this.newDocs,
+            oldFiles: this.oldFiles,
+            newFiles: this.newFiles,
+            newProject: this.project
           }
-        ]
-      }
-    })
-
-    it('should return the correct number', function() {
-      expect(this.subject._countElements(this.project)).to.equal(26)
-    })
-
-    it('should deal with null folders', function() {
-      this.project.rootFolder[0].folders[0].folders = undefined
-      expect(this.subject._countElements(this.project)).to.equal(17)
-    })
-
-    it('should deal with null docs', function() {
-      this.project.rootFolder[0].folders[0].docs = undefined
-      expect(this.subject._countElements(this.project)).to.equal(23)
+        })
+      })
     })
 
-    it('should deal with null fileRefs', function() {
-      this.project.rootFolder[0].folders[0].folders[0].fileRefs = undefined
-      expect(this.subject._countElements(this.project)).to.equal(23)
+    describe('name already exists', function() {
+      it('should throw an error', async function() {
+        await expect(
+          this.subject.promises.renameEntity(
+            this.project._id,
+            this.doc._id,
+            'doc',
+            this.folder.name
+          )
+        ).to.be.rejectedWith(Errors.InvalidNameError)
+      })
     })
   })
 
   describe('_putElement', function() {
-    beforeEach(function() {
-      this.project = {
-        _id: projectId,
-        rootFolder: [{ _id: ObjectId() }]
-      }
-      this.folder = {
-        _id: ObjectId(),
-        name: 'someFolder',
-        docs: [{ name: 'another-doc.tex' }],
-        fileRefs: [{ name: 'another-file.tex' }],
-        folders: [{ name: 'another-folder' }]
-      }
-      this.doc = {
-        _id: ObjectId(),
-        name: 'new.tex'
-      }
-      this.path = { mongo: 'mongo.path', fileSystem: '/file/system/old.tex' }
-      this.ProjectLocator.findElement = sinon
-        .stub()
-        .yields(null, this.folder, this.path)
-      this.ProjectModel.findOneAndUpdate = sinon
-        .stub()
-        .yields(null, this.project)
-    })
-
     describe('updating the project', function() {
-      it('should use the correct mongo path', function(done) {
-        this.subject._putElement(
-          this.project,
-          this.folder._id,
-          this.doc,
-          'docs',
-          err => {
-            if (err != null) {
-              return done(err)
-            }
-            this.ProjectModel.findOneAndUpdate.args[0][0]._id.should.equal(
-              this.project._id
-            )
-            assert.deepEqual(
-              this.ProjectModel.findOneAndUpdate.args[0][1].$push[
-                this.path.mongo + '.docs'
-              ],
-              this.doc
-            )
-            done()
-          }
-        )
-      })
-
-      it('should return the project in the callback', function(done) {
-        this.subject._putElement(
-          this.project,
-          this.folder._id,
-          this.doc,
-          'docs',
-          (err, path, project) => {
-            if (err != null) {
-              return done(err)
-            }
-            assert.equal(project, this.project)
-            done()
-          }
-        )
-      })
-
-      it('should add an s onto the type if not included', function(done) {
-        this.subject._putElement(
-          this.project,
-          this.folder._id,
-          this.doc,
-          'doc',
-          err => {
-            if (err != null) {
-              return done(err)
-            }
-            assert.deepEqual(
-              this.ProjectModel.findOneAndUpdate.args[0][1].$push[
-                this.path.mongo + '.docs'
-              ],
-              this.doc
+      describe('when the parent folder is given', function() {
+        beforeEach(function() {
+          this.newFile = { _id: ObjectId(), name: 'new file.png' }
+          this.ProjectMock.expects('findOneAndUpdate')
+            .withArgs(
+              { _id: this.project._id },
+              {
+                $push: { 'rootFolder.0.folders.0.fileRefs': this.newFile },
+                $inc: { version: 1 }
+              }
             )
-            done()
-          }
-        )
-      })
+            .chain('exec')
+            .resolves(this.project)
+        })
 
-      it('should not call update if element is null', function(done) {
-        this.subject._putElement(
-          this.project,
-          this.folder._id,
-          null,
-          'doc',
-          err => {
-            expect(err).to.exist
-            this.ProjectModel.findOneAndUpdate.called.should.equal(false)
-            done()
-          }
-        )
-      })
+        it('should update the database', async function() {
+          await this.subject.promises._putElement(
+            this.project,
+            this.folder._id,
+            this.newFile,
+            'files'
+          )
+          this.ProjectMock.verify()
+        })
 
-      it('should default to root folder insert', function(done) {
-        this.subject._putElement(this.project, null, this.doc, 'doc', err => {
-          if (err != null) {
-            return done(err)
-          }
-          this.ProjectLocator.findElement.args[0][0].element_id.should.equal(
-            this.project.rootFolder[0]._id
+        it('should add an s onto the type if not included', async function() {
+          await this.subject.promises._putElement(
+            this.project,
+            this.folder._id,
+            this.newFile,
+            'file'
           )
-          done()
+          this.ProjectMock.verify()
         })
       })
 
-      it('should error if the element has no _id', function(done) {
-        const doc = { name: 'something' }
-        this.subject._putElement(
-          this.project,
-          this.folder._id,
-          doc,
-          'doc',
-          err => {
-            expect(err).to.exist
-            this.ProjectModel.findOneAndUpdate.called.should.equal(false)
-            done()
-          }
-        )
-      })
+      describe('error cases', function() {
+        it('should throw an error if element is null', async function() {
+          await expect(
+            this.subject.promises._putElement(
+              this.project,
+              this.folder._id,
+              null,
+              'file'
+            )
+          ).to.be.rejected
+        })
 
-      it('should error if element name contains invalid characters', function(done) {
-        const doc = {
-          _id: ObjectId(),
-          name: 'something*bad'
-        }
-        this.subject._putElement(
-          this.project,
-          this.folder._id,
-          doc,
-          'doc',
-          err => {
-            this.ProjectModel.findOneAndUpdate.called.should.equal(false)
-            expect(err).to.be.instanceOf(Errors.InvalidNameError)
-            expect(err).to.have.property('message', 'invalid element name')
-            done()
-          }
-        )
-      })
+        it('should error if the element has no _id', async function() {
+          const file = { name: 'something' }
+          await expect(
+            this.subject.promises._putElement(
+              this.project,
+              this.folder._id,
+              file,
+              'file'
+            )
+          ).to.be.rejected
+        })
 
-      it('should error if element name is too long', function(done) {
-        const doc = {
-          _id: ObjectId(),
-          name: new Array(200).join('long-') + 'something'
-        }
-        this.subject._putElement(
-          this.project,
-          this.folder._id,
-          doc,
-          'doc',
-          err => {
-            this.ProjectModel.findOneAndUpdate.called.should.equal(false)
-            expect(err).to.be.instanceOf(Errors.InvalidNameError)
-            expect(err).to.have.property('message', 'path too long')
-            done()
-          }
-        )
-      })
+        it('should error if element name contains invalid characters', async function() {
+          const file = { _id: ObjectId(), name: 'something*bad' }
+          await expect(
+            this.subject.promises._putElement(
+              this.project,
+              this.folder._id,
+              file,
+              'file'
+            )
+          ).to.be.rejected
+        })
 
-      it('should error if the folder name is too long', function(done) {
-        this.path = {
-          mongo: 'mongo.path',
-          fileSystem: new Array(200).join('subdir/') + 'foo'
-        }
-        this.ProjectLocator.findElement.callsArgWith(
-          1,
-          null,
-          this.folder,
-          this.path
-        )
-        const doc = {
-          _id: ObjectId(),
-          name: 'something'
-        }
-        this.subject._putElement(
-          this.project,
-          this.folder._id,
-          doc,
-          'doc',
-          err => {
-            this.ProjectModel.findOneAndUpdate.called.should.equal(false)
-            expect(err).to.be.instanceOf(Errors.InvalidNameError)
-            expect(err).to.have.property('message', 'path too long')
-            done()
+        it('should error if element name is too long', async function() {
+          const file = {
+            _id: ObjectId(),
+            name: 'long-'.repeat(1000) + 'something'
           }
-        )
-      })
-
-      it('should error if a document already exists with the same name', function(done) {
-        const doc = {
-          _id: ObjectId(),
-          name: 'another-doc.tex'
-        }
-        this.subject._putElement(this.project, this.folder, doc, 'doc', err => {
-          this.ProjectModel.findOneAndUpdate.called.should.equal(false)
-          expect(err).to.be.instanceOf(Errors.InvalidNameError)
-          expect(err).to.have.property('message', 'file already exists')
-          done()
+          await expect(
+            this.subject.promises._putElement(
+              this.project,
+              this.folder._id,
+              file,
+              'file'
+            )
+          ).to.be.rejectedWith(Errors.InvalidNameError)
         })
-      })
 
-      it('should error if a file already exists with the same name', function(done) {
-        const doc = {
-          _id: ObjectId(),
-          name: 'another-file.tex'
-        }
-        this.subject._putElement(this.project, this.folder, doc, 'doc', err => {
-          this.ProjectModel.findOneAndUpdate.called.should.equal(false)
-          expect(err).to.be.instanceOf(Errors.InvalidNameError)
-          expect(err).to.have.property('message', 'file already exists')
-          done()
+        it('should error if the folder name is too long', async function() {
+          const file = {
+            _id: ObjectId(),
+            name: 'something'
+          }
+          this.ProjectLocator.promises.findElement
+            .withArgs({
+              project: this.project,
+              element_id: this.folder._id,
+              type: 'folder'
+            })
+            .resolves({
+              element: this.folder,
+              path: { fileSystem: 'subdir/'.repeat(1000) + 'foo' }
+            })
+          await expect(
+            this.subject.promises._putElement(
+              this.project,
+              this.folder._id,
+              file,
+              'file'
+            )
+          ).to.be.rejectedWith(Errors.InvalidNameError)
         })
-      })
-
-      it('should error if a folder already exists with the same name', function(done) {
-        const doc = {
-          _id: ObjectId(),
-          name: 'another-folder'
-        }
-        this.subject._putElement(this.project, this.folder, doc, 'doc', err => {
-          this.ProjectModel.findOneAndUpdate.called.should.equal(false)
-          expect(err).to.be.instanceOf(Errors.InvalidNameError)
-          expect(err).to.have.property('message', 'file already exists')
-          done()
+        ;['file', 'doc', 'folder'].forEach(entityType => {
+          it(`should error if a ${entityType} already exists with the same name`, async function() {
+            const file = {
+              _id: ObjectId(),
+              name: this[entityType].name
+            }
+            await expect(
+              this.subject.promises._putElement(
+                this.project,
+                null,
+                file,
+                'file'
+              )
+            ).to.be.rejectedWith(Errors.InvalidNameError)
+          })
         })
       })
     })
-  })
-
-  describe('_checkValidElementName', function() {
-    beforeEach(function() {
-      this.folder = {
-        docs: [{ name: 'doc_name' }],
-        fileRefs: [{ name: 'file_name' }],
-        folders: [{ name: 'folder_name' }]
-      }
-    })
-
-    it('returns an error if name matches any doc name', function() {
-      this.subject._checkValidElementName(this.folder, 'doc_name', err => {
-        expect(err).to.be.instanceOf(Errors.InvalidNameError)
-        expect(err).to.have.property('message', 'file already exists')
-      })
-    })
-
-    it('returns an error if name matches any file name', function() {
-      this.subject._checkValidElementName(this.folder, 'file_name', err => {
-        expect(err).to.be.instanceOf(Errors.InvalidNameError)
-        expect(err).to.have.property('message', 'file already exists')
-      })
-    })
 
-    it('returns an error if name matches any folder name', function() {
-      this.subject._checkValidElementName(this.folder, 'folder_name', err => {
-        expect(err).to.be.instanceOf(Errors.InvalidNameError)
-        expect(err).to.have.property('message', 'file already exists')
+    describe('when the parent folder is not given', function() {
+      it('should default to root folder insert', async function() {
+        this.newFile = { _id: ObjectId(), name: 'new file.png' }
+        this.ProjectMock.expects('findOneAndUpdate')
+          .withArgs(
+            { _id: this.project._id },
+            {
+              $push: { 'rootFolder.0.fileRefs': this.newFile },
+              $inc: { version: 1 }
+            }
+          )
+          .chain('exec')
+          .resolves(this.project)
+        await this.subject.promises._putElement(
+          this.project,
+          this.rootFolder._id,
+          this.newFile,
+          'file'
+        )
       })
     })
+  })
 
-    it('returns nothing if name is valid', function() {
-      this.subject._checkValidElementName(
-        this.folder,
-        'unique_name',
-        err => expect(err).to.be.undefined
+  describe('_insertDeletedDocReference', function() {
+    beforeEach(async function() {
+      this.ProjectMock.expects('updateOne')
+        .withArgs(
+          { _id: this.project._id },
+          {
+            $push: {
+              deletedDocs: {
+                _id: this.doc._id,
+                name: this.doc.name,
+                deletedAt: sinon.match.date
+              }
+            }
+          }
+        )
+        .chain('exec')
+        .resolves()
+      await this.subject.promises._insertDeletedDocReference(
+        this.project._id,
+        this.doc
       )
     })
-  })
 
-  describe('_checkValidMove', function() {
-    beforeEach(function() {
-      this.destFolder = { _id: folderId }
-      this.destFolderPath = { fileSystem: '/foo/bar' }
-      this.ProjectLocator.findElement = sinon
-        .stub()
-        .yields(null, this.destFolder, this.destFolderPath)
-      this.subject._checkValidElementName = sinon.stub().yields()
+    it('should update the database', function() {
+      this.ProjectMock.verify()
     })
+  })
 
-    it('checks the element name is valid', function() {
-      this.doc = { _id: docId, name: 'doc_name' }
-      this.subject._checkValidMove(
-        this.project,
-        'doc',
-        this.doc,
-        { fileSystem: '/main.tex' },
-        this.destFolder._id,
-        err => {
-          expect(err).to.be.undefined
-          this.subject._checkValidElementName
-            .calledWith(this.destFolder, this.doc.name)
-            .should.equal(true)
-        }
+  describe('_insertDeletedFileReference', function() {
+    beforeEach(async function() {
+      this.ProjectMock.expects('updateOne')
+        .withArgs(
+          { _id: this.project._id },
+          {
+            $push: {
+              deletedFiles: {
+                _id: this.file._id,
+                name: this.file.name,
+                linkedFileData: this.file.linkedFileData,
+                hash: this.file.hash,
+                deletedAt: sinon.match.date
+              }
+            }
+          }
+        )
+        .chain('exec')
+        .resolves()
+      await this.subject.promises._insertDeletedFileReference(
+        this.project._id,
+        this.file
       )
     })
 
-    it('returns an error if trying to move a folder inside itself', function() {
-      const folder = { name: 'folder_name' }
-      this.subject._checkValidMove(
-        this.project,
-        'folder',
-        folder,
-        { fileSystem: '/foo' },
-        this.destFolder._id,
-        err => {
-          expect(err).to.be.instanceOf(Errors.InvalidNameError)
-          expect(err).to.have.property(
-            'message',
-            'destination folder is a child folder of me'
-          )
-        }
-      )
+    it('should update the database', function() {
+      this.ProjectMock.verify()
     })
   })
 
-  describe('_insertDeletedDocReference', function() {
+  describe('createNewFolderStructure', function() {
     beforeEach(function() {
-      this.doc = {
-        _id: ObjectId(),
-        name: 'test.tex'
-      }
-      this.callback = sinon.stub()
-      this.ProjectModel.update = sinon.stub().yields()
-      this.subject._insertDeletedDocReference(
-        projectId,
-        this.doc,
-        this.callback
-      )
-    })
-
-    it('should insert the doc into deletedDocs', function() {
-      this.ProjectModel.update
-        .calledWith(
+      this.mockRootFolder = 'MOCK_ROOT_FOLDER'
+      this.docUploads = ['MOCK_DOC_UPLOAD']
+      this.fileUploads = ['MOCK_FILE_UPLOAD']
+      this.FolderStructureBuilder.buildFolderStructure
+        .withArgs(this.docUploads, this.fileUploads)
+        .returns(this.mockRootFolder)
+      this.updateExpectation = this.ProjectMock.expects('updateOne')
+        .withArgs(
           {
-            _id: projectId
+            _id: this.project._id,
+            'rootFolder.0.folders.0': { $exists: false },
+            'rootFolder.0.docs.0': { $exists: false },
+            'rootFolder.0.files.0': { $exists: false }
           },
-          {
-            $push: {
-              deletedDocs: {
-                _id: this.doc._id,
-                name: this.doc.name,
-                deletedAt: new Date()
-              }
-            }
-          }
+          { $set: { rootFolder: [this.mockRootFolder] }, $inc: { version: 1 } }
+        )
+        .chain('exec')
+    })
+
+    describe('happy path', function() {
+      beforeEach(async function() {
+        this.updateExpectation.resolves({ n: 1 })
+        await this.subject.promises.createNewFolderStructure(
+          this.project._id,
+          this.docUploads,
+          this.fileUploads
         )
-        .should.equal(true)
+      })
+
+      it('updates the database', function() {
+        this.ProjectMock.verify()
+      })
     })
 
-    it('should call the callback', function() {
-      this.callback.called.should.equal(true)
+    describe("when the update doesn't find a matching document", function() {
+      beforeEach(async function() {
+        this.updateExpectation.resolves({ n: 0 })
+      })
+
+      it('throws an error', async function() {
+        await expect(
+          this.subject.promises.createNewFolderStructure(
+            this.project._id,
+            this.docUploads,
+            this.fileUploads
+          )
+        ).to.be.rejected
+      })
     })
   })
 })

services/web/test/unit/src/Project/ProjectEntityUpdateHandlerTests.js

@@ -134,7 +134,7 @@ describe('ProjectEntityUpdateHandler', function() {
       this.oldFileRef = { name: this.fileName, _id: 'oldFileRef' }
       this.ProjectEntityMongoUpdateHandler._confirmFolder = sinon
         .stub()
-        .yields(folder_id)
+        .returns(folder_id)
       this.ProjectEntityMongoUpdateHandler._putElement = sinon
         .stub()
         .yields(null, { path: { fileSystem: this.fileSystemPath } })
@@ -221,7 +221,7 @@ describe('ProjectEntityUpdateHandler', function() {
       }
       this.ProjectEntityMongoUpdateHandler._confirmFolder = sinon
         .stub()
-        .yields(folder_id)
+        .returns(folder_id)
       this.ProjectEntityMongoUpdateHandler._putElement = sinon
         .stub()
         .yields(null, { path: { fileSystem: this.fileSystemPath } })