codeceptjs 3.5.14 → 3.6.0-beta.1.ai-healers

package/lib/heal.js

@@ -0,0 +1,172 @@
+const debug = require('debug')('codeceptjs:heal');
+const colors = require('chalk');
+const Container = require('./container');
+const recorder = require('./recorder');
+const output = require('./output');
+const event = require('./event');
+
+/**
+ * @class
+ */
+class Heal {
+  constructor() {
+    this.recipes = {};
+    this.fixes = [];
+    this.prepareFns = [];
+    this.contextName = null;
+    this.numHealed = 0;
+  }
+
+  clear() {
+    this.recipes = {};
+    this.fixes = [];
+    this.prepareFns = [];
+    this.contextName = null;
+    this.numHealed = 0;
+  }
+
+  addRecipe(name, opts = {}) {
+    if (!opts.priority) opts.priority = 0;
+
+    if (!opts.fn) throw new Error(`Recipe ${name} should have a function 'fn' to execute`);
+
+    this.recipes[name] = opts;
+  }
+
+  connectToEvents() {
+    event.dispatcher.on(event.suite.before, (suite) => {
+      this.contextName = suite.title;
+    });
+
+    event.dispatcher.on(event.test.started, (test) => {
+      this.contextName = test.fullTitle();
+    });
+
+    event.dispatcher.on(event.test.finished, () => {
+      this.contextName = null;
+    });
+  }
+
+  hasCorrespondingRecipes(step) {
+    return matchRecipes(this.recipes, this.contextName)
+      .filter(r => !r.steps || r.steps.includes(step.name))
+      .length > 0;
+  }
+
+  async getCodeSuggestions(context) {
+    const suggestions = [];
+    const recipes = matchRecipes(this.recipes, this.contextName);
+
+    debug('Recipes', recipes);
+
+    const currentOutputLevel = output.level();
+    output.level(0);
+
+    for (const [property, prepareFn] of Object.entries(recipes.map(r => r.prepare).filter(p => !!p).reduce((acc, obj) => ({ ...acc, ...obj }), {}))) {
+      if (!prepareFn) continue;
+
+      if (context[property]) continue;
+      context[property] = await prepareFn(Container.support());
+    }
+
+    output.level(currentOutputLevel);
+
+    for (const recipe of recipes) {
+      let snippets = await recipe.fn(context);
+      if (!Array.isArray(snippets)) snippets = [snippets];
+
+      suggestions.push({
+        name: recipe.name,
+        snippets,
+      });
+    }
+
+    return suggestions.filter(s => !isBlank(s.snippets));
+  }
+
+  async healStep(failedStep, error, failureContext = {}) {
+    output.debug(`Trying to heal ${failedStep.toCode()} step`);
+
+    Object.assign(failureContext, {
+      error,
+      step: failedStep,
+      prevSteps: failureContext?.test?.steps?.slice(0, -1) || [],
+    });
+
+    const suggestions = await this.getCodeSuggestions(failureContext);
+
+    if (suggestions.length === 0) {
+      debug('No healing suggestions found');
+      throw error;
+    }
+
+    output.debug(`Received ${suggestions.length} suggestion${suggestions.length === 1 ? '' : 's'}`);
+
+    debug(suggestions);
+
+    for (const suggestion of suggestions) {
+      for (const codeSnippet of suggestion.snippets) {
+        try {
+          debug('Executing', codeSnippet);
+          recorder.catch((e) => {
+            debug(e);
+          });
+
+          if (typeof codeSnippet === 'string') {
+            const I = Container.support('I'); // eslint-disable-line
+            await eval(codeSnippet); // eslint-disable-line
+          } else if (typeof codeSnippet === 'function') {
+            await codeSnippet(Container.support());
+          }
+
+          this.fixes.push({
+            recipe: suggestion.name,
+            test: failureContext?.test,
+            step: failedStep,
+            snippet: codeSnippet,
+          });
+
+          recorder.add('healed', () => output.print(colors.bold.green(`  Code healed successfully by ${suggestion.name}`), colors.gray('(no errors thrown)')));
+          this.numHealed++;
+          // recorder.session.restore();
+          return;
+        } catch (err) {
+          debug('Failed to execute code', err);
+          recorder.ignoreErr(err); // healing did not help
+          recorder.catchWithoutStop(err);
+          await recorder.promise(); // wait for all promises to resolve
+        }
+      }
+    }
+    output.debug(`Couldn't heal the code for ${failedStep.toCode()}`);
+    recorder.throw(error);
+  }
+
+  static setDefaultHealers() {
+    require('./template/heal');
+  }
+}
+
+const heal = new Heal();
+
+module.exports = heal;
+
+function matchRecipes(recipes, contextName) {
+  return Object.entries(recipes)
+    .filter(([, recipe]) => !contextName || !recipe.grep || new RegExp(recipe.grep).test(contextName))
+    .sort(([, a], [, b]) => b.priority - a.priority)
+    .map(([name, recipe]) => {
+      recipe.name = name;
+      return recipe;
+    })
+    .filter(r => !!r.fn);
+}
+
+function isBlank(value) {
+  return (
+    value == null
+      || (Array.isArray(value) && value.length === 0)
+      || (typeof value === 'object' && Object.keys(value).length === 0)
+      || (typeof value === 'string' && value.trim() === '')
+  );
+}

