codeceptjs 3.7.0-beta.8 → 3.7.0-rc.1

package/lib/els.js

@@ -1,115 +1,124 @@
-const output = require('./output');
-const store = require('./store');
-const recorder = require('./recorder');
-const container = require('./container');
-const event = require('./event');
-const Step = require('./step');
-const { truth } = require('./assert/truth');
-const { isAsyncFunction, humanizeFunction } = require('./utils');
+const output = require('./output')
+const store = require('./store')
+const container = require('./container')
+const StepConfig = require('./step/config')
+const recordStep = require('./step/record')
+const FuncStep = require('./step/func')
+const { truth } = require('./assert/truth')
+const { isAsyncFunction, humanizeFunction } = require('./utils')
 
 function element(purpose, locator, fn) {
-  if (!fn) {
-    fn = locator;
-    locator = purpose;
-    purpose = 'first element';
+  let stepConfig
+  if (arguments[arguments.length - 1] instanceof StepConfig) {
+    stepConfig = arguments[arguments.length - 1]
   }
 
-  const step = prepareStep(purpose, locator, fn);
-  if (!step) return;
+  if (!fn || fn === stepConfig) {
+    fn = locator
+    locator = purpose
+    purpose = 'first element'
+  }
 
-  return executeStep(step, async () => {
-    const els = await step.helper._locate(locator);
-    output.debug(`Found ${els.length} elements, using first element`);
+  const step = prepareStep(purpose, locator, fn)
+  if (!step) return
 
-    return fn(els[0]);
-  });
+  return executeStep(
+    step,
+    async () => {
+      const els = await step.helper._locate(locator)
+      output.debug(`Found ${els.length} elements, using first element`)
+
+      return fn(els[0])
+    },
+    stepConfig,
+  )
 }
 
 function eachElement(purpose, locator, fn) {
   if (!fn) {
-    fn = locator;
-    locator = purpose;
-    purpose = 'for each element';
+    fn = locator
+    locator = purpose
+    purpose = 'for each element'
   }
 
-  const step = prepareStep(purpose, locator, fn);
-  if (!step) return;
+  const step = prepareStep(purpose, locator, fn)
+  if (!step) return
 
   return executeStep(step, async () => {
-    const els = await step.helper._locate(locator);
-    output.debug(`Found ${els.length} elements for each elements to iterate`);
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements for each elements to iterate`)
 
-    const errs = [];
-    let i = 0;
+    const errs = []
+    let i = 0
     for (const el of els) {
       try {
-        await fn(el, i);
+        await fn(el, i)
       } catch (err) {
-        output.error(`eachElement: failed operation on element #${i} ${el}`);
-        errs.push(err);
+        output.error(`eachElement: failed operation on element #${i} ${el}`)
+        errs.push(err)
       }
-      i++;
+      i++
     }
 
     if (errs.length) {
-      throw errs[0];
+      throw errs[0]
     }
-  });
+  })
 }
 
 function expectElement(locator, fn) {
-  const step = prepareStep('expect element to be', locator, fn);
-  if (!step) return;
+  const step = prepareStep('expect element to be', locator, fn)
+  if (!step) return
 
   return executeStep(step, async () => {
-    const els = await step.helper._locate(locator);
-    output.debug(`Found ${els.length} elements, first will be used for assertion`);
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements, first will be used for assertion`)
 
-    const result = await fn(els[0]);
-    const assertion = truth(`element (${locator})`, fn.toString());
-    assertion.assert(result);
-  });
+    const result = await fn(els[0])
+    const assertion = truth(`element (${locator})`, fn.toString())
+    assertion.assert(result)
+  })
 }
 
 function expectAnyElement(locator, fn) {
-  const step = prepareStep('expect any element to be', locator, fn);
-  if (!step) return;
+  const step = prepareStep('expect any element to be', locator, fn)
+  if (!step) return
 
   return executeStep(step, async () => {
-    const els = await step.helper._locate(locator);
-    output.debug(`Found ${els.length} elements, at least one should pass the assertion`);
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements, at least one should pass the assertion`)
 
-    const assertion = truth(`any element of (${locator})`, fn.toString());
+    const assertion = truth(`any element of (${locator})`, fn.toString())
 
-    let found = false;
+    let found = false
     for (const el of els) {
-      const result = await fn(el);
+      const result = await fn(el)
       if (result) {
-        found = true;
-        break;
+        found = true
+        break
       }
     }
-    if (!found) throw assertion.getException();
-  });
+    if (!found) throw assertion.getException()
+  })
 }
 
 function expectAllElements(locator, fn) {
-  const step = prepareStep('expect all elements', locator, fn);
-  if (!step) return;
+  const step = prepareStep('expect all elements', locator, fn)
+  if (!step) return
 
   return executeStep(step, async () => {
-    const els = await step.helper._locate(locator);
-    output.debug(`Found ${els.length} elements, all should pass the assertion`);
+    const els = await step.helper._locate(locator)
+    output.debug(`Found ${els.length} elements, all should pass the assertion`)
 
-    let i = 1;
+    let i = 1
     for (const el of els) {
-      output.debug(`checking element #${i}: ${el}`);
-      const result = await fn(el);
-      const assertion = truth(`element #${i} of (${locator})`, humanizeFunction(fn));
-      assertion.assert(result);
-      i++;
+      output.debug(`checking element #${i}: ${el}`)
+      const result = await fn(el)
+      const assertion = truth(`element #${i} of (${locator})`, humanizeFunction(fn))
+      assertion.assert(result)
+      i++
     }
-  });
+  })
 }
 
 module.exports = {
@@ -118,60 +127,32 @@ module.exports = {
   expectElement,
   expectAnyElement,
   expectAllElements,
-};
+}
 
 function prepareStep(purpose, locator, fn) {
-  if (store.dryRun) return;
-  const helpers = Object.values(container.helpers());
+  if (store.dryRun) return
+  const helpers = Object.values(container.helpers())
 
-  const helper = helpers.filter(h => !!h._locate)[0];
+  const helper = helpers.filter(h => !!h._locate)[0]
 
   if (!helper) {
-    throw new Error('No helper enabled with _locate method with returns a list of elements.');
+    throw new Error('No helper enabled with _locate method with returns a list of elements.')
   }
 
   if (!isAsyncFunction(fn)) {
-    throw new Error('Async function should be passed into each element');
+    throw new Error('Async function should be passed into each element')
   }
 
-  const isAssertion = purpose.startsWith('expect');
+  const isAssertion = purpose.startsWith('expect')
 
-  const step = new Step(helper, `${purpose} within "${locator}" ${isAssertion ? 'to be' : 'to'}`);
-  step.setActor('EL');
-  step.setArguments([humanizeFunction(fn)]);
-  step.helperMethod = '_locate';
+  const step = new FuncStep(`${purpose} within "${locator}" ${isAssertion ? 'to be' : 'to'}`)
+  step.setHelper(helper)
+  step.setArguments([humanizeFunction(fn)]) // user defined function is a passed argument
 
-  return step;
+  return step
 }
 
