codeceptjs 4.0.0-beta.4 → 4.0.0-beta.6.esm-aria

package/lib/actor.js

@@ -1,11 +1,12 @@
-const Step = require('./step');
-const { MetaStep } = require('./step');
-const container = require('./container');
-const { methodsOfObject } = require('./utils');
-const recorder = require('./recorder');
-const event = require('./event');
-const store = require('./store');
-const output = require('./output');
+import Step, { MetaStep } from './step.js'
+import recordStep from './step/record.js'
+import retryStep from './step/retry.js'
+import { methodsOfObject } from './utils.js'
+import { TIMEOUT_ORDER } from './timeout.js'
+import event from './event.js'
+import store from './store.js'
+import output from './output.js'
+import Container from './container.js'
 
 /**
  * @interface
@@ -21,13 +22,13 @@ class Actor {
    * ⚠️ returns a promise which is synchronized internally by recorder
    */
   async say(msg, color = 'cyan') {
-    const step = new Step('say', 'say');
-    step.status = 'passed';
+    const step = new Step('say', 'say')
+    step.status = 'passed'
     return recordStep(step, [msg]).then(() => {
       // this is backward compatibility as this event may be used somewhere
-      event.emit(event.step.comment, msg);
-      output.say(msg, `${color}`);
-    });
+      event.emit(event.step.comment, msg)
+      output.say(msg, `${color}`)
+    })
   }
 
   /**
@@ -38,14 +39,16 @@ class Actor {
    * @inner
    */
   limitTime(timeout) {
-    if (!store.timeouts) return this;
+    if (!store.timeouts) return this
 
-    event.dispatcher.prependOnceListener(event.step.before, (step) => {
-      output.log(`Timeout to ${step}: ${timeout}s`);
-      step.setTimeout(timeout * 1000, Step.TIMEOUT_ORDER.codeLimitTime);
-    });
+    console.log('I.limitTime() is deprecated, use step.timeout() instead')
 
-    return this;
+    event.dispatcher.prependOnceListener(event.step.before, step => {
+      output.log(`Timeout to ${step}: ${timeout}s`)
+      step.setTimeout(timeout * 1000, TIMEOUT_ORDER.codeLimitTime)
+    })
+
+    return this
   }
 
   /**
@@ -55,11 +58,9 @@ class Actor {
    * @inner
    */
   retry(opts) {
-    if (opts === undefined) opts = 1;
-    recorder.retry(opts);
-    // remove retry once the step passed
-    recorder.add(() => event.dispatcher.once(event.step.finished, () => recorder.retries.pop()));
-    return this;
+    console.log('I.retry() is deprecated, use step.retry() instead')
+    retryStep(opts)
+    return this
   }
 }
 
