Å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.
247 lines
7.9 KiB
TypeScript
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 }) }),
|
|
)
|
|
})
|
|
})
|