playwright-slack-report-burak 2.4.3 → 3.0.0

package/dist/src/LayoutGenerator.js

@@ -8,6 +8,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
  exports.generateAllRunSuites = 
  void 0;
 
+// Helper function to get build URL and CI platform name
+const getBuildInfo = () => {
+    if (process.env.GITHUB_ACTIONS || process.env.GITHUB_TOKEN) {
+        const repo = process.env.GITHUB_REPOSITORY;
+        const runId = process.env.GITHUB_RUN_ID;
+        const serverUrl = process.env.GITHUB_SERVER_URL || 'https://github.com';
+        const buildUrl = `${serverUrl}/${repo}/actions/runs/${runId}`;
+        return {
+            url: buildUrl,
+            platform: 'GitHub Actions'
+        };
+    }
+    return {
+        url: '#',
+        platform: 'CI'
+    };
+};
+
 const generateAllRunSuites = async (summaryResults) => {
     const suitesResults = [];
     const allSuites = [];
@@ -255,12 +273,13 @@ const generateProblemCaseList = async (summaryResults) => {
         let text = `${title}${list.map((value, index) => `*${index + 1}.* ${value}`).join('\n')}`;
         if (text.length > 2700) {
             text = text.substring(0, 2700) + '...';
+            const buildInfo = getBuildInfo();
             array.push({
                 type: 'section',
                 text: {
                     type: 'mrkdwn',
-                    text: text + '\n\n\n' + '⚠️ *There are too many items to display here. ' +
-                          'You can view more on CircleCI* ⚠️',
+                    text: text + '\n\n\n' + `⚠️ *There are too many items to display here. ` +
+                          `You can view more on ${buildInfo.platform}* ⚠️`,
                 },
             },
             {
@@ -271,7 +290,7 @@ const generateProblemCaseList = async (summaryResults) => {
                         type: 'plain_text',
                         text: 'Go to Build Details'
                     },
-                    url: process.env.CIRCLE_BUILD_URL
+                    url: buildInfo.url
                 }]
             });
         } else {
@@ -356,12 +375,13 @@ const generateFailuresReasons = async (summaryResults) => {
                 },
             });
             if (i === summaryResults.failures.length-1) {
+                const buildInfo = getBuildInfo();
                 failsList.push({
                     type: 'section',
                     text: {
                         type: 'mrkdwn',
                         text: '⚠️ *There are too many failures to display in full detail. '+
-                            'You can view more on CircleCI* ⚠️',
+                            `You can view more on ${buildInfo.platform}* ⚠️`,
                     },
                 },
                 {
@@ -373,7 +393,7 @@ const generateFailuresReasons = async (summaryResults) => {
                             type: 'plain_text',
                             text: 'Go to Build Details'
                         },
-                        url: process.env.CIRCLE_BUILD_URL
+                        url: buildInfo.url
                     }
                 ]
                 });
@@ -391,12 +411,13 @@ const generateFailuresReasons = async (summaryResults) => {
                 },
             });
             if (i > 23) {
+                const buildInfo = getBuildInfo();
                 failsList.push({
                     type: 'section',
                     text: {
                         type: 'mrkdwn',
                         text: '⚠️ *There are too many failures to display here '+
-                            'You can view more on CircleCI* ⚠️',
+                            `You can view more on ${buildInfo.platform}* ⚠️`,
                     },
                 },
                 {
@@ -407,7 +428,7 @@ const generateFailuresReasons = async (summaryResults) => {
                             type: 'plain_text',
                             text: 'Go to Build Details'
                         },
-                        url: process.env.CIRCLE_BUILD_URL
+                        url: buildInfo.url
                     }]
                 });
                 break;

package/dist/src/ResultsParser.js

@@ -10,12 +10,27 @@ const fs = require('fs');
 const path = require('path');
 const axios = require('axios');
 const { exec } = require('child_process');
+let AdmZip;
+try {
+    AdmZip = require('adm-zip');
+} catch (e) {
+    // adm-zip is required for GitHub Actions artifact extraction
+    AdmZip = null;
+}
 
 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;
