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

package/lib/heal.js

@@ -1,126 +1,125 @@
-import debug from 'debug';
-import colors from 'chalk';
-import Container from './container.js';
-import recorder from './recorder.js';
-import * as event from './event.js';
-import { output } from './output.js';
-
-const logger = debug('myapp:server');
-
-logger('codeceptjs:heal');
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:heal')
+import colors from 'chalk'
+import recorder from './recorder.js'
+import output from './output.js'
+import event from './event.js'
 
 /**
  * @class
  */
 class Heal {
   constructor() {
-    this.recipes = {};
-    this.fixes = [];
-    this.prepareFns = [];
-    this.contextName = null;
-    this.numHealed = 0;
+    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;
+    this.recipes = {}
+    this.fixes = []
+    this.prepareFns = []
+    this.contextName = null
+    this.numHealed = 0
   }
 
   addRecipe(name, opts = {}) {
-    if (!opts.priority) opts.priority = 0;
+    if (!opts.priority) opts.priority = 0
 
-    if (!opts.fn) throw new Error(`Recipe ${name} should have a function 'fn' to execute`);
+    if (!opts.fn) throw new Error(`Recipe ${name} should have a function 'fn' to execute`)
 
-    this.recipes[name] = opts;
+    this.recipes[name] = opts
   }
 
   connectToEvents() {
-    event.dispatcher.on(event.suite.before, (suite) => {
-      this.contextName = suite.title;
-    });
+    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.started, test => {
+      this.contextName = test.fullTitle()
+    })
 
     event.dispatcher.on(event.test.finished, () => {
-      this.contextName = null;
-    });
+      this.contextName = null
+    })
   }
 
   hasCorrespondingRecipes(step) {
-    return matchRecipes(this.recipes, this.contextName)
-      .filter(r => !r.steps || r.steps.includes(step.name))
-      .length > 0;
+    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);
+    const suggestions = []
+    const recipes = matchRecipes(this.recipes, this.contextName)
 
-    logger('Recipes', recipes);
+    debug('Recipes', recipes)
 
-    const currentOutputLevel = output.level();
-    output.level(0);
+    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;
+    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());
+      if (context[property]) continue
+      context[property] = await prepareFn(global.inject())
     }
 
-    output.level(currentOutputLevel);
+    output.level(currentOutputLevel)
 
     for (const recipe of recipes) {
-      let snippets = await recipe.fn(context);
-      if (!Array.isArray(snippets)) snippets = [snippets];
+      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));
+    return suggestions.filter(s => !isBlank(s.snippets))
   }
 
   async healStep(failedStep, error, failureContext = {}) {
-    output.debug(`Trying to heal ${failedStep.toCode()} step`);
+    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);
+    const suggestions = await this.getCodeSuggestions(failureContext)
 
     if (suggestions.length === 0) {
-      logger('No healing suggestions found');
-      throw error;
+      debug('No healing suggestions found')
+      throw error
     }
 
-    output.debug(`Received ${suggestions.length} suggestion${suggestions.length === 1 ? '' : 's'}`);
+    output.debug(`Received ${suggestions.length} suggestion${suggestions.length === 1 ? '' : 's'}`)
 
-    logger(suggestions);
+    debug(suggestions)
 
     for (const suggestion of suggestions) {
       for (const codeSnippet of suggestion.snippets) {
         try {
-          logger('Executing', codeSnippet);
-          recorder.catch((e) => {
-            logger(e);
-          });
+          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
+            const I = global.container.support('I')
+            await eval(codeSnippet)
           } else if (typeof codeSnippet === 'function') {
-            await codeSnippet(Container.support());
+            await codeSnippet(global.container.support())
           }
 
           this.fixes.push({
@@ -128,49 +127,54 @@ class Heal {
             test: failureContext?.test,
             step: failedStep,
             snippet: codeSnippet,
-          });
+          })
+
+          if (failureContext?.test) {
+            const test = failureContext.test
+            let note = `This test was healed by '${suggestion.name}'`
+            note += `\n\nReplace the failed code:\n\n`
+            note += colors.red(`- ${failedStep.toCode()}\n`)
+            note += colors.green(`+ ${codeSnippet}\n`)
+            test.addNote('heal', note)
+            test.meta.healed = true
+          }
 
-          recorder.add('healed', () => output.print(colors.bold.green(`  Code healed successfully by ${suggestion.name}`), colors.gray('(no errors thrown)')));
-          this.numHealed++;
+          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;
+          return
         } catch (err) {
-          logger('Failed to execute code', err);
-          recorder.ignoreErr(err); // healing did not help
-          recorder.catchWithoutStop(err);
-          await recorder.promise(); // wait for all promises to resolve
+          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);
+    output.debug(`Couldn't heal the code for ${failedStep.toCode()}`)
+    recorder.throw(error)
   }
 
