codeceptjs 3.5.12-beta.5 → 3.5.12-beta.7

package/lib/helper/MockServer.js

@@ -0,0 +1,215 @@
+const { mock, settings } = require('pactum');
+
+/**
+ * ## Configuration
+ *
+ * This helper should be configured in codecept.conf.(js|ts)
+ *
+ * @typedef MockServerConfig
+ * @type {object}
+ * @prop {number} [port=9393] - Mock server port
+ * @prop {string} [host="0.0.0.0"] - Mock server host
+ * @prop {object} [httpsOpts] - key & cert values are the paths to .key and .crt files
+ */
+let config = {
+  port: 9393,
+  host: '0.0.0.0',
+  httpsOpts: {
+    key: '',
+    cert: '',
+  },
+};
+
+/**
+ * MockServer
+ *
+ * The MockServer Helper in CodeceptJS empowers you to mock any server or service via HTTP or HTTPS, making it an excellent tool for simulating REST endpoints and other HTTP-based APIs.
+ *
+ * <!-- configuration -->
+ *
+ * #### Examples
+ *
+ * You can seamlessly integrate MockServer with other helpers like REST or Playwright. Here's a configuration example inside the `codecept.conf.js` file:
+ *
+ * ```javascript
+ * {
+ *   helpers: {
+ *     REST: {...},
+ *     MockServer: {
+ *       // default mock server config
+ *       port: 9393,
+ *       host: '0.0.0.0',
+ *       httpsOpts: {
+ *         key: '',
+ *         cert: '',
+ *       },
+ *     },
+ *   }
+ * }
+ * ```
+ *
+ * #### Adding Interactions
+ *
+ * Interactions add behavior to the mock server. Use the `I.addInteractionToMockServer()` method to include interactions. It takes an interaction object as an argument, containing request and response details.
+ *
+ * ```javascript
+ * I.addInteractionToMockServer({
+ *    request: {
+ *      method: 'GET',
+ *      path: '/api/hello'
+ *    },
+ *    response: {
+ *      status: 200,
+ *      body: {
+ *        'say': 'hello to mock server'
+ *      }
+ *    }
+ * });
+ * ```
+ *
+ * #### Request Matching
+ *
+ * When a real request is sent to the mock server, it matches the received request with the interactions. If a match is found, it returns the specified response; otherwise, a 404 status code is returned.
+ *
+ * - Strong match on HTTP Method, Path, Query Params & JSON body.
+ * - Loose match on Headers.
+ *
+ * ##### Strong Match on Query Params
+ *
+ * You can send different responses based on query parameters:
+ *
+ * ```javascript
+ * I.addInteractionToMockServer({
+ *   request: {
+ *     method: 'GET',
+ *     path: '/api/users',
+ *     queryParams: {
+ *       id: 1
+ *     }
+ *   },
+ *   response: {
+ *     status: 200,
+ *     body: 'user 1'
+ *   }
+ * });
+ *
+ * I.addInteractionToMockServer({
+ *   request: {
+ *     method: 'GET',
+ *     path: '/api/users',
+ *     queryParams: {
+ *       id: 2
+ *     }
+ *   },
+ *   response: {
+ *     status: 200,
+ *     body: 'user 2'
+ *   }
+ * });
+ * ```
+ *
+ * - GET to `/api/users?id=1` will return 'user 1'.
+ * - GET to `/api/users?id=2` will return 'user 2'.
+ * - For all other requests, it returns a 404 status code.
+ *
+ * ##### Loose Match on Body
+ *
+ * When `strict` is set to false, it performs a loose match on query params and response body:
+ *
+ * ```javascript
+ * I.addInteractionToMockServer({
+ *   strict: false,
+ *   request: {
+ *     method: 'POST',
+ *     path: '/api/users',
+ *     body: {
+ *       name: 'john'
+ *     }
+ *   },
+ *   response: {
+ *     status: 200
+ *   }
+ * });
+ * ```
+ *
+ * - POST to `/api/users` with the body containing `name` as 'john' will return a 200 status code.
+ * - POST to `/api/users` without the `name` property in the body will return a 404 status code.
+ *
+ * Happy testing with MockServer in CodeceptJS! 🚀
+ *
+ * ## Methods
+ */
+class MockServer {
+  constructor(passedConfig) {
+    settings.setLogLevel('SILENT');
+    config = { ...passedConfig };
+    if (global.debugMode) {
+      settings.setLogLevel('VERBOSE');
+    }
+  }
+
+  /**
+   * Start the mock server
+   * @param {number} [port] start the mock server with given port
+   */
+  async startMockServer(port) {
+    const _config = { ...config };
+    if (port) _config.port = port;
+    await mock.setDefaults(_config);
+    await mock.start();
+  }
+
+  /**
+   * Stop the mock server
+   *
+   */
+  async stopMockServer() {
+    await mock.stop();
+  }
+
+  /**
+   * An interaction adds behavior to the mock server
+   *
+   *
+   * ```js
+   * I.addInteractionToMockServer({
+   *    request: {
+   *      method: 'GET',
+   *      path: '/api/hello'
+   *    },
+   *    response: {
+   *      status: 200,
+   *      body: {
+   *        'say': 'hello to mock server'
+   *      }
+   *    }
+   * });
+   * ```
+   * ```js
+   * // with query params
+   * I.addInteractionToMockServer({
+   *    request: {
+   *      method: 'GET',
+   *      path: '/api/hello',
+   *      queryParams: {
+   *       id: 2
+   *     }
+   *    },
+   *    response: {
+   *      status: 200,
+   *      body: {
+   *        'say': 'hello to mock server'
+   *      }
+   *    }
+   * });
+   * ```
+   *
+   * @param {CodeceptJS.MockInteraction|object} interaction add behavior to the mock server
+   *
+   */
+  async addInteractionToMockServer(interaction) {
+    await mock.addInteraction(interaction);
+  }
+}
+
+module.exports = MockServer;

