chore: updated test methods

packages/accounts-base/accounts_server.js

@@ -918,6 +918,12 @@ export class AccountsServer extends AccountsCommon {
     );
   };
 
+  /**
+   *
+   * @param userId
+   * @private
+   * @returns {Promise<void>}
+   */
   _clearAllLoginTokens(userId) {
     this.users.update(userId, {
       $set: {
@@ -1099,7 +1105,14 @@ export class AccountsServer extends AccountsCommon {
   // tests. oldestValidDate is simulate expiring tokens without waiting
   // for them to actually expire. userId is used by tests to only expire
   // tokens for the test user.
-  _expireTokens(oldestValidDate, userId) {
+  /**
+   *
+   * @param oldestValidDate
+   * @param userId
+   * @private
+   * @return {Promise<void>}
+   */
+  async _expireTokens(oldestValidDate, userId) {
     const tokenLifetimeMs = this._getTokenLifetimeMs();
 
     // when calling from a test with extra arguments, you must specify both!
@@ -1114,7 +1127,7 @@ export class AccountsServer extends AccountsCommon {
 
     // Backwards compatible with older versions of meteor that stored login token
     // timestamps as numbers.
-    this.users.update({ ...userFilter,
+    await this.users.update({ ...userFilter,
       $or: [
         { "services.resume.loginTokens.when": { $lt: oldestValidDate } },
         { "services.resume.loginTokens.when": { $lt: +oldestValidDate } }
@@ -1151,7 +1164,7 @@ export class AccountsServer extends AccountsCommon {
   };
 
   // Called by accounts-password
-  insertUserDoc(options, user) {
+  async insertUserDoc(options, user) {
     // - clone user document, to protect from modification
     // - add createdAt timestamp
     // - prepare an _id, so that you can modify other collections (eg
@@ -1196,7 +1209,7 @@ export class AccountsServer extends AccountsCommon {
 
     let userId;
     try {
-      userId = this.users.insert(fullUser);
+      userId = await this.users.insert(fullUser);
     } catch (e) {
       // XXX string parsing sucks, maybe
       // https://jira.mongodb.org/browse/SERVER-3069 will get fixed one day
@@ -1226,9 +1239,9 @@ export class AccountsServer extends AccountsCommon {
   /// CLEAN UP FOR `logoutOtherClients`
   ///
 
-  _deleteSavedTokensForUser(userId, tokensToDelete) {
+  async _deleteSavedTokensForUser(userId, tokensToDelete) {
     if (tokensToDelete) {
-      this.users.update(userId, {
+      await this.users.update(userId, {
         $unset: {
           "services.resume.haveLoginTokensToDelete": 1,
           "services.resume.loginTokensToDelete": 1
@@ -1247,16 +1260,23 @@ export class AccountsServer extends AccountsCommon {
     // shouldn't happen very often. We shouldn't put a delay here because
     // that would give a lot of power to an attacker with a stolen login
     // token and the ability to crash the server.
-    Meteor.startup(() => {
-      this.users.find({
+    Meteor.startup(async () => {
+      await this.users.find({
         "services.resume.haveLoginTokensToDelete": true
-      }, {fields: {
+      }, {
+        fields: {
           "services.resume.loginTokensToDelete": 1
-        }}).forEach(user => {
+        }
+      }).forEach(user => {
         this._deleteSavedTokensForUser(
           user._id,
           user.services.resume.loginTokensToDelete
-        );
+        )
+          // We don't need to wait for this to complete.
+          .then(_ => _)
+          .catch(err => {
+            console.log(err);
+          });
       });
     });
   };
@@ -1276,7 +1296,7 @@ export class AccountsServer extends AccountsCommon {
   // @returns {Object} Object with token and id keys, like the result
   //        of the "login" method.
   //
-  updateOrCreateUserFromExternalService(
+  async updateOrCreateUserFromExternalService(
     serviceName,
     serviceData,
     options
@@ -1311,9 +1331,7 @@ export class AccountsServer extends AccountsCommon {
     } else {
       selector[serviceIdKey] = serviceData.id;
     }
-
-    let user = this.users.findOne(selector, {fields: this._options.defaultFieldSelector});
-
+    let user = await this.users.findOne(selector, {fields: this._options.defaultFieldSelector});
     // Check to see if the developer has a custom way to find the user outside
     // of the general selectors above.
     if (!user && this._additionalFindUserOnExternalLogin) {
@@ -1337,7 +1355,7 @@ export class AccountsServer extends AccountsCommon {
     }
 
     if (user) {
-      pinEncryptedFieldsToUser(serviceData, user._id);
+      await pinEncryptedFieldsToUser(serviceData, user._id);
 
       let setAttrs = {};
       Object.keys(serviceData).forEach(key =>
@@ -1347,7 +1365,7 @@ export class AccountsServer extends AccountsCommon {
       // XXX Maybe we should re-use the selector above and notice if the update
       //     touches nothing?
       setAttrs = { ...setAttrs, ...opts };
-      this.users.update(user._id, {
+      await this.users.update(user._id, {
         $set: setAttrs
       });
 
@@ -1359,9 +1377,10 @@ export class AccountsServer extends AccountsCommon {
       // Create a new user with the service data.
       user = {services: {}};
       user.services[serviceName] = serviceData;
+      const userId = await this.insertUserDoc(opts, user);
       return {
         type: serviceName,
-        userId: this.insertUserDoc(opts, user)
+        userId
       };
     }
   };
@@ -1543,7 +1562,7 @@ const setupDefaultLoginHandlers = accounts => {
 };
 
 // Login handler for resume tokens.
-const defaultResumeLoginHandler = (accounts, options) => {
+const defaultResumeLoginHandler = async (accounts, options) => {
   if (!options.resume)
     return undefined;
 
@@ -1554,7 +1573,7 @@ const defaultResumeLoginHandler = (accounts, options) => {
   // First look for just the new-style hashed login token, to avoid
   // sending the unhashed token to the database in a query if we don't
   // need to.
-  let user = accounts.users.findOne(
+  let user = await accounts.users.findOne(
     {"services.resume.loginTokens.hashedToken": hashedToken},
     {fields: {"services.resume.loginTokens.$": 1}});
 
@@ -1564,7 +1583,7 @@ const defaultResumeLoginHandler = (accounts, options) => {
     // the old-style token OR the new-style token, because another
     // client connection logging in simultaneously might have already
     // converted the token.
-    user = accounts.users.findOne({
+    user =  await accounts.users.findOne({
         $or: [
           {"services.resume.loginTokens.hashedToken": hashedToken},
           {"services.resume.loginTokens.token": options.resume}
@@ -1583,13 +1602,13 @@ const defaultResumeLoginHandler = (accounts, options) => {
   // {hashedToken, when} for a hashed token or {token, when} for an
   // unhashed token.
   let oldUnhashedStyleToken;
-  let token = user.services.resume.loginTokens.find(token =>
+  let token = await user.services.resume.loginTokens.find(token =>
     token.hashedToken === hashedToken
   );
   if (token) {
     oldUnhashedStyleToken = false;
   } else {
-    token = user.services.resume.loginTokens.find(token =>
+     token = await user.services.resume.loginTokens.find(token =>
       token.token === options.resume
     );
     oldUnhashedStyleToken = true;
@@ -1609,7 +1628,7 @@ const defaultResumeLoginHandler = (accounts, options) => {
     // after we read it).  Using $addToSet avoids getting an index
     // error if another client logging in simultaneously has already
     // inserted the new hashed token.
-    accounts.users.update(
+    await accounts.users.update(
       {
         _id: user._id,
         "services.resume.loginTokens.token": options.resume
@@ -1625,7 +1644,7 @@ const defaultResumeLoginHandler = (accounts, options) => {
     // Remove the old token *after* adding the new, since otherwise
     // another client trying to login between our removing the old and
     // adding the new wouldn't find a token to login with.
-    accounts.users.update(user._id, {
+    await accounts.users.update(user._id, {
       $pull: {
         "services.resume.loginTokens": { "token": options.resume }
       }
@@ -1641,49 +1660,50 @@ const defaultResumeLoginHandler = (accounts, options) => {
   };
 };
 
-const expirePasswordToken = (
-  accounts,
-  oldestValidDate,
-  tokenFilter,
-  userId
-) => {
-  // boolean value used to determine if this method was called from enroll account workflow
-  let isEnroll = false;
-  const userFilter = userId ? {_id: userId} : {};
-  // check if this method was called from enroll account workflow
-  if(tokenFilter['services.password.enroll.reason']) {
-    isEnroll = true;
-  }
-  let resetRangeOr = {
-    $or: [
-      { "services.password.reset.when": { $lt: oldestValidDate } },
-      { "services.password.reset.when": { $lt: +oldestValidDate } }
-    ]
-  };
-  if(isEnroll) {
-    resetRangeOr = {
+const expirePasswordToken =
+  async (
+    accounts,
+    oldestValidDate,
+    tokenFilter,
+    userId
+  ) => {
+    // boolean value used to determine if this method was called from enroll account workflow
+    let isEnroll = false;
+    const userFilter = userId ? { _id: userId } : {};
+    // check if this method was called from enroll account workflow
+    if (tokenFilter['services.password.enroll.reason']) {
+      isEnroll = true;
+    }
+    let resetRangeOr = {
       $or: [
-        { "services.password.enroll.when": { $lt: oldestValidDate } },
-        { "services.password.enroll.when": { $lt: +oldestValidDate } }
+        { "services.password.reset.when": { $lt: oldestValidDate } },
+        { "services.password.reset.when": { $lt: +oldestValidDate } }
       ]
     };
-  }
-  const expireFilter = { $and: [tokenFilter, resetRangeOr] };
-  if(isEnroll) {
-    accounts.users.update({...userFilter, ...expireFilter}, {
-      $unset: {
-        "services.password.enroll": ""
-      }
-    }, { multi: true });
-  } else {
-    accounts.users.update({...userFilter, ...expireFilter}, {
-      $unset: {
-        "services.password.reset": ""
-      }
-    }, { multi: true });
-  }
+    if (isEnroll) {
+      resetRangeOr = {
+        $or: [
+          { "services.password.enroll.when": { $lt: oldestValidDate } },
+          { "services.password.enroll.when": { $lt: +oldestValidDate } }
+        ]
+      };
+    }
+    const expireFilter = { $and: [tokenFilter, resetRangeOr] };
+    if (isEnroll) {
+      await accounts.users.update({ ...userFilter, ...expireFilter }, {
+        $unset: {
+          "services.password.enroll": ""
+        }
+      }, { multi: true });
+    } else {
+      await accounts.users.update({ ...userFilter, ...expireFilter }, {
+        $unset: {
+          "services.password.reset": ""
+        }
+      }, { multi: true });
+    }
 
-};
+  };
 
 const setExpireTokensInterval = accounts => {
   accounts.expireTokenInterval = Meteor.setInterval(() => {