@enact/ui-test-utils 4.0.0 → 4.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enact/ui-test-utils",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "UI Testing for the Enact framework",
   "repository": "https://github.com/enactjs/ui-test-utils",
   "type": "module",
@@ -23,38 +23,37 @@
   "author": "Roy Sutton <roy.sutton@lge.com>",
   "license": "Apache-2.0",
   "engines": {
-    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+    "node": "^20.19.0 || ^22.0.0 || >=24.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@wdio/cli": "^9.20.0",
-    "@wdio/dot-reporter": "^9.20.0",
-    "@wdio/local-runner": "^9.20.0",
-    "@wdio/mocha-framework": "^9.20.0",
-    "@wdio/spec-reporter": "^9.20.0",
-    "@wdio/static-server-service": "^9.20.0",
-    "@wdio/visual-service": "^9.0.0",
+    "@wdio/cli": "^9.27.0",
+    "@wdio/dot-reporter": "^9.27.0",
+    "@wdio/local-runner": "^9.27.0",
+    "@wdio/mocha-framework": "^9.27.0",
+    "@wdio/spec-reporter": "^9.27.0",
+    "@wdio/static-server-service": "^9.27.0",
+    "@wdio/visual-service": "^9.2.1",
     "chalk": "^5.6.2",
     "cross-spawn": "^7.0.6",
-    "expect-webdriverio": "^5.4.3",
-    "fs-extra": "^11.3.2",
+    "expect-webdriverio": "^5.6.5",
+    "fs-extra": "^11.3.4",
     "minimist": "^1.2.8",
     "query-string": "^7.1.3",
-    "ramda": "^0.31.3",
-    "readdirp": "^3.6.0",
+    "ramda": "^0.32.0",
+    "readdirp": "^5.0.0",
     "wdio-docker-service": "^3.2.1",
-    "webdriverio": "^9.20.0"
+    "webdriverio": "^9.27.0"
   },
   "devDependencies": {
-    "eslint": "^9.36.0",
-    "eslint-config-enact": "^5.0.2",
-    "globals": "^16.4.0"
+    "eslint": "^9.39.3",
+    "eslint-config-enact": "^5.1.0",
+    "globals": "^17.4.0"
   },
   "overrides": {
-    "cross-spawn": "$cross-spawn",
-    "express": "^4.21.2",
-    "ws": "^8.18.0"
+    "serialize-javascript": "^7.0.4",
+    "simple-xml-to-json": "1.2.4"
   }
 }

package/screenshot/utils/confHelpers.js

@@ -32,6 +32,7 @@ const baselineRelativePath = 'screenshots/reference';
 const screenshotRelativePath = 'screenshots/screen';
 const baselineFolder = path.join(distPath, baselineRelativePath);
 const screenshotFolder = path.join(distPath, screenshotRelativePath);
+const pendingFailuresFolder = path.join(distPath, 'pending-failures');
 
 const generateReferenceName = getScreenshotName(baselineFolder);
 
