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

package/lib/helper/JSONResponse.js

@@ -1,13 +1,6 @@
-const Helper = require('@codeceptjs/helper')
-
-let expect
-
-import('chai').then((chai) => {
-  expect = chai.expect
-  chai.use(require('chai-deep-match'))
-})
-
-const joi = require('joi')
+import Helper from '@codeceptjs/helper'
+import assert from 'assert'
+import joi from 'joi'
 
 /**
  * This helper allows performing assertions on JSON responses paired with following helpers:
@@ -76,14 +69,17 @@ class JSONResponse extends Helper {
 
   _beforeSuite() {
     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)}`,
-      )
-    }
-    // connect to REST helper
-    this.helpers[this.options.requestHelper].config.onResponse = (response) => {
-      this.response = response
+    try {
+      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)}`)
+      }
+      // connect to REST helper
+      this.helpers[this.options.requestHelper].config.onResponse = response => {
+        this.response = response
+      }
+    } catch (e) {
+      // Temporary workaround for ESM transition - helpers access issue
+      console.log('[JSONResponse] Warning: Could not connect to REST helper during ESM transition:', e.message)
     }
   }
 
@@ -93,7 +89,9 @@ class JSONResponse extends Helper {
 
   static _checkRequirements() {
     try {
-      require('joi')
+      // In ESM, joi is already imported at the top
+      // The import will fail at module load time if joi is missing
+      return null
     } catch (e) {
       return ['joi']
     }
@@ -110,7 +108,7 @@ class JSONResponse extends Helper {
    */
   seeResponseCodeIs(code) {
     this._checkResponseReady()
-    expect(this.response.status).to.eql(code, 'Response code is not the same as expected')
+    assert.strictEqual(this.response.status, code, 'Response code is not the same as expected')
   }
 
   /**
@@ -124,7 +122,7 @@ class JSONResponse extends Helper {
    */
   dontSeeResponseCodeIs(code) {
     this._checkResponseReady()
-    expect(this.response.status).not.to.eql(code)
+    assert.notStrictEqual(this.response.status, code)
   }
 
   /**
@@ -132,8 +130,7 @@ class JSONResponse extends Helper {
    */
   seeResponseCodeIsClientError() {
     this._checkResponseReady()
-    expect(this.response.status).to.be.gte(400)
-    expect(this.response.status).to.be.lt(500)
+    assert(this.response.status >= 400 && this.response.status < 500)
   }
 
   /**
@@ -141,8 +138,7 @@ class JSONResponse extends Helper {
    */
   seeResponseCodeIsRedirection() {
     this._checkResponseReady()
-    expect(this.response.status).to.be.gte(300)
-    expect(this.response.status).to.be.lt(400)
+    assert(this.response.status >= 300 && this.response.status < 400)
   }
 
   /**
@@ -150,8 +146,7 @@ class JSONResponse extends Helper {
    */
   seeResponseCodeIsServerError() {
     this._checkResponseReady()
-    expect(this.response.status).to.be.gte(500)
-    expect(this.response.status).to.be.lt(600)
+    assert(this.response.status >= 500 && this.response.status < 600)
   }
 
   /**
@@ -164,8 +159,7 @@ class JSONResponse extends Helper {
    */
   seeResponseCodeIsSuccessful() {
     this._checkResponseReady()
-    expect(this.response.status).to.be.gte(200)
-    expect(this.response.status).to.be.lt(300)
+    assert(this.response.status >= 200 && this.response.status < 300)
   }
 
   /**
@@ -188,17 +182,19 @@ class JSONResponse extends Helper {
   seeResponseContainsJson(json = {}) {
     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)
     }
   }
 
@@ -222,9 +218,22 @@ class JSONResponse extends Helper {
   dontSeeResponseContainsJson(json = {}) {
     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
+      }
     }
   }
 
@@ -250,20 +259,27 @@ class JSONResponse extends Helper {
   seeResponseContainsKeys(keys = []) {
     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);
    * });
    * ```
    *
@@ -271,7 +287,7 @@ class JSONResponse extends Helper {
    */
   seeResponseValidByCallback(fn) {
     this._checkResponseReady()
-    fn({ ...this.response, expect })
+    fn({ ...this.response, assert })
     const body = fn.toString()
     fn.toString = () => `${body.split('\n')[1]}...`
   }
@@ -288,7 +304,7 @@ class JSONResponse extends Helper {
    */
   seeResponseEquals(resp) {
     this._checkResponseReady()
-    expect(this.response.data).to.deep.equal(resp)
+    assert.deepStrictEqual(this.response.data, resp)
   }
 
   /**
@@ -335,6 +351,17 @@ class JSONResponse extends Helper {
   _checkResponseReady() {
     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) {
+        this._assertContains(actual[key], expected[key])
+      } else {
+        assert.deepStrictEqual(actual[key], expected[key], `Values for key "${key}" don't match`)
+      }
+    }
+  }
 }
 
-module.exports = JSONResponse
+export { JSONResponse as default }

package/lib/helper/Mochawesome.js

@@ -1,9 +1,10 @@
-let addMochawesomeContext
 let currentTest
 let currentSuite
 
-const Helper = require('@codeceptjs/helper')
-const { clearString } = require('../utils')
+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) {
@@ -15,7 +16,10 @@ class Mochawesome extends Helper {
       disableScreenshots: false,
     }
 
-    addMochawesomeContext = require('mochawesome/addContext')
+    // ESM-compatible require for CommonJS module
+    const require = createRequire(import.meta.url)
+    this._addContext = require('mochawesome/addContext')
+
     this._createConfig(config)
   }
 
@@ -43,29 +47,28 @@ class Mochawesome extends Helper {
     if (this.options.disableScreenshots) return
     let fileName
     // Get proper name if we are fail on hook
-    if (test.ctx.test.type === 'hook') {
+    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}`)
     } else {
       currentTest = { test }
-      fileName = clearString(test.title)
+      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)
+      return this._addContext(currentTest, fileName)
     }
   }
 
   addMochawesomeContext(context) {
     if (currentTest === '') currentTest = { test: currentSuite.ctx.test }
-    return addMochawesomeContext(currentTest, context)
+    return this._addContext(currentTest, context)
   }
 }
 
-module.exports = Mochawesome
+export default Mochawesome