tissues 0.6.0 → 0.6.2

package/src/lib/drafts-perf.test.js

@@ -0,0 +1,203 @@
+/**
+ * Performance and adversarial tests for drafts.js.
+ *
+ * These tests verify that drafts are correct under load:
+ *   - 100 concurrent writes produce no collisions
+ *   - Reading 1000 items completes in < 500ms
+ *   - Corrupt files don't prevent other items from processing
+ *   - writeToDrafts during an active readDrafts doesn't cause double-processing
+ *
+ * Run standalone: node --test src/lib/drafts-perf.test.js
+ */
+
+import { test, describe, before, after } 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 {
+  getDraftsDir,
+  writeToDrafts,
+  readDrafts,
+  markComplete,
+  hasPending,
+  countPending,
+} from './drafts.js'
+
+function makeTempRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-drafts-perf-'))
+  fs.mkdirSync(path.join(dir, '.git'))
+  return dir
+}
+
+// ---------------------------------------------------------------------------
+// 100 concurrent writes
+// ---------------------------------------------------------------------------
+
+describe('100 concurrent writes', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('all 100 files exist with unique IDs', async () => {
+    const writes = Array.from({ length: 100 }, (_, i) =>
+      Promise.resolve(
+        writeToDrafts({ repo: 'perf/repo', title: `Issue ${i}`, body: `body ${i}` }, tmpDir),
+      ),
+    )
+
+    const items = await Promise.all(writes)
+    const ids = new Set(items.map((i) => i.id))
+
+    assert.equal(ids.size, 100, 'all 100 IDs should be unique')
+    assert.equal(countPending(tmpDir), 100, 'all 100 files should be on disk')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Reading 1000 items
+// ---------------------------------------------------------------------------
+
+describe('readDrafts() at scale', () => {
+  let tmpDir
+
+  before(() => {
+    tmpDir = makeTempRepo()
+    const dir = getDraftsDir(tmpDir)
+
+    // Pre-seed 1000 items directly (faster than writeToDrafts loop)
+    for (let i = 0; i < 1000; i++) {
+      const id = `perf${String(i).padStart(6, '0')}`
+      const record = {
+        id,
+        repo: 'perf/repo',
+        title: `Issue ${i}`,
+        body: `body ${i}`,
+        labels: [],
+        createdAt: new Date(Date.now() - (1000 - i) * 1000).toISOString(),
+        status: 'pending',
+        attemptCount: 0,
+      }
+      fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify(record), 'utf8')
+    }
+  })
+
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('reads 1000 items in < 500ms', () => {
+    const start = Date.now()
+    const items = readDrafts(tmpDir)
+    const elapsed = Date.now() - start
+
+    assert.equal(items.length, 1000)
+    assert.ok(elapsed < 500, `readDrafts took ${elapsed}ms — expected < 500ms`)
+  })
+
+  test('results are sorted by createdAt', () => {
+    const items = readDrafts(tmpDir)
+    for (let i = 1; i < items.length; i++) {
+      const prev = new Date(items[i - 1].createdAt)
+      const curr = new Date(items[i].createdAt)
+      assert.ok(prev <= curr, `item ${i - 1} should be before item ${i}`)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Corrupt files don't break the rest
+// ---------------------------------------------------------------------------
+
+describe('adversarial: corrupt files in drafts', () => {
+  let tmpDir
+
+  before(() => {
+    tmpDir = makeTempRepo()
+    const dir = getDraftsDir(tmpDir)
+
+    // Write 5 valid items
+    for (let i = 0; i < 5; i++) {
+      writeToDrafts({ repo: 'a/b', title: `Valid ${i}`, body: '' }, tmpDir)
+    }
+
+    // Inject 3 corrupt files
+    fs.writeFileSync(path.join(dir, 'corrupt1.json'), '{ this is not json', 'utf8')
+    fs.writeFileSync(path.join(dir, 'corrupt2.json'), '', 'utf8')
+    fs.writeFileSync(path.join(dir, 'corrupt3.json'), 'null', 'utf8')
+  })
+
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('readDrafts() skips corrupt files and returns all valid items', () => {
+    const items = readDrafts(tmpDir)
+    // Should get 5 valid items (null is valid JSON but has no .id, gets returned anyway)
+    const validItems = items.filter((i) => i && i.id)
+    assert.equal(validItems.length, 5, 'should return all 5 valid items')
+  })
+
+  test('hasPending() does not throw on corrupt dir', () => {
+    assert.doesNotThrow(() => hasPending(tmpDir))
+    assert.equal(hasPending(tmpDir), true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// New write during read doesn't cause double-processing
+// ---------------------------------------------------------------------------
+
+describe('concurrent write during read', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('item written after readDrafts snapshot is not included in that batch', () => {
+    // Write 3 items before read
+    writeToDrafts({ repo: 'c/d', title: 'Pre A', body: '' }, tmpDir)
+    writeToDrafts({ repo: 'c/d', title: 'Pre B', body: '' }, tmpDir)
+    writeToDrafts({ repo: 'c/d', title: 'Pre C', body: '' }, tmpDir)
+
+    // Snapshot the batch
+    const batch = readDrafts(tmpDir)
+    assert.equal(batch.length, 3)
+
+    // Write a new item AFTER reading — simulates concurrent create
+    writeToDrafts({ repo: 'c/d', title: 'Post D', body: '' }, tmpDir)
+
+    // The batch we already read should not include the late arrival
+    const lateArrival = batch.find((i) => i.title === 'Post D')
+    assert.equal(lateArrival, undefined, 'late-arriving item should not appear in existing batch')
+
+    // A fresh read should see all 4
+    const fresh = readDrafts(tmpDir)
+    assert.equal(fresh.length, 4)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// SIGTERM survival (file persists if process would be killed mid-flush)
+// ---------------------------------------------------------------------------
+
+describe('durability: file survives after write', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('draft file exists immediately after writeToDrafts (before any network call)', () => {
+    // Simulate: we write draft, then "crash" (don't call createIssue)
+    const item = writeToDrafts({ repo: 'e/f', title: 'Crash survivor', body: 'important' }, tmpDir)
+
+    // The file should exist on disk right now
+    const dir = getDraftsDir(tmpDir)
+    const filePath = path.join(dir, `${item.id}.json`)
+    assert.ok(fs.existsSync(filePath), 'file must exist immediately after write')
+
+    // Simulate a re-run: readDrafts finds it
+    const recovered = readDrafts(tmpDir)
+    const mine = recovered.find((i) => i.id === item.id)
+    assert.ok(mine, 'file should be recoverable via readDrafts after simulated crash')
+    assert.equal(mine.status, 'pending')
+  })
+})

package/src/lib/drafts.test.js

@@ -0,0 +1,300 @@
+/**
+ * Tests for drafts.js
+ *
+ * Uses real temp directories — no mocks. Each describe block gets its own
+ * isolated tmpDir so tests remain independent and clean up after themselves.
+ */
+
+import { test, describe, before, after, beforeEach } 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 {
+  getDraftsDir,
+  writeToDrafts,
+  readDrafts,
+  markComplete,
+  markFailed,
+  hasPending,
+  countPending,
+} from './drafts.js'
+
+// ---------------------------------------------------------------------------
+// Helper: create a temp dir that looks like a repo root
+// ---------------------------------------------------------------------------
+
+function makeTempRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-drafts-test-'))
+  fs.mkdirSync(path.join(dir, '.git'))
+  return dir
+}
+
+// ---------------------------------------------------------------------------
+// writeToDrafts
+// ---------------------------------------------------------------------------
+
+describe('writeToDrafts()', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('creates a JSON file with correct structure', () => {
+    const item = writeToDrafts(
+      { repo: 'owner/repo', title: 'My issue', body: 'Some body', labels: ['bug'] },
+      tmpDir,
+    )
+
+    assert.equal(item.repo, 'owner/repo')
+    assert.equal(item.title, 'My issue')
+    assert.equal(item.body, 'Some body')
+    assert.deepEqual(item.labels, ['bug'])
+    assert.equal(item.status, 'pending')
+    assert.equal(item.attemptCount, 0)
+    assert.ok(item.id, 'id should be set')
+    assert.ok(item.createdAt, 'createdAt should be set')
+
+    const dir = getDraftsDir(tmpDir)
+    const filePath = path.join(dir, `${item.id}.json`)
+    assert.ok(fs.existsSync(filePath), 'file should exist on disk')
+
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+    assert.deepEqual(parsed, item)
+  })
+
+  test('uses empty array for labels when omitted', () => {
+    const item = writeToDrafts({ repo: 'owner/repo', title: 'No labels', body: 'body' }, tmpDir)
+    assert.deepEqual(item.labels, [])
+  })
+
+  test('two concurrent writeToDrafts() calls produce unique IDs', () => {
+    const a = writeToDrafts({ repo: 'a/b', title: 'A', body: '' }, tmpDir)
+    const b = writeToDrafts({ repo: 'a/b', title: 'B', body: '' }, tmpDir)
+    assert.notEqual(a.id, b.id)
+
+    const dir = getDraftsDir(tmpDir)
+    assert.ok(fs.existsSync(path.join(dir, `${a.id}.json`)))
+    assert.ok(fs.existsSync(path.join(dir, `${b.id}.json`)))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// readDrafts
+// ---------------------------------------------------------------------------
+
+describe('readDrafts()', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('returns empty array when drafts is empty', () => {
+    const items = readDrafts(tmpDir)
+    assert.deepEqual(items, [])
+  })
+
+  test('returns items sorted by createdAt ascending', async () => {
+    // Write three items with intentional ordering
+    const a = writeToDrafts({ repo: 'r/r', title: 'First', body: '' }, tmpDir)
+    await new Promise((r) => setTimeout(r, 5)) // tiny gap so timestamps differ
+    const b = writeToDrafts({ repo: 'r/r', title: 'Second', body: '' }, tmpDir)
+    await new Promise((r) => setTimeout(r, 5))
+    const c = writeToDrafts({ repo: 'r/r', title: 'Third', body: '' }, tmpDir)
+
+    const items = readDrafts(tmpDir)
+    const titles = items.map((i) => i.title)
+    assert.ok(titles.indexOf('First') < titles.indexOf('Second'), 'First should be before Second')
+    assert.ok(titles.indexOf('Second') < titles.indexOf('Third'), 'Second should be before Third')
+  })
+
+  test('ignores non-JSON files gracefully', () => {
+    const dir = getDraftsDir(tmpDir)
+    fs.writeFileSync(path.join(dir, '.DS_Store'), 'junk')
+    fs.writeFileSync(path.join(dir, 'README.txt'), 'not json')
+
+    // Should not throw and should not include the non-JSON files
+    const items = readDrafts(tmpDir)
+    const nonDraft = items.filter((i) => !i.id)
+    assert.equal(nonDraft.length, 0)
+  })
+
+  test('skips corrupt JSON files', () => {
+    const dir = getDraftsDir(tmpDir)
+    fs.writeFileSync(path.join(dir, 'corrupt.json'), '{ invalid json !!!')
+
+    // Should not throw
+    const items = readDrafts(tmpDir)
+    // The corrupt file should be silently skipped
+    const corrupt = items.find((i) => i === undefined)
+    assert.equal(corrupt, undefined)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// markComplete
+// ---------------------------------------------------------------------------
+
+describe('markComplete()', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('deletes the draft file', () => {
+    const item = writeToDrafts({ repo: 'r/r', title: 'To delete', body: '' }, tmpDir)
+    const dir = getDraftsDir(tmpDir)
+    const filePath = path.join(dir, `${item.id}.json`)
+
+    assert.ok(fs.existsSync(filePath))
+    markComplete(item.id, { issueNumber: 42, issueUrl: 'https://github.com/r/r/issues/42' }, tmpDir)
+    assert.ok(!fs.existsSync(filePath), 'file should be deleted')
+  })
+
+  test('is idempotent — does not throw if file already gone', () => {
+    assert.doesNotThrow(() => markComplete('nonexistent-id', {}, tmpDir))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// markFailed
+// ---------------------------------------------------------------------------
+
+describe('markFailed()', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('updates file with status=failed and error message', () => {
+    const item = writeToDrafts({ repo: 'r/r', title: 'Fail me', body: '' }, tmpDir)
+    markFailed(item.id, 'Connection refused', tmpDir)
+
+    const dir = getDraftsDir(tmpDir)
+    const filePath = path.join(dir, `${item.id}.json`)
+    assert.ok(fs.existsSync(filePath), 'file should still exist')
+
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+    assert.equal(parsed.status, 'failed')
+    assert.equal(parsed.error, 'Connection refused')
+    assert.ok(parsed.failedAt, 'failedAt should be set')
+  })
+
+  test('is idempotent — does not throw if file is gone', () => {
+    assert.doesNotThrow(() => markFailed('nonexistent-id', 'error', tmpDir))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// hasPending / countPending
+// ---------------------------------------------------------------------------
+
+describe('hasPending() and countPending()', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('hasPending() returns false when drafts dir does not exist', () => {
+    const freshDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-fresh-'))
+    fs.mkdirSync(path.join(freshDir, '.git'))
+    try {
+      assert.equal(hasPending(freshDir), false)
+    } finally {
+      fs.rmSync(freshDir, { recursive: true, force: true })
+    }
+  })
+
+  test('countPending() returns 0 when drafts is empty', () => {
+    assert.equal(countPending(tmpDir), 0)
+  })
+
+  test('hasPending() returns true after writing an item', () => {
+    writeToDrafts({ repo: 'r/r', title: 'Pending', body: '' }, tmpDir)
+    assert.equal(hasPending(tmpDir), true)
+  })
+
+  test('countPending() counts correctly', () => {
+    writeToDrafts({ repo: 'r/r', title: 'One more', body: '' }, tmpDir)
+    const count = countPending(tmpDir)
+    assert.ok(count >= 2, `Expected at least 2 pending, got ${count}`)
+  })
+
+  test('hasPending() returns false after all items are removed', () => {
+    const items = readDrafts(tmpDir)
+    for (const item of items) {
+      markComplete(item.id, {}, tmpDir)
+    }
+    assert.equal(hasPending(tmpDir), false)
+    assert.equal(countPending(tmpDir), 0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Full round-trip lifecycle
+// ---------------------------------------------------------------------------
+
+describe('Full round-trip: write → read → markComplete', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('lifecycle ends with empty drafts', async () => {
+    // Write three items
+    const a = writeToDrafts({ repo: 'lifecycle/repo', title: 'Issue A', body: 'body a' }, tmpDir)
+    await new Promise((r) => setTimeout(r, 2))
+    const b = writeToDrafts({ repo: 'lifecycle/repo', title: 'Issue B', body: 'body b' }, tmpDir)
+    await new Promise((r) => setTimeout(r, 2))
+    const c = writeToDrafts({ repo: 'lifecycle/repo', title: 'Issue C', body: 'body c' }, tmpDir)
+
+    // Read and verify order
+    const items = readDrafts(tmpDir)
+    assert.equal(items.length, 3)
+    assert.equal(items[0].title, 'Issue A')
+    assert.equal(items[1].title, 'Issue B')
+    assert.equal(items[2].title, 'Issue C')
+
+    // Complete all
+    for (const item of items) {
+      markComplete(item.id, {}, tmpDir)
+    }
+
+    // Drafts should be empty
+    assert.equal(hasPending(tmpDir), false)
+    assert.deepEqual(readDrafts(tmpDir), [])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Migration: old outbox dir → drafts
+// ---------------------------------------------------------------------------
+
+describe('outbox → drafts migration', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('auto-renames .tissues/outbox/ to .tissues/drafts/ on first access', () => {
+    // Simulate an old outbox directory
+    const oldDir = path.join(tmpDir, '.tissues', 'outbox')
+    fs.mkdirSync(oldDir, { recursive: true })
+    fs.writeFileSync(path.join(oldDir, 'test-issue.json'), JSON.stringify({
+      id: 'test-issue',
+      repo: 'r/r',
+      title: 'Test issue',
+      body: '',
+      labels: [],
+      createdAt: new Date().toISOString(),
+      status: 'pending',
+    }))
+
+    // getDraftsDir should migrate
+    const dir = getDraftsDir(tmpDir)
+    assert.ok(dir.endsWith('.tissues/drafts'), `Expected drafts dir, got ${dir}`)
+    assert.ok(!fs.existsSync(oldDir), 'old outbox dir should be gone')
+    assert.ok(fs.existsSync(path.join(dir, 'test-issue.json')), 'migrated file should exist')
+  })
+})