Files
accounted/components/agent/__tests__/conversation-list-mutations.test.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

247 lines
7.9 KiB
TypeScript

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import type { ConversationRow } from '../conversation-display'
import {
createRevisionGuard,
patchConversation,
removeRow,
restoreRow,
runOptimisticPatch,
setPinned,
setTitle,
} from '../conversation-mutations'
/**
* These exercise the REAL transforms and the real write coordinator, not copies
* of them: deleting the rollback or the response check makes this suite fail.
*
* What is being protected: the /chat sidebar used to fire pin, archive and
* rename blind, so a failed archive removed a row that still existed on the
* server and a failed rename showed a title the server never saved, both until
* the next reload.
*/
const row = (over: Partial<ConversationRow> = {}): ConversationRow => ({
id: 'c1',
intent_id: 'general.help',
context_ref: null,
title: 'Juli mot juni',
pinned: false,
archived: false,
last_message_at: '2026-07-26T10:00:00Z',
last_message_preview: 'Juli gick 12 procent bättre',
created_at: '2026-07-26T09:00:00Z',
...over,
})
/** Minimal stand-in for React's setState updater contract. */
function fakeState(initial: ConversationRow[]) {
let current = initial
return {
set: (updater: (prev: ConversationRow[]) => ConversationRow[]) => {
current = updater(current)
},
get list() {
return current
},
}
}
beforeEach(() => {
vi.clearAllMocks()
})
afterEach(() => {
vi.restoreAllMocks()
// restoreAllMocks does not undo vi.stubGlobal, so the stubbed fetch would
// otherwise outlive this file.
vi.unstubAllGlobals()
})
describe('restoreRow', () => {
it('puts an archived row back into the CURRENT list, keeping later changes', () => {
const a = row({ id: 'a', last_message_at: '2026-07-26T12:00:00Z' })
const b = row({ id: 'b', last_message_at: '2026-07-26T11:00:00Z' })
// While the archive of `a` was in flight, the user renamed `b`.
const currentAfterOtherEdit = [{ ...b, title: 'Nytt namn' }]
const restored = restoreRow(currentAfterOtherEdit, a)
expect(restored.map((c) => c.id)).toEqual(['a', 'b'])
// The concurrent rename must survive: restoring a stale snapshot of the
// whole list would have thrown it away.
expect(restored.find((c) => c.id === 'b')!.title).toBe('Nytt namn')
})
it('re-inserts by the server ordering: pinned first, then most recent', () => {
const pinned = row({ id: 'p', pinned: true })
const newer = row({ id: 'n', last_message_at: '2026-07-26T12:00:00Z' })
const older = row({ id: 'o', last_message_at: '2026-07-20T12:00:00Z' })
expect(restoreRow([newer, older], pinned).map((c) => c.id)).toEqual(['p', 'n', 'o'])
expect(
restoreRow([pinned, older], row({ id: 'mid', last_message_at: '2026-07-25T12:00:00Z' })).map(
(c) => c.id,
),
).toEqual(['p', 'mid', 'o'])
})
it('is a no-op when the row is already present', () => {
const list = [row({ id: 'a' })]
expect(restoreRow(list, row({ id: 'a' }))).toBe(list)
})
})
describe('runOptimisticPatch', () => {
it('applies immediately and keeps the change when the server accepts it', async () => {
const state = fakeState([row({ id: 'c1' })])
const ok = await runOptimisticPatch({
id: 'c1',
body: { pinned: true },
apply: (l) => setPinned(l, 'c1', true),
revert: (l) => setPinned(l, 'c1', false),
setList: state.set,
guard: createRevisionGuard(),
onError: () => {},
patch: async () => true,
})
expect(ok).toBe(true)
expect(state.list[0]!.pinned).toBe(true)
})
it('reverts and reports when the server refuses', async () => {
const state = fakeState([row({ id: 'c1', title: 'Original' })])
const onError = vi.fn()
const ok = await runOptimisticPatch({
id: 'c1',
body: { title: 'Nytt' },
apply: (l) => setTitle(l, 'c1', 'Nytt'),
revert: (l) => setTitle(l, 'c1', 'Original'),
setList: state.set,
guard: createRevisionGuard(),
onError,
patch: async () => false,
})
expect(ok).toBe(false)
expect(state.list[0]!.title).toBe('Original')
expect(onError).toHaveBeenCalledOnce()
})
it('does not roll back over a newer write to the same row', async () => {
// Double-click on pin: the first request fails AFTER the second has already
// set the newer value. Reverting here would clobber it.
const state = fakeState([row({ id: 'c1', pinned: false })])
const guard = createRevisionGuard()
const onError = vi.fn()
let releaseFirst: (v: boolean) => void = () => {}
const first = runOptimisticPatch({
id: 'c1',
body: { pinned: true },
apply: (l) => setPinned(l, 'c1', true),
revert: (l) => setPinned(l, 'c1', false),
setList: state.set,
guard,
onError,
patch: () => new Promise<boolean>((resolve) => (releaseFirst = resolve)),
})
// Second write lands and succeeds while the first is still in flight.
await runOptimisticPatch({
id: 'c1',
body: { pinned: false },
apply: (l) => setPinned(l, 'c1', false),
revert: (l) => setPinned(l, 'c1', true),
setList: state.set,
guard,
onError,
patch: async () => true,
})
releaseFirst(false)
await first
// The newer write owns the row: its value stands and no error is shown for
// a change the user already superseded.
expect(state.list[0]!.pinned).toBe(false)
expect(onError).not.toHaveBeenCalled()
})
it('still rolls back a stale write to a DIFFERENT row', async () => {
const state = fakeState([row({ id: 'a', pinned: false }), row({ id: 'b', pinned: false })])
const guard = createRevisionGuard()
const onError = vi.fn()
await runOptimisticPatch({
id: 'b',
body: { pinned: true },
apply: (l) => setPinned(l, 'b', true),
revert: (l) => setPinned(l, 'b', false),
setList: state.set,
guard,
onError,
patch: async () => true,
})
await runOptimisticPatch({
id: 'a',
body: { pinned: true },
apply: (l) => setPinned(l, 'a', true),
revert: (l) => setPinned(l, 'a', false),
setList: state.set,
guard,
onError,
patch: async () => false,
})
expect(state.list.find((c) => c.id === 'a')!.pinned).toBe(false)
expect(state.list.find((c) => c.id === 'b')!.pinned).toBe(true)
expect(onError).toHaveBeenCalledOnce()
})
it('restores an archived row into the list as it stands when the request fails', async () => {
const archived = row({ id: 'a', last_message_at: '2026-07-26T12:00:00Z' })
const other = row({ id: 'b', last_message_at: '2026-07-26T11:00:00Z' })
const state = fakeState([archived, other])
await runOptimisticPatch({
id: 'a',
body: { archived: true },
apply: (l) => removeRow(l, 'a'),
revert: (l) => restoreRow(l, archived),
setList: state.set,
guard: createRevisionGuard(),
onError: () => {},
patch: async () => false,
})
expect(state.list.map((c) => c.id)).toEqual(['a', 'b'])
})
})
describe('patchConversation', () => {
it('reports failure for a non-2xx instead of assuming success', async () => {
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: false, status: 403 }))
expect(await patchConversation('c1', { pinned: true })).toBe(false)
})
it('reports failure when the request throws (offline)', async () => {
vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new TypeError('Failed to fetch')))
// Must not reject: an unhandled rejection was the old behaviour.
expect(await patchConversation('c1', { pinned: true })).toBe(false)
})
it('sends the PATCH to the conversation endpoint', async () => {
const fetchMock = vi.fn().mockResolvedValue({ ok: true })
vi.stubGlobal('fetch', fetchMock)
await patchConversation('c1', { archived: true })
expect(fetchMock).toHaveBeenCalledWith(
'/api/agent/conversations/c1',
expect.objectContaining({ method: 'PATCH', body: JSON.stringify({ archived: true }) }),
)
})
})