playwright-slack-report-burak 2.1.0 → 2.2.0

package/dist/src/ResultsParser.js

@@ -6,38 +6,120 @@
 /* eslint-disable class-methods-use-this */
 /* eslint-disable no-param-reassign */
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const { execSync } = require('child_process');
+
 class ResultsParser {
     result;
     separateFlakyTests;
+    totalShardCount = process.env.CIRCLE_NODE_TOTAL ? parseInt(process.env.CIRCLE_NODE_TOTAL, 10) : 1;
+    shardIndex = process.env.CIRCLE_NODE_INDEX ? parseInt(process.env.CIRCLE_NODE_INDEX, 10) : 0;
     constructor(options = { separateFlakyTests: false }) {
         this.result = [];
         this.separateFlakyTests = options.separateFlakyTests;
     }
     async getParsedResults() {
+      const summary = {
+          total: 0,
+          passed: 0,
+          failed: 0,
+          flaky: 0,
+          skipped: 0,
+          failures: [],
+          tests: [],
+      };
         const failures = await this.getFailures();
         const flakes = await this.getFlakes();
         let passes = await this.getPasses();
         /*if (this.separateFlakyTests) {
             passes = this.doSeparateFlakyTests(passes, flakes);
         }*/
-        const summary = {
-            passed: passes.length,
-            failed: failures.length,
-            flaky: (this.separateFlakyTests && flakes.length > 0) ?
-                flakes.length : 0,
+
+        // Define the directory to store node summaries
+        const summariesDir = path.join('./', 'playwright-report');
+        
+        if (!fs.existsSync(summariesDir)) {
+            fs.mkdirSync(summariesDir, { recursive: true });
+        }
+
+        // Determine the current node index
+        const currentNodeIndex = this.shardIndex;
+
+        // Define the file for the current node's summary
+        const nodeSummaryFile = path.join(summariesDir, `node_summary_${currentNodeIndex}.json`);
+
+        const totalTestCasesForNode = this.result.reduce((acc, suite) => acc + suite.testSuite.tests.length, 0);
+
+        // Initialize or read existing summary from file
+        let nodeSummary = {
+            total: totalTestCasesForNode,
+            passed: 0,
+            failed: 0,
+            flaky: 0,
             skipped: 0,
-            failures,
+            failures: [],
             tests: [],
         };
+
+        // Create the file if it doesn't exist
+        if (!fs.existsSync(nodeSummaryFile)) {
+            fs.writeFileSync(nodeSummaryFile, JSON.stringify(nodeSummary, null, 2));
+        } else {
+            nodeSummary = JSON.parse(fs.readFileSync(nodeSummaryFile, 'utf-8'));
+        }
+
+        // Update the node summary with new test results
         for (const suite of this.result) {
-            summary.tests = summary.tests.concat(suite.testSuite.tests);
+            nodeSummary.tests = nodeSummary.tests.concat(suite.testSuite.tests);
             for (const test of suite.testSuite.tests) {
                 if (test.status === 'skipped') {
-                    summary.skipped += 1;
+                    nodeSummary.skipped += 1;
+                }
+                if (test.status === 'failed' || test.status === 'timedOut') {
+                    nodeSummary.failed += 1;
+                }
+                if (this.separateFlakyTests && test.status === 'passed' && test.retry > 0) {
+                    nodeSummary.flaky += 1;
+                }
+                if (test.status === 'passed' && (!this.separateFlakyTests || test.retry === 0)) {
+                    nodeSummary.passed += 1;
+                }
+            }
+        }
+
+        // Write the updated summary back to the file for the current node
+        fs.writeFileSync(nodeSummaryFile, JSON.stringify(nodeSummary, null, 2));
+
+        if (this.shardIndex === 0 && this.totalShardCount > 1) {
+          await this.fetchAllArtifacts();
+        }
+
+        console.log('Contents of playwright-report for node', this.shardIndex, ':', fs.readdirSync(summariesDir));
+
+        if (this.allNodeSummaryFilesExist() && this.allBlobZipsExist() && this.shardIndex === 0) {
+            // Merge all node summaries into the final summary
+            for (let i = 0; i < this.totalShardCount; i++) {
+                const nodeSummaryFile = path.join(summariesDir, `node_summary_${i}.json`);
+                const fileToRead = nodeSummaryFile;
+
+                if (fs.existsSync(fileToRead)) {
+                    const nodeSummary = JSON.parse(fs.readFileSync(fileToRead, 'utf-8'));
+                    summary.total += nodeSummary.total;
+                    summary.passed += nodeSummary.passed;
+                    summary.failed += nodeSummary.failed;
+                    summary.flaky += nodeSummary.flaky;
+                    summary.skipped += nodeSummary.skipped;
+                    summary.failures = summary.failures.concat(nodeSummary.failures);
+                    summary.tests = summary.tests.concat(nodeSummary.tests);
                 }
             }
+            this.mergeReports();
+            return summary;
+        } else {
+            return { stopReporter: true, currentShardIndex: this.shardIndex, totalShardCount: this.totalShardCount };
         }
-        return summary;
     }
     async getFailures() {
         const failures = [];
@@ -179,5 +261,86 @@ class ResultsParser {
         }
         return [..._passes.values()];
     }*/
+    allNodeSummaryFilesExist() {
+      console.log('Checking if all node summary files exist...');
+      const summariesDir = path.join('./', 'playwright-report');
+      
+      for (let i = 0; i < this.totalShardCount; i++) {
+          const nodeSummaryFile = path.join(summariesDir, `node_summary_${i}.json`);
+          if (!fs.existsSync(nodeSummaryFile)) {
+              return false;
+          }
+      }
+      return true;
+    }
+
+    allBlobZipsExist() {
+      console.log('Checking if all blob zips exist...');
+      const summariesDir = path.join('./', 'playwright-report');
+      
+        for (let i = 0; i < this.totalShardCount; i++) {
+            const blobZipFile = path.join(summariesDir, `blob-report-node-${i}.zip`);
+            if (!fs.existsSync(blobZipFile)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    async fetchAllArtifacts() {
+        const summariesDir = path.join('./', 'playwright-report');
+        while (!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) {
+          console.log('Waiting for all blob zips to exist...');
+          if (!fs.existsSync(summariesDir)) {
+              fs.mkdirSync(summariesDir, { recursive: true });
+          }
+          for (let i = 1; i < this.totalShardCount; i++) {            
+              await this.fetchArtifact(i, `node_summary_${i}.json`, summariesDir);
+              await this.fetchArtifact(i, `blob-report-node-${i}.zip`, summariesDir);
+          }
+        }
+    }
+
+    async fetchArtifact(i, file, summariesDir) {
+        const circleciToken = process.env.safetywingtest_CIRCLECI_API_TOKEN;
+        const circleciJobId = process.env.CIRCLE_WORKFLOW_JOB_ID || '5175a4cb-273e-42fd-a5a6-40c3dc31c9de';
+        const circleciApiUrl = `https://output.circle-artifacts.com/output/job/${circleciJobId}/artifacts/${i}/html-report/${file}`;
+        const filePath = path.join(summariesDir, file);
+
+        while (true) {
+            try {
+                const response = await axios.get(circleciApiUrl, {
+                    headers: {
+                        'Circle-Token': circleciToken,
+                    },
+                    responseType: 'arraybuffer'
+                });
+
+                fs.writeFileSync(filePath, response.data);
+                console.log(`Successfully fetched file ${file} from shard ${i}`);
+                break; // Exit the loop if the file is fetched successfully
+            } catch (error) {
+                if (error.response && error.response.status === 404) {
+                    console.warn(`File ${file} not found at ${circleciApiUrl}. Retrying in 10 seconds...`);
+                    await new Promise(resolve => setTimeout(resolve, 10000)); // Wait for 10 seconds
+                } else {
+                    console.error(`Failed to fetch file ${file} from shard ${i}!`, error);
+                    break; // Exit the loop on other errors
+                }
+            }
+        }
+    }
+    mergeReports() {
+      try {
+        // Execute the command to merge reports
+        execSync(`npx playwright merge-reports --reporter html -c ./playwright-report playwright-report`);
+        //new Promise(resolve => setTimeout(resolve, 5000));
+        console.log('Reports merged successfully.');
+        console.log('Contents of playwright-report:', fs.readdirSync('./playwright-report'));
+      } catch (error) {
+          // Log a warning instead of throwing an error
+          console.warn('Warning: Failed to merge reports. This may not affect the overall process.', error.message);
+      }
+    }
 }
 exports.default = ResultsParser;

package/dist/src/SlackReporter.js

@@ -71,6 +71,11 @@ class SlackReporter {
             return;
         }
         const resultSummary = await this.resultsParser.getParsedResults();
+        // SHARDING SUPPORT - Stop slack messages for non-zero index node
+        if (process.env.CIRCLE_NODE_INDEX && process.env.CIRCLE_NODE_INDEX !== '0') {
+            this.log(`❌ Stopping reporter for non-zero index node ${process.env.CIRCLE_NODE_INDEX} of ${process.env.CIRCLE_NODE_TOTAL}`);
+            return;
+        }
         resultSummary.meta = this.meta;
         const maxRetry = Math.max(...resultSummary.tests.map((o) => o.retry));
         if (this.sendResults === 'on-failure'

package/package.json

@@ -30,7 +30,7 @@
     "lint-fix": "npx eslint . --ext .ts --fix"
   },
   "name": "playwright-slack-report-burak",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "main": "index.js",
   "types": "dist/index.d.ts",
   "repository": "git@github.com:ryanrosello-og/playwright-slack-report.git",