-async function executeStep(step, action) {
-  let error;
-  const promise = recorder.add('register element wrapper', async () => {
-    event.emit(event.step.started, step);
-
-    try {
-      await action();
-    } catch (err) {
-      recorder.throw(err);
-      event.emit(event.step.failed, step, err);
-      event.emit(event.step.finished, step);
-      // event.emit(event.step.after, step)
-      error = err;
-      // await recorder.promise();
-      return;
-    }
-
-    event.emit(event.step.after, step);
-    event.emit(event.step.passed, step);
-    event.emit(event.step.finished, step);
-  });
-
-  // await recorder.promise();
-
-  // if (error) {
-  //   console.log('error', error.inspect())
-  //   return recorder.throw(error);
-  // }
-
-  return promise;
+async function executeStep(step, action, stepConfig = {}) {
+  step.setCallable(action)
+  return recordStep(step, [stepConfig])
 }

package/lib/helper/AI.js

@@ -3,13 +3,14 @@ const ora = require('ora-classic')
 const fs = require('fs')
 const path = require('path')
 const ai = require('../ai')
-const standardActingHelpers = require('../plugin/standardActingHelpers')
 const Container = require('../container')
 const { splitByChunks, minifyHtml } = require('../html')
 const { beautify } = require('../utils')
 const output = require('../output')
 const { registerVariable } = require('../pause')
 
+const standardActingHelpers = Container.STANDARD_ACTING_HELPERS
+
 const gtpRole = {
   user: 'user',
 }

package/lib/helper/Playwright.js

@@ -523,12 +523,17 @@ class Playwright extends Helper {
         this.currentRunningTest.artifacts.har = fileName
         contextOptions.recordHar = this.options.recordHar
       }
+
+      // load pre-saved cookies
+      if (test?.opts?.cookies) contextOptions.storageState = { cookies: test.opts.cookies }
+
       if (this.storageState) contextOptions.storageState = this.storageState
       if (this.options.userAgent) contextOptions.userAgent = this.options.userAgent
       if (this.options.locale) contextOptions.locale = this.options.locale
       if (this.options.colorScheme) contextOptions.colorScheme = this.options.colorScheme
       this.contextOptions = contextOptions
       if (!this.browserContext || !restartsSession()) {
+        this.debugSection('New Session', JSON.stringify(this.contextOptions))
         this.browserContext = await this.browser.newContext(this.contextOptions) // Adding the HTTPSError ignore in the context so that we can ignore those errors
       }
     }