@@ -69,93 +70,60 @@ class Actor {
  * Wraps helper methods into promises.
  * @ignore
  */
-module.exports = function (obj = {}) {
-  if (!store.actor) {
-    store.actor = new Actor();
-  }
-  const actor = store.actor;
-
-  const translation = container.translation();
-
-  if (Object.keys(obj).length > 0) {
-    Object.keys(obj)
-      .forEach(action => {
-        const actionAlias = translation.actionAliasFor(action);
-
-        const currentMethod = obj[action];
-        const ms = new MetaStep('I', action);
-        if (translation.loaded) {
-          ms.name = actionAlias;
-          ms.actor = translation.I;
-        }
-        ms.setContext(actor);
-        actor[action] = actor[actionAlias] = ms.run.bind(ms, currentMethod);
-      });
+export default function (obj = {}, container) {
+  // Use global container if none provided
+  if (!container) {
+    container = Container
   }
+  
+  const actor = container.actor() || new Actor()
 
-  const helpers = container.helpers();
+  // load all helpers once container initialized
+  container.started(() => {
+    const translation = container.translation()
+    const helpers = container.helpers()
 
-  // add methods from enabled helpers
-  Object.values(helpers)
-    .forEach((helper) => {
+    // add methods from enabled helpers
+    Object.values(helpers).forEach(helper => {
       methodsOfObject(helper, 'Helper')
         .filter(method => method !== 'constructor' && method[0] !== '_')
-        .forEach((action) => {
-          const actionAlias = translation.actionAliasFor(action);
+        .forEach(action => {
+          const actionAlias = translation.actionAliasFor(action)
           if (!actor[action]) {
             actor[action] = actor[actionAlias] = function () {
-              const step = new Step(helper, action);
+              const step = new Step(helper, action)
               if (translation.loaded) {
-                step.name = actionAlias;
-                step.actor = translation.I;
+                step.name = actionAlias
+                step.actor = translation.I
               }
               // add methods to promise chain
-              return recordStep(step, Array.from(arguments));
-            };
+              return recordStep(step, Array.from(arguments))
+            }
           }
-        });
-    });
-
-  return actor;
-};
-
-function recordStep(step, args) {
-  step.status = 'queued';
-  step.setArguments(args);
-
-  // run async before step hooks
-  event.emit(event.step.before, step);
-
-  const task = `${step.name}: ${step.humanizeArgs()}`;
-  let val;
-
-  // run step inside promise
-  recorder.add(task, () => {
-    if (!step.startTime) { // step can be retries
-      event.emit(event.step.started, step);
-      step.startTime = Date.now();
-    }
-    return val = step.run(...args);
-  }, false, undefined, step.getTimeout());
-
-  event.emit(event.step.after, step);
-
-  recorder.add('step passed', () => {
-    step.endTime = Date.now();
-    event.emit(event.step.passed, step, val);
-    event.emit(event.step.finished, step);
-  });
-
-  recorder.catchWithoutStop((err) => {
-    step.status = 'failed';
-    step.endTime = Date.now();
-    event.emit(event.step.failed, step);
-    event.emit(event.step.finished, step);
-    throw err;
-  });
-
-  recorder.add('return result', () => val);
-  // run async after step hooks
-
-  return recorder.promise();
+        })
+    })
+
+    // add translated custom steps from actor
+    Object.keys(obj).forEach(key => {
+      const actionAlias = translation.actionAliasFor(key)
+      if (!actor[actionAlias]) {
+        actor[actionAlias] = actor[key]
+      }
+    })
+
+    container.append({
+      support: {
+        I: actor,
+      },
+    })
+  })
+  // store.actor = actor;
+  // add custom steps from actor
+  Object.keys(obj).forEach(key => {
+    const ms = new MetaStep('I', key)
+    ms.setContext(actor)
+    actor[key] = ms.run.bind(ms, obj[key])
+  })
+
+  return actor
 }

package/lib/ai.js

@@ -1,40 +1,45 @@
-const debug = require('debug')('codeceptjs:ai');
-const output = require('./output');
-const event = require('./event');
-const { removeNonInteractiveElements, minifyHtml, splitByChunks } = require('./html');
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:ai')
+import output from './output.js'
+import event from './event.js'
+import { removeNonInteractiveElements, minifyHtml, splitByChunks } from './html.js'
 
 const defaultHtmlConfig = {
   maxLength: 50000,
   simplify: true,
   minify: true,
   html: {},
-};
+}
 
 const defaultPrompts = {
-  writeStep: (html, input) => [{
-    role: 'user',
-    content: `I am test engineer writing test in CodeceptJS
+  writeStep: (html, input) => [
+    {
+      role: 'user',
+      content: `I am test engineer writing test in CodeceptJS
         I have opened web page and I want to use CodeceptJS to ${input} on this page
         Provide me valid CodeceptJS code to accomplish it
         Use only locators from this HTML: \n\n${html}`,
-  },
+    },
   ],
 
   healStep: (html, { step, error, prevSteps }) => {
-    return [{
-      role: 'user',
-      content: `As a test automation engineer I am testing web application using CodeceptJS.
+    return [
+      {
+        role: 'user',
+        content: `As a test automation engineer I am testing web application using CodeceptJS.
         I want to heal a test that fails. Here is the list of executed steps: ${prevSteps.map(s => s.toString()).join(', ')}
         Propose how to adjust ${step.toCode()} step to fix the test.
         Use locators in order of preference: semantic locator by text, CSS, XPath. Use codeblocks marked with \`\`\`
         Here is the error message: ${error.message}
         Here is HTML code of a page where the failure has happened: \n\n${html}`,
-    }];
+      },
+    ]
   },
 
-  generatePageObject: (html, extraPrompt = '', rootLocator = null) => [{
-    role: 'user',
-    content: `As a test automation engineer I am creating a Page Object for a web application using CodeceptJS.
+  generatePageObject: (html, extraPrompt = '', rootLocator = null) => [
+    {
+      role: 'user',
+      content: `As a test automation engineer I am creating a Page Object for a web application using CodeceptJS.
         Here is an sample page object:
 
 const { I } = inject();
@@ -60,72 +65,73 @@ module.exports = {
         ${extraPrompt}
         ${rootLocator ? `All provided elements are inside '${rootLocator}'. Declare it as root variable and for every locator use locate(...).inside(root)` : ''}
         Add only locators from this HTML: \n\n${html}`,
-  }],
-};
+    },
+  ],
+}
 
 class AiAssistant {
   constructor() {
-    this.totalTime = 0;
-    this.numTokens = 0;
+    this.totalTime = 0
+    this.numTokens = 0
 
-    this.reset();
-    this.connectToEvents();
+    this.reset()
+    this.connectToEvents()
   }
 
   enable(config = {}) {
-    debug('Enabling AI assistant');
-    this.isEnabled = true;
+    debug('Enabling AI assistant')
+    this.isEnabled = true
 
-    const { html, prompts, ...aiConfig } = config;
+    const { html, prompts, ...aiConfig } = config
 
-    this.config = Object.assign(this.config, aiConfig);
-    this.htmlConfig = Object.assign(defaultHtmlConfig, html);
-    this.prompts = Object.assign(defaultPrompts, prompts);
+    this.config = Object.assign(this.config, aiConfig)
+    this.htmlConfig = Object.assign(defaultHtmlConfig, html)
+    this.prompts = Object.assign(defaultPrompts, prompts)
 
-    debug('Config', this.config);
+    debug('Config', this.config)
   }
 
   reset() {
-    this.numTokens = 0;
-    this.isEnabled = false;
+    this.numTokens = 0
+    this.isEnabled = false
     this.config = {
       maxTokens: 1000000,
       request: null,
       response: parseCodeBlocks,
       // lets limit token usage to 1M
-    };
-    this.minifiedHtml = null;
-    this.response = null;
-    this.totalTime = 0;
+    }
+    this.minifiedHtml = null
+    this.response = null
+    this.totalTime = 0
   }
 
   disable() {
-    this.isEnabled = false;
+    this.isEnabled = false
   }
 
   connectToEvents() {
     event.dispatcher.on(event.all.result, () => {
       if (this.isEnabled && this.numTokens > 0) {
-        const numTokensK = Math.ceil(this.numTokens / 1000);
-        const maxTokensK = Math.ceil(this.config.maxTokens / 1000);
-        output.print(`AI assistant took ${this.totalTime}s and used ~${numTokensK}K input tokens. Tokens limit: ${maxTokensK}K`);
+        const numTokensK = Math.ceil(this.numTokens / 1000)
+        const maxTokensK = Math.ceil(this.config.maxTokens / 1000)
+        output.print(`AI assistant took ${this.totalTime}s and used ~${numTokensK}K input tokens. Tokens limit: ${maxTokensK}K`)
       }
-    });
+    })
   }
 
   checkRequestFn() {
     if (!this.isEnabled) {
-      debug('AI assistant is disabled');
-      return;
+      debug('AI assistant is disabled')
+      return
     }
 
-    if (this.config.request) return;
+    if (this.config.request) return
 
     const noRequestErrorMessage = `
-     No request function is set for AI assistant.  
-     Please implement your own request function and set it in the config.    
+     No request function is set for AI assistant.
 
-     [!] AI request was decoupled from CodeceptJS. To connect to OpenAI or other AI service, please implement your own request function and set it in the config.
+     [!] AI request was decoupled from CodeceptJS. To connect to OpenAI or other AI service.
+     Please implement your own request function and set it in the config.
 
      Example (connect to OpenAI):
 
@@ -134,82 +140,80 @@ class AiAssistant {
          const OpenAI = require('openai');
          const openai = new OpenAI({ apiKey: process.env['OPENAI_API_KEY'] })
          const response = await openai.chat.completions.create({
-          model: 'gpt-3.5-turbo-0125',
+          model: 'gpt-4o-mini',
           messages,
          });
          return response?.data?.choices[0]?.message?.content;
        }
      }
-    `.trim();
+    `.trim()
 
-    throw new Error(noRequestErrorMessage);
+    throw new Error(noRequestErrorMessage)
   }
 
   async setHtmlContext(html) {
-    let processedHTML = html;
+    let processedHTML = html
 
     if (this.htmlConfig.simplify) {
-      processedHTML = removeNonInteractiveElements(processedHTML, this.htmlConfig);
+      processedHTML = removeNonInteractiveElements(processedHTML, this.htmlConfig)
     }
 
-    if (this.htmlConfig.minify) processedHTML = await minifyHtml(processedHTML);
-    if (this.htmlConfig.maxLength) processedHTML = splitByChunks(processedHTML, this.htmlConfig.maxLength)[0];
+    if (this.htmlConfig.minify) processedHTML = await minifyHtml(processedHTML)
+    if (this.htmlConfig.maxLength) processedHTML = splitByChunks(processedHTML, this.htmlConfig.maxLength)[0]
 
-    this.minifiedHtml = processedHTML;
+    this.minifiedHtml = processedHTML
   }
 
   getResponse() {
-    return this.response || '';
+    return this.response || ''
   }
 
   async createCompletion(messages) {
-    if (!this.isEnabled) return '';
-
-    debug('Request', messages);
-
-    this.checkRequestFn();
-
-    this.response = null;
-
-    this.calculateTokens(messages);
+    if (!this.isEnabled) return ''
 
     try {
-      const startTime = process.hrtime();
-      this.response = await this.config.request(messages);
-      const endTime = process.hrtime(startTime);
-      const executionTimeInSeconds = endTime[0] + endTime[1] / 1e9;
-
-      this.totalTime += Math.round(executionTimeInSeconds);
-      debug('AI response time', executionTimeInSeconds);
-      debug('Response', this.response);
-      this.stopWhenReachingTokensLimit();
-      return this.response;
+      this.checkRequestFn()
+      debug('Request', messages)
+
+      this.response = null
+
+      this.calculateTokens(messages)
+      const startTime = process.hrtime()
+      this.response = await this.config.request(messages)
+      const endTime = process.hrtime(startTime)
+      const executionTimeInSeconds = endTime[0] + endTime[1] / 1e9
+
+      this.totalTime += Math.round(executionTimeInSeconds)
+      debug('AI response time', executionTimeInSeconds)
+      debug('Response', this.response)
+      this.stopWhenReachingTokensLimit()
+      return this.response
     } catch (err) {
-      debug(err.response);
-      output.print('');
-      output.error(`AI service error: ${err.message}`);
-      if (err?.response?.data?.error?.code) output.error(err?.response?.data?.error?.code);
-      if (err?.response?.data?.error?.message) output.error(err?.response?.data?.error?.message);
-      this.stopWhenReachingTokensLimit();
-      return '';
+      debug(err.response)
+      output.print('')
+      output.error(`AI service error: ${err.message}`)
+      if (err?.response?.data?.error?.code) output.error(err?.response?.data?.error?.code)
+      if (err?.response?.data?.error?.message) output.error(err?.response?.data?.error?.message)
+      this.stopWhenReachingTokensLimit()
+      return ''
     }
   }
 
   async healFailedStep(failureContext) {
-    if (!this.isEnabled) return [];
-    if (!failureContext.html) throw new Error('No HTML context provided');
+    if (!this.isEnabled) return []
+    if (!failureContext.html) throw new Error('No HTML context provided')
 
-    await this.setHtmlContext(failureContext.html);
+    await this.setHtmlContext(failureContext.html)
 
     if (!this.minifiedHtml) {
-      debug('HTML context is empty after removing non-interactive elements & minification');
-      return [];
+      debug('HTML context is empty after removing non-interactive elements & minification')
+      return []
     }
 
-    const response = await this.createCompletion(this.prompts.healStep(this.minifiedHtml, failureContext));
-    if (!response) return [];
+    const response = await this.createCompletion(this.prompts.healStep(this.minifiedHtml, failureContext))
+    if (!response) return []
 
-    return this.config.response(response);
+    return this.config.response(response)
   }
 
   /**
@@ -219,13 +223,13 @@ class AiAssistant {
    * @returns
    */
   async generatePageObject(extraPrompt = null, locator = null) {
-    if (!this.isEnabled) return [];
-    if (!this.minifiedHtml) throw new Error('No HTML context provided');
+    if (!this.isEnabled) return []
+    if (!this.minifiedHtml) throw new Error('No HTML context provided')
 
-    const response = await this.createCompletion(this.prompts.generatePageObject(this.minifiedHtml, locator, extraPrompt));
-    if (!response) return [];
+    const response = await this.createCompletion(this.prompts.generatePageObject(this.minifiedHtml, locator, extraPrompt))
+    if (!response) return []
 
-    return this.config.response(response);
+    return this.config.response(response)
   }
 
   calculateTokens(messages) {
@@ -233,66 +237,72 @@ class AiAssistant {
     // this approach was tested via https://platform.openai.com/tokenizer
     // we need it to display current tokens usage so users could analyze effectiveness of AI
 
-    const inputString = messages.map(m => m.content).join(' ').trim();
-    const numWords = (inputString.match(/[^\s\-:=]+/g) || []).length;
+    const inputString = messages
+      .map(m => m.content)
+      .join(' ')
+      .trim()
+    const numWords = (inputString.match(/[^\s\-:=]+/g) || []).length
 
     // 2.5 token is constant for average HTML input
-    const tokens = numWords * 2.5;
+    const tokens = numWords * 2.5
 
-    this.numTokens += tokens;
+    this.numTokens += tokens
 
-    return tokens;
+    return tokens
   }
 
   stopWhenReachingTokensLimit() {
-    if (this.numTokens < this.config.maxTokens) return;
+    if (this.numTokens < this.config.maxTokens) return
 
-    output.print(`AI assistant has reached the limit of ${this.config.maxTokens} tokens in this session. It will be disabled now`);
-    this.disable();
+    output.print(`AI assistant has reached the limit of ${this.config.maxTokens} tokens in this session. It will be disabled now`)
+    this.disable()
   }
 
   async writeSteps(input) {
-    if (!this.isEnabled) return;
-    if (!this.minifiedHtml) throw new Error('No HTML context provided');
+    if (!this.isEnabled) return
+    if (!this.minifiedHtml) throw new Error('No HTML context provided')
 
-    const snippets = [];
+    const snippets = []
 
-    const response = await this.createCompletion(this.prompts.writeStep(this.minifiedHtml, input));
-    if (!response) return;
-    snippets.push(...this.config.response(response));
+    const response = await this.createCompletion(this.prompts.writeStep(this.minifiedHtml, input))
+    if (!response) return
+    snippets.push(...this.config.response(response))
 
-    debug(snippets[0]);
+    debug(snippets[0])
 
-    return snippets[0];
+    return snippets[0]
   }
 }
 
 function parseCodeBlocks(response) {
   // Regular expression pattern to match code snippets
-  const codeSnippetPattern = /```(?:javascript|js|typescript|ts)?\n([\s\S]+?)\n```/g;
+  const codeSnippetPattern = /```(?:javascript|js|typescript|ts)?\n([\s\S]+?)\n```/g
 
   // Array to store extracted code snippets
-  const codeSnippets = [];
+  const codeSnippets = []
 
-  response = response.split('\n').map(line => line.trim()).join('\n');
+  response = response
+    .split('\n')
+    .map(line => line.trim())
+    .join('\n')
 
   // Iterate over matches and extract code snippets
-  let match;
+  let match
   while ((match = codeSnippetPattern.exec(response)) !== null) {
-    codeSnippets.push(match[1]);
+    codeSnippets.push(match[1])
   }
 
   // Remove "Scenario", "Feature", and "require()" lines
   const modifiedSnippets = codeSnippets.map(snippet => {
-    const lines = snippet.split('\n');
+    const lines = snippet.split('\n')
 
-    const filteredLines = lines.filter(line => !line.includes('I.amOnPage') && !line.startsWith('Scenario') && !line.startsWith('Feature') && !line.includes('= require('));
+    const filteredLines = lines.filter(line => !line.includes('I.amOnPage') && !line.startsWith('Scenario') && !line.startsWith('Feature') && !line.includes('= require('))
 
-    return filteredLines.join('\n');
+    return filteredLines.join('\n')
     // remove snippets that move from current url
-  }); // .filter(snippet => !line.includes('I.amOnPage'));
+  }) // .filter(snippet => !line.includes('I.amOnPage'));
 
-  return modifiedSnippets.filter(snippet => !!snippet);
+  return modifiedSnippets.filter(snippet => !!snippet)
 }
 
