Merge final CI coverage parent into manual compact
This commit is contained in:
Hypatia May
@@ -1,11 +1,14 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import { Context, Service } from 'cordis'
|
||||
import { Context, FiberState, Service } from 'cordis'
|
||||
import Loader from '@cordisjs/plugin-loader'
|
||||
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'
|
||||
|
||||
@@ -21,6 +24,32 @@ class TestInvariantProbe extends Service {
|
||||
}
|
||||
}
|
||||
|
||||
function deferred(): { readonly promise: Promise<void>; readonly resolve: () => void } {
|
||||
let resolve!: () => void
|
||||
const promise = new Promise<void>((done) => {
|
||||
resolve = done
|
||||
})
|
||||
return { promise, resolve }
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
describe('global test invariant host', () => {
|
||||
it('uses one exhaustive topology to reserve every package name with enabled checks', async () => {
|
||||
const ctx = new Context()
|
||||
@@ -61,7 +90,8 @@ describe('global test invariant host', () => {
|
||||
return () => {}
|
||||
})
|
||||
const fakeContext = { invariants: { register } } as unknown as Context
|
||||
for (const [rawPath, companion] of Object.entries(testInvariantCompanions)) {
|
||||
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
|
||||
@@ -84,4 +114,233 @@ describe('global test invariant host', () => {
|
||||
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('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 () => {
|
||||
const delayedStarted = deferred()
|
||||
const releaseDelayed = deferred()
|
||||
|
||||
await withFakeCompanions(
|
||||
(_path, index) => async () => ({
|
||||
name: `test-invariant-${index}`,
|
||||
inject: ['invariants'],
|
||||
async apply() {
|
||||
if (index === 0) {
|
||||
delayedStarted.resolve()
|
||||
await releaseDelayed.promise
|
||||
}
|
||||
return () => {}
|
||||
},
|
||||
}),
|
||||
async () => {
|
||||
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 delayedStarted.promise
|
||||
await Promise.resolve()
|
||||
await Promise.resolve()
|
||||
expect(rootApply).not.toHaveBeenCalled()
|
||||
expect(derivedApply).not.toHaveBeenCalled()
|
||||
expect(derivedFiber.inject).toEqual({
|
||||
[TEST_INVARIANT_READY_SERVICE]: null,
|
||||
})
|
||||
|
||||
releaseDelayed.resolve()
|
||||
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 () => {
|
||||
const delayedStarted = deferred()
|
||||
const releaseDelayed = deferred()
|
||||
|
||||
await withFakeCompanions(
|
||||
(_path, index) => async () => ({
|
||||
name: `test-invariant-${index}`,
|
||||
inject: ['invariants'],
|
||||
async apply() {
|
||||
if (index === 0) {
|
||||
delayedStarted.resolve()
|
||||
await releaseDelayed.promise
|
||||
}
|
||||
return () => {}
|
||||
},
|
||||
}),
|
||||
async () => {
|
||||
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 delayedStarted.promise
|
||||
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,
|
||||
})
|
||||
|
||||
releaseDelayed.resolve()
|
||||
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 () => {
|
||||
const delayedStarted = deferred()
|
||||
const releaseDelayed = deferred()
|
||||
|
||||
await withFakeCompanions(
|
||||
(_path, index) => async () => ({
|
||||
name: `test-invariant-${index}`,
|
||||
inject: ['invariants'],
|
||||
async apply() {
|
||||
if (index === 0) {
|
||||
delayedStarted.resolve()
|
||||
await releaseDelayed.promise
|
||||
}
|
||||
return () => {}
|
||||
},
|
||||
}),
|
||||
async () => {
|
||||
const ctx = new Context()
|
||||
const targetApply = vi.fn(function targetApply() {})
|
||||
const targetFiber = ctx.plugin(targetApply)
|
||||
|
||||
await delayedStarted.promise
|
||||
await expect(targetFiber.dispose()).resolves.toBeUndefined()
|
||||
expect(targetFiber.state).toBe(FiberState.DISPOSED)
|
||||
expect(targetApply).not.toHaveBeenCalled()
|
||||
|
||||
releaseDelayed.resolve()
|
||||
await targetFiber
|
||||
expect(targetApply).not.toHaveBeenCalled()
|
||||
},
|
||||
)
|
||||
})
|
||||
})
|
||||
|
||||
@@ -6,14 +6,14 @@
|
||||
*/
|
||||
|
||||
import { expect } from 'vitest'
|
||||
import { RegistryService } from 'cordis'
|
||||
import { FiberState, Inject, RegistryService } from 'cordis'
|
||||
import type { Context, Plugin } from 'cordis'
|
||||
import InvariantService from '@deepseek-ai/dsh-invariants'
|
||||
|
||||
declare global {
|
||||
interface ImportMeta {
|
||||
/** Eager Vite module-glob expansion used by the Vitest setup file. */
|
||||
glob<TModule>(pattern: string, options: { eager: true }): Record<string, TModule>
|
||||
/** Lazy Vite module-glob expansion used by the Vitest setup file. */
|
||||
glob<TModule>(pattern: string): Record<string, () => Promise<TModule>>
|
||||
}
|
||||
}
|
||||
|
||||
@@ -25,9 +25,18 @@ export interface TestInvariantCompanion {
|
||||
apply(ctx: Context): Promise<() => void>
|
||||
}
|
||||
|
||||
/** Every package companion, discovered eagerly so coverage observes each registration. */
|
||||
export const testInvariantCompanions: Readonly<Record<string, TestInvariantCompanion>> =
|
||||
import.meta.glob<TestInvariantCompanion>('../packages/*/*/src/invariant.ts', { eager: true })
|
||||
/** Private service dependency that holds ordinary root plugins until invariant startup completes. */
|
||||
export const TEST_INVARIANT_READY_SERVICE = 'testInvariantReady'
|
||||
|
||||
/**
|
||||
* Every package companion as a lazy loader keyed by glob path. Ordinary tests
|
||||
* load only their owner's module; the exhaustive topology test loads and
|
||||
* executes all of them, so aggregated coverage still observes every
|
||||
* registration while per-file setup stops importing 168 companions and their
|
||||
* transitive package sources.
|
||||
*/
|
||||
export const testInvariantCompanions: Readonly<Record<string, () => Promise<TestInvariantCompanion>>> =
|
||||
import.meta.glob<TestInvariantCompanion>('../packages/*/*/src/invariant.ts')
|
||||
|
||||
/** Manual-topology suites whose names cannot follow the focused invariant convention. */
|
||||
const MANUAL_INVARIANT_TEST_EXCEPTIONS = [
|
||||
@@ -36,12 +45,13 @@ const MANUAL_INVARIANT_TEST_EXCEPTIONS = [
|
||||
] as const
|
||||
|
||||
interface InvariantHost {
|
||||
readonly fibers: readonly PluginFiber[]
|
||||
readonly byCallback: ReadonlyMap<unknown, PluginFiber>
|
||||
readonly barrierOwners: WeakSet<Context['fiber']>
|
||||
readonly ready: Promise<void>
|
||||
}
|
||||
|
||||
type PluginFiber = ReturnType<RegistryService['plugin']>
|
||||
type PluginCallback = Plugin.Function | Plugin.Constructor
|
||||
|
||||
const hosts = new WeakMap<Context, InvariantHost>()
|
||||
// oxlint-disable-next-line typescript/unbound-method -- every call below supplies its RegistryService receiver explicitly.
|
||||
@@ -56,13 +66,24 @@ RegistryService.prototype.plugin = function(plugin: Plugin, config?: unknown, ge
|
||||
const callback = this.resolve(plugin)
|
||||
const existing = callback === undefined ? undefined : host.byCallback.get(callback)
|
||||
if (existing !== undefined) {
|
||||
return this.ctx === root ? joinInvariantStartup(existing, host.ready) : existing
|
||||
return hasBarrierOwner(host, this.ctx) ? existing : joinInvariantStartup(existing, host.ready)
|
||||
}
|
||||
|
||||
const fiber = originalPlugin.call(this, plugin, config, getOuterStack)
|
||||
// A root-level await is the test's composition boundary. Nested plugin
|
||||
// fibers must not await their own companion parent through the global host.
|
||||
if (this.ctx !== root) return fiber
|
||||
// Causal descendants of a gated target have already crossed the barrier.
|
||||
// Host service and companion descendants also bypass it so their own startup
|
||||
// cannot depend on the readiness they are responsible for providing.
|
||||
if (hasBarrierOwner(host, this.ctx)) {
|
||||
return originalPlugin.call(this, plugin, config, getOuterStack)
|
||||
}
|
||||
if (callback === undefined) return originalPlugin.call(this, plugin, config, getOuterStack)
|
||||
|
||||
const fiber = originalPlugin.call(
|
||||
this,
|
||||
withInvariantReadiness(plugin, callback as PluginCallback),
|
||||
config,
|
||||
getOuterStack,
|
||||
)
|
||||
host.barrierOwners.add(fiber.ctx.fiber)
|
||||
return joinInvariantStartup(fiber, host.ready)
|
||||
}
|
||||
|
||||
@@ -102,48 +123,89 @@ export function testInvariantCompanionPaths(testPath: string): string[] {
|
||||
}
|
||||
|
||||
function startInvariantHost(root: Context): InvariantHost {
|
||||
const fibers: PluginFiber[] = []
|
||||
const byCallback = new Map<unknown, PluginFiber>()
|
||||
const mount = (plugin: Plugin, config?: unknown): void => {
|
||||
const barrierOwners = new WeakSet<Context['fiber']>()
|
||||
const mount = (plugin: Plugin, config?: unknown): PluginFiber => {
|
||||
const fiber = originalPlugin.call(root.registry, plugin, config)
|
||||
const callback = root.registry.resolve(plugin)
|
||||
if (callback === undefined) throw new Error('test invariants: companion is not a valid Cordis plugin')
|
||||
fibers.push(fiber)
|
||||
byCallback.set(callback, fiber)
|
||||
barrierOwners.add(fiber.ctx.fiber)
|
||||
return fiber
|
||||
}
|
||||
|
||||
mount(InvariantService, { enabled: true })
|
||||
// The service mounts synchronously so the intercepted registration that
|
||||
// started this host immediately finds its own fiber in byCallback.
|
||||
// Companions load and mount inside the ready chain (after the service is
|
||||
// active, so their startup is directly joinable); every joined root plugin
|
||||
// awaits ready, so none starts ahead of its package checks. Tests plugging
|
||||
// a companion directly must await an earlier root plugin first — the
|
||||
// duplicate-mount failure otherwise is loud (owner name already reserved).
|
||||
const serviceFiber = mount(InvariantService, { enabled: true })
|
||||
const testPath = expect.getState().testPath ?? ''
|
||||
const companionPaths = testInvariantCompanionPaths(testPath)
|
||||
for (const path of companionPaths) {
|
||||
const companion = testInvariantCompanions[path]
|
||||
if (companion === undefined) {
|
||||
throw new Error(`test invariants: selected companion vanished at ${path}`)
|
||||
}
|
||||
if (!companion.inject.includes('invariants')) {
|
||||
throw new Error(`test invariants: ${path} must inject the invariant service`)
|
||||
}
|
||||
mount(companion)
|
||||
}
|
||||
|
||||
const [serviceFiber, ...companionFibers] = fibers
|
||||
if (serviceFiber === undefined) throw new Error('test invariants: service fiber was not mounted')
|
||||
// A companion is initially PENDING on the invariant service, and Cordis
|
||||
// Fiber.await() only joins work already in flight. Wait for the service to
|
||||
// activate its dependants before joining their startup and failures.
|
||||
const ready = serviceFiber.await()
|
||||
.then(() => Promise.all(companionFibers.map(fiber => fiber.await())))
|
||||
.then(() => undefined)
|
||||
const host = { fibers, byCallback, ready }
|
||||
const ready = requireActive(serviceFiber, 'invariant service').then(async () => {
|
||||
const companions = await Promise.all(companionPaths.map(async (path) => {
|
||||
const load = testInvariantCompanions[path]
|
||||
if (load === undefined) {
|
||||
throw new Error(`test invariants: selected companion vanished at ${path}`)
|
||||
}
|
||||
const companion = await load()
|
||||
if (!companion.inject.includes('invariants')) {
|
||||
throw new Error(`test invariants: ${path} must inject the invariant service`)
|
||||
}
|
||||
return { companion, path }
|
||||
}))
|
||||
const companionFibers = companions.map(({ companion, path }) => ({
|
||||
fiber: mount(companion),
|
||||
path,
|
||||
}))
|
||||
await Promise.all(companionFibers.map(({ fiber, path }) => requireActive(fiber, path)))
|
||||
root.provide(TEST_INVARIANT_READY_SERVICE, true)
|
||||
})
|
||||
const host = { byCallback, barrierOwners, ready }
|
||||
hosts.set(root, host)
|
||||
return host
|
||||
}
|
||||
|
||||
function hasBarrierOwner(host: InvariantHost, ctx: Context): boolean {
|
||||
let fiber = ctx.fiber
|
||||
while (true) {
|
||||
if (
|
||||
host.barrierOwners.has(fiber)
|
||||
&& (fiber.state === FiberState.LOADING || fiber.state === FiberState.ACTIVE)
|
||||
) {
|
||||
return true
|
||||
}
|
||||
const parent = fiber.parent.fiber
|
||||
if (parent === fiber) return false
|
||||
fiber = parent
|
||||
}
|
||||
}
|
||||
|
||||
async function requireActive(fiber: PluginFiber, label: string): Promise<void> {
|
||||
await fiber.await()
|
||||
if (fiber.state !== FiberState.ACTIVE) {
|
||||
throw new Error(`test invariants: ${label} settled without becoming active`)
|
||||
}
|
||||
}
|
||||
|
||||
function withInvariantReadiness(plugin: Plugin, callback: PluginCallback): Plugin.Object {
|
||||
return {
|
||||
apply: callback as Plugin.Function,
|
||||
inject: {
|
||||
...Inject.resolve(plugin.inject),
|
||||
[TEST_INVARIANT_READY_SERVICE]: null,
|
||||
},
|
||||
...(plugin.name === undefined ? {} : { name: plugin.name }),
|
||||
...(plugin.Config === undefined ? {} : { Config: plugin.Config }),
|
||||
...(plugin.provide === undefined ? {} : { provide: plugin.provide }),
|
||||
...(plugin.intercept === undefined ? {} : { intercept: plugin.intercept }),
|
||||
}
|
||||
}
|
||||
|
||||
function joinInvariantStartup(fiber: PluginFiber, invariantReady: Promise<void>): PluginFiber {
|
||||
const readiness = fiber.await().then(async (loaded) => {
|
||||
await invariantReady
|
||||
return loaded
|
||||
})
|
||||
const readiness = invariantReady.then(() => fiber.await())
|
||||
const joined = Object.create(fiber) as PluginFiber
|
||||
joined.then = readiness.then.bind(readiness)
|
||||
return joined
|
||||
|
||||
Reference in New Issue
Block a user