codeceptjs 3.5.0 → 3.5.1-2.beta.7

package/docs/build/GraphQLDataFactory.js

@@ -1,309 +0,0 @@
-const path = require('path');
-
-const Helper = require('@codeceptjs/helper');
-const GraphQL = require('./GraphQL');
-
-/**
- * Helper for managing remote data using GraphQL queries.
- * Uses data generators like [rosie](https://github.com/rosiejs/rosie) or factory girl to create new record.
- *
- * By defining a factory you set the rules of how data is generated.
- * This data will be saved on server via GraphQL queries and deleted in the end of a test.
- *
- * ## Use Case
- *
- * Acceptance tests interact with a websites using UI and real browser.
- * There is no way to create data for a specific test other than from user interface.
- * That makes tests slow and fragile. Instead of testing a single feature you need to follow all creation/removal process.
- *
- * This helper solves this problem.
- * If a web application has GraphQL support, it can be used to create and delete test records.
- * By combining GraphQL with Factories you can easily create records for tests:
- *
- * ```js
- * I.mutateData('createUser', { name: 'davert', email: 'davert@mail.com' });
- * let user = await I.mutateData('createUser', { name: 'davert'});
- * I.mutateMultiple('createPost', 3, {post_id: user.id});
- * ```
- *
- * To make this work you need
- *
- * 1. GraphQL endpoint which allows to perform create / delete requests and
- * 2. define data generation rules
- *
- * ### Setup
- *
- * Install [Rosie](https://github.com/rosiejs/rosie) and [Faker](https://www.npmjs.com/package/faker) libraries.
- *
- * ```sh
- * npm i rosie @faker-js/faker --save-dev
- * ```
- *
- * Create a factory file for a resource.
- *
- * See the example for Users factories:
- *
- * ```js
- * // tests/factories/users.js
- *
- * const { Factory } = require('rosie').Factory;
- * const { faker } = require('@faker-js/faker');
- *
- * // Used with a constructor function passed to Factory, so that the final build
- * // object matches the necessary pattern to be sent as the variables object.
- * module.exports = new Factory((buildObj) => ({
- *    input: { ...buildObj },
- * }))
- *    // 'attr'-id can be left out depending on the GraphQl resolvers
- *    .attr('name', () => faker.name.findName())
- *    .attr('email', () => faker.interact.email())
- * ```
- * For more options see [rosie documentation](https://github.com/rosiejs/rosie).
- *
- * Then configure GraphQLDataHelper to match factories and GraphQL schema:
-
- * ### Configuration
- *
- * GraphQLDataFactory has following config options:
- *
- * * `endpoint`: URL for the GraphQL server.
- * * `cleanup` (default: true): should inserted records be deleted up after tests
- * * `factories`: list of defined factories
- * * `headers`: list of headers
- * * `GraphQL`: configuration for GraphQL requests.
- *
- *
- * See the example:
- *
- * ```js
- *  GraphQLDataFactory: {
- *    endpoint: "http://user.com/graphql",
- *    cleanup: true,
- *    headers: {
- *      'Content-Type': 'application/json',
- *      'Accept': 'application/json',
- *    },
- *    factories: {
- *      createUser: {
- *        query: 'mutation createUser($input: UserInput!) { createUser(input: $input) { id name }}',
- *        factory: './factories/users',
- *        revert: (data) => ({
- *          query: 'mutation deleteUser($id: ID!) { deleteUser(id: $id) }',
- *          variables: { id : data.id},
- *        }),
- *      },
- *    }
- * }
- * ```
-
- * It is required to set GraphQL `endpoint` which is the URL to which all the queries go to.
- * Factory file is expected to be passed via `factory` option.
- *
- * This Helper uses [GraphQL](http://codecept.io/helpers/GraphQL/) helper and accepts its configuration in "GraphQL" section.
- * For instance, to set timeout you should add:
- *
- * ```js
- * "GraphQLDataFactory": {
- *    "GraphQL": {
- *      "timeout": "100000",
- *   }
- * }
- * ```
- *
- * ### Factory
- *
- * Factory contains operations -
- *
- * * `operation`: The operation/mutation that needs to be performed for creating a record in the backend.
- *
- * Each operation must have the following:
- *
- * * `query`: The mutation(query) string. It is expected to use variables to send data with the query.
- * * `factory`: The path to factory file. The object built by the factory in this file will be passed
- *    as the 'variables' object to go along with the mutation.
- * * `revert`: A function called with the data returned when an item is created. The object returned by
- *    this function is will be used to later delete the items created. So, make sure RELEVANT DATA IS RETURNED
- *    when a record is created by a mutation.
- *
- * ### Requests
- *
- * Requests can be updated on the fly by using `onRequest` function. For instance, you can pass in current session from a cookie.
- *
- * ```js
- *  onRequest: async (request) => {
- *     // using global codeceptjs instance
- *     let cookie = await codeceptjs.container.helpers('WebDriver').grabCookie('session');
- *     request.headers = { Cookie: `session=${cookie.value}` };
- *   }
- * ```
- *
- * ### Responses
- *
- * By default `I.mutateData()` returns a promise with created data as specified in operation query string:
- *
- * ```js
- * let client = await I.mutateData('createClient');
- * ```
- *
- * Data of created records are collected and used in the end of a test for the cleanup.
- *
- * ## Methods
- */
-class GraphQLDataFactory extends Helper {
-  constructor(config) {
-    super(config);
-
-    const defaultConfig = {
-      cleanup: true,
-      GraphQL: {},
-      factories: {},
-    };
-    this.config = Object.assign(defaultConfig, this.config);
-
-    if (this.config.headers) {
-      this.config.GraphQL.defaultHeaders = this.config.headers;
-    }
-    if (this.config.onRequest) {
-      this.config.GraphQL.onRequest = this.config.onRequest;
-    }
-    this.graphqlHelper = new GraphQL(Object.assign(this.config.GraphQL, { endpoint: this.config.endpoint }));
-    this.factories = this.config.factories;
-
-    this.created = {};
-    Object.keys(this.factories).forEach(f => (this.created[f] = []));
-  }
-
-  static _checkRequirements() {
-    try {
-      require('axios');
-      require('rosie');
-    } catch (e) {
-      return ['axios', 'rosie'];
-    }
-  }
-
-  _after() {
-    if (!this.config.cleanup) {
-      return Promise.resolve();
-    }
-    const promises = [];
-    // clean up all created items
-    for (const mutationName in this.created) {
-      const createdItems = this.created[mutationName];
-      if (!createdItems.length) continue;
-      this.debug(`Deleting ${createdItems.length} ${mutationName}(s)`);
-      for (const itemData of createdItems) {
-        promises.push(this._requestDelete(mutationName, itemData));
-      }
-    }
-    return Promise.all(promises);
-  }
-
-  /**
-   * Generates a new record using factory, sends a GraphQL mutation to store it.
-   *
-   * ```js
-   * // create a user
-   * I.mutateData('createUser');
-   * // create user with defined email
-   * // and receive it when inside async function
-   * const user = await I.mutateData('createUser', { email: 'user@user.com'});
-   * ```
-   *
-   * @param {string} operation to be performed
-   * @param {*} params predefined parameters
-   */
-  mutateData(operation, params) {
-    const variables = this._createItem(operation, params);
-    this.debug(`Creating ${operation} ${JSON.stringify(variables)}`);
-    return this._requestCreate(operation, variables);
-  }
-
-  /**
-   * Generates bunch of records and sends multiple GraphQL mutation requests to store them.
-   *
-   * ```js
-   * // create 3 users
-   * I.mutateMultiple('createUser', 3);
-   *
-   * // create 3 users of same age
-   * I.mutateMultiple('createUser', 3, { age: 25 });
-   * ```
-   *
-   * @param {string} operation
-   * @param {number} times
-   * @param {*} params
-   */
-  mutateMultiple(operation, times, params) {
-    const promises = [];
-    for (let i = 0; i < times; i++) {
-      promises.push(this.mutateData(operation, params));
-    }
-    return Promise.all(promises);
-  }
-
-  _createItem(operation, data) {
-    if (!this.factories[operation]) {
-      throw new Error(`Mutation ${operation} is not defined in config.factories`);
-    }
-    let modulePath = this.factories[operation].factory;
-    try {
-      try {
-        require.resolve(modulePath);
-      } catch (e) {
-        modulePath = path.join(global.codecept_dir, modulePath);
-      }
-      const builder = require(modulePath);
-      return builder.build(data);
-    } catch (err) {
-      throw new Error(`Couldn't load factory file from ${modulePath}, check that
-
-          "factories": {
-            "${operation}": {
-              "factory": "./path/to/factory"
-
-        points to valid factory file.
-        Factory file should export an object with build method.
-
-        Current file error: ${err.message}`);
-    }
-  }
-
-  /**
-   * Executes request to create a record to the GraphQL endpoint.
-   * Can be replaced from a custom helper.
-   *
-   * @param {string} operation
-   * @param {*} variables to be sent along with the query
-   */
-  _requestCreate(operation, variables) {
-    const { query } = this.factories[operation];
-    return this.graphqlHelper.sendMutation(query, variables).then((response) => {
-      const data = response.data.data[operation];
-      this.created[operation].push(data);
-      this.debugSection('Created', `record: ${data}`);
-      return data;
-    });
-  }
-
-  /**
-   * Executes request to delete a record to the GraphQL endpoint.
-   * Can be replaced from a custom helper.
-   *
-   * @param {string} operation
-   * @param {*} data of the record to be deleted.
-   */
-  _requestDelete(operation, data) {
-    const deleteOperation = this.factories[operation].revert(data);
-    const { query, variables } = deleteOperation;
-
-    return this.graphqlHelper.sendMutation(query, variables)
-      .then((response) => {
-        const idx = this.created[operation].indexOf(data);
-        this.debugSection('Deleted', `record: ${response.data.data}`);
-        this.created[operation].splice(idx, 1);
-      });
-  }
-}
-
-module.exports = GraphQLDataFactory;

