@symbiosis-lab/moss-plugin-matters 1.4.2

package/src/__tests__/syndication.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  addCanonicalLinkToContent,
+  getArticleContent,
+  isArticleLive,
+} from "../main";
+import type { ArticleInfo } from "../types";
+
+describe("addCanonicalLinkToContent", () => {
+  const canonicalUrl = "https://example.com/posts/hello/";
+
+  it("appends markdown canonical link for markdown content", () => {
+    const result = addCanonicalLinkToContent("# Hello\n\nContent.", canonicalUrl, false);
+    expect(result).toContain("---");
+    expect(result).toContain(`[Original link](${canonicalUrl})`);
+    expect(result).not.toContain("<hr>");
+  });
+
+  it("appends HTML canonical link for HTML content", () => {
+    const result = addCanonicalLinkToContent("<h1>Hello</h1><p>Content.</p>", canonicalUrl, true);
+    expect(result).toContain("<hr>");
+    expect(result).toContain(`<a href="${canonicalUrl}">Original link</a>`);
+    expect(result).not.toContain("---\n");
+  });
+
+  it("defaults to markdown mode when isHtml is omitted", () => {
+    const result = addCanonicalLinkToContent("# Hello", canonicalUrl);
+    expect(result).toContain("---");
+    expect(result).not.toContain("<hr>");
+  });
+});
+
+describe("getArticleContent", () => {
+  const baseArticle: ArticleInfo = {
+    source_path: "posts/test.md",
+    title: "Test",
+    content: "# Test\n\nMarkdown content.",
+    frontmatter: {},
+    url_path: "posts/test/",
+    tags: [],
+  };
+
+  it("returns html_content when available", () => {
+    const article: ArticleInfo = {
+      ...baseArticle,
+      html_content: "<h1>Test</h1>\n<p>Markdown content.</p>",
+    };
+    const result = getArticleContent(article);
+    expect(result.content).toBe("<h1>Test</h1>\n<p>Markdown content.</p>");
+    expect(result.isHtml).toBe(true);
+  });
+
+  it("falls back to markdown content when html_content is undefined", () => {
+    const result = getArticleContent(baseArticle);
+    expect(result.content).toBe("# Test\n\nMarkdown content.");
+    expect(result.isHtml).toBe(false);
+  });
+
+  it("falls back to markdown content when html_content is empty string", () => {
+    const article: ArticleInfo = {
+      ...baseArticle,
+      html_content: "",
+    };
+    const result = getArticleContent(article);
+    expect(result.content).toBe("# Test\n\nMarkdown content.");
+    expect(result.isHtml).toBe(false);
+  });
+});
+
+describe("isArticleLive", () => {
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    globalThis.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it("returns true when article URL responds with 200", async () => {
+    vi.mocked(globalThis.fetch).mockResolvedValueOnce({ ok: true } as Response);
+
+    const result = await isArticleLive("https://guoliu.github.io", "writings/reviews/tools-for-thought/");
+    expect(result).toBe(true);
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      "https://guoliu.github.io/writings/reviews/tools-for-thought/",
+      { method: "HEAD" }
+    );
+  });
+
+  it("returns false when article URL responds with 404", async () => {
+    vi.mocked(globalThis.fetch).mockResolvedValueOnce({ ok: false, status: 404 } as Response);
+
+    const result = await isArticleLive("https://guoliu.github.io", "writings/reviews/new-article/");
+    expect(result).toBe(false);
+  });
+
+  it("returns false when fetch throws (network error)", async () => {
+    vi.mocked(globalThis.fetch).mockRejectedValueOnce(new Error("Network error"));
+
+    const result = await isArticleLive("https://guoliu.github.io", "writings/reviews/new-article/");
+    expect(result).toBe(false);
+  });
+
+  it("handles trailing slash on siteUrl and leading slash on articlePath", async () => {
+    vi.mocked(globalThis.fetch).mockResolvedValueOnce({ ok: true } as Response);
+
+    await isArticleLive("https://guoliu.github.io/", "/writings/reviews/test/");
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      "https://guoliu.github.io/writings/reviews/test/",
+      { method: "HEAD" }
+    );
+  });
+
+  it("handles siteUrl without trailing slash and articlePath without leading slash", async () => {
+    vi.mocked(globalThis.fetch).mockResolvedValueOnce({ ok: true } as Response);
+
+    await isArticleLive("https://guoliu.github.io", "writings/reviews/test/");
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      "https://guoliu.github.io/writings/reviews/test/",
+      { method: "HEAD" }
+    );
+  });
+});

