cypress-fail-on-network-error 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 nils-hoyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# cypress-fail-on-network-error
+
+This Plugin observes network requests through cypress network events. Cypress test will fail when the error conditions are met. For observing `console.error()` please check out [cypress-fail-on-console-error](https://www.npmjs.com/package/cypress-fail-on-console-error).
+
+### Installation
+
+```
+npm install cypress-fail-on-network-error --save-dev
+```
+
+### Usage
+
+`cypress/support/e2e.js`
+
+```js
+import failOnNetworkError, { Config, Request } from 'cypress-fail-on-network-error';
+
+const config: Config = {
+    requests: [
+        'simpleUrlToExclude',
+        { url: 'simpleUrlToExclude', method: 'GET', status: 400 },
+        { url: /urlToExclude/, method: 'POST', status: 428 },
+        { status: 430 },
+        { status: { from: 200, to: 399 } },
+    ],
+};
+
+failOnNetworkError(config)
+```
+
+### Config
+
+| Parameter             | Default               | <div style="width:300px">Description</div>    |
+|---                    |---                    |---                                            |
+| `requests`     | `[]` | Exclude requests from throwing `AssertionError`. Types `string`, `RegExp`, `Request` are accepted. `string` and `request.url` will be converted to type `RegExp`. [String.match()](https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/String/match) will be used for matching. |                                   
+
+<br/>
+
+### Set config from cypress test 
+Use `failOnNetworkError` functions `getConfig()` and `setConfig()` with your own requirements. Detailed example implementation [cypress comands](https://github.com/nils-hoyer/cypress-fail-on-network-error/blob/main/cypress/support/e2e.ts#L14-L64) & [cypress test](https://github.com/nils-hoyer/cypress-fail-on-network-error/blob/main/cypress/e2e/shouldfailOnNetworkError.cy.ts#L1-L25). Note that the config will be resetted to initial config between tests.
+```js
+const { getConfig, setConfig } = failOnNetworkError(config);
+
+Cypress.Commands.addAll({
+    getConfigRequests: () => {
+        return cy.wrap(getConfig().requests);
+    },
+    setConfigRequests: (requests: (string | Request)[]) => {
+        setConfig({ ...getConfig(), requests });
+    },
+});
+```
+
+```js
+describe('example test', () => {
+    it('should set exclude requests', () => {
+        cy.setConfigRequests(['urlToExclude']);
+        cy.visit('url');
+    });
+});
+```
+
+### Wait for all pending requests to be resolved
+Use `failOnNetworkError` function `waitForRequests()` to wait until all pending requests are resolved. The default timeout is 10000 ms which can be changed by overriding the default value `waitForRequests(5000)`. When reaching the timeout, Cypress test execution will continue without throwing an timeout exception.
+Detailed documenation for [cypress comands](https://github.com/nils-hoyer/cypress-fail-on-network-error/blob/main/cypress/support/e2e.ts#L13-L35) & [cypress test](https://github.com/nils-hoyer/cypress-fail-on-network-error/blob/main/cypress/e2e/shouldWaitForRequests.cy.ts).
+
+```js
+const { waitForRequests } = failOnNetworkError(config);
+
+Cypress.Commands.addAll({
+    waitForRequests: () => waitForRequests(),
+});
+```
+
+```js
+describe('example test', () => {
+    it('should wait for requests to be solved', () => {
+        cy.visit('url');
+        cy.waitForRequests();
+    });
+});
+```
+
+
+### Contributing
+1. Create an project issue with proper description and expected behaviour
+2. Provide a PR with implementation and tests. Command `npm run verify` have to pass locally

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="cypress" />
+/// <reference types="cypress" />
+/// <reference types="cypress" />
+/// <reference types="cypress" />
+export type Config = {
+    requests?: (string | Request)[];
+};
+export interface Request {
+    url?: string | RegExp;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    status?: number | Range;
+}
+export type Range = {
+    from: number;
+    to: number;
+};
+export default function failOnNetworkError(_config?: Config): {
+    getConfig: () => Required<Config>;
+    setConfig: (_config: Config) => void;
+    waitForRequests: (timeout?: number) => Cypress.Chainable<any>;
+};
+export declare const validateConfig: (config: Config) => void;
+export declare const createConfig: (config: Config) => Required<Config>;
+export declare const mapToRequests: (_unknowns: (string | Request)[]) => Request[];
+export declare const findRequest: (requests: RequestSession[], eventRequestId: string) => RequestSession | undefined;
+export declare const isRequestExcluded: (request: RequestSession, config: Required<Config>) => boolean;
+export type RequestSession = {
+    requestId: string;
+    method: string;
+    url: string;
+    status?: number;
+};

package/dist/index.js

@@ -0,0 +1,155 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as chai from 'chai';
+import { AssertionError } from 'chai';
+import typeDetect from 'type-detect';
+export default function failOnNetworkError(_config = {}) {
+    let config;
+    let originConfig;
+    let requests = [];
+    const getRequests = () => requests;
+    const getConfig = () => config;
+    const setConfig = (_config) => {
+        validateConfig(_config);
+        config = createConfig(_config);
+        originConfig = originConfig !== null && originConfig !== void 0 ? originConfig : Object.assign({}, config);
+    };
+    const waitForRequests = (timeout = 10000) => {
+        const requestsDone = () => getRequests().every((request) => request.status !== undefined);
+        return cy.wrap(waitUntil(requestsDone, timeout), {
+            timeout: timeout + 100,
+        });
+    };
+    setConfig(_config);
+    Cypress.on('request:event', (eventName, event) => {
+        const subscribedEvents = [
+            'incoming:request',
+            'request:error',
+            'response:received',
+        ];
+        const unknownResponse = eventName === 'response:received' &&
+            findRequest(requests, event.requestId) === undefined;
+        if (!subscribedEvents || unknownResponse)
+            return;
+        if (eventName === 'incoming:request') {
+            requests.push({
+                requestId: event.requestId,
+                method: event.method,
+                url: event.url,
+                status: undefined,
+            });
+            return;
+        }
+        requests = requests.map((request) => {
+            if (request.requestId !== event.requestId)
+                return request;
+            return Object.assign(Object.assign({}, request), { status: event.status });
+        });
+        if (!isRequestExcluded(findRequest(requests, event.requestId), getConfig())) {
+            throw new AssertionError(`cypress-fail-on-network-error:\n${JSON.stringify(requests)}`);
+        }
+    });
+    Cypress.on('test:after:run', () => __awaiter(this, void 0, void 0, function* () {
+        setConfig(originConfig);
+        requests = [];
+    }));
+    return {
+        getConfig,
+        setConfig,
+        waitForRequests,
+    };
+}
+export const validateConfig = (config) => {
+    var _a;
+    // TODO replace any with Request
+    (_a = config.requests) === null || _a === void 0 ? void 0 : _a.forEach((request) => {
+        if (typeDetect(request) === 'string')
+            return;
+        chai.expect(typeDetect(request.url)).to.be.oneOf([
+            'string',
+            'RegExp',
+            'undefined',
+        ]);
+        chai.expect(typeDetect(request.method)).to.be.oneOf([
+            'string',
+            'undefined',
+        ]);
+        chai.expect(typeDetect(request.status)).to.be.oneOf([
+            'Object',
+            'number',
+            'undefined',
+        ]);
+        if (typeDetect(request.status) === 'Object') {
+            chai.expect(typeDetect(request.status.from)).to.equal('number');
+            chai.expect(typeDetect(request.status.to)).to.equal('number');
+        }
+    });
+};
+//TODO: use Request[] instead of any
+export const createConfig = (config) => {
+    return {
+        requests: config.requests !== undefined ? mapToRequests(config.requests) : [],
+    };
+};
+export const mapToRequests = (_unknowns) => _unknowns.map((unknown) => {
+    if (typeof unknown !== 'string') {
+        let status = undefined;
+        if (unknown.status !== undefined) {
+            status =
+                typeDetect(unknown.status) === 'number'
+                    ? { from: unknown.status, to: unknown.status }
+                    : {
+                        from: unknown.status.from,
+                        to: unknown.status.to,
+                    };
+        }
+        return {
+            url: unknown.url,
+            method: unknown.method,
+            status,
+        };
+    }
+    return {
+        url: unknown,
+        method: undefined,
+        status: undefined,
+    };
+});
+export const findRequest = (requests, eventRequestId) => requests.find((request) => request.requestId === eventRequestId);
+export const isRequestExcluded = (request, config) => {
+    var _a;
+    //TODO: replace any with Request
+    return (_a = config.requests) === null || _a === void 0 ? void 0 : _a.some((configRequest) => {
+        const urlMatch = configRequest.url
+            ? new RegExp(configRequest.url).test(request.url)
+            : true;
+        const statusMatch = configRequest.status
+            ? configRequest.status.from >= request.status &&
+                configRequest.status.to <= request.status
+            : true;
+        const methodMatch = (configRequest === null || configRequest === void 0 ? void 0 : configRequest.method)
+            ? (configRequest === null || configRequest === void 0 ? void 0 : configRequest.method) === request.method
+            : true;
+        return urlMatch && statusMatch && methodMatch;
+    });
+};
+const waitUntil = (predicate, timeout) => {
+    const startTime = new Date().getTime();
+    const isTimeUp = (startTime, timeout) => new Date().getTime() > startTime + timeout;
+    const poll = (resolve) => {
+        if (predicate() || isTimeUp(startTime, timeout)) {
+            resolve();
+        }
+        else {
+            setTimeout(() => poll(resolve), 500);
+        }
+    };
+    return new Cypress.Promise(poll);
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "cypress-fail-on-network-error",
+  "version": "1.0.3",
+  "description": "fail cypress test on network error",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "npm run build:be & npm run build:fe",
+    "build:fe": "npx rimraf dist/ && tsc",
+    "build:be": "node ./backend/app.cjs",
+    "dev": "npm run dev:fe & npm run dev:be",
+    "dev:fe": "nodemon --watch './src' --ext 'ts' --exec 'npm run build:fe'",
+    "dev:be": "nodemon --watch './backend/app.js' --ext 'js' --exec 'npm run build:be'",
+    "prettier": "prettier --write \"**/*\"",
+    "prettier:check": "prettier --check \"**/*\"",
+    "lint": "tsc --noEmit && tsc -p ./test/tsconfig.json && tsc -p ./cypress/tsconfig.json",
+    "test": "npm run test:ut && npm run test:it",
+    "test:ut": "ts-mocha -n loader=ts-node/esm test/unitTest.ts",
+    "test:it": "ts-mocha -n loader=ts-node/esm test/integrationTest.ts --timeout 60000",
+    "verify": "npm run build && npm run lint && npm run prettier:check && npm run test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nils-hoyer/cypress-fail-on-network-error.git"
+  },
+  "keywords": [
+    "cypress",
+    "testing",
+    "network",
+    "request",
+    "response",
+    "error"
+  ],
+  "author": "nils-hoyer",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/nils-hoyer/cypress-fail-on-network-error/issues"
+  },
+  "homepage": "https://github.com/nils-hoyer/cypress-fail-on-network-error#readme",
+  "dependencies": {
+    "chai": "^5.0.0",
+    "type-detect": "^4.0.8"
+  },
+  "devDependencies": {
+    "@types/chai": "4.3.11",
+    "@types/expect": "24.3.0",
+    "@types/mocha": "10.0.6",
+    "@types/type-detect": "4.0.3",
+    "cors": "2.8.5",
+    "cypress": "13.6.2",
+    "express": "4.18.1",
+    "mocha": "10.2.0",
+    "nodemon": "3.0.2",
+    "prettier": "3.1.1",
+    "prettier-plugin-organize-imports": "3.2.4",
+    "rimraf": "5.0.5",
+    "ts-mocha": "10.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "5.2.2"
+  }
+}