expect-webdriverio 2.0.0 → 2.0.1

package/lib/util/elementsUtil.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateElementsArray = exports.wrapExpectedWithArray = void 0;
+const wrapExpectedWithArray = (el, actual, expected) => {
+    if (Array.isArray(el) && el.length > 1 && Array.isArray(actual)) {
+        expected = [expected];
+    }
+    return expected;
+};
+exports.wrapExpectedWithArray = wrapExpectedWithArray;
+const updateElementsArray = (success, received, refetched, full = false) => {
+    if (!success) {
+        return;
+    }
+    if (Array.isArray(received) && Array.isArray(refetched)) {
+        if (full === true) {
+            while (received.length > 0) {
+                received.pop();
+            }
+        }
+        if (received.length === 0) {
+            refetched.forEach(el => received.push(el));
+        }
+    }
+};
+exports.updateElementsArray = updateElementsArray;

package/lib/util/executeCommand.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCommand = void 0;
+const refetchElements_1 = require("./refetchElements");
+async function executeCommand(el, condition, options = {}, params = [], fullRefetch = false) {
+    const { isNot = false } = this;
+    let elements;
+    if (Array.isArray(el)) {
+        elements = await refetchElements_1.refetchElements(el, options.wait, fullRefetch);
+    }
+    else {
+        elements = [el];
+    }
+    if (elements.length === 0) {
+        return {
+            el: elements,
+            success: false,
+        };
+    }
+    const results = [];
+    for (const element of elements) {
+        results.push(await condition(element, ...params, options));
+    }
+    const values = [...new Set(results.filter(result => result.result === isNot).map(result => result.value))];
+    return {
+        el: Array.isArray(el) ? elements : el,
+        success: results.every(result => result.result === true),
+        values: values.length > 1 ? values : values[0]
+    };
+}
+exports.executeCommand = executeCommand;

package/lib/util/expectAdapter.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runExpect = exports.jestResultToJasmine = exports.buildJasmineFromJestResult = exports.getContext = void 0;
+const options_1 = require("../options");
+const config = options_1.getConfig();
+const { mode: MODE } = config;
+const getContext = (context) => global === context ? {} : context || {};
+exports.getContext = getContext;
+function runJestExpect(fn, args) {
+    return fn.apply(this, args);
+}
+const buildJasmineFromJestResult = (result, isNot) => {
+    return {
+        pass: result.pass !== isNot,
+        message: result.message()
+    };
+};
+exports.buildJasmineFromJestResult = buildJasmineFromJestResult;
+const jestResultToJasmine = (result, isNot) => {
+    if (result instanceof Promise) {
+        return result.then(jestStyleResult => exports.buildJasmineFromJestResult(jestStyleResult, isNot));
+    }
+    return exports.buildJasmineFromJestResult(result, isNot);
+};
+exports.jestResultToJasmine = jestResultToJasmine;
+function runJasmineExpect(fn) {
+    const context = exports.getContext(this);
+    return {
+        compare(...args) {
+            const result = fn.apply({ ...context, isNot: false }, args);
+            return exports.jestResultToJasmine(result, false);
+        },
+        negativeCompare(...args) {
+            const result = fn.apply({ ...context, isNot: true }, args);
+            return exports.jestResultToJasmine(result, true);
+        }
+    };
+}
+exports.runExpect = MODE === 'jasmine' ? runJasmineExpect : runJestExpect;

