codeceptjs 4.0.0-beta.1 → 4.0.0-beta.10.esm-aria

package/lib/template/heal.js

@@ -1,4 +1,4 @@
-const { heal, ai } = require('codeceptjs')
+import { heal, ai } from 'codeceptjs'
 
 heal.addRecipe('ai', {
   priority: 10,
@@ -6,17 +6,8 @@ heal.addRecipe('ai', {
     html: ({ I }) => I.grabHTMLFrom('body'),
   },
   suggest: true,
-  steps: [
-    'click',
-    'fillField',
-    'appendField',
-    'selectOption',
-    'attachFile',
-    'checkOption',
-    'uncheckOption',
-    'doubleClick',
-  ],
-  fn: async (args) => {
+  steps: ['click', 'fillField', 'appendField', 'selectOption', 'attachFile', 'checkOption', 'uncheckOption', 'doubleClick'],
+  fn: async args => {
     return ai.healFailedStep(args)
   },
 })

package/lib/template/prompts/generatePageObject.js

@@ -0,0 +1,31 @@
+export default (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();
+
+export default {
+
+  // setting locators
+  element1: '#selector',
+  element2: '.selector',
+  element3: locate().withText('text'),
+
+  // setting methods
+  doSomethingOnPage(params) {
+    // ...
+  },
+}
+
+      I want to generate a Page Object for the page I provide.
+      Write JavaScript code in similar manner to list all locators on the page.
+      Use locators in order of preference: by text (use locate().withText()), label, CSS, XPath.
+      Avoid TailwindCSS, Bootstrap or React style formatting classes in locators.
+      Add methods to interact with page when needed.
+      ${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}`,
+  },
+]

package/lib/template/prompts/healStep.js

@@ -0,0 +1,13 @@
+export default (html, { step, error, prevSteps }) => {
+  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}`,
+    },
+  ]
+}

package/lib/template/prompts/writeStep.js

