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

package/lib/command/workers/runTests.js

@@ -75,217 +75,53 @@ function filterTests() {
 }
 
 function initializeListeners() {
-  function simplifyError(error) {
-    if (error) {
-      const { stack, uncaught, message, actual, expected } = error
-
-      return {
-        stack,
-        uncaught,
-        message,
-        actual,
-        expected,
-      }
-    }
-
-    return null
-  }
-  function simplifyTest(test, err = null) {
-    test = { ...test }
-
-    if (test.start && !test.duration) {
-      const end = new Date()
-      test.duration = end - test.start
-    }
-
-    if (test.err) {
-      err = simplifyError(test.err)
-      test.status = 'failed'
-    } else if (err) {
-      err = simplifyError(err)
-      test.status = 'failed'
-    }
-    const parent = {}
-    if (test.parent) {
-      parent.title = test.parent.title
-    }
-
-    if (test.opts) {
-      Object.keys(test.opts).forEach(k => {
-        if (typeof test.opts[k] === 'object') delete test.opts[k]
-        if (typeof test.opts[k] === 'function') delete test.opts[k]
-      })
-    }
-
-    return {
-      opts: test.opts || {},
-      tags: test.tags || [],
-      uid: test.uid,
-      workerIndex,
-      retries: test._retries,
-      title: test.title,
-      status: test.status,
-      notes: test.notes || [],
-      meta: test.meta || {},
-      artifacts: test.artifacts || [],
-      duration: test.duration || 0,
-      err,
-      parent,
-      steps: test.steps && test.steps.length > 0 ? simplifyStepsInTestObject(test.steps, err) : [],
-    }
-  }
-
-  function simplifyStepsInTestObject(steps, err) {
-    steps = [...steps]
-    const _steps = []
-
-    for (step of steps) {
-      const _args = []
-
-      if (step.args) {
-        for (const arg of step.args) {
-          // check if arg is a JOI object
-          if (arg && arg.$_root) {
-            _args.push(JSON.stringify(arg).slice(0, 300))
-            // check if arg is a function
-          } else if (arg && typeof arg === 'function') {
-            _args.push(arg.name)
-          } else {
-            _args.push(arg)
-          }
-        }
-      }
-
-      _steps.push({
-        actor: step.actor,
-        name: step.name,
-        status: step.status,
-        args: JSON.stringify(_args),
-        startedAt: step.startedAt,
-        startTime: step.startTime,
-        endTime: step.endTime,
-        finishedAt: step.finishedAt,
-        duration: step.duration,
-        err,
-      })
-    }
-
-    return _steps
-  }
-
-  function simplifyStep(step, err = null) {
-    step = { ...step }
-
-    if (step.startTime && !step.duration) {
-      const end = new Date()
-      step.duration = end - step.startTime
-    }
-
-    if (step.err) {
-      err = simplifyError(step.err)
-      step.status = 'failed'
-    } else if (err) {
-      err = simplifyError(err)
-      step.status = 'failed'
-    }
-
-    const parent = {}
-    if (step.metaStep) {
-      parent.title = step.metaStep.actor
-    }
-
-    if (step.opts) {
-      Object.keys(step.opts).forEach(k => {
-        if (typeof step.opts[k] === 'object') delete step.opts[k]
-        if (typeof step.opts[k] === 'function') delete step.opts[k]
-      })
-    }
-
-    return {
-      opts: step.opts || {},
-      workerIndex,
-      title: step.name,
-      status: step.status,
-      duration: step.duration || 0,
-      err,
-      parent,
-      test: simplifyTest(step.test),
-    }
-  }
-
-  collectStats()
   // suite
-  event.dispatcher.on(event.suite.before, suite => sendToParentThread({ event: event.suite.before, workerIndex, data: simplifyTest(suite) }))
-  event.dispatcher.on(event.suite.after, suite => sendToParentThread({ event: event.suite.after, workerIndex, data: simplifyTest(suite) }))
+  event.dispatcher.on(event.suite.before, suite => sendToParentThread({ event: event.suite.before, workerIndex, data: suite.simplify() }))
+  event.dispatcher.on(event.suite.after, suite => sendToParentThread({ event: event.suite.after, workerIndex, data: suite.simplify() }))
 
   // calculate duration
   event.dispatcher.on(event.test.started, test => (test.start = new Date()))
 
   // tests
-  event.dispatcher.on(event.test.before, test => sendToParentThread({ event: event.test.before, workerIndex, data: simplifyTest(test) }))
-  event.dispatcher.on(event.test.after, test => sendToParentThread({ event: event.test.after, workerIndex, data: simplifyTest(test) }))
+  event.dispatcher.on(event.test.before, test => sendToParentThread({ event: event.test.before, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.after, test => sendToParentThread({ event: event.test.after, workerIndex, data: test.simplify() }))
   // we should force-send correct errors to prevent race condition
-  event.dispatcher.on(event.test.finished, (test, err) => sendToParentThread({ event: event.test.finished, workerIndex, data: simplifyTest(test, err) }))
-  event.dispatcher.on(event.test.failed, (test, err) => sendToParentThread({ event: event.test.failed, workerIndex, data: simplifyTest(test, err) }))
-  event.dispatcher.on(event.test.passed, (test, err) => sendToParentThread({ event: event.test.passed, workerIndex, data: simplifyTest(test, err) }))
-  event.dispatcher.on(event.test.started, test => sendToParentThread({ event: event.test.started, workerIndex, data: simplifyTest(test) }))
-  event.dispatcher.on(event.test.skipped, test => sendToParentThread({ event: event.test.skipped, workerIndex, data: simplifyTest(test) }))
+  event.dispatcher.on(event.test.finished, (test, err) => sendToParentThread({ event: event.test.finished, workerIndex, data: { ...test.simplify(), err } }))
+  event.dispatcher.on(event.test.failed, (test, err) => sendToParentThread({ event: event.test.failed, workerIndex, data: { ...test.simplify(), err } }))
+  event.dispatcher.on(event.test.passed, (test, err) => sendToParentThread({ event: event.test.passed, workerIndex, data: { ...test.simplify(), err } }))
+  event.dispatcher.on(event.test.started, test => sendToParentThread({ event: event.test.started, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.skipped, test => sendToParentThread({ event: event.test.skipped, workerIndex, data: test.simplify() }))
 
   // steps
-  event.dispatcher.on(event.step.finished, step => sendToParentThread({ event: event.step.finished, workerIndex, data: simplifyStep(step) }))
-  event.dispatcher.on(event.step.started, step => sendToParentThread({ event: event.step.started, workerIndex, data: simplifyStep(step) }))
-  event.dispatcher.on(event.step.passed, step => sendToParentThread({ event: event.step.passed, workerIndex, data: simplifyStep(step) }))
-  event.dispatcher.on(event.step.failed, step => sendToParentThread({ event: event.step.failed, workerIndex, data: simplifyStep(step) }))
+  event.dispatcher.on(event.step.finished, step => sendToParentThread({ event: event.step.finished, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.started, step => sendToParentThread({ event: event.step.started, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.passed, step => sendToParentThread({ event: event.step.passed, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.failed, step => sendToParentThread({ event: event.step.failed, workerIndex, data: step.simplify() }))
 
-  event.dispatcher.on(event.hook.failed, (test, err) => sendToParentThread({ event: event.hook.failed, workerIndex, data: simplifyTest(test, err) }))
-  event.dispatcher.on(event.hook.passed, (test, err) => sendToParentThread({ event: event.hook.passed, workerIndex, data: simplifyTest(test, err) }))
-  event.dispatcher.on(event.all.failures, data => sendToParentThread({ event: event.all.failures, workerIndex, data }))
+  event.dispatcher.on(event.hook.failed, (hook, err) => sendToParentThread({ event: event.hook.failed, workerIndex, data: { ...hook.simplify(), err } }))
+  event.dispatcher.on(event.hook.passed, hook => sendToParentThread({ event: event.hook.passed, workerIndex, data: hook.simplify() }))
+  event.dispatcher.on(event.hook.finished, hook => sendToParentThread({ event: event.hook.finished, workerIndex, data: hook.simplify() }))
 
+  event.dispatcher.once(event.all.after, () => {
+    sendToParentThread({ event: event.all.after, workerIndex, data: container.result().simplify() })
+  })
   // all
-  event.dispatcher.once(event.all.result, () => parentPort.close())
+  event.dispatcher.once(event.all.result, () => {
+    sendToParentThread({ event: event.all.result, workerIndex, data: container.result().simplify() })
+    parentPort?.close()
+  })
 }
 
 function disablePause() {
   global.pause = () => {}
 }
 
-function collectStats() {
-  const stats = {
-    passes: 0,
-    failures: 0,
-    skipped: 0,
-    tests: 0,
-    pending: 0,
-  }
-  event.dispatcher.on(event.test.skipped, () => {
-    stats.skipped++
-  })
-  event.dispatcher.on(event.test.passed, () => {
-    stats.passes++
-  })
-  event.dispatcher.on(event.test.failed, test => {
-    if (test.ctx._runnable.title.includes('hook: AfterSuite')) {
-      stats.failedHooks += 1
-    }
-    stats.failures++
-  })
-  event.dispatcher.on(event.test.skipped, () => {
-    stats.pending++
-  })
-  event.dispatcher.on(event.test.finished, () => {
-    stats.tests++
-  })
-  event.dispatcher.once(event.all.after, () => {
-    sendToParentThread({ event: event.all.after, data: stats })
-  })
-}
-
 function sendToParentThread(data) {
-  parentPort.postMessage(data)
+  parentPort?.postMessage(data)
 }
 
 function listenToParentThread() {
-  parentPort.on('message', eventData => {
+  parentPort?.on('message', eventData => {
     container.append({ support: eventData.data })
   })
 }

package/lib/container.js

@@ -9,6 +9,7 @@ const recorder = require('./recorder')
 const event = require('./event')
 const WorkerStorage = require('./workerStorage')
 const store = require('./store')
+const Result = require('./result')
 const ai = require('./ai')
 
 let asyncHelperPromise
@@ -25,6 +26,8 @@ let container = {
    */
   mocha: {},
   translation: {},
+  /** @type {Result | null} */
+  result: null,
 }
 
 /**
@@ -54,6 +57,7 @@ class Container {
     container.translation = loadTranslation(config.translation || null, config.vocabularies || [])
     container.proxySupport = createSupportObjects(config.include || {})
     container.plugins = createPlugins(config.plugins || {}, opts)
+    container.result = new Result()
 
     createActor(config.include?.I)
 
@@ -127,6 +131,18 @@ class Container {
     return container.mocha
   }
 
+  /**
+   * Get result
+   *
+   * @returns {Result}
+   */
+  static result() {
+    if (!container.result) {
+      container.result = new Result()
+    }
+    return container.result
+  }
+
   /**
    * Append new services to container
    *

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/event.js

@@ -1,10 +1,10 @@
-const debug = require('debug')('codeceptjs:event');
-const events = require('events');
-const { error } = require('./output');
+const debug = require('debug')('codeceptjs:event')
+const events = require('events')
+const { error } = require('./output')
 
-const dispatcher = new events.EventEmitter();
+const dispatcher = new events.EventEmitter()
 
-dispatcher.setMaxListeners(50);
+dispatcher.setMaxListeners(50)
 /**
  * @namespace
  * @alias event
@@ -59,6 +59,7 @@ module.exports = {
     started: 'hook.start',
     passed: 'hook.passed',
     failed: 'hook.failed',
+    finished: 'hook.finished',
   },
 
   /**
@@ -141,33 +142,33 @@ module.exports = {
    * @param {*} [param]
    */
   emit(event, param) {
-    let msg = `Emitted | ${event}`;
+    let msg = `Emitted | ${event}`
     if (param && param.toString()) {
-      msg += ` (${param.toString()})`;
+      msg += ` (${param.toString()})`
     }
-    debug(msg);
+    debug(msg)
     try {
-      this.dispatcher.emit.apply(this.dispatcher, arguments);
+      this.dispatcher.emit.apply(this.dispatcher, arguments)
     } catch (err) {
-      error(`Error processing ${event} event:`);
-      error(err.stack);
+      error(`Error processing ${event} event:`)
+      error(err.stack)
     }
   },
 
   /** for testing only! */
   cleanDispatcher: () => {
-    let event;
+    let event
     for (event in this.test) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.test[event])
     }
     for (event in this.suite) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.test[event])
     }
     for (event in this.step) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.test[event])
     }
     for (event in this.all) {
-      this.dispatcher.removeAllListeners(this.test[event]);
+      this.dispatcher.removeAllListeners(this.test[event])
     }
   },
-};
+}

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/exit.js

@@ -1,20 +1,17 @@
 const event = require('../event')
+const debug = require('debug')('codeceptjs:exit')
 
 module.exports = function () {
   let failedTests = []
 
-  event.dispatcher.on(event.test.failed, testOrSuite => {
-    // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
-    // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
+  event.dispatcher.on(event.test.failed, test => {
+    const id = test.uid || (test.ctx && test.ctx.test.uid) || 'empty'
     failedTests.push(id)
   })
 
   // if test was successful after retries
-  event.dispatcher.on(event.test.passed, testOrSuite => {
-    // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
-    // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
+  event.dispatcher.on(event.test.passed, test => {
+    const id = test.uid || (test.ctx && test.ctx.test.uid) || 'empty'
     failedTests = failedTests.filter(failed => id !== failed)
   })