package/lib/util/formatMessage.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberError = exports.enhanceErrorBe = exports.enhanceError = exports.not = exports.getSelectors = exports.getSelector = void 0;
+const jest_matcher_utils_1 = require("jest-matcher-utils");
+const jasmineUtils_1 = require("../jasmineUtils");
+const EXPECTED_LABEL = 'Expected';
+const RECEIVED_LABEL = 'Received';
+const NOT_SUFFIX = ' [not]';
+const NOT_EXPECTED_LABEL = EXPECTED_LABEL + NOT_SUFFIX;
+const getSelector = (el) => {
+    let result = typeof el.selector === 'string' ? el.selector : '<fn>';
+    if (Array.isArray(el) && el.props.length > 0) {
+        result += ', <props>';
+    }
+    return result;
+};
+exports.getSelector = getSelector;
+const getSelectors = (el) => {
+    const selectors = [];
+    let parent;
+    if (Array.isArray(el)) {
+        selectors.push(`${el.foundWith}(\`${exports.getSelector(el)}\`)`);
+        parent = el.parent;
+    }
+    else {
+        parent = el;
+    }
+    while (parent && 'selector' in parent) {
+        const selector = exports.getSelector(parent);
+        const index = parent.index ? `[${parent.index}]` : '';
+        selectors.push(`${parent.index ? '$' : ''}$(\`${selector}\`)${index}`);
+        parent = parent.parent;
+    }
+    return selectors.reverse().join('.');
+};
+exports.getSelectors = getSelectors;
+const not = (isNot) => {
+    return `${isNot ? 'not ' : ''}`;
+};
+exports.not = not;
+const enhanceError = (subject, expected, actual, context, verb, expectation, arg2 = '', { message = '', containing = false }) => {
+    const { isNot = false } = context;
+    subject = typeof subject === 'string' ? subject : exports.getSelectors(subject);
+    let contain = '';
+    if (containing) {
+        contain = ' containing';
+    }
+    if (verb) {
+        verb += ' ';
+    }
+    let diffString;
+    if (isNot && jasmineUtils_1.equals(actual, expected)) {
+        diffString = `${EXPECTED_LABEL}: ${jest_matcher_utils_1.printExpected(expected)}\n` +
+            `${RECEIVED_LABEL}: ${jest_matcher_utils_1.printReceived(actual)}`;
+    }
+    else {
+        diffString = jest_matcher_utils_1.printDiffOrStringify(expected, actual, EXPECTED_LABEL, RECEIVED_LABEL, true);
+    }
+    if (isNot) {
+        diffString = diffString
+            .replace(EXPECTED_LABEL, NOT_EXPECTED_LABEL)
+            .replace(RECEIVED_LABEL, RECEIVED_LABEL + ' '.repeat(NOT_SUFFIX.length));
+    }
+    if (message) {
+        message += '\n';
+    }
+    if (arg2) {
+        arg2 = ` ${arg2}`;
+    }
+    const msg = `${message}Expect ${subject} ${exports.not(isNot)}to ${verb}${expectation}${arg2}${contain}\n\n${diffString}`;
+    return msg;
+};
+exports.enhanceError = enhanceError;
+const enhanceErrorBe = (subject, pass, context, verb, expectation, options) => {
+    return exports.enhanceError(subject, exports.not(context.isNot) + expectation, exports.not(!pass) + expectation, context, verb, expectation, '', options);
+};
+exports.enhanceErrorBe = enhanceErrorBe;
+const numberError = (gte, lte, eq) => {
+    if (typeof eq === 'number') {
+        return eq;
+    }
+    let error = '';
+    error = `>= ${gte}`;
+    error += lte ? ` && <= ${lte}` : '';
+    return error;
+};
+exports.numberError = numberError;

package/lib/util/refetchElements.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refetchElements = void 0;
+const options_1 = require("../options");
+const config = options_1.getConfig();
+const { options: DEFAULT_OPTIONS } = config;
+const refetchElements = async (elements, wait = DEFAULT_OPTIONS.wait, full = false) => {
+    if (elements) {
+        if (wait > 0 && (elements.length === 0 || full)) {
+            elements = await elements.parent[elements.foundWith](elements.selector, ...elements.props);
+        }
+    }
+    return elements;
+};
+exports.refetchElements = refetchElements;

