browser-commander 0.33.1 → 0.33.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.33.2
+
+### Patch Changes
+
+- 0013b28: The failure screenshot that `browser-commander/tests` writes for a failed scenario captures the view without a clip for Playwright and Puppeteer pages that have no fixed viewport (issue #180), as trace checkpoints and default screenshots already do. A clipped engine capture could leave a resized headful window drawn at its old size. Pages with a fixed viewport and other engines keep the engine's screenshot.
+
 ## 0.33.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-commander",
-  "version": "0.33.1",
+  "version": "0.33.2",
   "description": "Universal browser automation library that supports Playwright, Puppeteer, and Selenium with a unified API",
   "main": "src/index.js",
   "bin": {

package/src/tests/index.js

@@ -11,6 +11,7 @@ import path from 'node:path';
 import { test as baseTest } from 'test-anywhere';
 import { launchBrowser } from '../browser/launcher.js';
 import { makeBrowserCommander } from '../factory.js';
+import { captureStableViewport } from '../capture/viewport.js';
 import {
   finishScenarioTrace,
   resolveTestDownloads,
@@ -571,7 +572,19 @@ export async function writeFailureArtifacts(options = {}) {
   if (page && typeof page.screenshot === 'function') {
     const screenshotPath = path.join(artifactsDir, `${safeName}.png`);
     try {
-      await page.screenshot({ path: screenshotPath });
+      // A clipped engine capture can leave a resized headful window drawn at
+      // its old size (issue #180); without a fixed viewport, capture the view.
+      if (['playwright', 'puppeteer'].includes(engine)) {
+        const shot = await captureStableViewport(page, engine, {
+          type: 'png',
+          path: screenshotPath,
+        });
+        if (shot.engine === 'cdp') {
+          writeFileSync(screenshotPath, shot.bytes);
+        }
+      } else {
+        await page.screenshot({ path: screenshotPath });
+      }
       artifacts.push(screenshotPath);
     } catch (screenshotError) {
       const screenshotErrorPath = path.join(

package/tests/unit/tests/index.test.js

@@ -232,6 +232,7 @@ describe('browser-commander/tests', () => {
         page: {
           screenshot: async ({ path: screenshotPath }) => {
             assert.ok(screenshotPath.endsWith('.png'));
+            return Buffer.from('png');
           },
         },
         error: new Error('broken'),
@@ -241,6 +242,7 @@ describe('browser-commander/tests', () => {
       });
 
       assert.strictEqual(artifacts.length, 2);
+      assert.ok(artifacts[1].endsWith('.png'), artifacts[1]);
       const errorJson = JSON.parse(readFileSync(artifacts[0], 'utf8'));
       assert.strictEqual(errorJson.message, 'broken');
       assert.strictEqual(errorJson.engine, 'playwright');

package/tests/unit/traces/issue-180-screenshots.test.js

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { startTrace } from '../../../src/traces/recorder.js';
 import { TRACE_MODE } from '../../../src/traces/schema.js';
 import { screenshot } from '../../../src/capture/index.js';
+import { writeFailureArtifacts } from '../../../src/tests/index.js';
 import {
   createFakeCommander,
   createFakePage,
@@ -45,6 +46,22 @@ function cdpFake({ viewport = null, failWith, engine = 'playwright' } = {}) {
   return { page, calls };
 }
 
+/** One clip-less CDP capture of the view, and no engine screenshot. */
+function assertViewCapture(calls) {
+  assert.deepEqual(calls.cdp, [
+    {
+      method: 'Page.captureScreenshot',
+      params: {
+        format: 'png',
+        fromSurface: false,
+        captureBeyondViewport: false,
+      },
+    },
+  ]);
+  assert.equal(calls.engine.length, 0);
+  assert.equal(calls.detached, 1);
+}
+
 describe('trace checkpoint screenshots (issue #180)', () => {
   const directory = useTempTraceDirectory();
 
@@ -74,18 +91,7 @@ describe('trace checkpoint screenshots (issue #180)', () => {
           await checkpointShot(page, { withCommander, engine }),
           'cdp-png'
         );
-        assert.deepEqual(calls.cdp, [
-          {
-            method: 'Page.captureScreenshot',
-            params: {
-              format: 'png',
-              fromSurface: false,
-              captureBeyondViewport: false,
-            },
-          },
-        ]);
-        assert.equal(calls.engine.length, 0);
-        assert.equal(calls.detached, 1);
+        assertViewCapture(calls);
       });
     }
   }
@@ -171,3 +177,48 @@ describe('default commander screenshots (issue #180)', () => {
     });
   }
 });
+
+describe('failure artifact screenshots (issue #180)', () => {
+  const directory = useTempTraceDirectory();
+
+  /** The PNG artifact a failed scenario writes, read back as text. */
+  async function failureShot(page, engine) {
+    page.screenshot = async (options) => {
+      page.engineCalls.push(options);
+      await fs.writeFile(options.path, 'engine-png');
+      return Buffer.from('engine-png');
+    };
+    const [, shot] = await writeFailureArtifacts({
+      page,
+      error: new Error('broken'),
+      testId: 'resized',
+      engine,
+      artifactsDir: directory.path,
+    });
+    assert.ok(shot.endsWith('.png'), shot);
+    return (await fs.readFile(shot)).toString();
+  }
+
+  for (const engine of ['playwright', 'puppeteer']) {
+    it(`${engine} without a fixed viewport sends no clip`, async () => {
+      const { page, calls } = cdpFake({ engine });
+      page.engineCalls = calls.engine;
+      assert.equal(await failureShot(page, engine), 'cdp-png');
+      assertViewCapture(calls);
+    });
+  }
+
+  for (const [name, engine, viewport] of [
+    ['playwright with a fixed viewport', 'playwright', { width: 8, height: 6 }],
+    ['puppeteer with a fixed viewport', 'puppeteer', { width: 8, height: 6 }],
+    ['selenium', 'selenium', null],
+  ]) {
+    it(`${name} keeps the engine screenshot`, async () => {
+      const page =
+        engine === 'selenium' ? {} : cdpFake({ engine, viewport }).page;
+      page.engineCalls = [];
+      assert.equal(await failureShot(page, engine), 'engine-png');
+      assert.equal(page.engineCalls.length, 1);
+    });
+  }
+});