playwright-slack-report-burak 3.0.33 → 3.0.35

package/dist/src/ResultsParser.js

@@ -18,6 +18,11 @@ try {
     AdmZip = null;
 }
 
+const SUMMARIES_DIR = path.join('./', 'playwright-report');
+const NODE_ARTIFACTS_DIR = path.join(SUMMARIES_DIR, 'nodeArtifacts');
+const FINAL_OUTPUT_DIR = path.join(SUMMARIES_DIR, 'finalOutput');
+const TEMP_MERGE_DIR = path.join(NODE_ARTIFACTS_DIR, 'temp-merge');
+
 class ResultsParser {
     result;
     separateFlakyTests;
@@ -50,17 +55,15 @@ class ResultsParser {
         }*/
 
         // Define the directory to store node summaries
-        const summariesDir = path.join('./', 'playwright-report');
-        
-        if (!fs.existsSync(summariesDir)) {
-            fs.mkdirSync(summariesDir, { recursive: true });
+        if (!fs.existsSync(SUMMARIES_DIR)) {
+            fs.mkdirSync(SUMMARIES_DIR, { 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 nodeSummaryFile = path.join(SUMMARIES_DIR, `node_summary_${currentNodeIndex}.json`);
 
         const totalTestCasesForNode = this.result.reduce((acc, suite) => acc + suite.testSuite.tests.length, 0);
 
@@ -102,7 +105,7 @@ class ResultsParser {
         if (this.shardIndex === 1 && this.allNodeSummaryFilesExist() && this.allBlobZipsExist()) {
             // Merge all node summaries into the final summary
             for (let i = 1; i <= this.totalShardCount; i++) {
-                const nodeSummaryFile = path.join(summariesDir, `node_summary_${i}.json`);
+                const nodeSummaryFile = path.join(SUMMARIES_DIR, `node_summary_${i}.json`);
                 const fileToRead = nodeSummaryFile;
 
                 if (fs.existsSync(fileToRead)) {
@@ -314,10 +317,9 @@ class ResultsParser {
     }*/
     allNodeSummaryFilesExist() {
       console.log('Checking if all node summary files exist...');
-      const summariesDir = path.join('./', 'playwright-report');
       
       for (let i = 1; i <= this.totalShardCount; i++) {
-          const nodeSummaryFile = path.join(summariesDir, `node_summary_${i}.json`);
+          const nodeSummaryFile = path.join(SUMMARIES_DIR, `node_summary_${i}.json`);
           if (!fs.existsSync(nodeSummaryFile)) {
               return false;
           }
@@ -327,10 +329,9 @@ class ResultsParser {
 
     allBlobZipsExist() {
       console.log('Checking if all blob zips exist...');
-      const summariesDir = path.join('./', 'playwright-report');
       
         for (let i = 1; i <= this.totalShardCount; i++) {
-            const blobZipFile = path.join(summariesDir, `blob-report-node-${i}.zip`);
+            const blobZipFile = path.join(NODE_ARTIFACTS_DIR, `blob-report-node-${i}.zip`);
             if (!fs.existsSync(blobZipFile)) {
                 return false;
             }
@@ -339,21 +340,54 @@ class ResultsParser {
     }
 
     async fetchAllArtifacts() {
-        const summariesDir = path.join('./', 'playwright-report');
+        // Ensure playwright-report directory exists
+        if (!fs.existsSync(SUMMARIES_DIR)) {
+            fs.mkdirSync(SUMMARIES_DIR, { recursive: true });
+        }
+        
+        // Create nodeArtifacts directory under playwright-report
+        if (!fs.existsSync(NODE_ARTIFACTS_DIR)) {
+            fs.mkdirSync(NODE_ARTIFACTS_DIR, { recursive: true });
+        }
+        
+        // Copy artifacts from node 1 to nodeArtifacts
+        // Check multiple potential locations for node 1's blob file
+        const possibleNode1BlobSources = [
+            path.join(SUMMARIES_DIR, 'blob-report-node-1.zip'),
+            path.join('./', 'blob-report-node-1.zip'),
+            path.join(SUMMARIES_DIR, 'blob-report-1.zip'),
+        ];
+        
+        const node1BlobDest = path.join(NODE_ARTIFACTS_DIR, 'blob-report-node-1.zip');
+        let node1BlobCopied = false;
+        
+        for (const source of possibleNode1BlobSources) {
+            if (fs.existsSync(source)) {
+                fs.copyFileSync(source, node1BlobDest);
+                console.log(`Copied ${source} to nodeArtifacts`);
+                node1BlobCopied = true;
+                break;
+            }
+        }
+        
+        if (!node1BlobCopied) {
+            console.warn('Warning: blob-report-node-1.zip not found in expected locations');
+        }
+        
         while (!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) {
           console.log('Waiting for all blob zips to exist...');
-          if (!fs.existsSync(summariesDir)) {
-              fs.mkdirSync(summariesDir, { recursive: true });
+          if (!fs.existsSync(SUMMARIES_DIR)) {
+              fs.mkdirSync(SUMMARIES_DIR, { recursive: true });
           }
           for (let i = 2; i <= this.totalShardCount; i++) {            
-              await this.fetchArtifact(i, `node_summary_${i}.json`, summariesDir);
-              await this.fetchArtifact(i, `blob-report-node-${i}.zip`, summariesDir);
+              await this.fetchArtifact(i, `node_summary_${i}.json`, SUMMARIES_DIR);
+              await this.fetchArtifact(i, `blob-report-node-${i}.zip`, NODE_ARTIFACTS_DIR);
           }
         }
     }
 
-    async fetchArtifact(i, file, summariesDir) {
-        const filePath = path.join(summariesDir, file);
+    async fetchArtifact(i, file, targetDir) {
+        const filePath = path.join(targetDir, file);
         await this.fetchArtifactFromGitHubActions(i, file, filePath);
     }
 
@@ -438,10 +472,41 @@ class ResultsParser {
     mergeReports() {
       let breakMergeWaiter = false;
       try {
-        // Execute the command to merge reports
-        exec(`npx playwright merge-reports --reporter html -c ./playwright-report playwright-report`);
-        // Wait until index.html exists
-        while (!fs.existsSync(path.join('./playwright-report', 'index.html'))) {
+        // Ensure playwright-report directory exists
+        if (!fs.existsSync(SUMMARIES_DIR)) {
+            fs.mkdirSync(SUMMARIES_DIR, { recursive: true });
+        }
+        
+        // Create finalOutput directory under playwright-report
+        if (!fs.existsSync(FINAL_OUTPUT_DIR)) {
+            fs.mkdirSync(FINAL_OUTPUT_DIR, { recursive: true });
+        }
+        
+        // Copy blob files before merging (Playwright merge-reports expects blob files)
+        // We'll copy them temporarily for merging, then extract later for resource copying
+        if (!fs.existsSync(TEMP_MERGE_DIR)) {
+            fs.mkdirSync(TEMP_MERGE_DIR, { recursive: true });
+        }
+        
+        // Copy all blob zip files to temp directory for merging
+        for (let i = 1; i <= this.totalShardCount; i++) {
+            const blobZipFile = path.join(NODE_ARTIFACTS_DIR, `blob-report-node-${i}.zip`);
+            if (fs.existsSync(blobZipFile)) {
+                try {
+                    const destFile = path.join(TEMP_MERGE_DIR, `blob-report-node-${i}.zip`);
+                    fs.copyFileSync(blobZipFile, destFile);
+                    console.log(`Copied blob-report-node-${i}.zip for merging`);
+                } catch (error) {
+                    console.warn(`Failed to copy blob-report-node-${i}.zip for merging:`, error.message);
+                }
+            }
+        }
+        
+        // Execute the command to merge reports FROM TEMP_MERGE_DIR INTO finalOutput
+        exec(`npx playwright merge-reports --reporter html ${TEMP_MERGE_DIR} ${FINAL_OUTPUT_DIR}`);
+        
+        // Wait until index.html exists in finalOutput
+        while (!fs.existsSync(path.join(FINAL_OUTPUT_DIR, 'index.html'))) {
           console.log('Waiting 2 seconds for merged html report to be generated...');
           const currentTime = new Date().getTime();
           breakMergeWaiter = false;
@@ -452,10 +517,62 @@ class ResultsParser {
           }
         }
         console.log('Reports merged successfully.');
+        
+        // Once merge is complete, unzip all blobs in nodeArtifacts into separate folders
+        this.unzipBlobsAndCopyResources(NODE_ARTIFACTS_DIR, FINAL_OUTPUT_DIR);
       } 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);
       }
     }
+    
+    unzipBlobsAndCopyResources(nodeArtifactsDir, finalOutputDir) {
+        if (!AdmZip) {
+            console.error('adm-zip is required for blob extraction. Please install it: npm install adm-zip');
+            return;
+        }
+        
+        // Unzip all blob files in nodeArtifacts into separate folders
+        for (let i = 1; i <= this.totalShardCount; i++) {
+            const blobZipFile = path.join(nodeArtifactsDir, `blob-report-node-${i}.zip`);
+            if (fs.existsSync(blobZipFile)) {
+                const extractDir = path.join(nodeArtifactsDir, `node-${i}`);
+                if (!fs.existsSync(extractDir)) {
+                    fs.mkdirSync(extractDir, { recursive: true });
+                }
+                
+                try {
+                    const zip = new AdmZip(blobZipFile);
+                    zip.extractAllTo(extractDir, true);
+                    console.log(`Extracted blob-report-node-${i}.zip to ${extractDir}`);
+                    
+                    // Check if this folder contains a "resources" folder with zip files
+                    const resourcesDir = path.join(extractDir, 'resources');
+                    if (fs.existsSync(resourcesDir) && fs.statSync(resourcesDir).isDirectory()) {
+                        const files = fs.readdirSync(resourcesDir);
+                        const zipFiles = files.filter(file => file.endsWith('.zip'));
+                        
+                        if (zipFiles.length > 0) {
+                            // Copy the resources folder to finalOutput
+                            const finalResourcesDir = path.join(finalOutputDir, 'resources');
+                            if (!fs.existsSync(finalResourcesDir)) {
+                                fs.mkdirSync(finalResourcesDir, { recursive: true });
+                            }
+                            
+                            // Copy each zip file to finalOutput/resources
+                            for (const zipFile of zipFiles) {
+                                const sourceFile = path.join(resourcesDir, zipFile);
+                                const destFile = path.join(finalResourcesDir, zipFile);
+                                fs.copyFileSync(sourceFile, destFile);
+                                console.log(`Copied ${zipFile} to finalOutput/resources`);
+                            }
+                        }
+                    }
+                } catch (error) {
+                    console.warn(`Failed to extract or process blob-report-node-${i}.zip:`, error.message);
+                }
+            }
+        }
+    }
 }
 exports.default = ResultsParser;

package/package.json

@@ -32,7 +32,7 @@
     "lint-fix": "npx eslint . --ext .ts --fix"
   },
   "name": "playwright-slack-report-burak",
-  "version": "3.0.33",
+  "version": "3.0.35",
   "main": "index.js",
   "types": "dist/index.d.ts",
   "author": "Burak B. <burak.boluk@hotmail.com>",