deepseek-harness/scripts/test-invariants.spec.ts

import { describe, expect, it, vi } from 'vitest'
import { Context, FiberState, Service, ValidationError } from 'cordis'
import Loader from '@cordisjs/plugin-loader'
import z from 'schemastery'
import InvariantService from '@deepseek-ai/dsh-invariants'
import type { InvariantInstaller } from '@deepseek-ai/dsh-invariants'
import { packageInvariantOwners } from './package-invariants.ts'
import {
  TEST_INVARIANT_READY_SERVICE,
  testInvariantCompanionPaths,
  testInvariantCompanions,
  type TestInvariantCompanion,
  usesManualInvariantTree,
} from './test-invariants.ts'

declare module 'cordis' {
  interface Context {
    testInvariantProbe: TestInvariantProbe
  }
}

class TestInvariantProbe extends Service {
  constructor(ctx: Context) {
    super(ctx, 'testInvariantProbe')
  }
}

function deferred(): { readonly promise: Promise<void>; readonly resolve: () => void } {
  let resolve!: () => void
  const promise = new Promise<void>((done) => {
    resolve = done
  })
  return { promise, resolve }
}

function requiredConfig() {
  return z.object({
    requiredValue: z.string().required(),
  })
}

function queuedReadinessConfig(
  ctx: Context,
  onPublished: (dispose: () => void) => void,
) {
  return z.transform(z.any(), () => {
    queueMicrotask(() => {
      onPublished(ctx.provide(TEST_INVARIANT_READY_SERVICE, true))
    })
    return {}
  }, true)
}

function invalidConfigApply(): never {
  throw new Error('invalid plugin apply executed')
}

async function rejectionOf(fiber: ReturnType<Context['plugin']>): Promise<unknown> {
  return fiber.then(
    () => undefined,
    (error: unknown) => error,
  )
}

function expectRequiredConfigValidation(error: unknown): void {
  expect(error).toBeInstanceOf(ValidationError)
  expect(error).toHaveProperty('message', expect.stringMatching(/requiredValue/))
}

async function withFakeCompanions(
  create: (path: string, index: number) => () => Promise<TestInvariantCompanion>,
  run: () => Promise<void>,
): Promise<void> {
  const mutable = testInvariantCompanions as Record<string, () => Promise<TestInvariantCompanion>>
  const originals = Object.entries(mutable)
  for (const [index, [path]] of originals.entries()) {
    mutable[path] = create(path, index)
  }
  try {
    await run()
  } finally {
    for (const [path, load] of originals) {
      mutable[path] = load
    }
  }
}

async function withDelayedFirstCompanion(
  run: (control: { readonly started: Promise<void>; readonly release: () => void }) => Promise<void>,
): Promise<void> {
  const started = deferred()
  const release = deferred()
  await withFakeCompanions(
    (_path, index) => async () => ({
      name: `test-invariant-${index}`,
      inject: ['invariants'],
      async apply() {
        if (index === 0) {
          started.resolve()
          await release.promise
        }
        return () => {}
      },
    }),
    () => run({ started: started.promise, release: release.resolve }),
  )
}

