@vellumai/assistant 0.4.17 → 0.4.19

package/src/__tests__/app-bundler.test.ts

@@ -1,81 +1,99 @@
-import { afterEach,beforeEach, describe, expect, mock, test } from 'bun:test';
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // Mock the logger before importing the module under test
-mock.module('../util/logger.js', () => ({
+mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
 }));
 
-import { extractRemoteUrls, materializeAssets } from '../bundler/app-bundler.js';
+import {
+  extractRemoteUrls,
+  materializeAssets,
+} from "../bundler/app-bundler.js";
 
 // ---------------------------------------------------------------------------
 // extractRemoteUrls
 // ---------------------------------------------------------------------------
 
-describe('extractRemoteUrls', () => {
-  test('extracts src attributes with double quotes', () => {
+describe("extractRemoteUrls", () => {
+  test("extracts src attributes with double quotes", () => {
     const html = '<img src="https://cdn.example.com/logo.png">';
-    expect(extractRemoteUrls(html)).toEqual(['https://cdn.example.com/logo.png']);
+    expect(extractRemoteUrls(html)).toEqual([
+      "https://cdn.example.com/logo.png",
+    ]);
   });
 
-  test('extracts src attributes with single quotes', () => {
+  test("extracts src attributes with single quotes", () => {
     const html = "<img src='https://cdn.example.com/logo.png'>";
-    expect(extractRemoteUrls(html)).toEqual(['https://cdn.example.com/logo.png']);
+    expect(extractRemoteUrls(html)).toEqual([
+      "https://cdn.example.com/logo.png",
+    ]);
   });
 
-  test('extracts unquoted src attributes', () => {
-    const html = '<img src=https://cdn.example.com/logo.png>';
-    expect(extractRemoteUrls(html)).toEqual(['https://cdn.example.com/logo.png']);
+  test("extracts unquoted src attributes", () => {
+    const html = "<img src=https://cdn.example.com/logo.png>";
+    expect(extractRemoteUrls(html)).toEqual([
+      "https://cdn.example.com/logo.png",
+    ]);
   });
 
-  test('extracts href attributes', () => {
-    const html = '<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto">';
+  test("extracts href attributes", () => {
+    const html =
+      '<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto">';
     expect(extractRemoteUrls(html)).toEqual([
-      'https://fonts.googleapis.com/css?family=Roboto',
+      "https://fonts.googleapis.com/css?family=Roboto",
     ]);
   });
 
-  test('extracts CSS url() references with double quotes', () => {
-    const html = '<div style="background: url(&quot;https://cdn.example.com/bg.jpg&quot;)"></div>';
+  test("extracts CSS url() references with double quotes", () => {
+    const html =
+      '<div style="background: url(&quot;https://cdn.example.com/bg.jpg&quot;)"></div>';
     // The regex matches url("...") literally, not HTML entities
     expect(extractRemoteUrls(html)).toEqual([]);
 
     // With actual quotes in a <style> block
-    const html2 = '<style>body { background: url("https://cdn.example.com/bg.jpg"); }</style>';
-    expect(extractRemoteUrls(html2)).toEqual(['https://cdn.example.com/bg.jpg']);
+    const html2 =
+      '<style>body { background: url("https://cdn.example.com/bg.jpg"); }</style>';
+    expect(extractRemoteUrls(html2)).toEqual([
+      "https://cdn.example.com/bg.jpg",
+    ]);
   });
 
-  test('extracts CSS url() references with single quotes', () => {
-    const html = "<style>body { background: url('https://cdn.example.com/bg.jpg'); }</style>";
-    expect(extractRemoteUrls(html)).toEqual(['https://cdn.example.com/bg.jpg']);
+  test("extracts CSS url() references with single quotes", () => {
+    const html =
+      "<style>body { background: url('https://cdn.example.com/bg.jpg'); }</style>";
+    expect(extractRemoteUrls(html)).toEqual(["https://cdn.example.com/bg.jpg"]);
   });
 
-  test('extracts CSS url() references without quotes', () => {
-    const html = '<style>body { background: url(https://cdn.example.com/bg.jpg); }</style>';
-    expect(extractRemoteUrls(html)).toEqual(['https://cdn.example.com/bg.jpg']);
+  test("extracts CSS url() references without quotes", () => {
+    const html =
+      "<style>body { background: url(https://cdn.example.com/bg.jpg); }</style>";
+    expect(extractRemoteUrls(html)).toEqual(["https://cdn.example.com/bg.jpg"]);
   });
 
-  test('ignores relative URLs', () => {
+  test("ignores relative URLs", () => {
     const html = '<img src="images/logo.png"><link href="./style.css">';
     expect(extractRemoteUrls(html)).toEqual([]);
   });
 
-  test('ignores data URIs', () => {
+  test("ignores data URIs", () => {
     const html = '<img src="data:image/png;base64,iVBORw0KGgo=">';
     expect(extractRemoteUrls(html)).toEqual([]);
   });
 
-  test('deduplicates identical URLs', () => {
+  test("deduplicates identical URLs", () => {
     const html = `
       <img src="https://cdn.example.com/logo.png">
       <img src="https://cdn.example.com/logo.png">
     `;
-    expect(extractRemoteUrls(html)).toEqual(['https://cdn.example.com/logo.png']);
+    expect(extractRemoteUrls(html)).toEqual([
+      "https://cdn.example.com/logo.png",
+    ]);
   });
 
-  test('extracts multiple different URLs', () => {
+  test("extracts multiple different URLs", () => {
     const html = `
       <img src="https://cdn.example.com/logo.png">
       <link href="https://fonts.example.com/style.css">
@@ -83,17 +101,17 @@ describe('extractRemoteUrls', () => {
     `;
     const urls = extractRemoteUrls(html);
     expect(urls).toHaveLength(3);
-    expect(urls).toContain('https://cdn.example.com/logo.png');
-    expect(urls).toContain('https://fonts.example.com/style.css');
-    expect(urls).toContain('https://cdn.example.com/app.js');
+    expect(urls).toContain("https://cdn.example.com/logo.png");
+    expect(urls).toContain("https://fonts.example.com/style.css");
+    expect(urls).toContain("https://cdn.example.com/app.js");
   });
 
-  test('returns empty array for HTML with no remote URLs', () => {
-    const html = '<html><body><p>Hello World</p></body></html>';
+  test("returns empty array for HTML with no remote URLs", () => {
+    const html = "<html><body><p>Hello World</p></body></html>";
     expect(extractRemoteUrls(html)).toEqual([]);
   });
 
-  test('handles mixed src, href, and url() in a single document', () => {
+  test("handles mixed src, href, and url() in a single document", () => {
     const html = `
       <link href="https://example.com/a.css">
       <img src="https://example.com/b.png">
@@ -103,9 +121,11 @@ describe('extractRemoteUrls', () => {
     expect(urls).toHaveLength(3);
   });
 
-  test('handles HTTP (not just HTTPS)', () => {
+  test("handles HTTP (not just HTTPS)", () => {
     const html = '<img src="http://cdn.example.com/legacy.png">';
-    expect(extractRemoteUrls(html)).toEqual(['http://cdn.example.com/legacy.png']);
+    expect(extractRemoteUrls(html)).toEqual([
+      "http://cdn.example.com/legacy.png",
+    ]);
   });
 });
 
@@ -113,7 +133,7 @@ describe('extractRemoteUrls', () => {
 // materializeAssets
 // ---------------------------------------------------------------------------
 
-describe('materializeAssets', () => {
+describe("materializeAssets", () => {
   let originalFetch: typeof globalThis.fetch;
 
   beforeEach(() => {
@@ -124,16 +144,16 @@ describe('materializeAssets', () => {
     globalThis.fetch = originalFetch;
   });
 
-  test('returns unchanged HTML when there are no remote URLs', async () => {
-    const html = '<html><body>No remote assets</body></html>';
+  test("returns unchanged HTML when there are no remote URLs", async () => {
+    const html = "<html><body>No remote assets</body></html>";
     const result = await materializeAssets(html);
     expect(result.rewrittenHtml).toBe(html);
     expect(result.assets).toEqual([]);
   });
 
-  test('fetches remote assets and rewrites URLs', async () => {
-    const imageUrl = 'https://cdn.example.com/image.png';
-    const imageData = Buffer.from('fake-image-data');
+  test("fetches remote assets and rewrites URLs", async () => {
+    const imageUrl = "https://cdn.example.com/image.png";
+    const imageData = Buffer.from("fake-image-data");
 
     globalThis.fetch = mock((url: string) => {
       if (url === imageUrl) {
@@ -147,19 +167,21 @@ describe('materializeAssets', () => {
 
     expect(result.rewrittenHtml).toBe('<img src="assets/e724846245db.png">');
     expect(result.assets).toHaveLength(1);
-    expect(result.assets[0].archivePath).toBe('assets/e724846245db.png');
+    expect(result.assets[0].archivePath).toBe("assets/e724846245db.png");
     expect(result.assets[0].data).toEqual(imageData);
   });
 
-  test('handles multiple distinct assets', async () => {
+  test("handles multiple distinct assets", async () => {
     const urls = [
-      'https://cdn.example.com/a.png',
-      'https://cdn.example.com/b.css',
-      'https://cdn.example.com/c.js',
+      "https://cdn.example.com/a.png",
+      "https://cdn.example.com/b.css",
+      "https://cdn.example.com/c.js",
     ];
 
     globalThis.fetch = mock((url: string) => {
-      return Promise.resolve(new Response(Buffer.from(`data-for-${url}`), { status: 200 }));
+      return Promise.resolve(
+        new Response(Buffer.from(`data-for-${url}`), { status: 200 }),
+      );
     }) as unknown as typeof fetch;
 
     const html = `
@@ -172,18 +194,20 @@ describe('materializeAssets', () => {
     expect(result.assets).toHaveLength(3);
 
     const expectedFilenames: Record<string, string> = {
-      'https://cdn.example.com/a.png': '6155f67efa62.png',
-      'https://cdn.example.com/b.css': '5e6d8d571910.css',
-      'https://cdn.example.com/c.js': '20fb1ea9b4c9.js',
+      "https://cdn.example.com/a.png": "6155f67efa62.png",
+      "https://cdn.example.com/b.css": "5e6d8d571910.css",
+      "https://cdn.example.com/c.js": "20fb1ea9b4c9.js",
     };
     for (const url of urls) {
-      expect(result.rewrittenHtml).toContain(`assets/${expectedFilenames[url]}`);
+      expect(result.rewrittenHtml).toContain(
+        `assets/${expectedFilenames[url]}`,
+      );
       expect(result.rewrittenHtml).not.toContain(url);
     }
   });
 
-  test('keeps original URL when fetch returns non-OK status', async () => {
-    const imageUrl = 'https://cdn.example.com/missing.png';
+  test("keeps original URL when fetch returns non-OK status", async () => {
+    const imageUrl = "https://cdn.example.com/missing.png";
 
     globalThis.fetch = mock(() => {
       return Promise.resolve(new Response(null, { status: 404 }));
@@ -196,11 +220,11 @@ describe('materializeAssets', () => {
     expect(result.assets).toEqual([]);
   });
 
-  test('keeps original URL when fetch throws (network error)', async () => {
-    const imageUrl = 'https://cdn.example.com/unreachable.png';
+  test("keeps original URL when fetch throws (network error)", async () => {
+    const imageUrl = "https://cdn.example.com/unreachable.png";
 
     globalThis.fetch = mock(() => {
-      return Promise.reject(new Error('Network error'));
+      return Promise.reject(new Error("Network error"));
     }) as unknown as typeof fetch;
 
     const html = `<img src="${imageUrl}">`;
@@ -210,13 +234,15 @@ describe('materializeAssets', () => {
     expect(result.assets).toEqual([]);
   });
 
-  test('partially succeeds: fetched assets are rewritten, failed ones remain', async () => {
-    const goodUrl = 'https://cdn.example.com/good.png';
-    const badUrl = 'https://cdn.example.com/bad.png';
+  test("partially succeeds: fetched assets are rewritten, failed ones remain", async () => {
+    const goodUrl = "https://cdn.example.com/good.png";
+    const badUrl = "https://cdn.example.com/bad.png";
 
     globalThis.fetch = mock((url: string) => {
       if (url === goodUrl) {
-        return Promise.resolve(new Response(Buffer.from('good-data'), { status: 200 }));
+        return Promise.resolve(
+          new Response(Buffer.from("good-data"), { status: 200 }),
+        );
       }
       return Promise.resolve(new Response(null, { status: 500 }));
     }) as unknown as typeof fetch;
@@ -224,18 +250,20 @@ describe('materializeAssets', () => {
     const html = `<img src="${goodUrl}"><img src="${badUrl}">`;
     const result = await materializeAssets(html);
 
-    expect(result.rewrittenHtml).toContain('assets/691e2a787421.png');
+    expect(result.rewrittenHtml).toContain("assets/691e2a787421.png");
     expect(result.rewrittenHtml).toContain(badUrl);
     expect(result.assets).toHaveLength(1);
   });
 
-  test('deduplicates same URL appearing multiple times in HTML', async () => {
-    const imageUrl = 'https://cdn.example.com/icon.png';
+  test("deduplicates same URL appearing multiple times in HTML", async () => {
+    const imageUrl = "https://cdn.example.com/icon.png";
     let fetchCount = 0;
 
     globalThis.fetch = mock(() => {
       fetchCount++;
-      return Promise.resolve(new Response(Buffer.from('icon-data'), { status: 200 }));
+      return Promise.resolve(
+        new Response(Buffer.from("icon-data"), { status: 200 }),
+      );
     }) as unknown as typeof fetch;
 
     const html = `<img src="${imageUrl}"><div style="background: url(${imageUrl})"></div>`;
@@ -251,13 +279,15 @@ describe('materializeAssets', () => {
     expect(matches).toHaveLength(2);
   });
 
-  test('preserves file extensions in asset filenames', async () => {
-    const pngUrl = 'https://cdn.example.com/image.png';
-    const cssUrl = 'https://cdn.example.com/style.css';
-    const noExtUrl = 'https://cdn.example.com/api/data';
+  test("preserves file extensions in asset filenames", async () => {
+    const pngUrl = "https://cdn.example.com/image.png";
+    const cssUrl = "https://cdn.example.com/style.css";
+    const noExtUrl = "https://cdn.example.com/api/data";
 
     globalThis.fetch = mock(() => {
-      return Promise.resolve(new Response(Buffer.from('data'), { status: 200 }));
+      return Promise.resolve(
+        new Response(Buffer.from("data"), { status: 200 }),
+      );
     }) as unknown as typeof fetch;
 
     const html = `<img src="${pngUrl}"><link href="${cssUrl}"><img src="${noExtUrl}">`;
@@ -265,10 +295,10 @@ describe('materializeAssets', () => {
 
     expect(result.assets).toHaveLength(3);
 
-    const pngAsset = result.assets.find((a) => a.archivePath.endsWith('.png'));
-    const cssAsset = result.assets.find((a) => a.archivePath.endsWith('.css'));
+    const pngAsset = result.assets.find((a) => a.archivePath.endsWith(".png"));
+    const cssAsset = result.assets.find((a) => a.archivePath.endsWith(".css"));
     const noExtAsset = result.assets.find(
-      (a) => !a.archivePath.endsWith('.png') && !a.archivePath.endsWith('.css'),
+      (a) => !a.archivePath.endsWith(".png") && !a.archivePath.endsWith(".css"),
     );
 
     expect(pngAsset).toBeDefined();
@@ -276,17 +306,20 @@ describe('materializeAssets', () => {
     expect(noExtAsset).toBeDefined();
   });
 
-  test('rewrites CSS url() references alongside src/href', async () => {
-    const cssUrl = 'https://cdn.example.com/bg.jpg';
+  test("rewrites CSS url() references alongside src/href", async () => {
+    const cssUrl = "https://cdn.example.com/bg.jpg";
 
     globalThis.fetch = mock(() => {
-      return Promise.resolve(new Response(Buffer.from('jpg-data'), { status: 200 }));
+      return Promise.resolve(
+        new Response(Buffer.from("jpg-data"), { status: 200 }),
+      );
     }) as unknown as typeof fetch;
 
-    const html = '<style>body { background: url("https://cdn.example.com/bg.jpg"); }</style>';
+    const html =
+      '<style>body { background: url("https://cdn.example.com/bg.jpg"); }</style>';
     const result = await materializeAssets(html);
 
-    expect(result.rewrittenHtml).toContain('assets/8550eecd4975.jpg');
+    expect(result.rewrittenHtml).toContain("assets/8550eecd4975.jpg");
     expect(result.rewrittenHtml).not.toContain(cssUrl);
   });
 });