gsd-pi 2.10.0 → 2.10.2

package/node_modules/@gsd/native/src/__tests__/glob.test.mjs

@@ -1,237 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import * as fs from "node:fs";
-import * as os from "node:os";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-
-// Load the native addon directly
-const addonDir = path.resolve(
-  __dirname,
-  "..",
-  "..",
-  "..",
-  "..",
-  "native",
-  "addon",
-);
-const platformTag = `${process.platform}-${process.arch}`;
-const candidates = [
-  path.join(addonDir, `gsd_engine.${platformTag}.node`),
-  path.join(addonDir, "gsd_engine.dev.node"),
-];
-
-let native;
-for (const candidate of candidates) {
-  try {
-    native = require(candidate);
-    break;
-  } catch {
-    // try next
-  }
-}
-
-if (!native) {
-  console.error(
-    "Native addon not found. Run `npm run build:native -w @gsd/native` first.",
-  );
-  process.exit(1);
-}
-
-describe("native glob: glob()", () => {
-  test("finds files matching a pattern", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "file1.ts"), "const a = 1;");
-    fs.writeFileSync(path.join(tmpDir, "file2.ts"), "const b = 2;");
-    fs.writeFileSync(path.join(tmpDir, "file3.js"), "const c = 3;");
-
-    const result = await native.glob({ pattern: "*.ts", path: tmpDir });
-
-    assert.equal(result.totalMatches, 2);
-    assert.equal(result.matches.length, 2);
-    const paths = result.matches.map((m) => m.path).sort();
-    assert.deepEqual(paths, ["file1.ts", "file2.ts"]);
-  });
-
-  test("recursive matching into subdirectories", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.mkdirSync(path.join(tmpDir, "src"));
-    fs.mkdirSync(path.join(tmpDir, "src", "nested"));
-    fs.writeFileSync(path.join(tmpDir, "root.ts"), "");
-    fs.writeFileSync(path.join(tmpDir, "src", "a.ts"), "");
-    fs.writeFileSync(path.join(tmpDir, "src", "nested", "b.ts"), "");
-
-    const result = await native.glob({ pattern: "*.ts", path: tmpDir });
-
-    assert.equal(result.totalMatches, 3);
-    const paths = result.matches.map((m) => m.path).sort();
-    assert.ok(paths.includes("root.ts"));
-    assert.ok(paths.includes("src/a.ts"));
-    assert.ok(paths.includes("src/nested/b.ts"));
-  });
-
-  test("respects maxResults limit", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    for (let i = 0; i < 10; i++) {
-      fs.writeFileSync(path.join(tmpDir, `file${i}.txt`), "");
-    }
-
-    const result = await native.glob({
-      pattern: "*.txt",
-      path: tmpDir,
-      maxResults: 3,
-    });
-
-    assert.equal(result.matches.length, 3);
-    assert.equal(result.totalMatches, 3);
-  });
-
-  test("filters by file type (directories only)", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.mkdirSync(path.join(tmpDir, "dir1"));
-    fs.mkdirSync(path.join(tmpDir, "dir2"));
-    fs.writeFileSync(path.join(tmpDir, "file.txt"), "");
-
-    const result = await native.glob({
-      pattern: "*",
-      path: tmpDir,
-      recursive: false,
-      fileType: 2, // Dir
-    });
-
-    assert.equal(result.totalMatches, 2);
-    const paths = result.matches.map((m) => m.path).sort();
-    assert.deepEqual(paths, ["dir1", "dir2"]);
-  });
-
-  test("respects .gitignore", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    // Init a git repo so .gitignore is respected
-    fs.mkdirSync(path.join(tmpDir, ".git"));
-    fs.writeFileSync(path.join(tmpDir, ".gitignore"), "ignored.txt\n");
-    fs.writeFileSync(path.join(tmpDir, "kept.txt"), "");
-    fs.writeFileSync(path.join(tmpDir, "ignored.txt"), "");
-
-    const result = await native.glob({
-      pattern: "*.txt",
-      path: tmpDir,
-      gitignore: true,
-    });
-
-    assert.equal(result.totalMatches, 1);
-    assert.equal(result.matches[0].path, "kept.txt");
-  });
-
-  test("includes gitignored files when gitignore=false", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.mkdirSync(path.join(tmpDir, ".git"));
-    fs.writeFileSync(path.join(tmpDir, ".gitignore"), "ignored.txt\n");
-    fs.writeFileSync(path.join(tmpDir, "kept.txt"), "");
-    fs.writeFileSync(path.join(tmpDir, "ignored.txt"), "");
-
-    const result = await native.glob({
-      pattern: "*.txt",
-      path: tmpDir,
-      gitignore: false,
-    });
-
-    assert.equal(result.totalMatches, 2);
-  });
-
-  test("skips node_modules by default", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.mkdirSync(path.join(tmpDir, "node_modules"));
-    fs.writeFileSync(path.join(tmpDir, "node_modules", "dep.js"), "");
-    fs.writeFileSync(path.join(tmpDir, "app.js"), "");
-
-    const result = await native.glob({
-      pattern: "*.js",
-      path: tmpDir,
-      gitignore: false,
-    });
-
-    assert.equal(result.totalMatches, 1);
-    assert.equal(result.matches[0].path, "app.js");
-  });
-
-  test("sortByMtime returns most recent first", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "old.txt"), "old");
-    // Ensure different mtime
-    const now = new Date();
-    fs.utimesSync(
-      path.join(tmpDir, "old.txt"),
-      new Date(now.getTime() - 5000),
-      new Date(now.getTime() - 5000),
-    );
-    fs.writeFileSync(path.join(tmpDir, "new.txt"), "new");
-
-    const result = await native.glob({
-      pattern: "*.txt",
-      path: tmpDir,
-      sortByMtime: true,
-    });
-
-    assert.equal(result.totalMatches, 2);
-    assert.equal(result.matches[0].path, "new.txt");
-    assert.equal(result.matches[1].path, "old.txt");
-  });
-
-  test("errors on non-existent path", async () => {
-    await assert.rejects(
-      () =>
-        native.glob({
-          pattern: "*.txt",
-          path: "/nonexistent/path/that/does/not/exist",
-        }),
-      /Path not found/,
-    );
-  });
-
-  test("returns mtime for each entry", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "test.txt"), "content");
-
-    const result = await native.glob({ pattern: "*.txt", path: tmpDir });
-
-    assert.equal(result.matches.length, 1);
-    assert.ok(typeof result.matches[0].mtime === "number");
-    // mtime should be within the last minute
-    const oneMinuteAgo = Date.now() - 60_000;
-    assert.ok(result.matches[0].mtime > oneMinuteAgo);
-  });
-});
-
-describe("native glob: invalidateFsScanCache()", () => {
-  test("can be called with a path", () => {
-    // Should not throw
-    native.invalidateFsScanCache("/tmp");
-  });
-
-  test("can be called without arguments", () => {
-    // Should not throw
-    native.invalidateFsScanCache();
-  });
-});

