ODS V3 Pre-Release: Public testing and refinement ahead of the official V3 launch. Turn your PC, Mac, or Linux box into a private AI server.
Python ai-agentsamdcomfyuidockerllama-cppllmlocal-ain8nnvidiaopen-webuiragself-hostedspeech-to-textstrix-halotext-to-speechworkflow-automation
import {act,fireEvent,render,screen,waitFor} from '@testing-library/react'
import PortalModelRecovery from './PortalModelRecovery'
const pending={pending:true,phase:'applied',transactionId:'a'.repeat(64)}
const done={...pending,pending:false,phase:'completed',outcome:'commit'}
const reply=(body,ok=true)=>({ok,json:async()=>body})
afterEach(()=>vi.unstubAllGlobals())
it('does not call an owned activation interrupted or offer competing recovery',async()=>{
vi.stubGlobal('fetch',vi.fn(async()=>reply(pending)))
const view=render(<PortalModelRecovery operationActive/>)
const button=await screen.findByRole('button',{name:'Recover model switch'})
expect(button).toBeDisabled()
expect(screen.getByText(/A model operation is in progress/)).toBeVisible()
expect(screen.queryByText(/was interrupted/)).toBeNull()
fireEvent.click(button)
expect(fetch.mock.calls.every(([,options])=>options.method!=='POST')).toBe(true)
view.rerender(<PortalModelRecovery operationActive={false}/>)
expect(button).toBeEnabled()
expect(screen.getByText(/still needs verification/)).toBeVisible()
})
it('is invisible for an idle or unsupported runtime and never starts recovery automatically',async()=>{
vi.stubGlobal('fetch',vi.fn(async()=>reply({pending:false,phase:'idle',transactionId:null})))
const {container}=render(<PortalModelRecovery/>)
await waitFor(()=>expect(fetch).toHaveBeenCalledOnce())
expect(container).toBeEmptyDOMElement()
expect(fetch.mock.calls[0][1].method).toBeUndefined()
})
it('waits for an active operation to end before retiring an externally recovered error',async()=>{
let state=pending
vi.stubGlobal('fetch',vi.fn(async()=>reply(state)))
const recovered=vi.fn()
const view=render(<PortalModelRecovery onRecovered={recovered}/>)
await screen.findByRole('button',{name:'Recover model switch'})
state=done
view.rerender(<PortalModelRecovery onRecovered={recovered} operationActive/>)
await waitFor(()=>expect(screen.queryByRole('button')).toBeNull())
expect(recovered).not.toHaveBeenCalled()
view.rerender(<PortalModelRecovery onRecovered={recovered} operationActive={false}/>)
await waitFor(()=>expect(recovered).toHaveBeenCalledOnce())
view.rerender(<PortalModelRecovery onRecovered={recovered} refreshKey={1}/>)
await act(async()=>{})
expect(recovered).toHaveBeenCalledOnce()
expect(fetch.mock.calls.every(([,options])=>!options.method)).toBe(true)
})
it('recovers only the existing transaction and prevents duplicate clicks',async()=>{
let resolvePost
vi.stubGlobal('fetch',vi.fn(async(_,options)=>options?.method==='POST'?await new Promise(resolve=>{resolvePost=resolve}):reply(pending)))
const recovered=vi.fn(),busy=vi.fn(),changed=vi.fn()
render(<PortalModelRecovery onRecovered={recovered} onBusyChange={busy} onPendingChange={changed}/>)
const button=await screen.findByRole('button',{name:'Recover model switch'})
fireEvent.click(button);fireEvent.click(button)
expect(fetch.mock.calls.filter(([,options])=>options.method==='POST')).toHaveLength(1)
expect(fetch.mock.calls[1][1]).toMatchObject({method:'POST',body:'{}'})
expect(busy).toHaveBeenLastCalledWith(true)
await act(async()=>resolvePost(reply(done)))
expect(recovered).toHaveBeenCalledOnce()
expect(changed).toHaveBeenLastCalledWith(false)
expect(screen.queryByRole('button')).toBeNull()
})
it('keeps pending work and explains missing proof without claiming success',async()=>{
vi.stubGlobal('fetch',vi.fn(async(_,options)=>reply(options?.method==='POST'?{...pending,reason:'model-recovery-proof-required'}:pending,options?.method!=='POST')))
const recovered=vi.fn()
render(<PortalModelRecovery onRecovered={recovered}/>)
fireEvent.click(await screen.findByRole('button',{name:'Recover model switch'}))
expect(await screen.findByRole('alert')).toHaveTextContent('still needs repair')
expect(recovered).not.toHaveBeenCalled()
expect(screen.getByRole('button',{name:'Recover model switch'})).toBeEnabled()
expect(screen.queryByRole('button',{name:'Release without checking'})).toBeNull()
expect(screen.getByRole('link',{name:/Get help on Discord/})).toBeVisible()
})
it('offers a release without the live proof only when the switch changed nothing',async()=>{
// Fleet row 27: a cloud-default model can never be proven, so recovery waited forever.
const posts=[]
vi.stubGlobal('fetch',vi.fn(async(_,options)=>{
if(options?.method!=='POST')return reply(pending)
posts.push(options.body)
return posts.length===1
? reply({...pending,reason:'model-recovery-proof-required',releasable:true},false)
: reply({...done,outcome:'rollback'})
}))
const recovered=vi.fn()
render(<PortalModelRecovery onRecovered={recovered}/>)
fireEvent.click(await screen.findByRole('button',{name:'Recover model switch'}))
expect(await screen.findByRole('alert')).toHaveTextContent('could not confirm the model Portal used')
expect(screen.getByRole('link',{name:/Get help on Discord/})).toBeVisible()
fireEvent.click(screen.getByRole('button',{name:'Release without checking'}))
await waitFor(()=>expect(recovered).toHaveBeenCalledOnce())
expect(posts).toEqual(['{}','{"releaseUnverified":true}'])
})
it('a lost response does not replay the mutation or mark it complete',async()=>{
vi.stubGlobal('fetch',vi.fn(async(_,options)=>{if(options?.method==='POST')throw new Error('lost');return reply(pending)}))
const recovered=vi.fn()
render(<PortalModelRecovery onRecovered={recovered}/>)
fireEvent.click(await screen.findByRole('button',{name:'Recover model switch'}))
expect(await screen.findByRole('alert')).toHaveTextContent('could not be confirmed')
expect(fetch.mock.calls.filter(([,options])=>options.method==='POST')).toHaveLength(1)
expect(recovered).not.toHaveBeenCalled()
})
it.each([
[409,pending],
[503,{pending:true,phase:'unavailable',transactionId:null}],
])('shows a validated pending receipt returned with HTTP %s',async(status,state)=>{
vi.stubGlobal('fetch',vi.fn(async()=>({...reply(state,false),status})))
const changed=vi.fn(),recovered=vi.fn()
render(<PortalModelRecovery onPendingChange={changed} onRecovered={recovered}/>)
expect(await screen.findByRole('button',{name:'Recover model switch'})).toBeEnabled()
expect(changed).toHaveBeenLastCalledWith(true)
expect(recovered).not.toHaveBeenCalled()
expect(fetch.mock.calls.every(([,options])=>!options.method)).toBe(true)
})
it.each([
[404,pending],
[500,pending],
[503,{detail:'unavailable'}],
[409,{pending:false,phase:'held',transactionId:'a'.repeat(64)}],
])('does not infer recovery state from an unrelated or invalid HTTP %s response',async(status,state)=>{
vi.stubGlobal('fetch',vi.fn(async()=>({...reply(state,false),status})))
const changed=vi.fn(),recovered=vi.fn()
const view=render(<PortalModelRecovery onPendingChange={changed} onRecovered={recovered}/>)
await act(async()=>{})
expect(view.container).toBeEmptyDOMElement()
expect(changed).not.toHaveBeenCalled()
expect(recovered).not.toHaveBeenCalled()
})
it('closing the menu does not abort accepted recovery; reopening reads persisted state',async()=>{
let resolvePost,signal
vi.stubGlobal('fetch',vi.fn(async(_,options)=>{
if(options?.method==='POST'){signal=options.signal;return await new Promise(resolve=>{resolvePost=resolve})}
return reply(pending)
}))
const recovered=vi.fn()
const view=render(<PortalModelRecovery active onRecovered={recovered}/>)
fireEvent.click(await screen.findByRole('button',{name:'Recover model switch'}))
view.rerender(<PortalModelRecovery active={false} onRecovered={recovered}/>)
expect(signal.aborted).toBe(false)
await act(async()=>resolvePost(reply(done)))
expect(recovered).toHaveBeenCalledOnce()
})