@@ -52,6 +53,15 @@ function initFile (name, content) {
 }
 
 function onPrepare () {
+	global.sessionFailures = new Map();
+	global.failedSessions = new Set();
+
+	// Clear any leftover pending-failure files from a previous run
+	if (fs.existsSync(pendingFailuresFolder)) {
+		fs.rmSync(pendingFailuresFolder, {recursive: true, force: true});
+	}
+	fs.mkdirSync(pendingFailuresFolder, {recursive: true});
+
 	if (!fs.existsSync('tests/screenshot/dist/screenshots/reference')) {
 		console.log('No reference screenshots found, creating new references!');
 	}
@@ -62,7 +72,169 @@ function onPrepare () {
 	return buildApps('screenshot');
 }
 
-function beforeTest (testData) {
+/* Checks if a browser session is healthy. If not, it will attempt to recover. */
+async function checkSessionHealth () {
+	const sessionId = browser.sessionId;
+
+	// Check if this session has been marked as dead
+	if (global.failedSessions && global.failedSessions.has(sessionId)) {
+		throw new Error('Session is marked as failed - skipping remaining tests');
+	}
+
+	// Skip health check if the session was just recovered
+	if (global.recentlyRecovered && global.recentlyRecovered.has(sessionId)) {
+		global.recentlyRecovered.delete(sessionId);
+	} else {
+		// Quick health check with a short timeout
+		try {
+			await Promise.race([
+				browser.execute(() => true),
+				new Promise((_, reject) =>
+					setTimeout(() => reject(new Error('Health check timeout')), 3000)
+				)
+			]);
+
+			// Success - reset failure counter
+			if (global.sessionFailures) {
+				global.sessionFailures.set(sessionId, 0);
+			}
+		} catch (e) {
+			// Track consecutive failures
+			const failures = (global.sessionFailures?.get(sessionId) || 0) + 1;
+			if (global.sessionFailures) {
+				global.sessionFailures.set(sessionId, failures);
+			}
+
+			console.log(`Session ${sessionId} health check failed (failure ${failures}/3)`);
+
+			// Only mark as dead after 3 consecutive failures
+			if (failures >= 3) {
+				console.log(`Session ${sessionId} has failed 3 times - marking as dead`);
+				if (global.failedSessions) {
+					global.failedSessions.add(sessionId);
+				}
+				throw new Error('Session health check failed - marking as dead');
+			}
+
+			// Try quick recovery for the first 2 failures
+			console.log(`Attempting quick recovery for session ${sessionId}...`);
+			try {
+				await browser.reloadSession();
+				await browser.setWindowSize(1920, 1167);
+				console.log(`Session ${sessionId} recovered`);
+			} catch (recoveryError) {
+				console.log(`Recovery attempt failed, will retry next test`);
+			}
+		}
+	}
+}
+
+async function cleanUpSessionHealthCheck (testData, error) {
+	if (error) {
+		const isTimeout = error.message &&
+			(error.message.includes('timeout') ||
+				error.message.includes('aborted') ||
+				error.message.includes('HEADERS_TIMEOUT') ||
+				error.message.includes('ECONNREFUSED'));
+
+		if (isTimeout) {
+			const sessionId = browser.sessionId;
+
+			// Track consecutive failures
+			if (!global.sessionFailures) {
+				global.sessionFailures = new Map();
+			}
+
+			const failures = (global.sessionFailures.get(sessionId) || 0) + 1;
+			global.sessionFailures.set(sessionId, failures);
+
+			console.log(`Timeout #${failures} in session ${sessionId} - test: "${testData.title}"`);
+
+			// Circuit breaker: after 3 consecutive timeouts, kill the session
+			if (failures >= 3) {
+				console.log(`Session ${sessionId} has failed 3 times consecutively - marking as dead`);
+
+				if (!global.failedSessions) {
+					global.failedSessions = new Set();
+				}
+				global.failedSessions.add(sessionId);
+
+				// Try to clean up with very short timeout, then give up
+				try {
+					await Promise.race([
+						(async () => {
+							try {
+								await browser.execute(() => window.stop());
+							} catch (e) {
+								// Ignore
+							}
+							await browser.deleteSession();
+						})(),
+						new Promise((_, reject) =>
+							setTimeout(() => reject(new Error('Cleanup timeout')), 2000)
+						)
+					]);
+					console.log('Session cleanup completed');
+				} catch (e) {
+					console.log('Session cleanup timed out - session is dead');
+				}
+
+				return; // Don't try to recover
+			}
+
+			// For first 2 failures, attempt recovery
+			console.log(`Attempting recovery for session ${sessionId} (attempt ${failures}/3)`);
+
+			try {
+				// Try light recovery with timeout
+				await Promise.race([
+					(async () => {
+						try {
+							await browser.execute(() => window.stop());
+						} catch (e) {
+							// Ignore
+						}
+						await browser.deleteSession();
+						await browser.reloadSession();
+						await browser.setWindowSize(1920, 1167);
+						await browser.pause(1000);
+					})(),
+					new Promise((_, reject) =>
+						setTimeout(() => reject(new Error('Recovery timeout')), 10000)
+					)
+				]);
+
+				console.log('Session recovered successfully');
+
+				// Reset failure count on successful recovery
+				global.sessionFailures.set(sessionId, 0);
+
+				// Mark that we just recovered - skip next health check
+				if (!global.recentlyRecovered) {
+					global.recentlyRecovered = new Set();
+				}
+				global.recentlyRecovered.add(sessionId);
+
+			} catch (recoveryError) {
+				console.error(`Session recovery failed: ${recoveryError.message}`);
+			}
+		} else {
+			const sessionId = browser.sessionId;
+			if (global.sessionFailures && global.sessionFailures.has(sessionId)) {
+				global.sessionFailures.set(sessionId, 0);
+			}
+		}
+	} else {
+		const sessionId = browser.sessionId;
+		if (global.sessionFailures && global.sessionFailures.has(sessionId)) {
+			global.sessionFailures.set(sessionId, 0);
+		}
+	}
+}
+
+async function beforeTest (testData) {
+	await checkSessionHealth();
+
 	// If title doesn't have a '/', it's not a screenshot test, don't save
 	if (testData && testData.title && testData.title.indexOf('/') > 0) {
 		const filename = generateReferenceName({test: testData});
@@ -78,7 +250,7 @@ function beforeTest (testData) {
 	}
 }
 
-function afterTest (testData, _context, {passed}) {
+async function afterTest (testData, _context, {error, passed}) {
 	// If this doesn't include context data, not a screenshot test
 	if (testData && testData.title && testData.context && testData.context.params) {
 		const fileName = testData.context.fileName.replace(/ /g, '_') + '.png';
@@ -98,26 +270,52 @@ function afterTest (testData, _context, {passed}) {
 			});
 		}
 
+		// Use a stable filename derived from the test identifier so the worker can find and
+		// delete the right file on a passing retry, even across different worker processes.
+		const testIdentifier = testData.title + '::' + fileName;
+		const pendingKey = cryptoModule.createHash('md5').update(testIdentifier).digest('hex');
+		const pendingFile = path.join(pendingFailuresFolder, `${pendingKey}.json`);
+
 		if (!passed) {
+			// Track pending failed tests to avoid duplicate logging during retries
 			const screenPath = path.join(screenshotRelativePath, 'actual', fileName);
 			const diffPath = path.join(screenshotRelativePath, 'diff', fileName);
-			fs.open(failedScreenshotFilename, 'a', (err, fd) => {
-				if (err) {
-					console.error('Unable to create failed test log file!');
-				} else {
-					const title = testData.title.replace(/~\//g, '/');
-					const {params, url} = testData.context;
-					const output = {title, diffPath, referencePath, screenPath, params, url};
-					fs.appendFile(fd, `${JSON.stringify(output)},`, 'utf8', () => {
-						fs.close(fd);
-					});
-				}
-			});
+			const title = testData.title.replace(/~\//g, '/');
+			const {params, url} = testData.context;
+			const output = {title, diffPath, referencePath, screenPath, params, url};
+			try {
+				fs.writeFileSync(pendingFile, JSON.stringify(output), 'utf8');
+			} catch (writeErr) {
+				console.error(`Unable to stage failure for "${title}": ${writeErr.message}`);
+			}
+		} else {
+			// Test passed (possibly on retry) — remove the staged failure so it won't be reported
+			try {
+				fs.unlinkSync(pendingFile);
+			} catch (e) {
+				// test passed on first attempt — nothing to do
+			}
 		}
 	}
+
+	await cleanUpSessionHealthCheck(testData, error);
 }
 
 function onComplete () {
+	// Write all tests that ultimately failed
+	if (fs.existsSync(pendingFailuresFolder)) {
+		const pendingFiles = fs.readdirSync(pendingFailuresFolder).filter(f => f.endsWith('.json'));
+		for (const file of pendingFiles) {
+			try {
+				const raw = fs.readFileSync(path.join(pendingFailuresFolder, file), 'utf8');
+				fs.appendFileSync(failedScreenshotFilename, `${raw},`, 'utf8');
+			} catch (e) {
+				console.error(`Failed to flush pending failure ${file}: ${e.message}`);
+			}
+		}
+		fs.rmSync(pendingFailuresFolder, {recursive: true, force: true});
+	}
+
 	const {size: newSize} = fs.statSync(newScreenshotFilename),
 		{size: failedSize} = fs.statSync(failedScreenshotFilename);
 

package/src/build-apps.js

@@ -3,18 +3,20 @@ import path from 'path';
 let chalk;
 import spawn from 'cross-spawn';
 import fs from 'fs-extra';
-import readdirp from 'readdirp';
+import {readdirpPromise} from 'readdirp';
 import * as url from 'url';
 
 const env = {
 	ILIB_BASE_PATH: '/framework/ilib',
 	ILIB_ASSET_CREATE: 'false',
 	SIMPLE_CSS_IDENT: 'true',
-	BROWSERSLIST: 'Chrome 79'
+	BROWSERSLIST: 'Chrome 132'
 };
 
 function findViews (base) {
-	return readdirp.promise(path.join('tests', base, 'apps'), {fileFilter: '*-View.js'});
+	return readdirpPromise(path.join('tests', base, 'apps'), {
+		fileFilter: (entry) => entry.basename.endsWith('-View.js')
+	});
 }
 
 // eslint-disable-next-line no-shadow

package/utils/Page.js

@@ -12,7 +12,7 @@ export class Page {
 
 	async open (appPath, urlExtra = '?locale=en-US') {
 		await browser.execute(function () {
-			document.body.innerHTML = '';
+			document.body.textContent = '';
 		});
 
 		this._url = `/${appPath}/${urlExtra}`;