flexysnap 0.5.3 → 0.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flexysnap",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Flexible visual snapshot testing for Playwright, built for e-commerce.",
   "keywords": [
     "playwright",

package/src/testUtils.js

@@ -34,30 +34,65 @@ async function attemptNavigation(page, url, timeout) {
     }
 }
 
-async function prepareRetry(page, waitMs) {
-    await page.goto('about:blank', { timeout: 5000 }).catch(() => {});
+const CLOSE_STUCK_TARGET_TIMEOUT_MS = 5000;
+const replacementContexts = [];
+
+function closeWithinTimeout(closeable, timeoutMs) {
+    let timeoutHandle;
+    const timeoutPromise = new Promise(resolve => {
+        timeoutHandle = setTimeout(resolve, timeoutMs);
+    });
+    const closePromise = closeable.close().catch(() => {});
+    return Promise.race([closePromise, timeoutPromise]).finally(() => clearTimeout(timeoutHandle));
+}
+
+async function openReplacementPage(stuckPage, contextOptions) {
+    const stuckContext = stuckPage.context();
+    const browser = stuckContext.browser();
+
+    if (!browser) {
+        await closeWithinTimeout(stuckPage, CLOSE_STUCK_TARGET_TIMEOUT_MS);
+        return stuckContext.newPage();
+    }
+
+    const viewport = stuckPage.viewportSize();
+    await closeWithinTimeout(stuckContext, CLOSE_STUCK_TARGET_TIMEOUT_MS);
+
+    const replacementContext = await browser.newContext({ viewport, ...contextOptions });
+    replacementContexts.push(replacementContext);
+    await configureContext(replacementContext);
+
+    return replacementContext.newPage();
+}
+
+async function prepareRetry(stuckPage, waitMs, contextOptions) {
+    logTimestamp('Discarding stuck page and opening a new browser context');
+    const replacementPage = await openReplacementPage(stuckPage, contextOptions);
     logTimestamp(`Waiting ${waitMs}ms before retrying`);
-    await page.waitForTimeout(waitMs);
+    await replacementPage.waitForTimeout(waitMs);
+    return replacementPage;
 }
 
 async function gotoWithRetry(page, url, options = {}) {
-    const { baseTimeout = 20000, backoffMs = 3000 } = options;
+    const { baseTimeout = 20000, backoffMs = 3000, contextOptions = {} } = options;
     const maxAttempts = 3;
     let error = null;
+    let currentPage = page;
     for (let i = 1; i <= maxAttempts; ++i) {
         error = null;
         const timeout = baseTimeout * i;
         try {
-            await attemptNavigation(page, url, timeout);
+            await attemptNavigation(currentPage, url, timeout);
             break
         } catch (e) {
             error = e
             if (i < maxAttempts)
-                await prepareRetry(page, backoffMs * i);
+                currentPage = await prepareRetry(currentPage, backoffMs * i, contextOptions);
         }
     }
     if (error)
         throw error
+    return currentPage;
 }
 
 
@@ -82,9 +117,7 @@ function isTestedSiteUrl(url) {
     return baseUrl !== '' && url.href.includes(baseUrl);
 }
 
-test.beforeEach(async ({ context }) => {
-    startTimer();
-    logTimestamp('Test execution started');
+async function configureContext(context) {
     context.on('requestfailed', request => {
         const errorText = request.failure()?.errorText;
         logTimestamp(`Request failed: ${request.method()} ${request.url()} - ${errorText}`);
@@ -112,6 +145,19 @@ test.beforeEach(async ({ context }) => {
         logTimestamp('Requesting ' + urlString);
         route.continue({ url: urlString });
     });
+}
+
+test.beforeEach(async ({ context }) => {
+    startTimer();
+    logTimestamp('Test execution started');
+    await configureContext(context);
+});
+
+test.afterEach(async () => {
+    const contextsToClose = replacementContexts.splice(0, replacementContexts.length);
+    for (const replacementContext of contextsToClose) {
+        await closeWithinTimeout(replacementContext, CLOSE_STUCK_TARGET_TIMEOUT_MS);
+    }
 });
 
 let testStartTime = null;