codeceptjs 3.4.1 → 3.5.1-2.beta.7

package/lib/helper/Expect.js

@@ -0,0 +1,422 @@
+const chai = require('chai');
+const output = require('../output');
+
+const { expect } = chai;
+
+chai.use(require('chai-string'));
+// @ts-ignore
+chai.use(require('chai-exclude'));
+chai.use(require('chai-match-pattern'));
+
+/**
+ * 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.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.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.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.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.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.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 = '') {
+    // @ts-ignore
+    output.step(`I expect "${JSON.stringify(actualValue)}" to start with "${JSON.stringify(expectedValueToStartWith)}"`);
+    return expect(actualValue, customErrorMsg).to.startsWith(
+      expectedValueToStartWith,
+    );
+  }
+
+  /**
+     *
+     * @param {*} actualValue
+     * @param {*} expectedValueToNotStartWith
+     * @param {*} [customErrorMsg]
+     */
+  expectNotStartsWith(
+    actualValue,
+    expectedValueToNotStartWith,
+    customErrorMsg = '',
+  ) {
+    // @ts-ignore
+    output.step(`I expect "${JSON.stringify(actualValue)}" to not start with "${JSON.stringify(expectedValueToNotStartWith)}"`);
+    return expect(actualValue, customErrorMsg).not.to.startsWith(
+      expectedValueToNotStartWith,
+    );
+  }
+
+  /**
+     * @param {*} actualValue
+     * @param {*} expectedValueToEndWith
+     * @param {*} [customErrorMsg]
+     */
+  expectEndsWith(actualValue, expectedValueToEndWith, customErrorMsg = '') {
+    // @ts-ignore
+    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.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.step(`I expect "${JSON.stringify(targetData)}" to match this JSON schema "${JSON.stringify(jsonSchema)}"`);
+    chai.use(require('chai-json-schema'));
+    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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.step(`I expect "${JSON.stringify(actualValue)}" to match the ${JSON.stringify(expectedPattern)} pattern`);
+    return expect(actualValue, customErrorMsg).to.matchPattern(expectedPattern);
+  }
+}
+
+module.exports = ExpectHelper;

package/lib/helper/FileSystem.js

@@ -52,7 +52,7 @@ class FileSystem extends Helper {
   }
 
   /**
-   * Writes test to file
+   * Writes text to file
    * @param {string} name
    * @param {string} text
    */

package/lib/helper/GraphQL.js

@@ -81,6 +81,8 @@ class GraphQL extends Helper {
       'Content-Type': 'application/json',
     });
 
+    request.headers = { ...this.headers, ...request.headers };
+
     if (this.config.onRequest) {
       await this.config.onRequest(request);
     }
@@ -200,5 +202,28 @@ class GraphQL extends Helper {
   _setRequestTimeout(newTimeout) {
     this.options.timeout = newTimeout;
   }
+
+  /**
+   * Sets request headers for all requests of this test
+   *
+   * @param {object} headers headers list
+   */
+  haveRequestHeaders(headers) {
+    this.headers = { ...this.headers, ...headers };
+  }
+
+  /**
+   * Adds a header for Bearer authentication
+   *
+   * ```js
+   * // we use secret function to hide token from logs
+   * I.amBearerAuthenticated(secret('heregoestoken'))
+   * ```
+   *
+   * @param {string | CodeceptJS.Secret} accessToken  Bearer access token
+   */
+  amBearerAuthenticated(accessToken) {
+    this.haveRequestHeaders({ Authorization: `Bearer ${accessToken}` });
+  }
 }
 module.exports = GraphQL;

package/lib/helper/JSONResponse.js

