Function wrapMethod

benchmark/MongoLatencyWrapper.js:30–72

* Wrap a Collection method to add artificial latency * @param {string} methodName - Name of the method to wrap * @param {number} latencyMs - Delay in milliseconds

(methodName, latencyMs)

 * @param {number} latencyMs - Delay in milliseconds
 */
function wrapMethod(methodName, latencyMs) {
  if (!originalMethods.has(methodName)) {
    originalMethods.set(methodName, Collection.prototype[methodName]);
  }

  const originalMethod = originalMethods.get(methodName);

  Collection.prototype[methodName] = function (...args) {
    // For methods that return cursors (like find, aggregate), we need to delay the execution
    // but still return a cursor-like object
    const result = originalMethod.apply(this, args);

    // Check if result has cursor methods (toArray, forEach, etc.)
    if (result && typeof result.toArray === 'function') {
      // Wrap cursor methods that actually execute the query
      const originalToArray = result.toArray.bind(result);
      result.toArray = function() {
        // Wait for the original promise to settle, then delay the result
        return originalToArray().then(
          value => new Promise(resolve => setTimeout(() => resolve(value), latencyMs)),
          error => new Promise((_, reject) => setTimeout(() => reject(error), latencyMs))
        );
      };
      return result;
    }

    // For promise-returning methods, wrap the promise with delay
    if (result && typeof result.then === 'function') {
      // Wait for the original promise to settle, then delay the result
      return result.then(
        value => new Promise(resolve => setTimeout(() => resolve(value), latencyMs)),
        error => new Promise((_, reject) => setTimeout(() => reject(error), latencyMs))
      );
    }

    // For synchronous methods, just add delay
    return new Promise((resolve) => {
      setTimeout(() => {
        resolve(result);
      }, latencyMs);
    });
  };
}

/**
 * Wrap MongoDB Collection methods with artificial latency