@samsara-dev/appwright 0.9.15 → 0.9.16

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # appwright
 
+## 0.9.16
+
+### Patch Changes
+
+- 7e73c82: Fix persistent device video download race condition that caused the process to hang when a worker had only one test (common with retries). When the 5-second delay wasn't enough for endTime to be written, the code misclassified the last test as intermediate and waited for a file that only the endTime download path would create. The intermediate test branch now polls for both the video file on disk and endTime being set, and all downloads go through a per-session lock to prevent concurrent writes.
+
 ## 0.9.15
 
 ### Patch Changes

package/dist/reporter.d.ts

@@ -1,11 +1,21 @@
 import type { Reporter, TestCase, TestResult } from "@playwright/test/reporter";
 declare class VideoDownloader implements Reporter {
     private downloadPromises;
+    private sessionDownloadLocks;
     onBegin(): void;
     onTestBegin(test: TestCase, result: TestResult): void;
     onTestEnd(test: TestCase, result: TestResult): void;
     onEnd(): Promise<void>;
     private trimAndAttachPersistentDeviceVideo;
+    /**
+     * Ensures exactly one download per session. The first caller triggers the
+     * download; concurrent callers await the same promise. Returns the
+     * downloaded file path, or null if the download failed.
+     *
+     * Keyed by sessionId (not workerIndex) because Playwright can reuse
+     * workerIndex across worker restarts with different BrowserStack sessions.
+     */
+    private ensureWorkerVideoDownloaded;
     private downloadAndAttachDeviceVideo;
     private providerSupportsVideo;
 }

package/dist/reporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../src/reporter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAUhF,cAAM,eAAgB,YAAW,QAAQ;IACvC,OAAO,CAAC,gBAAgB,CAAsB;IAE9C,OAAO;IAQP,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU;IAU9C,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU;IAuGtC,KAAK;YAKG,kCAAkC;IA6ChD,OAAO,CAAC,4BAA4B;IAyBpC,OAAO,CAAC,qBAAqB;CAU9B;AAwHD,eAAe,eAAe,CAAC"}
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../src/reporter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAUhF,cAAM,eAAgB,YAAW,QAAQ;IACvC,OAAO,CAAC,gBAAgB,CAAsB;IAK9C,OAAO,CAAC,oBAAoB,CAA6C;IAEzE,OAAO;IAQP,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU;IAU9C,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU;IAgItC,KAAK;YAKG,kCAAkC;IA6ChD;;;;;;;OAOG;YACW,2BAA2B;IAqBzC,OAAO,CAAC,4BAA4B;IAyBpC,OAAO,CAAC,qBAAqB;CAU9B;AA0ID,eAAe,eAAe,CAAC"}

package/dist/reporter.js

@@ -13,6 +13,11 @@ const utils_1 = require("./utils");
 const workerInfo_1 = require("./fixture/workerInfo");
 class VideoDownloader {
     downloadPromises = [];
+    // Ensures only one download per session — prevents concurrent downloads
+    // when multiple tests on the same worker resolve endTime simultaneously.
+    // Keyed by sessionId (not workerIndex) because Playwright can reuse
+    // workerIndex across worker restarts with different sessions.
+    sessionDownloadLocks = new Map();
     onBegin() {
         if (fs_1.default.existsSync((0, utils_1.basePath)())) {
             fs_1.default.rmSync((0, utils_1.basePath)(), {
@@ -53,7 +58,7 @@ class VideoDownloader {
                 type: "workerInfo",
                 description: `Ran on worker #${workerIndex}.`,
             });
-            // The `onTestEnd` is method is called before the worker ends and
+            // The `onTestEnd` method is called before the worker ends and
             // the worker's `endTime` is saved to disk. We add a 5 secs delay
             // to prevent a harmful race condition.
             const workerDownload = getWorkerInfo(workerIndex)
@@ -77,21 +82,37 @@ class VideoDownloader {
                         return; // Nothing to do here
                     }
                     const workerVideoBaseName = `worker-${workerIndex}-${sessionId}-video`;
+                    const expectedWorkerVideoPath = path_1.default.join((0, utils_1.basePath)(), `${workerVideoBaseName}.mp4`);
                     if (endTime) {
-                        // This is the last test in the worker, so let's download the video
-                        const provider = (0, providers_1.getProviderClass)(providerName);
-                        const downloaded = await provider.downloadVideo(sessionId, (0, utils_1.basePath)(), workerVideoBaseName);
-                        if (!downloaded) {
+                        // Last test in the worker — download through the lock
+                        // so concurrent endTime resolutions don't race.
+                        const downloadedPath = await this.ensureWorkerVideoDownloaded(sessionId, providerName, workerVideoBaseName);
+                        if (!downloadedPath) {
                             return;
                         }
-                        return this.trimAndAttachPersistentDeviceVideo(test, result, downloaded.path);
+                        return this.trimAndAttachPersistentDeviceVideo(test, result, downloadedPath);
                     }
                     else {
-                        // This is an intermediate test in the worker, so let's wait for the
-                        // video file to be found on disk. Once it is, we trim and attach it.
-                        const expectedWorkerVideoPath = path_1.default.join((0, utils_1.basePath)(), `${workerVideoBaseName}.mp4`);
-                        await waitFor(() => fs_1.default.existsSync(expectedWorkerVideoPath));
-                        return this.trimAndAttachPersistentDeviceVideo(test, result, expectedWorkerVideoPath);
+                        // This looks like an intermediate test, but endTime may not
+                        // have been written yet (race condition — common when a worker
+                        // has only one test, e.g. retries). Poll for EITHER the video
+                        // file on disk (written by the last test's download) OR
+                        // endTime appearing (meaning we need to download ourselves).
+                        const resolved = await waitForFileOrEndTime(expectedWorkerVideoPath, workerIndex);
+                        if (resolved === "file") {
+                            return this.trimAndAttachPersistentDeviceVideo(test, result, expectedWorkerVideoPath);
+                        }
+                        else {
+                            // endTime was set but file doesn't exist yet. Use the
+                            // per-session lock so only one test triggers the download;
+                            // others await the same promise.
+                            const downloadedPath = await this.ensureWorkerVideoDownloaded(sessionId, providerName, workerVideoBaseName);
+                            if (!downloadedPath) {
+                                logger_1.logger.error(`Video download returned null for session ${sessionId}, skipping attachment`);
+                                return;
+                            }
+                            return this.trimAndAttachPersistentDeviceVideo(test, result, downloadedPath);
+                        }
                     }
                 });
             })
@@ -146,6 +167,25 @@ class VideoDownloader {
             name: "video",
         });
     }
