test: add new tests

packages/opencode/test/config/markdown.test.ts

@@ -1,89 +1,146 @@
-import { expect, test } from "bun:test"
+import { expect, test, describe } from "bun:test"
 import { ConfigMarkdown } from "../../src/config/markdown"
 
-const template = `This is a @valid/path/to/a/file and it should also match at
+describe("ConfigMarkdown: normal template", () => {
-the beginning of a line:
+  const template = `This is a @valid/path/to/a/file and it should also match at
+  the beginning of a line:
 
-@another-valid/path/to/a/file
+  @another-valid/path/to/a/file
 
-but this is not:
+  but this is not:
 
-   - Adds a "Co-authored-by:" footer which clarifies which AI agent
+     - Adds a "Co-authored-by:" footer which clarifies which AI agent
-     helped create this commit, using an appropriate \`noreply@...\`
+       helped create this commit, using an appropriate \`noreply@...\`
-     or \`noreply@anthropic.com\` email address.
+       or \`noreply@anthropic.com\` email address.
 
-We also need to deal with files followed by @commas, ones
+  We also need to deal with files followed by @commas, ones
-with @file-extensions.md, even @multiple.extensions.bak,
+  with @file-extensions.md, even @multiple.extensions.bak,
-hidden directories like @.config/ or files like @.bashrc
+  hidden directories like @.config/ or files like @.bashrc
-and ones at the end of a sentence like @foo.md.
+  and ones at the end of a sentence like @foo.md.
 
-Also shouldn't forget @/absolute/paths.txt with and @/without/extensions,
+  Also shouldn't forget @/absolute/paths.txt with and @/without/extensions,
-as well as @~/home-files and @~/paths/under/home.txt.
+  as well as @~/home-files and @~/paths/under/home.txt.
 
-If the reference is \`@quoted/in/backticks\` then it shouldn't match at all.`
+  If the reference is \`@quoted/in/backticks\` then it shouldn't match at all.`
 
-const matches = ConfigMarkdown.files(template)
+  const matches = ConfigMarkdown.files(template)
 
-test("should extract exactly 12 file references", () => {
+  test("should extract exactly 12 file references", () => {
-  expect(matches.length).toBe(12)
+    expect(matches.length).toBe(12)
+  })
+
+  test("should extract valid/path/to/a/file", () => {
+    expect(matches[0][1]).toBe("valid/path/to/a/file")
+  })
+
+  test("should extract another-valid/path/to/a/file", () => {
+    expect(matches[1][1]).toBe("another-valid/path/to/a/file")
+  })
+
+  test("should extract paths ignoring comma after", () => {
+    expect(matches[2][1]).toBe("commas")
+  })
+
+  test("should extract a path with a file extension and comma after", () => {
+    expect(matches[3][1]).toBe("file-extensions.md")
+  })
+
+  test("should extract a path with multiple dots and comma after", () => {
+    expect(matches[4][1]).toBe("multiple.extensions.bak")
+  })
+
+  test("should extract hidden directory", () => {
+    expect(matches[5][1]).toBe(".config/")
+  })
+
+  test("should extract hidden file", () => {
+    expect(matches[6][1]).toBe(".bashrc")
+  })
+
+  test("should extract a file ignoring period at end of sentence", () => {
+    expect(matches[7][1]).toBe("foo.md")
+  })
+
+  test("should extract an absolute path with an extension", () => {
+    expect(matches[8][1]).toBe("/absolute/paths.txt")
+  })
+
+  test("should extract an absolute path without an extension", () => {
+    expect(matches[9][1]).toBe("/without/extensions")
+  })
+
+  test("should extract an absolute path in home directory", () => {
+    expect(matches[10][1]).toBe("~/home-files")
+  })
+
+  test("should extract an absolute path under home directory", () => {
+    expect(matches[11][1]).toBe("~/paths/under/home.txt")
+  })
+
+  test("should not match when preceded by backtick", () => {
+    const backtickTest = "This `@should/not/match` should be ignored"
+    const backtickMatches = ConfigMarkdown.files(backtickTest)
+    expect(backtickMatches.length).toBe(0)
+  })
+
+  test("should not match email addresses", () => {
+    const emailTest = "Contact user@example.com for help"
+    const emailMatches = ConfigMarkdown.files(emailTest)
+    expect(emailMatches.length).toBe(0)
+  })
 })
 