package/node_modules/@gsd/native/src/__tests__/grep.test.mjs

@@ -1,162 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import * as fs from "node:fs";
-import * as os from "node:os";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-
-// Load the native addon directly
-const addonDir = path.resolve(__dirname, "..", "..", "..", "..", "native", "addon");
-const platformTag = `${process.platform}-${process.arch}`;
-const candidates = [
-  path.join(addonDir, `gsd_engine.${platformTag}.node`),
-  path.join(addonDir, "gsd_engine.dev.node"),
-];
-
-let native;
-for (const candidate of candidates) {
-  try {
-    native = require(candidate);
-    break;
-  } catch {
-    // try next
-  }
-}
-
-if (!native) {
-  console.error("Native addon not found. Run `npm run build:native -w @gsd/native` first.");
-  process.exit(1);
-}
-
-describe("native grep: search()", () => {
-  test("finds matches in buffer content", () => {
-    const content = Buffer.from("hello world\nfoo bar\nhello rust\n");
-    const result = native.search(content, { pattern: "hello" });
-
-    assert.equal(result.matchCount, 2);
-    assert.equal(result.matches.length, 2);
-    assert.equal(result.matches[0].line, "hello world");
-    assert.equal(result.matches[0].lineNumber, 1);
-    assert.equal(result.matches[1].line, "hello rust");
-    assert.equal(result.matches[1].lineNumber, 3);
-    assert.equal(result.limitReached, false);
-  });
-
-  test("supports case-insensitive search", () => {
-    const content = Buffer.from("Hello World\nhello world\nHELLO\n");
-    const result = native.search(content, {
-      pattern: "hello",
-      ignoreCase: true,
-    });
-
-    assert.equal(result.matchCount, 3);
-  });
-
-  test("respects maxCount limit", () => {
-    const content = Buffer.from("aaa\naaa\naaa\naaa\n");
-    const result = native.search(content, {
-      pattern: "aaa",
-      maxCount: 2,
-    });
-
-    assert.equal(result.matches.length, 2);
-    assert.equal(result.limitReached, true);
-  });
-
-  test("returns context lines", () => {
-    const content = Buffer.from("line1\nline2\nmatch_here\nline4\nline5\n");
-    const result = native.search(content, {
-      pattern: "match_here",
-      contextBefore: 1,
-      contextAfter: 1,
-    });
-
-    assert.equal(result.matches.length, 1);
-    assert.equal(result.matches[0].contextBefore.length, 1);
-    assert.equal(result.matches[0].contextBefore[0].line, "line2");
-    assert.equal(result.matches[0].contextAfter.length, 1);
-    assert.equal(result.matches[0].contextAfter[0].line, "line4");
-  });
-
-  test("throws on invalid regex", () => {
-    const content = Buffer.from("hello");
-    assert.throws(() => {
-      native.search(content, { pattern: "[invalid" });
-    });
-  });
-});
-
-describe("native grep: grep()", () => {
-  let tmpDir;
-
-  test("searches files on disk", (t) => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-grep-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "file1.txt"), "hello world\nfoo bar\n");
-    fs.writeFileSync(path.join(tmpDir, "file2.txt"), "hello rust\nbaz qux\n");
-    fs.writeFileSync(path.join(tmpDir, "file3.log"), "no match here\n");
-
-    const result = native.grep({
-      pattern: "hello",
-      path: tmpDir,
-    });
-
-    assert.equal(result.totalMatches, 2);
-    assert.equal(result.filesWithMatches, 2);
-    assert.equal(result.matches.length, 2);
-
-    // Matches should be sorted by file path
-    const paths = result.matches.map((m) => m.path);
-    assert.deepEqual(paths, [...paths].sort());
-  });
-
-  test("respects glob filter", (t) => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-grep-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "code.ts"), "hello typescript\n");
-    fs.writeFileSync(path.join(tmpDir, "code.js"), "hello javascript\n");
-    fs.writeFileSync(path.join(tmpDir, "readme.md"), "hello markdown\n");
-
-    const result = native.grep({
-      pattern: "hello",
-      path: tmpDir,
-      glob: "*.ts",
-    });
-
-    assert.equal(result.totalMatches, 1);
-    assert.equal(result.matches[0].line, "hello typescript");
-  });
-
-  test("respects maxCount", (t) => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-grep-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    for (let i = 0; i < 10; i++) {
-      fs.writeFileSync(path.join(tmpDir, `file${i}.txt`), "match_me\n");
-    }
-
-    const result = native.grep({
-      pattern: "match_me",
-      path: tmpDir,
-      maxCount: 3,
-    });
-
-    assert.ok(result.matches.length <= 3);
-    assert.equal(result.limitReached, true);
-  });
-
-  test("errors on non-existent path", () => {
-    assert.throws(() => {
-      native.grep({
-        pattern: "test",
-        path: "/nonexistent/path/that/does/not/exist",
-      });
-    });
-  });
-});

