@link-assistant/web-capture 1.12.0 → 2.0.1

package/tests/unit/browser.test.js

@@ -1,172 +0,0 @@
-import { createBrowser, getBrowserEngine } from '../../src/browser.js';
-
-describe('Browser Abstraction Layer', () => {
-  describe('getBrowserEngine', () => {
-    it('returns puppeteer by default', () => {
-      const req = { query: {} };
-      expect(getBrowserEngine(req)).toBe('puppeteer');
-    });
-
-    it('returns playwright when engine=playwright query param is provided', () => {
-      const req = { query: { engine: 'playwright' } };
-      expect(getBrowserEngine(req)).toBe('playwright');
-    });
-
-    it('returns playwright when engine=pw query param is provided', () => {
-      const req = { query: { engine: 'pw' } };
-      expect(getBrowserEngine(req)).toBe('playwright');
-    });
-
-    it('returns puppeteer when engine=puppeteer query param is provided', () => {
-      const req = { query: { engine: 'puppeteer' } };
-      expect(getBrowserEngine(req)).toBe('puppeteer');
-    });
-
-    it('returns puppeteer when engine=pptr query param is provided', () => {
-      const req = { query: { engine: 'pptr' } };
-      expect(getBrowserEngine(req)).toBe('puppeteer');
-    });
-
-    it('returns playwright when browser=playwright query param is provided', () => {
-      const req = { query: { browser: 'playwright' } };
-      expect(getBrowserEngine(req)).toBe('playwright');
-    });
-
-    it('is case insensitive', () => {
-      const req1 = { query: { engine: 'PLAYWRIGHT' } };
-      const req2 = { query: { engine: 'PlAyWrIgHt' } };
-      expect(getBrowserEngine(req1)).toBe('playwright');
-      expect(getBrowserEngine(req2)).toBe('playwright');
-    });
-
-    it('returns playwright from BROWSER_ENGINE env var', () => {
-      const originalEnv = process.env.BROWSER_ENGINE;
-      process.env.BROWSER_ENGINE = 'playwright';
-      const req = { query: {} };
-      expect(getBrowserEngine(req)).toBe('playwright');
-      if (originalEnv) {
-        process.env.BROWSER_ENGINE = originalEnv;
-      } else {
-        delete process.env.BROWSER_ENGINE;
-      }
-    });
-
-    it('prefers query param over env var', () => {
-      const originalEnv = process.env.BROWSER_ENGINE;
-      process.env.BROWSER_ENGINE = 'playwright';
-      const req = { query: { engine: 'puppeteer' } };
-      expect(getBrowserEngine(req)).toBe('puppeteer');
-      if (originalEnv) {
-        process.env.BROWSER_ENGINE = originalEnv;
-      } else {
-        delete process.env.BROWSER_ENGINE;
-      }
-    });
-  });
-
-  describe('createBrowser - Puppeteer', () => {
-    it('creates a puppeteer browser with type field', async () => {
-      const browser = await createBrowser('puppeteer');
-      expect(browser.type).toBe('puppeteer');
-      expect(browser.newPage).toBeDefined();
-      expect(browser.close).toBeDefined();
-      await browser.close();
-    });
-
-    it('can create and use a page', async () => {
-      const browser = await createBrowser('puppeteer');
-      const page = await browser.newPage();
-      expect(page.setViewport).toBeDefined();
-      expect(page.goto).toBeDefined();
-      expect(page.content).toBeDefined();
-      expect(page.screenshot).toBeDefined();
-      expect(page.type).toBe('puppeteer');
-      await browser.close();
-    });
-  });
-
-  describe('createBrowser - Playwright', () => {
-    it('creates a playwright browser with type field', async () => {
-      const browser = await createBrowser('playwright');
-      expect(browser.type).toBe('playwright');
-      expect(browser.newPage).toBeDefined();
-      expect(browser.close).toBeDefined();
-      await browser.close();
-    });
-
-    it('can create and use a page', async () => {
-      const browser = await createBrowser('playwright');
-      const page = await browser.newPage();
-      expect(page.setViewport).toBeDefined();
-      expect(page.goto).toBeDefined();
-      expect(page.content).toBeDefined();
-      expect(page.screenshot).toBeDefined();
-      expect(page.type).toBe('playwright');
-      await browser.close();
-    });
-  });
-
-  describe('Page Adapter Compatibility', () => {
-    it('both adapters support the same interface', async () => {
-      const puppeteerBrowser = await createBrowser('puppeteer');
-      const playwrightBrowser = await createBrowser('playwright');
-
-      const puppeteerPage = await puppeteerBrowser.newPage();
-      const playwrightPage = await playwrightBrowser.newPage();
-
-      // Check that both have the same methods
-      const methods = [
-        'setExtraHTTPHeaders',
-        'setUserAgent',
-        'setViewport',
-        'goto',
-        'content',
-        'screenshot',
-        'close',
-      ];
-      for (const method of methods) {
-        expect(puppeteerPage[method]).toBeDefined();
-        expect(playwrightPage[method]).toBeDefined();
-      }
-
-      await puppeteerBrowser.close();
-      await playwrightBrowser.close();
-    });
-
-    it('both adapters expose browser-commander v0.7.0+ APIs', async () => {
-      const puppeteerBrowser = await createBrowser('puppeteer');
-      const playwrightBrowser = await createBrowser('playwright');
-
-      const puppeteerPage = await puppeteerBrowser.newPage();
-      const playwrightPage = await playwrightBrowser.newPage();
-
-      // browser-commander v0.7.0: keyboard interaction
-      expect(puppeteerPage.keyboard).toBeDefined();
-      expect(puppeteerPage.keyboard.press).toBeDefined();
-      expect(puppeteerPage.keyboard.type).toBeDefined();
-      expect(playwrightPage.keyboard).toBeDefined();
-      expect(playwrightPage.keyboard.press).toBeDefined();
-
-      // browser-commander v0.7.0: dialog handling
-      expect(puppeteerPage.onDialog).toBeDefined();
-      expect(puppeteerPage.offDialog).toBeDefined();
-      expect(puppeteerPage.clearDialogHandlers).toBeDefined();
-      expect(playwrightPage.onDialog).toBeDefined();
-
-      // browser-commander v0.7.0: media emulation
-      expect(puppeteerPage.emulateMedia).toBeDefined();
-      expect(playwrightPage.emulateMedia).toBeDefined();
-
-      // browser-commander v0.8.0: PDF generation
-      expect(puppeteerPage.pdf).toBeDefined();
-      expect(playwrightPage.pdf).toBeDefined();
-
-      // browser-commander: evaluate
-      expect(puppeteerPage.evaluate).toBeDefined();
-      expect(playwrightPage.evaluate).toBeDefined();
-
-      await puppeteerBrowser.close();
-      await playwrightBrowser.close();
-    });
-  });
-});

