codeceptjs 4.0.0-beta.1 → 4.0.0-beta.10.esm-aria

package/lib/helper/ExpectHelper.js

@@ -1,399 +0,0 @@
-import * as output from '../output.js';
-
-import { expect } from 'chai'
-
-import('chai').then((chai) => {
-  chai.use(require('chai-string'))
-  // @ts-ignore
-  chai.use(require('chai-exclude'))
-  chai.use(require('chai-match-pattern'))
-  chai.use(require('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: {...},
- *     ExpectHelper: {},
- *   }
- *}
- * ```
- *
- * ## 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 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 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 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 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 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 expect(actualValue, customErrorMsg).not.to.contain(expectedValueToNotContain)
-  }
-
-  /**
-   *
-   * @param {*} actualValue
-   * @param {*} expectedValueToStartWith
-   * @param {*} [customErrorMsg]
-   */
-  expectStartsWith(actualValue, expectedValueToStartWith, customErrorMsg = '') {
-    // Log the step output
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to start with "${JSON.stringify(expectedValueToStartWith)}"`);
-
-    // Check if actualValue is a string
-    expect(actualValue, customErrorMsg).to.be.a('string');
-
-    // Check if actualValue starts with expectedValueToStartWith
-    expect(actualValue.startsWith(expectedValueToStartWith), customErrorMsg).to.be.true;
-  }
-
-
-  /**
-   *
-   * @param {*} actualValue
-   * @param {*} expectedValueToNotStartWith
-   * @param {*} [customErrorMsg]
-   */
-  expectNotStartsWith(actualValue, expectedValueToNotStartWith, customErrorMsg = '') {
-    // Log the step output
-    output.output.step(`I expect "${JSON.stringify(actualValue)}" to not start with "${JSON.stringify(expectedValueToNotStartWith)}"`);
-
-    // Check if actualValue is a string
-    expect(actualValue, customErrorMsg).to.be.a('string');
-
-    // Check if actualValue starts with expectedValueToStartWith
-    expect(actualValue.startsWith(expectedValueToNotStartWith), customErrorMsg).to.be.false;
-  }
-
-  /**
-   * @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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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;