package/src/__tests__/test-profile-escape.test.ts

@@ -0,0 +1,209 @@
+/**
+ * Tests for the MOSS_MATTERS_TEST_PROFILE escape hatch (T8a, 2026-05-28).
+ *
+ * Verifies both layers of the escape hatch:
+ *   1. API layer: apiConfig.queryMode flips to "user" and apiConfig.testUserName
+ *      is set to the profile (strips leading @).
+ *   2. UI layer: when the env var is set, the process hook auto-binds to the
+ *      test profile without prompting login and without calling openBrowser.
+ *
+ * Both layers must work together for the e2e harness — an API-only flip
+ * leaves the auth webview visible (per dispatch plan).
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mockGetPluginEnvVar = vi.fn();
+const mockOpenBrowser = vi.fn();
+const mockGetConfig = vi.fn();
+const mockSaveConfig = vi.fn().mockResolvedValue(undefined);
+const mockDetectBoundUser = vi.fn();
+const mockFetchUserProfile = vi.fn();
+const mockSyncToLocalFiles = vi.fn();
+
+vi.mock("@symbiosis-lab/moss-api", () => ({
+  getPluginCookie: vi.fn(),
+  setPluginCookie: vi.fn(),
+  httpPost: vi.fn(),
+  httpGet: vi.fn(),
+  fetchUrl: vi.fn(),
+  downloadAsset: vi.fn(),
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+  listFiles: vi.fn().mockResolvedValue([]),
+  showToast: vi.fn().mockResolvedValue(undefined),
+  openBrowser: (...args: unknown[]) => mockOpenBrowser(...args),
+  closeBrowser: vi.fn().mockResolvedValue(undefined),
+  readPluginFile: vi.fn(),
+  writePluginFile: vi.fn().mockResolvedValue(undefined),
+  pluginFileExists: vi.fn().mockResolvedValue(false),
+  getPluginEnvVar: (...args: unknown[]) => mockGetPluginEnvVar(...args),
+  // clearPluginCookies — called by promptLogin() before opening the browser.
+  clearPluginCookies: vi.fn().mockResolvedValue(undefined),
+  // setMessageContext is called at module load by utils.ts — stub it.
+  setMessageContext: vi.fn(),
+  sendMessage: vi.fn().mockResolvedValue(undefined),
+  reportError: vi.fn().mockResolvedValue(undefined),
+  reportComplete: vi.fn().mockResolvedValue(undefined),
+  startTask: vi.fn().mockResolvedValue({
+    id: "0",
+    progress: vi.fn().mockResolvedValue(undefined),
+    awaiting: vi.fn().mockResolvedValue(undefined),
+    succeeded: vi.fn().mockResolvedValue(undefined),
+    failed: vi.fn().mockResolvedValue(undefined),
+    cancelled: vi.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+vi.mock("../config", () => ({
+  getConfig: (...args: unknown[]) => mockGetConfig(...args),
+  saveConfig: (...args: unknown[]) => mockSaveConfig(...args),
+}));
+
+vi.mock("../sync", () => ({
+  detectBoundUser: (...args: unknown[]) => mockDetectBoundUser(...args),
+  syncToLocalFiles: (...args: unknown[]) => mockSyncToLocalFiles(...args),
+  scanLocalArticles: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock("../credential", () => ({
+  clearTokenCache: vi.fn(),
+  loadStoredToken: vi.fn().mockResolvedValue(null),
+  saveStoredToken: vi.fn().mockResolvedValue(undefined),
+  clearStoredToken: vi.fn().mockResolvedValue(undefined),
+  getSessionState: vi.fn().mockResolvedValue("none"),
+  shouldNudgeSessionExpired: vi.fn().mockResolvedValue(false),
+  markSessionInvalidated: vi.fn().mockResolvedValue(undefined),
+  authHeaderToken: vi.fn().mockResolvedValue(""),
+  captureLogin: vi.fn().mockResolvedValue(""),
+  prepareWebviewAuth: vi.fn().mockResolvedValue(undefined),
+  beginFreshLogin: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("../api", async () => {
+  const actual = await vi.importActual<typeof import("../api")>("../api");
+  return {
+    ...actual,
+    fetchAllArticlesSince: vi.fn().mockResolvedValue({ articles: [], userName: "guo" }),
+    fetchAllDraftsSince: vi.fn().mockResolvedValue([]),
+    fetchAllCollections: vi.fn().mockResolvedValue([]),
+    fetchUserProfile: (...args: unknown[]) => mockFetchUserProfile(...args),
+    fetchArticleComments: vi.fn().mockResolvedValue([]),
+    fetchAllArticleCommentCounts: vi.fn().mockResolvedValue(new Map()),
+    createDraft: vi.fn(),
+    fetchDraft: vi.fn(),
+    uploadCoverByUrl: vi.fn(),
+    uploadEmbedByUrl: vi.fn(),
+  };
+});
+
+vi.mock("../downloader", () => ({
+  downloadMediaAndUpdate: vi.fn().mockResolvedValue({ downloads: 0, updates: 0 }),
+  rewriteAllInternalLinks: vi.fn().mockResolvedValue(0),
+}));
+
+vi.mock("../social", () => ({
+  loadSocialData: vi.fn().mockResolvedValue({ articles: [] }),
+  saveSocialData: vi.fn().mockResolvedValue(undefined),
+  mergeSocialData: vi.fn().mockReturnValue({ articles: [] }),
+}));
+
+vi.mock("../domain", async () => {
+  const actual = await vi.importActual<typeof import("../domain")>("../domain");
+  return {
+    ...actual,
+    initializeDomain: vi.fn().mockResolvedValue(undefined),
+  };
+});
+
+describe("MOSS_MATTERS_TEST_PROFILE escape hatch", () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    vi.resetModules();
+    mockGetConfig.mockResolvedValue({});
+    // Ensure auth-check route reads as "unauth + saved userName" so the
+    // process hook progresses past Phase 1 without prompting login again.
+    mockDetectBoundUser.mockResolvedValue(null);
+    // apiConfig is a module singleton — reset its escape-hatch fields so
+    // a prior test that flipped queryMode doesn't leak into the next.
+    const { apiConfig } = await import("../api");
+    apiConfig.queryMode = "viewer";
+    apiConfig.testUserName = "Matty";
+  });
+
+  it("API layer: flips apiConfig.queryMode to 'user' when env var is set", async () => {
+    mockGetPluginEnvVar.mockResolvedValue("@guo");
+
+    // Fresh import so module-level cache + apiConfig are reset.
+    const main = await import("../main");
+    const { apiConfig } = await import("../api");
+
+    // Pre-state: viewer mode (production default)
+    expect(apiConfig.queryMode).toBe("viewer");
+
+    // Trigger the process hook
+    const ctx = { config: { sync_on_build: false } } as Parameters<typeof main.process>[0];
+    await main.process(ctx);
+
+    // Post-state: user mode, profile bound
+    expect(apiConfig.queryMode).toBe("user");
+    expect(apiConfig.testUserName).toBe("guo");
+  });
+
+  it("API layer: strips leading @ from profile name", async () => {
+    mockGetPluginEnvVar.mockResolvedValue("@guo");
+    const main = await import("../main");
+    const { apiConfig } = await import("../api");
+    await main.process({ config: { sync_on_build: false } } as Parameters<typeof main.process>[0]);
+    expect(apiConfig.testUserName).toBe("guo");
+  });
+
+  it("API layer: accepts profile without leading @", async () => {
+    mockGetPluginEnvVar.mockResolvedValue("matty");
+    const main = await import("../main");
+    const { apiConfig } = await import("../api");
+    await main.process({ config: { sync_on_build: false } } as Parameters<typeof main.process>[0]);
+    expect(apiConfig.testUserName).toBe("matty");
+  });
+
+  it("UI layer: skips openBrowser when env var is set", async () => {
+    mockGetPluginEnvVar.mockResolvedValue("@guo");
+    const main = await import("../main");
+    await main.process({ config: { sync_on_build: false } } as Parameters<typeof main.process>[0]);
+    expect(mockOpenBrowser).not.toHaveBeenCalled();
+  });
+
+  it("UI layer: auto-binds project to test profile", async () => {
+    mockGetPluginEnvVar.mockResolvedValue("@guo");
+    const main = await import("../main");
+    await main.process({ config: { sync_on_build: false } } as Parameters<typeof main.process>[0]);
+
+    // saveConfig is called with boundUserName + userName = "guo"
+    const lastCall = mockSaveConfig.mock.calls[mockSaveConfig.mock.calls.length - 1];
+    expect(lastCall?.[0]).toMatchObject({
+      boundUserName: "guo",
+      userName: "guo",
+    });
+  });
+
+  it("production path: env var unset → apiConfig stays in 'viewer' mode", async () => {
+    mockGetPluginEnvVar.mockResolvedValue(undefined);
+    // Saved username so auth Phase 1 doesn't prompt login
+    mockGetConfig.mockResolvedValue({ boundUserName: "real-user", userName: "real-user" });
+
+    const main = await import("../main");
+    const { apiConfig } = await import("../api");
+    await main.process({ config: { sync_on_build: false } } as Parameters<typeof main.process>[0]);
+
+    // queryMode might be flipped by the saved-username unauthenticated
+    // fallback (matters' legacy code path) — what we care about is that
+    // the test-profile branch did NOT fire (no openBrowser call, the
+    // bound user matches the saved one not "guo").
+    expect(mockOpenBrowser).not.toHaveBeenCalled();
+    // The escape hatch did not auto-rebind to a test profile.
+    const lastCall = mockSaveConfig.mock.calls[mockSaveConfig.mock.calls.length - 1];
+    if (lastCall) {
+      expect(lastCall[0].boundUserName).not.toBe("guo");
+    }
+    expect(apiConfig.testUserName).not.toBe("guo");
+  });
+});

package/src/__tests__/url-detect.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import { isDraftUrl, looksLikePublishedArticleUrl } from "../url-detect";
+
+describe("matters url-detect", () => {
+  describe("isDraftUrl", () => {
+    it("recognizes the draft editor URL", () => {
+      expect(isDraftUrl("https://matters.town/me/drafts/abc123")).toBe(true);
+      expect(isDraftUrl("https://matters.town/me/drafts/xzy-987-xyz")).toBe(true);
+    });
+
+    it("rejects non-draft URLs", () => {
+      expect(isDraftUrl("https://matters.town/@guo/some-post-a1b2c3")).toBe(false);
+      expect(isDraftUrl("https://matters.town/")).toBe(false);
+      expect(isDraftUrl("https://matters.town/login")).toBe(false);
+      expect(isDraftUrl("https://matters.town/@guo")).toBe(false);
+    });
+  });
+
+  describe("looksLikePublishedArticleUrl", () => {
+    it("recognizes a published article URL with hash suffix", () => {
+      // Positive: /@user/slug-hash (6+ alphanumeric chars at end)
+      expect(looksLikePublishedArticleUrl("https://matters.town/@guo/some-post-a1b2c3")).toBe(true);
+      expect(looksLikePublishedArticleUrl("https://matters.town/@alice/my-article-xyz789")).toBe(true);
+      expect(looksLikePublishedArticleUrl("https://matters.town/@bob/hello-world-abcdef")).toBe(true);
+    });
+
+    it("rejects a draft URL", () => {
+      expect(looksLikePublishedArticleUrl("https://matters.town/me/drafts/abc123")).toBe(false);
+    });
+
+    it("rejects home URL", () => {
+      expect(looksLikePublishedArticleUrl("https://matters.town/")).toBe(false);
+    });
+
+    it("rejects login URL", () => {
+      expect(looksLikePublishedArticleUrl("https://matters.town/login")).toBe(false);
+    });
+
+    it("rejects bare profile root (no article path)", () => {
+      expect(looksLikePublishedArticleUrl("https://matters.town/@guo")).toBe(false);
+    });
+
+    it("rejects /@user/followers (profile sub-page, no hash)", () => {
+      // "followers" has no numeric suffix — fails the hash requirement
+      expect(looksLikePublishedArticleUrl("https://matters.town/@guo/followers")).toBe(false);
+    });
+
+    it("rejects /@user/settings (profile sub-page, no hash)", () => {
+      expect(looksLikePublishedArticleUrl("https://matters.town/@guo/settings")).toBe(false);
+    });
+
+    it("rejects /@user/bookmarks (profile sub-page, no hash)", () => {
+      expect(looksLikePublishedArticleUrl("https://matters.town/@guo/bookmarks")).toBe(false);
+    });
+
+    it("rejects a slug without the hash suffix (fewer than 6 alphanumeric chars)", () => {
+      // "abc" is only 3 chars — below the 6-char minimum
+      expect(looksLikePublishedArticleUrl("https://matters.town/@guo/no-hash-abc")).toBe(false);
+    });
+
+    it("requires the hash to be at the end after a dash", () => {
+      // A slug like "pure-text-only" has no trailing hash segment
+      expect(looksLikePublishedArticleUrl("https://matters.town/@guo/pure-text-only")).toBe(false);
+    });
+
+    it("known false-trigger: /@user/tags-abcdef returns true (accepted, caught by API verify)", () => {
+      // /@guo/tags-abcdef passes the regex because its final path segment ends
+      // in "-<6+ alnum>". This is an intentionally accepted false-positive: the
+      // regex cannot cheaply distinguish article slugs from profile sub-pages
+      // whose names happen to end in a hash-like suffix. The caller (the matters
+      // plugin sync check) always verifies the candidate URL against the Matters
+      // API (draft.article); the API rejects non-article paths, so this false-
+      // trigger is harmless in practice. Do NOT change the regex to reject this
+      // case — the cure would be worse than the disease (over-fitting to a URL
+      // shape that Matters can change at any time).
+      expect(looksLikePublishedArticleUrl("https://matters.town/@guo/tags-abcdef")).toBe(true);
+    });
+  });
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect } from "vitest";
+import {
+  slugify,
+  simpleHash,
+  generateLocalFilename,
+  getExtensionFromContentType,
+  uint8ArrayToBase64,
+  formatArticleSyncSummary,
+} from "../utils";
+
+describe("formatArticleSyncSummary", () => {
+  it("leads with the noun for the all-unchanged run (the opaque '5 unchanged' case)", () => {
+    expect(formatArticleSyncSummary({ created: 0, updated: 0, skipped: 5, failed: 0 })).toBe(
+      "5 articles already up to date",
+    );
+  });
+
+  it("uses the singular noun for one article", () => {
+    expect(formatArticleSyncSummary({ created: 0, updated: 0, skipped: 1, failed: 0 })).toBe(
+      "1 article already up to date",
+    );
+  });
+
+  it("shows the total then the changed breakdown for a mixed run", () => {
+    expect(formatArticleSyncSummary({ created: 3, updated: 2, skipped: 5, failed: 0 })).toBe(
+      "10 articles: 3 new, 2 updated, 5 unchanged",
+    );
+  });
+
+  it("omits zero-count segments", () => {
+    expect(formatArticleSyncSummary({ created: 4, updated: 0, skipped: 0, failed: 0 })).toBe(
+      "4 articles: 4 new",
+    );
+  });
+
+  it("reports nothing-to-do plainly", () => {
+    expect(formatArticleSyncSummary({ created: 0, updated: 0, skipped: 0, failed: 0 })).toBe(
+      "no articles to sync",
+    );
+  });
+
+  it("appends a failure count as a separate cohort when some synced and some failed", () => {
+    expect(formatArticleSyncSummary({ created: 5, updated: 0, skipped: 0, failed: 2 })).toBe(
+      "5 articles: 5 new, 2 failed to sync",
+    );
+  });
+
+  it("keeps the failure cohort distinct from an all-unchanged set (no 'up to date, 2 failed' ambiguity)", () => {
+    expect(formatArticleSyncSummary({ created: 0, updated: 0, skipped: 5, failed: 2 })).toBe(
+      "5 articles already up to date, 2 failed to sync",
+    );
+  });
+
+  it("reports a fully-failed run without a misleading 'synced' noun", () => {
+    expect(formatArticleSyncSummary({ created: 0, updated: 0, skipped: 0, failed: 3 })).toBe(
+      "3 articles failed to sync",
+    );
+  });
+});
+
+describe("slugify", () => {
+  it("converts simple text to lowercase slug", () => {
+    expect(slugify("Hello World")).toBe("hello-world");
+  });
+
+  it("removes special characters", () => {
+    expect(slugify("Hello! World?")).toBe("hello-world");
+  });
+
+  it("handles multiple spaces", () => {
+    expect(slugify("Hello   World")).toBe("hello-world");
+  });
+
+  it("trims leading and trailing hyphens", () => {
+    expect(slugify("  Hello World  ")).toBe("hello-world");
+  });
+
+  it("preserves CJK characters", () => {
+    expect(slugify("你好世界")).toBe("你好世界");
+    expect(slugify("Hello 世界")).toBe("hello-世界");
+  });
+
+  it("preserves Cyrillic characters", () => {
+    expect(slugify("Привет мир")).toBe("привет-мир");
+  });
+
+  it("preserves Arabic characters", () => {
+    expect(slugify("مرحبا بالعالم")).toBe("مرحبا-بالعالم");
+  });
+
+  it("handles empty string", () => {
+    expect(slugify("")).toBe("");
+  });
+
+  it("handles numbers", () => {
+    expect(slugify("Test 123")).toBe("test-123");
+  });
+
+  it("collapses multiple hyphens", () => {
+    expect(slugify("Hello---World")).toBe("hello-world");
+  });
+});
+
+describe("simpleHash", () => {
+  it("returns consistent hash for same input", () => {
+    const hash1 = simpleHash("test");
+    const hash2 = simpleHash("test");
+    expect(hash1).toBe(hash2);
+  });
+
+  it("returns different hash for different inputs", () => {
+    const hash1 = simpleHash("test1");
+    const hash2 = simpleHash("test2");
+    expect(hash1).not.toBe(hash2);
+  });
+
+  it("returns hexadecimal string", () => {
+    const hash = simpleHash("test");
+    expect(hash).toMatch(/^[0-9a-f]+$/);
+  });
+
+  it("handles empty string", () => {
+    const hash = simpleHash("");
+    expect(hash).toBe("0");
+  });
+});
+
+describe("generateLocalFilename", () => {
+  it("extracts filename with extension from URL", () => {
+    expect(
+      generateLocalFilename("https://example.com/images/photo.jpg")
+    ).toBe("photo.jpg");
+  });
+
+  it("extracts UUID-based filename", () => {
+    expect(
+      generateLocalFilename(
+        "https://cdn.example.com/550e8400-e29b-41d4-a716-446655440000/image.png"
+      )
+    ).toBe("550e8400-e29b-41d4-a716-446655440000.png");
+  });
+
+  it("handles UUID without extension", () => {
+    expect(
+      generateLocalFilename(
+        "https://cdn.example.com/550e8400-e29b-41d4-a716-446655440000"
+      )
+    ).toBe("550e8400-e29b-41d4-a716-446655440000");
+  });
+
+  it("removes /public suffix", () => {
+    expect(
+      generateLocalFilename("https://cdn.example.com/image.jpg/public")
+    ).toBe("image.jpg");
+  });
+
+  it("falls back to hash for URLs without filename", () => {
+    const result = generateLocalFilename("https://example.com/");
+    expect(result).toMatch(/^[0-9a-f]+$/);
+  });
+
+  it("returns null for invalid URLs", () => {
+    expect(generateLocalFilename("not-a-url")).toBeNull();
+  });
+});
+
+describe("getExtensionFromContentType", () => {
+  it("returns jpg for image/jpeg", () => {
+    expect(getExtensionFromContentType("image/jpeg")).toBe("jpg");
+  });
+
+  it("returns jpg for image/jpg", () => {
+    expect(getExtensionFromContentType("image/jpg")).toBe("jpg");
+  });
+
+  it("returns png for image/png", () => {
+    expect(getExtensionFromContentType("image/png")).toBe("png");
+  });
+
+  it("returns gif for image/gif", () => {
+    expect(getExtensionFromContentType("image/gif")).toBe("gif");
+  });
+
+  it("returns webp for image/webp", () => {
+    expect(getExtensionFromContentType("image/webp")).toBe("webp");
+  });
+
+  it("returns svg for image/svg+xml", () => {
+    expect(getExtensionFromContentType("image/svg+xml")).toBe("svg");
+  });
+
+  it("handles content-type with charset", () => {
+    expect(getExtensionFromContentType("image/png; charset=utf-8")).toBe("png");
+  });
+
+  it("returns null for unknown content types", () => {
+    expect(getExtensionFromContentType("application/json")).toBeNull();
+  });
+
+  it("returns null for empty string", () => {
+    expect(getExtensionFromContentType("")).toBeNull();
+  });
+});
+
+describe("uint8ArrayToBase64", () => {
+  it("converts small arrays correctly", () => {
+    const bytes = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+    expect(uint8ArrayToBase64(bytes)).toBe("SGVsbG8=");
+  });
+
+  it("handles empty array", () => {
+    const bytes = new Uint8Array([]);
+    expect(uint8ArrayToBase64(bytes)).toBe("");
+  });
+
+  it("handles large arrays without stack overflow", () => {
+    // Create a 100KB array
+    const bytes = new Uint8Array(100000);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = i % 256;
+    }
+    // Should not throw
+    const result = uint8ArrayToBase64(bytes);
+    expect(result.length).toBeGreaterThan(0);
+  });
+});