codeceptjs 3.7.0-beta.7 → 3.7.0-beta.9

package/lib/actor.js

@@ -3,8 +3,7 @@ const MetaStep = require('./step/meta')
 const recordStep = require('./step/record')
 const container = require('./container')
 const { methodsOfObject } = require('./utils')
-const { TIMEOUT_ORDER } = require('./step/timeout')
-const recorder = require('./recorder')
+const { TIMEOUT_ORDER } = require('./timeout')
 const event = require('./event')
 const store = require('./store')
 const output = require('./output')

package/lib/ai.js

@@ -1,40 +1,44 @@
-const debug = require('debug')('codeceptjs:ai');
-const output = require('./output');
-const event = require('./event');
-const { removeNonInteractiveElements, minifyHtml, splitByChunks } = require('./html');
+const debug = require('debug')('codeceptjs:ai')
+const output = require('./output')
+const event = require('./event')
+const { removeNonInteractiveElements, minifyHtml, splitByChunks } = require('./html')
 
 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 +64,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 +139,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 +222,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 +236,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();
+module.exports = new AiAssistant()

package/lib/codecept.js

@@ -105,8 +105,8 @@ class Codecept {
     // default hooks
     runHook(require('./listener/store'))
     runHook(require('./listener/steps'))
-    runHook(require('./listener/artifacts'))
     runHook(require('./listener/config'))
+    runHook(require('./listener/result'))
     runHook(require('./listener/helpers'))
     runHook(require('./listener/globalTimeout'))
     runHook(require('./listener/globalRetry'))
@@ -199,13 +199,13 @@ class Codecept {
         mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test)
       }
       const done = () => {
-        event.emit(event.all.result, this)
-        event.emit(event.all.after, this)
+        event.emit(event.all.result, container.result())
+        event.emit(event.all.after)
         resolve()
       }
 
       try {
-        event.emit(event.all.before, this)
+        event.emit(event.all.before)
         mocha.run(() => done())
       } catch (e) {
         output.error(e.stack)

package/lib/command/check.js

@@ -22,6 +22,7 @@ module.exports = async function (options) {
     config: false,
     container: false,
     pageObjects: false,
+    plugins: false,
     helpers: false,
     setup: false,
     tests: false,
@@ -115,6 +116,9 @@ module.exports = async function (options) {
   }
   printCheck('page objects', checks['pageObjects'], `Total: ${Object.keys(pageObjects).length} support objects`)
 
+  checks.plugins = true // how to check plugins?
+  printCheck('plugins', checks['plugins'], Object.keys(container.plugins()).join(', '))
+
   if (Object.keys(helpers).length) {
     const suite = container.mocha().suite
     const test = createTest('test', () => {})

package/lib/command/run-workers.js

@@ -8,12 +8,6 @@ const Workers = require('../workers')
 module.exports = async function (workerCount, selectedRuns, options) {
   process.env.profile = options.profile
 
-  const suiteArr = []
-  const passedTestArr = []
-  const failedTestArr = []
-  const skippedTestArr = []
-  const stepArr = []
-
   const { config: testConfig, override = '' } = options
   const overrideConfigs = tryOrDefault(() => JSON.parse(override), {})
   const by = options.suites ? 'suite' : 'test'
@@ -35,65 +29,19 @@ module.exports = async function (workerCount, selectedRuns, options) {
   const workers = new Workers(numberOfWorkers, config)
   workers.overrideConfig(overrideConfigs)
 
-  workers.on(event.suite.before, suite => {
-    suiteArr.push(suite)
-  })
-
-  workers.on(event.step.passed, step => {
-    stepArr.push(step)
-  })
-
-  workers.on(event.step.failed, step => {
-    stepArr.push(step)
-  })
-
   workers.on(event.test.failed, test => {
-    failedTestArr.push(test)
     output.test.failed(test)
   })
 
   workers.on(event.test.passed, test => {
-    passedTestArr.push(test)
     output.test.passed(test)
   })
 
   workers.on(event.test.skipped, test => {
-    skippedTestArr.push(test)
     output.test.skipped(test)
   })
 
-  workers.on(event.all.result, () => {
-    // expose test stats after all workers finished their execution
-    function addStepsToTest(test, stepArr) {
-      stepArr.test.steps.forEach(step => {
-        if (test.steps.length === 0) {
-          test.steps.push(step)
-        }
-      })
-    }
-
-    stepArr.forEach(step => {
-      passedTestArr.forEach(test => {
-        if (step.test.title === test.title) {
-          addStepsToTest(test, step)
-        }
-      })
-
-      failedTestArr.forEach(test => {
-        if (step.test.title === test.title) {
-          addStepsToTest(test, step)
-        }
-      })
-    })
-
-    event.dispatcher.emit(event.workers.result, {
-      suites: suiteArr,
-      tests: {
-        passed: passedTestArr,
-        failed: failedTestArr,
-        skipped: skippedTestArr,
-      },
-    })
+  workers.on(event.all.result, result => {
     workers.printResults()
   })