codeceptjs 4.0.0-beta.2 → 4.0.0-beta.20

package/lib/helper/JSONResponse.js

@@ -1,12 +1,6 @@
-import joi from 'joi';
-import Helper from '../helper.js';
-
-let expect;
-
-import('chai').then(chai => {
-  expect = chai.expect;
-  chai.use(require('chai-deep-match'));
-});
+import Helper from '@codeceptjs/helper'
+import assert from 'assert'
+import { z } from 'zod'
 
 /**
  * This helper allows performing assertions on JSON responses paired with following helpers:
@@ -66,36 +60,30 @@ import('chai').then(chai => {
  */
 class JSONResponse extends Helper {
   constructor(config = {}) {
-    super(config);
+    super(config)
     this.options = {
       requestHelper: 'REST',
-    };
-    this.options = { ...this.options, ...config };
+    }
+    this.options = { ...this.options, ...config }
   }
 
   _beforeSuite() {
-    this.response = null;
+    this.response = null
     if (!this.helpers[this.options.requestHelper]) {
-      throw new Error(`Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`);
+      throw new Error(`Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`)
+    }
+    const origOnResponse = this.helpers[this.options.requestHelper].config.onResponse
+    this.helpers[this.options.requestHelper].config.onResponse = response => {
+      this.response = response
+      if (typeof origOnResponse === 'function') origOnResponse(response)
     }
-    // connect to REST helper
-    this.helpers[this.options.requestHelper].config.onResponse = (response) => {
-      this.response = response;
-    };
   }
 
   _before() {
-    this.response = null;
-  }
-
-  static _checkRequirements() {
-    try {
-      require('joi');
-    } catch (e) {
-      return ['joi'];
-    }
+    this.response = null
   }
 
+  
   /**
    * Checks that response code is equal to the provided one
    *
@@ -106,8 +94,8 @@ class JSONResponse extends Helper {
    * @param {number} code
    */
   seeResponseCodeIs(code) {
-    this._checkResponseReady();
-    expect(this.response.status).to.eql(code, 'Response code is not the same as expected');
+    this._checkResponseReady()
+    assert.strictEqual(this.response.status, code, 'Response code is not the same as expected')
   }
 
   /**
@@ -120,35 +108,32 @@ class JSONResponse extends Helper {
    * @param {number} code
    */
   dontSeeResponseCodeIs(code) {
-    this._checkResponseReady();
-    expect(this.response.status).not.to.eql(code);
+    this._checkResponseReady()
+    assert.notStrictEqual(this.response.status, code)
   }
 
   /**
    * Checks that the response code is 4xx
    */
   seeResponseCodeIsClientError() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(400);
-    expect(this.response.status).to.be.lt(500);
+    this._checkResponseReady()
+    assert(this.response.status >= 400 && this.response.status < 500)
   }
 
   /**
    * Checks that the response code is 3xx
    */
   seeResponseCodeIsRedirection() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(300);
-    expect(this.response.status).to.be.lt(400);
+    this._checkResponseReady()
+    assert(this.response.status >= 300 && this.response.status < 400)
   }
 
   /**
    * Checks that the response code is 5xx
    */
   seeResponseCodeIsServerError() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(500);
-    expect(this.response.status).to.be.lt(600);
+    this._checkResponseReady()
+    assert(this.response.status >= 500 && this.response.status < 600)
   }
 
   /**
@@ -160,9 +145,8 @@ class JSONResponse extends Helper {
    * ```
    */
   seeResponseCodeIsSuccessful() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(200);
