@link-assistant/web-capture 1.12.0 → 2.0.1

package/tests/ci/rust-dockerfile.test.js

@@ -1,54 +0,0 @@
-import { readFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const repoRoot = resolve(__dirname, '../../..');
-
-function parseVersion(version) {
-  return version.split('.').map((part) => Number(part));
-}
-
-function compareVersions(left, right) {
-  const leftParts = parseVersion(left);
-  const rightParts = parseVersion(right);
-  const maxLength = Math.max(leftParts.length, rightParts.length);
-
-  for (let index = 0; index < maxLength; index += 1) {
-    const leftPart = leftParts[index] || 0;
-    const rightPart = rightParts[index] || 0;
-
-    if (leftPart !== rightPart) {
-      return leftPart - rightPart;
-    }
-  }
-
-  return 0;
-}
-
-describe('Rust Dockerfile', () => {
-  test('uses a Rust builder image that satisfies Cargo.toml rust-version', () => {
-    const cargoToml = readFileSync(
-      resolve(repoRoot, 'rust/Cargo.toml'),
-      'utf8'
-    );
-    const dockerfile = readFileSync(
-      resolve(repoRoot, 'rust/Dockerfile'),
-      'utf8'
-    );
-
-    const requiredRustVersion = cargoToml.match(
-      /^rust-version = "([^"]+)"/m
-    )?.[1];
-    const dockerRustVersion = dockerfile.match(
-      /^FROM rust:(\d+(?:\.\d+){1,2})[-\s]/m
-    )?.[1];
-
-    expect(requiredRustVersion).toBeDefined();
-    expect(dockerRustVersion).toBeDefined();
-    expect(
-      compareVersions(dockerRustVersion, requiredRustVersion)
-    ).toBeGreaterThanOrEqual(0);
-  });
-});

package/tests/ci/workflow-policy.test.js

