expect-webdriverio 4.0.0

package/lib/matchers/mock/toBeRequestedWith.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBeRequestedWith = exports.toBeRequestedWithFn = void 0;
+const utils_1 = require("../../utils");
+const expectAdapter_1 = require("../../util/expectAdapter");
+const jasmineUtils_1 = require("../../jasmineUtils");
+const STR_LIMIT = 80;
+const KEY_LIMIT = 12;
+function toBeRequestedWithFn(received, requestedWith = {}, options = {}) {
+    const isNot = this.isNot || false;
+    const { expectation = 'called with', verb = 'be' } = this;
+    return browser.call(async () => {
+        let actual;
+        const pass = await utils_1.waitUntil(async () => {
+            for (const call of received.calls) {
+                actual = call;
+                if (methodMatcher(call.method, requestedWith.method) &&
+                    statusCodeMatcher(call.statusCode, requestedWith.statusCode) &&
+                    urlMatcher(call.url, requestedWith.url) &&
+                    headersMatcher(call.headers, requestedWith.requestHeaders) &&
+                    headersMatcher(call.responseHeaders, requestedWith.responseHeaders) &&
+                    bodyMatcher(call.postData, requestedWith.postData) &&
+                    bodyMatcher(call.body, requestedWith.response)) {
+                    return true;
+                }
+            }
+            return false;
+        }, isNot, { ...options, wait: isNot ? 0 : options.wait });
+        const message = utils_1.enhanceError('mock', minifyRequestedWith(requestedWith), minifyRequestMock(actual, requestedWith) || 'was not called', this, verb, expectation, '', options);
+        return {
+            pass,
+            message: () => message,
+        };
+    });
+}
+exports.toBeRequestedWithFn = toBeRequestedWithFn;
+const methodMatcher = (method, expected) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (!Array.isArray(expected)) {
+        expected = [expected];
+    }
+    return expected
+        .map((m) => {
+        if (typeof m !== 'string') {
+            return console.error('expect.toBeRequestedWith: unsupported value passed to method ' + m);
+        }
+        return m.toUpperCase();
+    })
+        .includes(method);
+};
+const statusCodeMatcher = (statusCode, expected) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (!Array.isArray(expected)) {
+        expected = [expected];
+    }
+    return expected.includes(statusCode);
+};
+const urlMatcher = (url, expected) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (typeof expected === 'function') {
+        return expected(url);
+    }
+    return jasmineUtils_1.equals(url, expected);
+};
+const headersMatcher = (headers, expected) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (typeof expected === 'function') {
+        return expected(headers);
+    }
+    return jasmineUtils_1.equals(headers, expected);
+};
+const bodyMatcher = (body, expected) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (typeof expected === 'function') {
+        return expected(body);
+    }
+    if (typeof body === 'undefined') {
+        return false;
+    }
+    let parsedBody = body;
+    if (body instanceof Buffer) {
+        parsedBody = body.toString();
+    }
+    if (typeof (body) === 'string' && isExpectedJsonLike(expected)) {
+        parsedBody = tryParseBody(body);
+        if (parsedBody === null) {
+            return false;
+        }
+    }
+    return jasmineUtils_1.equals(parsedBody, expected);
+};
+const isExpectedJsonLike = (expected) => {
+    if (typeof expected === 'undefined') {
+        return false;
+    }
+    const actualSample = isMatcher(expected)
+        ? expected.sample
+        : expected;
+    return (Array.isArray(actualSample) ||
+        (typeof actualSample === 'object' &&
+            actualSample !== null &&
+            actualSample instanceof RegExp === false));
+};
+const isMatcher = (filter) => {
+    var _a;
+    return typeof ((_a = filter.__proto__) === null || _a === void 0 ? void 0 : _a.asymmetricMatch) === 'function';
+};
+const tryParseBody = (jsonString, fallback = null) => {
+    try {
+        return typeof jsonString === 'undefined' ? fallback : JSON.parse(jsonString);
+    }
+    catch (_a) {
+        return fallback;
+    }
+};
+const minifyRequestMock = (requestMock, requestedWith) => {
+    if (typeof requestMock === 'undefined') {
+        return requestMock;
+    }
+    const r = {
+        url: requestMock.url,
+        method: requestMock.method,
+        requestHeaders: requestMock.headers,
+        responseHeaders: requestMock.responseHeaders,
+        postData: typeof requestMock.postData === 'string' && isExpectedJsonLike(requestedWith.postData)
+            ? tryParseBody(requestMock.postData, requestMock.postData)
+            : requestMock.postData,
+        response: typeof requestMock.body === 'string' && isExpectedJsonLike(requestedWith.response)
+            ? tryParseBody(requestMock.body, requestMock.body)
+            : requestMock.body,
+    };
+    deleteUndefinedValues(r, requestedWith);
+    return minifyRequestedWith(r);
+};
+const minifyRequestedWith = (r) => {
+    const result = {
+        url: requestedWithParamToString(r.url),
+        method: r.method,
+        requestHeaders: requestedWithParamToString(r.requestHeaders, shortenJson),
+        responseHeaders: requestedWithParamToString(r.responseHeaders, shortenJson),
+        postData: requestedWithParamToString(r.postData, shortenJson),
+        response: requestedWithParamToString(r.response, shortenJson),
+    };
+    deleteUndefinedValues(result);
+    return result;
+};
+const requestedWithParamToString = (param, transformFn) => {
+    if (typeof param === 'undefined') {
+        return;
+    }
+    if (typeof param === 'function') {
+        param = param.toString();
+    }
+    else if (isMatcher(param)) {
+        return (param.constructor.name +
+            ' ' +
+            (JSON.stringify(param.sample) || ''));
+    }
+    else if (transformFn && typeof param === 'object' && param !== null) {
+        param = transformFn(param);
+    }
+    if (typeof param === 'string') {
+        param = shortenString(param);
+    }
+    return param;
+};
+const shortenJson = (obj, lengthLimit = STR_LIMIT * 2, keyLimit = KEY_LIMIT) => {
+    if (JSON.stringify(obj).length < lengthLimit) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        const firstItem = typeof obj[0] === 'object' && obj[0] !== null
+            ? shortenJson(obj[0], lengthLimit / 2, keyLimit / 4)
+            : shortenString(JSON.stringify(obj[0]));
+        return [firstItem, `... ${obj.length - 1} more items`];
+    }
+    const minifiedObject = {};
+    const entries = Object.entries(obj);
+    if (keyLimit >= 4) {
+        entries.slice(0, keyLimit).forEach(([k, v]) => {
+            if (typeof v === 'object' && v !== null) {
+                v = shortenJson(v, lengthLimit / 2, keyLimit / 4);
+            }
+            else if (typeof v === 'string') {
+                v = shortenString(v, 16);
+            }
+            minifiedObject[shortenString(k, 24)] = v;
+        });
+    }
+    if (entries.length > keyLimit) {
+        minifiedObject['...'] = `${entries.length} items in total`;
+    }
+    return minifiedObject;
+};
+const shortenString = (str, limit = STR_LIMIT) => {
+    return str.length > limit ? str.substring(0, limit / 2 - 1) + '..' + str.substr(1 - limit / 2) : str;
+};
+const deleteUndefinedValues = (obj, baseline = obj) => {
+    Object.keys(obj).forEach((k) => {
+        if (typeof baseline[k] === 'undefined') {
+            delete obj[k];
+        }
+    });
+};
+function toBeRequestedWith(...args) {
+    return expectAdapter_1.runExpect.call(this, toBeRequestedWithFn, args);
+}
+exports.toBeRequestedWith = toBeRequestedWith;