package/node_modules/@gsd/native/src/__tests__/highlight.test.mjs

@@ -1,156 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-
-// Load the native addon directly
-const addonDir = path.resolve(__dirname, "..", "..", "..", "..", "native", "addon");
-const platformTag = `${process.platform}-${process.arch}`;
-const candidates = [
-  path.join(addonDir, `gsd_engine.${platformTag}.node`),
-  path.join(addonDir, "gsd_engine.dev.node"),
-];
-
-let native;
-for (const candidate of candidates) {
-  try {
-    native = require(candidate);
-    break;
-  } catch {
-    // try next
-  }
-}
-
-if (!native) {
-  console.error("Native addon not found. Run `npm run build:native -w @gsd/native` first.");
-  process.exit(1);
-}
-
-const testColors = {
-  comment: "\x1b[38;2;106;153;85m",
-  keyword: "\x1b[38;2;197;134;192m",
-  function: "\x1b[38;2;220;220;170m",
-  variable: "\x1b[38;2;156;220;254m",
-  string: "\x1b[38;2;206;145;120m",
-  number: "\x1b[38;2;181;206;168m",
-  type: "\x1b[38;2;78;201;176m",
-  operator: "\x1b[38;2;212;212;212m",
-  punctuation: "\x1b[38;2;212;212;212m",
-};
-
-describe("native highlight: highlightCode()", () => {
-  test("highlights JavaScript code with ANSI colors", () => {
-    const code = 'const x = 42;\n';
-    const result = native.highlightCode(code, "javascript", testColors);
-
-    // Result should contain ANSI escape sequences
-    assert.ok(result.includes("\x1b["), "should contain ANSI escape codes");
-    // Result should contain the original tokens
-    assert.ok(result.includes("const"), "should contain 'const'");
-    assert.ok(result.includes("42"), "should contain '42'");
-    // Reset codes should be present
-    assert.ok(result.includes("\x1b[39m"), "should contain ANSI reset codes");
-  });
-
-  test("returns unhighlighted code for unknown language", () => {
-    const code = "some random text\n";
-    const result = native.highlightCode(code, "nonexistent_lang_xyz", testColors);
-
-    // Plain text syntax should pass through without color codes on plain content
-    assert.ok(typeof result === "string");
-    assert.ok(result.includes("some random text"));
-  });
-
-  test("handles null language gracefully", () => {
-    const code = "hello world\n";
-    const result = native.highlightCode(code, null, testColors);
-
-    assert.ok(typeof result === "string");
-    assert.ok(result.includes("hello world"));
-  });
-
-  test("handles empty code", () => {
-    const result = native.highlightCode("", "javascript", testColors);
-    assert.equal(result, "");
-  });
-
-  test("handles multiline code", () => {
-    const code = 'function foo() {\n  return "bar";\n}\n';
-    const result = native.highlightCode(code, "javascript", testColors);
-
-    assert.ok(result.includes("function"));
-    assert.ok(result.includes("foo"));
-    assert.ok(result.includes("return"));
-    assert.ok(result.includes("bar"));
-  });
-
-  test("supports optional inserted/deleted colors", () => {
-    const colorsWithDiff = {
-      ...testColors,
-      inserted: "\x1b[38;2;0;255;0m",
-      deleted: "\x1b[38;2;255;0;0m",
-    };
-    const code = "+added line\n-removed line\n";
-    const result = native.highlightCode(code, "diff", colorsWithDiff);
-
-    assert.ok(typeof result === "string");
-    assert.ok(result.length > 0);
-  });
-});
-
-describe("native highlight: supportsLanguage()", () => {
-  test("returns true for known aliases", () => {
-    assert.ok(native.supportsLanguage("javascript"));
-    assert.ok(native.supportsLanguage("typescript"));
-    assert.ok(native.supportsLanguage("python"));
-    assert.ok(native.supportsLanguage("rust"));
-    assert.ok(native.supportsLanguage("go"));
-    assert.ok(native.supportsLanguage("bash"));
-  });
-
-  test("returns true case-insensitively", () => {
-    assert.ok(native.supportsLanguage("JavaScript"));
-    assert.ok(native.supportsLanguage("PYTHON"));
-    assert.ok(native.supportsLanguage("Rust"));
-  });
-
-  test("returns true for short aliases", () => {
-    assert.ok(native.supportsLanguage("ts"));
-    assert.ok(native.supportsLanguage("py"));
-    assert.ok(native.supportsLanguage("rs"));
-    assert.ok(native.supportsLanguage("rb"));
-    assert.ok(native.supportsLanguage("sh"));
-  });
-
-  test("returns false for completely unknown languages", () => {
-    assert.equal(native.supportsLanguage("nonexistent_lang_xyz"), false);
-  });
-});
-
-describe("native highlight: getSupportedLanguages()", () => {
-  test("returns an array of language names", () => {
-    const langs = native.getSupportedLanguages();
-    assert.ok(Array.isArray(langs));
-    assert.ok(langs.length > 0, "should have at least one language");
-  });
-
-  test("includes common languages", () => {
-    const langs = native.getSupportedLanguages();
-    // These are syntect default syntax names
-    assert.ok(langs.includes("JavaScript"), "should include JavaScript");
-    assert.ok(langs.includes("Python"), "should include Python");
-    assert.ok(langs.includes("Rust"), "should include Rust");
-    assert.ok(langs.includes("C"), "should include C");
-  });
-
-  test("returns strings", () => {
-    const langs = native.getSupportedLanguages();
-    for (const lang of langs) {
-      assert.equal(typeof lang, "string");
-    }
-  });
-});