package/lib/helper/AI.js

@@ -0,0 +1,124 @@
+const Helper = require('@codeceptjs/helper');
+const ai = require('../ai');
+const standardActingHelpers = require('../plugin/standardActingHelpers');
+const Container = require('../container');
+const { splitByChunks, minifyHtml } = require('../html');
+
+/**
+ * AI Helper for CodeceptJS.
+ *
+ * This helper class provides integration with the AI 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 AI API at once. We split HTML fragments by 8000 chars to not exceed token limit. Increase this value if you use GPT-4.
+ */
+class AI extends Helper {
+  constructor(config) {
+    super(config);
+    this.aiAssistant = ai;
+
+    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 AI 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 AI 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 response = await this.aiAssistant.createCompletion(messages);
+
+    console.log(response);
+
+    return response;
+  }
+}
+
+module.exports = AI;

package/lib/helper/Appium.js

@@ -2,7 +2,6 @@ let webdriverio;
 
 const fs = require('fs');
 const axios = require('axios').default;
-const { v4: uuidv4 } = require('uuid');
 
 const Webdriver = require('./WebDriver');
 const AssertionFailedError = require('../assert/error');
@@ -1089,40 +1088,17 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async performSwipe(from, to) {
-    await this.browser.performActions([{
-      id: uuidv4(),
-      type: 'pointer',
-      parameters: {
-        pointerType: 'touch',
-      },
-      actions: [
-        {
-          duration: 0,
-          x: from.x,
-          y: from.y,
-          type: 'pointerMove',
-          origin: 'viewport',
-        },
-        {
-          button: 1,
-          type: 'pointerDown',
-        },
-        {
-          duration: 200,
-          type: 'pause',
-        },
-        {
-          duration: 600,
-          x: to.x,
-          y: to.y,
-          type: 'pointerMove',
-          origin: 'viewport',
-        },
-        {
-          button: 1,
-          type: 'pointerUp',
-        },
-      ],
+    await this.browser.touchPerform([{
+      action: 'press',
+      options: from,
+    }, {
+      action: 'wait',
+      options: { ms: 1000 },
+    }, {
+      action: 'moveTo',
+      options: to,
+    }, {
+      action: 'release',
     }]);
     await this.browser.pause(1000);
   }
@@ -1152,7 +1128,7 @@ class Appium extends Webdriver {
       yoffset = 100;
     }
 
-    return this.swipe(parseLocator.call(this, locator), 0, yoffset, speed);
+    return this.swipe(locator, 0, yoffset, speed);
   }
 
   /**

package/lib/helper/Expect.js

@@ -1,15 +1,12 @@
+const chai = require('chai');
 const output = require('../output');
 
-let expect;
+const { expect } = chai;
 
-import('chai').then(chai => {
-  expect = chai.expect;
-  chai.use(require('chai-string'));
-  // @ts-ignore
-  chai.use(require('chai-exclude'));
-  chai.use(require('chai-match-pattern'));
-  chai.use(require('chai-json-schema'));
-});
+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.
@@ -182,7 +179,7 @@ class ExpectHelper {
   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);
   }
 

package/lib/helper/JSONResponse.js

@@ -1,13 +1,12 @@
+const assert = require('assert');
+const chai = require('chai');
+const joi = require('joi');
+const chaiDeepMatch = require('chai-deep-match');
 const Helper = require('@codeceptjs/helper');
 
-let expect;
-
-import('chai').then(chai => {
-  expect = chai.expect;
-  chai.use(require('chai-deep-match'));
-});
+chai.use(chaiDeepMatch);
 
-const joi = require('joi');
+const { expect } = chai;
 
 /**
  * This helper allows performing assertions on JSON responses paired with following helpers:
@@ -92,6 +91,7 @@ class JSONResponse extends Helper {
   static _checkRequirements() {
     try {
       require('joi');
+      require('chai');
     } catch (e) {
       return ['joi'];
     }
@@ -194,7 +194,7 @@ class JSONResponse extends Helper {
           fails++;
         }
       }
-      expect(fails < this.response.data.length, `No elements in array matched ${JSON.stringify(json)}`).to.be.true;
+      assert.ok(fails < this.response.data.length, `No elements in array matched ${JSON.stringify(json)}`);
     } else {
       expect(this.response.data).to.deep.match(json);
     }