package/tests/unit/cache.test.js

@@ -1,182 +0,0 @@
-import { jest } from '@jest/globals';
-import { mkdtemp, readFile, rm, writeFile, readdir } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { CaptureStore, CachedTransport } from '../../src/cache.js';
-import { captureResponse } from '../../src/transport.js';
-
-const request = {
-  url: 'https://example.test/source',
-  method: 'GET',
-  headers: { accept: 'application/octet-stream' },
-};
-const receipt = {
-  body: Buffer.from([0, 255, 65]),
-  finalUrl: 'https://example.test/final',
-  status: 206,
-  headers: { etag: 'v1' },
-  diagnostics: { outcome: 'response' },
-};
-let directory, store;
-beforeEach(async () => {
-  directory = await mkdtemp(path.join(tmpdir(), 'capture-cache-'));
-  store = new CaptureStore(directory);
-});
-afterEach(async () => {
-  await rm(directory, { recursive: true, force: true });
-});
-
-test('exact receipts survive cache hits, offline stale replay and online refresh', async () => {
-  let time = 1000;
-  const inner = jest.fn(async () => receipt);
-  const options = { ttl: 100, now: () => time };
-  const online = new CachedTransport(inner, store, options);
-  const first = await online.capture(request);
-  expect(first).toMatchObject({ cached: false, stale: false, receipt });
-  expect(
-    await captureResponse(request.url, {
-      transport: online.execute,
-      headers: request.headers,
-    })
-  ).toEqual(receipt);
-  expect(inner).toHaveBeenCalledTimes(1);
-  const forbidden = jest.fn(() => {
-    throw new Error('offline network access');
-  });
-  const offline = new CachedTransport(forbidden, store, {
-    ...options,
-    offline: true,
-  });
-  expect(await offline.capture(request)).toMatchObject({
-    cached: true,
-    stale: false,
-    receipt,
-  });
-  time = 1100;
-  expect(await offline.capture(request)).toMatchObject({
-    cached: true,
-    stale: true,
-    receipt,
-  });
-  expect(forbidden).not.toHaveBeenCalled();
-  expect(await online.capture(request)).toMatchObject({
-    cached: false,
-    stale: false,
-  });
-  expect(inner).toHaveBeenCalledTimes(2);
-  expect(await store.list()).toHaveLength(1);
-  expect(await store.prune(1200, 100)).toBe(1);
-  await expect(offline.capture(request)).rejects.toMatchObject({
-    kind: 'offline_cache_miss',
-  });
-});
-
-test('portable fixture imports/exports, request isolation and body deduplication', async () => {
-  const fixture = await readFile(
-    new globalThis.URL(
-      '../../../rust/tests/fixtures/capture-v1.json',
-      import.meta.url
-    ),
-    'utf8'
-  );
-  await store.import(fixture);
-  expect((await store.load(request)).receipt).toEqual(receipt);
-  expect(JSON.parse(await store.export(request))).toEqual(JSON.parse(fixture));
-  for (const different of [
-    { ...request, method: 'POST' },
-    { ...request, url: `${request.url}?query=1` },
-    { ...request, headers: { authorization: 'different' } },
-  ]) {
-    expect(await store.load(different)).toBeNull();
-  }
-  await store.store(
-    { ...request, url: `${request.url}/duplicate` },
-    receipt,
-    2000
-  );
-  expect(await readdir(path.join(directory, 'bodies'))).toHaveLength(1);
-  expect(await store.prune(1100, 100)).toBe(1);
-  expect(await readdir(path.join(directory, 'bodies'))).toHaveLength(1);
-  await expect(
-    store.import(fixture.replace('255', '254'))
-  ).rejects.toMatchObject({ kind: 'cache' });
-  await expect(
-    store.import(fixture.replace('"version": 1', '"version": 999'))
-  ).rejects.toMatchObject({ kind: 'cache' });
-});
-
-test('corrupt bodies are rejected and failed transports are never cached', async () => {
-  const stored = await store.store(request, receipt, 1000);
-  await writeFile(path.join(directory, 'bodies', stored.sha256), 'corrupt');
-  await expect(store.load(request)).rejects.toMatchObject({ kind: 'cache' });
-  const failure = new Error('transport failed');
-  const cache = new CachedTransport(async () => {
-    throw failure;
-  }, store);
-  await expect(
-    cache.capture({ ...request, url: 'https://other.test' })
-  ).rejects.toThrow('transport failed');
-  expect(await store.list()).toHaveLength(1);
-});
-
-test('Unicode header ordering matches the shared Rust replay format', async () => {
-  const fixture = await readFile(
-    new globalThis.URL(
-      '../../../rust/tests/fixtures/capture-v1-unicode.json',
-      import.meta.url
-    ),
-    'utf8'
-  );
-  const replay = JSON.parse(fixture);
-  await store.import(fixture);
-  expect((await store.load(replay.request)).receipt).toEqual(receipt);
-  expect(JSON.parse(await store.export(replay.request))).toEqual(replay);
-});
-
-test('failed online refresh retains the expired capture for offline replay', async () => {
-  await store.store(request, receipt, 800);
-  const cache = new CachedTransport(
-    async () => {
-      throw new Error('offline upstream');
-    },
-    store,
-    { ttl: 100, now: () => 1000 }
-  );
-  await expect(cache.capture(request)).rejects.toThrow('offline upstream');
-  const offline = new CachedTransport(null, store, {
-    offline: true,
-    ttl: 100,
-    now: () => 1000,
-  });
-  expect(await offline.capture(request)).toMatchObject({
-    stale: true,
-    receipt,
-  });
-  for (const replay of ['{', 'null', '{}']) {
-    await expect(store.import(replay)).rejects.toMatchObject({ kind: 'cache' });
-  }
-});
-
-test('headers are sorted without mutating the caller; TTL zero always refreshes', async () => {
-  const a = { ...request, headers: { z: '1', a: '2' } };
-  const b = { ...request, headers: { a: '2', z: '1' } };
-  await store.store(a, receipt, 1000);
-  expect((await store.load(b)).receipt).toEqual(receipt);
-  const inner = jest.fn(async () => receipt);
-  const cache = new CachedTransport(inner, store, { ttl: 0, now: () => 1000 });
-  await cache.capture(a);
-  await cache.capture(a);
-  expect(inner).toHaveBeenCalledTimes(2);
-});
-
-test('caller mutation during a fetch cannot change the stored request identity', async () => {
-  const mutable = { ...request, headers: { ...request.headers } };
-  const cache = new CachedTransport(async () => {
-    mutable.url = 'https://mutated.test';
-    mutable.headers.accept = 'text/plain';
-    return receipt;
-  }, store);
-  await cache.capture(mutable);
-  expect((await store.load(request)).receipt).toEqual(receipt);
-  expect(await store.load(mutable)).toBeNull();
-});