expect-webdriverio 1.2.0 → 1.4.1

package/README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://travis-ci.org/webdriverio/expect-webdriverio.svg?branch=master)](https://travis-ci.org/webdriverio/expect-webdriverio) [![codecov](https://codecov.io/gh/webdriverio/expect-webdriverio/branch/master/graph/badge.svg)](https://codecov.io/gh/webdriverio/expect-webdriverio)
 
-###### [TypeScript / JS Autocomplete](/docs/Types.md) | [Examples](docs/Examples.md) | [Extending Matchers](/docs/Extend.md)
+###### [API](docs/API.md) | [TypeScript / JS Autocomplete](/docs/Types.md) | [Examples](docs/Examples.md) | [Extending Matchers](/docs/Extend.md)
 
 > [WebdriverIO](https://webdriver.io/) Assertion library inspired by [expect](https://www.npmjs.com/package/expect)
 
@@ -24,7 +24,7 @@ NOTE: [WebdriverIO](https://github.com/webdriverio/webdriverio) `v5.16.11` or hi
 
 In your `wdio.conf.js`
 ```js
-beforeSession () { // before hook works as well
+before () { // not needed in WebdriverIO v6
     require('expect-webdriverio')
 },
 ```
@@ -39,458 +39,7 @@ See more [Examples](docs/Examples.md)
 
 ## API
 
-See available [Matchers](https://github.com/webdriverio/expect-webdriverio/blob/master/types/expect-webdriverio.d.ts#L64)
-
-Besides of the `expect-webdriverio` matchers you can use builtin Jest's [expect](https://jestjs.io/docs/en/expect) assertions or [expect/expectAsync](https://jasmine.github.io/api/3.5/global.html#expect) for Jasmine.
-
-## Default Options
-
-```js
-{
-    wait: 2000, // ms to wait for expectation to succeed
-    interval: 100, // interval between attempts
-}
-```
-
-Set options like this:
-```js
-beforeSession () { // before hook works as well
-    require('expect-webdriverio').setOptions({ wait: 5000 })
-},
-```
-
-### Matcher Options
-
-Every matcher can take several options that allows you to modify the assertion:
-
-##### Command Options
-
-| Name | Type | Details |
-| ---- | ---- | ------- |
-| <code><var>wait</var></code> | number | time in ms to wait for expectation to succeed. Default: `3000` |
-| <code><var>interval</var></code> | number | interval between attempts. Default: `100` |
-| <code><var>message</var></code> | string | user message to prepend before assertion error |
-
-##### String Options
-
-This options can be applied in addition to the command options when strings are being asserted.
-
-| Name | Type | Details |
-| ---- | ---- | ------- |
-| <code><var>ignoreCase</var></code> | boolean | apply `toLowerCase` to both actual and expected values |
-| <code><var>trim</var></code> | boolean | apply `trim` to actual value |
-| <code><var>containing</var></code> | boolean | expect actual value to contain expected value, otherwise strict equal. |
-| <code><var>asString</var></code> | boolean | might be helpful to force converting property value to string |
-
-##### Number Options
-
-This options can be applied in addition to the command options when numbers are being asserted.
-
-| Name | Type | Details |
-| ---- | ---- | ------- |
-| <code><var>eq</var></code> | number | equals |
-| <code><var>lte</var></code> | number | less then equals |
-| <code><var>gte</var></code> | number | greater than or equals |
-
-## Browser Matchers
-
-### toHaveUrl
-
-Checks if browser is on a specific page.
-
-##### Usage
-
-```js
-browser.url('https://webdriver.io/')
-expect(browser).toHaveUrl('https://webdriver.io')
-```
-
-### toHaveUrlContaining
-
-Checks if browser is on a specific page and contains the given value in URL.
-
-##### Usage
-
-```js
-browser.url('https://webdriver.io/')
-expect(browser).toHaveUrlContaining('webdriver.io')
-```
-
-### toHaveTitle
-
-Checks if website has a specific title.
-
-##### Usage
-
-```js
-browser.url('https://webdriver.io/')
-expect(browser).toHaveTitle('WebdriverIO · Next-gen browser and mobile automation test framework for Node.js')
-```
-
-### toHaveTitleContaining
-
-Checks if website has a specific title that contains the given value.
-
-##### Usage
-
-```js
-browser.url('https://webdriver.io/')
-expect(browser).toHaveTitleContaining('Next-gen browser and mobile automation test framework')
-```
-
-## Element Matchers
-
-### toBeDisplayed
-
-Calls [`isDisplayed`](/docs/api/element/isDisplayed.html) on given element.
-
-##### Usage
-
-```js
-const elem = $('#someElem')
-expect(elem).toBeDisplayed()
-```
-
-### toBeVisible
-
-Same as `toBeDisplayed`.
-
-##### Usage
-
-```js
-const elem = $('#someElem')
-expect(elem).toBeVisible()
-```
-
-### toExist
-
-Calls [`isExisting`](/docs/api/element/isExisting.html) on given element.
-
-##### Usage
-
-```js
-const elem = $('#someElem')
-expect(elem).toExist()
-```
-
-### toBePresent
-
-Same as `toExist`.
-
-##### Usage
-
-```js
-const elem = $('#someElem')
-expect(elem).toBePresent()
-```
-
-### toBeExisting
-
-Same as `toExist`.
-
-##### Usage
-
-```js
-const elem = $('#someElem')
-expect(elem).toBeExisting()
-```
-
-### toBeFocused
-
-Checks if element has focus. This assertion only works in a web context.
-
-##### Usage
-
-```js
-const elem = $('#someElem')
-expect(elem).toBeFocused()
-```
-
-### toHaveAttribute
-
-Checks if an element has a certain attribute with a specific value.
-
-##### Usage
-
-```js
-const myInput = $('input')
-expect(myInput).toHaveAttribute('class', 'form-control')
-```
-
-### toHaveAttr
-
-Same as `toHaveAttribute`.
-
-##### Usage
-
-```js
-const myInput = $('input')
-expect(myInput).toHaveAttr('class', 'form-control')
-```
-
-### toHaveAttributeContaining
-
-Checks if an element has a certain attribute that contains a value.
-
-##### Usage
-
-```js
-const myInput = $('input')
-expect(myInput).toHaveAttributeContaining('class', 'form')
-```
-
-### toHaveAttrContaining
-
-Same as `toHaveAttributeContaining`.
-
-##### Usage
-
-```js
-const myInput = $('input')
-expect(myInput).toHaveAttrContaining('class', 'form')
-```
-
-### toHaveClass
-
-Checks if an element has a certain class name.
-
-##### Usage
-
-```js
-const myInput = $('input')
-expect(myInput).toHaveClass('form-control', { message: 'Not a form control!', })
-```
-
-### toHaveClassContaining
-
-Checks if an element has a certain class name that contains provided value.
-
-##### Usage
-
-```js
-const myInput = $('input')
-expect(myInput).toHaveClassContaining('form')
-```
-
-### toHaveProperty
-
-Checks if an element has a certain property.
-
-##### Usage
-
-```js
-const elem = $('#elem')
-expect(elem).toHaveProperty('height', 23)
-expect(elem).not.toHaveProperty('height', 0)
-```
-
-### toHaveValue
-
-Checks if an input element has a certain value.
-
-##### Usage
-
-```js
-const myInput = $('input')
-expect(myInput).toHaveValue('user', { ignoreCase: true })
-```
-
-### toHaveValueContaining
-
-Checks if an input element contains a certain value.
-
-##### Usage
-
-```js
-const myInput = $('input')
-expect(myInput).toHaveValueContaining('us')
-```
-
-### toBeClickable
-
-Checks if an element can be clicked by calling [`isClickable`](/docs/api/element/isClickable.html) on the element.
-
-##### Usage
-
-```js
-const elem = $('#elem')
-expect(elem).toBeClickable()
-```
-
-### toBeDisabled
-
-Checks if an element is disabled by calling [`isEnabled`](/docs/api/element/isEnabled.html) on the element.
-
-##### Usage
-
-```js
-const elem = $('#elem')
-expect(elem).toBeDisabled()
-// same as
-expect(elem).not.toBeEnabled()
-```
-
-### toBeEnabled
-
-Checks if an element is enabled by calling [`isEnabled`](/docs/api/element/isEnabled.html) on the element.
-
-##### Usage
-
-```js
-const elem = $('#elem')
-expect(elem).toBeEnabled()
-// same as
-expect(elem).not.toBeDisabled()
-```
-
-### toBeSelected
-
-Checks if an element is enabled by calling [`isSelected`](/docs/api/element/isSelected.html) on the element.
-
-##### Usage
-
-```js
-const elem = $('#elem')
-expect(elem).toBeSelected()
-```
-
-### toBeChecked
-
-Same as `toBeSelected`.
-
-##### Usage
-
-```js
-const elem = $('#elem')
-expect(elem).toBeChecked()
-```
-
-### toHaveHref
-
-Checks if link element has a specifc link target.
-
-##### Usage
-
-```js
-const link = $('a')
-expect(link).toHaveHref('https://webdriver.io')
-```
-
-### toHaveLink
-
-Same as `toHaveHref`.
-
-##### Usage
-
-```js
-const link = $('a')
-expect(link).toHaveLink('https://webdriver.io')
-```
-
-### toHaveHrefContaining
-
-Checks if link element contains a specifc link target.
-
-##### Usage
-
-```js
-const link = $('a')
-expect(link).toHaveHrefContaining('webdriver.io')
-```
-
-### toHaveLinkContaining
-
-Same as `toHaveHrefContaining`.
-
-##### Usage
-
-```js
-const link = $('a')
-expect(link).toHaveLinkContaining('webdriver.io')
-```
-
-### toHaveId
-
-Checks if element has a specific `id` attribute.
-
-##### Usage
-
-```js
-const elem = $('#elem')
-expect(elem).toHaveId('elem')
-```
-
-### toHaveText
-
-Checks if element has a specific text.
-
-##### Usage
-
-```js
-browser.url('https://webdriver.io/')
-const elem = $('.tagline')
-expect(elem).toHaveText('Next-gen browser and mobile automation test framework for Node.js')
-```
-
-### toHaveTextContaining
-
-Checks if element contains a specific text.
-
-##### Usage
-
-```js
-browser.url('https://webdriver.io/')
-const elem = $('.tagline')
-expect(elem).toHaveTextContaining('browser and mobile automation test framework')
-```
-
-### toBeDisplayedInViewport
-
-Checks if an element is within the viewport by calling [`isDisplayedInViewport`](/docs/api/element/isDisplayedInViewport.html) on the element.
-
-##### Usage
-
-```js
-const elem = $('#elem')
-expect(elem).toBeDisplayedInViewport()
-```
-
-### toBeVisibleInViewport
-
-Same as `toBeDisplayedInViewport`.
-
-##### Usage
-
-```js
-const elem = $('#elem')
-expect(elem).toBeVisibleInViewport()
-```
-
-### toHaveChildren
-
-Checks amount of fetched elements using [`$$`](/docs/api/browser/$$.html) command.
-
-##### Usage
-
-```js
-const elems = $$('div')
-expect(elems).toHaveChildren({ gte: 10 })
-// same as
-assert.ok(elems.length >= 10)
-```
-
-### toBeElementsArrayOfSize
-
-Same as `toHaveChildren`.
-
-##### Usage
-
-```js
-const elems = $$('div')
-expect(elems).toBeElementsArrayOfSize({ gte: 10 })
-// same as
-assert.ok(elems.length >= 10)
-```
+Please see [API doc](docs/API.md)
 
 ## Error messages
 
@@ -501,7 +50,7 @@ Error messages are informative out of the box and contain:
 - highlight the difference (texts assertions)
 
 ![toHaveText](/docs/img/errors/text.png?raw=true "toHaveText")
-![toHaveClass](/docs/img/errors/class.png?raw=true "toHaveClass")
+![toHaveElementClass](/docs/img/errors/class.png?raw=true "toHaveElementClass")
 ![not.toBeVisible](/docs/img/errors/not-visible.png?raw=true "not.toBeVisible")
 
 ## What's next?

package/lib/jasmineUtils.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImmutableUnorderedSet = exports.isImmutableUnorderedKeyed = exports.hasProperty = exports.isUndefined = exports.fnNameFor = exports.isA = exports.equals = void 0;
+function equals(a, b, customTesters, strictCheck) {
+    customTesters = customTesters || [];
+    return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
+}
+exports.equals = equals;
+const functionToString = Function.prototype.toString;
+function isAsymmetric(obj) {
+    return !!obj && isA('Function', obj.asymmetricMatch);
+}
+function asymmetricMatch(a, b) {
+    var asymmetricA = isAsymmetric(a), asymmetricB = isAsymmetric(b);
+    if (asymmetricA && asymmetricB) {
+        return undefined;
+    }
+    if (asymmetricA) {
+        return a.asymmetricMatch(b);
+    }
+    if (asymmetricB) {
+        return b.asymmetricMatch(a);
+    }
+}
+function eq(a, b, aStack, bStack, customTesters, hasKey) {
+    var result = true;
+    var asymmetricResult = asymmetricMatch(a, b);
+    if (asymmetricResult !== undefined) {
+        return asymmetricResult;
+    }
+    for (var i = 0; i < customTesters.length; i++) {
+        var customTesterResult = customTesters[i](a, b);
+        if (customTesterResult !== undefined) {
+            return customTesterResult;
+        }
+    }
+    if (a instanceof Error && b instanceof Error) {
+        return a.message == b.message;
+    }
+    if (Object.is(a, b)) {
+        return true;
+    }
+    if (a === null || b === null) {
+        return a === b;
+    }
+    var className = Object.prototype.toString.call(a);
+    if (className != Object.prototype.toString.call(b)) {
+        return false;
+    }
+    switch (className) {
+        case '[object Boolean]':
+        case '[object String]':
+        case '[object Number]':
+            if (typeof a !== typeof b) {
+                return false;
+            }
+            else if (typeof a !== 'object' && typeof b !== 'object') {
+                return Object.is(a, b);
+            }
+            else {
+                return Object.is(a.valueOf(), b.valueOf());
+            }
+        case '[object Date]':
+            return +a == +b;
+        case '[object RegExp]':
+            return a.source === b.source && a.flags === b.flags;
+    }
+    if (typeof a !== 'object' || typeof b !== 'object') {
+        return false;
+    }
+    if (isDomNode(a) && isDomNode(b)) {
+        return a.isEqualNode(b);
+    }
+    var length = aStack.length;
+    while (length--) {
+        if (aStack[length] === a) {
+            return bStack[length] === b;
+        }
+        else if (bStack[length] === b) {
+            return false;
+        }
+    }
+    aStack.push(a);
+    bStack.push(b);
+    var size = 0;
+    if (className == '[object Array]') {
+        size = a.length;
+        if (size !== b.length) {
+            return false;
+        }
+        while (size--) {
+            result = eq(a[size], b[size], aStack, bStack, customTesters, hasKey);
+            if (!result) {
+                return false;
+            }
+        }
+    }
+    var aKeys = keys(a, className == '[object Array]', hasKey), key;
+    size = aKeys.length;
+    if (keys(b, className == '[object Array]', hasKey).length !== size) {
+        return false;
+    }
+    while (size--) {
+        key = aKeys[size];
+        result =
+            hasKey(b, key) &&
+                eq(a[key], b[key], aStack, bStack, customTesters, hasKey);
+        if (!result) {
+            return false;
+        }
+    }
+    aStack.pop();
+    bStack.pop();
+    return result;
+}
+function keys(obj, isArray, hasKey) {
+    var allKeys = (function (o) {
+        var keys = [];
+        for (var key in o) {
+            if (hasKey(o, key)) {
+                keys.push(key);
+            }
+        }
+        return keys.concat(Object.getOwnPropertySymbols(o).filter(symbol => Object.getOwnPropertyDescriptor(o, symbol)
+            .enumerable));
+    })(obj);
+    if (!isArray) {
+        return allKeys;
+    }
+    var extraKeys = [];
+    if (allKeys.length === 0) {
+        return allKeys;
+    }
+    for (var x = 0; x < allKeys.length; x++) {
+        if (typeof allKeys[x] === 'symbol' || !allKeys[x].match(/^[0-9]+$/)) {
+            extraKeys.push(allKeys[x]);
+        }
+    }
+    return extraKeys;
+}
+function hasDefinedKey(obj, key) {
+    return hasKey(obj, key) && obj[key] !== undefined;
+}
+function hasKey(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function isA(typeName, value) {
+    return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
+}
+exports.isA = isA;
+function isDomNode(obj) {
+    return (obj !== null &&
+        typeof obj === 'object' &&
+        typeof obj.nodeType === 'number' &&
+        typeof obj.nodeName === 'string' &&
+        typeof obj.isEqualNode === 'function');
+}
+function fnNameFor(func) {
+    if (func.name) {
+        return func.name;
+    }
+    const matches = functionToString
+        .call(func)
+        .match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
+    return matches ? matches[1] : '<anonymous>';
+}
+exports.fnNameFor = fnNameFor;
+function isUndefined(obj) {
+    return obj === void 0;
+}
+exports.isUndefined = isUndefined;
+function getPrototype(obj) {
+    if (Object.getPrototypeOf) {
+        return Object.getPrototypeOf(obj);
+    }
+    if (obj.constructor.prototype == obj) {
+        return null;
+    }
+    return obj.constructor.prototype;
+}
+function hasProperty(obj, property) {
+    if (!obj) {
+        return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(obj, property)) {
+        return true;
+    }
+    return hasProperty(getPrototype(obj), property);
+}
+exports.hasProperty = hasProperty;
+const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
+const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
+const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
+function isImmutableUnorderedKeyed(maybeKeyed) {
+    return !!(maybeKeyed &&
+        maybeKeyed[IS_KEYED_SENTINEL] &&
+        !maybeKeyed[IS_ORDERED_SENTINEL]);
+}
+exports.isImmutableUnorderedKeyed = isImmutableUnorderedKeyed;
+function isImmutableUnorderedSet(maybeSet) {
+    return !!(maybeSet &&
+        maybeSet[IS_SET_SENTINEL] &&
+        !maybeSet[IS_ORDERED_SENTINEL]);
+}
+exports.isImmutableUnorderedSet = isImmutableUnorderedSet;

package/lib/matchers/element/toHaveChildren.js

@@ -10,9 +10,15 @@ async function condition(el, gte, lte, eq) {
         value: children.length
     };
 }
-function toHaveChildrenFn(received, options = {}) {
+function toHaveChildrenFn(received, size, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'children', verb = 'have' } = this;
+    if (typeof size === 'number') {
+        options.eq = size;
+    }
+    else if (typeof size === 'object') {
+        options = { ...options, ...size };
+    }
     const eq = options.eq;
     const gte = options.gte || 1;
     const lte = options.lte || 0;
@@ -27,7 +33,8 @@ function toHaveChildrenFn(received, options = {}) {
         }, isNot, options);
         utils_1.updateElementsArray(pass, received, el);
         const error = utils_1.numberError(gte, lte, eq);
-        const message = utils_1.enhanceError(el, error, utils_1.wrapExpectedWithArray(el, children, error), this, verb, expectation, '', options);
+        const expected = utils_1.wrapExpectedWithArray(el, children, error);
+        const message = utils_1.enhanceError(el, expected, children, this, verb, expectation, '', options);
         return {
             pass,
             message: () => message