Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

3.6 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest'
import { PromiseSettlementWaiters } from './promise-settlement-waiters'

describe('PromiseSettlementWaiters', () => {
  it.each([false, true])('preserves abort scheduling with abortInMicrotask=%s', async (defer) => {
    let resolveBase = (_value: string): void => {}
    const base = new Promise<string>((resolve) => {
      resolveBase = resolve
    })
    const waiters = new PromiseSettlementWaiters(base)
    const controller = new AbortController()
    const reason = { code: 'aborted' }
    const wait = waiters.wait({
      signal: controller.signal,
      abortInMicrotask: defer,
      createAbortError: () => reason
    })
    resolveBase('raw result')
    controller.abort()
    await (defer ? expect(wait).resolves.toBe('raw result') : expect(wait).rejects.toBe(reason))
    expect(waiters.waiterCount).toBe(0)
  })

  it('lets an earlier deferred abort win over a later raw settlement', async () => {
    let resolveBase = (_value: string): void => {}
    const base = new Promise<string>((resolve) => {
      resolveBase = resolve
    })
    const waiters = new PromiseSettlementWaiters(base)
    const controller = new AbortController()
    const wait = waiters.wait({
      signal: controller.signal,
      abortInMicrotask: true,
      createAbortError: () => false
    })
    controller.abort()
    resolveBase('raw result')
    await expect(wait).rejects.toBe(false)
    expect(waiters.waiterCount).toBe(0)
  })

  it('removes ten thousand aborted callers while one anchor remains pending', async () => {
    let resolveBase: (value: number) => void = () => {}
    const basePromise = new Promise<number>((resolve) => {
      resolveBase = resolve
    })
    const thenSpy = vi.spyOn(basePromise, 'then')
    const waiters = new PromiseSettlementWaiters(basePromise)
    const anchor = waiters.wait()
    const controllers = Array.from({ length: 10_000 }, () => new AbortController())
    const cancelled = controllers.map((controller) =>
      waiters.wait({ signal: controller.signal }).catch((error) => error)
    )

    for (const controller of controllers) {
      controller.abort()
    }
    await Promise.all(cancelled)

    expect(waiters.waiterCount).toBe(1)
    expect(thenSpy).toHaveBeenCalledOnce()
    resolveBase(42)
    await expect(anchor).resolves.toBe(42)
    expect(waiters.waiterCount).toBe(0)
  })

  it('removes timed-out callers and clears their timers on settlement', async () => {
    vi.useFakeTimers()
    try {
      let resolveBase: () => void = () => {}
      const waiters = new PromiseSettlementWaiters(
        new Promise<void>((resolve) => {
          resolveBase = resolve
        })
      )
      const timedOut = waiters
        .wait({ timeoutMs: 10, createTimeoutError: () => new Error('late') })
        .catch((error) => error)
      const active = waiters.wait({ timeoutMs: 100 })

      await vi.advanceTimersByTimeAsync(10)
      await expect(timedOut).resolves.toMatchObject({ message: 'late' })
      expect(waiters.waiterCount).toBe(1)
      resolveBase()
      await expect(active).resolves.toBeUndefined()
      expect(vi.getTimerCount()).toBe(0)
    } finally {
      vi.useRealTimers()
    }
  })

  it('notifies ownership cleanup for an already-aborted caller', async () => {
    const controller = new AbortController()
    controller.abort()
    const onAbandon = vi.fn()
    const waiters = new PromiseSettlementWaiters(new Promise<void>(() => {}))

    await expect(waiters.wait({ signal: controller.signal, onAbandon })).rejects.toMatchObject({
      name: 'AbortError'
    })

    expect(onAbandon).toHaveBeenCalledWith('abort')
    expect(waiters.waiterCount).toBe(0)
  })
})