package/docs/build/JSONResponse.js

@@ -1,338 +0,0 @@
-const assert = require('assert');
-const chai = require('chai');
-const joi = require('joi');
-const chaiDeepMatch = require('chai-deep-match');
-const Helper = require('@codeceptjs/helper');
-
-chai.use(chaiDeepMatch);
-
-const { expect } = chai;
-
-/**
- * This helper allows performing assertions on JSON responses paired with following helpers:
- *
- * * REST
- * * GraphQL
- * * Playwright
- *
- * It can check status codes, response data, response structure.
- *
- *
- * ## Configuration
- *
- * * `requestHelper` - a helper which will perform requests. `REST` by default, also `Playwright` or `GraphQL` can be used. Custom helpers must have `onResponse` hook in their config, which will be executed when request is performed.
- *
- * ### Examples
- *
- * Zero-configuration when paired with REST:
- *
- * ```js
- * // inside codecept.conf.js
- *{
- *   helpers: {
- *     REST: {
- *       endpoint: 'http://site.com/api',
- *     },
- *     JSONResponse: {}
- *   }
- *}
- * ```
- * Explicitly setting request helper if you use `makeApiRequest` of Playwright to perform requests and not paired REST:
- *
- * ```js
- * // inside codecept.conf.js
- * // ...
- *   helpers: {
- *     Playwright: {
- *       url: 'https://localhost',
- *       browser: 'chromium',
- *     },
- *     JSONResponse: {
- *       requestHelper: 'Playwright',
- *     }
- *   }
- * ```
- * ## Access From Helpers
- *
- * If you plan to add custom assertions it is recommended to create a helper that will retrieve response object from JSONResponse:
- *
- *
- * ```js
- * // inside custom helper
- * const response = this.helpers.JSONResponse.response;
- * ```
- *
- * ## Methods
- */
-class JSONResponse extends Helper {
-  constructor(config = {}) {
-    super(config);
-    this.options = {
-      requestHelper: 'REST',
-    };
-    this.options = { ...this.options, ...config };
-  }
-
-  _beforeSuite() {
-    this.response = null;
-    if (!this.helpers[this.options.requestHelper]) {
-      throw new Error(`Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`);
-    }
-    // connect to REST helper
-    this.helpers[this.options.requestHelper].config.onResponse = (response) => {
-      this.response = response;
-    };
-  }
-
-  _before() {
-    this.response = null;
-  }
-
-  static _checkRequirements() {
-    try {
-      require('joi');
-      require('chai');
-    } catch (e) {
-      return ['joi'];
-    }
-  }
-
-  /**
-   * Checks that response code is equal to the provided one
-   *
-   * ```js
-   * I.seeResponseCodeIs(200);
-   * ```
-   *
-   * @param {number} code
-   */
-  seeResponseCodeIs(code) {
-    this._checkResponseReady();
-    expect(this.response.status).to.eql(code, 'Response code is not the same as expected');
-  }
-
-  /**
-   * Checks that response code is not equal to the provided one
-   *
-   * ```js
-   * I.dontSeeResponseCodeIs(500);
-   * ```
-   *
-   * @param {number} code
-   */
-  dontSeeResponseCodeIs(code) {
-    this._checkResponseReady();
-    expect(this.response.status).not.to.eql(code);
-  }
-
-  /**
-   * Checks that the response code is 4xx
-   */
-  seeResponseCodeIsClientError() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(400);
-    expect(this.response.status).to.be.lt(500);
-  }
-
-  /**
-   * Checks that the response code is 3xx
-   */
-  seeResponseCodeIsRedirection() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(300);
-    expect(this.response.status).to.be.lt(400);
-  }
-
-  /**
-   * Checks that the response code is 5xx
-   */
-  seeResponseCodeIsServerError() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(500);
-    expect(this.response.status).to.be.lt(600);
-  }
-
-  /**
-   * Checks that the response code is 2xx
-   * Use it instead of seeResponseCodeIs(200) if server can return 204 instead.
-   *
-   * ```js
-   * I.seeResponseCodeIsSuccessful();
-   * ```
-   */
-  seeResponseCodeIsSuccessful() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(200);
-    expect(this.response.status).to.be.lt(300);
-  }
-
-  /**
-   * Checks for deep inclusion of a provided json in a response data.
-   *
-   * ```js
-   * // response.data == { user: { name: 'jon', email: 'jon@doe.com' } }
-   *
-   * I.seeResponseContainsJson({ user: { email: 'jon@doe.com' } });
-   * ```
-   * If an array is received, checks that at least one element contains JSON
-   * ```js
-   * // response.data == [{ user: { name: 'jon', email: 'jon@doe.com' } }]
-   *
-   * I.seeResponseContainsJson({ user: { email: 'jon@doe.com' } });
-   * ```
-   *
-   * @param {object} json
-   */
-  seeResponseContainsJson(json = {}) {
-    this._checkResponseReady();
-    if (Array.isArray(this.response.data)) {
-      let fails = 0;
-      for (const el of this.response.data) {
-        try {
-          expect(el).to.deep.match(json);
-        } catch (err) {
-          fails++;
-        }
-      }
-      assert.ok(fails < this.response.data.length, `No elements in array matched ${JSON.stringify(json)}`);
-    } else {
-      expect(this.response.data).to.deep.match(json);
-    }
-  }
-
-  /**
-   * Checks for deep inclusion of a provided json in a response data.
-   *
-   * ```js
-   * // response.data == { data: { user: 1 } }
-   *
-   * I.dontSeeResponseContainsJson({ user: 2 });
-   * ```
-   * If an array is received, checks that no element of array contains json:
-   * ```js
-   * // response.data == [{ user: 1 }, { user: 3 }]
-   *
-   * I.dontSeeResponseContainsJson({ user: 2 });
-   * ```
-   *
-   * @param {object} json
-   */
-  dontSeeResponseContainsJson(json = {}) {
-    this._checkResponseReady();
-    if (Array.isArray(this.response.data)) {
-      this.response.data.forEach(data => expect(data).not.to.deep.match(json));
-    } else {
-      expect(this.response.data).not.to.deep.match(json);
-    }
-  }
-
-  /**
-   * Checks for deep inclusion of a provided json in a response data.
-   *
-   * ```js
-   * // response.data == { user: { name: 'jon', email: 'jon@doe.com' } }
-   *
-   * I.seeResponseContainsKeys(['user']);
-   * ```
-   *
-   * If an array is received, check is performed for each element of array:
-   *
-   * ```js
-   * // response.data == [{ user: 'jon' }, { user: 'matt'}]
-   *
-   * I.seeResponseContainsKeys(['user']);
-   * ```
-   *
-   * @param {array} keys
-   */
-  seeResponseContainsKeys(keys = []) {
-    this._checkResponseReady();
-    if (Array.isArray(this.response.data)) {
-      this.response.data.forEach(data => expect(data).to.include.keys(keys));
-    } else {
-      expect(this.response.data).to.include.keys(keys);
-    }
-  }
-
-  /**
-   * Executes a callback function passing in `response` object and chai assertions with `expect`
-   * Use it to perform custom checks of response data
-   *
-   * ```js
-   * I.seeResponseValidByCallback(({ data, status, expect }) => {
-   *   expect(status).to.eql(200);
-   *   expect(data).keys.to.include(['user', 'company']);
-   * });
-   * ```
-   *
-   * @param {function} fn
-   */
-  seeResponseValidByCallback(fn) {
-    this._checkResponseReady();
-    fn({ ...this.response, expect });
-    const body = fn.toString();
-    fn.toString = () => `${body.split('\n')[1]}...`;
-  }
-
-  /**
-   * Checks that response data equals to expected:
-   *
-   * ```js
-   * // response.data is { error: 'Not allowed' }
-   *
-   * I.seeResponseEquals({ error: 'Not allowed' })
-   * ```
-   * @param {object} resp
-   */
-  seeResponseEquals(resp) {
-    this._checkResponseReady();
-    expect(this.response.data).to.deep.equal(resp);
-  }
-
-  /**
-   * Validates JSON structure of response using [joi library](https://joi.dev).
-   * See [joi API](https://joi.dev/api/) for complete reference on usage.
-   *
-   * Use pre-initialized joi instance by passing function callback:
-   *
-   * ```js
-   * // response.data is { name: 'jon', id: 1 }
-   *
-   * I.seeResponseMatchesJsonSchema(joi => {
-   *   return joi.object({
-   *     name: joi.string(),
-   *     id: joi.number()
-   *   })
-   * });
-   *
-   * // or pass a valid schema
-   * const joi = require('joi');
-   *
-   * I.seeResponseMatchesJsonSchema(joi.object({
-   *   name: joi.string(),
-   *   id: joi.number();
-   * });
-   * ```
-   *
-   * @param {any} fnOrSchema
-   */
-  seeResponseMatchesJsonSchema(fnOrSchema) {
-    this._checkResponseReady();
-    let schema = fnOrSchema;
-    if (typeof fnOrSchema === 'function') {
-      schema = fnOrSchema(joi);
-      const body = fnOrSchema.toString();
-      fnOrSchema.toString = () => `${body.split('\n')[1]}...`;
-    }
-    if (!schema) throw new Error('Empty Joi schema provided, see https://joi.dev/ for details');
-    if (!joi.isSchema(schema)) throw new Error('Invalid Joi schema provided, see https://joi.dev/ for details');
-    schema.toString = () => schema.describe();
-    joi.assert(this.response.data, schema);
-  }
-
-  _checkResponseReady() {
-    if (!this.response) throw new Error('Response is not available');
-  }
-}
-
-module.exports = JSONResponse;