-    expect(this.response.status).to.be.lt(300);
+    this._checkResponseReady()
+    assert(this.response.status >= 200 && this.response.status < 300)
   }
 
   /**
@@ -183,19 +167,21 @@ class JSONResponse extends Helper {
    * @param {object} json
    */
   seeResponseContainsJson(json = {}) {
-    this._checkResponseReady();
+    this._checkResponseReady()
     if (Array.isArray(this.response.data)) {
-      let fails = 0;
+      let found = false
       for (const el of this.response.data) {
         try {
-          expect(el).to.deep.match(json);
+          this._assertContains(el, json)
+          found = true
+          break
         } catch (err) {
-          fails++;
+          continue
         }
       }
-      expect(fails < this.response.data.length, `No elements in array matched ${JSON.stringify(json)}`).to.be.true;
+      assert(found, `No elements in array matched ${JSON.stringify(json)}`)
     } else {
-      expect(this.response.data).to.deep.match(json);
+      this._assertContains(this.response.data, json)
     }
   }
 
@@ -217,11 +203,24 @@ class JSONResponse extends Helper {
    * @param {object} json
    */
   dontSeeResponseContainsJson(json = {}) {
-    this._checkResponseReady();
+    this._checkResponseReady()
     if (Array.isArray(this.response.data)) {
-      this.response.data.forEach(data => expect(data).not.to.deep.match(json));
+      for (const data of this.response.data) {
+        try {
+          this._assertContains(data, json)
+          assert.fail(`Found matching element: ${JSON.stringify(data)}`)
+        } catch (err) {
+          // expected to fail
+          continue
+        }
+      }
     } else {
-      expect(this.response.data).not.to.deep.match(json);
+      try {
+        this._assertContains(this.response.data, json)
+        assert.fail('Response contains the JSON')
+      } catch (err) {
+        // expected to fail
+      }
     }
   }
 
@@ -245,32 +244,39 @@ class JSONResponse extends Helper {
    * @param {array} keys
    */
   seeResponseContainsKeys(keys = []) {
-    this._checkResponseReady();
+    this._checkResponseReady()
     if (Array.isArray(this.response.data)) {
-      this.response.data.forEach(data => expect(data).to.include.keys(keys));
+      for (const data of this.response.data) {
+        for (const key of keys) {
+          assert(key in data, `Key "${key}" is not found in ${JSON.stringify(data)}`)
+        }
+      }
     } else {
-      expect(this.response.data).to.include.keys(keys);
+      for (const key of keys) {
+        assert(key in this.response.data, `Key "${key}" is not found in ${JSON.stringify(this.response.data)}`)
+      }
     }
   }
 
   /**
-   * Executes a callback function passing in `response` object and chai assertions with `expect`
+   * Executes a callback function passing in `response` object and assert
    * Use it to perform custom checks of response data
    *
    * ```js
-   * I.seeResponseValidByCallback(({ data, status, expect }) => {
-   *   expect(status).to.eql(200);
-   *   expect(data).keys.to.include(['user', 'company']);
+   * I.seeResponseValidByCallback(({ data, status }) => {
+   *   assert.strictEqual(status, 200);
+   *   assert('user' in data);
+   *   assert('company' in data);
    * });
    * ```
    *
    * @param {function} fn
    */
   seeResponseValidByCallback(fn) {
-    this._checkResponseReady();
-    fn({ ...this.response, expect });
-    const body = fn.toString();
-    fn.toString = () => `${body.split('\n')[1]}...`;
+    this._checkResponseReady()
+    fn({ ...this.response, assert })
+    const body = fn.toString()
+    fn.toString = () => `${body.split('\n')[1]}...`
   }
 
   /**
@@ -284,54 +290,86 @@ class JSONResponse extends Helper {
    * @param {object} resp
    */
   seeResponseEquals(resp) {
-    this._checkResponseReady();
-    expect(this.response.data).to.deep.equal(resp);
+    this._checkResponseReady()
+    assert.deepStrictEqual(this.response.data, resp)
   }
 
   /**
-   * Validates JSON structure of response using [joi library](https://joi.dev).
-   * See [joi API](https://joi.dev/api/) for complete reference on usage.
+   * Validates JSON structure of response using [Zod library](https://zod.dev).
+   * See [Zod API](https://zod.dev/) for complete reference on usage.
    *
-   * Use pre-initialized joi instance by passing function callback:
+   * Use pre-initialized Zod instance by passing function callback:
    *
    * ```js
    * // response.data is { name: 'jon', id: 1 }
    *
-   * I.seeResponseMatchesJsonSchema(joi => {
-   *   return joi.object({
-   *     name: joi.string(),
-   *     id: joi.number()
+   * I.seeResponseMatchesJsonSchema(z => {
+   *   return z.object({
+   *     name: z.string(),
+   *     id: z.number()
    *   })
    * });
    *
    * // or pass a valid schema
-   * const joi = require('joi');
+   * import { z } from 'zod';
    *
-   * I.seeResponseMatchesJsonSchema(joi.object({
-   *   name: joi.string(),
-   *   id: joi.number();
-   * });
+   * I.seeResponseMatchesJsonSchema(z.object({
+   *   name: z.string(),
+   *   id: z.number()
+   * }));
    * ```
    *
    * @param {any} fnOrSchema
    */
   seeResponseMatchesJsonSchema(fnOrSchema) {
-    this._checkResponseReady();
-    let schema = fnOrSchema;
+    this._checkResponseReady()
+    let schema = fnOrSchema
     if (typeof fnOrSchema === 'function') {
-      schema = fnOrSchema(joi);
-      const body = fnOrSchema.toString();
-      fnOrSchema.toString = () => `${body.split('\n')[1]}...`;
+      schema = fnOrSchema(z)
+      const body = fnOrSchema.toString()
+      fnOrSchema.toString = () => `${body.split('\n')[1]}...`
+    }
+    if (!schema) throw new Error('Empty Zod schema provided, see https://zod.dev/ for details')
+    if (!(schema instanceof z.ZodType)) throw new Error('Invalid Zod schema provided, see https://zod.dev/ for details')
+    schema.toString = () => schema._def.description || JSON.stringify(schema._def)
+    const result = schema.parse(this.response.data)
+    if (!result) {
+      throw new Error('Schema validation failed')
     }
-    if (!schema) throw new Error('Empty Joi schema provided, see https://joi.dev/ for details');
-    if (!joi.isSchema(schema)) throw new Error('Invalid Joi schema provided, see https://joi.dev/ for details');
-    schema.toString = () => schema.describe();
-    joi.assert(this.response.data, schema);
   }
 
   _checkResponseReady() {
-    if (!this.response) throw new Error('Response is not available');
+    if (!this.response) throw new Error('Response is not available')
+  }
+
+  _assertContains(actual, expected) {
+    for (const key in expected) {
+      assert(key in actual, `Key "${key}" not found in ${JSON.stringify(actual)}`)
+      if (typeof expected[key] === 'object' && expected[key] !== null) {
+        if (Array.isArray(expected[key])) {
+          // Handle array comparison: each expected element should have a match in actual array
+          assert(Array.isArray(actual[key]), `Expected array for key "${key}", but got ${typeof actual[key]}`)
+          for (const expectedItem of expected[key]) {
+            let found = false
+            for (const actualItem of actual[key]) {
+              try {
+                this._assertContains(actualItem, expectedItem)
+                found = true
+                break
+              } catch (err) {
+                continue
+              }
+            }
+            assert(found, `No matching element found in array for ${JSON.stringify(expectedItem)}`)
+          }
+        } else {
+          this._assertContains(actual[key], expected[key])
+        }
+      } else {
+        assert.deepStrictEqual(actual[key], expected[key], `Values for key "${key}" don't match`)
+      }
+    }
   }
 }
 
-export default JSONResponse;
+export { JSONResponse as default }

package/lib/helper/Mochawesome.js

@@ -1,71 +1,96 @@
-import Helper from '@codeceptjs/helper';
-import { clearString } from '../utils.js';
+let currentTest
+let currentSuite
 
-let addMochawesomeContext;
-let currentTest;
-let currentSuite;
+import Helper from '@codeceptjs/helper'
+import { createRequire } from 'module'
+import { clearString } from '../utils.js'
+import { testToFileName } from '../mocha/test.js'
 
 class Mochawesome extends Helper {
   constructor(config) {
-    super(config);
+    super(config)
 
     // set defaults
     this.options = {
       uniqueScreenshotNames: false,
       disableScreenshots: false,
-    };
+    }
+
+    // ESM-compatible require for CommonJS module
+    const require = createRequire(import.meta.url)
+    this._addContext = require('mochawesome/addContext')
 
-    addMochawesomeContext = require('mochawesome/addContext');
-    this._createConfig(config);
+    this._createConfig(config)
   }
 
   _createConfig(config) {
     // override defaults with config
-    Object.assign(this.options, config);
+    Object.assign(this.options, config)
   }
 
   _beforeSuite(suite) {
-    currentSuite = suite;
-    currentTest = '';
+    currentSuite = suite
+    currentTest = ''
   }
 
   _before() {
     if (currentSuite && currentSuite.ctx) {
-      currentTest = { test: currentSuite.ctx.currentTest };
+      currentTest = { test: currentSuite.ctx.currentTest }
     }
   }
 
   _test(test) {
-    currentTest = { test };
+    // If this is a retried test, we want to add context to the retried test
+    // but also potentially preserve context from the original test
+    const originalTest = test.retriedTest && test.retriedTest()
+    if (originalTest) {
+      // This is a retried test - use the retried test for context
+      currentTest = { test }
+
+      // Optionally copy context from original test if it exists
+      // Note: mochawesome context is stored in test.ctx, but we need to be careful
+      // not to break the mocha context structure
+    } else {
+      // Normal test (not a retry)
+      currentTest = { test }
+    }
   }
 
   _failed(test) {
-    if (this.options.disableScreenshots) return;
-    let fileName;
+    if (this.options.disableScreenshots) return
+    let fileName
     // Get proper name if we are fail on hook
-    if (test.ctx.test.type === 'hook') {
-      currentTest = { test: test.ctx.test };
+    if (test.ctx?.test?.type === 'hook') {
+      currentTest = { test: test.ctx.test }
       // ignore retries if we are in hook
-      test._retries = -1;
-      fileName = clearString(`${test.title}_${currentTest.test.title}`);
+      test._retries = -1
+      fileName = clearString(`${test.title}_${currentTest.test.title}`)
     } else {
-      currentTest = { test };
-      fileName = clearString(test.title);
+      currentTest = { test }
+      fileName = testToFileName(test)
     }
     if (this.options.uniqueScreenshotNames) {
-      const uuid = test.uuid || test.ctx.test.uuid;
-      fileName = `${fileName.substring(0, 10)}_${uuid}`;
+      fileName = testToFileName(test, { unique: true })
     }
     if (test._retries < 1 || test._retries === test.retryNum) {
-      fileName = `${fileName}.failed.png`;
-      return addMochawesomeContext(currentTest, fileName);
+      fileName = `${fileName}.failed.png`
+      return this._addContext(currentTest, fileName)
     }
   }
 
   addMochawesomeContext(context) {
-    if (currentTest === '') currentTest = { test: currentSuite.ctx.test };
-    return addMochawesomeContext(currentTest, context);
+    if (currentTest === '') currentTest = { test: currentSuite.ctx.test }
+
+    // For retried tests, make sure we're adding context to the current (retried) test
+    // not the original test
+    let targetTest = currentTest
+    if (currentTest.test && currentTest.test.retriedTest && currentTest.test.retriedTest()) {
+      // This test has been retried, make sure we're using the current test for context
+      targetTest = { test: currentTest.test }
+    }
+
+    return this._addContext(targetTest, context)
   }
 }
 
-export default Mochawesome;
+export default Mochawesome