package/lib/utils.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aliasFn = exports.compareNumbers = exports.waitUntil = exports.executeCommandBe = exports.executeCommand = exports.numberError = exports.enhanceError = exports.wrapExpectedWithArray = exports.updateElementsArray = exports.compareTextWithArray = exports.compareText = void 0;
+const options_1 = require("./options");
+const executeCommand_1 = require("./util/executeCommand");
+Object.defineProperty(exports, "executeCommand", { enumerable: true, get: function () { return executeCommand_1.executeCommand; } });
+const elementsUtil_1 = require("./util/elementsUtil");
+Object.defineProperty(exports, "wrapExpectedWithArray", { enumerable: true, get: function () { return elementsUtil_1.wrapExpectedWithArray; } });
+Object.defineProperty(exports, "updateElementsArray", { enumerable: true, get: function () { return elementsUtil_1.updateElementsArray; } });
+const formatMessage_1 = require("./util/formatMessage");
+Object.defineProperty(exports, "enhanceError", { enumerable: true, get: function () { return formatMessage_1.enhanceError; } });
+Object.defineProperty(exports, "numberError", { enumerable: true, get: function () { return formatMessage_1.numberError; } });
+const expectAdapter_1 = require("./util/expectAdapter");
+const config = options_1.getConfig();
+const { options: DEFAULT_OPTIONS } = config;
+const waitUntil = async (condition, isNot = false, { wait = DEFAULT_OPTIONS.wait, interval = DEFAULT_OPTIONS.interval } = {}) => {
+    if (wait === 0) {
+        return await condition();
+    }
+    try {
+        let error;
+        await browser.waitUntil(async () => {
+            error = undefined;
+            try {
+                return isNot !== await condition();
+            }
+            catch (err) {
+                error = err;
+                return false;
+            }
+        }, {
+            timeout: wait,
+            interval
+        });
+        if (error) {
+            throw error;
+        }
+        return !isNot;
+    }
+    catch (err) {
+        return isNot;
+    }
+};
+exports.waitUntil = waitUntil;
+async function executeCommandBe(received, command, options) {
+    const { isNot, expectation, verb = 'be' } = this;
+    received = await received;
+    let el = received;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand_1.executeCommand.call(this, el, async (element) => ({ result: await command(element) }), options);
+        el = result.el;
+        return result.success;
+    }, isNot, options);
+    elementsUtil_1.updateElementsArray(pass, received, el);
+    const message = formatMessage_1.enhanceErrorBe(el, pass, this, verb, expectation, options);
+    return {
+        pass,
+        message: () => message
+    };
+}
+exports.executeCommandBe = executeCommandBe;
+const compareNumbers = (actual, gte, lte, eq) => {
+    if (typeof eq === 'number') {
+        return actual === eq;
+    }
+    if (lte > 0 && actual > lte) {
+        return false;
+    }
+    return actual >= gte;
+};
+exports.compareNumbers = compareNumbers;
+const compareText = (actual, expected, { ignoreCase = false, trim = false, containing = false }) => {
+    if (typeof actual !== 'string') {
+        return {
+            value: actual,
+            result: false
+        };
+    }
+    if (trim) {
+        actual = actual.trim();
+    }
+    if (ignoreCase) {
+        actual = actual.toLowerCase();
+        expected = expected.toLowerCase();
+    }
+    if (containing) {
+        return {
+            value: actual,
+            result: actual.includes(expected)
+        };
+    }
+    return {
+        value: actual,
+        result: actual === expected
+    };
+};
+exports.compareText = compareText;
+const compareTextWithArray = (actual, expectedArray, { ignoreCase = false, trim = false, containing = false }) => {
+    if (typeof actual !== 'string') {
+        return {
+            value: actual,
+            result: false
+        };
+    }
+    if (trim) {
+        actual = actual.trim();
+    }
+    if (ignoreCase) {
+        actual = actual.toLowerCase();
+        expectedArray = expectedArray.map(item => item.toLowerCase());
+    }
+    if (containing) {
+        const textInArray = expectedArray.some((t) => actual.includes(t));
+        return {
+            value: actual,
+            result: textInArray
+        };
+    }
+    return {
+        value: actual,
+        result: expectedArray.includes(actual)
+    };
+};
+exports.compareTextWithArray = compareTextWithArray;
+function aliasFn(fn, { verb, expectation } = {}, ...args) {
+    const context = expectAdapter_1.getContext(this);
+    context.verb = verb;
+    context.expectation = expectation;
+    return fn.apply(context, args);
+}
+exports.aliasFn = aliasFn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "",
   "main": "lib/index.js",
   "scripts": {