157 lines
12 KiB
TypeScript
157 lines
12 KiB
TypeScript
import { beforeEach, expect, it, vi } from 'vitest'
|
|
import { ApiResponseError } from '@/shared/api/http'
|
|
import { useDispatchCommandRecovery } from './dispatchCommandRecovery'
|
|
import { command } from './dispatchTestFixtures'
|
|
beforeEach(() => sessionStorage.clear())
|
|
it('rejects a loading result that has not completed loading', async () => {
|
|
const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
|
|
recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: 0, idempotencyKey: 'key' })
|
|
const read = vi.fn()
|
|
await expect(recovery.execute(vi.fn().mockResolvedValue({ ...command('LOADING_COMPLETE'), stage: 'LOADING' }), read, vi.fn())).rejects.toThrow('装车完成')
|
|
expect(read).not.toHaveBeenCalled()
|
|
expect(recovery.pending.value?.result).toBeNull()
|
|
expect(recovery.pending.value?.body.idempotencyKey).toBe('key')
|
|
})
|
|
it('retains the exact original version and body when POST outcome is unknown and a newer detail was read', async () => {
|
|
const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
|
|
recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: 0, idempotencyKey: 'key', remark: 'original' })
|
|
const send = vi.fn().mockRejectedValueOnce(new Error('network unknown')).mockResolvedValueOnce(command('LOADING_COMPLETE'))
|
|
const read = vi.fn().mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: 50 }), find = vi.fn().mockRejectedValue(new ApiResponseError('not found', 'HTTP_404'))
|
|
await expect(recovery.execute(send, read, find)).rejects.toThrow('network unknown')
|
|
await recovery.execute(send, read, find)
|
|
expect(send.mock.calls[1]![0].body).toEqual({ recordVersion: 0, idempotencyKey: 'key', remark: 'original' })
|
|
expect(recovery.pending.value).toBeNull()
|
|
})
|
|
it('keeps a proven result across GET failure and does not send the command a second time', async () => {
|
|
const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
|
|
recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: 0, idempotencyKey: 'key' })
|
|
const send = vi.fn().mockResolvedValue(command('LOADING_COMPLETE')), read = vi.fn().mockRejectedValueOnce(new Error('read failed')).mockResolvedValueOnce({ dispatchNo: 'PC/1', recordVersion: 1 }), find = vi.fn()
|
|
await expect(recovery.execute(send, read, find)).rejects.toThrow('read failed')
|
|
expect(recovery.pending.value?.result?.stage).toBe('AFTER_LOADING')
|
|
expect(JSON.parse(sessionStorage.getItem(`dispatch-command:${owner}`)!).result).toEqual(command('LOADING_COMPLETE'))
|
|
const reopened = useDispatchCommandRecovery(() => owner)
|
|
expect(reopened.pending.value?.result).toEqual(command('LOADING_COMPLETE'))
|
|
await reopened.execute(send, read, find)
|
|
expect(send).toHaveBeenCalledTimes(1); expect(find).not.toHaveBeenCalled()
|
|
expect(reopened.pending.value).toBeNull(); expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
|
|
})
|
|
it('shares one pending command between empty-create and workflow dialogs and refuses a new command', () => {
|
|
const owner = crypto.randomUUID(), first = useDispatchCommandRecovery(() => owner), second = useDispatchCommandRecovery(() => owner)
|
|
first.begin('PC/1', 'EDIT', { recordVersion: 0, idempotencyKey: 'key' })
|
|
expect(second.pending.value?.dispatchNo).toBe('PC/1')
|
|
expect(() => second.begin('', 'CREATE', { idempotencyKey: 'new' })).toThrow('原请求')
|
|
})
|
|
it('does not discard an earlier unknown write on a later business rejection', async () => {
|
|
const recovery = useDispatchCommandRecovery(() => crypto.randomUUID())
|
|
expect(() => recovery.begin('PC/1', 'EDIT', { recordVersion: 0, idempotencyKey: 'key' })).toThrow('账号')
|
|
const owner = crypto.randomUUID(), stable = useDispatchCommandRecovery(() => owner)
|
|
stable.begin('PC/1', 'EDIT', { recordVersion: 0, idempotencyKey: 'key' })
|
|
const send = vi.fn().mockRejectedValueOnce(new Error('unknown')).mockRejectedValueOnce(new ApiResponseError('version conflict', 'A0409'))
|
|
const find = vi.fn().mockRejectedValue(new ApiResponseError('not found', 'HTTP_404'))
|
|
await expect(stable.execute(send, vi.fn(), find)).rejects.toThrow('unknown')
|
|
await expect(stable.execute(send, vi.fn(), find)).rejects.toThrow('version conflict')
|
|
stable.discardRejected(); expect(stable.pending.value).not.toBeNull()
|
|
expect(find).toHaveBeenCalledWith('PC/1', 'key')
|
|
expect(send.mock.calls[1]![0].body).toEqual({ recordVersion: 0, idempotencyKey: 'key' })
|
|
expect(stable.pending.value?.rejected).toBe(false)
|
|
const saved = JSON.parse(sessionStorage.getItem(`dispatch-command:${owner}`)!)
|
|
expect(saved).toMatchObject({ attempted: true, rejected: false, result: null, body: { recordVersion: 0, idempotencyKey: 'key' } })
|
|
expect(useDispatchCommandRecovery(() => owner).pending.value).toEqual(saved)
|
|
})
|
|
it('rejects a mismatched business number/action/key instead of treating it as successful', async () => {
|
|
const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
|
|
recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: 0, idempotencyKey: 'key' })
|
|
const read = vi.fn()
|
|
await expect(recovery.execute(vi.fn().mockResolvedValue(command('LOADING_COMPLETE', 'different')), read, vi.fn())).rejects.toThrow('不一致')
|
|
expect(read).not.toHaveBeenCalled(); expect(recovery.pending.value).not.toBeNull()
|
|
})
|
|
it('does not release a proven result for an older detail version, including versions beyond safe integer precision', async () => {
|
|
const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
|
|
recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: '9007199254740992', idempotencyKey: 'key' })
|
|
const send = vi.fn().mockResolvedValue({ ...command('LOADING_COMPLETE'), recordVersion: '9007199254740993' }), find = vi.fn()
|
|
await expect(recovery.execute(send, vi.fn().mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: '9007199254740992' }), find)).rejects.toThrow('详情版本早于')
|
|
expect(recovery.pending.value?.result).not.toBeNull()
|
|
await recovery.execute(send, vi.fn().mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: '9007199254740994' }), find)
|
|
expect(send).toHaveBeenCalledTimes(1); expect(recovery.pending.value).toBeNull()
|
|
})
|
|
it('treats an internal server error as unknown instead of authorizing a new command', async () => {
|
|
const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
|
|
recovery.begin('PC/1', 'EDIT', { recordVersion: 0, idempotencyKey: 'key' })
|
|
await expect(recovery.execute(vi.fn().mockRejectedValue(new ApiResponseError('server failure', 'A0500', 500)), vi.fn(), vi.fn())).rejects.toThrow('server failure')
|
|
recovery.discardRejected(); expect(recovery.pending.value?.rejected).toBe(false)
|
|
})
|
|
it.each(['400', '401', '403', '404', '409', '410', '422'].flatMap(code => [code, `A0${code}`, `HTTP_${code}`]))(
|
|
'clears the first definite rejection %s from memory and storage and preserves its original error', async code => {
|
|
const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
|
|
recovery.begin('PC/1', 'SUBMIT_REVIEW', { recordVersion: 0, idempotencyKey: 'rejected-key' })
|
|
const rejection = new ApiResponseError('明确拒绝', code)
|
|
const send = vi.fn().mockRejectedValue(rejection), read = vi.fn(), find = vi.fn()
|
|
await expect(recovery.execute(send, read, find)).rejects.toBe(rejection)
|
|
expect(send).toHaveBeenCalledTimes(1)
|
|
expect(read).not.toHaveBeenCalled(); expect(find).not.toHaveBeenCalled()
|
|
expect(recovery.pending.value).toBeNull(); expect(recovery.busy.value).toBe(false)
|
|
expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
|
|
const reopened = useDispatchCommandRecovery(() => owner)
|
|
expect(reopened.pending.value).toBeNull()
|
|
expect(() => reopened.begin('PC/1', 'EDIT', { recordVersion: 2, idempotencyKey: 'fresh-key' })).not.toThrow()
|
|
},
|
|
)
|
|
it('cleans an explicitly rejected legacy browser record when its scope is restored', () => {
|
|
const owner = crypto.randomUUID(), key = `dispatch-command:${owner}`
|
|
sessionStorage.setItem(key, JSON.stringify({ dispatchNo: 'PC/1', action: 'SUBMIT_REVIEW',
|
|
body: { recordVersion: 0, idempotencyKey: 'terminal-key' }, attempted: true, rejected: true, result: null }))
|
|
const recovery = useDispatchCommandRecovery(() => owner)
|
|
expect(recovery.pending.value).toBeNull(); expect(sessionStorage.getItem(key)).toBeNull()
|
|
expect(() => recovery.begin('PC/1', 'EDIT', { recordVersion: 1, idempotencyKey: 'new-key' })).not.toThrow()
|
|
})
|
|
it('cleans a terminal rejected record already shared by dialogs in the same scope', () => {
|
|
const owner = crypto.randomUUID(), first = useDispatchCommandRecovery(() => owner)
|
|
first.begin('PC/1', 'SUBMIT_REVIEW', { recordVersion: 0, idempotencyKey: 'terminal-key' })
|
|
first.pending.value!.attempted = true; first.pending.value!.rejected = true
|
|
sessionStorage.setItem(`dispatch-command:${owner}`, JSON.stringify(first.pending.value))
|
|
const second = useDispatchCommandRecovery(() => owner)
|
|
expect(second.pending).toBe(first.pending)
|
|
expect(first.pending.value).toBeNull(); expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
|
|
})
|
|
it('retains a restored unknown record without explicit rejection proof and reconciles its original key', async () => {
|
|
const owner = crypto.randomUUID(), key = `dispatch-command:${owner}`
|
|
const original = { dispatchNo: 'PC/1', action: 'EDIT', body: { recordVersion: 0, idempotencyKey: 'unknown-key', remark: 'original' },
|
|
attempted: true, rejected: false, result: null }
|
|
sessionStorage.setItem(key, JSON.stringify(original))
|
|
const recovery = useDispatchCommandRecovery(() => owner)
|
|
expect(recovery.pending.value).toEqual(original)
|
|
const rejection = new ApiResponseError('later rejection', 'A0409')
|
|
const send = vi.fn().mockRejectedValue(rejection), read = vi.fn()
|
|
const find = vi.fn().mockRejectedValue(new ApiResponseError('not found', 'HTTP_404'))
|
|
await expect(recovery.execute(send, read, find)).rejects.toBe(rejection)
|
|
expect(find).toHaveBeenCalledWith('PC/1', 'unknown-key')
|
|
expect(send.mock.calls[0]![0].body).toEqual(original.body)
|
|
expect(read).not.toHaveBeenCalled()
|
|
expect(recovery.pending.value).toEqual(original); expect(JSON.parse(sessionStorage.getItem(key)!)).toEqual(original)
|
|
})
|
|
it('only rereads a restored proven result and keeps it when the detail read still fails', async () => {
|
|
const owner = crypto.randomUUID(), key = `dispatch-command:${owner}`
|
|
const original = { dispatchNo: 'PC/1', action: 'LOADING_COMPLETE', body: { recordVersion: 0, idempotencyKey: 'key' },
|
|
attempted: true, rejected: false, result: command('LOADING_COMPLETE') }
|
|
sessionStorage.setItem(key, JSON.stringify(original))
|
|
const recovery = useDispatchCommandRecovery(() => owner)
|
|
const send = vi.fn(), find = vi.fn(), failure = new Error('detail unavailable')
|
|
const read = vi.fn().mockRejectedValueOnce(failure).mockResolvedValueOnce({ dispatchNo: 'PC/1', recordVersion: 1 })
|
|
await expect(recovery.execute(send, read, find)).rejects.toBe(failure)
|
|
expect(recovery.pending.value).toEqual(original); expect(JSON.parse(sessionStorage.getItem(key)!)).toEqual(original)
|
|
await recovery.execute(send, read, find)
|
|
expect(send).not.toHaveBeenCalled(); expect(find).not.toHaveBeenCalled(); expect(read).toHaveBeenCalledTimes(2)
|
|
expect(recovery.pending.value).toBeNull(); expect(sessionStorage.getItem(key)).toBeNull()
|
|
})
|
|
|
|
it('accepts a loading confirmation that already departed and recovers it without resubmitting', async () => {
|
|
const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
|
|
recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: 0, idempotencyKey: 'key' })
|
|
const send = vi.fn().mockResolvedValue({ ...command('LOADING_COMPLETE'), stage: 'DELIVERING', recordVersion: 3 })
|
|
const read = vi.fn().mockRejectedValueOnce(new Error('read failed')).mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: 3 })
|
|
await expect(recovery.execute(send, read, vi.fn())).rejects.toThrow('read failed')
|
|
expect(recovery.pending.value?.result?.stage).toBe('DELIVERING')
|
|
await recovery.execute(send, read, vi.fn())
|
|
expect(send).toHaveBeenCalledTimes(1); expect(recovery.pending.value).toBeNull()
|
|
})
|