@symbiosis-lab/moss-plugin-matters 1.4.2

package/src/__tests__/config.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { setupMockTauri, type MockTauriContext } from "@symbiosis-lab/moss-api/testing";
+
+import {
+  getConfig,
+  saveConfig,
+  type MattersPluginConfig,
+} from "../config";
+
+describe("Config Module", () => {
+  let ctx: MockTauriContext;
+
+  beforeEach(() => {
+    ctx = setupMockTauri({ pluginName: "matters-syndicator" });
+  });
+
+  afterEach(() => {
+    ctx.cleanup();
+  });
+
+  describe("getConfig", () => {
+    it("returns default config when file does not exist", async () => {
+      // No file set up = file doesn't exist
+      const config = await getConfig();
+      expect(config).toEqual({});
+    });
+
+    it("returns parsed config when file exists", async () => {
+      const savedConfig: MattersPluginConfig = {
+        userName: "testuser",
+        language: "zh_hant",
+      };
+      // Set up the config file in the plugin's storage directory
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        JSON.stringify(savedConfig)
+      );
+
+      const config = await getConfig();
+      expect(config).toEqual(savedConfig);
+    });
+
+    it("returns empty config on parse error", async () => {
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        "invalid json {{{"
+      );
+
+      const config = await getConfig();
+      expect(config).toEqual({});
+    });
+  });
+
+  describe("saveConfig", () => {
+    it("writes config to plugin storage", async () => {
+      const config: MattersPluginConfig = {
+        userName: "testuser",
+        language: "en",
+      };
+
+      await saveConfig(config);
+
+      const savedContent = ctx.filesystem.getFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`
+      );
+      expect(savedContent).toBeDefined();
+      expect(JSON.parse(savedContent!.content)).toEqual(config);
+    });
+
+    it("preserves existing fields when updating", async () => {
+      const existingConfig: MattersPluginConfig = {
+        userName: "olduser",
+        language: "zh_hant",
+      };
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        JSON.stringify(existingConfig)
+      );
+
+      // Get existing config, merge, and save
+      const existing = await getConfig();
+      const merged = { ...existing, userName: "newuser" };
+      await saveConfig(merged);
+
+      const savedContent = ctx.filesystem.getFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`
+      );
+      expect(JSON.parse(savedContent!.content)).toEqual({
+        userName: "newuser",
+        language: "zh_hant",
+      });
+    });
+  });
+
+  describe("Config schema", () => {
+    it("supports userName field", async () => {
+      const config: MattersPluginConfig = { userName: "Matty" };
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        JSON.stringify(config)
+      );
+
+      const result = await getConfig();
+      expect(result.userName).toBe("Matty");
+    });
+
+    it("supports language field", async () => {
+      const config: MattersPluginConfig = { language: "zh_hans" };
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        JSON.stringify(config)
+      );
+
+      const result = await getConfig();
+      expect(result.language).toBe("zh_hans");
+    });
+
+    it("supports both userName and language", async () => {
+      const config: MattersPluginConfig = {
+        userName: "刘果",
+        language: "zh_hant",
+      };
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        JSON.stringify(config)
+      );
+
+      const result = await getConfig();
+      expect(result.userName).toBe("刘果");
+      expect(result.language).toBe("zh_hant");
+    });
+
+    it("handles empty config object", async () => {
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        "{}"
+      );
+
+      const result = await getConfig();
+      expect(result).toEqual({});
+      expect(result.userName).toBeUndefined();
+      expect(result.language).toBeUndefined();
+    });
+
+    it("supports lastSyncedAt field for incremental sync", async () => {
+      const timestamp = "2024-01-15T12:00:00.000Z";
+      const config: MattersPluginConfig = {
+        userName: "testuser",
+        lastSyncedAt: timestamp,
+      };
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        JSON.stringify(config)
+      );
+
+      const result = await getConfig();
+      expect(result.lastSyncedAt).toBe(timestamp);
+    });
+
+    it("stores and retrieves all config fields together", async () => {
+      const config: MattersPluginConfig = {
+        userName: "testuser",
+        language: "zh_hant",
+        lastSyncedAt: "2024-01-15T12:00:00.000Z",
+      };
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        JSON.stringify(config)
+      );
+
+      const result = await getConfig();
+      expect(result).toEqual(config);
+    });
+  });
+
+  describe("Incremental Sync", () => {
+    it("can update lastSyncedAt while preserving other fields", async () => {
+      const initialConfig: MattersPluginConfig = {
+        userName: "testuser",
+        language: "en",
+      };
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        JSON.stringify(initialConfig)
+      );
+
+      // Read, update, and save
+      const config = await getConfig();
+      const newTimestamp = new Date().toISOString();
+      await saveConfig({ ...config, lastSyncedAt: newTimestamp });
+
+      const savedContent = ctx.filesystem.getFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`
+      );
+      const parsed = JSON.parse(savedContent!.content);
+
+      expect(parsed.userName).toBe("testuser");
+      expect(parsed.language).toBe("en");
+      expect(parsed.lastSyncedAt).toBe(newTimestamp);
+    });
+
+    it("lastSyncedAt is undefined on first sync", async () => {
+      ctx.filesystem.setFile(
+        `${ctx.projectPath}/.moss/plugins/matters-syndicator/config.json`,
+        JSON.stringify({ userName: "testuser" })
+      );
+
+      const config = await getConfig();
+      expect(config.lastSyncedAt).toBeUndefined();
+    });
+  });
+});

package/src/__tests__/converter.test.ts

@@ -0,0 +1,289 @@
+import { describe, it, expect } from "vitest";
+import {
+  generateFrontmatter,
+  parseFrontmatter,
+  regenerateFrontmatter,
+  extractRemoteImageUrls,
+  extractMarkdownLinks,
+} from "../converter";
+
+// NOTE: the `htmlToMarkdown` describe block was deleted with the hand-rolled
+// converter (B4). Production HTML→Markdown now runs through moss's shared Rust
+// `htmd` converter (imported from `@symbiosis-lab/moss-api`), so the old tests
+// no longer have a unit under test. They also enshrined the lone-backslash
+// `<br>` output (`line1\\\nline2`) — i.e. the exact B3 bug the project fixed —
+// which would be false confidence to keep.
+
+describe("generateFrontmatter", () => {
+  it("generates basic frontmatter", () => {
+    const result = generateFrontmatter({ title: "Test Title" });
+    expect(result).toContain("---");
+    expect(result).toContain('title: "Test Title"');
+  });
+
+  it("escapes quotes in title", () => {
+    const result = generateFrontmatter({ title: 'Test "Quote"' });
+    expect(result).toContain('title: "Test \\"Quote\\""');
+  });
+
+  it("includes date and updated", () => {
+    const result = generateFrontmatter({
+      title: "Test",
+      date: "2024-01-01",
+      updated: "2024-01-02",
+    });
+    expect(result).toContain('date: "2024-01-01"');
+    expect(result).toContain('updated: "2024-01-02"');
+  });
+
+  it("includes tags array", () => {
+    const result = generateFrontmatter({
+      title: "Test",
+      tags: ["tag1", "tag2"],
+    });
+    expect(result).toContain("tags:");
+    expect(result).toContain('  - "tag1"');
+    expect(result).toContain('  - "tag2"');
+  });
+
+  it("includes cover", () => {
+    const result = generateFrontmatter({
+      title: "Test",
+      cover: "cover.jpg",
+    });
+    expect(result).toContain('cover: "cover.jpg"');
+  });
+
+  it("includes syndicated URLs", () => {
+    const result = generateFrontmatter({
+      title: "Test",
+      syndicated: ["https://example.com/article"],
+    });
+    expect(result).toContain("syndicated:");
+    expect(result).toContain('  - "https://example.com/article"');
+  });
+
+  it("includes collections mapping", () => {
+    const result = generateFrontmatter({
+      title: "Test",
+      collections: { "my-collection": 0, "other-collection": 1 },
+    });
+    expect(result).toContain("collections:");
+    expect(result).toContain("  my-collection: 0");
+    expect(result).toContain("  other-collection: 1");
+  });
+});
+
+describe("parseFrontmatter", () => {
+  it("parses basic frontmatter", () => {
+    const content = `---
+title: "Test Title"
+---
+Body content`;
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result?.frontmatter.title).toBe("Test Title");
+    expect(result?.body).toBe("Body content");
+  });
+
+  it("parses array values", () => {
+    const content = `---
+title: "Test"
+tags:
+  - "tag1"
+  - "tag2"
+---
+Body`;
+    const result = parseFrontmatter(content);
+    expect(result?.frontmatter.tags).toEqual(["tag1", "tag2"]);
+  });
+
+  it("returns null for content without frontmatter", () => {
+    const content = "Just some text without frontmatter";
+    expect(parseFrontmatter(content)).toBeNull();
+  });
+
+  it("returns null for malformed frontmatter", () => {
+    const content = `---
+title: Test
+No closing delimiter`;
+    expect(parseFrontmatter(content)).toBeNull();
+  });
+
+  it("handles empty body", () => {
+    const content = `---
+title: "Test"
+---
+`;
+    const result = parseFrontmatter(content);
+    expect(result?.body).toBe("");
+  });
+});
+
+describe("regenerateFrontmatter", () => {
+  it("regenerates basic frontmatter", () => {
+    const result = regenerateFrontmatter({ title: "Test" });
+    expect(result).toContain("---");
+    expect(result).toContain('title: "Test"');
+  });
+
+  it("preserves field order", () => {
+    const result = regenerateFrontmatter({
+      tags: ["a", "b"],
+      title: "Test",
+      date: "2024-01-01",
+    });
+    const lines = result.split("\n");
+    const titleIndex = lines.findIndex((l) => l.includes("title:"));
+    const dateIndex = lines.findIndex((l) => l.includes("date:"));
+    const tagsIndex = lines.findIndex((l) => l === "tags:");
+    expect(titleIndex).toBeLessThan(dateIndex);
+    expect(dateIndex).toBeLessThan(tagsIndex);
+  });
+
+  it("handles nested objects", () => {
+    const result = regenerateFrontmatter({
+      collections: { "col-1": 0, "col-2": 1 },
+    });
+    expect(result).toContain("collections:");
+    expect(result).toContain("  col-1: 0");
+  });
+});
+
+describe("extractRemoteImageUrls", () => {
+  it("extracts HTTP image URLs", () => {
+    const content = "![alt](http://example.com/image.jpg)";
+    const result = extractRemoteImageUrls(content);
+    expect(result).toHaveLength(1);
+    expect(result[0].url).toBe("http://example.com/image.jpg");
+  });
+
+  it("extracts HTTPS image URLs", () => {
+    const content = "![alt](https://example.com/image.png)";
+    const result = extractRemoteImageUrls(content);
+    expect(result).toHaveLength(1);
+    expect(result[0].url).toBe("https://example.com/image.png");
+  });
+
+  it("ignores local image paths", () => {
+    const content = "![alt](./images/local.jpg)";
+    const result = extractRemoteImageUrls(content);
+    expect(result).toHaveLength(0);
+  });
+
+  it("ignores relative paths", () => {
+    const content = "![alt](assets/image.jpg)";
+    const result = extractRemoteImageUrls(content);
+    expect(result).toHaveLength(0);
+  });
+
+  it("deduplicates URLs", () => {
+    const content = `
+![img1](https://example.com/image.jpg)
+![img2](https://example.com/image.jpg)
+`;
+    const result = extractRemoteImageUrls(content);
+    expect(result).toHaveLength(1);
+  });
+
+  it("extracts multiple different URLs", () => {
+    const content = `
+![img1](https://example.com/image1.jpg)
+![img2](https://example.com/image2.png)
+`;
+    const result = extractRemoteImageUrls(content);
+    expect(result).toHaveLength(2);
+  });
+
+  it("generates local filenames", () => {
+    const content = "![alt](https://cdn.example.com/uploads/photo.jpg)";
+    const result = extractRemoteImageUrls(content);
+    expect(result[0].localFilename).toBe("photo.jpg");
+  });
+
+  it("handles empty content", () => {
+    const result = extractRemoteImageUrls("");
+    expect(result).toHaveLength(0);
+  });
+
+  it("handles content with no images", () => {
+    const content = "Just some text without images";
+    const result = extractRemoteImageUrls(content);
+    expect(result).toHaveLength(0);
+  });
+});
+
+describe("extractMarkdownLinks", () => {
+  it("extracts markdown links", () => {
+    const content = "Check out [my link](https://example.com)";
+    const result = extractMarkdownLinks(content);
+    expect(result).toHaveLength(1);
+    expect(result[0].url).toBe("https://example.com");
+    expect(result[0].fullMatch).toBe("[my link](https://example.com)");
+  });
+
+  it("does NOT extract image syntax", () => {
+    const content = "![alt text](https://example.com/image.jpg)";
+    const result = extractMarkdownLinks(content);
+    expect(result).toHaveLength(0);
+  });
+
+  it("extracts links but not images in mixed content", () => {
+    const content = `
+Here is a [link](https://example.com) and
+an image ![image](https://example.com/img.png) and
+another [second link](https://other.com).
+`;
+    const result = extractMarkdownLinks(content);
+    expect(result).toHaveLength(2);
+    expect(result[0].url).toBe("https://example.com");
+    expect(result[1].url).toBe("https://other.com");
+  });
+
+  it("extracts Matters.town article links", () => {
+    const content = "Read my [previous article](https://matters.town/@alice/hello-world-abc123)";
+    const result = extractMarkdownLinks(content);
+    expect(result).toHaveLength(1);
+    expect(result[0].url).toBe("https://matters.town/@alice/hello-world-abc123");
+  });
+
+  it("handles multiple links on same line", () => {
+    const content = "[link1](https://a.com) and [link2](https://b.com)";
+    const result = extractMarkdownLinks(content);
+    expect(result).toHaveLength(2);
+    expect(result[0].url).toBe("https://a.com");
+    expect(result[1].url).toBe("https://b.com");
+  });
+
+  it("handles links with empty text", () => {
+    const content = "[](https://example.com)";
+    const result = extractMarkdownLinks(content);
+    expect(result).toHaveLength(1);
+    expect(result[0].url).toBe("https://example.com");
+  });
+
+  it("handles relative links", () => {
+    const content = "[local](./path/to/file.md)";
+    const result = extractMarkdownLinks(content);
+    expect(result).toHaveLength(1);
+    expect(result[0].url).toBe("./path/to/file.md");
+  });
+
+  it("handles empty content", () => {
+    const result = extractMarkdownLinks("");
+    expect(result).toHaveLength(0);
+  });
+
+  it("handles content with no links", () => {
+    const content = "Just plain text without any links";
+    const result = extractMarkdownLinks(content);
+    expect(result).toHaveLength(0);
+  });
+
+  it("trims whitespace from URLs", () => {
+    const content = "[link](  https://example.com  )";
+    const result = extractMarkdownLinks(content);
+    expect(result).toHaveLength(1);
+    expect(result[0].url).toBe("https://example.com");
+  });
+});