playwright-slack-report-burak 3.0.4 → 3.0.6

package/dist/src/ResultsParser.js

@@ -34,6 +34,13 @@ class ResultsParser {
     constructor(options = { separateFlakyTests: false }) {
         this.result = [];
         this.separateFlakyTests = options.separateFlakyTests;
+        // Log shard detection in ResultsParser
+        console.log('🔍 [ResultsParser] Initialized with shard detection:');
+        console.log(`🔍   MATRIX_SHARD env: ${process.env.MATRIX_SHARD !== undefined ? `"${process.env.MATRIX_SHARD}"` : 'undefined'}`);
+        console.log(`🔍   MATRIX_INDEX env: ${process.env.MATRIX_INDEX !== undefined ? `"${process.env.MATRIX_INDEX}"` : 'undefined'}`);
+        console.log(`🔍   MATRIX_COUNT env: ${process.env.MATRIX_COUNT !== undefined ? `"${process.env.MATRIX_COUNT}"` : 'undefined'}`);
+        console.log(`🔍   Calculated shardIndex: ${this.shardIndex}`);
+        console.log(`🔍   Calculated totalShardCount: ${this.totalShardCount}`);
     }
     async getParsedResults() {
       const summary = {
@@ -90,19 +97,27 @@ class ResultsParser {
         // Create the file
         fs.writeFileSync(nodeSummaryFile, JSON.stringify(nodeSummary, null, 2));
 
+        console.log(`🔍 [ResultsParser] Current shard: ${this.shardIndex}, Total shards: ${this.totalShardCount}`);
+        console.log(`🔍 [ResultsParser] Created node summary file: ${nodeSummaryFile}`);
+
         if (this.shardIndex === 0 && this.totalShardCount > 1) {
+          console.log(`🔍 [ResultsParser] Shard 0 detected with ${this.totalShardCount} total shards - will fetch artifacts from other shards`);
           if (process.env.CI) {
-            console.log('Fetching all artifacts from GitHub Actions...');
+            console.log('🔍 [ResultsParser] CI environment detected - fetching all artifacts from GitHub Actions...');
             await this.fetchAllArtifacts();
           } else {
+            console.log('🔍 [ResultsParser] Local environment - waiting for artifacts to appear...');
             while (!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) {
-              console.log('Waiting for all both to exist...');
+              console.log('🔍 [ResultsParser] Waiting for all artifacts to exist...');
               await new Promise(resolve => setTimeout(resolve, 1000)); // Wait for 1 second
             }
           }
+        } else {
+          console.log(`🔍 [ResultsParser] Not shard 0 (current: ${this.shardIndex}) or single shard (total: ${this.totalShardCount}) - skipping artifact fetch`);
         }
 
         if (this.shardIndex === 0 && this.allNodeSummaryFilesExist() && this.allBlobZipsExist()) {
+            console.log(`🔍 [ResultsParser] Shard 0: All artifacts available, merging results from all shards...`);
             // 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`);

package/dist/src/SlackReporter.js

@@ -6,6 +6,13 @@ const webhook_1 = require("@slack/webhook");
 const ResultsParser_1 = require("./ResultsParser");
 const SlackClient_1 = require("./SlackClient");
 const SlackWebhookClient_1 = require("./SlackWebhookClient");
+let axios;
+try {
+    axios = require('axios');
+} catch (e) {
+    // axios optional for GitHub Actions API detection
+    axios = null;
+}
 class SlackReporter {
     customLayout;
     customLayoutAsync;
@@ -64,6 +71,112 @@ class SlackReporter {
     onTestEnd(test, result) {
         this.resultsParser.addTestResult(test.parent.title, test, this.browsers);
     }
+    /**
+     * Detect GitHub Actions shard information using GitHub API
+     * Returns { shardIndex: number, totalShards: number } or null if detection fails
+     */
+    async detectGitHubActionsShardInfo() {
+        // Check if we're in GitHub Actions
+        if (!process.env.GITHUB_ACTIONS || process.env.GITHUB_ACTIONS !== 'true') {
+            return null;
+        }
+        const githubToken = process.env.GITHUB_TOKEN;
+        const repo = process.env.GITHUB_REPOSITORY;
+        const runId = process.env.GITHUB_RUN_ID;
+        const currentJobId = process.env.GITHUB_JOB;
+        if (!githubToken || !repo || !runId) {
+            this.log(`🔍 [GitHub Actions Detection] Missing required env vars: GITHUB_TOKEN=${!!githubToken}, GITHUB_REPOSITORY=${!!repo}, GITHUB_RUN_ID=${!!runId}`);
+            return null;
+        }
+        if (!axios) {
+            this.log(`🔍 [GitHub Actions Detection] axios not available, skipping API detection`);
+            return null;
+        }
+        try {
+            // Get workflow run details
+            const apiUrl = `https://api.github.com/repos/${repo}/actions/runs/${runId}/jobs`;
+            const response = await axios.get(apiUrl, {
+                headers: {
+                    'Authorization': `token ${githubToken}`,
+                    'Accept': 'application/vnd.github.v3+json'
+                },
+                params: {
+                    per_page: 100
+                }
+            });
+            const jobs = response.data.jobs || [];
+            if (jobs.length === 0) {
+                this.log(`🔍 [GitHub Actions Detection] No jobs found in workflow run`);
+                return null;
+            }
+            // Filter jobs that are part of the same workflow run and have the same name (matrix jobs)
+            // Group by job name to find matrix jobs
+            const jobGroups = {};
+            for (const job of jobs) {
+                const jobName = job.name || '';
+                if (!jobGroups[jobName]) {
+                    jobGroups[jobName] = [];
+                }
+                jobGroups[jobName].push(job);
+            }
+            // Find the job group that contains the current job
+            let currentJob = null;
+            let jobGroup = null;
+            for (const [jobName, jobsInGroup] of Object.entries(jobGroups)) {
+                currentJob = jobsInGroup.find(j => j.id.toString() === currentJobId || j.name === currentJobId);
+                if (currentJob) {
+                    jobGroup = jobsInGroup;
+                    break;
+                }
+            }
+            // If we can't find current job by ID, try to match by name from GITHUB_JOB
+            if (!currentJob && currentJobId) {
+                for (const [jobName, jobsInGroup] of Object.entries(jobGroups)) {
+                    if (jobName.includes(currentJobId) || currentJobId.includes(jobName)) {
+                        jobGroup = jobsInGroup;
+                        // Try to find the job by looking at run_attempt or other identifiers
+                        currentJob = jobsInGroup[0];
+                        break;
+                    }
+                }
+            }
+            // If still no match, use all jobs (might be a single job or we can't determine)
+            if (!jobGroup || jobGroup.length === 0) {
+                jobGroup = jobs;
+                currentJob = jobs[0];
+            }
+            // Sort jobs by name or ID to get consistent ordering
+            jobGroup.sort((a, b) => {
+                if (a.name && b.name) {
+                    return a.name.localeCompare(b.name);
+                }
+                return a.id - b.id;
+            });
+            // Find index of current job
+            const currentJobIndex = jobGroup.findIndex(j => 
+                j.id === currentJob?.id || 
+                j.name === currentJob?.name ||
+                (currentJobId && (j.name === currentJobId || j.name?.includes(currentJobId)))
+            );
+            const shardIndex = currentJobIndex >= 0 ? currentJobIndex : 0;
+            const totalShards = jobGroup.length;
+            this.log(`🔍 [GitHub Actions Detection] Detected via API:`);
+            this.log(`🔍   Total jobs in group: ${totalShards}`);
+            this.log(`🔍   Current job index: ${shardIndex}`);
+            this.log(`🔍   Current job ID: ${currentJobId}`);
+            this.log(`🔍   Current job name: ${currentJob?.name || 'unknown'}`);
+            return {
+                shardIndex,
+                totalShards
+            };
+        } catch (error) {
+            this.log(`🔍 [GitHub Actions Detection] Failed to detect via API: ${error.message}`);
+            if (error.response) {
+                this.log(`🔍   Status: ${error.response.status}, Data: ${JSON.stringify(error.response.data)}`);
+            }
+            return null;
+        }
+    }
     async onEnd() {
         const { okToProceed, message } = this.preChecks();
         if (!okToProceed) {
@@ -73,19 +186,107 @@ class SlackReporter {
         // SHARDING SUPPORT - Stop slack messages for non-zero index shard(s)
         // Only shard 0 (0-based) should post when aggregating results from multiple shards
         
-        // Detect shard index from multiple sources (GitHub Actions compatible)
-        let currentShardIndex = process.env.strategy.job-total !== undefined 
-            ? process.env.strategy.job-total 
-            : undefined;
+        this.log('🔍 [Shard Detection] Starting shard detection logic...');
+        
+        // Log all relevant environment variables
+        this.log(`🔍 [Shard Detection] Environment variables:`);
+        this.log(`🔍   CI: ${process.env.CI !== undefined ? `"${process.env.CI}"` : 'undefined'}`);
+        this.log(`🔍   GITHUB_ACTIONS: ${process.env.GITHUB_ACTIONS !== undefined ? `"${process.env.GITHUB_ACTIONS}"` : 'undefined'}`);
+        this.log(`🔍   GITHUB_JOB: ${process.env.GITHUB_JOB !== undefined ? `"${process.env.GITHUB_JOB}"` : 'undefined'}`);
+        this.log(`🔍   MATRIX_SHARD: ${process.env.MATRIX_SHARD !== undefined ? `"${process.env.MATRIX_SHARD}"` : 'undefined'}`);
+        this.log(`🔍   MATRIX_INDEX: ${process.env.MATRIX_INDEX !== undefined ? `"${process.env.MATRIX_INDEX}"` : 'undefined'}`);
+        this.log(`🔍   MATRIX_COUNT: ${process.env.MATRIX_COUNT !== undefined ? `"${process.env.MATRIX_COUNT}"` : 'undefined'}`);
+        
+        // Step 1: Try GitHub Actions API detection (most robust for GitHub Actions)
+        let githubApiShardInfo = null;
+        if (process.env.GITHUB_ACTIONS === 'true') {
+            this.log(`🔍 [Shard Detection] Attempting GitHub Actions API detection...`);
+            githubApiShardInfo = await this.detectGitHubActionsShardInfo();
+        }
+        
+        // Step 2: Detect shard index from environment variables (priority)
+        let currentShardIndex = process.env.MATRIX_SHARD !== undefined 
+            ? process.env.MATRIX_SHARD 
+            : (process.env.MATRIX_INDEX !== undefined ? process.env.MATRIX_INDEX : undefined);
+        
+        // Step 3: Use GitHub API detection if env vars not set
+        if (currentShardIndex === undefined && githubApiShardInfo) {
+            currentShardIndex = githubApiShardInfo.shardIndex.toString();
+            this.log(`🔍 [Shard Detection] Using GitHub API detected shardIndex: "${currentShardIndex}"`);
+        }
+        
+        this.log(`🔍 [Shard Detection] Initial currentShardIndex: ${currentShardIndex !== undefined ? `"${currentShardIndex}"` : 'undefined'}`);
+        
+        // Step 4: Get shard count from multiple sources (priority order)
+        let totalShards;
+        if (process.env.MATRIX_COUNT !== undefined) {
+            totalShards = parseInt(process.env.MATRIX_COUNT, 10);
+            this.log(`🔍 [Shard Detection] Using MATRIX_COUNT env var: ${totalShards}`);
+        } else if (githubApiShardInfo && githubApiShardInfo.totalShards > 1) {
+            totalShards = githubApiShardInfo.totalShards;
+            this.log(`🔍 [Shard Detection] Using GitHub API detected totalShards: ${totalShards}`);
+        } else {
+            // Fallback to ResultsParser
+            const parserTotalShards = this.resultsParser.totalShardCount;
+            totalShards = parserTotalShards;
+            this.log(`🔍 [Shard Detection] Using ResultsParser totalShards: ${totalShards}`);
+        }
+        
+        // Get shard info from ResultsParser for fallback
+        const parserShardIndex = this.resultsParser.shardIndex;
+        const parserTotalShards = this.resultsParser.totalShardCount;
+        
+        this.log(`🔍 [Shard Detection] ResultsParser values:`);
+        this.log(`🔍   parserShardIndex: ${parserShardIndex !== undefined ? parserShardIndex : 'undefined'}`);
+        this.log(`🔍   parserTotalShards: ${parserTotalShards !== undefined ? parserTotalShards : 'undefined'}`);
+        
+        this.log(`🔍 [Shard Detection] Calculated totalShards: ${totalShards}`);
+        
+        // If we still don't have shard index, try to infer from parser or GitHub API
+        if (currentShardIndex === undefined) {
+            if (githubApiShardInfo && githubApiShardInfo.shardIndex !== undefined) {
+                currentShardIndex = githubApiShardInfo.shardIndex.toString();
+                this.log(`🔍 [Shard Detection] Using GitHub API shardIndex as fallback: "${currentShardIndex}"`);
+            } else if (parserShardIndex !== undefined) {
+                currentShardIndex = parserShardIndex.toString();
+                this.log(`🔍 [Shard Detection] Using parserShardIndex as fallback: "${currentShardIndex}"`);
+            }
+        }
+        
+        // CRITICAL: In CI (especially GitHub Actions), if we can't detect shard info, block posting
+        // This prevents duplicate messages when running with multiple shards
+        if (process.env.CI && currentShardIndex === undefined) {
+            if (process.env.GITHUB_ACTIONS === 'true') {
+                this.log(`❌ [Shard Detection] BLOCKING: GitHub Actions detected but shard index cannot be determined.`);
+                this.log(`❌   Attempted: GitHub API detection ${githubApiShardInfo ? 'succeeded' : 'failed'}, env vars not set`);
+                this.log(`❌   This prevents duplicate messages when running with multiple shards.`);
+            } else {
+                this.log(`❌ [Shard Detection] BLOCKING: CI environment detected but shard info not set.`);
+                this.log(`❌   MATRIX_COUNT: undefined, MATRIX_SHARD: undefined`);
+                this.log(`❌   This prevents duplicate messages when running with multiple shards.`);
+            }
+            this.log(`❌ Skipping Slack report to prevent duplicate messages from all shards.`);
+            this.log(`💡 Fix: Add these env vars to your workflow:`);
+            this.log(`💡   env:`);
+            this.log(`💡     MATRIX_SHARD: $\{\{ strategy.job-index \}\}  # 0-based (only shard 0 posts)`);
+            this.log(`💡     MATRIX_COUNT: $\{\{ strategy.job-total \}\}`);
+            this.log(`💡   OR ensure GITHUB_TOKEN has workflow permissions for API detection`);
+            return;
+        }
         
         // Convert to number for comparison (default to 0 if undefined)
         const shardIndexNum = currentShardIndex !== undefined ? parseInt(currentShardIndex, 10) : 0;
         
+        this.log(`🔍 [Shard Detection] Final values:`);
+        this.log(`🔍   currentShardIndex (string): ${currentShardIndex !== undefined ? `"${currentShardIndex}"` : 'undefined'}`);
+        this.log(`🔍   shardIndexNum (number): ${shardIndexNum}`);
+        this.log(`🔍   totalShards: ${totalShards}`);
+        
         // CRITICAL: For GitHub Actions with multiple shards, only shard 0 should post
         // If we're in CI with multiple shards and don't know which shard we are, block all posts
         // This prevents duplicate messages when MATRIX_SHARD/MATRIX_INDEX is not set
         if (process.env.CI && totalShards > 1 && currentShardIndex === undefined) {
-            this.log(`❌ GitHub Actions detected with ${totalShards} shards but shard index not set (MATRIX_SHARD/MATRIX_INDEX missing).`);
+            this.log(`❌ [Shard Detection] BLOCKING: CI environment detected with ${totalShards} shards but shard index not set (MATRIX_SHARD/MATRIX_INDEX missing).`);
             this.log(`❌ Skipping Slack report to prevent duplicate messages from all shards.`);
             this.log(`💡 Fix: Add these env vars to your workflow:`);
             this.log(`💡   env:`);
@@ -97,6 +298,7 @@ class SlackReporter {
         // Only allow shard 0 (0-based) to post when there are multiple shards
         // This ensures only one shard posts the aggregated report
         if (totalShards > 1 && shardIndexNum !== 0) {
+            this.log(`❌ [Shard Detection] BLOCKING: Non-zero shard detected (shard ${currentShardIndex} of ${totalShards})`);
             this.log(`❌ Stopping reporter for non-zero index shard ${currentShardIndex} of ${totalShards}`);
             this.log(`ℹ️ Only shard 0 will post the aggregated report.`);
             return;
@@ -104,9 +306,9 @@ class SlackReporter {
         
         // Single shard - always allow posting
         if (totalShards === 1) {
-            this.log(`ℹ️ Single shard detected. Posting Slack report.`);
+            this.log(`✅ [Shard Detection] ALLOWING: Single shard detected. Posting Slack report.`);
         } else {
-            this.log(`ℹ️ Multiple shards detected (${totalShards}). Shard ${currentShardIndex} will post aggregated report.`);
+            this.log(`✅ [Shard Detection] ALLOWING: Multiple shards detected (${totalShards}). Shard ${currentShardIndex} (index ${shardIndexNum}) will post aggregated report.`);
         }
         
         const resultSummary = await this.resultsParser.getParsedResults();

package/package.json

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