opencode-teammate 0.1.0

package/src/utils/frontmatter.spec.ts

@@ -0,0 +1,491 @@
+import { describe, expect, it } from "bun:test";
+import { parse, extract, stringify } from "./frontmatter";
+
+/**
+ * Test suite for the frontmatter utility module.
+ *
+ * Tests cover parsing, extracting, and stringifying YAML frontmatter,
+ * including edge cases, data type handling, and roundtrip conversions.
+ */
+describe("frontmatter", () => {
+  describe("parse", () => {
+    it("should parse basic frontmatter", () => {
+      const content = `---
+title: My Title
+description: My Description
+---
+
+content here`;
+
+      const result = parse(content);
+      expect(result).toEqual({
+        title: "My Title",
+        description: "My Description",
+      });
+    });
+
+    it("should parse nested objects", () => {
+      const content = `---
+title: My Title
+nested:
+  key: value
+  another: data
+---`;
+
+      const result = parse(content);
+      expect(result).toEqual({
+        title: "My Title",
+        nested: {
+          key: "value",
+          another: "data",
+        },
+      });
+    });
+
+    it("should parse multiple levels of nesting", () => {
+      const content = `---
+level1:
+  level2:
+    level3: deep value
+    another: value
+  sibling: data
+---`;
+
+      const result = parse(content);
+      expect(result).toEqual({
+        level1: {
+          level2: {
+            level3: "deep value",
+            another: "value",
+          },
+          sibling: "data",
+        },
+      });
+    });
+
+    it("should parse different data types", () => {
+      const content = `---
+string: hello
+number: 42
+float: 3.14
+boolean_true: true
+boolean_false: false
+null_value: null
+---`;
+
+      const result = parse(content);
+      expect(result).toEqual({
+        string: "hello",
+        number: 42,
+        float: 3.14,
+        boolean_true: true,
+        boolean_false: false,
+        null_value: null,
+      });
+    });
+
+    it("should parse quoted strings", () => {
+      const content = `---
+single: 'single quotes'
+double: "double quotes"
+---`;
+
+      const result = parse(content);
+      expect(result).toEqual({
+        single: "single quotes",
+        double: "double quotes",
+      });
+    });
+
+    it("should return empty object when no frontmatter", () => {
+      const content = `# Just a title
+
+Some content`;
+
+      const result = parse(content);
+      expect(result).toEqual({});
+    });
+
+    it("should return empty object when delimiter not found", () => {
+      const content = `---
+title: Test
+no closing delimiter`;
+
+      const result = parse(content);
+      expect(result).toEqual({});
+    });
+
+    it("should handle empty frontmatter", () => {
+      const content = `---
+---
+
+content`;
+
+      const result = parse(content);
+      expect(result).toEqual({});
+    });
+
+    it("should ignore comments in frontmatter", () => {
+      const content = `---
+# This is a comment
+title: My Title
+# Another comment
+description: My Description
+---`;
+
+      const result = parse(content);
+      expect(result).toEqual({
+        title: "My Title",
+        description: "My Description",
+      });
+    });
+
+    it("should handle custom delimiter", () => {
+      const content = `+++
+title: My Title
+description: My Description
++++
+
+content here`;
+
+      const result = parse(content, { delimiter: "+++" });
+      expect(result).toEqual({
+        title: "My Title",
+        description: "My Description",
+      });
+    });
+
+    it("should handle content with whitespace before delimiter", () => {
+      const content = `   ---
+title: My Title
+---`;
+
+      const result = parse(content);
+      expect(result).toEqual({
+        title: "My Title",
+      });
+    });
+
+    it("should handle strings that look like numbers", () => {
+      const content = `---
+version: "1.0"
+code: "007"
+---`;
+
+      const result = parse(content);
+      expect(result).toEqual({
+        version: "1.0",
+        code: "007",
+      });
+    });
+  });
+
+  describe("extract", () => {
+    it("should extract frontmatter and content", () => {
+      const content = `---
+title: My Title
+description: My Description
+---
+
+# Main Content
+
+This is the body of the document.`;
+
+      const result = extract(content);
+      expect(result.metadata).toEqual({
+        title: "My Title",
+        description: "My Description",
+      });
+      expect(result.content).toBe(`
+# Main Content
+
+This is the body of the document.`);
+    });
+
+    it("should handle content immediately after closing delimiter", () => {
+      const content = `---
+title: Test
+---
+Content starts here`;
+
+      const result = extract(content);
+      expect(result.metadata).toEqual({ title: "Test" });
+      expect(result.content).toBe("Content starts here");
+    });
+
+    it("should return empty data and full content when no frontmatter", () => {
+      const content = `# Just a title
+
+Some content`;
+
+      const result = extract(content);
+      expect(result.metadata).toEqual({});
+      expect(result.content).toBe(content);
+    });
+
+    it("should extract with nested objects", () => {
+      const content = `---
+title: My Title
+nested:
+  key: value
+---
+
+Content here`;
+
+      const result = extract(content);
+      expect(result.metadata).toEqual({
+        title: "My Title",
+        nested: {
+          key: "value",
+        },
+      });
+      expect(result.content).toBe("\nContent here");
+    });
+
+    it("should handle custom delimiter", () => {
+      const content = `~~~
+title: Custom
+~~~
+Body content`;
+
+      const result = extract(content, { delimiter: "~~~" });
+      expect(result.metadata).toEqual({ title: "Custom" });
+      expect(result.content).toBe("Body content");
+    });
+
+    it("should preserve empty lines in content", () => {
+      const content = `---
+title: Test
+---
+
+
+Content with empty lines above`;
+
+      const result = extract(content);
+      expect(result.content).toBe("\n\nContent with empty lines above");
+    });
+  });
+
+  describe("stringify", () => {
+    it("should stringify basic data", () => {
+      const data = {
+        title: "My Title",
+        description: "My Description",
+      };
+
+      const result = stringify(data);
+      expect(result).toBe(`---
+title: My Title
+description: My Description
+---
+`);
+    });
+
+    it("should stringify nested objects", () => {
+      const data = {
+        title: "My Title",
+        nested: {
+          key: "value",
+          another: "data",
+        },
+      };
+
+      const result = stringify(data);
+      expect(result).toBe(`---
+title: My Title
+nested:
+  key: value
+  another: data
+---
+`);
+    });
+
+    it("should stringify different data types", () => {
+      const data = {
+        string: "hello",
+        number: 42,
+        boolean: true,
+        null_value: null,
+      };
+
+      const result = stringify(data);
+      expect(result).toBe(`---
+string: hello
+number: 42
+boolean: true
+null_value: null
+---
+`);
+    });
+
+    it("should handle deeply nested objects", () => {
+      const data = {
+        level1: {
+          level2: {
+            level3: "deep",
+          },
+        },
+      };
+
+      const result = stringify(data);
+      expect(result).toBe(`---
+level1:
+  level2:
+    level3: deep
+---
+`);
+    });
+
+    it("should use custom delimiter", () => {
+      const data = {
+        title: "Test",
+      };
+
+      const result = stringify(data, { delimiter: "+++" });
+      expect(result).toBe(`+++
+title: Test
++++
+`);
+    });
+
+    it("should quote strings with special characters", () => {
+      const data = {
+        title: "Title: With Colon",
+        description: "Has # hash",
+      };
+
+      const result = stringify(data);
+      expect(result).toContain('"Title: With Colon"');
+      expect(result).toContain('"Has # hash"');
+    });
+
+    it("should handle empty object", () => {
+      const data = {};
+
+      const result = stringify(data);
+      expect(result).toBe(`---
+---
+`);
+    });
+
+    it("should handle arrays", () => {
+      const data = {
+        tags: ["typescript", "testing", "bun"],
+        items: [1, 2, 3],
+      };
+
+      const result = stringify(data);
+      expect(result).toContain("tags:");
+      expect(result).toContain("- typescript");
+      expect(result).toContain("- testing");
+      expect(result).toContain("- bun");
+    });
+  });
+
+  describe("roundtrip", () => {
+    it("should parse and stringify back to similar format", () => {
+      const original = {
+        title: "My Title",
+        description: "My Description",
+        nested: {
+          key: "value",
+        },
+      };
+
+      const stringified = stringify(original);
+      const parsed = parse(stringified);
+
+      expect(parsed).toEqual(original);
+    });
+
+    it("should handle complex nested structures", () => {
+      const original = {
+        title: "Complex",
+        metadata: {
+          author: "John Doe",
+          date: "2024-01-01",
+          tags: {
+            primary: "typescript",
+            secondary: "testing",
+          },
+        },
+        settings: {
+          enabled: true,
+          count: 42,
+        },
+      };
+
+      const stringified = stringify(original);
+      const parsed = parse(stringified);
+
+      expect(parsed).toEqual(original);
+    });
+
+    it("should preserve data types through roundtrip", () => {
+      const original = {
+        string: "hello",
+        number: 42,
+        float: 3.14,
+        boolean_true: true,
+        boolean_false: false,
+        null_value: null,
+      };
+
+      const stringified = stringify(original);
+      const parsed = parse(stringified);
+
+      expect(parsed).toEqual(original);
+      expect(typeof parsed.string).toBe("string");
+      expect(typeof parsed.number).toBe("number");
+      expect(typeof parsed.float).toBe("number");
+      expect(typeof parsed.boolean_true).toBe("boolean");
+      expect(typeof parsed.boolean_false).toBe("boolean");
+      expect(parsed.null_value).toBeNull();
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle empty string", () => {
+      const result = parse("");
+      expect(result).toEqual({});
+    });
+
+    it("should handle only delimiters", () => {
+      const content = `---
+---`;
+      const result = parse(content);
+      expect(result).toEqual({});
+    });
+
+    it("should handle whitespace-only frontmatter", () => {
+      const content = `---
+
+
+---`;
+      const result = parse(content);
+      expect(result).toEqual({});
+    });
+
+    it("should handle keys with no values correctly", () => {
+      const content = `---
+title:
+description: Has value
+---`;
+      const result = parse(content);
+      expect(result).toEqual({
+        title: {},
+        description: "Has value",
+      });
+    });
+
+    it("should handle multiple colons in value", () => {
+      const content = `---
+url: "https://example.com:8080/path"
+---`;
+      const result = parse(content);
+      expect(result).toEqual({
+        url: "https://example.com:8080/path",
+      });
+    });
+  });
+});