review changes pt.4

Author: Bhargavi-BS

nightwatch/globals.js

@@ -259,21 +259,31 @@ module.exports = {
     });
 
     eventBroadcaster.on('TestRunStarted', async (test) => {
-      TestMap.storeTestDetails(test);
+      process.env.VALID_ALLY_PLATFORM = accessibilityAutomation.validateA11yCaps(browser)
       await accessibilityAutomation.beforeEachExecution(test)
       if (testRunner != "cucumber"){
-        const uuid = TestMap.getUUID(test);
+        const uuid = TestMap.storeTestDetails(test);
         process.env.TEST_RUN_UUID = uuid;
         await testObservability.sendTestRunEvent('TestRunStarted', test, uuid)
       }
-      
     });
 
     eventBroadcaster.on('TestRunFinished', async (test) => {
       const uuid = process.env.TEST_RUN_UUID || TestMap.getUUID(test);
-      await accessibilityAutomation.afterEachExecution(test, uuid);
-      if (testRunner != "cucumber"){
-        await testObservability.sendTestRunEvent('TestRunFinished', test, uuid)
+      if (TestMap.hasTestFinished(uuid)) {
+        Logger.debug(`Test with UUID ${uuid} already marked as finished, skipping duplicate TestRunFinished event`);
+        return;
+      }
+      try {
+        await accessibilityAutomation.afterEachExecution(test, uuid)
+        if (testRunner != "cucumber"){
+          await testObservability.sendTestRunEvent('TestRunFinished', test, uuid)
+          TestMap.markTestFinished(uuid);
+        }
+        
+      } catch (error) {
+        Logger.error(`Error in TestRunFinished event: ${error.message}`);
+        TestMap.markTestFinished(uuid);
       }
     });
   },
@@ -341,6 +351,7 @@ module.exports = {
     }
 
     try {
+      // In parallel mode, env-specific settings are passed to beforeChildProcess hook instead of before hook,
       if (helper.isAccessibilitySession() && !settings.parallel_mode) {
         accessibilityAutomation.setAccessibilityCapabilities(settings);
         accessibilityAutomation.commandWrapper();

src/scripts/accessibilityScripts.js

@@ -84,19 +84,23 @@ class AccessibilityScripts {
   }
 
   store() {
-    if (!fs.existsSync(this.browserstackFolderPath)){
-      fs.mkdirSync(this.browserstackFolderPath);
-    }
-
-    fs.writeFileSync(this.commandsPath, JSON.stringify({
-      commands: this.commandsToWrap,
-      scripts: {
-        scan: this.performScan,
-        getResults: this.getResults,
-        getResultsSummary: this.getResultsSummary,
-        saveResults: this.saveTestResults
+    try {
+      if (!fs.existsSync(this.browserstackFolderPath)){
+        fs.mkdirSync(this.browserstackFolderPath);
       }
-    }));
+
+      fs.writeFileSync(this.commandsPath, JSON.stringify({
+        commands: this.commandsToWrap,
+        scripts: {
+          scan: this.performScan,
+          getResults: this.getResults,
+          getResultsSummary: this.getResultsSummary,
+          saveResults: this.saveTestResults
+        }
+      }));
+    } catch (error) {
+      Logger.debug(`Failed to store accessibility commands file: ${error.message}`);
+    }
   }
 }
 

src/testObservability.js

@@ -9,9 +9,11 @@ const CrashReporter = require('./utils/crashReporter');
 const Logger = require('./utils/logger');
 const {API_URL, TAKE_SCREENSHOT_REGEX} = require('./utils/constants');
 const OrchestrationUtils = require('./testorchestration/orchestrationUtils');
+const AccessibilityAutomation = require('./accessibilityAutomation');
 const accessibilityScripts = require('./scripts/accessibilityScripts');
 const TestMap = require('./utils/testMap');
 const hooksMap = {};
+const accessibilityAutomation = new AccessibilityAutomation();
 
 class TestObservability {
   configure(settings = {}) {
@@ -92,7 +94,7 @@ class TestObservability {
                    this._parentSettings?.testReportingOptions ||
                    this._parentSettings?.testObservabilityOptions ||
                    {};
-    const accessibility = this._settings.accessibility || false;             
+    const accessibility = helper.isAccessibilityEnabled(this._parentSettings);             
     const accessibilityOptions = accessibility ? this._settings.accessibilityOptions || {} : {};
     this._gitMetadata = await helper.getGitMetaData();
     const fromProduct = {
@@ -490,7 +492,8 @@ class TestObservability {
         [provider]: helper.getIntegrationsObject(testMetaData.sessionCapabilities, testMetaData.sessionId, testMetaData.host, settings?.desiredCapabilities?.['bstack:options']?.osVersion)
       },
       product_map: {
-        accessibility: helper.isAccessibilitySession()
+        observability: helper.isTestObservabilitySession(),
+        accessibility: helper.isAccessibilitySession() && accessibilityAutomation.shouldScanTestForAccessibility() && process.env.VALID_ALLY_PLATFORM
       }
     };
 

src/utils/testMap.js

@@ -2,34 +2,77 @@ const {v4: uuidv4} = require('uuid');
 
 const sharedTestMap = new Map();
 let sharedCurrentTest = null;
+let activeTestRuns = new Map(); 
 
 class TestMap {
 
   static storeTestDetails(test) {
     const testIdentifier = this.generateTestIdentifier(test);
+    const uuid = this.generateUUID();
 
     if (!sharedTestMap.has(testIdentifier)) {
-      const uuid = this.generateUUID();
       sharedTestMap.set(testIdentifier, {
-        uuid,
+        baseUuid: uuid, // Store the first UUID as base
+        retries: [],
+        currentUuid: uuid,
         test,
         createdAt: new Date().toISOString()
       });
+    } else {
+      // This is a retry - add new UUID to retries array
+      const testData = sharedTestMap.get(testIdentifier);
+      testData.retries.push({
+        uuid,
+        startedAt: new Date().toISOString()
+      });
+      testData.currentUuid = uuid; // Update to latest UUID
+      sharedTestMap.set(testIdentifier, testData);
     }
+    
+    // Track this as an active test run
+    activeTestRuns.set(uuid, {
+      identifier: testIdentifier,
+      startedAt: new Date().toISOString(),
+      hasFinished: false
+    });
+    
     sharedCurrentTest = testIdentifier;
+    
+    return uuid;
   }
 
   static getUUID(test = null) {
     if (test) {
       const testIdentifier = typeof test === 'string' ? test : this.generateTestIdentifier(test);
       const testData = sharedTestMap.get(testIdentifier);
 
-      return testData ? testData.uuid : null;
+      return testData ? testData.currentUuid : null;
     }
+    
+    return null;
   }
 
+  static markTestFinished(uuid) {
+    if (activeTestRuns.has(uuid)) {
+      const testRun = activeTestRuns.get(uuid);
+      testRun.hasFinished = true;
+      testRun.finishedAt = new Date().toISOString();
+      activeTestRuns.set(uuid, testRun);
+      
+      return true;
+    }
+    
+    return false;
+  }
+
+  static hasTestFinished(uuid) {
+    const testRun = activeTestRuns.get(uuid);
+    return testRun ? testRun.hasFinished : false;
+  }
+
+
   static getTestDetails(identifier) {
-  return sharedTestMap.has(identifier) ? sharedTestMap.get(identifier) : null;
+    return sharedTestMap.has(identifier) ? sharedTestMap.get(identifier) : null;
   }
 
   static generateTestIdentifier(test) {