e5ce3fe87a
While gitea is unreachable, propose-approved writes queue instead of being lost; on reconnect they replay in order. The hard requirement is no duplication. The mechanism is coalescing by axis. Every write targets one field of one issue (estimate / priority / assignee / milestone), so `issue:kind` is the axis identity. Queuing a second write to the same axis supersedes the first (moved to the tail), so a burst of edits replays as one final write — and replay is idempotent (the apply path no-ops a change already reflected server-side). - `enqueueWrite` (coalesce), `pendingWrites`, `coalesceKey`, `affectedIssues` (what a post-replay reconcile re-reads), and `replayQueue(queue, apply)` which drains through the same guarded write path and returns the writes that still failed so they stay queued. Never throws — a failure is data. Acceptance met: a burst of offline edits + reconnect lands the final state with a single apply per axis (not one per edit); still-failing writes stay queued. +4 core tests; typecheck green. Follow-up: persist the queue in main + trigger replay on the reconnect signal (the offline banner + disabled composer already exist) — the coalesce/replay core is the tested heart. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
68 lines
3.0 KiB
TypeScript
68 lines
3.0 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest'
|
|
|
|
import type { IssueChange } from '../changes/apply-changes-v0.js'
|
|
import { affectedIssues, coalesceKey, enqueueWrite, pendingWrites, replayQueue, type QueuedWrite } from './write-queue-v0.js'
|
|
|
|
const reest = (issue: number, estimate: string): IssueChange =>
|
|
({ kind: 'reestimate', issue, estimate }) as IssueChange
|
|
const assign = (issue: number, assignee: string | null): IssueChange => ({ kind: 'assign', issue, assignee })
|
|
|
|
describe('write-queue-v0 (#33)', () => {
|
|
it('coalesces repeat writes to the same (issue, axis) — replay applies the latest once', () => {
|
|
let q: QueuedWrite[] = []
|
|
q = enqueueWrite(q, reest(7, 'est/2d'), '2026-02-10T09:00:00Z')
|
|
q = enqueueWrite(q, reest(7, 'est/5d'), '2026-02-10T09:05:00Z') // supersedes est/2d
|
|
q = enqueueWrite(q, assign(7, 'christian'), '2026-02-10T09:06:00Z') // different axis — kept
|
|
|
|
expect(q).toHaveLength(2)
|
|
const pending = pendingWrites(q)
|
|
expect(pending).toEqual([
|
|
{ kind: 'reestimate', issue: 7, estimate: 'est/5d' },
|
|
{ kind: 'assign', issue: 7, assignee: 'christian' },
|
|
])
|
|
expect(coalesceKey(reest(7, 'est/2d'))).toBe('7:reestimate')
|
|
})
|
|
|
|
it('keeps writes to different issues and axes distinct', () => {
|
|
let q: QueuedWrite[] = []
|
|
q = enqueueWrite(q, reest(7, 'est/2d'), 't1')
|
|
q = enqueueWrite(q, reest(8, 'est/3d'), 't2')
|
|
q = enqueueWrite(q, assign(8, null), 't3')
|
|
expect(q).toHaveLength(3)
|
|
expect(affectedIssues(q)).toEqual([7, 8])
|
|
})
|
|
|
|
it('a burst of edits then reconnect lands the final state without duplicating', async () => {
|
|
let q: QueuedWrite[] = []
|
|
// offline: three edits to #7's estimate, one assign
|
|
q = enqueueWrite(q, reest(7, 'est/1d'), 't1')
|
|
q = enqueueWrite(q, reest(7, 'est/2d'), 't2')
|
|
q = enqueueWrite(q, reest(7, 'est/8d'), 't3')
|
|
q = enqueueWrite(q, assign(7, 'stephen'), 't4')
|
|
|
|
const apply = vi.fn(async () => ({ ok: true }))
|
|
const { drained, remaining } = await replayQueue(q, apply)
|
|
|
|
// only the final estimate + the assign are applied — not three estimate writes
|
|
expect(apply).toHaveBeenCalledTimes(2)
|
|
expect(apply).toHaveBeenNthCalledWith(1, { kind: 'reestimate', issue: 7, estimate: 'est/8d' })
|
|
expect(apply).toHaveBeenNthCalledWith(2, { kind: 'assign', issue: 7, assignee: 'stephen' })
|
|
expect(remaining).toHaveLength(0)
|
|
expect(drained).toHaveLength(2)
|
|
})
|
|
|
|
it('keeps writes that still fail on reconnect queued (never throws)', async () => {
|
|
let q: QueuedWrite[] = []
|
|
q = enqueueWrite(q, reest(7, 'est/2d'), 't1')
|
|
q = enqueueWrite(q, reest(8, 'est/3d'), 't2')
|
|
// #7 applies, #8 rejects (still unreachable) — and one apply throws
|
|
const apply = vi.fn(async (c: IssueChange) => {
|
|
if (c.issue === 8) throw new Error('offline')
|
|
return { ok: true }
|
|
})
|
|
const { drained, remaining } = await replayQueue(q, apply)
|
|
expect(drained.map((w) => w.change.issue)).toEqual([7])
|
|
expect(remaining.map((w) => w.change.issue)).toEqual([8])
|
|
})
|
|
})
|