codeceptjs 4.0.0-beta.7.esm-aria → 4.0.0-beta.8.esm-aria

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/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)
+}

package/lib/utils.js

@@ -1,6 +1,7 @@
 import fs from 'fs'
 import os from 'os'
 import path from 'path'
+import { createRequire } from 'module'
 import chalk from 'chalk'
 import getFunctionArguments from 'fn-args'
 import deepClone from 'lodash.clonedeep'
@@ -9,8 +10,7 @@ import { convertColorToRGBA, isColorProperty } from './colorUtils.js'
 import Fuse from 'fuse.js'
 import crypto from 'crypto'
 import jsBeautify from 'js-beautify'
-import childProcess from 'child_process'
-import { createRequire } from 'module'
+import { spawnSync } from 'child_process'
 
 function deepMerge(target, source) {
   return merge(target, source)
@@ -195,8 +195,39 @@ export const test = {
   submittedData(dataFile) {
     return function (key) {
       if (!fs.existsSync(dataFile)) {
-        const waitTill = new Date(new Date().getTime() + 1 * 1000) // wait for one sec for file to be created
-        while (waitTill > new Date()) {}
+        // Extended timeout for CI environments to handle slower processing
+        const waitTime = process.env.CI ? 60 * 1000 : 2 * 1000 // 60 seconds in CI, 2 seconds otherwise
+        let pollInterval = 100 // Start with 100ms polling interval
+        const maxPollInterval = 2000 // Max 2 second intervals
+        const startTime = new Date().getTime()
+
+        // Synchronous polling with exponential backoff to reduce CPU usage
+        while (new Date().getTime() - startTime < waitTime) {
+          if (fs.existsSync(dataFile)) {
+            break
+          }
+
+          // Use Node.js child_process.spawnSync with platform-specific sleep commands
+          // This avoids busy waiting and allows other processes to run
+          try {
+            if (os.platform() === 'win32') {
+              // Windows: use ping with precise timing (ping waits exactly the specified ms)
+              spawnSync('ping', ['-n', '1', '-w', pollInterval.toString(), '127.0.0.1'], { stdio: 'ignore' })
+            } else {
+              // Unix/Linux/macOS: use sleep with fractional seconds
+              spawnSync('sleep', [(pollInterval / 1000).toString()], { stdio: 'ignore' })
+            }
+          } catch (err) {
+            // If system commands fail, use a simple busy wait with minimal CPU usage
+            const end = new Date().getTime() + pollInterval
+            while (new Date().getTime() < end) {
+              // No-op loop - much lighter than previous approaches
+            }
+          }
+
+          // Exponential backoff: gradually increase polling interval to reduce resource usage
+          pollInterval = Math.min(pollInterval * 1.2, maxPollInterval)
+        }
       }
       if (!fs.existsSync(dataFile)) {
         throw new Error('Data file was not created in time')
@@ -447,8 +478,12 @@ export const isNotSet = function (obj) {
   return false
 }
 
-export const emptyFolder = async directoryPath => {
-  childProcess.execSync(`rm -rf ${directoryPath}/*`)
+export const emptyFolder = directoryPath => {
+  // Do not throw on non-existent directory, since it may be created later
+  if (!fs.existsSync(directoryPath)) return
+  for (const file of fs.readdirSync(directoryPath)) {
+    fs.rmSync(path.join(directoryPath, file), { recursive: true, force: true })
+  }
 }
 
 export const printObjectProperties = obj => {
@@ -547,6 +582,52 @@ export const humanizeString = function (string) {
   return _result.join(' ').trim()
 }
 
+/**
+ * Creates a circular-safe replacer function for JSON.stringify
+ * @param {string[]} keysToSkip - Keys to skip during serialization to break circular references
+ * @returns {Function} Replacer function for JSON.stringify
+ */
+function createCircularSafeReplacer(keysToSkip = []) {
+  const seen = new WeakSet()
+  const defaultSkipKeys = ['parent', 'tests', 'suite', 'root', 'runner', 'ctx']
+  const skipKeys = new Set([...defaultSkipKeys, ...keysToSkip])
+
+  return function (key, value) {
+    // Skip specific keys that commonly cause circular references
+    if (key && skipKeys.has(key)) {
+      return undefined
+    }
+
+    if (value === null || typeof value !== 'object') {
+      return value
+    }
+
+    // Handle circular references
+    if (seen.has(value)) {
+      return `[Circular Reference to ${value.constructor?.name || 'Object'}]`
+    }
+
+    seen.add(value)
+    return value
+  }
+}
+
+/**
+ * Safely stringify an object, handling circular references
+ * @param {any} obj - Object to stringify
+ * @param {string[]} keysToSkip - Additional keys to skip during serialization
+ * @param {number} space - Number of spaces for indentation (default: 0)
+ * @returns {string} JSON string representation
+ */
+export const safeStringify = function (obj, keysToSkip = [], space = 0) {
+  try {
+    return JSON.stringify(obj, createCircularSafeReplacer(keysToSkip), space)
+  } catch (error) {
+    // Fallback for any remaining edge cases
+    return JSON.stringify({ error: `Failed to serialize: ${error.message}` }, null, space)
+  }
+}
+
 export const serializeError = function (error) {
   if (error) {
     const { stack, uncaught, message, actual, expected } = error

package/lib/workerStorage.js

@@ -1,4 +1,5 @@
 import { isMainThread, parentPort } from 'worker_threads'
+import Container from './container.js'
 
 const workerObjects = {}
 const shareEvent = 'share'
@@ -7,7 +8,7 @@ const invokeWorkerListeners = workerObj => {
   const { threadId } = workerObj
   workerObj.on('message', messageData => {
     if (messageData.event === shareEvent) {
-      share(messageData.data)
+      Container.share(messageData.data)
     }
   })
   workerObj.on('exit', () => {