@@ -300,16 +300,16 @@ class JSONResponse extends Helper {
    *
    * I.seeResponseMatchesJsonSchema(joi => {
    *   return joi.object({
-   *     name: joi.string();
-   *     id: joi.number();
+   *     name: joi.string(),
+   *     id: joi.number()
    *   })
    * });
    *
    * // or pass a valid schema
-   * const joi = require('joi);
+   * const joi = require('joi');
    *
    * I.seeResponseMatchesJsonSchema(joi.object({
-   *   name: joi.string();
+   *   name: joi.string(),
    *   id: joi.number();
    * });
    * ```

package/lib/helper/Nightmare.js

@@ -694,7 +694,7 @@ class Nightmare extends Helper {
   async appendField(field, value) {
     const el = await findField.call(this, field);
     assertElementExists(el, field, 'Field');
-    return this.browser.enterText(el, value, false)
+    return this.browser.enterText(el, value.toString(), false)
       .wait(this.options.waitForAction);
   }
 
@@ -702,14 +702,16 @@ class Nightmare extends Helper {
    * {{> seeInField }}
    */
   async seeInField(field, value) {
-    return proceedSeeInField.call(this, 'assert', field, value);
+    const _value = (typeof value === 'boolean') ? value : value.toString();
+    return proceedSeeInField.call(this, 'assert', field, _value);
   }
 
   /**
    * {{> dontSeeInField }}
    */
   async dontSeeInField(field, value) {
-    return proceedSeeInField.call(this, 'negate', field, value);
+    const _value = (typeof value === 'boolean') ? value : value.toString();
+    return proceedSeeInField.call(this, 'negate', field, _value);
   }
 
   /**
@@ -1261,8 +1263,11 @@ class Nightmare extends Helper {
       const body = document.body;
       const html = document.documentElement;
       window.scrollTo(0, Math.max(
-        body.scrollHeight, body.offsetHeight,
-        html.clientHeight, html.scrollHeight, html.offsetHeight
+        body.scrollHeight,
+        body.offsetHeight,
+        html.clientHeight,
+        html.scrollHeight,
+        html.offsetHeight
       ));
     });
     /* eslint-enable */

package/lib/helper/OpenAI.js

@@ -0,0 +1,126 @@
+const Helper = require('@codeceptjs/helper');
+const AiAssistant = require('../ai');
+const standardActingHelpers = require('../plugin/standardActingHelpers');
+const Container = require('../container');
+const { splitByChunks, minifyHtml } = require('../html');
+
+/**
+ * OpenAI Helper for CodeceptJS.
+ *
+ * This helper class provides integration with the OpenAI GPT-3.5 or 4 language model for generating responses to questions or prompts within the context of web pages. It allows you to interact with the GPT-3.5 model to obtain intelligent responses based on HTML fragments or general prompts.
+ * This helper should be enabled with any web helpers like Playwright or Puppeteer or WebDrvier to ensure the HTML context is available.
+ *
+ * ## Configuration
+ *
+ * This helper should be configured in codecept.json or codecept.conf.js
+ *
+ * * `chunkSize`: (optional, default: 80000) - The maximum number of characters to send to the OpenAI API at once. We split HTML fragments by 8000 chars to not exceed token limit. Increase this value if you use GPT-4.
+ */
+class OpenAI extends Helper {
+  constructor(config) {
+    super(config);
+    this.aiAssistant = new AiAssistant();
+
+    this.options = {
+      chunkSize: 80000,
+    };
+    this.options = { ...this.options, ...config };
+  }
+
+  _beforeSuite() {
+    const helpers = Container.helpers();
+
+    for (const helperName of standardActingHelpers) {
+      if (Object.keys(helpers).indexOf(helperName) > -1) {
+        this.helper = helpers[helperName];
+        break;
+      }
+    }
+  }
+
+  /**
+   * Asks the OpenAI GPT language model a question based on the provided prompt within the context of the current page's HTML.
+   *
+   * ```js
+   * I.askGptOnPage('what does this page do?');
+   * ```
+   *
+   * @async
+   * @param {string} prompt - The question or prompt to ask the GPT model.
+   * @returns {Promise<string>} - A Promise that resolves to the generated responses from the GPT model, joined by newlines.
+   */
+  async askGptOnPage(prompt) {
+    const html = await this.helper.grabSource();
+
+    const htmlChunks = splitByChunks(html, this.options.chunkSize);
+
+    if (htmlChunks.length > 1) this.debug(`Splitting HTML into ${htmlChunks.length} chunks`);
+
+    const responses = [];
+
+    for (const chunk of htmlChunks) {
+      const messages = [
+        { role: 'user', content: prompt },
+        { role: 'user', content: `Within this HTML: ${minifyHtml(chunk)}` },
+      ];
+
+      if (htmlChunks.length > 1) messages.push({ role: 'user', content: 'If action is not possible on this page, do not propose anything, I will send another HTML fragment' });
+
+      const response = await this.aiAssistant.createCompletion(messages);
+
+      console.log(response);
+
+      responses.push(response);
+    }
+
+    return responses.join('\n\n');
+  }
+
+  /**
+   * Asks the OpenAI GPT-3.5 language model a question based on the provided prompt within the context of a specific HTML fragment on the current page.
+   *
+   * ```js
+   * I.askGptOnPageFragment('describe features of this screen', '.screen');
+   * ```
+   *
+   * @async
+   * @param {string} prompt - The question or prompt to ask the GPT-3.5 model.
+   * @param {string} locator - The locator or selector used to identify the HTML fragment on the page.
+   * @returns {Promise<string>} - A Promise that resolves to the generated response from the GPT model.
+   */
+  async askGptOnPageFragment(prompt, locator) {
+    const html = await this.helper.grabHTMLFrom(locator);
+
+    const messages = [
+      { role: 'user', content: prompt },
+      { role: 'user', content: `Within this HTML: ${minifyHtml(html)}` },
+    ];
+
+    const response = await this.aiAssistant.createCompletion(messages);
+
+    console.log(response);
+
+    return response;
+  }
+
+  /**
+   * Send a general request to ChatGPT and return response.
+   * @param {string} prompt
+   * @returns {Promise<string>} - A Promise that resolves to the generated response from the GPT model.
+   */
+  async askGptGeneralPrompt(prompt) {
+    const messages = [
+      { role: 'user', content: prompt },
+    ];
+
+    const completion = await this.aiAssistant.createCompletion(messages);
+
+    const response = completion?.data?.choices[0]?.message?.content;
+
+    console.log(response);
+
+    return response;
+  }
+}
+
+module.exports = OpenAI;