tissues 0.6.1 → 0.6.2

package/src/lib/templates.test.js

@@ -0,0 +1,207 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { listTemplates, loadTemplate, renderTemplate } from './templates.js'
+
+// ---------------------------------------------------------------------------
+// renderTemplate — pure function, no file I/O
+// ---------------------------------------------------------------------------
+
+describe('renderTemplate', () => {
+  test('replaces a single variable', () => {
+    const result = renderTemplate('Hello {{name}}!', { name: 'World' })
+    assert.equal(result, 'Hello World!')
+  })
+
+  test('replaces multiple different variables', () => {
+    const result = renderTemplate('{{greeting}} {{name}}', { greeting: 'Hi', name: 'Alice' })
+    assert.equal(result, 'Hi Alice')
+  })
+
+  test('leaves unknown variables intact', () => {
+    const result = renderTemplate('Hello {{unknown}}!', {})
+    assert.equal(result, 'Hello {{unknown}}!')
+  })
+
+  test('leaves null/undefined variable values intact', () => {
+    const result = renderTemplate('{{a}} {{b}}', { a: null, b: undefined })
+    assert.equal(result, '{{a}} {{b}}')
+  })
+
+  test('replaces the same variable multiple times', () => {
+    const result = renderTemplate('{{x}} and {{x}}', { x: 'foo' })
+    assert.equal(result, 'foo and foo')
+  })
+
+  test('handles numeric variable values', () => {
+    const result = renderTemplate('Count: {{n}}', { n: 42 })
+    assert.equal(result, 'Count: 42')
+  })
+
+  test('no substitution when template has no placeholders', () => {
+    const result = renderTemplate('Plain text body.', { anything: 'value' })
+    assert.equal(result, 'Plain text body.')
+  })
+
+  test('handles empty template string', () => {
+    const result = renderTemplate('', { key: 'val' })
+    assert.equal(result, '')
+  })
+
+  test('renders description placeholder used in built-in templates', () => {
+    const body = '## Summary\n\n{{description}}\n\n## Details'
+    const result = renderTemplate(body, { description: 'A short description.' })
+    assert.equal(result, '## Summary\n\nA short description.\n\n## Details')
+  })
+
+  test('multiple standard template variables', () => {
+    const body = '{{title}} by {{agent}} on {{date}} in {{repo}}'
+    const result = renderTemplate(body, {
+      title: 'Fix bug',
+      agent: 'bot',
+      date: '2025-01-01',
+      repo: 'owner/repo',
+    })
+    assert.equal(result, 'Fix bug by bot on 2025-01-01 in owner/repo')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// loadTemplate — built-in templates (no file system required for these)
+// ---------------------------------------------------------------------------
+
+describe('loadTemplate – built-in templates', () => {
+  // Use a temp dir with .git so findRepoRoot() resolves there and no
+  // repo-level template files interfere.
+  let tmpDir
+
+  test('loads the default template', () => {
+    const tpl = loadTemplate('default', os.tmpdir())
+    assert.equal(tpl.key, 'default')
+    assert.ok(tpl.body.includes('{{description}}'))
+    // source may be 'built-in' or 'user' if the user has a custom default template
+    assert.ok(['built-in', 'user'].includes(tpl.source))
+  })
+
+  test('loads the bug template', () => {
+    const tpl = loadTemplate('bug', os.tmpdir())
+    assert.equal(tpl.key, 'bug')
+    assert.ok(tpl.name.length > 0)
+    assert.ok(tpl.body.includes('{{description}}'))
+    assert.equal(tpl.source, 'built-in')
+  })
+
+  test('loads the feature template', () => {
+    const tpl = loadTemplate('feature', os.tmpdir())
+    assert.equal(tpl.key, 'feature')
+    assert.equal(tpl.source, 'built-in')
+  })
+
+  test('throws for unknown template name', () => {
+    assert.throws(
+      () => loadTemplate('does-not-exist', os.tmpdir()),
+      /Template "does-not-exist" not found/
+    )
+  })
+
+  test('returned object has key, name, body, source properties', () => {
+    const tpl = loadTemplate('bug', os.tmpdir())
+    assert.ok('key' in tpl)
+    assert.ok('name' in tpl)
+    assert.ok('body' in tpl)
+    assert.ok('source' in tpl)
+    assert.equal(typeof tpl.body, 'string')
+    assert.ok(tpl.body.length > 0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// loadTemplate – repo template overrides built-in
+// ---------------------------------------------------------------------------
+
+describe('loadTemplate – repo templates override built-in', () => {
+  let tmpDir
+
+  test('repo template shadows built-in when file exists', () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-tpl-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues', 'templates'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'templates', 'bug.md'),
+      '## Custom Bug Template\n\n{{description}}\n'
+    )
+
+    const tpl = loadTemplate('bug', tmpDir)
+    assert.equal(tpl.source, 'repo')
+    assert.ok(tpl.body.includes('Custom Bug Template'))
+
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  test('repo template name extracted from file front-matter if present', () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-tpl-name-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues', 'templates'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'templates', 'custom.md'),
+      'name: My Custom Template\n\n## Body\n\n{{description}}\n'
+    )
+
+    const tpl = loadTemplate('custom', tmpDir)
+    assert.equal(tpl.source, 'repo')
+    assert.equal(tpl.name, 'My Custom Template')
+
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// listTemplates
+// ---------------------------------------------------------------------------
+
+describe('listTemplates', () => {
+  test('returns an array', () => {
+    const list = listTemplates(os.tmpdir())
+    assert.ok(Array.isArray(list))
+  })
+
+  test('includes all built-in template keys', () => {
+    const list = listTemplates(os.tmpdir())
+    const builtInKeys = list.filter((t) => t.source === 'built-in').map((t) => t.key)
+    for (const key of ['default', 'bug', 'feature']) {
+      assert.ok(builtInKeys.includes(key), `missing built-in template: ${key}`)
+    }
+  })
+
+  test('each item has key, name, source properties', () => {
+    const list = listTemplates(os.tmpdir())
+    for (const item of list) {
+      assert.ok('key' in item, 'missing key')
+      assert.ok('name' in item, 'missing name')
+      assert.ok('source' in item, 'missing source')
+    }
+  })
+
+  test('repo templates appear before built-ins in the list', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-list-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues', 'templates'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'templates', 'bug.md'),
+      '## Repo Bug\n\n{{description}}\n'
+    )
+
+    try {
+      const list = listTemplates(tmpDir)
+      const repoIdx = list.findIndex((t) => t.source === 'repo' && t.key === 'bug')
+      const builtInIdx = list.findIndex((t) => t.source === 'built-in' && t.key === 'bug')
+      assert.ok(repoIdx >= 0, 'repo template not found in list')
+      assert.ok(builtInIdx >= 0, 'built-in template not found in list')
+      assert.ok(repoIdx < builtInIdx, 'repo template should appear before built-in in list')
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+})