-test("should extract valid/path/to/a/file", () => {
+describe("ConfigMarkdown: frontmatter parsing", async () => {
-  expect(matches[0][1]).toBe("valid/path/to/a/file")
+  const template = `---
-})
+description: "This is a description wrapped in quotes"
+# field: this is a commented out field that should be ignored
+# occupation: This man has the following occupation: Software Engineer
+title: 'Hello World'
+name: John "Doe"
 
-test("should extract another-valid/path/to/a/file", () => {
+family: He has no 'family'
-  expect(matches[1][1]).toBe("another-valid/path/to/a/file")
+summary: >
-})
+  This is a summary
+---
 
-test("should extract paths ignoring comma after", () => {
+Content
-  expect(matches[2][1]).toBe("commas")
+`
-})
 
-test("should extract a path with a file extension and comma after", () => {
+  const matter = await import("gray-matter")
-  expect(matches[3][1]).toBe("file-extensions.md")
+  const parsed = matter.default(template)
-})
 
-test("should extract a path with multiple dots and comma after", () => {
+  test("should parse without throwing", () => {
-  expect(matches[4][1]).toBe("multiple.extensions.bak")
+    expect(parsed).toBeDefined()
-})
+    expect(parsed.data).toBeDefined()
+    expect(parsed.content).toBeDefined()
+  })
 
-test("should extract hidden directory", () => {
+  test("should extract description field", () => {
-  expect(matches[5][1]).toBe(".config/")
+    expect(parsed.data.description).toBe("This is a description wrapped in quotes")
-})
+  })
 
-test("should extract hidden file", () => {
+  test("should extract title field with single quotes", () => {
-  expect(matches[6][1]).toBe(".bashrc")
+    expect(parsed.data.title).toBe("Hello World")
-})
+  })
 
-test("should extract a file ignoring period at end of sentence", () => {
+  test("should extract name field with embedded quotes", () => {
-  expect(matches[7][1]).toBe("foo.md")
+    expect(parsed.data.name).toBe('John "Doe"')
-})
+  })
 
-test("should extract an absolute path with an extension", () => {
+  test("should extract family field with embedded single quotes", () => {
-  expect(matches[8][1]).toBe("/absolute/paths.txt")
+    expect(parsed.data.family).toBe("He has no 'family'")
-})
+  })
 
-test("should extract an absolute path without an extension", () => {
+  test("should extract multiline summary field", () => {
-  expect(matches[9][1]).toBe("/without/extensions")
+    expect(parsed.data.summary).toBe("This is a summary\n")
-})
+  })
 
-test("should extract an absolute path in home directory", () => {
+  test("should not include commented fields in data", () => {
-  expect(matches[10][1]).toBe("~/home-files")
+    expect(parsed.data.field).toBeUndefined()
-})
+    expect(parsed.data.occupation).toBeUndefined()
+  })
 
-test("should extract an absolute path under home directory", () => {
+  test("should extract content after frontmatter", () => {
-  expect(matches[11][1]).toBe("~/paths/under/home.txt")
+    expect(parsed.content.trim()).toBe("Content")
-})
+  })
-
-test("should not match when preceded by backtick", () => {
-  const backtickTest = "This `@should/not/match` should be ignored"
-  const backtickMatches = ConfigMarkdown.files(backtickTest)
-  expect(backtickMatches.length).toBe(0)
-})
-
-test("should not match email addresses", () => {
-  const emailTest = "Contact user@example.com for help"
-  const emailMatches = ConfigMarkdown.files(emailTest)
-  expect(emailMatches.length).toBe(0)
 })