Merge pull request #2113 from overleaf/em-project-details-handler-async

Move ProjectDetailsHandler to async/await

GitOrigin-RevId: 5ec9343d6203850641174cc728db9a2e56f44775

services/web/app/src/Features/Collaborators/CollaboratorsHandler.js

@@ -13,7 +13,6 @@
  * DS207: Consider shorter variations of null checks
  * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
  */
-let CollaboratorsHandler
 const UserCreator = require('../User/UserCreator')
 const { Project } = require('../../models/Project')
 const ProjectGetter = require('../Project/ProjectGetter')
@@ -29,8 +28,9 @@ const EmailHelper = require('../Helpers/EmailHelper')
 const ProjectEditorHandler = require('../Project/ProjectEditorHandler')
 const Sources = require('../Authorization/Sources')
 const { ObjectId } = require('mongojs')
+const { promisifyAll } = require('../../util/promises')
 
-module.exports = CollaboratorsHandler = {
+const CollaboratorsHandler = {
   getMemberIdsWithPrivilegeLevels(project_id, callback) {
     if (callback == null) {
       callback = function(error, members) {}
@@ -665,3 +665,8 @@ module.exports = CollaboratorsHandler = {
     })
   }
 }
+
+CollaboratorsHandler.promises = promisifyAll(CollaboratorsHandler, {
+  without: ['getMemberIdsWithPrivilegeLevelsFromFields']
+})
+module.exports = CollaboratorsHandler

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

@@ -238,8 +238,7 @@ async function undeleteProject(project_id) {
   let restored = new Project(deletedProject.project)
 
   // if we're undeleting, we want the document to show up
-  const generateUniqueName = promisify(ProjectDetailsHandler.generateUniqueName)
-  restored.name = await generateUniqueName(
+  restored.name = await ProjectDetailsHandler.promises.generateUniqueName(
     deletedProject.deleterData.deletedProjectOwnerId,
     restored.name + ' (Restored)'
   )

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

@@ -1,25 +1,9 @@
-/* eslint-disable
-    camelcase,
-    handle-callback-err,
-    max-len,
-    no-unused-vars,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * DS103: Rewrite code to no longer use __guard__
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
+const _ = require('underscore')
 const ProjectGetter = require('./ProjectGetter')
 const UserGetter = require('../User/UserGetter')
 const { Project } = require('../../models/Project')
-const { ObjectId } = require('mongojs')
 const logger = require('logger-sharelatex')
-const tpdsUpdateSender = require('../ThirdPartyDataStore/TpdsUpdateSender')
-const _ = require('underscore')
+const TpdsUpdateSender = require('../ThirdPartyDataStore/TpdsUpdateSender')
 const PublicAccessLevels = require('../Authorization/PublicAccessLevels')
 const Errors = require('../Errors/Errors')
 const ProjectTokenGenerator = require('./ProjectTokenGenerator')
@@ -27,411 +11,276 @@ const ProjectEntityHandler = require('./ProjectEntityHandler')
 const ProjectHelper = require('./ProjectHelper')
 const CollaboratorsHandler = require('../Collaborators/CollaboratorsHandler')
 const settings = require('settings-sharelatex')
-const { promisify } = require('util')
-
-const ProjectDetailsHandler = {
-  getDetails(project_id, callback) {
-    return ProjectGetter.getProject(
-      project_id,
-      {
-        name: true,
-        description: true,
-        compiler: true,
-        features: true,
-        owner_ref: true,
-        overleaf: true
-      },
-      function(err, project) {
-        if (err != null) {
-          logger.warn({ err, project_id }, 'error getting project')
-          return callback(err)
-        }
-        if (project == null) {
-          return callback(new Errors.NotFoundError('project not found'))
-        }
-        return UserGetter.getUser(project.owner_ref, function(err, user) {
-          if (err != null) {
-            return callback(err)
-          }
-          const details = {
-            name: project.name,
-            description: project.description,
-            compiler: project.compiler,
-            features:
-              (user != null ? user.features : undefined) ||
-              settings.defaultFeatures
-          }
+const { callbackify } = require('util')
 
-          if (project.overleaf != null) {
-            details.overleaf = project.overleaf
-          }
-
-          logger.log({ project_id, details }, 'getting project details')
-          return callback(err, details)
-        })
-      }
-    )
-  },
+const MAX_PROJECT_NAME_LENGTH = 150
 
-  getProjectDescription(project_id, callback) {
-    return ProjectGetter.getProject(
-      project_id,
-      { description: true },
-      (err, project) =>
-        callback(err, project != null ? project.description : undefined)
-    )
-  },
+module.exports = {
+  MAX_PROJECT_NAME_LENGTH,
+  getDetails: callbackify(getDetails),
+  getProjectDescription: callbackify(getProjectDescription),
+  setProjectDescription: callbackify(setProjectDescription),
+  transferOwnership: callbackify(transferOwnership),
+  renameProject: callbackify(renameProject),
+  validateProjectName: callbackify(validateProjectName),
+  generateUniqueName: callbackify(generateUniqueName),
+  setPublicAccessLevel: callbackify(setPublicAccessLevel),
+  ensureTokensArePresent: callbackify(ensureTokensArePresent),
+  fixProjectName,
+  promises: {
+    getDetails,
+    getProjectDescription,
+    setProjectDescription,
+    transferOwnership,
+    renameProject,
+    validateProjectName,
+    generateUniqueName,
+    setPublicAccessLevel,
+    ensureTokensArePresent
+  }
+}
 
-  setProjectDescription(project_id, description, callback) {
-    const conditions = { _id: project_id }
-    const update = { description }
-    logger.log(
-      { conditions, update, project_id, description },
-      'setting project description'
-    )
-    return Project.update(conditions, update, function(err) {
-      if (err != null) {
-        logger.warn({ err }, 'something went wrong setting project description')
-      }
-      return callback(err)
+async function getDetails(projectId) {
+  let project
+  try {
+    project = await ProjectGetter.promises.getProject(projectId, {
+      name: true,
+      description: true,
+      compiler: true,
+      features: true,
+      owner_ref: true,
+      overleaf: true
     })
-  },
+  } catch (err) {
+    logger.warn({ err, projectId }, 'error getting project')
+    throw err
+  }
+  if (project == null) {
+    throw new Errors.NotFoundError('project not found')
+  }
+  const user = await UserGetter.promises.getUser(project.owner_ref)
+  const details = {
+    name: project.name,
+    description: project.description,
+    compiler: project.compiler,
+    features:
+      user != null && user.features != null
+        ? user.features
+        : settings.defaultFeatures
+  }
+  if (project.overleaf != null) {
+    details.overleaf = project.overleaf
+  }
+  logger.log({ projectId, details }, 'getting project details')
+  return details
+}
 
-  transferOwnership(project_id, user_id, suffix, callback) {
-    if (suffix == null) {
-      suffix = ''
-    }
-    if (typeof suffix === 'function') {
-      callback = suffix
-      suffix = ''
-    }
-    return ProjectGetter.getProject(
-      project_id,
-      { owner_ref: true, name: true },
-      function(err, project) {
-        if (err != null) {
-          return callback(err)
-        }
-        if (project == null) {
-          return callback(new Errors.NotFoundError('project not found'))
-        }
-        if (project.owner_ref === user_id) {
-          return callback()
-        }
+async function getProjectDescription(projectId) {
+  const project = await ProjectGetter.promises.getProject(projectId, {
+    description: true
+  })
+  if (project == null) {
+    return undefined
+  }
+  return project.description
+}
 
-        return UserGetter.getUser(user_id, function(err, user) {
-          if (err != null) {
-            return callback(err)
-          }
-          if (user == null) {
-            return callback(new Errors.NotFoundError('user not found'))
-          }
+async function setProjectDescription(projectId, description) {
+  const conditions = { _id: projectId }
+  const update = { description }
+  logger.log(
+    { conditions, update, projectId, description },
+    'setting project description'
+  )
+  try {
+    await Project.update(conditions, update).exec()
+  } catch (err) {
+    logger.warn({ err }, 'something went wrong setting project description')
+    throw err
+  }
+}
 
-          //	we make sure the user to which the project is transferred is not a collaborator for the project,
-          //	this prevents any conflict during unique name generation
-          return CollaboratorsHandler.removeUserFromProject(
-            project_id,
-            user_id,
-            function(err) {
-              if (err != null) {
-                return callback(err)
-              }
-              return ProjectDetailsHandler.generateUniqueName(
-                user_id,
-                project.name + suffix,
-                function(err, name) {
-                  if (err != null) {
-                    return callback(err)
-                  }
-                  return Project.update(
-                    { _id: project_id },
-                    {
-                      $set: {
-                        owner_ref: user_id,
-                        name
-                      }
-                    },
-                    function(err) {
-                      if (err != null) {
-                        return callback(err)
-                      }
-                      return ProjectEntityHandler.flushProjectToThirdPartyDataStore(
-                        project_id,
-                        callback
-                      )
-                    }
-                  )
-                }
-              )
-            }
-          )
-        })
-      }
-    )
-  },
+async function transferOwnership(projectId, userId, suffix = '') {
+  const project = await ProjectGetter.promises.getProject(projectId, {
+    owner_ref: true,
+    name: true
+  })
+  if (project == null) {
+    throw new Errors.NotFoundError('project not found')
+  }
+  if (project.owner_ref === userId) {
+    return
+  }
+  const user = await UserGetter.promises.getUser(userId)
+  if (user == null) {
+    throw new Errors.NotFoundError('user not found')
+  }
 
-  renameProject(project_id, newName, callback) {
-    if (callback == null) {
-      callback = function() {}
-    }
-    return ProjectDetailsHandler.validateProjectName(newName, function(error) {
-      if (error != null) {
-        return callback(error)
+  // we make sure the user to which the project is transferred is not a collaborator for the project,
+  // this prevents any conflict during unique name generation
+  await CollaboratorsHandler.promises.removeUserFromProject(projectId, userId)
+  const name = await generateUniqueName(userId, project.name + suffix)
+  await Project.update(
+    { _id: projectId },
+    {
+      $set: {
+        owner_ref: userId,
+        name
       }
-      logger.log({ project_id, newName }, 'renaming project')
-      return ProjectGetter.getProject(project_id, { name: true }, function(
-        err,
-        project
-      ) {
-        if (err != null || project == null) {
-          logger.warn(
-            { err, project_id },
-            'error getting project or could not find it todo project rename'
-          )
-          return callback(err)
-        }
-        const oldProjectName = project.name
-        return Project.update(
-          { _id: project_id },
-          { name: newName },
-          (err, project) => {
-            if (err != null) {
-              return callback(err)
-            }
-            return tpdsUpdateSender.moveEntity(
-              {
-                project_id,
-                project_name: oldProjectName,
-                newProjectName: newName
-              },
-              callback
-            )
-          }
-        )
-      })
-    })
-  },
-
-  MAX_PROJECT_NAME_LENGTH: 150,
-  validateProjectName(name, callback) {
-    if (callback == null) {
-      callback = function(error) {}
-    }
-    if (name == null || name.length === 0) {
-      return callback(
-        new Errors.InvalidNameError('Project name cannot be blank')
-      )
-    } else if (name.length > ProjectDetailsHandler.MAX_PROJECT_NAME_LENGTH) {
-      return callback(new Errors.InvalidNameError('Project name is too long'))
-    } else if (name.indexOf('/') > -1) {
-      return callback(
-        new Errors.InvalidNameError('Project name cannot contain / characters')
-      )
-    } else if (name.indexOf('\\') > -1) {
-      return callback(
-        new Errors.InvalidNameError('Project name cannot contain \\ characters')
-      )
-    } else {
-      return callback()
-    }
-  },
-
-  generateUniqueName(user_id, name, suffixes, callback) {
-    if (suffixes == null) {
-      suffixes = []
-    }
-    if (callback == null) {
-      callback = function(error, newName) {}
-    }
-    if (arguments.length === 3 && typeof suffixes === 'function') {
-      // make suffixes an optional argument
-      callback = suffixes
-      suffixes = []
-    }
-    return ProjectDetailsHandler.ensureProjectNameIsUnique(
-      user_id,
-      name,
-      suffixes,
-      callback
-    )
-  },
-
-  // FIXME: we should put a lock around this to make it completely safe, but we would need to do that at
-  // the point of project creation, rather than just checking the name at the start of the import.
-  // If we later move this check into ProjectCreationHandler we can ensure all new projects are created
-  // with a unique name.  But that requires thinking through how we would handle incoming projects from
-  // dropbox for example.
-  ensureProjectNameIsUnique(user_id, name, suffixes, callback) {
-    if (suffixes == null) {
-      suffixes = []
-    }
-    if (callback == null) {
-      callback = function(error, name, changed) {}
     }
-    return ProjectGetter.findAllUsersProjects(user_id, { name: 1 }, function(
-      error,
-      allUsersProjectNames
-    ) {
-      if (error != null) {
-        return callback(error)
-      }
-      // allUsersProjectNames is returned as a hash {owned: [name1, name2, ...], readOnly: [....]}
-      // collect all of the names and flatten them into a single array
-      const projectNameList = _.pluck(
-        _.flatten(_.values(allUsersProjectNames)),
-        'name'
-      )
-      return ProjectHelper.ensureNameIsUnique(
-        projectNameList,
-        name,
-        suffixes,
-        ProjectDetailsHandler.MAX_PROJECT_NAME_LENGTH,
-        callback
-      )
-    })
-  },
+  ).exec()
+  await ProjectEntityHandler.promises.flushProjectToThirdPartyDataStore(
+    projectId
+  )
+}
 
-  fixProjectName(name) {
-    if (name === '' || !name) {
-      name = 'Untitled'
-    }
-    if (name.indexOf('/') > -1) {
-      // v2 does not allow / in a project name
-      name = name.replace(/\//g, '-')
-    }
-    if (name.indexOf('\\') > -1) {
-      // backslashes in project name will prevent syncing to dropbox
-      name = name.replace(/\\/g, '')
-    }
-    if (name.length > ProjectDetailsHandler.MAX_PROJECT_NAME_LENGTH) {
-      name = name.substr(0, ProjectDetailsHandler.MAX_PROJECT_NAME_LENGTH)
-    }
-    return name
-  },
+async function renameProject(projectId, newName) {
+  await validateProjectName(newName)
+  logger.log({ projectId, newName }, 'renaming project')
+  let project
+  try {
+    project = await ProjectGetter.promises.getProject(projectId, { name: true })
+  } catch (err) {
+    logger.warn({ err, projectId }, 'error getting project')
+    throw err
+  }
+  if (project == null) {
+    logger.warn({ projectId }, 'could not find project to rename')
+    return
+  }
+  const oldProjectName = project.name
+  await Project.update({ _id: projectId }, { name: newName }).exec()
+  await TpdsUpdateSender.promises.moveEntity({
+    project_id: projectId,
+    project_name: oldProjectName,
+    newProjectName: newName
+  })
+}
 
-  setPublicAccessLevel(project_id, newAccessLevel, callback) {
-    if (callback == null) {
-      callback = function() {}
-    }
-    logger.log({ project_id, level: newAccessLevel }, 'set public access level')
-    // DEPRECATED: `READ_ONLY` and `READ_AND_WRITE` are still valid in, but should no longer
-    // be passed here. Remove after token-based access has been live for a while
-    if (
-      project_id != null &&
-      newAccessLevel != null &&
-      _.include(
-        [
-          PublicAccessLevels.READ_ONLY,
-          PublicAccessLevels.READ_AND_WRITE,
-          PublicAccessLevels.PRIVATE,
-          PublicAccessLevels.TOKEN_BASED
-        ],
-        newAccessLevel
-      )
-    ) {
-      return Project.update(
-        { _id: project_id },
-        { publicAccesLevel: newAccessLevel },
-        err => callback(err)
-      )
-    }
-  },
+async function validateProjectName(name) {
+  if (name == null || name.length === 0) {
+    throw new Errors.InvalidNameError('Project name cannot be blank')
+  }
+  if (name.length > MAX_PROJECT_NAME_LENGTH) {
+    throw new Errors.InvalidNameError('Project name is too long')
+  }
+  if (name.indexOf('/') > -1) {
+    throw new Errors.InvalidNameError(
+      'Project name cannot contain / characters'
+    )
+  }
+  if (name.indexOf('\\') > -1) {
+    throw new Errors.InvalidNameError(
+      'Project name cannot contain \\ characters'
+    )
+  }
+}
 
-  ensureTokensArePresent(project_id, callback) {
-    if (callback == null) {
-      callback = function(err, tokens) {}
-    }
-    return ProjectGetter.getProject(project_id, { tokens: 1 }, function(
-      err,
-      project
-    ) {
-      if (err != null) {
-        return callback(err)
-      }
-      if (
-        project.tokens != null &&
-        project.tokens.readOnly != null &&
-        project.tokens.readAndWrite != null
-      ) {
-        logger.log({ project_id }, 'project already has tokens')
-        return callback(null, project.tokens)
-      } else {
-        logger.log(
-          {
-            project_id,
-            has_tokens: project.tokens != null,
-            has_readOnly:
-              __guard__(
-                project != null ? project.tokens : undefined,
-                x => x.readOnly
-              ) != null,
-            has_readAndWrite:
-              __guard__(
-                project != null ? project.tokens : undefined,
-                x1 => x1.readAndWrite
-              ) != null
-          },
-          'generating tokens for project'
-        )
-        return ProjectDetailsHandler._generateTokens(project, function(err) {
-          if (err != null) {
-            return callback(err)
-          }
-          return Project.update(
-            { _id: project_id },
-            { $set: { tokens: project.tokens } },
-            function(err) {
-              if (err != null) {
-                return callback(err)
-              }
-              return callback(null, project.tokens)
-            }
-          )
-        })
-      }
-    })
-  },
+// FIXME: we should put a lock around this to make it completely safe, but we would need to do that at
+// the point of project creation, rather than just checking the name at the start of the import.
+// If we later move this check into ProjectCreationHandler we can ensure all new projects are created
+// with a unique name.  But that requires thinking through how we would handle incoming projects from
+// dropbox for example.
+async function generateUniqueName(userId, name, suffixes = []) {
+  const allUsersProjectNames = await ProjectGetter.promises.findAllUsersProjects(
+    userId,
+    { name: 1 }
+  )
+  // allUsersProjectNames is returned as a hash {owned: [name1, name2, ...], readOnly: [....]}
+  // collect all of the names and flatten them into a single array
+  const projectNameList = _.pluck(
+    _.flatten(_.values(allUsersProjectNames)),
+    'name'
+  )
+  const uniqueName = await ProjectHelper.promises.ensureNameIsUnique(
+    projectNameList,
+    name,
+    suffixes,
+    MAX_PROJECT_NAME_LENGTH
+  )
+  return uniqueName
+}
 
-  _generateTokens(project, callback) {
-    if (callback == null) {
-      callback = function(err) {}
-    }
-    if (!project.tokens) {
-      project.tokens = {}
-    }
-    const { tokens } = project
-    if (tokens.readAndWrite == null) {
-      const { token, numericPrefix } = ProjectTokenGenerator.readAndWriteToken()
-      tokens.readAndWrite = token
-      tokens.readAndWritePrefix = numericPrefix
-    }
-    if (tokens.readOnly == null) {
-      return ProjectTokenGenerator.generateUniqueReadOnlyToken(function(
-        err,
-        token
-      ) {
-        if (err != null) {
-          return callback(err)
-        }
-        tokens.readOnly = token
-        return callback()
-      })
-    } else {
-      return callback()
-    }
+function fixProjectName(name) {
+  if (name === '' || !name) {
+    name = 'Untitled'
+  }
+  if (name.indexOf('/') > -1) {
+    // v2 does not allow / in a project name
+    name = name.replace(/\//g, '-')
+  }
+  if (name.indexOf('\\') > -1) {
+    // backslashes in project name will prevent syncing to dropbox
+    name = name.replace(/\\/g, '')
   }
+  if (name.length > MAX_PROJECT_NAME_LENGTH) {
+    name = name.substr(0, MAX_PROJECT_NAME_LENGTH)
+  }
+  return name
 }
 
-function __guard__(value, transform) {
-  return typeof value !== 'undefined' && value !== null
-    ? transform(value)
-    : undefined
+async function setPublicAccessLevel(projectId, newAccessLevel) {
+  logger.log({ projectId, level: newAccessLevel }, 'set public access level')
+  // DEPRECATED: `READ_ONLY` and `READ_AND_WRITE` are still valid in, but should no longer
+  // be passed here. Remove after token-based access has been live for a while
+  if (
+    projectId != null &&
+    newAccessLevel != null &&
+    _.include(
+      [
+        PublicAccessLevels.READ_ONLY,
+        PublicAccessLevels.READ_AND_WRITE,
+        PublicAccessLevels.PRIVATE,
+        PublicAccessLevels.TOKEN_BASED
+      ],
+      newAccessLevel
+    )
+  ) {
+    await Project.update(
+      { _id: projectId },
+      { publicAccesLevel: newAccessLevel }
+    ).exec()
+  }
 }
 
-const promises = {
-  generateUniqueName: promisify(ProjectDetailsHandler.generateUniqueName)
+async function ensureTokensArePresent(projectId) {
+  const project = await ProjectGetter.promises.getProject(projectId, {
+    tokens: 1
+  })
+  if (
+    project.tokens != null &&
+    project.tokens.readOnly != null &&
+    project.tokens.readAndWrite != null
+  ) {
+    logger.log({ projectId }, 'project already has tokens')
+    return project.tokens
+  }
+  const hasTokens = project.tokens != null
+  const hasReadOnly = hasTokens && project.tokens.readOnly != null
+  const hasReadAndWrite = hasTokens && project.tokens.readAndWrite != null
+  logger.log(
+    { projectId, hasTokens, hasReadOnly, hasReadAndWrite },
+    'generating tokens for project'
+  )
+  await _generateTokens(project)
+  await Project.update(
+    { _id: projectId },
+    { $set: { tokens: project.tokens } }
+  ).exec()
+  return project.tokens
 }
 
-ProjectDetailsHandler.promises = promises
-
-module.exports = ProjectDetailsHandler
+async function _generateTokens(project, callback) {
+  if (!project.tokens) {
+    project.tokens = {}
+  }
+  const { tokens } = project
+  if (tokens.readAndWrite == null) {
+    const { token, numericPrefix } = ProjectTokenGenerator.readAndWriteToken()
+    tokens.readAndWrite = token
+    tokens.readAndWritePrefix = numericPrefix
+  }
+  if (tokens.readOnly == null) {
+    tokens.readOnly = await ProjectTokenGenerator.promises.generateUniqueReadOnlyToken()
+  }
+}

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

@@ -14,7 +14,6 @@
  * DS207: Consider shorter variations of null checks
  * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
  */
-let ProjectEntityHandler, self
 const _ = require('underscore')
 const async = require('async')
 const path = require('path')
@@ -25,8 +24,9 @@ const Errors = require('../Errors/Errors')
 const { Project } = require('../../models/Project')
 const ProjectGetter = require('./ProjectGetter')
 const TpdsUpdateSender = require('../ThirdPartyDataStore/TpdsUpdateSender')
+const { promisifyAll } = require('../../util/promises')
 
-module.exports = ProjectEntityHandler = self = {
+const ProjectEntityHandler = {
   getAllDocs(project_id, callback) {
     logger.log({ project_id }, 'getting all docs for project')
 
@@ -46,7 +46,10 @@ module.exports = ProjectEntityHandler = self = {
         docContents[docContent._id] = docContent
       }
 
-      return self._getAllFolders(project_id, function(error, folders) {
+      return ProjectEntityHandler._getAllFolders(project_id, function(
+        error,
+        folders
+      ) {
         if (folders == null) {
           folders = {}
         }
@@ -79,7 +82,10 @@ module.exports = ProjectEntityHandler = self = {
 
   getAllFiles(project_id, callback) {
     logger.log({ project_id }, 'getting all files for project')
-    return self._getAllFolders(project_id, function(err, folders) {
+    return ProjectEntityHandler._getAllFolders(project_id, function(
+      err,
+      folders
+    ) {
       if (folders == null) {
         folders = {}
       }
@@ -104,13 +110,16 @@ module.exports = ProjectEntityHandler = self = {
       if (err != null) {
         return callback(err)
       }
-      return self.getAllEntitiesFromProject(project, callback)
+      return ProjectEntityHandler.getAllEntitiesFromProject(project, callback)
     })
   },
 
   getAllEntitiesFromProject(project, callback) {
     logger.log({ project }, 'getting all entities for project')
-    return self._getAllFoldersFromProject(project, function(err, folders) {
+    return ProjectEntityHandler._getAllFoldersFromProject(project, function(
+      err,
+      folders
+    ) {
       if (folders == null) {
         folders = {}
       }
@@ -147,13 +156,16 @@ module.exports = ProjectEntityHandler = self = {
       if (project == null) {
         return callback(Errors.NotFoundError('no project'))
       }
-      return self.getAllDocPathsFromProject(project, callback)
+      return ProjectEntityHandler.getAllDocPathsFromProject(project, callback)
     })
   },
 
   getAllDocPathsFromProject(project, callback) {
     logger.log({ project }, 'getting all docs for project')
-    return self._getAllFoldersFromProject(project, function(err, folders) {
+    return ProjectEntityHandler._getAllFoldersFromProject(project, function(
+      err,
+      folders
+    ) {
       if (folders == null) {
         folders = {}
       }
@@ -191,7 +203,10 @@ module.exports = ProjectEntityHandler = self = {
           return callback(error)
         }
         const requests = []
-        return self.getAllDocs(project_id, function(error, docs) {
+        return ProjectEntityHandler.getAllDocs(project_id, function(
+          error,
+          docs
+        ) {
           if (error != null) {
             return callback(error)
           }
@@ -211,7 +226,10 @@ module.exports = ProjectEntityHandler = self = {
                 )
               ))(docPath, doc)
           }
-          return self.getAllFiles(project_id, function(error, files) {
+          return ProjectEntityHandler.getAllFiles(project_id, function(
+            error,
+            files
+          ) {
             if (error != null) {
               return callback(error)
             }
@@ -268,7 +286,7 @@ module.exports = ProjectEntityHandler = self = {
       if (project == null) {
         return callback(Errors.NotFoundError('no project'))
       }
-      return self._getAllFoldersFromProject(project, callback)
+      return ProjectEntityHandler._getAllFoldersFromProject(project, callback)
     })
   },
 
@@ -295,3 +313,6 @@ module.exports = ProjectEntityHandler = self = {
     return callback(null, folders)
   }
 }
+
+ProjectEntityHandler.promises = promisifyAll(ProjectEntityHandler)
+module.exports = ProjectEntityHandler

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

@@ -13,18 +13,18 @@
  * DS207: Consider shorter variations of null checks
  * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
  */
-let ProjectGetter
 const mongojs = require('../../infrastructure/mongojs')
 const metrics = require('metrics-sharelatex')
 const { db } = mongojs
 const { ObjectId } = mongojs
 const async = require('async')
+const { promisifyAll } = require('../../util/promises')
 const { Project } = require('../../models/Project')
 const logger = require('logger-sharelatex')
 const LockManager = require('../../infrastructure/LockManager')
 const { DeletedProject } = require('../../models/DeletedProject')
 
-module.exports = ProjectGetter = {
+const ProjectGetter = {
   EXCLUDE_DEPTH: 8,
 
   getProjectWithoutDocLines(project_id, callback) {
@@ -221,3 +221,6 @@ module.exports = ProjectGetter = {
 ;['getProject', 'getProjectWithoutDocLines'].map(method =>
   metrics.timeAsyncMethod(ProjectGetter, method, 'mongo.ProjectGetter', logger)
 )
+
+ProjectGetter.promises = promisifyAll(ProjectGetter)
+module.exports = ProjectGetter

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

@@ -11,7 +11,6 @@
  * DS207: Consider shorter variations of null checks
  * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
  */
-let ProjectHelper
 const ENGINE_TO_COMPILER_MAP = {
   latex_dvipdf: 'latex',
   pdflatex: 'pdflatex',
@@ -19,8 +18,9 @@ const ENGINE_TO_COMPILER_MAP = {
   lualatex: 'lualatex'
 }
 const { ObjectId } = require('../../infrastructure/mongojs')
+const { promisify } = require('util')
 
-module.exports = ProjectHelper = {
+const ProjectHelper = {
   compilerFromV1Engine(engine) {
     return ENGINE_TO_COMPILER_MAP[engine]
   },
@@ -58,13 +58,13 @@ module.exports = ProjectHelper = {
       suffixes = []
     }
     if (callback == null) {
-      callback = function(error, name, changed) {}
+      callback = function(error, name) {}
     }
     const allNames = new Set(nameList)
     const isUnique = x => !allNames.has(x)
     // check if the supplied name is already unique
     if (isUnique(name)) {
-      return callback(null, name, false)
+      return callback(null, name)
     }
     // the name already exists, try adding the user-supplied suffixes to generate a unique name
     for (let suffix of Array.from(suffixes)) {
@@ -74,7 +74,7 @@ module.exports = ProjectHelper = {
         maxLength
       )
       if (isUnique(candidateName)) {
-        return callback(null, candidateName, true)
+        return callback(null, candidateName)
       }
     }
     // if there are no (more) suffixes, use a numeric one
@@ -84,7 +84,7 @@ module.exports = ProjectHelper = {
       maxLength
     )
     if (uniqueName != null) {
-      return callback(null, uniqueName, true)
+      return callback(null, uniqueName)
     } else {
       return callback(
         new Error(`Failed to generate a unique name for: ${name}`)
@@ -129,3 +129,8 @@ module.exports = ProjectHelper = {
     return null
   }
 }
+
+ProjectHelper.promises = {
+  ensureNameIsUnique: promisify(ProjectHelper.ensureNameIsUnique)
+}
+module.exports = ProjectHelper

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

@@ -10,17 +10,17 @@
  * DS207: Consider shorter variations of null checks
  * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
  */
-let ProjectTokenGenerator
 const crypto = require('crypto')
 const V1Api = require('../V1/V1Api')
 const Async = require('async')
 const logger = require('logger-sharelatex')
+const { promisify } = require('util')
 
 // This module mirrors the token generation in Overleaf (`random_token.rb`),
 // for the purposes of implementing token-based project access, like the
 // 'unlisted-projects' feature in Overleaf
 
-module.exports = ProjectTokenGenerator = {
+const ProjectTokenGenerator = {
   // (From Overleaf `random_token.rb`)
   //   Letters (not numbers! see generate_token) used in tokens. They're all
   //   consonants, to avoid embarassing words (I can't think of any that use only
@@ -105,3 +105,10 @@ module.exports = ProjectTokenGenerator = {
     )
   }
 }
+
+ProjectTokenGenerator.promises = {
+  generateUniqueReadOnlyToken: promisify(
+    ProjectTokenGenerator.generateUniqueReadOnlyToken
+  )
+}
+module.exports = ProjectTokenGenerator

services/web/app/src/Features/ThirdPartyDataStore/TpdsUpdateSender.js

@@ -13,7 +13,7 @@
  * DS207: Consider shorter variations of null checks
  * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
  */
-let TpdsUpdateSender, tpdsUrl
+let tpdsUrl
 const settings = require('settings-sharelatex')
 const logger = require('logger-sharelatex')
 const path = require('path')
@@ -22,6 +22,7 @@ const keys = require('../../infrastructure/Keys')
 const metrics = require('metrics-sharelatex')
 const request = require('request')
 const CollaboratorsHandler = require('../Collaborators/CollaboratorsHandler')
+const { promisifyAll } = require('../../util/promises')
 
 const buildPath = function(user_id, project_name, filePath) {
   let projectPath = path.join(project_name, '/', filePath)
@@ -44,7 +45,7 @@ if (settings.apis.thirdPartyDataStore.linode_url != null) {
   tpdsUrl = settings.apis.thirdPartyDataStore.url
 }
 
-module.exports = TpdsUpdateSender = {
+const TpdsUpdateSender = {
   _enqueue(group, method, job, callback) {
     if (!tpdsworkerEnabled()) {
       return callback()
@@ -321,3 +322,6 @@ var mergeProjectNameAndPath = function(project_name, path) {
   const fullPath = `/${project_name}/${path}`
   return fullPath
 }
+
+TpdsUpdateSender.promises = promisifyAll(TpdsUpdateSender)
+module.exports = TpdsUpdateSender

services/web/app/src/Features/User/UserGetter.js

@@ -11,17 +11,17 @@
  * DS207: Consider shorter variations of null checks
  * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
  */
-let UserGetter
 const mongojs = require('../../infrastructure/mongojs')
 const metrics = require('metrics-sharelatex')
 const logger = require('logger-sharelatex')
 const { db } = mongojs
 const { ObjectId } = mongojs
+const { promisifyAll } = require('../../util/promises')
 const { getUserAffiliations } = require('../Institutions/InstitutionsAPI')
 const Errors = require('../Errors/Errors')
 const Features = require('../../infrastructure/Features')
 
-module.exports = UserGetter = {
+const UserGetter = {
   getUser(query, projection, callback) {
     if (callback == null) {
       callback = function(error, user) {}
@@ -248,3 +248,6 @@ var decorateFullEmails = (defaultEmail, emailsData, affiliationsData) =>
 ].map(method =>
   metrics.timeAsyncMethod(UserGetter, method, 'mongo.UserGetter', logger)
 )
+
+UserGetter.promises = promisifyAll(UserGetter)
+module.exports = UserGetter

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

@@ -106,7 +106,9 @@ describe('ProjectDeleter', function() {
     }
 
     this.ProjectDetailsHandler = {
-      generateUniqueName: sinon.stub().yields(null, this.project.name)
+      promises: {
+        generateUniqueName: sinon.stub().resolves(this.project.name)
+      }
     }
 
     this.db = {
@@ -533,7 +535,7 @@ describe('ProjectDeleter', function() {
       this.ProjectDeleter.undeleteProject(this.project._id, err => {
         expect(err).not.to.exist
         sinon.assert.calledWith(
-          this.ProjectDetailsHandler.generateUniqueName,
+          this.ProjectDetailsHandler.promises.generateUniqueName,
           this.project.owner_ref
         )
         done()
@@ -544,7 +546,7 @@ describe('ProjectDeleter', function() {
       this.ProjectDeleter.undeleteProject(this.project._id, err => {
         expect(err).not.to.exist
         sinon.assert.calledWith(
-          this.ProjectDetailsHandler.generateUniqueName,
+          this.ProjectDetailsHandler.promises.generateUniqueName,
           this.project.owner_ref,
           this.project.name + ' (Restored)'
         )

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

@@ -1,25 +1,9 @@
-/* eslint-disable
-    handle-callback-err,
-    max-len,
-    no-return-assign,
-    no-unused-vars,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS101: Remove unnecessary use of Array.from
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const should = require('chai').should()
-const modulePath = '../../../../app/src/Features/Project/ProjectDetailsHandler'
 const Errors = require('../../../../app/src/Features/Errors/Errors')
 const SandboxedModule = require('sandboxed-module')
 const sinon = require('sinon')
-const { assert } = require('chai')
 const { expect } = require('chai')
-require('chai').should()
+
+const MODULE_PATH = '../../../../app/src/Features/Project/ProjectDetailsHandler'
 
 describe('ProjectDetailsHandler', function() {
   beforeEach(function() {
@@ -34,24 +18,53 @@ describe('ProjectDetailsHandler', function() {
     }
     this.user = { features: 'mock-features' }
     this.ProjectGetter = {
-      getProjectWithoutDocLines: sinon
-        .stub()
-        .callsArgWith(1, null, this.project),
-      getProject: sinon.stub().callsArgWith(2, null, this.project)
+      promises: {
+        getProjectWithoutDocLines: sinon.stub().resolves(this.project),
+        getProject: sinon.stub().resolves(this.project),
+        findAllUsersProjects: sinon.stub().resolves({
+          owned: [],
+          readAndWrite: [],
+          readOnly: [],
+          tokenReadAndWrite: [],
+          tokenReadOnly: []
+        })
+      }
     }
     this.ProjectModel = {
-      update: sinon.stub(),
-      findOne: sinon.stub()
+      update: sinon.stub().returns({
+        exec: sinon.stub().resolves()
+      })
+    }
+    this.UserGetter = {
+      promises: {
+        getUser: sinon.stub().resolves(this.user)
+      }
+    }
+    this.TpdsUpdateSender = {
+      promises: {
+        moveEntity: sinon.stub().resolves()
+      }
     }
-    this.UserGetter = { getUser: sinon.stub().callsArgWith(1, null, this.user) }
-    this.tpdsUpdateSender = { moveEntity: sinon.stub().callsArgWith(1) }
     this.ProjectEntityHandler = {
-      flushProjectToThirdPartyDataStore: sinon.stub().callsArg(1)
+      promises: {
+        flushProjectToThirdPartyDataStore: sinon.stub().resolves()
+      }
     }
     this.CollaboratorsHandler = {
-      removeUserFromProject: sinon.stub().callsArg(2)
+      promises: {
+        removeUserFromProject: sinon.stub().resolves()
+      }
+    }
+    this.ProjectTokenGenerator = {
+      readAndWriteToken: sinon.stub(),
+      promises: {
+        generateUniqueReadOnlyToken: sinon.stub()
+      }
     }
-    return (this.handler = SandboxedModule.require(modulePath, {
+    this.settings = {
+      defaultFeatures: 'default-features'
+    }
+    this.handler = SandboxedModule.require(MODULE_PATH, {
       globals: {
         console: console
       },
@@ -61,7 +74,7 @@ describe('ProjectDetailsHandler', function() {
           Project: this.ProjectModel
         },
         '../User/UserGetter': this.UserGetter,
-        '../ThirdPartyDataStore/TpdsUpdateSender': this.tpdsUpdateSender,
+        '../ThirdPartyDataStore/TpdsUpdateSender': this.TpdsUpdateSender,
         './ProjectEntityHandler': this.ProjectEntityHandler,
         '../Collaborators/CollaboratorsHandler': this.CollaboratorsHandler,
         'logger-sharelatex': {
@@ -69,308 +82,264 @@ describe('ProjectDetailsHandler', function() {
           warn() {},
           err() {}
         },
-        './ProjectTokenGenerator': (this.ProjectTokenGenerator = {}),
-        'settings-sharelatex': (this.settings = {
-          defaultFeatures: 'default-features'
-        })
+        './ProjectTokenGenerator': this.ProjectTokenGenerator,
+        '../Errors/Errors': Errors,
+        'settings-sharelatex': this.settings
       }
-    }))
+    })
   })
 
   describe('getDetails', function() {
-    it('should find the project and owner', function(done) {
-      return this.handler.getDetails(this.project_id, (err, details) => {
-        details.name.should.equal(this.project.name)
-        details.description.should.equal(this.project.description)
-        details.compiler.should.equal(this.project.compiler)
-        details.features.should.equal(this.user.features)
-        assert.equal(details.something, undefined)
-        return done()
-      })
+    it('should find the project and owner', async function() {
+      const details = await this.handler.promises.getDetails(this.project_id)
+      details.name.should.equal(this.project.name)
+      details.description.should.equal(this.project.description)
+      details.compiler.should.equal(this.project.compiler)
+      details.features.should.equal(this.user.features)
+      expect(details.something).to.be.undefined
     })
 
-    it('should find overleaf metadata if it exists', function(done) {
+    it('should find overleaf metadata if it exists', async function() {
       this.project.overleaf = { id: 'id' }
-      return this.handler.getDetails(this.project_id, (err, details) => {
-        details.overleaf.should.equal(this.project.overleaf)
-        assert.equal(details.something, undefined)
-        return done()
-      })
+      const details = await this.handler.promises.getDetails(this.project_id)
+      details.overleaf.should.equal(this.project.overleaf)
+      expect(details.something).to.be.undefined
     })
 
-    it('should return an error for a non-existent project', function(done) {
-      this.ProjectGetter.getProject.callsArg(2, null, null)
-      const err = new Errors.NotFoundError('project not found')
-      return this.handler.getDetails(
-        '0123456789012345678901234',
-        (error, details) => {
-          err.should.eql(error)
-          return done()
-        }
-      )
+    it('should return an error for a non-existent project', async function() {
+      this.ProjectGetter.promises.getProject.resolves(null)
+      await expect(
+        this.handler.promises.getDetails('0123456789012345678901234')
+      ).to.be.rejectedWith(Errors.NotFoundError)
     })
 
-    it('should return the default features if no owner found', function(done) {
-      this.UserGetter.getUser.callsArgWith(1, null, null)
-      return this.handler.getDetails(this.project_id, (err, details) => {
-        details.features.should.equal(this.settings.defaultFeatures)
-        return done()
-      })
+    it('should return the default features if no owner found', async function() {
+      this.UserGetter.promises.getUser.resolves(null)
+      const details = await this.handler.promises.getDetails(this.project_id)
+      details.features.should.equal(this.settings.defaultFeatures)
     })
 
-    it('should return the error', function(done) {
-      const error = 'some error'
-      this.ProjectGetter.getProject.callsArgWith(2, error)
-      return this.handler.getDetails(this.project_id, err => {
-        err.should.equal(error)
-        return done()
-      })
+    it('should rethrow any error', async function() {
+      this.ProjectGetter.promises.getProject.rejects(new Error('boom'))
+      await expect(this.handler.promises.getDetails(this.project_id)).to.be
+        .rejected
     })
   })
 
   describe('transferOwnership', function() {
     beforeEach(function() {
-      this.handler.generateUniqueName = sinon
-        .stub()
-        .callsArgWith(2, null, 'teapot')
-      return this.ProjectModel.update.callsArgWith(2)
-    })
-
-    it("should return a not found error if the project can't be found", function(done) {
-      this.ProjectGetter.getProject.callsArgWith(2)
-      return this.handler.transferOwnership('abc', '123', err => {
-        err.should.exist
-        err.name.should.equal('NotFoundError')
-        return done()
+      this.ProjectGetter.promises.findAllUsersProjects.resolves({
+        owned: [{ name: this.project.name }],
+        readAndWrite: [],
+        readOnly: [],
+        tokenReadAndWrite: [],
+        tokenReadOnly: []
       })
     })
 
-    it("should return a not found error if the user can't be found", function(done) {
-      this.ProjectGetter.getProject.callsArgWith(2)
-      return this.handler.transferOwnership('abc', '123', err => {
-        err.should.exist
-        err.name.should.equal('NotFoundError')
-        return done()
-      })
+    it("should return a not found error if the project can't be found", async function() {
+      this.ProjectGetter.promises.getProject.resolves(null)
+      await expect(
+        this.handler.promises.transferOwnership('abc', '123')
+      ).to.be.rejectedWith(Errors.NotFoundError)
+    })
+
+    it("should return a not found error if the user can't be found", async function() {
+      this.UserGetter.promises.getUser.resolves(null)
+      await expect(
+        this.handler.promises.transferOwnership('abc', '123')
+      ).to.be.rejectedWith(Errors.NotFoundError)
     })
 
-    it('should return an error if user cannot be removed as collaborator ', function(done) {
-      const errorMessage = 'user-cannot-be-removed'
-      this.CollaboratorsHandler.removeUserFromProject.callsArgWith(
-        2,
-        errorMessage
+    it('should return an error if user cannot be removed as collaborator ', async function() {
+      this.CollaboratorsHandler.promises.removeUserFromProject.rejects(
+        new Error('user-cannot-be-removed')
       )
-      return this.handler.transferOwnership('abc', '123', err => {
-        err.should.exist
-        err.should.equal(errorMessage)
-        return done()
-      })
+      await expect(this.handler.promises.transferOwnership('abc', '123')).to.be
+        .rejected
     })
 
-    it('should transfer ownership of the project', function(done) {
-      return this.handler.transferOwnership('abc', '123', () => {
-        sinon.assert.calledWith(
-          this.ProjectModel.update,
-          { _id: 'abc' },
-          sinon.match({ $set: { name: 'teapot' } })
-        )
-        return done()
-      })
+    it('should transfer ownership of the project', async function() {
+      await this.handler.promises.transferOwnership('abc', '123')
+      expect(this.ProjectModel.update).to.have.been.calledWith(
+        { _id: 'abc' },
+        sinon.match({ $set: { owner_ref: '123' } })
+      )
     })
 
-    it("should remove the user from the project's collaborators", function(done) {
-      return this.handler.transferOwnership('abc', '123', () => {
-        sinon.assert.calledWith(
-          this.CollaboratorsHandler.removeUserFromProject,
-          'abc',
-          '123'
-        )
-        return done()
-      })
+    it("should remove the user from the project's collaborators", async function() {
+      await this.handler.promises.transferOwnership('abc', '123')
+      expect(
+        this.CollaboratorsHandler.promises.removeUserFromProject
+      ).to.have.been.calledWith('abc', '123')
     })
 
-    it('should flush the project to tpds', function(done) {
-      return this.handler.transferOwnership('abc', '123', () => {
-        sinon.assert.calledWith(
-          this.ProjectEntityHandler.flushProjectToThirdPartyDataStore,
-          'abc'
-        )
-        return done()
-      })
+    it('should flush the project to tpds', async function() {
+      await this.handler.promises.transferOwnership('abc', '123')
+      expect(
+        this.ProjectEntityHandler.promises.flushProjectToThirdPartyDataStore
+      ).to.have.been.calledWith('abc')
     })
 
-    it('should generate a unique name for the project', function(done) {
-      return this.handler.transferOwnership('abc', '123', () => {
-        sinon.assert.calledWith(
-          this.handler.generateUniqueName,
-          '123',
-          this.project.name
-        )
-        return done()
-      })
+    it('should generate a unique name for the project', async function() {
+      await this.handler.promises.transferOwnership('abc', '123')
+      expect(this.ProjectModel.update).to.have.been.calledWith(
+        { _id: 'abc' },
+        sinon.match({ $set: { name: `${this.project.name} (1)` } })
+      )
     })
 
-    it('should append the supplied suffix to the project name, if passed', function(done) {
-      return this.handler.transferOwnership('abc', '123', ' wombat', () => {
-        sinon.assert.calledWith(
-          this.handler.generateUniqueName,
-          '123',
-          `${this.project.name} wombat`
-        )
-        return done()
-      })
+    it('should append the supplied suffix to the project name, if passed', async function() {
+      await this.handler.promises.transferOwnership('abc', '123', ' wombat')
+      expect(this.ProjectModel.update).to.have.been.calledWith(
+        { _id: 'abc' },
+        sinon.match({ $set: { name: `${this.project.name} wombat` } })
+      )
     })
   })
 
   describe('getProjectDescription', function() {
-    it('should make a call to mongo just for the description', function(done) {
-      this.ProjectGetter.getProject.callsArgWith(2)
-      return this.handler.getProjectDescription(
+    it('should make a call to mongo just for the description', async function() {
+      this.ProjectGetter.promises.getProject.resolves()
+      await this.handler.promises.getProjectDescription(this.project_id)
+      expect(this.ProjectGetter.promises.getProject).to.have.been.calledWith(
         this.project_id,
-        (err, description) => {
-          this.ProjectGetter.getProject
-            .calledWith(this.project_id, { description: true })
-            .should.equal(true)
-          return done()
-        }
+        { description: true }
       )
     })
 
-    it('should return what the mongo call returns', function(done) {
-      const err = 'error'
-      const description = 'cool project'
-      this.ProjectGetter.getProject.callsArgWith(2, err, { description })
-      return this.handler.getProjectDescription(
-        this.project_id,
-        (returnedErr, returnedDescription) => {
-          err.should.equal(returnedErr)
-          description.should.equal(returnedDescription)
-          return done()
-        }
+    it('should return what the mongo call returns', async function() {
+      const expectedDescription = 'cool project'
+      this.ProjectGetter.promises.getProject.resolves({
+        description: expectedDescription
+      })
+      const description = await this.handler.promises.getProjectDescription(
+        this.project_id
       )
+      expect(description).to.equal(expectedDescription)
     })
   })
 
   describe('setProjectDescription', function() {
     beforeEach(function() {
-      return (this.description = 'updated teh description')
+      this.description = 'updated teh description'
     })
 
-    it('should update the project detials', function(done) {
-      this.ProjectModel.update.callsArgWith(2)
-      return this.handler.setProjectDescription(
+    it('should update the project detials', async function() {
+      await this.handler.promises.setProjectDescription(
         this.project_id,
-        this.description,
-        () => {
-          this.ProjectModel.update
-            .calledWith(
-              { _id: this.project_id },
-              { description: this.description }
-            )
-            .should.equal(true)
-          return done()
-        }
+        this.description
+      )
+      expect(this.ProjectModel.update).to.have.been.calledWith(
+        { _id: this.project_id },
+        { description: this.description }
       )
     })
   })
 
   describe('renameProject', function() {
     beforeEach(function() {
-      this.handler.validateProjectName = sinon.stub().yields()
-      this.ProjectModel.update.callsArgWith(2)
-      return (this.newName = 'new name here')
-    })
-
-    it('should update the project with the new name', function(done) {
-      const newName = 'new name here'
-      return this.handler.renameProject(this.project_id, this.newName, () => {
-        this.ProjectModel.update
-          .calledWith({ _id: this.project_id }, { name: this.newName })
-          .should.equal(true)
-        return done()
-      })
+      this.newName = 'new name here'
     })
 
-    it('should tell the tpdsUpdateSender', function(done) {
-      return this.handler.renameProject(this.project_id, this.newName, () => {
-        this.tpdsUpdateSender.moveEntity
-          .calledWith({
-            project_id: this.project_id,
-            project_name: this.project.name,
-            newProjectName: this.newName
-          })
-          .should.equal(true)
-        return done()
-      })
+    it('should update the project with the new name', async function() {
+      await this.handler.promises.renameProject(this.project_id, this.newName)
+      expect(this.ProjectModel.update).to.have.been.calledWith(
+        { _id: this.project_id },
+        { name: this.newName }
+      )
     })
 
-    it('should not do anything with an invalid name', function(done) {
-      this.handler.validateProjectName = sinon
-        .stub()
-        .yields(new Error('invalid name'))
-      return this.handler.renameProject(this.project_id, this.newName, () => {
-        this.tpdsUpdateSender.moveEntity.called.should.equal(false)
-        this.ProjectModel.update.called.should.equal(false)
-        return done()
-      })
+    it('should tell the TpdsUpdateSender', async function() {
+      await this.handler.promises.renameProject(this.project_id, this.newName)
+      expect(this.TpdsUpdateSender.promises.moveEntity).to.have.been.calledWith(
+        {
+          project_id: this.project_id,
+          project_name: this.project.name,
+          newProjectName: this.newName
+        }
+      )
+    })
+
+    it('should not do anything with an invalid name', async function() {
+      await expect(this.handler.promises.renameProject(this.project_id)).to.be
+        .rejected
+      expect(this.TpdsUpdateSender.promises.moveEntity).not.to.have.been.called
+      expect(this.ProjectModel.update).not.to.have.been.called
     })
   })
 
   describe('validateProjectName', function() {
-    it('should reject undefined names', function(done) {
-      return this.handler.validateProjectName(undefined, error => {
-        expect(error).to.exist
-        return done()
-      })
+    it('should reject undefined names', async function() {
+      await expect(this.handler.promises.validateProjectName(undefined)).to.be
+        .rejected
     })
 
-    it('should reject empty names', function(done) {
-      return this.handler.validateProjectName('', error => {
-        expect(error).to.exist
-        return done()
-      })
+    it('should reject empty names', async function() {
+      await expect(this.handler.promises.validateProjectName('')).to.be.rejected
     })
 
-    it('should reject names with /s', function(done) {
-      return this.handler.validateProjectName('foo/bar', error => {
-        expect(error).to.exist
-        return done()
-      })
+    it('should reject names with /s', async function() {
+      await expect(this.handler.promises.validateProjectName('foo/bar')).to.be
+        .rejected
     })
 
-    it('should reject names with \\s', function(done) {
-      return this.handler.validateProjectName('foo\\bar', error => {
-        expect(error).to.exist
-        return done()
-      })
+    it('should reject names with \\s', async function() {
+      await expect(this.handler.promises.validateProjectName('foo\\bar')).to.be
+        .rejected
     })
 
-    it('should reject long names', function(done) {
-      return this.handler.validateProjectName(
-        new Array(1000).join('a'),
-        error => {
-          expect(error).to.exist
-          return done()
-        }
-      )
+    it('should reject long names', async function() {
+      await expect(this.handler.promises.validateProjectName('a'.repeat(1000)))
+        .to.be.rejected
     })
 
-    it('should accept normal names', function(done) {
-      return this.handler.validateProjectName('foobar', error => {
-        expect(error).to.not.exist
-        return done()
-      })
+    it('should accept normal names', async function() {
+      await expect(this.handler.promises.validateProjectName('foobar')).to.be
+        .resolved
     })
   })
 
-  describe('ensureProjectNameIsUnique', function() {
+  describe('generateUniqueName', function() {
     beforeEach(function() {
-      this.result = {
+      this.longName = 'x'.repeat(this.handler.MAX_PROJECT_NAME_LENGTH - 5)
+      const usersProjects = {
         owned: [
           { _id: 1, name: 'name' },
           { _id: 2, name: 'name1' },
           { _id: 3, name: 'name11' },
-          { _id: 100, name: 'numeric' }
+          { _id: 100, name: 'numeric' },
+          { _id: 101, name: 'numeric (1)' },
+          { _id: 102, name: 'numeric (2)' },
+          { _id: 103, name: 'numeric (3)' },
+          { _id: 104, name: 'numeric (4)' },
+          { _id: 105, name: 'numeric (5)' },
+          { _id: 106, name: 'numeric (6)' },
+          { _id: 107, name: 'numeric (7)' },
+          { _id: 108, name: 'numeric (8)' },
+          { _id: 109, name: 'numeric (9)' },
+          { _id: 110, name: 'numeric (10)' },
+          { _id: 111, name: 'numeric (11)' },
+          { _id: 112, name: 'numeric (12)' },
+          { _id: 113, name: 'numeric (13)' },
+          { _id: 114, name: 'numeric (14)' },
+          { _id: 115, name: 'numeric (15)' },
+          { _id: 116, name: 'numeric (16)' },
+          { _id: 117, name: 'numeric (17)' },
+          { _id: 118, name: 'numeric (18)' },
+          { _id: 119, name: 'numeric (19)' },
+          { _id: 120, name: 'numeric (20)' },
+          { _id: 130, name: 'numeric (30)' },
+          { _id: 131, name: 'numeric (31)' },
+          { _id: 132, name: 'numeric (32)' },
+          { _id: 133, name: 'numeric (33)' },
+          { _id: 134, name: 'numeric (34)' },
+          { _id: 135, name: 'numeric (35)' },
+          { _id: 136, name: 'numeric (36)' },
+          { _id: 137, name: 'numeric (37)' },
+          { _id: 138, name: 'numeric (38)' },
+          { _id: 139, name: 'numeric (39)' },
+          { _id: 140, name: 'numeric (40)' }
         ],
         readAndWrite: [{ _id: 4, name: 'name2' }, { _id: 5, name: 'name22' }],
         readOnly: [{ _id: 6, name: 'name3' }, { _id: 7, name: 'name33' }],
@@ -381,240 +350,163 @@ describe('ProjectDetailsHandler', function() {
         tokenReadOnly: [
           { _id: 10, name: 'name5' },
           { _id: 11, name: 'name55' },
-          { _id: 12, name: 'x'.repeat(15) }
+          { _id: 12, name: this.longName }
         ]
       }
-      for (let i of Array.from(
-        [
-          1,
-          2,
-          3,
-          4,
-          5,
-          6,
-          7,
-          8,
-          9,
-          10,
-          11,
-          12,
-          13,
-          14,
-          15,
-          16,
-          17,
-          18,
-          19,
-          20
-        ].concat([30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40])
-      )) {
-        this.result.owned.push({ _id: 100 + i, name: `numeric (${i})` })
-      }
-      return (this.ProjectGetter.findAllUsersProjects = sinon
-        .stub()
-        .callsArgWith(2, null, this.result))
+      this.ProjectGetter.promises.findAllUsersProjects.resolves(usersProjects)
     })
 
-    it('should leave a unique name unchanged', function(done) {
-      return this.handler.ensureProjectNameIsUnique(
+    it('should leave a unique name unchanged', async function() {
+      const name = await this.handler.promises.generateUniqueName(
         this.user_id,
         'unique-name',
-        ['-test-suffix'],
-        (error, name, changed) => {
-          expect(name).to.equal('unique-name')
-          expect(changed).to.equal(false)
-          return done()
-        }
+        ['-test-suffix']
       )
+      expect(name).to.equal('unique-name')
     })
 
-    it('should append a suffix to an existing name', function(done) {
-      return this.handler.ensureProjectNameIsUnique(
+    it('should append a suffix to an existing name', async function() {
+      const name = await this.handler.promises.generateUniqueName(
         this.user_id,
         'name1',
-        ['-test-suffix'],
-        (error, name, changed) => {
-          expect(name).to.equal('name1-test-suffix')
-          expect(changed).to.equal(true)
-          return done()
-        }
+        ['-test-suffix']
       )
+      expect(name).to.equal('name1-test-suffix')
     })
 
-    it('should fallback to a second suffix when needed', function(done) {
-      return this.handler.ensureProjectNameIsUnique(
+    it('should fallback to a second suffix when needed', async function() {
+      const name = await this.handler.promises.generateUniqueName(
         this.user_id,
         'name1',
-        ['1', '-test-suffix'],
-        (error, name, changed) => {
-          expect(name).to.equal('name1-test-suffix')
-          expect(changed).to.equal(true)
-          return done()
-        }
+        ['1', '-test-suffix']
       )
+      expect(name).to.equal('name1-test-suffix')
     })
 
-    it('should truncate the name when append a suffix if the result is too long', function(done) {
-      this.handler.MAX_PROJECT_NAME_LENGTH = 20
-      return this.handler.ensureProjectNameIsUnique(
+    it('should truncate the name when append a suffix if the result is too long', async function() {
+      const name = await this.handler.promises.generateUniqueName(
         this.user_id,
-        'x'.repeat(15),
-        ['-test-suffix'],
-        (error, name, changed) => {
-          expect(name).to.equal('x'.repeat(8) + '-test-suffix')
-          expect(changed).to.equal(true)
-          return done()
-        }
+        this.longName,
+        ['-test-suffix']
+      )
+      expect(name).to.equal(
+        this.longName.substr(0, this.handler.MAX_PROJECT_NAME_LENGTH - 12) +
+          '-test-suffix'
       )
     })
 
-    it('should use a numeric index if no suffix is supplied', function(done) {
-      return this.handler.ensureProjectNameIsUnique(
+    it('should use a numeric index if no suffix is supplied', async function() {
+      const name = await this.handler.promises.generateUniqueName(
         this.user_id,
         'name1',
-        [],
-        (error, name, changed) => {
-          expect(name).to.equal('name1 (1)')
-          expect(changed).to.equal(true)
-          return done()
-        }
+        []
       )
+      expect(name).to.equal('name1 (1)')
     })
 
-    it('should use a numeric index if all suffixes are exhausted', function(done) {
-      return this.handler.ensureProjectNameIsUnique(
+    it('should use a numeric index if all suffixes are exhausted', async function() {
+      const name = await this.handler.promises.generateUniqueName(
         this.user_id,
         'name',
-        ['1', '11'],
-        (error, name, changed) => {
-          expect(name).to.equal('name (1)')
-          expect(changed).to.equal(true)
-          return done()
-        }
+        ['1', '11']
       )
+      expect(name).to.equal('name (1)')
     })
 
-    it('should find the next lowest available numeric index for the base name', function(done) {
-      return this.handler.ensureProjectNameIsUnique(
+    it('should find the next lowest available numeric index for the base name', async function() {
+      const name = await this.handler.promises.generateUniqueName(
         this.user_id,
         'numeric',
-        [],
-        (error, name, changed) => {
-          expect(name).to.equal('numeric (21)')
-          expect(changed).to.equal(true)
-          return done()
-        }
+        []
       )
+      expect(name).to.equal('numeric (21)')
     })
 
-    it('should find the next available numeric index when a numeric index is already present', function(done) {
-      return this.handler.ensureProjectNameIsUnique(
+    it('should find the next available numeric index when a numeric index is already present', async function() {
+      const name = await this.handler.promises.generateUniqueName(
         this.user_id,
         'numeric (5)',
-        [],
-        (error, name, changed) => {
-          expect(name).to.equal('numeric (21)')
-          expect(changed).to.equal(true)
-          return done()
-        }
+        []
       )
+      expect(name).to.equal('numeric (21)')
     })
 
-    it('should not find a numeric index lower than the one already present', function(done) {
-      return this.handler.ensureProjectNameIsUnique(
+    it('should not find a numeric index lower than the one already present', async function() {
+      const name = await this.handler.promises.generateUniqueName(
         this.user_id,
         'numeric (31)',
-        [],
-        (error, name, changed) => {
-          expect(name).to.equal('numeric (41)')
-          expect(changed).to.equal(true)
-          return done()
-        }
+        []
       )
+      expect(name).to.equal('numeric (41)')
     })
   })
 
   describe('fixProjectName', function() {
     it('should change empty names to Untitled', function() {
-      return expect(this.handler.fixProjectName('')).to.equal('Untitled')
+      expect(this.handler.fixProjectName('')).to.equal('Untitled')
     })
 
     it('should replace / with -', function() {
-      return expect(this.handler.fixProjectName('foo/bar')).to.equal('foo-bar')
+      expect(this.handler.fixProjectName('foo/bar')).to.equal('foo-bar')
     })
 
     it("should replace \\ with ''", function() {
-      return expect(this.handler.fixProjectName('foo \\ bar')).to.equal(
-        'foo  bar'
-      )
+      expect(this.handler.fixProjectName('foo \\ bar')).to.equal('foo  bar')
     })
 
     it('should truncate long names', function() {
-      return expect(
-        this.handler.fixProjectName(new Array(1000).join('a'))
-      ).to.equal('a'.repeat(150))
+      expect(this.handler.fixProjectName('a'.repeat(1000))).to.equal(
+        'a'.repeat(150)
+      )
     })
 
     it('should accept normal names', function() {
-      return expect(this.handler.fixProjectName('foobar')).to.equal('foobar')
+      expect(this.handler.fixProjectName('foobar')).to.equal('foobar')
     })
   })
 
   describe('setPublicAccessLevel', function() {
     beforeEach(function() {
-      this.ProjectModel.update.callsArgWith(2)
-      return (this.accessLevel = 'readOnly')
+      this.accessLevel = 'readOnly'
     })
 
-    it('should update the project with the new level', function(done) {
-      return this.handler.setPublicAccessLevel(
+    it('should update the project with the new level', async function() {
+      await this.handler.promises.setPublicAccessLevel(
         this.project_id,
-        this.accessLevel,
-        () => {
-          this.ProjectModel.update
-            .calledWith(
-              { _id: this.project_id },
-              { publicAccesLevel: this.accessLevel }
-            )
-            .should.equal(true)
-          return done()
-        }
+        this.accessLevel
+      )
+      expect(this.ProjectModel.update).to.have.been.calledWith(
+        { _id: this.project_id },
+        { publicAccesLevel: this.accessLevel }
       )
     })
 
-    it('should not produce an error', function(done) {
-      return this.handler.setPublicAccessLevel(
-        this.project_id,
-        this.accessLevel,
-        err => {
-          expect(err).to.not.exist
-          return done()
-        }
-      )
+    it('should not produce an error', async function() {
+      await expect(
+        this.handler.promises.setPublicAccessLevel(
+          this.project_id,
+          this.accessLevel
+        )
+      ).to.be.resolved
     })
 
     describe('when update produces an error', function() {
       beforeEach(function() {
-        return this.ProjectModel.update.callsArgWith(2, new Error('woops'))
+        this.ProjectModel.update.rejects(new Error('woops'))
       })
 
-      it('should produce an error', function(done) {
-        return this.handler.setPublicAccessLevel(
-          this.project_id,
-          this.accessLevel,
-          err => {
-            expect(err).to.exist
-            expect(err).to.be.instanceof(Error)
-            return done()
-          }
-        )
+      it('should produce an error', async function() {
+        await expect(
+          this.handler.promises.setPublicAccessLevel(
+            this.project_id,
+            this.accessLevel
+          )
+        ).to.be.rejected
       })
     })
   })
 
   describe('ensureTokensArePresent', function() {
-    beforeEach(function() {})
-
     describe('when the project has tokens', function() {
       beforeEach(function() {
         this.project = {
@@ -625,126 +517,90 @@ describe('ProjectDetailsHandler', function() {
             readAndWritePrefix: '42'
           }
         }
-        this.ProjectGetter.getProject = sinon
-          .stub()
-          .callsArgWith(2, null, this.project)
-        return (this.ProjectModel.update = sinon.stub())
+        this.ProjectGetter.promises.getProject.resolves(this.project)
       })
 
-      it('should get the project', function(done) {
-        return this.handler.ensureTokensArePresent(
+      it('should get the project', async function() {
+        await this.handler.promises.ensureTokensArePresent(this.project_id)
+        expect(this.ProjectGetter.promises.getProject).to.have.been.calledOnce
+        expect(this.ProjectGetter.promises.getProject).to.have.been.calledWith(
           this.project_id,
-          (err, tokens) => {
-            expect(this.ProjectGetter.getProject.callCount).to.equal(1)
-            expect(
-              this.ProjectGetter.getProject.calledWith(this.project_id, {
-                tokens: 1
-              })
-            ).to.equal(true)
-            return done()
+          {
+            tokens: 1
           }
         )
       })
 
-      it('should not update the project with new tokens', function(done) {
-        return this.handler.ensureTokensArePresent(
-          this.project_id,
-          (err, tokens) => {
-            expect(this.ProjectModel.update.callCount).to.equal(0)
-            return done()
-          }
-        )
+      it('should not update the project with new tokens', async function() {
+        await this.handler.promises.ensureTokensArePresent(this.project_id)
+        expect(this.ProjectModel.update).not.to.have.been.called
       })
 
-      it('should produce the tokens without error', function(done) {
-        return this.handler.ensureTokensArePresent(
-          this.project_id,
-          (err, tokens) => {
-            expect(err).to.not.exist
-            expect(tokens).to.deep.equal(this.project.tokens)
-            return done()
-          }
+      it('should produce the tokens without error', async function() {
+        const tokens = await this.handler.promises.ensureTokensArePresent(
+          this.project_id
         )
+        expect(tokens).to.deep.equal(this.project.tokens)
       })
     })
 
     describe('when tokens are missing', function() {
       beforeEach(function() {
         this.project = { _id: this.project_id }
-        this.ProjectGetter.getProject = sinon
-          .stub()
-          .callsArgWith(2, null, this.project)
+        this.ProjectGetter.promises.getProject.resolves(this.project)
         this.readOnlyToken = 'abc'
         this.readAndWriteToken = '42def'
         this.readAndWriteTokenPrefix = '42'
-        this.ProjectTokenGenerator.generateUniqueReadOnlyToken = sinon
-          .stub()
-          .callsArgWith(0, null, this.readOnlyToken)
-        this.ProjectTokenGenerator.readAndWriteToken = sinon.stub().returns({
+        this.ProjectTokenGenerator.promises.generateUniqueReadOnlyToken.resolves(
+          this.readOnlyToken
+        )
+        this.ProjectTokenGenerator.readAndWriteToken.returns({
           token: this.readAndWriteToken,
           numericPrefix: this.readAndWriteTokenPrefix
         })
-        return (this.ProjectModel.update = sinon.stub().callsArgWith(2, null))
       })
 
-      it('should get the project', function(done) {
-        return this.handler.ensureTokensArePresent(
+      it('should get the project', async function() {
+        await this.handler.promises.ensureTokensArePresent(this.project_id)
+        expect(this.ProjectGetter.promises.getProject).to.have.been.calledOnce
+        expect(this.ProjectGetter.promises.getProject).to.have.been.calledWith(
           this.project_id,
-          (err, tokens) => {
-            expect(this.ProjectGetter.getProject.callCount).to.equal(1)
-            expect(
-              this.ProjectGetter.getProject.calledWith(this.project_id, {
-                tokens: 1
-              })
-            ).to.equal(true)
-            return done()
+          {
+            tokens: 1
           }
         )
       })
 
-      it('should update the project with new tokens', function(done) {
-        return this.handler.ensureTokensArePresent(
-          this.project_id,
-          (err, tokens) => {
-            expect(
-              this.ProjectTokenGenerator.generateUniqueReadOnlyToken.callCount
-            ).to.equal(1)
-            expect(
-              this.ProjectTokenGenerator.readAndWriteToken.callCount
-            ).to.equal(1)
-            expect(this.ProjectModel.update.callCount).to.equal(1)
-            expect(
-              this.ProjectModel.update.calledWith(
-                { _id: this.project_id },
-                {
-                  $set: {
-                    tokens: {
-                      readOnly: this.readOnlyToken,
-                      readAndWrite: this.readAndWriteToken,
-                      readAndWritePrefix: this.readAndWriteTokenPrefix
-                    }
-                  }
-                }
-              )
-            ).to.equal(true)
-            return done()
+      it('should update the project with new tokens', async function() {
+        await this.handler.promises.ensureTokensArePresent(this.project_id)
+        expect(this.ProjectTokenGenerator.promises.generateUniqueReadOnlyToken)
+          .to.have.been.calledOnce
+        expect(this.ProjectTokenGenerator.readAndWriteToken).to.have.been
+          .calledOnce
+        expect(this.ProjectModel.update).to.have.been.calledOnce
+        expect(this.ProjectModel.update).to.have.been.calledWith(
+          { _id: this.project_id },
+          {
+            $set: {
+              tokens: {
+                readOnly: this.readOnlyToken,
+                readAndWrite: this.readAndWriteToken,
+                readAndWritePrefix: this.readAndWriteTokenPrefix
+              }
+            }
           }
         )
       })
 
-      it('should produce the tokens without error', function(done) {
-        return this.handler.ensureTokensArePresent(
-          this.project_id,
-          (err, tokens) => {
-            expect(err).to.not.exist
-            expect(tokens).to.deep.equal({
-              readOnly: this.readOnlyToken,
-              readAndWrite: this.readAndWriteToken,
-              readAndWritePrefix: this.readAndWriteTokenPrefix
-            })
-            return done()
-          }
+      it('should produce the tokens without error', async function() {
+        const tokens = await this.handler.promises.ensureTokensArePresent(
+          this.project_id
         )
+        expect(tokens).to.deep.equal({
+          readOnly: this.readOnlyToken,
+          readAndWrite: this.readAndWriteToken,
+          readAndWritePrefix: this.readAndWriteTokenPrefix
+        })
       })
     })
   })

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

@@ -135,4 +135,4 @@ describe('ProjectHelper', function() {
 })
 
 // describe "ensureNameIsUnique", ->
-// see tests for: ProjectDetailsHandler.ensureProjectNameIsUnique, which calls here.
+// see tests for: ProjectDetailsHandler.generateUniqueName, which calls here.