Skip to content

armgit / ODS

Public Imported from GitHub
0

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.

7.6 KB
Raw Blame
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()
})