package/node_modules/@gsd/native/src/__tests__/html.test.mjs

@@ -1,98 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-
-const addonDir = path.resolve(__dirname, "..", "..", "..", "..", "native", "addon");
-const platformTag = `${process.platform}-${process.arch}`;
-const candidates = [
-  path.join(addonDir, `gsd_engine.${platformTag}.node`),
-  path.join(addonDir, "gsd_engine.dev.node"),
-];
-
-let native;
-for (const candidate of candidates) {
-  try {
-    native = require(candidate);
-    break;
-  } catch {
-    // try next
-  }
-}
-
-if (!native) {
-  console.error("Native addon not found. Run `npm run build:native -w @gsd/native` first.");
-  process.exit(1);
-}
-
-describe("native html: htmlToMarkdown()", () => {
-  test("converts basic HTML to markdown", () => {
-    const html = "<h1>Hello</h1><p>World</p>";
-    const result = native.htmlToMarkdown(html);
-    assert.ok(result.includes("Hello"), "Should contain heading text");
-    assert.ok(result.includes("World"), "Should contain paragraph text");
-  });
-
-  test("converts links to markdown links", () => {
-    const html = '<p>Visit <a href="https://example.com">Example</a></p>';
-    const result = native.htmlToMarkdown(html);
-    assert.ok(result.includes("[Example]"), "Should contain markdown link text");
-    assert.ok(result.includes("(https://example.com)"), "Should contain markdown link URL");
-  });
-
-  test("converts lists to markdown", () => {
-    const html = "<ul><li>First</li><li>Second</li><li>Third</li></ul>";
-    const result = native.htmlToMarkdown(html);
-    assert.ok(result.includes("First"), "Should contain first item");
-    assert.ok(result.includes("Second"), "Should contain second item");
-    assert.ok(result.includes("Third"), "Should contain third item");
-  });
-
-  test("converts bold and italic", () => {
-    const html = "<p><strong>bold</strong> and <em>italic</em></p>";
-    const result = native.htmlToMarkdown(html);
-    assert.ok(result.includes("**bold**") || result.includes("__bold__"), "Should contain bold");
-    assert.ok(result.includes("*italic*") || result.includes("_italic_"), "Should contain italic");
-  });
-
-  test("handles empty HTML", () => {
-    const result = native.htmlToMarkdown("");
-    assert.equal(typeof result, "string");
-  });
-
-  test("handles plain text", () => {
-    const result = native.htmlToMarkdown("Just plain text");
-    assert.ok(result.includes("Just plain text"), "Should preserve plain text");
-  });
-
-  test("accepts skipImages option", () => {
-    const html = '<h1>Title</h1><p>Content with <img src="photo.jpg" alt="photo"> image</p>';
-    const result = native.htmlToMarkdown(html, { skipImages: true });
-    assert.ok(result.includes("Title"), "Should contain heading");
-    assert.ok(result.includes("Content"), "Should contain paragraph text");
-  });
-
-  test("accepts cleanContent option", () => {
-    const html = '<nav><a href="/home">Home</a></nav><main><h1>Article</h1><p>Body text.</p></main><footer>Copyright</footer>';
-    const result = native.htmlToMarkdown(html, { cleanContent: true });
-    assert.ok(result.includes("Article") || result.includes("Body text"), "Should contain main content");
-  });
-
-  test("converts code blocks", () => {
-    const html = "<pre><code>const x = 1;</code></pre>";
-    const result = native.htmlToMarkdown(html);
-    assert.ok(result.includes("const x = 1;"), "Should contain code content");
-  });
-
-  test("converts complex nested HTML", () => {
-    const html = '<div><h2>Section</h2><p>Text with <a href="https://example.com"><strong>bold link</strong></a>.</p><ul><li>Item one</li><li>Item two</li></ul></div>';
-    const result = native.htmlToMarkdown(html);
-    assert.ok(result.includes("Section"), "Should contain heading");
-    assert.ok(result.includes("example.com"), "Should contain link");
-    assert.ok(result.includes("one"), "Should contain list items");
-  });
-});