package/lib/matchers/mock/toBeRequestedWithResponse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBeRequestedWithResponse = void 0;
+const toBeRequestedWith_1 = require("./toBeRequestedWith");
+const expectAdapter_1 = require("../../util/expectAdapter");
+function toBeRequestedWithResponseFn(received, response, options = {}) {
+    return toBeRequestedWith_1.toBeRequestedWithFn.call(this, received, { response }, options);
+}
+function toBeRequestedWithResponse(...args) {
+    console.warn('expect(...).toBeRequestedWithResponse is deprecated and will be removed in next release. Use toBeRequestedWith instead.');
+    return expectAdapter_1.runExpect.call(this, toBeRequestedWithResponseFn, args);
+}
+exports.toBeRequestedWithResponse = toBeRequestedWithResponse;

package/lib/matchers.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const matchers = {
+    ...require('./matchers/browser/toHaveTitle'),
+    ...require('./matchers/browser/toHaveTitleContaining'),
+    ...require('./matchers/browser/toHaveUrl'),
+    ...require('./matchers/browser/toHaveUrlContaining'),
+    ...require('./matchers/elements/toBeElementsArrayOfSize'),
+    ...require('./matchers/element/toBeClickable'),
+    ...require('./matchers/element/toBeDisabled'),
+    ...require('./matchers/element/toBeDisplayed'),
+    ...require('./matchers/element/toBeDisplayedInViewport'),
+    ...require('./matchers/element/toBeEnabled'),
+    ...require('./matchers/element/toBeExisting'),
+    ...require('./matchers/element/toBeFocused'),
+    ...require('./matchers/element/toBeSelected'),
+    ...require('./matchers/element/toHaveAttribute'),
+    ...require('./matchers/element/toHaveAttributeContaining'),
+    ...require('./matchers/element/toHaveChildren'),
+    ...require('./matchers/element/toHaveElementClass'),
+    ...require('./matchers/element/toHaveElementClassContaining'),
+    ...require('./matchers/element/toHaveHref'),
+    ...require('./matchers/element/toHaveHrefContaining'),
+    ...require('./matchers/element/toHaveId'),
+    ...require('./matchers/element/toHaveElementProperty'),
+    ...require('./matchers/element/toHaveText'),
+    ...require('./matchers/element/toHaveTextContaining'),
+    ...require('./matchers/element/toHaveValue'),
+    ...require('./matchers/element/toHaveValueContaining'),
+    ...require('./matchers/element/toHaveStyle'),
+    ...require('./matchers/mock/toBeRequested'),
+    ...require('./matchers/mock/toBeRequestedTimes'),
+    ...require('./matchers/mock/toBeRequestedWith'),
+    ...require('./matchers/mock/toBeRequestedWithResponse'),
+};
+Object.keys(matchers).forEach(key => {
+    if (key.endsWith('Fn')) {
+        delete matchers[key];
+    }
+});
+exports.default = matchers;

