expect-webdriverio 1.3.1 → 2.0.1

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

@@ -1,34 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toBeRequestedWithResponse = void 0;
-const utils_1 = require("../../utils");
+const toBeRequestedWith_1 = require("./toBeRequestedWith");
 const expectAdapter_1 = require("../../util/expectAdapter");
-const jasmineUtils_1 = require("../../jasmineUtils");
 function toBeRequestedWithResponseFn(received, response, options = {}) {
-    const isNot = this.isNot || false;
-    const { expectation = 'called', verb = 'be' } = this;
-    return browser.call(async () => {
-        let actual;
-        const pass = await utils_1.waitUntil(async () => {
-            if (received.calls.length === 0) {
-                return isNot;
-            }
-            if (isNot) {
-                return !received.calls.reduce((res, mock) => res || jasmineUtils_1.equals(mock === null || mock === void 0 ? void 0 : mock.body, response), false);
-            }
-            return Boolean(received.calls.find((mock) => {
-                actual = mock === null || mock === void 0 ? void 0 : mock.body;
-                return !isNot === jasmineUtils_1.equals(mock === null || mock === void 0 ? void 0 : mock.body, response);
-            }));
-        });
-        const message = utils_1.enhanceError('mock', response, actual, this, verb, expectation, '', options);
-        return {
-            pass,
-            message: () => message
-        };
-    });
+    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

@@ -29,6 +29,7 @@ const matchers = {
     ...require('./matchers/element/toHaveValueContaining'),
     ...require('./matchers/mock/toBeRequested'),
     ...require('./matchers/mock/toBeRequestedTimes'),
+    ...require('./matchers/mock/toBeRequestedWith'),
     ...require('./matchers/mock/toBeRequestedWithResponse'),
 };
 Object.keys(matchers).forEach(key => {

package/lib/options.js

@@ -21,11 +21,13 @@ else {
 if (!expectLib._expectWebdriverio) {
     expectLib._expectWebdriverio = { options: { ...DEFAULT_OPTIONS }, mode };
 }
-exports.getConfig = () => expectLib._expectWebdriverio;
-exports.setDefaultOptions = (options = {}) => {
+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

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

package/lib/util/expectAdapter.js

@@ -4,22 +4,25 @@ exports.runExpect = exports.jestResultToJasmine = exports.buildJasmineFromJestRe
 const options_1 = require("../options");
 const config = options_1.getConfig();
 const { mode: MODE } = config;
-exports.getContext = (context) => global === context ? {} : context || {};
+const getContext = (context) => global === context ? {} : context || {};
+exports.getContext = getContext;
 function runJestExpect(fn, args) {
     return fn.apply(this, args);
 }
-exports.buildJasmineFromJestResult = (result, isNot) => {
+const buildJasmineFromJestResult = (result, isNot) => {
     return {
         pass: result.pass !== isNot,
         message: result.message()
     };
 };
-exports.jestResultToJasmine = (result, isNot) => {
+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 {

package/lib/util/formatMessage.js

@@ -2,18 +2,20 @@
 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;
-exports.getSelector = (el) => {
+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.getSelectors = (el) => {
+exports.getSelector = getSelector;
+const getSelectors = (el) => {
     const selectors = [];
     let parent;
     if (Array.isArray(el)) {
@@ -31,10 +33,12 @@ exports.getSelectors = (el) => {
     }
     return selectors.reverse().join('.');
 };
-exports.not = (isNot) => {
+exports.getSelectors = getSelectors;
+const not = (isNot) => {
     return `${isNot ? 'not ' : ''}`;
 };
-exports.enhanceError = (subject, expected, actual, context, verb, expectation, arg2 = '', { message = '', containing = false }) => {
+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 = '';
@@ -45,7 +49,7 @@ exports.enhanceError = (subject, expected, actual, context, verb, expectation, a
         verb += ' ';
     }
     let diffString;
-    if (isNot && actual === expected) {
+    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)}`;
     }
@@ -66,10 +70,12 @@ exports.enhanceError = (subject, expected, actual, context, verb, expectation, a
     const msg = `${message}Expect ${subject} ${exports.not(isNot)}to ${verb}${expectation}${arg2}${contain}\n\n${diffString}`;
     return msg;
 };
-exports.enhanceErrorBe = (subject, pass, context, verb, expectation, options) => {
+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.numberError = (gte, lte, eq) => {
+exports.enhanceErrorBe = enhanceErrorBe;
+const numberError = (gte, lte, eq) => {
     if (typeof eq === 'number') {
         return eq;
     }
@@ -78,3 +84,4 @@ exports.numberError = (gte, lte, eq) => {
     error += lte ? ` && <= ${lte}` : '';
     return error;
 };
+exports.numberError = numberError;

package/lib/util/refetchElements.js

@@ -4,7 +4,7 @@ exports.refetchElements = void 0;
 const options_1 = require("../options");
 const config = options_1.getConfig();
 const { options: DEFAULT_OPTIONS } = config;
-exports.refetchElements = async (elements, wait = DEFAULT_OPTIONS.wait, full = false) => {
+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);
@@ -12,3 +12,4 @@ exports.refetchElements = async (elements, wait = DEFAULT_OPTIONS.wait, full = f
     }
     return elements;
 };
+exports.refetchElements = refetchElements;

package/lib/utils.js

@@ -1,6 +1,6 @@
 "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.compareText = void 0;
+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; } });
@@ -44,7 +44,8 @@ const waitUntil = async (condition, isNot = false, { wait = DEFAULT_OPTIONS.wait
 exports.waitUntil = waitUntil;
 async function executeCommandBe(received, command, options) {
     const { isNot, expectation, verb = 'be' } = this;
-    let el = await received;
+    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;
@@ -68,7 +69,7 @@ const compareNumbers = (actual, gte, lte, eq) => {
     return actual >= gte;
 };
 exports.compareNumbers = compareNumbers;
-exports.compareText = (actual, expected, { ignoreCase = false, trim = false, containing = false }) => {
+const compareText = (actual, expected, { ignoreCase = false, trim = false, containing = false }) => {
     if (typeof actual !== 'string') {
         return {
             value: actual,
@@ -93,6 +94,34 @@ exports.compareText = (actual, expected, { ignoreCase = false, trim = false, con
         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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "1.3.1",
+  "version": "2.0.1",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
@@ -9,10 +9,11 @@
     "clean:build": "rimraf ./lib",
     "clean:tests": "rimraf test-types/**/node_modules && rimraf test-types/**/dist",
     "compile": "tsc --build tsconfig.build.json",
-    "release": "npm run release:patch",
-    "release:patch": "np patch",
-    "release:minor": "np minor",
-    "release:major": "np major",
+    "release": "release-it --github.release",
+    "release:ci": "npm run release -- --ci --npm.skipChecks --no-git.requireCleanWorkingDir",
+    "release:patch": "npm run release -- patch",
+    "release:minor": "npm run release -- minor",
+    "release:major": "npm run release -- major",
     "test": "run-s test:*",
     "test:lint": "eslint . --ext .js,.jsx,.ts,.tsx",
     "test:unit": "jest",
@@ -21,7 +22,8 @@
     "ts": "run-p ts:*",
     "ts:default": "cd test-types/default && tsc --incremental",
     "ts:jest": "cd test-types/jest && tsc --incremental",
-    "ts:jasmine": "cd test-types/jasmine && tsc --incremental"
+    "ts:jasmine": "cd test-types/jasmine && tsc --incremental",
+    "prepare": "husky install"
   },
   "repository": {
     "type": "git",
@@ -40,32 +42,28 @@
   },
   "homepage": "https://github.com/webdriverio/expect-webdriverio#readme",
   "devDependencies": {
-    "@types/jasmine": "^3.5.11",
-    "@types/jest": "^26.0.4",
-    "@types/node": "^14.0.23",
-    "@typescript-eslint/eslint-plugin": "^3.6.1",
-    "@typescript-eslint/parser": "^3.6.1",
-    "codecov": "^3.7.0",
-    "eslint": "^7.4.0",
-    "husky": "^4.2.5",
-    "jest": "^26.1.0",
-    "np": "^6.3.2",
+    "@types/jasmine": "^3.6.6",
+    "@types/jest": "^26.0.20",
+    "@types/node": "^14.14.33",
+    "@typescript-eslint/eslint-plugin": "^4.17.0",
+    "@typescript-eslint/parser": "^4.17.0",
+    "codecov": "^3.8.1",
+    "eslint": "^7.21.0",
+    "husky": "^5.1.3",
+    "jest": "^26.6.3",
     "npm-run-all": "^4.1.5",
+    "release-it": "^14.4.1",
     "rimraf": "^3.0.2",
     "shelljs": "^0.8.4",
-    "ts-jest": "^26.1.3",
-    "typescript": "^3.9.7",
-    "webdriverio": "^6.3.0"
+    "ts-jest": "^26.5.3",
+    "ts-node": "^9.1.1",
+    "typescript": "^4.2.3",
+    "webdriverio": "^7.1.1"
   },
   "types": "types/jest-global.d.ts",
   "typeScriptVersion": "3.8.3",
-  "husky": {
-    "hooks": {
-      "pre-commit": "run-s compile"
-    }
-  },
   "dependencies": {
-    "expect": "^26.1.0",
-    "jest-matcher-utils": "^26.1.0"
+    "expect": "^26.6.2",
+    "jest-matcher-utils": "^26.6.2"
   }
 }