-module.exports = new AiAssistant();
+export default new AiAssistant()

package/lib/assert/empty.js

@@ -1,11 +1,13 @@
-const Assertion = require('../assert')
-const AssertionFailedError = require('./error')
-const { template } = require('../utils')
-const output = require('../output')
+import assertionModule from '../assert.js'
+const Assertion = assertionModule.default || assertionModule
+import AssertionFailedError from './error.js'
+import { template } from '../utils.js'
+import outputModule from '../output.js'
+const output = outputModule.default || outputModule
 
 class EmptinessAssertion extends Assertion {
   constructor(params) {
-    super((value) => {
+    super(value => {
       if (Array.isArray(value)) {
         return value.length === 0
       }
@@ -22,9 +24,7 @@ class EmptinessAssertion extends Assertion {
     const err = new AssertionFailedError(this.params, "{{customMessage}}expected {{subject}} '{{value}}' {{type}}")
 
     err.cliMessage = () => {
-      const msg = err.template
-        .replace('{{value}}', output.colors.bold('{{value}}'))
-        .replace('{{subject}}', output.colors.bold('{{subject}}'))
+      const msg = err.template.replace('{{value}}', output.colors.bold('{{value}}')).replace('{{subject}}', output.colors.bold('{{subject}}'))
       return template(msg, this.params)
     }
     return err
@@ -37,7 +37,6 @@ class EmptinessAssertion extends Assertion {
   }
 }
 
-module.exports = {
-  Assertion: EmptinessAssertion,
-  empty: (subject) => new EmptinessAssertion({ subject }),
-}
+export { EmptinessAssertion as Assertion }
+
+export const empty = subject => new EmptinessAssertion({ subject })