@@ -1,79 +0,0 @@
-import { readFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const repoRoot = resolve(__dirname, '../../..');
-
-const workflowFiles = [
-  '.github/workflows/js.yml',
-  '.github/workflows/rust.yml',
-  '.github/workflows/parity.yml',
-];
-
-function readRootFile(relativePath) {
-  return readFileSync(resolve(repoRoot, relativePath), 'utf8');
-}
-
-function readWorkflow(relativePath) {
-  return readRootFile(relativePath);
-}
-
-describe('workflow policy', () => {
-  test.each(workflowFiles)(
-    '%s uses release-safe concurrency cancellation',
-    (workflowFile) => {
-      const workflow = readWorkflow(workflowFile);
-
-      expect(workflow).toContain(
-        "cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}"
-      );
-      expect(workflow).not.toContain(
-        "cancel-in-progress: ${{ github.ref == 'refs/heads/main' }}"
-      );
-    }
-  );
-
-  test.each(workflowFiles)(
-    '%s uses the current checkout action',
-    (workflowFile) => {
-      const workflow = readWorkflow(workflowFile);
-
-      expect(workflow).toContain('uses: actions/checkout@v6');
-      expect(workflow).not.toContain('uses: actions/checkout@v4');
-    }
-  );
-
-  test('Rust workflow uses the current cache action', () => {
-    const workflow = readWorkflow('.github/workflows/rust.yml');
-
-    expect(workflow).toContain('uses: actions/cache@v5');
-    expect(workflow).not.toContain('uses: actions/cache@v4');
-  });
-
-  test('parity check ignores repository-level CI tests', () => {
-    const parityScript = readRootFile('scripts/check-js-rust-parity.mjs');
-
-    expect(parityScript).toContain('"js/tests/ci/"');
-    expect(parityScript).toContain(
-      'matchingFiles(files, JS_PARITY_PATHS, JS_PARITY_IGNORE_PATHS)'
-    );
-  });
-});
-
-test('release workflows require dependency health gates', () => {
-  const js = readWorkflow('.github/workflows/js.yml');
-  expect(js).toContain('npm audit --package-lock-only --audit-level=moderate');
-  expect(js).toContain('check-dependency-freshness.mjs npm');
-  expect(js).toContain('needs: [lint, test, dependency-health]');
-  const rust = readWorkflow('.github/workflows/rust.yml');
-  expect(rust).toContain('check-dependency-freshness.mjs cargo');
-  expect(rust).toContain('cargo update --dry-run');
-  expect(rust).toContain('needs: [lint, test, build, dependency-health]');
-  for (const workflow of [js, rust]) {
-    expect(
-      workflow.match(/needs\.dependency-health\.result == 'success'/g)
-    ).toHaveLength(2);
-  }
-});

package/tests/e2e/docker.test.js

@@ -1,186 +0,0 @@
-import fetch from 'node-fetch';
-import http from 'http';
-import getPort from 'get-port';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
-const WAIT_FOR_READY = 10000; // ms
-const PORT = 3000; // Use the same port as in docker-compose.yml
-const baseUrl = `http://localhost:${PORT}`;
-
-const timings = {};
-let mockServer;
-let mockUrl;
-
-const MOCK_HTML = `<!DOCTYPE html>
-<html lang="en">
-<head><meta charset="utf-8"><title>Example Domain</title></head>
-<body><h1>Example Domain</h1><p>This domain is for use in illustrative examples.</p></body>
-</html>`;
-
-async function isServiceRunning() {
-  try {
-    const res = await fetch(`${baseUrl}/health`);
-    return res.status === 200;
-  } catch {
-    return false;
-  }
-}
-
-beforeAll(async () => {
-  timings.start = Date.now();
-
-  // Start a local mock server to avoid depending on external network
-  const mockPort = await getPort();
-  mockServer = http.createServer((req, res) => {
-    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-    res.end(MOCK_HTML);
-  });
-  await new Promise((resolve) =>
-    mockServer.listen(mockPort, '0.0.0.0', resolve)
-  );
-  // docker-compose.yml maps this hostname to the host gateway on Linux CI.
-  mockUrl = `http://host.docker.internal:${mockPort}`;
-
-  console.log('Checking if Docker service is already running...');
-  const alreadyRunning = await isServiceRunning();
-  if (!alreadyRunning) {
-    console.log('Service not running, starting Docker container...');
-    try {
-      const dockerStart = Date.now();
-      // Start the Docker container using docker compose (v2 command)
-      const { stdout, stderr } = await execAsync('docker compose up -d');
-      timings.dockerStartup = Date.now() - dockerStart;
-      console.log('Docker compose output:', stdout);
-      if (stderr) {
-        console.error('Docker compose errors:', stderr);
-      }
-
-      // Wait for the service to be ready
-      const readyStart = Date.now();
-      await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error('Docker service did not start in time'));
-        }, WAIT_FOR_READY);
-
-        const checkReady = async () => {
-          try {
-            console.log(`Checking if service is ready at ${baseUrl}...`);
-            const res = await fetch(`${baseUrl}/health`);
-            if (res.status === 200) {
-              console.log('Service is ready!');
-              clearTimeout(timeout);
-              resolve();
-            } else {
-              console.log(`Service not ready yet, status: ${res.status}`);
-              setTimeout(checkReady, 500);
-            }
-          } catch (err) {
-            console.log('Service not ready yet, error:', err.message);
-            setTimeout(checkReady, 500);
-          }
-        };
-        checkReady();
-      });
-      timings.serviceReady = Date.now() - readyStart;
-    } catch (error) {
-      console.error('Failed to start Docker container:', error);
-      throw error;
-    }
-    timings.beforeAll = Date.now() - timings.start;
-    console.log('Timing: Docker startup:', `${timings.dockerStartup}ms`);
-    console.log('Timing: Service readiness:', `${timings.serviceReady}ms`);
-    console.log('Timing: beforeAll total:', `${timings.beforeAll}ms`);
-  } else {
-    console.log('Docker service is already running. Skipping startup.');
-    timings.beforeAll = Date.now() - timings.start;
-    console.log(
-      'Timing: beforeAll (already running):',
-      `${timings.beforeAll}ms`
-    );
-  }
-}, 30000); // Reduced timeout for beforeAll
-
-afterAll(async () => {
-  if (mockServer) {
-    mockServer.close();
-  }
-  // Stop Docker containers
-  try {
-    await execAsync('docker compose down');
-  } catch {
-    // Ignore errors during cleanup
-  }
-});
-
-describe('E2E (Docker): Web Capture Microservice', () => {
-  it('should return HTML from /html endpoint', async () => {
-    const htmlStart = Date.now();
-    const res = await fetch(
-      `${baseUrl}/html?url=${encodeURIComponent(mockUrl)}`
-    );
-    expect(res.status).toBe(200);
-    const text = await res.text();
-    expect(text).toMatch(/<html/i);
-    timings.html = Date.now() - htmlStart;
-    console.log('Timing: /html endpoint:', `${timings.html}ms`);
-  }, 20000);
-
-  it('should return Markdown from /markdown endpoint', async () => {
-    const mdStart = Date.now();
-    const res = await fetch(
-      `${baseUrl}/markdown?url=${encodeURIComponent(mockUrl)}`
-    );
-    expect(res.status).toBe(200);
-    const text = await res.text();
-    expect(text).toMatch(/example/i);
-    timings.markdown = Date.now() - mdStart;
-    console.log('Timing: /markdown endpoint:', `${timings.markdown}ms`);
-  }, 20000);
-
-  it('should return PNG from /image endpoint', async () => {
-    const pngStart = Date.now();
-    const res = await fetch(
-      `${baseUrl}/image?url=${encodeURIComponent(mockUrl)}`
-    );
-    expect(res.status).toBe(200);
-    expect(res.headers.get('content-type')).toMatch(/^image\/png/);
-    const buf = Buffer.from(await res.arrayBuffer());
-    // PNG signature check
-    const pngSignature = Buffer.from([
-      0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
-    ]);
-    expect(buf.slice(0, 8)).toEqual(pngSignature);
-    expect(buf.length).toBeGreaterThan(100); // Should be a non-trivial PNG
-    timings.png = Date.now() - pngStart;
-    console.log('Timing: /image endpoint:', `${timings.png}ms`);
-  }, 60000);
-
-  it('should stream content from /stream endpoint', async () => {
-    const startTime = Date.now();
-    const res = await fetch(
-      `${baseUrl}/stream?url=${encodeURIComponent(mockUrl)}`
-    );
-    expect(res.status).toBe(200);
-    // Get the response as text
-    const text = await res.text();
-    expect(text).toMatch(/<html/i);
-    expect(text).toMatch(/Example Domain/i);
-    const endTime = Date.now();
-    console.log(`Timing: /stream endpoint: ${endTime - startTime}ms`);
-  }, 20000);
-
-  it('should return content from /fetch endpoint', async () => {
-    const startTime = Date.now();
-    const res = await fetch(
-      `${baseUrl}/fetch?url=${encodeURIComponent(mockUrl)}`
-    );
-    expect(res.status).toBe(200);
-    const text = await res.text();
-    expect(text).toMatch(/<html/i);
-    expect(text).toMatch(/Example Domain/i);
-    const endTime = Date.now();
-    console.log(`Timing: /fetch endpoint: ${endTime - startTime}ms`);
-  }, 20000);
-});