@@ -0,0 +1,9 @@
+export default (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}`,
+  },
+]

package/lib/test-server.js

@@ -0,0 +1,334 @@
+import express from 'express'
+import fs from 'fs'
+import path from 'path'
+
+/**
+ * Internal API test server to replace json-server dependency
+ * Provides REST API endpoints for testing CodeceptJS helpers
+ */
+class TestServer {
+  constructor(config = {}) {
+    this.app = express()
+    this.server = null
+    this.port = config.port || 8010
+    this.host = config.host || 'localhost'
+    this.dbFile = config.dbFile || path.join(__dirname, '../test/data/rest/db.json')
+    this.readOnly = config.readOnly || false
+    this.lastModified = null
+    this.data = this.loadData()
+
+    this.setupMiddleware()
+    this.setupRoutes()
+    this.setupFileWatcher()
+  }
+
+  loadData() {
+    try {
+      const content = fs.readFileSync(this.dbFile, 'utf8')
+      const data = JSON.parse(content)
+      // Update lastModified time when loading data
+      if (fs.existsSync(this.dbFile)) {
+        this.lastModified = fs.statSync(this.dbFile).mtime
+      }
+      console.log('[Data Load] Loaded data from file:', JSON.stringify(data))
+      return data
+    } catch (err) {
+      console.warn(`[Data Load] Could not load data file ${this.dbFile}:`, err.message)
+      console.log('[Data Load] Using fallback default data')
+      return {
+        posts: [{ id: 1, title: 'json-server', author: 'davert' }],
+        user: { name: 'john', password: '123456' },
+      }
+    }
+  }
+
+  reloadData() {
+    console.log('[Reload] Reloading data from file...')
+    this.data = this.loadData()
+    console.log('[Reload] Data reloaded successfully')
+    return this.data
+  }
+
+  saveData() {
+    if (this.readOnly) {
+      console.log('[Save] Skipping save - running in read-only mode')
+      return
+    }
+    try {
+      fs.writeFileSync(this.dbFile, JSON.stringify(this.data, null, 2))
+      console.log('[Save] Data saved to file')
+      // Force update modification time to ensure auto-reload works
+      const now = new Date()
+      fs.utimesSync(this.dbFile, now, now)
+      this.lastModified = now
+      console.log('[Save] File modification time updated')
+    } catch (err) {
+      console.warn(`[Save] Could not save data file ${this.dbFile}:`, err.message)
+    }
+  }
+
+  setupMiddleware() {
+    // Parse JSON bodies
+    this.app.use(express.json())
+
+    // Parse URL-encoded bodies
+    this.app.use(express.urlencoded({ extended: true }))
+
+    // CORS support
+    this.app.use((req, res, next) => {
+      res.header('Access-Control-Allow-Origin', '*')
+      res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS')
+      res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization, X-Test')
+
+      if (req.method === 'OPTIONS') {
+        res.status(200).end()
+        return
+      }
+      next()
+    })
+
+    // Auto-reload middleware - check if file changed before each request
+    this.app.use((req, res, next) => {
+      try {
+        if (fs.existsSync(this.dbFile)) {
+          const stats = fs.statSync(this.dbFile)
+          if (!this.lastModified || stats.mtime > this.lastModified) {
+            console.log(`[Auto-reload] Database file changed (${this.dbFile}), reloading data...`)
+            console.log(`[Auto-reload] Old mtime: ${this.lastModified}, New mtime: ${stats.mtime}`)
+            this.reloadData()
+            this.lastModified = stats.mtime
+            console.log(`[Auto-reload] Data reloaded, user name is now: ${this.data.user?.name}`)
+          }
+        }
+      } catch (err) {
+        console.warn('[Auto-reload] Error checking file modification time:', err.message)
+      }
+      next()
+    })
+
+    // Logging middleware
+    this.app.use((req, res, next) => {
+      console.log(`${req.method} ${req.path}`)
+      next()
+    })
+  }
+
+  setupRoutes() {
+    // Reload endpoint (for testing)
+    this.app.post('/_reload', (req, res) => {
+      this.reloadData()
+      res.json({ message: 'Data reloaded', data: this.data })
+    })
+
+    // Headers endpoint (for header testing)
+    this.app.get('/headers', (req, res) => {
+      res.json(req.headers)
+    })
+
+    this.app.post('/headers', (req, res) => {
+      res.json(req.headers)
+    })
+
+    // User endpoints
+    this.app.get('/user', (req, res) => {
+      console.log(`[GET /user] Serving user data: ${JSON.stringify(this.data.user)}`)
+      res.json(this.data.user)
+    })
+
+    this.app.post('/user', (req, res) => {
+      this.data.user = { ...this.data.user, ...req.body }
+      this.saveData()
+      res.status(201).json(this.data.user)
+    })
+
+    this.app.patch('/user', (req, res) => {
+      this.data.user = { ...this.data.user, ...req.body }
+      this.saveData()
+      res.json(this.data.user)
+    })
+
+    this.app.put('/user', (req, res) => {
+      this.data.user = req.body
+      this.saveData()
+      res.json(this.data.user)
+    })
+
+    // Posts endpoints
+    this.app.get('/posts', (req, res) => {
+      res.json(this.data.posts)
+    })
+
+    this.app.get('/posts/:id', (req, res) => {
+      const id = parseInt(req.params.id)
+      const post = this.data.posts.find(p => p.id === id)
+
+      if (!post) {
+        // Return empty object instead of 404 for json-server compatibility
+        return res.json({})
+      }
+
+      res.json(post)
+    })
+
+    this.app.post('/posts', (req, res) => {
+      const newId = Math.max(...this.data.posts.map(p => p.id || 0)) + 1
+      const newPost = { id: newId, ...req.body }
+
+      this.data.posts.push(newPost)
+      this.saveData()
+      res.status(201).json(newPost)
+    })
+
+    this.app.put('/posts/:id', (req, res) => {
+      const id = parseInt(req.params.id)
+      const postIndex = this.data.posts.findIndex(p => p.id === id)
+
+      if (postIndex === -1) {
+        return res.status(404).json({ error: 'Post not found' })
+      }
+
+      this.data.posts[postIndex] = { id, ...req.body }
+      this.saveData()
+      res.json(this.data.posts[postIndex])
+    })
+
+    this.app.patch('/posts/:id', (req, res) => {
+      const id = parseInt(req.params.id)
+      const postIndex = this.data.posts.findIndex(p => p.id === id)
+
+      if (postIndex === -1) {
+        return res.status(404).json({ error: 'Post not found' })
+      }
+
+      this.data.posts[postIndex] = { ...this.data.posts[postIndex], ...req.body }
+      this.saveData()
+      res.json(this.data.posts[postIndex])
+    })
+
+    this.app.delete('/posts/:id', (req, res) => {
+      const id = parseInt(req.params.id)
+      const postIndex = this.data.posts.findIndex(p => p.id === id)
+
+      if (postIndex === -1) {
+        return res.status(404).json({ error: 'Post not found' })
+      }
+
+      const deletedPost = this.data.posts.splice(postIndex, 1)[0]
+      this.saveData()
+      res.json(deletedPost)
+    })
+
+    // File upload endpoint (basic implementation)
+    this.app.post('/upload', (req, res) => {
+      // Simple upload simulation - for more complex file uploads,
+      // multer would be needed but basic tests should work
+      res.json({
+        message: 'File upload endpoint available',
+        headers: req.headers,
+        body: req.body,
+      })
+    })
+
+    // Comments endpoints (for ApiDataFactory tests)
+    this.app.get('/comments', (req, res) => {
+      res.json(this.data.comments || [])
+    })
+
+    this.app.post('/comments', (req, res) => {
+      if (!this.data.comments) this.data.comments = []
+      const newId = Math.max(...this.data.comments.map(c => c.id || 0), 0) + 1
+      const newComment = { id: newId, ...req.body }
+
+      this.data.comments.push(newComment)
+      this.saveData()
+      res.status(201).json(newComment)
+    })
+
+    this.app.delete('/comments/:id', (req, res) => {
+      if (!this.data.comments) this.data.comments = []
+      const id = parseInt(req.params.id)
+      const commentIndex = this.data.comments.findIndex(c => c.id === id)
+
+      if (commentIndex === -1) {
+        return res.status(404).json({ error: 'Comment not found' })
+      }
+
+      const deletedComment = this.data.comments.splice(commentIndex, 1)[0]
+      this.saveData()
+      res.json(deletedComment)
+    })
+
+    // Generic catch-all for other endpoints
+    this.app.use((req, res) => {
+      res.status(404).json({ error: 'Endpoint not found' })
+    })
+  }
+
+  setupFileWatcher() {
+    if (fs.existsSync(this.dbFile)) {
+      fs.watchFile(this.dbFile, (current, previous) => {
+        if (current.mtime !== previous.mtime) {
+          console.log('Database file changed, reloading data...')
+          this.reloadData()
+        }
+      })
+    }
+  }
+
+  start() {
+    return new Promise((resolve, reject) => {
+      this.server = this.app.listen(this.port, this.host, err => {
+        if (err) {
+          reject(err)
+        } else {
+          console.log(`Test server running on http://${this.host}:${this.port}`)
+          resolve(this.server)
+        }
+      })
+    })
+  }
+
+  stop() {
+    return new Promise(resolve => {
+      if (this.server) {
+        this.server.close(() => {
+          console.log('Test server stopped')
+          resolve()
+        })
+      } else {
+        resolve()
+      }
+    })
+  }
+}
+
+export default TestServer
+
+// CLI usage - Import meta for ESM
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const config = {
+    port: process.env.PORT || 8010,
+    host: process.env.HOST || '0.0.0.0',
+    dbFile: process.argv[2] || path.join(__dirname, '../test/data/rest/db.json'),
+  }
+
+  const server = new TestServer(config)
+  server.start().catch(console.error)
+
+  // Graceful shutdown
+  process.on('SIGINT', () => {
+    console.log('\nShutting down test server...')
+    server.stop().then(() => process.exit(0))
+  })
+
+  process.on('SIGTERM', () => {
+    console.log('\nShutting down test server...')
+    server.stop().then(() => process.exit(0))
+  })
+}