+    // Handle both 0-based and 1-based shard indexing
+    // If MATRIX_SHARD is not set, try to infer from workflow (1-based) or default to 0
+    totalShardCount = process.env.MATRIX_COUNT ? parseInt(process.env.MATRIX_COUNT, 10) : 1;
+    shardIndex = process.env.MATRIX_SHARD !== undefined 
+        ? parseInt(process.env.MATRIX_SHARD, 10) 
+        : (process.env.MATRIX_INDEX !== undefined ? parseInt(process.env.MATRIX_INDEX, 10) : 0);
+    
+    // Determine if we're using 1-based indexing (workflow-style) or 0-based
+    // This is detected by checking if artifacts exist with 1-based naming
+    isOneBasedIndexing = false;
     constructor(options = { separateFlakyTests: false }) {
         this.result = [];
         this.separateFlakyTests = options.separateFlakyTests;
@@ -77,7 +92,7 @@ class ResultsParser {
 
         if (this.shardIndex === 0 && this.totalShardCount > 1) {
           if (process.env.CI) {
-            console.log('Fetching all artifacts...');
+            console.log('Fetching all artifacts from GitHub Actions...');
             await this.fetchAllArtifacts();
           } else {
             while (!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) {
@@ -333,6 +348,10 @@ class ResultsParser {
           if (!fs.existsSync(summariesDir)) {
               fs.mkdirSync(summariesDir, { recursive: true });
           }
+          // Fetch artifacts for shards 1 to totalShardCount-1 (if using 1-based) or 0 to totalShardCount-1 (if 0-based)
+          // Since we're shard 0, we need to fetch from other shards
+          // The workflow uses 1-based shards (1, 2, 3...), but we need to map them to 0-based internally (0, 1, 2...)
+          // So shard 1 in workflow = shard 0 internally, shard 2 = shard 1, etc.
           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);
@@ -341,30 +360,216 @@ class ResultsParser {
     }
 
     async fetchArtifact(i, file, summariesDir) {
-        const circleciToken = process.env.safetywingtest_CIRCLECI_API_TOKEN;
-        const circleciJobId = process.env.CIRCLE_WORKFLOW_JOB_ID || '8133c154-ceb3-466c-b4e1-d3d8768b60fa';
-        const circleciApiUrl = `https://output.circle-artifacts.com/output/job/${circleciJobId}/artifacts/${i}/html-report/${file}`;
         const filePath = path.join(summariesDir, file);
+        await this.fetchArtifactFromGitHubActions(i, file, filePath);
+    }
+
+    // Helper to extract shard index from artifact name
+    extractShardIndexFromArtifactName(artifactName, i) {
+        // Try to extract number from artifact name (e.g., html-report-1 -> 1)
+        const match = artifactName.match(/-(\d+)$/);
+        if (match) {
+            const artifactShard = parseInt(match[1], 10);
+            // If artifact uses 1-based indexing, convert to 0-based for internal use
+            // html-report-1 (workflow) -> shard 0 (internal)
+            // html-report-2 (workflow) -> shard 1 (internal)
+            return artifactShard - 1;
+        }
+        // Fallback to the provided index
+        return i;
+    }
+
+    async fetchArtifactFromGitHubActions(i, file, filePath) {
+        const githubToken = process.env.GITHUB_TOKEN;
+        const repo = process.env.GITHUB_REPOSITORY;
+        const runId = process.env.GITHUB_RUN_ID;
+        
+        if (!githubToken || !repo) {
+            console.error('GitHub Actions: Missing GITHUB_TOKEN or GITHUB_REPOSITORY');
+            return;
+        }
 
+        // GitHub Actions artifact API endpoint
+        const githubApiUrl = `https://api.github.com/repos/${repo}/actions/artifacts`;
+        
+        // Try multiple artifact naming patterns:
+        // 1. html-report-{i} (1-based workflow style)
+        // 2. blob-report-node-{i} (direct blob reports)
+        // 3. test-results-{i} (alternative naming)
+        // Note: i is 0-based internally, so for 1-based workflows we need i+1
+        const artifactNamePatterns = [
+            `html-report-${i + 1}`,  // 1-based workflow style (most common)
+            `blob-report-node-${i}`,  // 0-based direct blob
+            `blob-report-node-${i + 1}`, // 1-based direct blob
+            `html-report-${i}`,       // 0-based html-report
+            `test-results-${i + 1}`,  // Alternative naming
+        ];
+        
         while (true) {
             try {
-                const response = await axios.get(circleciApiUrl, {
+                // List all artifacts to find the one we need
+                const listResponse = await axios.get(githubApiUrl, {
                     headers: {
-                        'Circle-Token': circleciToken,
+                        'Authorization': `token ${githubToken}`,
+                        'Accept': 'application/vnd.github.v3+json'
                     },
-                    responseType: 'arraybuffer'
+                    params: {
+                        per_page: 100
+                    }
                 });
-
-                fs.writeFileSync(filePath, response.data);
-                console.log(`Successfully fetched file ${file} from shard ${i}`);
-                break; // Exit the loop if the file is fetched successfully
+                
+                // Try to find artifact matching any of our patterns
+                let artifact = null;
+                for (const pattern of artifactNamePatterns) {
+                    artifact = listResponse.data.artifacts.find(
+                        (a) => a.name === pattern || 
+                               a.name.includes(`shard-${i}`) || 
+                               a.name.includes(`shard-${i + 1}`) ||
+                               a.name.includes(`node-${i}`) ||
+                               a.name.includes(`node-${i + 1}`)
+                    );
+                    if (artifact) {
+                        console.log(`Found artifact: ${artifact.name} (matched pattern: ${pattern})`);
+                        break;
+                    }
+                }
+                
+                if (artifact && artifact.archive_download_url) {
+                    // Download the artifact ZIP
+                    const downloadResponse = await axios.get(artifact.archive_download_url, {
+                        headers: {
+                            'Authorization': `token ${githubToken}`,
+                            'Accept': 'application/vnd.github.v3+json'
+                        },
+                        responseType: 'arraybuffer'
+                    });
+                    
+                    if (!AdmZip) {
+                        console.error('adm-zip is required for GitHub Actions artifact extraction. Please install it: npm install adm-zip');
+                        return;
+                    }
+                    
+                    // Extract ZIP and find the specific file
+                    const zip = new AdmZip(downloadResponse.data);
+                    
+                    // Try direct file match first
+                    let zipEntry = zip.getEntry(file);
+                    
+                    // If not found, try common path variations
+                    if (!zipEntry) {
+                        const possiblePaths = [
+                            file,
+                            `playwright-report/${file}`,
+                            `playwright-report/${file}`,
+                            `html-report-${i + 1}/${file}`,
+                            `html-report-${i}/${file}`,
+                        ];
+                        for (const possiblePath of possiblePaths) {
+                            zipEntry = zip.getEntry(possiblePath);
+                            if (zipEntry) break;
+                        }
+                    }
+                    
+                    if (zipEntry) {
+                        fs.writeFileSync(filePath, zipEntry.getData());
+                        console.log(`Successfully fetched file ${file} from GitHub Actions shard ${i} (artifact: ${artifact.name})`);
+                        break;
+                    } else {
+                        // If file not found in ZIP root, extract and search recursively
+                        const extractPath = path.join(path.dirname(filePath), `temp-artifact-${i}`);
+                        zip.extractAllTo(extractPath, true);
+                        
+                        // Extract shard index from artifact name to handle files named with index 0
+                        const artifactShardIndex = this.extractShardIndexFromArtifactName(artifact.name, i);
+                        
+                        // Look for the file recursively, also try with shard index from artifact name
+                        const searchInDir = (dir, targetFile, alternateTargetFile = null) => {
+                            const entries = fs.readdirSync(dir, { withFileTypes: true });
+                            for (const entry of entries) {
+                                const fullPath = path.join(dir, entry.name);
+                                if (entry.isDirectory()) {
+                                    const found = searchInDir(fullPath, targetFile, alternateTargetFile);
+                                    if (found) return found;
+                                } else {
+                                    // Check exact match
+                                    if (entry.name === targetFile) {
+                                        return fullPath;
+                                    }
+                                    // Check alternate filename (e.g., node_summary_0.json when we need node_summary_1.json)
+                                    if (alternateTargetFile && entry.name === alternateTargetFile) {
+                                        return fullPath;
+                                    }
+                                    // Check if ends with target file
+                                    if (entry.name.endsWith(targetFile)) {
+                                        return fullPath;
+                                    }
+                                }
+                            }
+                            return null;
+                        };
+                        
+                        // Try to find the file, also try with shard index from artifact
+                        let foundPath = searchInDir(extractPath, file);
+                        
+                        // If file uses index 0 pattern (like node_summary_0.json or blob-report-node-0.zip)
+                        // but we need it for a different shard, try to find any matching pattern
+                        if (!foundPath && (file.includes('_0') || file.includes('-node-0'))) {
+                            // Recursively search for any node_summary or blob-report file
+                            const findAllFiles = (dir, pattern) => {
+                                const results = [];
+                                try {
+                                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                                    for (const entry of entries) {
+                                        const fullPath = path.join(dir, entry.name);
+                                        if (entry.isDirectory()) {
+                                            results.push(...findAllFiles(fullPath, pattern));
+                                        } else if (entry.name.includes(pattern)) {
+                                            results.push(fullPath);
+                                        }
+                                    }
+                                } catch (e) {
+                                    // Ignore errors
+                                }
+                                return results;
+                            };
+                            
+                            // Find any node_summary or blob-report files
+                            const matchingFiles = findAllFiles(extractPath, file.includes('node_summary') ? 'node_summary' : 'blob-report');
+                            
+                            if (matchingFiles.length > 0) {
+                                foundPath = matchingFiles[0];
+                                // Copy to the expected path with correct shard index
+                                fs.copyFileSync(foundPath, filePath);
+                                console.log(`Found and copied file ${path.basename(foundPath)} -> ${file} from artifact ${artifact.name}`);
+                                // Clean up temp directory
+                                fs.rmSync(extractPath, { recursive: true, force: true });
+                                break;
+                            }
+                        }
+                        
+                        if (foundPath) {
+                            fs.copyFileSync(foundPath, filePath);
+                            console.log(`Successfully fetched file ${file} from GitHub Actions shard ${i} (artifact: ${artifact.name})`);
+                            // Clean up temp directory
+                            fs.rmSync(extractPath, { recursive: true, force: true });
+                            break;
+                        } else {
+                            console.warn(`File ${file} not found in artifact ${artifact.name}. Retrying in 10 seconds...`);
+                            fs.rmSync(extractPath, { recursive: true, force: true });
+                            await new Promise(resolve => setTimeout(resolve, 10000));
+                        }
+                    }
+                } else {
+                    console.warn(`Artifact not found (tried: ${artifactNamePatterns.join(', ')}). Retrying in 10 seconds...`);
+                    await new Promise(resolve => setTimeout(resolve, 10000));
+                }
             } 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
+                    console.warn(`Artifact not found. Retrying in 10 seconds...`);
+                    await new Promise(resolve => setTimeout(resolve, 10000));
                 } else {
-                    console.error(`Failed to fetch file ${file} from shard ${i}!`, error);
-                    break; // Exit the loop on other errors
+                    console.error(`Failed to fetch artifact from GitHub Actions shard ${i}!`, error.message);
+                    await new Promise(resolve => setTimeout(resolve, 10000));
                 }
             }
         }

package/dist/src/SlackReporter.js

@@ -71,9 +71,18 @@ class SlackReporter {
             return;
         }
         const resultSummary = await this.resultsParser.getParsedResults();
-        // SHARDING SUPPORT - Stop slack messages for non-zero index node(s)
-        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}`);
+        // SHARDING SUPPORT - Stop slack messages for non-zero index shard(s)
+        // Support both explicit MATRIX_SHARD/MATRIX_INDEX and workflow-style 1-based indexing
+        // If MATRIX_SHARD is not set, shard 0 will still send reports (handles single shard case)
+        const currentShardIndex = process.env.MATRIX_SHARD !== undefined 
+            ? process.env.MATRIX_SHARD 
+            : (process.env.MATRIX_INDEX !== undefined ? process.env.MATRIX_INDEX : undefined);
+        
+        // Only skip if explicitly set and not 0 (or '0')
+        // This allows shard 0 to send reports even when MATRIX_SHARD is not set
+        if (currentShardIndex !== undefined && currentShardIndex !== '0' && currentShardIndex !== 0) {
+            const totalShards = process.env.MATRIX_COUNT || '1';
+            this.log(`❌ Stopping reporter for non-zero index shard ${currentShardIndex} of ${totalShards}`);
             return;
         }
         resultSummary.meta = this.meta;

package/package.json

@@ -2,7 +2,8 @@
   "dependencies": {
     "@slack/web-api": "^6.8.1",
     "@slack/webhook": "^6.1.0",
-    "https-proxy-agent": "^7.0.1"
+    "https-proxy-agent": "^7.0.1",
+    "adm-zip": "^0.5.10"
   },
   "devDependencies": {
     "@playwright/test": "^1.23.3",
@@ -30,7 +31,7 @@
     "lint-fix": "npx eslint . --ext .ts --fix"
   },
   "name": "playwright-slack-report-burak",
-  "version": "2.4.3",
+  "version": "3.0.0",
   "main": "index.js",
   "types": "dist/index.d.ts",
   "author": "Burak B. <burak.boluk@hotmail.com>",