expect-webdriverio 4.11.10 → 4.12.1

package/lib/matchers/element/toHaveAttribute.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function conditionAttr(el, attribute) {
     const attr = await el.getAttribute(attribute);
@@ -27,7 +27,6 @@ export async function toHaveAttributeAndValue(received, attribute, value, option
         attr = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const expected = wrapExpectedWithArray(el, attr, value);
     const message = enhanceError(el, expected, attr, this, verb, expectation, attribute, options);
     return {
@@ -44,7 +43,6 @@ async function toHaveAttributeFn(received, attribute) {
         el = result.el;
         return result.success;
     }, isNot, {});
-    updateElementsArray(pass, received, el);
     const message = enhanceError(el, !isNot, pass, this, verb, expectation, attribute, {});
     return {
         pass,

package/lib/matchers/element/toHaveChildren.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, compareNumbers, numberError, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { waitUntil, enhanceError, compareNumbers, numberError, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, options) {
     const children = await el.$$('./*');
@@ -34,7 +34,6 @@ export async function toHaveChildren(received, expectedValue, options = DEFAULT_
         children = result.values;
         return result.success;
     }, isNot, { ...numberOptions, ...options });
-    updateElementsArray(pass, received, el);
     const error = numberError(numberOptions);
     const expectedArray = wrapExpectedWithArray(el, children, error);
     const message = enhanceError(el, expectedArray, children, this, verb, expectation, '', numberOptions);

package/lib/matchers/element/toHaveClass.js

@@ -1,9 +1,9 @@
 import { toHaveAttributeAndValue } from './toHaveAttribute.js';
-import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, compareText } from '../../utils.js';
+import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, compareText } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, attribute, value, options) {
     const { ignoreCase = false, trim = false, containing = false } = options;
-    let attr = await el.getAttribute(attribute);
+    let attr = await (await el).getAttribute(attribute);
     if (typeof attr !== 'string') {
         return { result: false };
     }
@@ -49,7 +49,6 @@ export async function toHaveElementClass(received, expectedValue, options = DEFA
         attr = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const message = enhanceError(el, wrapExpectedWithArray(el, attr, expectedValue), attr, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/element/toHaveComputedLabel.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, label, options) {
     const actualLabel = await el.getComputedLabel();
@@ -23,7 +23,6 @@ export async function toHaveComputedLabel(received, expectedValue, options = DEF
         actualLabel = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualLabel, expectedValue), actualLabel, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/element/toHaveComputedRole.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, role, options) {
     const actualRole = await el.getComputedRole();
@@ -23,7 +23,6 @@ export async function toHaveComputedRole(received, expectedValue, options = DEFA
         actualRole = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualRole, expectedValue), actualRole, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/element/toHaveElementProperty.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, property, value, options = DEFAULT_OPTIONS) {
     const { asString = false } = options;
@@ -31,7 +31,6 @@ export async function toHaveElementProperty(received, property, value, options =
         prop = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     let message;
     if (value === undefined) {
         message = enhanceError(el, !isNot, pass, this, verb, expectation, property, options);

package/lib/matchers/element/toHaveHTML.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, html, options) {
     const actualHTML = await el.getHTML(options.includeSelectorTag);
@@ -23,7 +23,6 @@ export async function toHaveHTML(received, expectedValue, options = DEFAULT_OPTI
         actualHTML = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualHTML, expectedValue), actualHTML, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/element/toHaveHeight.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, height) {
     const actualHeight = await el.getSize('height');
@@ -23,7 +23,6 @@ export async function toHaveHeight(received, expectedValue, options = DEFAULT_OP
         actualHeight = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualHeight, expectedValue), actualHeight, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/element/toHaveSize.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, compareObject, } from '../../utils.js';
+import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, compareObject, } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, size) {
     const actualSize = await el.getSize();
@@ -20,7 +20,6 @@ export async function toHaveSize(received, expectedValue, options = DEFAULT_OPTI
         actualSize = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualSize, expectedValue), actualSize, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/element/toHaveStyle.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, compareStyle, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { waitUntil, enhanceError, compareStyle, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, style, options) {
     return compareStyle(el, style, options);
@@ -19,7 +19,6 @@ export async function toHaveStyle(received, expectedValue, options = DEFAULT_OPT
         actualStyle = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualStyle, expectedValue), actualStyle, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/element/toHaveText.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, text, options) {
     const actualText = await el.getText();
@@ -23,7 +23,6 @@ export async function toHaveText(received, expectedValue, options = DEFAULT_OPTI
         actualText = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualText, expectedValue), actualText, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/element/toHaveWidth.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, width) {
     const actualWidth = await el.getSize('width');
@@ -23,7 +23,6 @@ export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPT
         actualWidth = result.values;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const message = enhanceError(el, wrapExpectedWithArray(el, actualWidth, expectedValue), actualWidth, this, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError, compareNumbers, numberError, updateElementsArray } from '../../utils.js';
+import { waitUntil, enhanceError, compareNumbers, numberError } from '../../utils.js';
 import { refetchElements } from '../../util/refetchElements.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toBeElementsArrayOfSize(received, expectedValue, options = DEFAULT_OPTIONS) {
@@ -20,14 +20,16 @@ export async function toBeElementsArrayOfSize(received, expectedValue, options =
         numberOptions = expectedValue;
     }
     let elements = await received;
-    const arrLength = elements.length;
     const pass = await waitUntil(async () => {
+        const isPassing = compareNumbers(elements.length, numberOptions);
+        if (isPassing) {
+            return isPassing;
+        }
         elements = await refetchElements(elements, numberOptions.wait, true);
-        return compareNumbers(elements.length, numberOptions);
+        return false;
     }, isNot, { ...numberOptions, ...options });
-    updateElementsArray(pass, received, elements, true);
     const error = numberError(numberOptions);
-    const message = enhanceError(elements, error, arrLength, this, verb, expectation, '', numberOptions);
+    const message = enhanceError(elements, error, elements.length, this, verb, expectation, '', numberOptions);
     const result = {
         pass,
         message: () => message

package/lib/util/elementsUtil.js

@@ -4,20 +4,3 @@ export const wrapExpectedWithArray = (el, actual, expected) => {
     }
     return expected;
 };
-export 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]);
-            }
-        }
-    }
-};