-  static setDefaultHealers() {
-    require('./template/heal');
+  static async setDefaultHealers() {
+    await import('./template/heal.js')
   }
 }
 
-const heal = new Heal();
+const heal = new Heal()
 
-export { heal };
+export default heal
 
 function matchRecipes(recipes, contextName) {
   return Object.entries(recipes)
     .filter(([, recipe]) => !contextName || !recipe.grep || new RegExp(recipe.grep).test(contextName))
     .sort(([, a], [, b]) => a.priority - b.priority)
     .map(([name, recipe]) => {
-      recipe.name = name;
-      return recipe;
+      recipe.name = name
+      return recipe
     })
-    .filter(r => !!r.fn);
+    .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() === '')
-  );
+  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

@@ -1,39 +1,53 @@
-import Helper from '@codeceptjs/helper';
-import AiAssistant from '../ai.js';
-import standardActingHelpers from '../plugin/standardActingHelpers.js';
-import Container from '../container.js';
-import { splitByChunks, minifyHtml } from '../html.js';
+import HelperModule from '@codeceptjs/helper'
+import ora from 'ora-classic'
+import fs from 'fs'
+import path from 'path'
+import ai from '../ai.js'
+import Container from '../container.js'
+import { splitByChunks, minifyHtml } from '../html.js'
+import { beautify } from '../utils.js'
+import output from '../output.js'
+import { registerVariable } from '../pause.js'
+
+const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
+
+const gtpRole = {
+  user: 'user',
+}
 
 /**
  * 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.
+ * This helper should be enabled with any web helpers like Playwright or Puppeteer or WebDriver to ensure the HTML context is available.
+ *
+ * Use it only in development mode. It is recommended to run it only inside pause() mode.
  *
  * ## Configuration
  *
- * This helper should be configured in codecept.json or codecept.conf.js
+ * This helper should be configured in codecept.conf.{js|ts}
  *
  * * `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 = AiAssistant;
+    super(config)
+    this.aiAssistant = ai
 
     this.options = {
       chunkSize: 80000,
-    };
-    this.options = { ...this.options, ...config };
+    }
+    this.options = { ...this.options, ...config }
+    this.aiAssistant.enable(this.config)
   }
 
   _beforeSuite() {
-    const helpers = Container.helpers();
+    const helpers = Container.helpers()
 
     for (const helperName of standardActingHelpers) {
       if (Object.keys(helpers).indexOf(helperName) > -1) {
-        this.helper = helpers[helperName];
-        break;
+        this.helper = helpers[helperName]
+        break
       }
     }
   }
@@ -50,30 +64,34 @@ class AI extends Helper {
    * @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 html = await this.helper.grabSource()
 
-    const htmlChunks = splitByChunks(html, this.options.chunkSize);
+    const htmlChunks = splitByChunks(html, this.options.chunkSize)
 
-    if (htmlChunks.length > 1) this.debug(`Splitting HTML into ${htmlChunks.length} chunks`);
+    if (htmlChunks.length > 1) this.debug(`Splitting HTML into ${htmlChunks.length} chunks`)
 
-    const responses = [];
+    const responses = []
 
     for (const chunk of htmlChunks) {
       const messages = [
-        { role: 'user', content: prompt },
-        { role: 'user', content: `Within this HTML: ${minifyHtml(chunk)}` },
-      ];
+        { role: gtpRole.user, content: prompt },
+        { role: gtpRole.user, content: `Within this HTML: ${await 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' });
+      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);
+      const response = await this._processAIRequest(messages)
 
-      console.log(response);
+      output.print(response)
 
-      responses.push(response);
+      responses.push(response)
     }
 
-    return responses.join('\n\n');
+    return responses.join('\n\n')
   }
 
   /**
@@ -89,36 +107,108 @@ class AI extends Helper {
    * @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 html = await this.helper.grabHTMLFrom(locator)
 
     const messages = [
-      { role: 'user', content: prompt },
-      { role: 'user', content: `Within this HTML: ${minifyHtml(html)}` },
-    ];
+      { role: gtpRole.user, content: prompt },
+      { role: gtpRole.user, content: `Within this HTML: ${await minifyHtml(html)}` },
+    ]
 
-    const response = await this.aiAssistant.createCompletion(messages);
+    const response = await this._processAIRequest(messages)
 
-    console.log(response);
+    output.print(response)
 
-    return response;
+    return response
   }
 
   /**
-   * Send a general request to ChatGPT and return response.
+   * Send a general request to AI 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 messages = [{ role: gtpRole.user, content: prompt }]
+
+    const response = await this._processAIRequest(messages)
+
+    output.print(response)
+
+    return response
+  }
+
+  /**
+   * Generates PageObject for current page using AI.
+   *
+   * It saves the PageObject to the output directory. You can review the page object and adjust it as needed and move to pages directory.
+   * Prompt can be customized in a global config file.
+   *
+   * ```js
+   * // create page object for whole page
+   * I.askForPageObject('home');
+   *
+   * // create page object with extra prompt
+   * I.askForPageObject('home', 'implement signIn(username, password) method');
+   *
+   * // create page object for a specific element
+   * I.askForPageObject('home', null, '.detail');
+   * ```
+   *
+   * Asks for a page object based on the provided page name, locator, and extra prompt.
+   *
+   * @async
+   * @param {string} pageName - The name of the page to retrieve the object for.
+   * @param {string|null} [extraPrompt=null] - An optional extra prompt for additional context or information.
+   * @param {string|null} [locator=null] - An optional locator to find a specific element on the page.
+   * @returns {Promise<Object>} A promise that resolves to the requested page object.
+   */
+  async askForPageObject(pageName, extraPrompt = null, locator = null) {
+    const spinner = ora(' Processing AI request...').start()
+
+    try {
+      const html = locator ? await this.helper.grabHTMLFrom(locator) : await this.helper.grabSource()
+      await this.aiAssistant.setHtmlContext(html)
+      const response = await this.aiAssistant.generatePageObject(extraPrompt, locator)
+      spinner.stop()
+
+      if (!response[0]) {
+        output.error('No response from AI')
+        return ''
+      }
 
-    const response = await this.aiAssistant.createCompletion(messages);
+      const code = beautify(response[0])
 
-    console.log(response);
+      output.print('----- Generated PageObject ----')
+      output.print(code)
+      output.print('-------------------------------')
+
+      const fileName = path.join(output_dir, `${pageName}Page-${Date.now()}.js`)
+
+      output.print(output.styles.bold(`Page object for ${pageName} is saved to ${output.styles.bold(fileName)}`))
+      fs.writeFileSync(fileName, code)
+
+      try {
+        registerVariable('page', require(fileName))
+        output.success('Page object registered for this session as `page` variable')
+        output.print('Use `=>page.methodName()` in shell to run methods of page object')
+        output.print('Use `click(page.locatorName)` to check locators of page object')
+      } catch (err) {
+        output.error('Error while registering page object')
+        output.error(err.message)
+      }
+
+      return code
+    } catch (e) {
+      spinner.stop()
+      throw Error(`Something went wrong! ${e.message}`)
+    }
+  }
 
-    return response;
+  async _processAIRequest(messages) {
+    const spinner = ora(' Processing AI request...').start()
+    const response = await this.aiAssistant.createCompletion(messages)
+    spinner.stop()
+    return response
   }
 }
 
-export default AI;
+export default AI