package/docs/build/Mochawesome.js

@@ -1,71 +0,0 @@
-let addMochawesomeContext;
-let currentTest;
-let currentSuite;
-
-const Helper = require('@codeceptjs/helper');
-const { clearString } = require('../utils');
-
-class Mochawesome extends Helper {
-  constructor(config) {
-    super(config);
-
-    // set defaults
-    this.options = {
-      uniqueScreenshotNames: false,
-      disableScreenshots: false,
-    };
-
-    addMochawesomeContext = require('mochawesome/addContext');
-    this._createConfig(config);
-  }
-
-  _createConfig(config) {
-    // override defaults with config
-    Object.assign(this.options, config);
-  }
-
-  _beforeSuite(suite) {
-    currentSuite = suite;
-    currentTest = '';
-  }
-
-  _before() {
-    if (currentSuite && currentSuite.ctx) {
-      currentTest = { test: currentSuite.ctx.currentTest };
-    }
-  }
-
-  _test(test) {
-    currentTest = { test };
-  }
-
-  _failed(test) {
-    if (this.options.disableScreenshots) return;
-    let fileName;
-    // Get proper name if we are fail on hook
-    if (test.ctx.test.type === 'hook') {
-      currentTest = { test: test.ctx.test };
-      // ignore retries if we are in hook
-      test._retries = -1;
-      fileName = clearString(`${test.title}_${currentTest.test.title}`);
-    } else {
-      currentTest = { test };
-      fileName = clearString(test.title);
-    }
-    if (this.options.uniqueScreenshotNames) {
-      const uuid = test.uuid || test.ctx.test.uuid;
-      fileName = `${fileName.substring(0, 10)}_${uuid}`;
-    }
-    if (test._retries < 1 || test._retries === test.retryNum) {
-      fileName = `${fileName}.failed.png`;
-      return addMochawesomeContext(currentTest, fileName);
-    }
-  }
-
-  addMochawesomeContext(context) {
-    if (currentTest === '') currentTest = { test: currentSuite.ctx.test };
-    return addMochawesomeContext(currentTest, context);
-  }
-}
-
-module.exports = Mochawesome;