package/tests/e2e/process.test.js

@@ -1,215 +0,0 @@
-import { spawn } from 'child_process';
-import fetch from 'node-fetch';
-import getPort from 'get-port';
-import path from 'path';
-
-const WAIT_FOR_READY = 5000; // ms
-let serverProcess;
-let serverOutput = '';
-let baseUrl;
-let mockProcess;
-let mockUrl;
-
-const MOCK_HTML = `<!DOCTYPE html>
-<html lang="en">
-<head><meta charset="utf-8"><title>Example Domain</title></head>
-<body><h1>Example Domain</h1><p>This domain is for use in illustrative examples.</p></body>
-</html>`;
-
-beforeAll(async () => {
-  const mockPort = await getPort();
-  mockProcess = startMockServer(mockPort);
-  await waitForProcessOutput(mockProcess, 'mock fixture server listening');
-  mockUrl = `http://127.0.0.1:${mockPort}`;
-
-  const port = await getPort();
-  baseUrl = `http://127.0.0.1:${port}`;
-
-  serverProcess = spawn(
-    'node',
-    [path.resolve('bin/web-capture.js'), '--serve', '--port', port.toString()],
-    {
-      env: process.env,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    }
-  );
-  collectProcessOutput(serverProcess, (chunk) => {
-    serverOutput += chunk;
-  });
-
-  // Wait for the server to be ready (simple delay or poll)
-  await new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(new Error('Server did not start in time'));
-    }, WAIT_FOR_READY);
-
-    let serverStarted = false;
-    serverProcess.stdout.on('data', (data) => {
-      if (
-        data.toString().includes('listening') ||
-        data.toString().includes('Server running')
-      ) {
-        serverStarted = true;
-        clearTimeout(timeout);
-        resolve();
-      }
-    });
-
-    serverProcess.on('error', (error) => {
-      clearTimeout(timeout);
-      reject(error);
-    });
-
-    serverProcess.on('exit', (code, signal) => {
-      if (!serverStarted) {
-        clearTimeout(timeout);
-        reject(
-          new Error(`Server process exited with code ${code}, signal ${signal}`)
-        );
-      }
-    });
-
-    // Fallback: resolve after WAIT_FOR_READY
-    setTimeout(resolve, WAIT_FOR_READY);
-  });
-});
-
-afterAll(() => {
-  if (serverProcess) {
-    serverProcess.kill();
-  }
-  if (mockProcess) {
-    mockProcess.kill();
-  }
-});
-
-describe('E2E: Web Capture Microservice', () => {
-  it('should return HTML from /html endpoint', async () => {
-    const res = await fetch(
-      `${baseUrl}/html?url=${encodeURIComponent(mockUrl)}`
-    );
-    const text = await expectTextResponse(res);
-    expect(text).toMatch(/<html/i);
-  });
-
-  it('should return Markdown from /markdown endpoint', async () => {
-    const res = await fetch(
-      `${baseUrl}/markdown?url=${encodeURIComponent(mockUrl)}`
-    );
-    const text = await expectTextResponse(res);
-    expect(text).toMatch(/example/i);
-  });
-
-  it('should return PNG from /image endpoint', async () => {
-    const res = await fetch(
-      `${baseUrl}/image?url=${encodeURIComponent(mockUrl)}`
-    );
-    await expectStatusOk(res);
-    expect(res.headers.get('content-type')).toMatch(/^image\/png/);
-    const buf = Buffer.from(await res.arrayBuffer());
-    // PNG signature check
-    const pngSignature = Buffer.from([
-      0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
-    ]);
-    expect(buf.slice(0, 8)).toEqual(pngSignature);
-    expect(buf.length).toBeGreaterThan(100); // Should be a non-trivial PNG
-  }, 60000);
-
-  it('should stream content from /stream endpoint', async () => {
-    const res = await fetch(
-      `${baseUrl}/stream?url=${encodeURIComponent(mockUrl)}`
-    );
-    const text = await expectTextResponse(res);
-    expect(text).toMatch(/<html/i);
-    expect(text).toMatch(/Example Domain/i);
-  }, 20000);
-
-  it('should return content from /fetch endpoint', async () => {
-    const res = await fetch(
-      `${baseUrl}/fetch?url=${encodeURIComponent(mockUrl)}`
-    );
-    const text = await expectTextResponse(res);
-    expect(text).toMatch(/<html/i);
-    expect(text).toMatch(/Example Domain/i);
-  }, 20000);
-});
-
-function startMockServer(port) {
-  const script = `
-    const http = require('http');
-    const html = ${JSON.stringify(MOCK_HTML)};
-    const server = http.createServer((req, res) => {
-      res.writeHead(200, {
-        'Content-Type': 'text/html; charset=utf-8',
-        'Content-Length': Buffer.byteLength(html),
-      });
-      res.end(html);
-    });
-    server.listen(${port}, '127.0.0.1', () => {
-      console.log('mock fixture server listening');
-    });
-    process.on('SIGTERM', () => server.close(() => process.exit(0)));
-    process.on('SIGINT', () => server.close(() => process.exit(0)));
-  `;
-  return spawn('node', ['-e', script], {
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-}
-
-function collectProcessOutput(child, onChunk) {
-  child.stdout.on('data', (data) => onChunk(data.toString()));
-  child.stderr.on('data', (data) => onChunk(data.toString()));
-}
-
-async function waitForProcessOutput(child, expected) {
-  let output = '';
-  collectProcessOutput(child, (chunk) => {
-    output += chunk;
-  });
-  await new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(
-        new Error(`Timed out waiting for "${expected}". Output:\n${output}`)
-      );
-    }, WAIT_FOR_READY);
-    child.stdout.on('data', (data) => {
-      if (data.toString().includes(expected)) {
-        clearTimeout(timeout);
-        resolve();
-      }
-    });
-    child.on('exit', (code, signal) => {
-      clearTimeout(timeout);
-      reject(new Error(`Process exited with code ${code}, signal ${signal}`));
-    });
-  });
-}
-
-async function expectTextResponse(res) {
-  let text;
-  try {
-    text = await res.text();
-  } catch (error) {
-    throw new Error(
-      `${error.message}\nServer output:\n${serverOutput || '(empty)'}`,
-      { cause: error }
-    );
-  }
-  expectResponseStatus(res.status, text);
-  return text;
-}
-
-async function expectStatusOk(res) {
-  if (res.status === 200) {
-    return;
-  }
-  expectResponseStatus(res.status, await res.text());
-}
-
-function expectResponseStatus(status, body) {
-  if (status !== 200) {
-    throw new Error(
-      `Expected HTTP 200, received ${status}\nBody:\n${body}\nServer output:\n${serverOutput}`
-    );
-  }
-}

package/tests/fixtures/bold-coalesce-and-leakage.html

@@ -1,27 +0,0 @@
-<!doctype html>
-<html>
-  <body>
-    <!-- Symptom A: two adjacent bold spans -->
-    <p>
-      <span style="font-weight: 700">13.1 </span
-      ><span style="font-weight: 700">First subsection</span>
-    </p>
-
-    <!-- Symptom B: outer bold ends, inner bold begins, no separator -->
-    <ol>
-      <li><span style="font-weight: 700">Item header.</span></li>
-    </ol>
-    <p><span style="font-weight: 700">Note:</span> body text.</p>
-
-    <!-- Symptom C: bold range spans across <br> and <img> -->
-    <p>
-      <span style="font-weight: 700"
-        >Caption A:<img
-          alt=""
-          src="data:image/png;base64,iVBORw0KGgo=" /><br />Caption B:<img
-          alt=""
-          src="data:image/png;base64,iVBORw0KGgo="
-      /></span>
-    </p>
-  </body>
-</html>