@@ -938,7 +943,8 @@ class Playwright extends Helper {
       throw new Error('Cannot open pages inside an Electron container')
     }
     if (!/^\w+\:(\/\/|.+)/.test(url)) {
-      url = this.options.url + (url.startsWith('/') ? url : `/${url}`)
+      url = this.options.url + (!this.options.url.endsWith('/') && url.startsWith('/') ? url : `/${url}`)
+      this.debug(`Changed URL to base url + relative path: ${url}`)
     }
 
     if (this.options.basicAuth && this.isAuthenticated !== true) {

package/lib/listener/store.js

@@ -2,11 +2,19 @@ const event = require('../event')
 const store = require('../store')
 
 module.exports = function () {
+  event.dispatcher.on(event.suite.before, suite => {
+    store.currentSuite = suite
+  })
+
+  event.dispatcher.on(event.suite.after, () => {
+    store.currentSuite = null
+  })
+
   event.dispatcher.on(event.test.before, test => {
     store.currentTest = test
   })
 
-  event.dispatcher.on(event.test.finished, test => {
+  event.dispatcher.on(event.test.finished, () => {
     store.currentTest = null
   })
 }

package/lib/mocha/asyncWrapper.js

@@ -19,10 +19,10 @@ const injectHook = function (inject, suite) {
   return recorder.promise()
 }
 
-function suiteTestFailedHookError(suite, err) {
+function suiteTestFailedHookError(suite, err, hookName) {
   suite.eachTest(test => {
     test.err = err
-    event.emit(event.test.failed, test, err)
+    event.emit(event.test.failed, test, err, ucfirst(hookName))
   })
 }
 
@@ -120,7 +120,7 @@ module.exports.injected = function (fn, suite, hookName) {
     const errHandler = err => {
       recorder.session.start('teardown')
       recorder.cleanAsyncErr()
-      if (hookName == 'before' || hookName == 'beforeSuite') suiteTestFailedHookError(suite, err)
+      if (hookName == 'before' || hookName == 'beforeSuite') suiteTestFailedHookError(suite, err, hookName)
       if (hookName === 'after') event.emit(event.test.after, suite)
       if (hookName === 'afterSuite') event.emit(event.suite.after, suite)
       recorder.add(() => doneFn(err))
@@ -145,11 +145,13 @@ module.exports.injected = function (fn, suite, hookName) {
     const opts = suite.opts || {}
     const retries = opts[`retry${ucfirst(hookName)}`] || 0
 
+    const currentTest = hookName === 'before' || hookName === 'after' ? suite?.ctx?.currentTest : null
+
     promiseRetry(
       async (retry, number) => {
         try {
           recorder.startUnlessRunning()
-          await fn.call(this, getInjectedArguments(fn))
+          await fn.call(this, { ...getInjectedArguments(fn), suite, test: currentTest })
           await recorder.promise().catch(err => retry(err))
         } catch (err) {
           retry(err)

package/lib/mocha/cli.js

@@ -198,17 +198,25 @@ class Cli extends Base {
         // add new line before the message
         err.message = '\n  ' + err.message
 
+        // explicitly show file with error
+        if (test.file) {
+          log += `\n${output.styles.basic(figures.circle)} ${output.styles.section('File:')} ${output.styles.basic(test.file)}\n`
+        }
+
         const steps = test.steps || (test.ctx && test.ctx.test.steps)
 
         if (steps && steps.length) {
           let scenarioTrace = ''
-          steps.reverse().forEach(step => {
-            const hasFailed = step.status === 'failed'
-            let line = `${hasFailed ? output.styles.bold(figures.cross) : figures.tick} ${step.toCode()} ${step.line()}`
-            if (hasFailed) line = output.styles.bold(line)
-            scenarioTrace += `\n${line}`
-          })
-          log += `${output.styles.basic(figures.circle)} ${output.styles.section('Scenario Steps')}:${scenarioTrace}\n`
+          steps
+            .reverse()
+            .slice(0, 10)
+            .forEach(step => {
+              const hasFailed = step.status === 'failed'
+              let line = `${hasFailed ? output.styles.bold(figures.cross) : figures.tick} ${step.toCode()} ${step.line()}`
+              if (hasFailed) line = output.styles.bold(line)
+              scenarioTrace += `\n${line}`
+            })
+          log += `\n${output.styles.basic(figures.circle)} ${output.styles.section('Scenario Steps')}:${scenarioTrace}\n`
         }
 
         // display artifacts in debug mode

package/lib/mocha/gherkin.js

@@ -107,7 +107,7 @@ module.exports = (text, file) => {
       )
       continue
     }
-    if (child.scenario && (currentLanguage ? child.scenario.keyword === currentLanguage.contexts.ScenarioOutline : child.scenario.keyword === 'Scenario Outline')) {
+    if (child.scenario && (currentLanguage ? currentLanguage.contexts.ScenarioOutline.includes(child.scenario.keyword) : child.scenario.keyword === 'Scenario Outline')) {
       for (const examples of child.scenario.examples) {
         const fields = examples.tableHeader.cells.map(c => c.value)
         for (const example of examples.tableBody) {

package/lib/mocha/inject.js

@@ -5,6 +5,7 @@ const getInjectedArguments = (fn, test) => {
   const testArgs = {}
   const params = parser.getParams(fn) || []
   const objects = container.support()
+
   for (const key of params) {
     testArgs[key] = {}
     if (test && test.inject && test.inject[key]) {
@@ -18,6 +19,10 @@ const getInjectedArguments = (fn, test) => {
     testArgs[key] = container.support(key)
   }
 
+  if (test) {
+    testArgs.suite = test?.parent
+    testArgs.test = test
+  }
   return testArgs
 }
 

package/lib/output.js

@@ -115,7 +115,7 @@ module.exports = {
       }
     }
 
-    let stepLine = step.toCliStyled()
+    let stepLine = step.toCliStyled ? step.toCliStyled() : step.toString()
     if (step.metaStep && outputLevel >= 1) {
       // this.stepShift += 2;
       stepLine = colors.dim(truncate(stepLine, this.spaceShift))

package/lib/plugin/analyze.js

@@ -2,6 +2,7 @@ const debug = require('debug')('codeceptjs:analyze')
 const { isMainThread } = require('node:worker_threads')
 const { arrowRight } = require('figures')
 const container = require('../container')
+const store = require('../store')
 const ai = require('../ai')
 const colors = require('chalk')
 const ora = require('ora-classic')
@@ -12,8 +13,8 @@ const { ansiRegExp, base64EncodeFile, markdownToAnsi } = require('../utils')
 const MAX_DATA_LENGTH = 5000
 
 const defaultConfig = {
-  clusterize: 2,
-  analyze: 3,
+  clusterize: 5,
+  analyze: 2,
   vision: false,
   categories: [
     'Browser connection error / browser crash',
@@ -64,17 +65,19 @@ const defaultConfig = {
         If you identify that all tests in the group have the same tag, add this tag to the group report, otherwise ignore TAG section.
         If you identify that all tests in the group have the same suite, add this suite to the group report, otherwise ignore SUITE section.
         Pick different emojis for each group.
-        Do not include group into report if it has only one test in affected tests section.
+        Order groups by the number of tests in the group.
+        If group has one test, skip that group.
 
         Provide list of groups in following format:
 
         _______________________________
 
-        ## Group <group_number>
+        ## Group <group_number> <emoji>
 
+        * SUMMARY <summary_of_errors>
         * CATEGORY <category_of_failure>
+        * URL <url_of_failure_if_any>
         * ERROR <error_message_1>, <error_message_2>, ...
-        * SUMMARY <summary_of_errors>
         * STEP <step_of_failure> (use CodeceptJS format I.click(), I.see(), etc; if all failures happend on the same step)
         * SUITE <suite_title>, <suite_title> (if SUITE is present, and if all tests in the group have the same suite or suites)
         * TAG <tag> (if TAG is present, and if all tests in the group have the same tag)
@@ -85,11 +88,6 @@ const defaultConfig = {
             x ...
         `,
         },
-        {
-          role: 'assistant',
-          content: `## '
-        `,
-        },
       ]
       return messages
     },
@@ -126,14 +124,17 @@ const defaultConfig = {
         Do not get to details, be concise.
         If there is failed step, just write it in STEPS section.
         If you have suggestions for the test, write them in SUMMARY section.
+        Do not be too technical in SUMMARY section.
         Inside SUMMARY write exact values, if you have suggestions, explain which information you used to suggest.
         Be concise, each section should not take more than one sentence.
 
         Response format:
 
+        * SUMMARY <explanation_of_failure>
+        * ERROR <error_message_1>, <error_message_2>, ...
         * CATEGORY <category_of_failure>
         * STEPS <step_of_failure>
-        * SUMMARY <explanation_of_failure>
+        * URL <url_of_failure_if_any>
 
         Do not add any other sections or explanations. Only CATEGORY, SUMMARY, STEPS.
         ${config.vision ? 'Also a screenshot of the page is attached to the prompt.' : ''}
@@ -153,11 +154,6 @@ const defaultConfig = {
         })
       }
 
-      messages.push({
-        role: 'assistant',
-        content: `## `,
-      })
-
       return messages
     },
   },
@@ -340,12 +336,13 @@ function serializeTest(test) {
 }
 
 function formatResponse(response) {
-  if (!response.startsWith('##')) response = '## ' + response
   return response
+    .replace(/<think>([\s\S]*?)<\/think>/g, store.debugMode ? colors.cyan('$1') : '')
     .split('\n')
     .map(line => line.trim())
     .filter(line => !/^[A-Z\s]+$/.test(line))
     .map(line => markdownToAnsi(line))
     .map(line => line.replace(/^x /gm, `    ${colors.red.bold('x')} `))
     .join('\n')
+    .trim()
 }