package/lib/timeout.js

@@ -0,0 +1,60 @@
+const TIMEOUT_ORDER = {
+  /**
+   * timeouts set with order below zero only override timeouts of higher order if their value is smaller
+   */
+  testOrSuite: -5,
+  /**
+   * 0-9 - designated for override of timeouts set from code, 5 is used by stepTimeout plugin when stepTimeout.config.overrideStepLimits=true
+   */
+  stepTimeoutHard: 5,
+  /**
+   * 10-19 - designated for timeouts set from code, 15 is order of I.setTimeout(t) operation
+   */
+  codeLimitTime: 15,
+  /**
+   * 20-29 - designated for timeout settings which could be overriden in tests code, 25 is used by stepTimeout plugin when stepTimeout.config.overrideStepLimits=false
+   */
+  stepTimeoutSoft: 25,
+}
+
+function getCurrentTimeout(timeouts) {
+  let totalTimeout
+  // iterate over all timeouts starting from highest values of order
+  new Map([...timeouts.entries()].sort().reverse()).forEach((timeout, order) => {
+    if (
+      timeout !== undefined &&
+      // when orders >= 0 - timeout value overrides those set with higher order elements
+      (order >= 0 ||
+        // when `order < 0 && totalTimeout === undefined` - timeout is used when nothing is set by elements with higher order
+        totalTimeout === undefined ||
+        // when `order < 0` - timeout overrides higher values of timeout or 'no timeout' (totalTimeout === 0) set by elements with higher order
+        (timeout > 0 && (timeout < totalTimeout || totalTimeout === 0)))
+    ) {
+      totalTimeout = timeout
+    }
+  })
+  return totalTimeout
+}
+
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'TimeoutError'
+  }
+}
+
+class TestTimeoutError extends TimeoutError {
+  constructor(timeout) {
+    super(`Timeout ${timeout}s exceeded (with Before hook)`)
+    this.name = 'TestTimeoutError'
+  }
+}
+
+class StepTimeoutError extends TimeoutError {
+  constructor(timeout, step) {
+    super(`Step ${step.toCode().trim()} timed out after ${timeout}s`)
+    this.name = 'StepTimeoutError'
+  }
+}
+
+export { TIMEOUT_ORDER, getCurrentTimeout, TimeoutError, TestTimeoutError, StepTimeoutError }

