487 lines
18 KiB
TypeScript
487 lines
18 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest'
|
|
import { Context, Service } from 'cordis'
|
|
import InvariantService, {
|
|
InvariantError,
|
|
assertInvariant,
|
|
observePluginInvariant,
|
|
observeServiceInvariant,
|
|
serviceShapeViolation,
|
|
type Config,
|
|
type InvariantInstaller,
|
|
type PluginInvariantContract,
|
|
} from '@deepseek-ai/dsh-invariants'
|
|
|
|
declare module 'cordis' {
|
|
interface Context {
|
|
invariantProbe: InvariantProbeService
|
|
watchedInvariantProbe: WatchedInvariantProbeService
|
|
}
|
|
|
|
interface Events {
|
|
'invariants-test/ping'(): void
|
|
}
|
|
}
|
|
|
|
class InvariantProbeService extends Service {
|
|
constructor(ctx: Context) {
|
|
super(ctx, 'invariantProbe')
|
|
}
|
|
}
|
|
|
|
class WatchedInvariantProbeService extends Service {
|
|
constructor(ctx: Context) {
|
|
super(ctx, 'watchedInvariantProbe')
|
|
}
|
|
}
|
|
|
|
interface RuntimeRegistration extends PromiseLike<() => void> {
|
|
(): void | Promise<void>
|
|
}
|
|
|
|
interface InstalledRegistration {
|
|
dispose(): Promise<void>
|
|
}
|
|
|
|
function runtimeRegistration(registration: () => void): RuntimeRegistration {
|
|
return registration as RuntimeRegistration
|
|
}
|
|
|
|
async function setup(config: Config = {}): Promise<{ ctx: Context; fiber: Awaited<ReturnType<Context['plugin']>> }> {
|
|
const ctx = new Context()
|
|
const fiber = await ctx.plugin(InvariantService, config)
|
|
return { ctx, fiber }
|
|
}
|
|
|
|
async function registerProbe(
|
|
ctx: Context,
|
|
packageName: string,
|
|
probe: () => void,
|
|
): Promise<InstalledRegistration> {
|
|
const registration = runtimeRegistration(ctx.invariants.register(packageName, (child) => {
|
|
child.on('invariants-test/ping', probe, { global: true })
|
|
}))
|
|
await registration
|
|
return {
|
|
async dispose() { await registration() },
|
|
}
|
|
}
|
|
|
|
describe('InvariantService selection', () => {
|
|
it('applies defaults when constructed directly without schema normalization', async () => {
|
|
const ctx = new Context()
|
|
const service = new InvariantService(ctx)
|
|
const probe = vi.fn()
|
|
const registration = runtimeRegistration(service.register('@deepseek-ai/dsh-session', (child) => {
|
|
child.on('invariants-test/ping', probe, { global: true })
|
|
}))
|
|
await registration
|
|
ctx.emit('invariants-test/ping')
|
|
expect(probe).toHaveBeenCalledOnce()
|
|
await registration()
|
|
})
|
|
|
|
it('enables registrations by default and treats empty lists as admit-all and exclude-none', async () => {
|
|
for (const config of [{}, { package_allowlist: [], package_blocklist: [] }]) {
|
|
const { ctx } = await setup(config)
|
|
const probe = vi.fn()
|
|
await registerProbe(ctx, '@deepseek-ai/dsh-session', probe)
|
|
ctx.emit('invariants-test/ping')
|
|
expect(probe).toHaveBeenCalledOnce()
|
|
}
|
|
})
|
|
|
|
it('disables every installer while still reserving package ownership', async () => {
|
|
const { ctx } = await setup({ enabled: false })
|
|
const probe = vi.fn()
|
|
const registration = await registerProbe(ctx, '@deepseek-ai/dsh-session', probe)
|
|
expect(() => ctx.invariants.register('@deepseek-ai/dsh-session', () => {}))
|
|
.toThrow(/already registered/)
|
|
ctx.emit('invariants-test/ping')
|
|
expect(probe).not.toHaveBeenCalled()
|
|
await registration.dispose()
|
|
})
|
|
|
|
it('uses unanchored, case-sensitive JavaScript regex sources', async () => {
|
|
const unanchored = await setup({ package_allowlist: ['session'] })
|
|
const unanchoredProbe = vi.fn()
|
|
await registerProbe(unanchored.ctx, '@deepseek-ai/dsh-session-extra', unanchoredProbe)
|
|
unanchored.ctx.emit('invariants-test/ping')
|
|
expect(unanchoredProbe).toHaveBeenCalledOnce()
|
|
|
|
const anchored = await setup({ package_allowlist: ['^@deepseek-ai/dsh-session$'] })
|
|
const anchoredProbe = vi.fn()
|
|
await registerProbe(anchored.ctx, '@deepseek-ai/dsh-session-extra', anchoredProbe)
|
|
anchored.ctx.emit('invariants-test/ping')
|
|
expect(anchoredProbe).not.toHaveBeenCalled()
|
|
|
|
const caseSensitive = await setup({ package_allowlist: ['Session'] })
|
|
const caseProbe = vi.fn()
|
|
await registerProbe(caseSensitive.ctx, '@deepseek-ai/dsh-session', caseProbe)
|
|
caseSensitive.ctx.emit('invariants-test/ping')
|
|
expect(caseProbe).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('lets the blocklist override an allowlist match', async () => {
|
|
const { ctx } = await setup({
|
|
package_allowlist: ['^@deepseek-ai/dsh-'],
|
|
package_blocklist: ['session'],
|
|
})
|
|
const sessionProbe = vi.fn()
|
|
const agentProbe = vi.fn()
|
|
await registerProbe(ctx, '@deepseek-ai/dsh-session', sessionProbe)
|
|
await registerProbe(ctx, '@deepseek-ai/dsh-agent', agentProbe)
|
|
ctx.emit('invariants-test/ping')
|
|
expect(sessionProbe).not.toHaveBeenCalled()
|
|
expect(agentProbe).toHaveBeenCalledOnce()
|
|
})
|
|
|
|
it('accepts zero-match patterns for packages registered later', async () => {
|
|
const { ctx } = await setup({ package_allowlist: ['^@later/invariants$'] })
|
|
const now = vi.fn()
|
|
const later = vi.fn()
|
|
await registerProbe(ctx, '@deepseek-ai/dsh-session', now)
|
|
await registerProbe(ctx, '@later/invariants', later)
|
|
ctx.emit('invariants-test/ping')
|
|
expect(now).not.toHaveBeenCalled()
|
|
expect(later).toHaveBeenCalledOnce()
|
|
})
|
|
|
|
it('allows the same source in both lists and applies blocklist precedence', async () => {
|
|
const { ctx } = await setup({ package_allowlist: ['agent'], package_blocklist: ['agent'] })
|
|
const probe = vi.fn()
|
|
await registerProbe(ctx, '@deepseek-ai/dsh-agent', probe)
|
|
ctx.emit('invariants-test/ping')
|
|
expect(probe).not.toHaveBeenCalled()
|
|
})
|
|
})
|
|
|
|
describe('InvariantService validation', () => {
|
|
it.each([
|
|
[{ package_allowlist: [''] }, /non-blank/],
|
|
[{ package_allowlist: [' '] }, /non-blank/],
|
|
[{ package_allowlist: [' session'] }, /surrounding whitespace/],
|
|
[{ package_blocklist: ['session '] }, /surrounding whitespace/],
|
|
[{ package_allowlist: ['session', 'session'] }, /duplicate regex/],
|
|
[{ package_blocklist: ['agent', 'agent'] }, /duplicate regex/],
|
|
[{ package_allowlist: ['['] }, /invalid regex/],
|
|
[{ package_blocklist: ['('] }, /invalid regex/],
|
|
])('rejects malformed filter config %#', async (config, message) => {
|
|
await expect((async () => {
|
|
const ctx = new Context()
|
|
await ctx.plugin(InvariantService, config)
|
|
})()).rejects.toThrow(message)
|
|
})
|
|
|
|
it.each(['', ' ', ' package', 'pack age', 'package\n'])('rejects malformed package name %j', async (packageName) => {
|
|
const { ctx } = await setup()
|
|
expect(() => ctx.invariants.register(packageName, () => {})).toThrow(/packageName/)
|
|
})
|
|
})
|
|
|
|
describe('InvariantService lifecycle', () => {
|
|
it('honors the installer dependency surface in its child fiber', async () => {
|
|
const { ctx } = await setup()
|
|
await ctx.plugin(InvariantProbeService)
|
|
let registration!: RuntimeRegistration
|
|
await ctx.plugin({
|
|
inject: ['invariants', 'invariantProbe'],
|
|
apply(child: Context) {
|
|
const installer = Object.assign((installerCtx: Context) => {
|
|
expect(Object.keys(installerCtx.fiber.inject)).toContain('invariantProbe')
|
|
expect(Object.keys(installerCtx.fiber.store ?? {})).toContain('invariantProbe')
|
|
expect(installerCtx.invariantProbe).toBeInstanceOf(InvariantProbeService)
|
|
}, { inject: ['invariantProbe'] })
|
|
expect(installer.inject).toEqual(['invariantProbe'])
|
|
registration = runtimeRegistration(child.invariants.register('@deepseek-ai/dsh-probe', installer))
|
|
return Promise.resolve(registration)
|
|
},
|
|
})
|
|
await registration
|
|
})
|
|
|
|
it('attributes failures to the registering package with the stable code', async () => {
|
|
const { ctx } = await setup()
|
|
const registration = runtimeRegistration(ctx.invariants.register('@deepseek-ai/dsh-session', (child, fail) => {
|
|
child.on('invariants-test/ping', () => fail('seq must strictly increase'), { global: true })
|
|
}))
|
|
await registration
|
|
let caught: unknown
|
|
try {
|
|
ctx.emit('invariants-test/ping')
|
|
} catch (error) {
|
|
caught = error
|
|
}
|
|
expect(caught).toBeInstanceOf(InvariantError)
|
|
expect(caught).toMatchObject({
|
|
name: 'InvariantError',
|
|
code: 'INVARIANT',
|
|
packageName: '@deepseek-ai/dsh-session',
|
|
message: 'invariant violated by "@deepseek-ai/dsh-session": seq must strictly increase',
|
|
})
|
|
})
|
|
|
|
it('disposes the child fiber completely and permits HMR re-registration', async () => {
|
|
const { ctx } = await setup()
|
|
const first = vi.fn()
|
|
const firstRegistration = await registerProbe(ctx, '@deepseek-ai/dsh-session', first)
|
|
ctx.emit('invariants-test/ping')
|
|
await firstRegistration.dispose()
|
|
ctx.emit('invariants-test/ping')
|
|
expect(first).toHaveBeenCalledOnce()
|
|
|
|
const second = vi.fn()
|
|
await registerProbe(ctx, '@deepseek-ai/dsh-session', second)
|
|
ctx.emit('invariants-test/ping')
|
|
expect(first).toHaveBeenCalledOnce()
|
|
expect(second).toHaveBeenCalledOnce()
|
|
})
|
|
|
|
it('reserves ownership until asynchronous child disposal completes', async () => {
|
|
const { ctx } = await setup()
|
|
let finishDisposal!: () => void
|
|
const disposalBarrier = new Promise<void>((resolve) => { finishDisposal = resolve })
|
|
const registration = runtimeRegistration(ctx.invariants.register('@deepseek-ai/dsh-session', (child) => {
|
|
child.effect(() => async () => { await disposalBarrier })
|
|
}))
|
|
await registration
|
|
|
|
const disposing = registration()
|
|
expect(() => ctx.invariants.register('@deepseek-ai/dsh-session', () => {}))
|
|
.toThrow(/already registered/)
|
|
finishDisposal()
|
|
await disposing
|
|
|
|
const replacement = runtimeRegistration(ctx.invariants.register('@deepseek-ai/dsh-session', () => {}))
|
|
await replacement
|
|
await replacement()
|
|
})
|
|
|
|
it('rolls back listeners and ownership atomically when an installer fails', async () => {
|
|
const { ctx } = await setup()
|
|
const leaked = vi.fn()
|
|
const failed = runtimeRegistration(ctx.invariants.register('@deepseek-ai/dsh-session', (child) => {
|
|
child.on('invariants-test/ping', leaked, { global: true })
|
|
throw new Error('installer failed')
|
|
}))
|
|
await expect(Promise.resolve(failed)).rejects.toThrow('installer failed')
|
|
ctx.emit('invariants-test/ping')
|
|
expect(leaked).not.toHaveBeenCalled()
|
|
|
|
const retry = vi.fn()
|
|
await registerProbe(ctx, '@deepseek-ai/dsh-session', retry)
|
|
ctx.emit('invariants-test/ping')
|
|
expect(retry).toHaveBeenCalledOnce()
|
|
})
|
|
|
|
it('releases a synchronous reservation if the service fiber is already inactive', async () => {
|
|
const { ctx, fiber } = await setup()
|
|
const service = ctx.invariants
|
|
await fiber.dispose()
|
|
expect(() => service.register('@deepseek-ai/dsh-session', () => {})).toThrow(/inactive/i)
|
|
})
|
|
})
|
|
|
|
describe('package-owned invariant helpers', () => {
|
|
async function registerInstaller(
|
|
ctx: Context,
|
|
packageName: string,
|
|
installer: InvariantInstaller,
|
|
): Promise<() => void> {
|
|
const registration = runtimeRegistration(ctx.invariants.register(packageName, installer))
|
|
const dispose = await Promise.resolve(registration)
|
|
return dispose
|
|
}
|
|
|
|
function effectPlugin(options: {
|
|
name?: string
|
|
inject?: string[]
|
|
effect?: string
|
|
service?: string
|
|
} = {}) {
|
|
return {
|
|
name: options.name ?? 'effect-probe',
|
|
inject: options.inject ?? [],
|
|
apply(ctx: Context) {
|
|
if (options.service !== undefined) ctx.provide(options.service, {})
|
|
if (options.effect !== undefined) {
|
|
ctx.effect(() => {
|
|
ctx.effect(() => () => {}, `${options.effect}.child`)
|
|
return () => {}
|
|
}, options.effect)
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
async function expectPluginViolation(
|
|
contract: PluginInvariantContract,
|
|
plugin: ReturnType<typeof effectPlugin>,
|
|
message: RegExp,
|
|
): Promise<void> {
|
|
const { ctx } = await setup()
|
|
await registerInstaller(ctx, `@deepseek-ai/${contract.name}`, (child, fail) => {
|
|
observePluginInvariant(child, fail, contract)
|
|
})
|
|
await expect(Promise.resolve(ctx.plugin(plugin))).rejects.toThrow(message)
|
|
}
|
|
|
|
it('checks existing and later plugin fibers, including nested effects and alternatives', async () => {
|
|
const { ctx } = await setup()
|
|
await ctx.plugin(InvariantProbeService)
|
|
const plugin = effectPlugin({
|
|
inject: ['invariantProbe'],
|
|
effect: 'probe.effect',
|
|
service: 'pluginProbe',
|
|
})
|
|
await ctx.plugin(plugin)
|
|
const validated = vi.fn(() => undefined)
|
|
await registerInstaller(ctx, '@deepseek-ai/dsh-existing-probe', (child, fail) => {
|
|
observePluginInvariant(child, fail, {
|
|
plugin,
|
|
name: 'effect-probe',
|
|
inject: ['invariantProbe'],
|
|
effects: [['missing.effect', 'probe.effect.child']],
|
|
services: ['pluginProbe'],
|
|
validate: validated,
|
|
})
|
|
})
|
|
expect(validated).toHaveBeenCalledOnce()
|
|
|
|
const later = effectPlugin({ name: 'later-probe', effect: 'later.effect' })
|
|
await registerInstaller(ctx, '@deepseek-ai/dsh-later-probe', (child, fail) => {
|
|
observePluginInvariant(child, fail, {
|
|
plugin: later,
|
|
name: 'later-probe',
|
|
effects: ['later.effect'],
|
|
})
|
|
})
|
|
await ctx.plugin(later)
|
|
})
|
|
|
|
it('matches package plugins by Cordis name without importing their callback', async () => {
|
|
const { ctx } = await setup()
|
|
const plugin = {
|
|
name: 'name-only-probe',
|
|
apply(pluginCtx: Context) {
|
|
pluginCtx.effect(() => () => {}, 'name-only.effect')
|
|
pluginCtx.inject([], () => {})
|
|
},
|
|
}
|
|
await registerInstaller(ctx, '@deepseek-ai/dsh-name-only-probe', (child, fail) => {
|
|
observePluginInvariant(child, fail, {
|
|
name: 'name-only-probe',
|
|
effects: ['name-only.effect'],
|
|
})
|
|
})
|
|
await ctx.plugin(plugin)
|
|
})
|
|
|
|
it('rejects a contract that does not identify a plugin', async () => {
|
|
const { ctx } = await setup()
|
|
const registration = runtimeRegistration(ctx.invariants.register('@deepseek-ai/dsh-invalid-plugin', (child, fail) => {
|
|
observePluginInvariant(child, fail, {
|
|
plugin: {} as never,
|
|
name: 'invalid-plugin',
|
|
})
|
|
}))
|
|
await expect(Promise.resolve(registration)).rejects.toThrow(/does not identify a Cordis plugin/)
|
|
})
|
|
|
|
it('rejects wrong plugin names, missing injections, effects, services, and custom checks', async () => {
|
|
const wrongName = effectPlugin({ name: 'actual-name', effect: 'probe.effect' })
|
|
await expectPluginViolation({
|
|
plugin: wrongName,
|
|
name: 'expected-name',
|
|
}, wrongName, /plugin name must be "expected-name"/)
|
|
|
|
const missingInjection = effectPlugin({ effect: 'probe.effect' })
|
|
await expectPluginViolation({
|
|
plugin: missingInjection,
|
|
name: 'effect-probe',
|
|
inject: ['missingService'],
|
|
}, missingInjection, /must inject "missingService"/)
|
|
|
|
const missingEffect = effectPlugin()
|
|
await expectPluginViolation({
|
|
plugin: missingEffect,
|
|
name: 'effect-probe',
|
|
effects: [['first.effect', 'second.effect']],
|
|
}, missingEffect, /must own effect "first.effect" or "second.effect"/)
|
|
|
|
const missingService = effectPlugin({ effect: 'probe.effect' })
|
|
await expectPluginViolation({
|
|
plugin: missingService,
|
|
name: 'effect-probe',
|
|
services: ['missingService'],
|
|
}, missingService, /must provide service "missingService"/)
|
|
|
|
const invalidCustom = effectPlugin({ effect: 'probe.effect' })
|
|
await expectPluginViolation({
|
|
plugin: invalidCustom,
|
|
name: 'effect-probe',
|
|
validate: () => 'custom plugin contract failed',
|
|
}, invalidCustom, /custom plugin contract failed/)
|
|
})
|
|
|
|
it('checks existing and future service implementations while ignoring unrelated changes', async () => {
|
|
const existing = await setup()
|
|
await existing.ctx.plugin(WatchedInvariantProbeService)
|
|
await registerInstaller(existing.ctx, '@deepseek-ai/dsh-existing-service', (child, fail) => {
|
|
observeServiceInvariant(child, fail, 'watchedInvariantProbe', value => (
|
|
value instanceof WatchedInvariantProbeService ? undefined : 'wrong watched service'
|
|
))
|
|
})
|
|
|
|
const future = await setup()
|
|
await registerInstaller(future.ctx, '@deepseek-ai/dsh-future-service', (child, fail) => {
|
|
observeServiceInvariant(child, fail, 'watchedInvariantProbe', value => (
|
|
value instanceof WatchedInvariantProbeService ? undefined : 'wrong watched service'
|
|
))
|
|
})
|
|
await future.ctx.plugin(InvariantProbeService)
|
|
await future.ctx.plugin(WatchedInvariantProbeService)
|
|
|
|
const invalid = await setup()
|
|
await registerInstaller(invalid.ctx, '@deepseek-ai/dsh-invalid-service', (child, fail) => {
|
|
observeServiceInvariant(child, fail, 'watchedInvariantProbe', () => 'wrong watched service')
|
|
})
|
|
await expect(Promise.resolve(invalid.ctx.plugin(WatchedInvariantProbeService)))
|
|
.rejects.toThrow(/wrong watched service/)
|
|
})
|
|
|
|
it('reports synchronous package assertions through the bound failure reporter', async () => {
|
|
const { ctx } = await setup()
|
|
const valid = await registerInstaller(ctx, '@deepseek-ai/dsh-valid-assertion', (_child, fail) => {
|
|
assertInvariant(fail, true, 'must stay true')
|
|
})
|
|
valid()
|
|
|
|
const invalid = runtimeRegistration(ctx.invariants.register('@deepseek-ai/dsh-invalid-assertion', (_child, fail) => {
|
|
assertInvariant(fail, false, 'must stay true')
|
|
}))
|
|
await expect(Promise.resolve(invalid)).rejects.toThrow(/must stay true/)
|
|
})
|
|
|
|
it('accepts structural service implementations and test doubles', () => {
|
|
expect(serviceShapeViolation({ kind: 'probe', run() {} }, {
|
|
methods: ['run'],
|
|
stringProperties: ['kind'],
|
|
})).toBeUndefined()
|
|
expect(serviceShapeViolation(Object.assign(() => {}, { run() {} }), {
|
|
methods: ['run'],
|
|
})).toBeUndefined()
|
|
})
|
|
|
|
it.each([
|
|
{ value: null, message: 'service implementation must be an object' },
|
|
{ value: 42, message: 'service implementation must be an object' },
|
|
{ value: {}, message: 'service implementation must expose method "run"' },
|
|
{ value: { run() {}, kind: '' }, message: 'service implementation must expose non-empty string "kind"' },
|
|
])('rejects invalid structural service implementations: $message', ({ value, message }) => {
|
|
expect(serviceShapeViolation(value, {
|
|
methods: ['run'],
|
|
stringProperties: ['kind'],
|
|
})).toBe(message)
|
|
})
|
|
})
|