const DEFAULT_TIMEOUT = 10000; /** * A function that wraps a sinon stub and returns an asynchronous function * that resolves if the stubbed function was called enough times, or throws * if the timeout is exceeded. * * The stub that has been passed in will be setup to call the wrapped function * directly. * * WARNING: Any existing `callsFake` behavior will be overwritten. * * @param {import('sinon').stub} stub - A sinon stub of a function * @param {unknown} [wrappedThis] - The object the stubbed function was called * on, if any (i.e. the `this` value) * @param {Object} [options] - Optional configuration * @param {number} [options.callCount] - The number of calls to wait for. * @param {number|null} [options.timeout] - The timeout, in milliseconds. Pass * in `null` to disable the timeout. * @returns {Function} An asynchronous function that resolves when the stub is * called enough times, or throws if the timeout is reached. */ function waitUntilCalled( stub, wrappedThis = null, { callCount = 1, timeout = DEFAULT_TIMEOUT } = {}, ) { let numCalls = 0; let resolve; let timeoutHandle; const stubHasBeenCalled = new Promise((_resolve) => { resolve = _resolve; if (timeout !== null) { timeoutHandle = setTimeout( () => resolve(new Error('Timeout exceeded')), timeout, ); } }); stub.callsFake((...args) => { try { if (stub.wrappedMethod) { stub.wrappedMethod.call(wrappedThis, ...args); } } finally { if (numCalls < callCount) { numCalls += 1; if (numCalls === callCount) { if (timeoutHandle) { clearTimeout(timeoutHandle); } resolve(); } } } }); return async () => { const error = await stubHasBeenCalled; if (error) { throw error; } }; } module.exports = waitUntilCalled;