package/lib/transform.js

@@ -1,26 +1,26 @@
 const transformers = {
   'gherkin.examples': [],
-};
+}
 
 function transform(target, value) {
   if (target in transformers) {
     for (const transform of transformers[target]) {
-      value = transform(value);
+      value = transform(value)
     }
   }
-  return value;
+  return value
 }
 
 transform.addTransformer = function (target, transformer) {
   if (target in transformers) {
-    transformers[target].push(transformer);
+    transformers[target].push(transformer)
   }
-};
+}
 
 transform.addTransformerBeforeAll = function (target, transformer) {
   if (target in transformers) {
-    transformers[target].unshift(transformer);
+    transformers[target].unshift(transformer)
   }
-};
+}
 
-export default transform;
+export default transform

package/lib/translation.js

@@ -1,56 +1,69 @@
-import merge from 'lodash.merge';
-import path from 'path';
-
-import importSync from 'import-sync';
-import * as translations from '../translations/index.js';
+import merge from 'lodash.merge'
+import path from 'path'
+import { createRequire } from 'module'
 
 const defaultVocabulary = {
   I: 'I',
   actions: {},
-};
+}
 
-export default class Translation {
+class Translation {
   constructor(vocabulary, loaded) {
-    this.vocabulary = vocabulary;
-    this.loaded = loaded !== false;
+    this.vocabulary = vocabulary
+    this.loaded = loaded !== false
   }
 
   loadVocabulary(vocabularyFile) {
-    if (!vocabularyFile) return;
-    const filePath = path.join(global.codecept_dir, vocabularyFile);
+    if (!vocabularyFile) return
+    const filePath = path.join(global.codecept_dir, vocabularyFile)
 
     try {
-      const vocabulary = importSync(filePath);
-      this.vocabulary = merge(this.vocabulary, vocabulary);
+      const require = createRequire(import.meta.url)
+      const vocabulary = require(filePath)
+      this.vocabulary = merge(this.vocabulary, vocabulary)
     } catch (err) {
-      throw new Error(`Can't load vocabulary from ${filePath}; ${err}`);
+      throw new Error(`Can't load vocabulary from ${filePath}; ${err}`)
     }
   }
 
   value(val) {
-    return this.vocabulary[val];
+    return this.vocabulary[val]
   }
 
   actionAliasFor(actualActionName) {
     if (this.vocabulary.actions && this.vocabulary.actions[actualActionName]) {
-      return this.vocabulary.actions[actualActionName];
+      return this.vocabulary.actions[actualActionName]
     }
-    return actualActionName;
+    return actualActionName
   }
 
   get I() {
-    return this.vocabulary.I;
+    return this.vocabulary.I
+  }
+
+  static async getLangs() {
+    const translations = await import('../translations/index.js')
+    return translations.default
   }
 
   static get langs() {
-    return translations;
+    // Synchronous fallback - may be empty initially
+    if (!this._cachedLangs) {
+      this.getLangs().then(langs => {
+        this._cachedLangs = langs
+      })
+      return {}
+    }
+    return this._cachedLangs
   }
 
   static createDefault() {
-    return new Translation(defaultVocabulary, true);
+    return new Translation(defaultVocabulary, true)
   }
 
   static createEmpty() {
-    return new Translation(defaultVocabulary, false);
+    return new Translation(defaultVocabulary, false)
   }
 }
+
+export default Translation

package/lib/utils/mask_data.js

@@ -0,0 +1,47 @@
+import { maskSensitiveData } from 'invisi-data'
+
+/**
+ * Mask sensitive data utility for CodeceptJS
+ * Supports both boolean and object configuration formats
+ *
+ * @param {string} input - The string to mask
+ * @param {boolean|object} config - Masking configuration
+ * @returns {string} - Masked string
+ */
+export function maskData(input, config) {
+  if (!config) {
+    return input
+  }
+
+  // Handle boolean config (backward compatibility)
+  if (typeof config === 'boolean' && config === true) {
+    return maskSensitiveData(input)
+  }
+
+  // Handle object config with custom patterns
+  if (typeof config === 'object' && config.enabled === true) {
+    const customPatterns = config.patterns || []
+    return maskSensitiveData(input, customPatterns)
+  }
+
+  return input
+}
+
+/**
+ * Check if masking is enabled based on global configuration
+ *
+ * @returns {boolean|object} - Current masking configuration
+ */
+export function getMaskConfig() {
+  return global.maskSensitiveData || false
+}
+
+/**
+ * Check if data should be masked
+ *
+ * @returns {boolean} - True if masking is enabled
+ */
+export function shouldMaskData() {
+  const config = getMaskConfig()
+  return config === true || (typeof config === 'object' && config.enabled === true)
+}