playwright-fluent
Version:
Fluent API around playwright
75 lines (74 loc) • 3.35 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.waitForStabilityOf = void 0;
const report_1 = require("../report");
const sleep_1 = require("../sleep");
const wait_until_1 = require("../wait-until");
function raw(input) {
if (input === null) {
return 'null';
}
if (input === undefined) {
return 'undefined';
}
if (typeof input === 'boolean') {
return `${input}`;
}
if (typeof input === 'number') {
return `${input}`;
}
return input;
}
/**
* Waits until the function getValue() returns the same result during 300 ms.
* The waiting mechanism can be modified by setting options
*
* @export
* @param {(() => Promise<string | boolean | number | null | undefined>)} getValue
* @param {(string | (() => Promise<string>))} errorMessage
* @param {WaitUntilOptions} [options=defaultWaitUntilOptions]
* @returns {Promise<void>}
*/
async function waitForStabilityOf(getValue, errorMessage, options = wait_until_1.defaultWaitUntilOptions) {
const waitOptions = {
...wait_until_1.defaultWaitUntilOptions,
...options,
};
(0, report_1.report)('wait options:', waitOptions.verbose);
(0, report_1.report)(JSON.stringify(waitOptions, null, 2), waitOptions.verbose);
const timeout = waitOptions.timeoutInMilliseconds;
const interval = waitOptions.stabilityInMilliseconds <= 0 ? 1 : waitOptions.stabilityInMilliseconds / 3;
const nbIntervals = timeout <= 0 ? 1 : timeout / interval;
const stabilityCounterMaxValue = waitOptions.stabilityInMilliseconds / interval;
let stabilityCounterCurrentValue = 0;
let previousResult = await getValue();
(0, report_1.report)(`value function has initially returned '${raw(previousResult)}'`, waitOptions.verbose);
for (let index = 0; index < nbIntervals; index++) {
await (0, sleep_1.sleep)(interval);
const result = await getValue();
(0, report_1.report)(`value function returned '${raw(result)}' after waiting ${(index + 1) * interval} ms`, waitOptions.verbose);
if (result === previousResult) {
stabilityCounterCurrentValue += 1;
}
if (result !== previousResult) {
previousResult = result;
stabilityCounterCurrentValue = 0;
}
if (stabilityCounterCurrentValue >= stabilityCounterMaxValue) {
(0, report_1.report)(`value function always returned '${raw(result)}' during ${stabilityCounterCurrentValue > 0 ? stabilityCounterCurrentValue * interval : interval} ms: no need to wait anymore.`, waitOptions.verbose);
return;
}
}
(0, report_1.report)(`value function could not converge to a stable result during ${waitOptions.timeoutInMilliseconds} ms.`, waitOptions.verbose);
(0, report_1.report)(`timeout of ${waitOptions.timeoutInMilliseconds} ms as been reached`, waitOptions.verbose);
if (!options.throwOnTimeout) {
(0, report_1.report)('exiting waiting mechanism without throwing', waitOptions.verbose);
return;
}
(0, report_1.report)('exiting waiting mechanism with throwing', waitOptions.verbose);
if (typeof errorMessage === 'string') {
throw new Error(errorMessage);
}
throw new Error(await errorMessage());
}
exports.waitForStabilityOf = waitForStabilityOf;