+    /**
+     * Ensures exactly one download per session. The first caller triggers the
+     * download; concurrent callers await the same promise. Returns the
+     * downloaded file path, or null if the download failed.
+     *
+     * Keyed by sessionId (not workerIndex) because Playwright can reuse
+     * workerIndex across worker restarts with different BrowserStack sessions.
+     */
+    async ensureWorkerVideoDownloaded(sessionId, providerName, workerVideoBaseName) {
+        if (!this.sessionDownloadLocks.has(sessionId)) {
+            const downloadPromise = (async () => {
+                const provider = (0, providers_1.getProviderClass)(providerName);
+                const downloaded = await provider.downloadVideo(sessionId, (0, utils_1.basePath)(), workerVideoBaseName);
+                return downloaded?.path ?? null;
+            })();
+            this.sessionDownloadLocks.set(sessionId, downloadPromise);
+        }
+        return this.sessionDownloadLocks.get(sessionId);
+    }
     downloadAndAttachDeviceVideo(test, result, providerClass, sessionId) {
         const videoFileName = `${sessionId}-${test.id}`;
         if (!providerClass.downloadVideo) {
@@ -174,21 +214,37 @@ class VideoDownloader {
         return !!provider.downloadVideo;
     }
 }
-function waitFor(condition, timeout = 60 * 60 * 1000) {
-    return new Promise((resolve, reject) => {
-        let interval;
-        const timeoutId = setTimeout(() => {
-            clearInterval(interval);
-            reject(new Error("Timed out waiting for condition"));
-        }, timeout);
-        interval = setInterval(() => {
-            if (condition()) {
-                clearInterval(interval);
-                clearTimeout(timeoutId);
-                resolve();
+/**
+ * Poll until the video file appears on disk OR the worker's endTime is set.
+ *
+ * When a worker has only one test (common with retries), the 5-second delay
+ * before checking endTime may not be enough — the worker teardown can take
+ * longer than 5 seconds. In that case onTestEnd
+ * incorrectly treats the last test as "intermediate" and waits for a video file
+ * that will never be created. This function resolves the race by checking both
+ * conditions in parallel.
+ *
+ * Uses validateMp4 instead of fs.existsSync to ensure the file is fully
+ * written (has a valid moov atom) before returning.
+ */
+async function waitForFileOrEndTime(filePath, workerIndex, timeout = 5 * 60 * 1000) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        if (fs_1.default.existsSync(filePath) && validateMp4(filePath)) {
+            return "file";
+        }
+        try {
+            const info = await getWorkerInfo(workerIndex);
+            if (info?.endTime) {
+                return "endTime";
             }
-        }, 500);
-    });
+        }
+        catch {
+            // getWorkerInfo can fail transiently; keep polling
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    throw new Error(`Timed out waiting for video file or worker ${workerIndex} endTime`);
 }
 /**
  * Validate that an MP4 file has a valid moov atom (metadata header).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@samsara-dev/appwright",
-  "version": "0.9.15",
+  "version": "0.9.16",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"