describe('global test invariant host', () => {
  it('uses one exhaustive topology to reserve every package name with enabled checks', async () => {
    const ctx = new Context()
    await ctx.plugin(TestInvariantProbe)

    const owners = packageInvariantOwners(process.cwd())
    expect(Object.keys(testInvariantCompanions)).toHaveLength(owners.length)
    const unreserved: string[] = []
    for (const owner of owners) {
      try {
        const dispose = ctx.invariants.register(owner.packageName, () => {})
        unreserved.push(owner.packageName)
        dispose()
      } catch (error) {
        expect(error).toHaveProperty(
          'message',
          `invariants: package "${owner.packageName}" is already registered`,
        )
      }
    }
    expect(unreserved).toEqual([])
  })

  it('mounts the owning package companion while leaving non-package roots service-only', () => {
    expect(testInvariantCompanionPaths('/repo/packages/core/tools/tests/tools.spec.ts'))
      .toEqual(['../packages/core/tools/src/invariant.ts'])
    expect(testInvariantCompanionPaths('/repo/examples/echo-agent/tests/echo.spec.ts')).toEqual([])
    expect(testInvariantCompanionPaths('/repo/scripts/test-invariants.spec.ts'))
      .toEqual(Object.keys(testInvariantCompanions).sort())
  })

  it('loads and executes every source companion through the real Loader shape', async () => {
    const owners = new Map(packageInvariantOwners(process.cwd()).map(owner => [owner.sourcePath, owner.packageName]))
    const registrations = new Map<string, string>()
    const loader = Object.create(Loader.prototype) as Loader
    const register = vi.fn((_packageName: string, installer: InvariantInstaller) => {
      expect(typeof installer).toBe('function')
      return () => {}
    })
    const fakeContext = { invariants: { register } } as unknown as Context
    for (const [rawPath, load] of Object.entries(testInvariantCompanions)) {
      const companion = await load()
      const path = rawPath.replace(/^\.\.\//, '')
      expect(companion.default, path).toBeUndefined()
      const unwrapped = loader.unwrapExports(companion) as typeof companion
      expect(unwrapped, path).toBe(companion)
      expect(typeof unwrapped.name, path).toBe('string')
      expect(unwrapped.inject, path).toContain('invariants')
      expect(typeof unwrapped.apply, path).toBe('function')
      await unwrapped.apply(fakeContext)
      const call = register.mock.calls.at(-1)
      if (call === undefined) throw new Error(`${path}: companion did not register`)
      registrations.set(path, call[0])
    }
    expect(registrations).toEqual(owners)
  })

  it('recognizes focused invariant suites without a package inventory', () => {
    expect(usesManualInvariantTree('/repo/packages/core/session/tests/invariant.spec.ts')).toBe(true)
    expect(usesManualInvariantTree('/repo/packages/core/session/tests/request-invariant-hmr.spec.ts')).toBe(true)
    expect(usesManualInvariantTree('C:\\repo\\packages\\support\\invariants\\tests\\service.spec.ts')).toBe(true)
    expect(usesManualInvariantTree('/repo/packages/examples/agent-spine-demo/tests/agent-core.spec.ts')).toBe(true)
    expect(usesManualInvariantTree('/repo/packages/core/session/tests/session.spec.ts')).toBe(false)
  })

  it('preserves config validation failures without starting the rejected plugin', async () => {
    const ctx = new Context()
    const apply = vi.fn(invalidConfigApply)
    const plugin = {
      apply,
      Config: requiredConfig(),
    }

    const fiber = ctx.plugin(plugin, {})
    const firstError = await rejectionOf(fiber)
    expectRequiredConfigValidation(firstError)
    await ctx.plugin(TestInvariantProbe)
    const secondError = await rejectionOf(fiber)
    expect(secondError).toBe(firstError)
    expect(fiber.state).toBe(FiberState.DISPOSED)
    expect(apply).not.toHaveBeenCalled()
  })

  it('disposes invalid config when readiness refresh wins the rejection-handler race', async () => {
    await withDelayedFirstCompanion(
      async ({ started, release }) => {
        const ctx = new Context()
        const apply = vi.fn(invalidConfigApply)
        let disposeQueuedReadiness: (() => void) | undefined
        const plugin = {
          apply,
          Config: z.intersect([
            queuedReadinessConfig(ctx, (dispose) => {
              disposeQueuedReadiness = dispose
            }),
            requiredConfig(),
          ]),
        }

        const fiber = ctx.plugin(plugin, {})
        const firstError = await rejectionOf(fiber)
        expectRequiredConfigValidation(firstError)
        expect(fiber.state).toBe(FiberState.DISPOSED)
        expect(apply).not.toHaveBeenCalled()

        await started
        if (disposeQueuedReadiness === undefined) throw new Error('queued readiness was not published')
        disposeQueuedReadiness()
        release()
        await ctx.plugin(TestInvariantProbe)

        const secondError = await rejectionOf(fiber)
        expect(secondError).toBe(firstError)
        expect(fiber.state).toBe(FiberState.DISPOSED)
        expect(apply).not.toHaveBeenCalled()
      },
    )
  })

  it('retains a valid plugin failure when readiness wins the initial-probe race', async () => {
    await withDelayedFirstCompanion(
      async ({ started, release }) => {
        const ctx = new Context()
        const failure = new Error('valid plugin apply failed')
        const applied = deferred()
        const apply = vi.fn(function validConfigApply() {
          applied.resolve()
          throw failure
        })
        let disposeQueuedReadiness: (() => void) | undefined
        const plugin = {
          apply,
          Config: queuedReadinessConfig(ctx, (dispose) => {
            disposeQueuedReadiness = dispose
          }),
        }

        const fiber = ctx.plugin(plugin, {})
        const returnedError = rejectionOf(fiber)
        try {
          await Promise.all([started, applied.promise])
          expect(fiber.state).toBe(FiberState.FAILED)
          expect(apply).toHaveBeenCalledOnce()
          expect(ctx.registry.has(plugin)).toBe(true)
          expect(ctx.registry.get(plugin)?.fibers).toHaveLength(1)

          if (disposeQueuedReadiness === undefined) throw new Error('queued readiness was not published')
          Reflect.deleteProperty(fiber.inject, TEST_INVARIANT_READY_SERVICE)
          disposeQueuedReadiness()
          release()

          expect(await returnedError).toBe(failure)
          expect(fiber.state).toBe(FiberState.FAILED)
          expect(apply).toHaveBeenCalledOnce()
          expect(ctx.registry.has(plugin)).toBe(true)
          expect(ctx.registry.get(plugin)?.fibers).toHaveLength(1)
        } finally {
          Reflect.deleteProperty(fiber.inject, TEST_INVARIANT_READY_SERVICE)
          disposeQueuedReadiness?.()
          release()
        }
      },
    )
  })

  it('holds a root plugin until every lazy companion is active, then permits nested startup', async () => {
    const delayedStarted = deferred()
    const releaseDelayed = deferred()
    const order: string[] = []
    let delayedCompanion: TestInvariantCompanion | undefined
    const companionNestedApply = vi.fn(function companionNestedApply() {})

    await withFakeCompanions(
      (path, index) => async () => {
        const companion: TestInvariantCompanion = {
          name: `test-invariant-${index}`,
          inject: ['invariants'],
          async apply(companionCtx) {
            order.push(`companion-start:${path}`)
            if (index === 0) {
              delayedStarted.resolve()
              await releaseDelayed.promise
            }
            if (index === 1) await companionCtx.plugin(companionNestedApply)
            order.push(`companion-active:${path}`)
            return () => {}
          },
        }
        if (index === 0) delayedCompanion = companion
        return companion
      },
      async () => {
        const ctx = new Context()
        ctx.provide('testInvariantTargetDependency', true)
        let nestedFiber: ReturnType<Context['plugin']> | undefined
        const nestedApply = vi.fn(function nestedApply() {
          order.push('nested')
        })
        const targetApply = Object.assign(vi.fn(function targetApply(targetCtx: Context) {
          order.push('target')
          nestedFiber = targetCtx.plugin(nestedApply)
        }), {
          inject: ['testInvariantTargetDependency'],
        })

        const targetFiber = ctx.plugin(targetApply)
        expect(ctx.registry.get(targetApply)?.callback).toBe(targetApply)
        expect(targetFiber.inject).toEqual({
          testInvariantTargetDependency: null,
          [TEST_INVARIANT_READY_SERVICE]: null,
        })

        await delayedStarted.promise
        await Promise.resolve()
        await Promise.resolve()
        expect(targetApply).not.toHaveBeenCalled()

        releaseDelayed.resolve()
        await targetFiber
        if (nestedFiber === undefined) throw new Error('target did not register its nested plugin')
        await nestedFiber

        expect(targetFiber.state).toBe(FiberState.ACTIVE)
        expect(targetApply).toHaveBeenCalledOnce()
        expect(nestedApply).toHaveBeenCalledOnce()
        expect(companionNestedApply).toHaveBeenCalledOnce()
        const targetIndex = order.indexOf('target')
        expect(targetIndex).toBeGreaterThan(-1)
        expect(order.slice(0, targetIndex)).toHaveLength(Object.keys(testInvariantCompanions).length * 2)
        expect(order.at(-1)).toBe('nested')

        if (delayedCompanion === undefined) throw new Error('delayed companion did not load')
        await ctx.plugin(InvariantService, { enabled: true })
        await ctx.plugin(delayedCompanion)
        expect(ctx.registry.get(InvariantService)?.fibers).toHaveLength(1)
        expect(ctx.registry.get(delayedCompanion)?.fibers).toHaveLength(1)
      },
    )
  })

  it('holds plugins registered on a root-derived context until companion readiness', async () => {
    await withDelayedFirstCompanion(
      async ({ started, release }) => {
        const ctx = new Context()
        const rootApply = vi.fn(function rootApply() {})
        const derivedApply = vi.fn(function derivedApply() {})
        const derived = ctx.extend()
          .isolate('testInvariantDerived')
          .intercept('testInvariantDerived', {})

        const rootFiber = ctx.plugin(rootApply)
        const derivedFiber = derived.plugin(derivedApply)

        await started
        await Promise.resolve()
        await Promise.resolve()
        expect(rootApply).not.toHaveBeenCalled()
        expect(derivedApply).not.toHaveBeenCalled()
        expect(derivedFiber.inject).toEqual({
          [TEST_INVARIANT_READY_SERVICE]: null,
        })

        release()
        await Promise.all([rootFiber, derivedFiber])
        expect(rootFiber.state).toBe(FiberState.ACTIVE)
        expect(derivedFiber.state).toBe(FiberState.ACTIVE)
        expect(rootApply).toHaveBeenCalledOnce()
        expect(derivedApply).toHaveBeenCalledOnce()
      },
    )
  })

  it('holds a child registered externally on a pending target context', async () => {
    await withDelayedFirstCompanion(
      async ({ started, release }) => {
        const ctx = new Context()
        const targetApply = vi.fn(function targetApply() {})
        const childApply = vi.fn(function childApply() {})

        const targetFiber = ctx.plugin(targetApply)
        const childFiber = targetFiber.ctx.plugin(childApply)

        await started
        await Promise.resolve()
        await Promise.resolve()
        expect(targetFiber.state).toBe(FiberState.PENDING)
        expect(childFiber.state).toBe(FiberState.PENDING)
        expect(targetApply).not.toHaveBeenCalled()
        expect(childApply).not.toHaveBeenCalled()
        expect(childFiber.inject).toEqual({
          [TEST_INVARIANT_READY_SERVICE]: null,
        })

        release()
        await Promise.all([targetFiber, childFiber])
        expect(targetFiber.state).toBe(FiberState.ACTIVE)
        expect(childFiber.state).toBe(FiberState.ACTIVE)
        expect(targetApply).toHaveBeenCalledOnce()
        expect(childApply).toHaveBeenCalledOnce()
      },
    )
  })

  it.each(['load', 'startup'] as const)(
    'rejects a target when a lazy companion fails during %s without starting the target',
    async (phase) => {
      const failure = new Error(`test invariant companion ${phase} failed`)
      await withFakeCompanions(
        (_path, index) => phase === 'load' && index === 0
          ? async () => { throw failure }
          : async () => ({
            name: `test-invariant-${index}`,
            inject: ['invariants'],
            async apply() {
              if (phase === 'startup' && index === 0) throw failure
              return () => {}
            },
          }),
        async () => {
          const ctx = new Context()
          const targetApply = vi.fn(function targetApply() {})
          const targetFiber = ctx.plugin(targetApply)

          await expect(targetFiber).rejects.toBe(failure)
          expect(targetApply).not.toHaveBeenCalled()
          expect(targetFiber.state).toBe(FiberState.PENDING)
          await expect(targetFiber.dispose()).resolves.toBeUndefined()
          expect(targetFiber.state).toBe(FiberState.DISPOSED)
        },
      )
    },
  )

  it('disposes a pending target without waiting for companion readiness', async () => {
    await withDelayedFirstCompanion(
      async ({ started, release }) => {
        const ctx = new Context()
        const targetApply = vi.fn(function targetApply() {})
        const targetFiber = ctx.plugin(targetApply)

        await started
        await expect(targetFiber.dispose()).resolves.toBeUndefined()
        expect(targetFiber.state).toBe(FiberState.DISPOSED)
        expect(targetApply).not.toHaveBeenCalled()

        release()
        await targetFiber
        expect(targetApply).not.toHaveBeenCalled()
      },
    )
  })
})