package/lib/util/executeCommand.js

@@ -1,27 +1,8 @@
-import { refetchElements } from './refetchElements.js';
-export async function executeCommand(el, condition, options = {}, params = [], fullRefetch = false) {
-    const { isNot = false } = this;
-    let elements;
-    if (Array.isArray(el)) {
-        elements = await 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))];
+export async function executeCommand(el, condition, options = {}, params = []) {
+    const result = await condition(el, ...params, options);
     return {
-        el: Array.isArray(el) ? elements : el,
-        success: results.every(result => result.result === true),
-        values: values.length > 1 ? values : values[0]
+        el,
+        success: result.result === true,
+        values: result.value
     };
 }

package/lib/util/formatMessage.js

@@ -68,7 +68,7 @@ export const enhanceErrorBe = (subject, pass, context, verb, expectation, option
     return enhanceError(subject, not(context.isNot) + expectation, not(!pass) + expectation, context, verb, expectation, '', options);
 };
 export const numberError = (options = {}) => {
-    if (options.eq) {
+    if (typeof options.eq === 'number') {
         return options.eq;
     }
     if (options.gte && options.lte) {

package/lib/utils.js

@@ -1,6 +1,6 @@
 import isEqual from 'lodash.isequal';
 import { executeCommand } from './util/executeCommand.js';
-import { wrapExpectedWithArray, updateElementsArray } from './util/elementsUtil.js';
+import { wrapExpectedWithArray } from './util/elementsUtil.js';
 import { enhanceError, enhanceErrorBe, numberError } from './util/formatMessage.js';
 import { DEFAULT_OPTIONS } from './constants.js';
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -53,7 +53,6 @@ async function executeCommandBe(received, command, options) {
         el = result.el;
         return result.success;
     }, isNot, options);
-    updateElementsArray(pass, received, el);
     const message = enhanceErrorBe(el, pass, this, verb, expectation, options);
     return {
         pass,
@@ -217,7 +216,7 @@ function aliasFn(fn, { verb, expectation, } = {}, ...args) {
     this.expectation = expectation;
     return fn.apply(this, args);
 }
-export { updateElementsArray, wrapExpectedWithArray, enhanceError, numberError, executeCommand, executeCommandBe, waitUntil, compareNumbers, aliasFn, };
+export { wrapExpectedWithArray, enhanceError, numberError, executeCommand, executeCommandBe, waitUntil, compareNumbers, aliasFn, };
 function replaceActual(replace, actual) {
     const hasMultipleReplacers = replace.every((r) => Array.isArray(r));
     const replacers = hasMultipleReplacers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "4.11.10",
+  "version": "4.12.1",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",