package/lib/helper/Playwright.js

@@ -47,6 +47,9 @@ const {
   setRestartStrategy, restartsSession, restartsContext, restartsBrowser,
 } = require('./extras/PlaywrightRestartOpts');
 const { createValueEngine, createDisabledEngine } = require('./extras/PlaywrightPropEngine');
+const {
+  seeElementError, dontSeeElementError, dontSeeElementInDOMError, seeElementInDOMError,
+} = require('./errors/ElementAssertion');
 
 const pathSeparator = path.sep;
 
@@ -1451,7 +1454,11 @@ class Playwright extends Helper {
   async seeElement(locator) {
     let els = await this._locate(locator);
     els = await Promise.all(els.map(el => el.isVisible()));
-    return empty('visible elements').negate(els.filter(v => v).fill('ELEMENT'));
+    try {
+      return empty('visible elements').negate(els.filter(v => v).fill('ELEMENT'));
+    } catch (e) {
+      dontSeeElementError(locator);
+    }
   }
 
   /**
@@ -1461,7 +1468,11 @@ class Playwright extends Helper {
   async dontSeeElement(locator) {
     let els = await this._locate(locator);
     els = await Promise.all(els.map(el => el.isVisible()));
-    return empty('visible elements').assert(els.filter(v => v).fill('ELEMENT'));
+    try {
+      return empty('visible elements').assert(els.filter(v => v).fill('ELEMENT'));
+    } catch (e) {
+      seeElementError(locator);
+    }
   }
 
   /**
@@ -1469,7 +1480,11 @@ class Playwright extends Helper {
    */
   async seeElementInDOM(locator) {
     const els = await this._locate(locator);
-    return empty('elements on page').negate(els.filter(v => v).fill('ELEMENT'));
+    try {
+      return empty('elements on page').negate(els.filter(v => v).fill('ELEMENT'));
+    } catch (e) {
+      dontSeeElementInDOMError(locator);
+    }
   }
 
   /**
@@ -1477,7 +1492,11 @@ class Playwright extends Helper {
    */
   async dontSeeElementInDOM(locator) {
     const els = await this._locate(locator);
-    return empty('elements on a page').assert(els.filter(v => v).fill('ELEMENT'));
+    try {
+      return empty('elements on a page').assert(els.filter(v => v).fill('ELEMENT'));
+    } catch (e) {
+      seeElementInDOMError(locator);
+    }
   }
 
   /**
@@ -2169,6 +2188,8 @@ class Playwright extends Helper {
     let chunked = chunkArray(attrs, values.length);
     chunked = chunked.filter((val) => {
       for (let i = 0; i < val.length; ++i) {
+        // the attribute could be a boolean
+        if (typeof val[i] === 'boolean') return val[i] === values[i];
         // if the attribute doesn't exist, returns false as well
         if (!val[i] || !val[i].includes(values[i])) return false;
       }
@@ -2974,27 +2995,27 @@ class Playwright extends Helper {
       throw new Error('Failure in test automation. You use "I.grabRecordedNetworkTraffics", but "I.startRecordingTraffic" was never called before.');
     }
 
-    const requests = await this.requests;
-    const promises = requests.map(async (request) => request.response.then(
-      async (response) => {
-        let body;
-        try {
-          // There's no 'body' for some requests (redirect etc...)
-          body = JSON.parse((await response.body()).toString());
-        } catch (e) {
-          // only interested in JSON, not HTML responses.
-        }
+    const promises = this.requests.map(async (request) => {
+      const resp = await request.response;
+      let body;
+      try {
+        // There's no 'body' for some requests (redirect etc...)
+        body = JSON.parse((await resp.body()).toString());
+      } catch (e) {
+        // only interested in JSON, not HTML responses.
+      }
 
-        request.response = {
-          status: response.status(),
-          statusText: response.statusText(),
+      return {
+        url: resp.url(),
+        response: {
+          status: resp.status(),
+          statusText: resp.statusText(),
           body,
-        };
-      },
-    ));
-    await Promise.all(promises);
+        },
+      };
+    });
 
-    return this.requests;
+    return Promise.all(promises);
   }
 
   /**

package/lib/helper/Puppeteer.js

@@ -39,6 +39,9 @@ const findReact = require('./extras/React');
 const { highlightElement } = require('./scripts/highlightElement');
 const { blurElement } = require('./scripts/blurElement');
 const { focusElement } = require('./scripts/focusElement');
+const {
+  dontSeeElementError, seeElementError, dontSeeElementInDOMError, seeElementInDOMError,
+} = require('./errors/ElementAssertion');
 
 let puppeteer;
 let perfTiming;
@@ -1038,8 +1041,11 @@ class Puppeteer extends Helper {
     els = (await Promise.all(els.map(el => el.boundingBox() && el))).filter(v => v);
     // Puppeteer visibility was ignored? | Remove when Puppeteer is fixed
     els = await Promise.all(els.map(async el => (await el.evaluate(node => window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none')) && el));
-
-    return empty('visible elements').negate(els.filter(v => v).fill('ELEMENT'));
+    try {
+      return empty('visible elements').negate(els.filter(v => v).fill('ELEMENT'));
+    } catch (e) {
+      dontSeeElementError(locator);
+    }
   }
 
   /**
@@ -1051,8 +1057,11 @@ class Puppeteer extends Helper {
     els = (await Promise.all(els.map(el => el.boundingBox() && el))).filter(v => v);
     // Puppeteer visibility was ignored? | Remove when Puppeteer is fixed
     els = await Promise.all(els.map(async el => (await el.evaluate(node => window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none')) && el));
-
-    return empty('visible elements').assert(els.filter(v => v).fill('ELEMENT'));
+    try {
+      return empty('visible elements').assert(els.filter(v => v).fill('ELEMENT'));
+    } catch (e) {
+      seeElementError(locator);
+    }
   }
 
   /**
@@ -1060,7 +1069,11 @@ class Puppeteer extends Helper {
    */
   async seeElementInDOM(locator) {
     const els = await this._locate(locator);
-    return empty('elements on page').negate(els.filter(v => v).fill('ELEMENT'));
+    try {
+      return empty('elements on page').negate(els.filter(v => v).fill('ELEMENT'));
+    } catch (e) {
+      dontSeeElementInDOMError(locator);
+    }
   }
 
   /**
@@ -1068,7 +1081,11 @@ class Puppeteer extends Helper {
    */
   async dontSeeElementInDOM(locator) {
     const els = await this._locate(locator);
-    return empty('elements on a page').assert(els.filter(v => v).fill('ELEMENT'));
+    try {
+      return empty('elements on a page').assert(els.filter(v => v).fill('ELEMENT'));
+    } catch (e) {
+      seeElementInDOMError(locator);
+    }
   }
 
   /**
@@ -1825,6 +1842,8 @@ class Puppeteer extends Helper {
       for (let i = 0; i < val.length; ++i) {
         const _actual = Number.isNaN(val[i]) || (typeof values[i]) === 'string' ? val[i] : Number.parseInt(values[i], 10);
         const _expected = Number.isNaN(values[i]) || (typeof values[i]) === 'string' ? values[i] : Number.parseInt(values[i], 10);
+        // the attribute could be a boolean
+        if (typeof _actual === 'boolean') return _actual === _expected;
         // if the attribute doesn't exist, returns false as well
         if (!_actual || !_actual.includes(_expected)) return false;
       }

package/lib/helper/WebDriver.js

@@ -32,6 +32,9 @@ const { highlightElement } = require('./scripts/highlightElement');
 const store = require('../store');
 const { focusElement } = require('./scripts/focusElement');
 const { blurElement } = require('./scripts/blurElement');
+const {
+  dontSeeElementError, seeElementError, seeElementInDOMError, dontSeeElementInDOMError,
+} = require('./errors/ElementAssertion');
 
 const SHADOW = 'shadow';
 const webRoot = 'body';
@@ -1461,7 +1464,11 @@ class WebDriver extends Helper {
     const res = await this._locate(locator, true);
     assertElementExists(res, locator);
     const selected = await forEachAsync(res, async el => el.isDisplayed());
-    return truth(`elements of ${(new Locator(locator))}`, 'to be seen').assert(selected);
+    try {
+      return truth(`elements of ${(new Locator(locator))}`, 'to be seen').assert(selected);
+    } catch (e) {
+      dontSeeElementError(locator);
+    }
   }
 
   /**
@@ -1474,7 +1481,11 @@ class WebDriver extends Helper {
       return truth(`elements of ${(new Locator(locator))}`, 'to be seen').negate(false);
     }
     const selected = await forEachAsync(res, async el => el.isDisplayed());
-    return truth(`elements of ${(new Locator(locator))}`, 'to be seen').negate(selected);
+    try {
+      return truth(`elements of ${(new Locator(locator))}`, 'to be seen').negate(selected);
+    } catch (e) {
+      seeElementError(locator);
+    }
   }
 
   /**
@@ -1483,7 +1494,11 @@ class WebDriver extends Helper {
    */
   async seeElementInDOM(locator) {
     const res = await this._res(locator);
-    return empty('elements').negate(res);
+    try {
+      return empty('elements').negate(res);
+    } catch (e) {
+      dontSeeElementInDOMError(locator);
+    }
   }
 
   /**
@@ -1492,7 +1507,11 @@ class WebDriver extends Helper {
    */
   async dontSeeElementInDOM(locator) {
     const res = await this._res(locator);
-    return empty('elements').assert(res);
+    try {
+      return empty('elements').assert(res);
+    } catch (e) {
+      seeElementInDOMError(locator);
+    }
   }
 
   /**
@@ -1612,6 +1631,8 @@ class WebDriver extends Helper {
       for (let i = 0; i < val.length; ++i) {
         const _actual = Number.isNaN(val[i]) || (typeof values[i]) === 'string' ? val[i] : Number.parseInt(val[i], 10);
         const _expected = Number.isNaN(values[i]) || (typeof values[i]) === 'string' ? values[i] : Number.parseInt(values[i], 10);
+        // the attribute could be a boolean
+        if (typeof _actual === 'boolean') return _actual === _expected;
         if (_actual !== _expected) return false;
       }
       return true;

package/lib/helper/errors/ElementAssertion.js

@@ -0,0 +1,38 @@
+const Locator = require('../../locator');
+
+const prefixMessage = 'Element';
+
+function seeElementError(locator) {
+  if (typeof locator === 'object') {
+    locator = JSON.stringify(locator);
+  }
+  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is still visible on page.`);
+}
+
+function seeElementInDOMError(locator) {
+  if (typeof locator === 'object') {
+    locator = JSON.stringify(locator);
+  }
+  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is still seen in DOM.`);
+}
+
+function dontSeeElementError(locator) {
+  if (typeof locator === 'object') {
+    locator = JSON.stringify(locator);
+  }
+  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is not visible on page.`);
+}
+
+function dontSeeElementInDOMError(locator) {
+  if (typeof locator === 'object') {
+    locator = JSON.stringify(locator);
+  }
+  throw new Error(`${prefixMessage} "${(new Locator(locator))}" is not seen in DOM.`);
+}
+
+module.exports = {
+  seeElementError,
+  dontSeeElementError,
+  seeElementInDOMError,
+  dontSeeElementInDOMError,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "3.5.12-beta.5",
+  "version": "3.5.12-beta.7",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",
@@ -23,7 +23,6 @@
   },
   "files": [
     "bin",
-    "docs",
     "lib",
     "translations",
     "typings/**/*.d.ts"
@@ -56,6 +55,7 @@
     "test:unit:webbapi:webDriver:devtools": "mocha test/helper/WebDriver_devtools_test.js --exit",
     "test:unit:webbapi:testCafe": "mocha test/helper/TestCafe_test.js",
     "test:unit:expect": "mocha test/helper/Expect_test.js",
+    "test:unit:mockServer": "mocha test/helper/MockServer_test.js",
     "test:plugin": "mocha test/plugin/plugin_test.js",
     "def": "./runok.js def",
     "dev:graphql": "node test/data/graphql/index.js",
@@ -105,6 +105,7 @@
     "ms": "2.1.3",
     "openai": "3.2.1",
     "ora-classic": "5.4.2",
+    "pactum": "3.6.0",
     "parse-function": "5.6.4",
     "parse5": "7.1.2",
     "promise-retry": "1.1.1",
@@ -133,7 +134,7 @@
     "contributor-faces": "1.1.0",
     "documentation": "12.3.0",
     "dtslint": "4.2.1",
-    "electron": "28.0.0",
+    "electron": "28.1.4",
     "eslint": "8.56.0",
     "eslint-config-airbnb-base": "15.0.0",
     "eslint-plugin-import": "2.29.1",
@@ -146,7 +147,7 @@
     "jsdoc": "3.6.11",
     "jsdoc-typeof-plugin": "1.0.0",
     "json-server": "0.10.1",
-    "playwright": "1.40.1",
+    "playwright": "1.41.1",
     "puppeteer": "21.1.1",
     "qrcode-terminal": "0.12.0",
     "rosie": "2.1.1",
@@ -161,7 +162,7 @@
     "typedoc-plugin-markdown": "3.17.1",
     "typescript": "5.3.3",
     "wdio-docker-service": "1.5.0",
-    "webdriverio": "8.27.2",
+    "webdriverio": "8.28.8",
     "xml2js": "0.6.2",
     "xpath": "0.0.34"
   },

package/typings/index.d.ts

@@ -382,6 +382,22 @@ declare namespace CodeceptJS {
     [key: string]: any;
   };
 
+  type MockRequest = {
+    method: 'GET'|'PUT'|'POST'|'PATCH'|'DELETE'|string;
+    path: string;
+    queryParams?: object;
+  }
+
+  type MockResponse = {
+    status: number;
+    body?: object;
+  }
+
+  type MockInteraction = {
+    request: MockRequest;
+    response: MockResponse;
+  }
+
   interface PageScrollPosition {
     x: number;
     y: number;