@arghajit/dummy 0.1.2-beta-4 → 0.1.2

package/dist/reporter/playwright-pulse-reporter.d.ts

@@ -20,14 +20,8 @@ export declare class PlaywrightPulseReporter implements Reporter {
     private getBrowserDetails;
     private processStep;
     onTestEnd(test: TestCase, result: PwTestResult): Promise<void>;
-    private _getBaseTestId;
-    private _getStatusOrder;
-    /**
-     * Refactored to group all run attempts for a single logical test case.
-     * @param allAttempts An array of all individual test run attempts.
-     * @returns An array of ConsolidatedTestResult objects, where each object represents one logical test and contains an array of all its runs.
-     */
     private _getFinalizedResults;
+    private _getStatusOrder;
     onError(error: any): void;
     private _getEnvDetails;
     private _writeShardResults;

package/dist/reporter/playwright-pulse-reporter.js

@@ -40,10 +40,8 @@ const crypto_1 = require("crypto");
 const ua_parser_js_1 = require("ua-parser-js");
 const os = __importStar(require("os"));
 const convertStatus = (status, testCase, retryCount = 0) => {
-    if (status === "passed" && retryCount > 0) {
-        return "flaky";
-    }
     if ((testCase === null || testCase === void 0 ? void 0 : testCase.expectedStatus) === "failed") {
+        // If expected to fail but passed, it's flaky
         if (status === "passed")
             return "flaky";
         return "failed";
@@ -51,6 +49,10 @@ const convertStatus = (status, testCase, retryCount = 0) => {
     if ((testCase === null || testCase === void 0 ? void 0 : testCase.expectedStatus) === "skipped") {
         return "skipped";
     }
+    // If a test passes on a retry, it's considered flaky
+    if (status === "passed" && retryCount > 0) {
+        return "flaky";
+    }
     switch (status) {
         case "passed":
             return "passed";
@@ -69,12 +71,11 @@ const INDIVIDUAL_REPORTS_SUBDIR = "pulse-results";
 class PlaywrightPulseReporter {
     constructor(options = {}) {
         var _a, _b, _c;
-        // This will now store all individual run attempts for all tests using our new local type.
         this.results = [];
         this.baseOutputFile = "playwright-pulse-report.json";
         this.isSharded = false;
         this.shardIndex = undefined;
-        this.currentRunId = "";
+        this.currentRunId = ""; // Added to store the overall run ID
         this.options = options;
         this.baseOutputFile = (_a = options.outputFile) !== null && _a !== void 0 ? _a : this.baseOutputFile;
         this.outputDir = (_b = options.outputDir) !== null && _b !== void 0 ? _b : "pulse-report";
@@ -89,6 +90,7 @@ class PlaywrightPulseReporter {
         this.config = config;
         this.suite = suite;
         this.runStartTime = Date.now();
+        // Generate the overall runId once at the beginning
         this.currentRunId = `run-${this.runStartTime}-${(0, crypto_1.randomUUID)()}`;
         const configDir = this.config.rootDir;
         const configFileDir = this.config.configFile
@@ -114,7 +116,9 @@ class PlaywrightPulseReporter {
         })
             .catch((err) => console.error("Pulse Reporter: Error during initialization:", err));
     }
-    onTestBegin(test) { }
+    onTestBegin(test) {
+        // console.log(`Starting test: ${test.title}`); // Removed for brevity in final output
+    }
     getBrowserDetails(test) {
         var _a, _b, _c, _d;
         const project = (_a = test.parent) === null || _a === void 0 ? void 0 : _a.project();
@@ -165,7 +169,8 @@ class PlaywrightPulseReporter {
         }
         return finalString.trim();
     }
-    async processStep(step, testId, browserDetails, testCase, retryCount = 0) {
+    async processStep(step, testId, browserDetails, testCase, retryCount = 0 // Pass retryCount to convertStatus for steps
+    ) {
         var _a, _b, _c, _d;
         let stepStatus = "passed";
         let errorMessage = ((_a = step.error) === null || _a === void 0 ? void 0 : _a.message) || undefined;
@@ -173,6 +178,7 @@ class PlaywrightPulseReporter {
             stepStatus = "skipped";
         }
         else {
+            // Use the extended convertStatus
             stepStatus = convertStatus(step.error ? "failed" : "passed", testCase, retryCount);
         }
         const duration = step.duration;
@@ -206,13 +212,15 @@ class PlaywrightPulseReporter {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         const project = (_a = test.parent) === null || _a === void 0 ? void 0 : _a.project();
         const browserDetails = this.getBrowserDetails(test);
+        // Use the extended convertStatus, passing result.retry
         const testStatus = convertStatus(result.status, test, result.retry);
         const startTime = new Date(result.startTime);
         const endTime = new Date(startTime.getTime() + result.duration);
         const processAllSteps = async (steps) => {
             let processed = [];
             for (const step of steps) {
-                const processedStep = await this.processStep(step, test.id, browserDetails, test, result.retry);
+                const processedStep = await this.processStep(step, test.id, browserDetails, test, result.retry // Pass retryCount to processStep
+                );
                 processed.push(processedStep);
                 if (step.steps && step.steps.length > 0) {
                     processedStep.steps = await processAllSteps(step.steps);
@@ -244,11 +252,11 @@ class PlaywrightPulseReporter {
                 ? JSON.stringify(this.config.metadata)
                 : undefined,
         };
-        // Correctly handle the ID for each run attempt.
-        const testIdWithRunCounter = `${test.id}-run-${result.retry}`;
+        // Modify test.id for retries
+        const testIdWithRunCounter = result.retry > 0 ? `${test.id}-${result.retry}` : test.id;
         const pulseResult = {
-            id: testIdWithRunCounter,
-            runId: this.currentRunId,
+            id: testIdWithRunCounter, // Use the modified ID
+            runId: this.currentRunId, // Assign the overall run ID
             name: test.titlePath().join(" > "),
             suiteName: (project === null || project === void 0 ? void 0 : project.name) || ((_e = this.config.projects[0]) === null || _e === void 0 ? void 0 : _e.name) || "Default Suite",
             status: testStatus,
@@ -256,8 +264,8 @@ class PlaywrightPulseReporter {
             startTime: startTime,
             endTime: endTime,
             browser: browserDetails,
-            retries: result.retry,
-            runCounter: result.retry,
+            retries: result.retry, // This remains the Playwright retry count (0 for first run, 1 for first retry, etc.)
+            runCounter: result.retry, // This is your 'runCounter'
             steps: ((_f = result.steps) === null || _f === void 0 ? void 0 : _f.length) ? await processAllSteps(result.steps) : [],
             errorMessage: (_g = result.error) === null || _g === void 0 ? void 0 : _g.message,
             stackTrace: (_h = result.error) === null || _h === void 0 ? void 0 : _h.stack,
@@ -276,6 +284,7 @@ class PlaywrightPulseReporter {
             if (!attachment.path)
                 continue;
             try {
+                // Use the new testIdWithRunCounter for the subfolder
                 const testSubfolder = testIdWithRunCounter.replace(/[^a-zA-Z0-9_-]/g, "_");
                 const safeAttachmentName = path
                     .basename(attachment.path)
@@ -308,10 +317,34 @@ class PlaywrightPulseReporter {
         }
         this.results.push(pulseResult);
     }
-    // New method to extract the base test ID, ignoring the run-counter suffix
-    _getBaseTestId(testResultId) {
-        const parts = testResultId.split("-run-");
-        return parts[0];
+    _getFinalizedResults(allResults) {
+        const finalResultsMap = new Map();
+        for (const result of allResults) {
+            // The key for de-duplication should now be the base test ID (without the run counter suffix)
+            // This ensures that all runs of a single logical test are considered together.
+            const baseTestId = result.id.split("-").slice(0, -1).join("-"); // Remove '-${runCounter}'
+            const existing = finalResultsMap.get(baseTestId);
+            // We want to keep the "most successful" run for the final report.
+            // Priority: passed > flaky > failed > skipped.
+            // If statuses are equal, prefer the one with higher retry count (latest attempt).
+            if (!existing) {
+                finalResultsMap.set(baseTestId, result);
+            }
+            else {
+                const currentStatusOrder = this._getStatusOrder(result.status);
+                const existingStatusOrder = this._getStatusOrder(existing.status);
+                if (currentStatusOrder < existingStatusOrder) {
+                    // Current result is "better" (e.g., passed over failed)
+                    finalResultsMap.set(baseTestId, result);
+                }
+                else if (currentStatusOrder === existingStatusOrder &&
+                    result.retries > existing.retries) {
+                    // Same status, but current is a later retry, so prefer it
+                    finalResultsMap.set(baseTestId, result);
+                }
+            }
+        }
+        return Array.from(finalResultsMap.values());
     }
     _getStatusOrder(status) {
         switch (status) {
@@ -324,47 +357,9 @@ class PlaywrightPulseReporter {
             case "skipped":
                 return 4;
             default:
-                return 99;
+                return 99; // Unknown status
         }
     }
-    /**
-     * Refactored to group all run attempts for a single logical test case.
-     * @param allAttempts An array of all individual test run attempts.
-     * @returns An array of ConsolidatedTestResult objects, where each object represents one logical test and contains an array of all its runs.
-     */
-    _getFinalizedResults(allAttempts) {
-        const groupedResults = new Map();
-        for (const attempt of allAttempts) {
-            const baseTestId = this._getBaseTestId(attempt.id);
-            if (!groupedResults.has(baseTestId)) {
-                groupedResults.set(baseTestId, []);
-            }
-            groupedResults.get(baseTestId).push(attempt);
-        }
-        const finalResults = [];
-        for (const [baseId, runs] of groupedResults.entries()) {
-            // Sort runs to find the best status
-            runs.sort((a, b) => this._getStatusOrder(a.status) - this._getStatusOrder(b.status));
-            const bestRun = runs[0];
-            // Calculate total duration from the earliest start to the latest end time of all runs
-            const startTimes = runs.map((run) => run.startTime.getTime());
-            const endTimes = runs.map((run) => run.endTime.getTime());
-            const overallDuration = Math.max(...endTimes) - Math.min(...startTimes);
-            finalResults.push({
-                id: baseId,
-                name: bestRun.name,
-                suiteName: bestRun.suiteName,
-                status: bestRun.status,
-                duration: overallDuration,
-                startTime: new Date(Math.min(...startTimes)),
-                endTime: new Date(Math.max(...endTimes)),
-                browser: bestRun.browser,
-                tags: bestRun.tags,
-                runs: runs.sort((a, b) => a.runCounter - b.runCounter), // Sort runs chronologically for the report
-            });
-        }
-        return finalResults;
-    }
     onError(error) {
         var _a;
         console.error(`PlaywrightPulseReporter: Error encountered (Shard: ${(_a = this.shardIndex) !== null && _a !== void 0 ? _a : "Main"}):`, (error === null || error === void 0 ? void 0 : error.message) || error);
@@ -399,7 +394,7 @@ class PlaywrightPulseReporter {
         }
     }
     async _mergeShardResults(finalRunData) {
-        let allShardRawResults = [];
+        let allShardRawResults = []; // Store raw results before final de-duplication
         const totalShards = this.config.shard ? this.config.shard.total : 1;
         for (let i = 0; i < totalShards; i++) {
             const tempFilePath = path.join(this.outputDir, `${TEMP_SHARD_FILE_PREFIX}${i}.json`);
@@ -417,10 +412,13 @@ class PlaywrightPulseReporter {
                 }
             }
         }
+        // Apply _getFinalizedResults after all raw shard results are collected
         const finalResultsList = this._getFinalizedResults(allShardRawResults);
+        finalResultsList.forEach((r) => (r.runId = finalRunData.id));
         finalRunData.passed = finalResultsList.filter((r) => r.status === "passed").length;
         finalRunData.failed = finalResultsList.filter((r) => r.status === "failed").length;
         finalRunData.skipped = finalResultsList.filter((r) => r.status === "skipped").length;
+        // Add flaky count
         finalRunData.flaky = finalResultsList.filter((r) => r.status === "flaky").length;
         finalRunData.totalTests = finalResultsList.length;
         const reviveDates = (key, value) => {
@@ -468,39 +466,36 @@ class PlaywrightPulseReporter {
             await this._writeShardResults();
             return;
         }
-        let finalReport;
-        // `this.results` contains all individual run attempts. We will keep them all.
-        const allAttempts = this.results;
-        // Use your existing logic ONLY to get the final statuses for the summary counts.
-        const summaryResults = this._getFinalizedResults(this.results);
+        // `this.results` now contains all individual run attempts.
+        // _getFinalizedResults will select the "best" run for each logical test.
+        const finalResults = this._getFinalizedResults(this.results);
         const runEndTime = Date.now();
         const duration = runEndTime - this.runStartTime;
+        // Use the stored overall runId
         const runId = this.currentRunId;
         const environmentDetails = this._getEnvDetails();
         const runData = {
             id: runId,
             timestamp: new Date(this.runStartTime),
-            totalTests: summaryResults.length,
-            passed: summaryResults.filter((r) => r.status === "passed").length,
-            failed: summaryResults.filter((r) => r.status === "failed").length,
-            skipped: summaryResults.filter((r) => r.status === "skipped").length,
-            flaky: summaryResults.filter((r) => r.status === "flaky").length,
+            totalTests: finalResults.length,
+            passed: finalResults.filter((r) => r.status === "passed").length,
+            failed: finalResults.filter((r) => r.status === "failed").length,
+            skipped: finalResults.filter((r) => r.status === "skipped").length,
+            flaky: finalResults.filter((r) => r.status === "flaky").length, // Add flaky count
             duration,
             environment: environmentDetails,
         };
-        // In the final report object, use the complete list of attempts.
-        finalReport = {
-            run: runData,
-            results: allAttempts, // <<< USE THE FULL LIST HERE
-            metadata: { generatedAt: new Date().toISOString() },
-        };
+        // Ensure all final results have the correct overall runId
+        finalResults.forEach((r) => (r.runId = runId));
+        let finalReport = undefined;
         if (this.isSharded) {
+            // _mergeShardResults will now perform the final de-duplication across shards
             finalReport = await this._mergeShardResults(runData);
         }
         else {
             finalReport = {
                 run: runData,
-                results: summaryResults, // Cast to any to bypass the type mismatch
+                results: finalResults, // Use the de-duplicated results for a non-sharded run
                 metadata: { generatedAt: new Date().toISOString() },
             };
         }
@@ -574,6 +569,8 @@ class PlaywrightPulseReporter {
         const allResultsFromAllFiles = [];
         let latestTimestamp = new Date(0);
         let lastRunEnvironment = undefined;
+        // We can't simply sum durations across merged files, as the tests might overlap.
+        // The final duration will be derived from the range of start/end times in the final results.
         let earliestStartTime = Date.now();
         let latestEndTime = 0;
         for (const file of reportFiles) {
@@ -581,26 +578,24 @@ class PlaywrightPulseReporter {
             try {
                 const content = await fs.readFile(filePath, "utf-8");
                 const json = JSON.parse(content);
-                // This is the tricky part. We need to handle both old and new report formats.
-                // Assuming the `results` array might contain the old, single-run objects or the new, consolidated ones.
+                if (json.run) {
+                    const runTimestamp = new Date(json.run.timestamp);
+                    if (runTimestamp > latestTimestamp) {
+                        latestTimestamp = runTimestamp;
+                        lastRunEnvironment = json.run.environment || undefined;
+                    }
+                }
                 if (json.results) {
-                    json.results.forEach((testResult) => {
-                        // Check if the TestResult has a 'runs' array (new format)
-                        if ("runs" in testResult && Array.isArray(testResult.runs)) {
-                            allResultsFromAllFiles.push(...testResult.runs);
-                        }
-                        else {
-                            // This is the old format (single run). We'll treat it as a single attempt.
-                            allResultsFromAllFiles.push(testResult); // Cast to any to get properties
-                        }
-                    });
+                    allResultsFromAllFiles.push(...json.results);
                 }
             }
             catch (err) {
                 console.warn(`Pulse Reporter: Could not parse report file ${filePath}. Skipping. Error: ${err.message}`);
             }
         }
+        // De-duplicate the results from ALL merged files using the helper function
         const finalMergedResults = this._getFinalizedResults(allResultsFromAllFiles);
+        // Calculate overall duration from the earliest start and latest end of the final merged results
         for (const res of finalMergedResults) {
             if (res.startTime.getTime() < earliestStartTime)
                 earliestStartTime = res.startTime.getTime();
@@ -616,7 +611,7 @@ class PlaywrightPulseReporter {
             passed: finalMergedResults.filter((r) => r.status === "passed").length,
             failed: finalMergedResults.filter((r) => r.status === "failed").length,
             skipped: finalMergedResults.filter((r) => r.status === "skipped").length,
-            flaky: finalMergedResults.filter((r) => r.status === "flaky").length,
+            flaky: finalMergedResults.filter((r) => r.status === "flaky").length, // Add flaky count
             duration: totalDuration,
         };
         const finalReport = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arghajit/dummy",
-  "version": "0.1.2-beta-4",
+  "version": "0.1.2",
   "description": "A Playwright reporter and dashboard for visualizing test results.",
   "homepage": "https://playwright-pulse-report.netlify.app/",
   "keywords": [
@@ -50,8 +50,7 @@
     "report:merge": "node ./scripts/merge-pulse-report.js",
     "report:email": "node ./scripts/sendReport.mjs",
     "report:minify": "node ./scripts/generate-email-report.mjs",
-    "generate-trend": "node ./scripts/generate-trend.mjs",
-    "deploy": "npm publish --access -public"
+    "generate-trend": "node ./scripts/generate-trend.mjs"
   },
   "dependencies": {
     "archiver": "^7.0.1",