codeceptjs 4.0.0-beta.2 → 4.0.0-beta.4

package/lib/helper/Expect.js

@@ -1,425 +0,0 @@
-import * as chai from 'chai';
-import chai_json_schema from 'chai-json-schema';
-import chai_match_pattern from 'chai-match-pattern';
-import chai_exclude from 'chai-exclude';
-import chai_string from 'chai-string';
-import * as output from '../output.js';
-
-chai.use(chai_string);
-// @ts-ignore
-chai.use(chai_exclude);
-chai.use(chai_match_pattern);
-chai.use(chai_json_schema);
-
-/**
- * This helper allows performing assertions based on Chai.
- *
- * ### Examples
- *
- * Zero-configuration when paired with other helpers like REST, Playwright:
- *
- * ```js
- * // inside codecept.conf.js
- *{
- *   helpers: {
- *     Playwright: {...},
- *     Expect: {},
- *   }
- *}
- * ```
- *
- * ## Methods
- */
-class ExpectHelper {
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
-  expectEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to equal "${JSON.stringify(expectedValue)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.equal(expectedValue);
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
-  expectNotEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not equal "${JSON.stringify(expectedValue)}"`);
-    return chai.expect(actualValue, customErrorMsg).not.to.equal(expectedValue);
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-
-     */
-  expectDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to deep equal "${JSON.stringify(expectedValue)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.deep.equal(expectedValue);
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
-  expectNotDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not deep equal "${JSON.stringify(expectedValue)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.not.deep.equal(expectedValue);
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToContain
-     * @param {*} [customErrorMsg]
-     */
-  expectContain(actualValue, expectedValueToContain, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to contain "${JSON.stringify(expectedValueToContain)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.contain(
-      expectedValueToContain,
-    );
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToNotContain
-     * @param {*} [customErrorMsg]
-     */
-  expectNotContain(
-    actualValue,
-    expectedValueToNotContain,
-    customErrorMsg = '',
-  ) {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not contain "${JSON.stringify(expectedValueToNotContain)}"`);
-    return chai.expect(actualValue, customErrorMsg).not.to.contain(
-      expectedValueToNotContain,
-    );
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToStartWith
-     * @param {*} [customErrorMsg]
-     */
-  expectStartsWith(actualValue, expectedValueToStartWith, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to start with "${JSON.stringify(expectedValueToStartWith)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.startsWith(
-      expectedValueToStartWith,
-    );
-  }
-
-  /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToNotStartWith
-     * @param {*} [customErrorMsg]
-     */
-  expectNotStartsWith(
-    actualValue,
-    expectedValueToNotStartWith,
-    customErrorMsg = '',
-  ) {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not start with "${JSON.stringify(expectedValueToNotStartWith)}"`);
-    return chai.expect(actualValue, customErrorMsg).not.to.startsWith(
-      expectedValueToNotStartWith,
-    );
-  }
-
-  /**
-     * @param {*} actualValue
-     * @param {*} expectedValueToEndWith
-     * @param {*} [customErrorMsg]
-     */
-  expectEndsWith(actualValue, expectedValueToEndWith, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to end with "${JSON.stringify(expectedValueToEndWith)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.endsWith(
-      expectedValueToEndWith,
-    );
-  }
-
-  /**
-     * @param {*} actualValue
-     * @param {*} expectedValueToNotEndWith
-     * @param {*} [customErrorMsg]
-     */
-  expectNotEndsWith(
-    actualValue,
-    expectedValueToNotEndWith,
-    customErrorMsg = '',
-  ) {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not end with "${JSON.stringify(expectedValueToNotEndWith)}"`);
-    return chai.expect(actualValue, customErrorMsg).not.to.endsWith(
-      expectedValueToNotEndWith,
-    );
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} jsonSchema
-     * @param {*} [customErrorMsg]
-     */
-  expectJsonSchema(targetData, jsonSchema, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to match this JSON schema "${JSON.stringify(jsonSchema)}"`);
-
-    return chai.expect(targetData, customErrorMsg).to.be.jsonSchema(jsonSchema);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} jsonSchema
-     * @param {*} [customErrorMsg]
-     * @param {*} [ajvOptions] Pass AJV options
-     */
-  expectJsonSchemaUsingAJV(
-    targetData,
-    jsonSchema,
-    customErrorMsg = '',
-    ajvOptions = { allErrors: true },
-  ) {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to match this JSON schema using AJV "${JSON.stringify(jsonSchema)}"`);
-    chai.use(require('chai-json-schema-ajv').create(ajvOptions));
-    return chai.expect(targetData, customErrorMsg).to.be.jsonSchema(jsonSchema);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} propertyName
-     * @param {*} [customErrorMsg]
-     */
-  expectHasProperty(targetData, propertyName, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to have property: "${JSON.stringify(propertyName)}"`);
-    return chai.expect(targetData, customErrorMsg).to.have.property(propertyName);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} propertyName
-     * @param {*} [customErrorMsg]
-     */
-  expectHasAProperty(targetData, propertyName, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to have a property: "${JSON.stringify(propertyName)}"`);
-    return chai.expect(targetData, customErrorMsg).to.have.a.property(propertyName);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} type
-     * @param {*} [customErrorMsg]
-     */
-  expectToBeA(targetData, type, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be a "${JSON.stringify(type)}"`);
-    return chai.expect(targetData, customErrorMsg).to.be.a(type);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} type
-     * @param {*} [customErrorMsg]
-     */
-  expectToBeAn(targetData, type, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be an "${JSON.stringify(type)}"`);
-    return chai.expect(targetData, customErrorMsg).to.be.an(type);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} regex
-     * @param {*} [customErrorMsg]
-     */
-  expectMatchRegex(targetData, regex, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to match the regex "${JSON.stringify(regex)}"`);
-    return chai.expect(targetData, customErrorMsg).to.match(regex);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} length
-     * @param {*} [customErrorMsg]
-     */
-  expectLengthOf(targetData, length, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to have length of "${JSON.stringify(length)}"`);
-    return chai.expect(targetData, customErrorMsg).to.have.lengthOf(length);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} [customErrorMsg]
-     */
-  expectEmpty(targetData, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be empty`);
-    return chai.expect(targetData, customErrorMsg).to.be.empty;
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} [customErrorMsg]
-     */
-  expectTrue(targetData, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be true`);
-    return chai.expect(targetData, customErrorMsg).to.be.true;
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} [customErrorMsg]
-     */
-  expectFalse(targetData, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be false`);
-    return chai.expect(targetData, customErrorMsg).to.be.false;
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} aboveThan
-     * @param {*} [customErrorMsg]
-     */
-  expectAbove(targetData, aboveThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be above ${JSON.stringify(aboveThan)}`);
-    return chai.expect(targetData, customErrorMsg).to.be.above(aboveThan);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} belowThan
-     * @param {*} [customErrorMsg]
-     */
-  expectBelow(targetData, belowThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to be below ${JSON.stringify(belowThan)}`);
-    return chai.expect(targetData, customErrorMsg).to.be.below(belowThan);
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} lengthAboveThan
-     * @param {*} [customErrorMsg]
-     */
-  expectLengthAboveThan(targetData, lengthAboveThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to have length of above ${JSON.stringify(lengthAboveThan)}`);
-    return chai.expect(targetData, customErrorMsg).to.have.lengthOf.above(
-      lengthAboveThan,
-    );
-  }
-
-  /**
-     * @param {*} targetData
-     * @param {*} lengthBelowThan
-     * @param {*} [customErrorMsg]
-     */
-  expectLengthBelowThan(targetData, lengthBelowThan, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(targetData)}" to have length of below ${JSON.stringify(lengthBelowThan)}`);
-    return chai.expect(targetData, customErrorMsg).to.have.lengthOf.below(
-      lengthBelowThan,
-    );
-  }
-
-  /**
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
-  expectEqualIgnoreCase(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect and ingore case "${JSON.stringify(actualValue)}" to equal "${JSON.stringify(expectedValue)}"`);
-    return chai.expect(actualValue, customErrorMsg).to.equalIgnoreCase(
-      expectedValue,
-    );
-  }
-
-  /**
-     * expects members of two arrays are deeply equal
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
-  expectDeepMembers(actualValue, expectedValue, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect members of "${JSON.stringify(actualValue)}" and "${JSON.stringify(expectedValue)}" arrays are deeply equal`);
-    return chai.expect(actualValue, customErrorMsg).to.have.deep.members(
-      expectedValue,
-    );
-  }
-
-  /**
-     * expects an array to be a superset of another array
-     * @param {*} superset
-     * @param {*} set
-     * @param {*} [customErrorMsg]
-     */
-  expectDeepIncludeMembers(superset, set, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(superset)}" array to be a superset of "${JSON.stringify(set)}" array`);
-    return chai.expect(superset, customErrorMsg).to.deep.include.members(
-      set,
-    );
-  }
-
-  /**
-     * expects members of two JSON objects are deeply equal excluding some properties
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} fieldsToExclude
-     * @param {*} [customErrorMsg]
-     */
-  expectDeepEqualExcluding(
-    actualValue,
-    expectedValue,
-    fieldsToExclude,
-    customErrorMsg = '',
-  ) {
-    // @ts-ignore
-    output.output.step(`I expect members of "${JSON.stringify(actualValue)}" and "${JSON.stringify(expectedValue)}" JSON objects are deeply equal excluding properties: ${JSON.stringify(fieldsToExclude)}`);
-    return chai.expect(actualValue, customErrorMsg)
-      .excludingEvery(fieldsToExclude)
-      .to.deep.equal(expectedValue);
-  }
-
-  /**
-     * expects a JSON object matches a provided pattern
-     * @param {*} actualValue
-     * @param {*} expectedPattern
-     * @param {*} [customErrorMsg]
-     */
-  expectMatchesPattern(actualValue, expectedPattern, customErrorMsg = '') {
-    // @ts-ignore
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to match the ${JSON.stringify(expectedPattern)} pattern`);
-    return chai.expect(actualValue, customErrorMsg).to.matchPattern(expectedPattern);
-  }
-}
-
-export default ExpectHelper;

package/lib/helper/MockServer.js

@@ -1,223 +0,0 @@
-import pkg from 'pactum';
-
-const { mock, settings } = pkg;
-
-/**
- * ## 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
-   *
-   * @returns void
-   */
-  async startMockServer(port) {
-    const _config = { ...config };
-    if (port) _config.port = port;
-    await mock.setDefaults(_config);
-    await mock.start();
-  }
-
-  /**
-   * Stop the mock server
-   *
-   * @returns void
-   *
-   */
-  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
-   *
-   * @returns void
-   *
-   */
-  async addInteractionToMockServer(interaction) {
-    await mock.addInteraction(interaction);
-  }
-}
-
-export default MockServer;