package/lib/options.js

@@ -0,0 +1,33 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDefaultOptions = exports.getConfig = void 0;
+const DEFAULT_OPTIONS = {
+    wait: 2000,
+    interval: 100,
+};
+let mode = 'jest';
+let expectLib;
+if (global.expectWdio) {
+    expectLib = global.expectWdio;
+}
+else if (global.jasmine && !((_a = global.expect) === null || _a === void 0 ? void 0 : _a.extend)) {
+    expectLib = global.jasmine;
+    mode = 'jasmine';
+}
+else {
+    expectLib = global.expect;
+}
+if (!expectLib._expectWebdriverio) {
+    expectLib._expectWebdriverio = { options: { ...DEFAULT_OPTIONS }, mode };
+}
+const getConfig = () => expectLib._expectWebdriverio;
+exports.getConfig = getConfig;
+const setDefaultOptions = (options = {}) => {
+    Object.entries(options).forEach(([key, value]) => {
+        if (key in DEFAULT_OPTIONS) {
+            expectLib._expectWebdriverio.options[key] = value;
+        }
+    });
+};
+exports.setDefaultOptions = setDefaultOptions;

package/lib/util/elementsUtil.js

@@ -0,0 +1,28 @@
+"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) {
+            for (let i = 0; i < refetched.length; i++) {
+                received.push(refetched[i]);
+            }
+        }
+    }
+};
+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,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runExpect = exports.runJasmineExpect = exports.jestResultToJasmine = exports.buildJasmineFromJestResult = exports.runJestExpect = 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);
+}
+exports.runJestExpect = runJestExpect;
+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.runJasmineExpect = runJasmineExpect;
+exports.runExpect = MODE === 'jasmine' ? runJasmineExpect : runJestExpect;

package/lib/util/formatMessage.js

@@ -0,0 +1,93 @@
+"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 = (options = {}) => {
+    if (options.eq) {
+        return options.eq;
+    }
+    if (options.gte && options.lte) {
+        return `>= ${options.gte} && <= ${options.lte}`;
+    }
+    if (options.gte) {
+        return `>= ${options.gte}`;
+    }
+    if (options.lte) {
+        return ` <= ${options.lte}`;
+    }
+    return "no params";
+};
+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,161 @@
+"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.compareStyle = 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, options = {}) => {
+    if (typeof options.eq === 'number') {
+        return actual === options.eq;
+    }
+    if (typeof options.gte === 'number' && typeof options.lte === 'number') {
+        return actual >= options.gte && actual <= options.lte;
+    }
+    if (typeof options.gte === 'number') {
+        return actual >= options.gte;
+    }
+    if (typeof options.lte === 'number') {
+        return actual <= options.lte;
+    }
+    return false;
+};
+exports.compareNumbers = compareNumbers;
+const compareText = (actual, expected, { ignoreCase = false, trim = true, 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;
+const compareStyle = async (actualEl, style, { ignoreCase = true, trim = false }) => {
+    let result = true;
+    const actual = {};
+    for (const key in style) {
+        const css = await actualEl.getCSSProperty(key);
+        let actualVal = css.value;
+        let expectedVal = style[key];
+        if (trim) {
+            actualVal = actualVal.trim();
+            expectedVal = expectedVal.trim();
+        }
+        if (ignoreCase) {
+            actualVal = actualVal.toLowerCase();
+            expectedVal = expectedVal.toLowerCase();
+        }
+        result = result && actualVal === expectedVal;
+        actual[key] = css.value;
+    }
+    return {
+        value: actual,
+        result
+    };
+};
+exports.compareStyle = compareStyle;
+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;