579 lines
25 KiB
TypeScript
579 lines
25 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import { ApprovalRequestId } from '../src/index.ts'
|
|
import type {
|
|
ApprovalRequestId as ApprovalRequestIdType, CordisDynamicPluginId,
|
|
} from '../src/types.ts'
|
|
import { AGENT_A, AGENT_B, CLIENT_CODE, setup, running } from './helpers.ts'
|
|
|
|
/**
|
|
* The runner's own chain on a real cordis tree: define records without running,
|
|
* run starts a real host-half fiber and broadcasts one request, the first answer
|
|
* settles it, and stop/undefine unwind both halves. Only the model and the
|
|
* browser are stand-ins (code strings and a recording gateway).
|
|
*/
|
|
|
|
/** A host half that registers one invoke handler and provides a service. */
|
|
const HOST_CODE = `
|
|
harness.handle('double', async (args) => args.value * 2)
|
|
return {
|
|
name: 'doubler',
|
|
apply(ctx) {
|
|
ctx.provide('dynDoubler', { ok: true })
|
|
},
|
|
}
|
|
`
|
|
|
|
type Runner = Awaited<ReturnType<typeof setup>>['runner']
|
|
|
|
function define(
|
|
runner: Runner,
|
|
request: {
|
|
sessionId: typeof AGENT_A.id
|
|
name: string
|
|
purpose: string
|
|
host?: string
|
|
client?: string
|
|
},
|
|
) {
|
|
return runner.define({
|
|
sessionId: request.sessionId,
|
|
plugin: { kind: 'new', idPrefix: 'dyn' },
|
|
name: request.name,
|
|
purpose: request.purpose,
|
|
code: {
|
|
...request.host === undefined ? {} : { host: request.host },
|
|
...request.client === undefined ? {} : { client: request.client },
|
|
},
|
|
})
|
|
}
|
|
|
|
describe('dynamic runner definitions', () => {
|
|
it('lists the whole registry for a global surface, each row carrying its owning session', async () => {
|
|
const { runner } = await setup()
|
|
const mine = define(runner, { sessionId: AGENT_A.id, name: 'mine', purpose: 'ours', host: HOST_CODE })
|
|
const theirs = define(runner, { sessionId: AGENT_B.id, name: 'theirs', purpose: 'not ours', client: CLIENT_CODE })
|
|
|
|
// Global by design: a run-control surface that is not inside a session can
|
|
// still name every package, and each row carries the address later verbs need.
|
|
expect(runner.inventory()).toEqual([
|
|
{
|
|
pluginId: mine.pluginId,
|
|
agentId: AGENT_A.id,
|
|
packages: [{
|
|
packageId: mine.packageId, name: 'mine', purpose: 'ours', hasHostHalf: true, hasClientHalf: false,
|
|
}],
|
|
},
|
|
{
|
|
pluginId: theirs.pluginId,
|
|
agentId: AGENT_B.id,
|
|
packages: [{
|
|
packageId: theirs.packageId, name: 'theirs', purpose: 'not ours', hasHostHalf: false, hasClientHalf: true,
|
|
}],
|
|
},
|
|
])
|
|
// Authority did not move with the listing: acting still needs the owner.
|
|
await expect(runner.run(AGENT_A, theirs.pluginId, theirs.packageId, 'run'))
|
|
.resolves.toMatchObject({ ok: false, reason: 'plugin-missing' })
|
|
})
|
|
|
|
it('tells a global surface which definitions even have a browser half to load', async () => {
|
|
const { runner } = await setup()
|
|
define(runner, { sessionId: AGENT_A.id, name: 'host only', purpose: 'no UI', host: HOST_CODE })
|
|
define(runner, {
|
|
sessionId: AGENT_A.id,
|
|
name: 'both halves',
|
|
purpose: 'UI too',
|
|
host: HOST_CODE,
|
|
client: CLIENT_CODE,
|
|
})
|
|
|
|
// A host-only package cannot be loaded into a page, so the surface must be
|
|
// able to tell the two apart from the listing alone.
|
|
expect(runner.inventory().map(row => [String(row.pluginId), row.packages[0]?.hasClientHalf])).toEqual([
|
|
['dyn-1', false],
|
|
['dyn-2', true],
|
|
])
|
|
})
|
|
|
|
it('records a definition without running it, and mints ids that are never reused', async () => {
|
|
const { runner } = await setup()
|
|
|
|
const first = define(runner, { sessionId: AGENT_A.id, name: 'first', purpose: 'do a thing', host: HOST_CODE })
|
|
const second = define(runner, { sessionId: AGENT_A.id, name: 'second', purpose: 'do another', client: 'return () => {}' })
|
|
|
|
expect(first).toEqual({
|
|
pluginId: 'dyn-1', packageId: 'pkg-1', name: 'first', purpose: 'do a thing',
|
|
hasHostHalf: true, hasClientHalf: false,
|
|
})
|
|
expect(second).toEqual({
|
|
pluginId: 'dyn-2', packageId: 'pkg-2', name: 'second', purpose: 'do another',
|
|
hasHostHalf: false, hasClientHalf: true,
|
|
})
|
|
expect(running(runner, AGENT_A)).toEqual([{ id: 'dyn-1', running: false }, { id: 'dyn-2', running: false }])
|
|
})
|
|
|
|
it.each([
|
|
[{ name: ' ', purpose: 'p', host: 'return () => {}' }, 'non-empty `name`'],
|
|
[{ name: 'n', purpose: '', host: 'return () => {}' }, 'non-empty `purpose`'],
|
|
[{ name: 'n', purpose: 'p' }, 'needs `code.host`, `code.client`, or both'],
|
|
])('refuses an incomplete define request: %j', async (request, message) => {
|
|
const { runner } = await setup()
|
|
expect(() => define(runner, { sessionId: AGENT_A.id, ...request })).toThrow(message)
|
|
})
|
|
|
|
it('keeps unparseable code out of the registry, teaching the TypeScript removal', async () => {
|
|
const { runner } = await setup()
|
|
|
|
expect(() => define(runner, {
|
|
sessionId: AGENT_A.id,
|
|
name: 'broken',
|
|
purpose: 'p',
|
|
client: 'return { type: \'text\' as const }',
|
|
})).toThrow('The sandbox runs plain JavaScript, not TypeScript')
|
|
expect(running(runner, AGENT_A)).toEqual([])
|
|
})
|
|
|
|
it('hides another session\'s definition, so only its own card can address it', async () => {
|
|
const { runner } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'owned', purpose: 'p', host: HOST_CODE,
|
|
})
|
|
|
|
expect(running(runner, AGENT_B)).toEqual([])
|
|
await expect(runner.run(AGENT_B, pluginId, packageId, 'run'))
|
|
.resolves.toMatchObject({ ok: false, reason: 'plugin-missing' })
|
|
await expect(runner.stop(AGENT_B, pluginId)).resolves.toMatchObject({ ok: false, reason: 'plugin-missing' })
|
|
})
|
|
})
|
|
|
|
describe('dynamic runner dispatch', () => {
|
|
it('starts a host-only package immediately, with no request and no approval', async () => {
|
|
const { ctx, runner, gateway } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'doubler', purpose: 'p', host: HOST_CODE,
|
|
})
|
|
|
|
const receipt = await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
|
|
expect(receipt).toEqual({
|
|
ok: true,
|
|
status: 'running',
|
|
pluginId,
|
|
packageId,
|
|
pluginRunId: 'run-1',
|
|
waitingFor: [],
|
|
currentPackageId: packageId,
|
|
mode: 'run',
|
|
})
|
|
expect(ctx.get('dynDoubler')).toEqual({ ok: true })
|
|
// Its own business: the only announcement is the run-state one.
|
|
expect(gateway.events).toEqual([
|
|
['cordis/dynamic-package', { pluginId, packageId, pluginRunId: 'run-1', name: 'doubler' }],
|
|
])
|
|
await expect(runner.invoke(pluginId, 'run-1' as never, 'double', { value: 21 }))
|
|
.resolves.toEqual({ ok: true, value: 42 })
|
|
expect(running(runner, AGENT_A)).toEqual([{ id: pluginId, running: true }])
|
|
})
|
|
|
|
it('returns awaiting approval, then records the page activation asynchronously', async () => {
|
|
const { ctx, runner, gateway } = await setup()
|
|
gateway.answer = 'approve'
|
|
gateway.clientWaitingFor = ['slots']
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'both', purpose: 'p', host: HOST_CODE, client: CLIENT_CODE,
|
|
})
|
|
|
|
const receipt = await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
|
|
expect(receipt).toEqual({
|
|
ok: true,
|
|
status: 'awaiting-approval',
|
|
pluginId,
|
|
packageId,
|
|
pluginRunId: 'run-1',
|
|
mode: 'run',
|
|
waitingFor: [],
|
|
nextPackageId: packageId,
|
|
})
|
|
await gateway.answering
|
|
expect(ctx.get('dynDoubler')).toEqual({ ok: true })
|
|
expect(runner.inventory()[0]?.latestRun).toMatchObject({
|
|
status: 'waiting',
|
|
client: { status: 'waiting', waitingFor: ['slots'] },
|
|
})
|
|
expect(gateway.events.map(([name]) => name)).toEqual([
|
|
'cordis/request-run', 'cordis/dynamic-package', 'cordis/request-run-resolved',
|
|
])
|
|
expect(gateway.events.at(-1)?.[1]).toMatchObject({ outcome: 'approved' })
|
|
})
|
|
|
|
it('returns awaiting approval, then records a refusal without starting', async () => {
|
|
const { ctx, runner, gateway } = await setup()
|
|
gateway.answer = 'reject'
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'both', purpose: 'p', host: HOST_CODE, client: CLIENT_CODE,
|
|
})
|
|
|
|
const receipt = await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
|
|
expect(receipt).toMatchObject({ ok: true, status: 'awaiting-approval' })
|
|
await gateway.answering
|
|
expect(ctx.get('dynDoubler')).toBeUndefined()
|
|
expect(running(runner, AGENT_A)).toEqual([{ id: pluginId, running: false }])
|
|
expect(gateway.events.at(-1)).toMatchObject(['cordis/request-run-resolved', { outcome: 'rejected' }])
|
|
})
|
|
|
|
it('records an asynchronous Client failure and unwinds the Host half it started', async () => {
|
|
const { ctx, runner, gateway } = await setup()
|
|
gateway.answer = { clientFails: 'createElement is not defined' }
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'both', purpose: 'p', host: HOST_CODE, client: CLIENT_CODE,
|
|
})
|
|
|
|
const receipt = await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
|
|
expect(receipt).toMatchObject({ ok: true, status: 'awaiting-approval' })
|
|
await gateway.answering
|
|
expect(runner.inventory()[0]?.latestRun).toMatchObject({
|
|
status: 'failed',
|
|
error: { message: 'createElement is not defined' },
|
|
})
|
|
// Rollback restores the state the request found: nothing was running before.
|
|
expect(ctx.get('dynDoubler')).toBeUndefined()
|
|
expect(running(runner, AGENT_A)).toEqual([{ id: pluginId, running: false }])
|
|
expect(gateway.events.at(-1)?.[1]).toMatchObject({ outcome: 'failed' })
|
|
})
|
|
|
|
it('replaces a prior run and records failure when the repeated run cannot load Client code', async () => {
|
|
const { ctx, runner, gateway } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'both', purpose: 'p', host: HOST_CODE, client: CLIENT_CODE,
|
|
})
|
|
// A first page ran it; a second request finds it already up.
|
|
gateway.answer = 'approve'
|
|
await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
await gateway.answering
|
|
gateway.answer = { clientFails: 'this page could not load it' }
|
|
|
|
const receipt = await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
|
|
expect(receipt).toMatchObject({ ok: true, status: 'starting' })
|
|
await gateway.answering
|
|
expect(runner.inventory()[0]?.latestRun).toMatchObject({
|
|
status: 'failed',
|
|
error: { message: 'this page could not load it' },
|
|
})
|
|
expect(ctx.get('dynDoubler')).toBeUndefined()
|
|
expect(running(runner, AGENT_A)).toEqual([{ id: pluginId, running: false }])
|
|
})
|
|
|
|
it('binds a running host half instead of evaluating it twice', async () => {
|
|
const { runner } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'doubler', purpose: 'p', host: HOST_CODE,
|
|
})
|
|
|
|
const first = await runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', null, false)
|
|
const second = await runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', null, false)
|
|
|
|
expect(first).toEqual({
|
|
ok: true, pluginId, packageId, pluginRunId: 'run-1', waitingFor: [], startedHere: true,
|
|
})
|
|
// Re-evaluating would collide on the provided service; binding is what lets
|
|
// a reloaded page take a live package back.
|
|
expect(second).toEqual({
|
|
ok: true, pluginId, packageId, pluginRunId: 'run-1', waitingFor: [], startedHere: false,
|
|
})
|
|
})
|
|
|
|
it('shares one activation when two pages start the same Package concurrently', async () => {
|
|
const { runner } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'doubler', purpose: 'p', host: HOST_CODE,
|
|
})
|
|
|
|
const [first, second] = await Promise.all([
|
|
runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', null, false),
|
|
runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', null, false),
|
|
])
|
|
|
|
expect(first).toMatchObject({ ok: true, pluginRunId: 'run-1', startedHere: true })
|
|
expect(second).toEqual(first)
|
|
})
|
|
|
|
it('hands the browser half\'s source only to the owning session, and only while it runs', async () => {
|
|
const { runner } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'ui', purpose: 'p', client: CLIENT_CODE,
|
|
})
|
|
|
|
expect(() => runner.getClientCode(AGENT_A, pluginId, 'run-0' as never)).toThrow('is not running')
|
|
const started = await runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', null, false)
|
|
if (!started.ok) throw new Error(started.message)
|
|
expect(runner.getClientCode(AGENT_A, pluginId, started.pluginRunId)).toEqual({
|
|
code: CLIENT_CODE, name: 'ui', pluginId, packageId, pluginRunId: started.pluginRunId,
|
|
})
|
|
expect(() => runner.getClientCode(AGENT_B, pluginId, started.pluginRunId)).toThrow('no dynamic plugin')
|
|
})
|
|
|
|
it('accepts and ignores an answer to a request nobody is waiting for', async () => {
|
|
const { runner } = await setup()
|
|
|
|
await expect(runner.resolveRequestRun(ApprovalRequestId('approval-404'), {
|
|
ok: true, pluginRunId: 'run-1' as never,
|
|
}))
|
|
.resolves.toEqual({ accepted: false })
|
|
})
|
|
|
|
it('refuses an answer after stop cancels the request and allows a fresh direct run', async () => {
|
|
const { runner, gateway } = await setup()
|
|
// No auto-answer: this suite drives the round trip by hand so the dispatch
|
|
// can be replaced underneath the page that is still loading run 1.
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'ui', purpose: 'p', client: CLIENT_CODE,
|
|
})
|
|
const pending = await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
expect(pending).toMatchObject({ ok: true, status: 'awaiting-approval' })
|
|
await Promise.resolve()
|
|
const asked = gateway.events.find(([name]) => name === 'cordis/request-run')?.[1]
|
|
const requestId = (asked as { requestId: ApprovalRequestIdType }).requestId
|
|
const first = await runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', requestId, false)
|
|
if (!first.ok) throw new Error(first.message)
|
|
expect(runner.getClientCode(AGENT_A, pluginId, first.pluginRunId).pluginRunId).toBe(first.pluginRunId)
|
|
// The user stops it while that page is still loading, cancelling the request.
|
|
await runner.stop(AGENT_A, pluginId)
|
|
|
|
await expect(runner.resolveRequestRun(requestId, { ok: true, pluginRunId: first.pluginRunId }))
|
|
.resolves.toEqual({ accepted: false })
|
|
expect(gateway.events).toContainEqual([
|
|
'cordis/request-run-resolved',
|
|
{ requestId, outcome: 'cancelled' },
|
|
])
|
|
await expect(runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', null, false))
|
|
.resolves.toMatchObject({ ok: true, pluginRunId: 'run-2', startedHere: true })
|
|
})
|
|
|
|
it('cancels a pending request after its provisional activation is stopped', async () => {
|
|
const { runner, gateway } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'ui', purpose: 'p', client: CLIENT_CODE,
|
|
})
|
|
const controller = new AbortController()
|
|
const pending = await runner.run(AGENT_A, pluginId, packageId, 'run', controller.signal)
|
|
expect(pending).toMatchObject({ ok: true, status: 'awaiting-approval' })
|
|
await Promise.resolve()
|
|
const asked = gateway.events.find(([name]) => name === 'cordis/request-run')?.[1]
|
|
const requestId = (asked as { requestId: ApprovalRequestIdType }).requestId
|
|
const started = await runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', requestId, false)
|
|
if (!started.ok) throw new Error(started.message)
|
|
await runner.stop(AGENT_A, pluginId)
|
|
|
|
await expect(runner.resolveRequestRun(requestId, { ok: true, pluginRunId: started.pluginRunId }))
|
|
.resolves.toEqual({ accepted: false })
|
|
controller.abort()
|
|
expect(gateway.events).toContainEqual([
|
|
'cordis/request-run-resolved',
|
|
{ requestId, outcome: 'cancelled' },
|
|
])
|
|
})
|
|
|
|
it('keeps a published request answerable after the creating Tool call ends', async () => {
|
|
const { runner, gateway } = await setup()
|
|
// No answer configured: the request stays pending until the signal fires.
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'ui', purpose: 'p', client: CLIENT_CODE,
|
|
})
|
|
const controller = new AbortController()
|
|
|
|
const pending = await runner.run(AGENT_A, pluginId, packageId, 'run', controller.signal)
|
|
await Promise.resolve()
|
|
controller.abort()
|
|
|
|
expect(pending).toMatchObject({ ok: true, status: 'awaiting-approval' })
|
|
const asked = gateway.events.find(([name]) => name === 'cordis/request-run')?.[1]
|
|
const requestId = (asked as { requestId: ApprovalRequestIdType }).requestId
|
|
const started = await runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', requestId, false)
|
|
if (!started.ok) throw new Error(started.message)
|
|
await expect(runner.resolveRequestRun(requestId, { ok: true, pluginRunId: started.pluginRunId }))
|
|
.resolves.toEqual({ accepted: true })
|
|
expect(running(runner, AGENT_A)).toEqual([{ id: pluginId, running: true }])
|
|
})
|
|
|
|
it('reports the sandbox failure and starts nothing when the host half throws', async () => {
|
|
const { runner, gateway } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id,
|
|
name: 'broken',
|
|
purpose: 'p',
|
|
host: 'harness.handle(\'never\', async () => 1)\nthrow new Error(\'host half exploded\')',
|
|
})
|
|
|
|
const receipt = await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
|
|
expect(receipt).toMatchObject({ ok: false, reason: 'host-half-failed' })
|
|
expect(gateway.events).toEqual([])
|
|
expect(running(runner, AGENT_A)).toEqual([{ id: pluginId, running: false }])
|
|
await expect(runner.invoke(pluginId, 'run-1' as never, 'never', null))
|
|
.resolves.toMatchObject({ code: 'plugin-not-running' })
|
|
})
|
|
})
|
|
|
|
describe('dynamic runner teardown', () => {
|
|
it('stops both halves while keeping the definition runnable', async () => {
|
|
const { ctx, runner, gateway } = await setup()
|
|
gateway.answer = 'approve'
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'doubler', purpose: 'p', host: HOST_CODE, client: CLIENT_CODE,
|
|
})
|
|
const first = await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
if (!first.ok) throw new Error(first.message)
|
|
await gateway.answering
|
|
|
|
await expect(runner.stop(AGENT_A, pluginId)).resolves.toEqual({ ok: true })
|
|
|
|
expect(ctx.get('dynDoubler')).toBeUndefined()
|
|
await expect(runner.invoke(pluginId, first.pluginRunId, 'double', { value: 1 }))
|
|
.resolves.toMatchObject({ code: 'plugin-not-running' })
|
|
expect(gateway.events.at(-1)).toEqual(['cordis/dynamic-retract', {
|
|
pluginId, packageId, pluginRunId: first.pluginRunId,
|
|
}])
|
|
expect(running(runner, AGENT_A)).toEqual([{ id: pluginId, running: false }])
|
|
// Runnable again, with a fresh activation identity.
|
|
await expect(runner.run(AGENT_A, pluginId, packageId, 'run'))
|
|
.resolves.toMatchObject({ ok: true, pluginRunId: 'run-2' })
|
|
})
|
|
|
|
it('announces the stop of a host-only package too, so a global surface drops its row', async () => {
|
|
const { runner, gateway } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'doubler', purpose: 'p', host: HOST_CODE,
|
|
})
|
|
await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
|
|
await expect(runner.stop(AGENT_A, pluginId)).resolves.toEqual({ ok: true })
|
|
|
|
// The retract mirrors the start announcement: a run-control surface tracks
|
|
// "is it running", which is independent of whether a browser half existed.
|
|
expect(gateway.events).toEqual([
|
|
['cordis/dynamic-package', { pluginId, packageId, pluginRunId: 'run-1', name: 'doubler' }],
|
|
['cordis/dynamic-retract', { pluginId, packageId, pluginRunId: 'run-1' }],
|
|
])
|
|
})
|
|
|
|
it('refuses to stop a definition that is not running', async () => {
|
|
const { runner } = await setup()
|
|
const { pluginId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'idle', purpose: 'p', host: HOST_CODE,
|
|
})
|
|
|
|
await expect(runner.stop(AGENT_A, pluginId)).resolves.toMatchObject({ ok: false, reason: 'not-running' })
|
|
})
|
|
|
|
it('stops a running definition on undefine and forgets it', async () => {
|
|
const { ctx, runner, gateway } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'doubler', purpose: 'p', host: HOST_CODE,
|
|
})
|
|
await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
|
|
await expect(runner.undefine(AGENT_A, pluginId)).resolves.toEqual({ ok: true, wasRunning: true })
|
|
|
|
expect(ctx.get('dynDoubler')).toBeUndefined()
|
|
expect(running(runner, AGENT_A)).toEqual([])
|
|
expect(gateway.events.map(([name]) => name))
|
|
.toEqual(['cordis/dynamic-package', 'cordis/dynamic-retract'])
|
|
await expect(runner.run(AGENT_A, pluginId, packageId, 'run'))
|
|
.resolves.toMatchObject({ ok: false, reason: 'plugin-missing' })
|
|
})
|
|
|
|
it('answers a missing definition with the memory-only explanation', async () => {
|
|
const { runner } = await setup()
|
|
const receipt = await runner.undefine(AGENT_A, 'dyn-404' as CordisDynamicPluginId)
|
|
|
|
expect(receipt).toMatchObject({ ok: false, reason: 'plugin-missing' })
|
|
expect((receipt as { message: string }).message).toContain('lost on DSH restart')
|
|
})
|
|
|
|
it('unwinds every host half when the runner itself is disposed', async () => {
|
|
const { ctx, runner } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'doubler', purpose: 'p', host: HOST_CODE,
|
|
})
|
|
await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
expect(ctx.get('dynDoubler')).toEqual({ ok: true })
|
|
|
|
await ctx.fiber.dispose()
|
|
|
|
expect(ctx.get('dynDoubler')).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('render failure reports', () => {
|
|
it('keeps the last report per package and shows it to a snapshot reader', async () => {
|
|
const { runner } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'ui', purpose: 'renders', client: CLIENT_CODE,
|
|
})
|
|
const started = await runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', null, false)
|
|
if (!started.ok) throw new Error(started.message)
|
|
|
|
await runner.reportRenderFailure(
|
|
AGENT_A, pluginId, started.pluginRunId,
|
|
{ slot: 'settings.section', message: 'boom', abdicated: true },
|
|
)
|
|
// Cross-page and last-writer-wins: a second page reporting overwrites,
|
|
// because "did this package's UI fail anywhere" has one answer.
|
|
await runner.reportRenderFailure(
|
|
AGENT_A, pluginId, started.pluginRunId,
|
|
{ slot: 'shell.overlay', message: 'later', abdicated: false },
|
|
)
|
|
|
|
expect(runner.snapshot(AGENT_A)[0]?.activeRun?.renderFailure)
|
|
.toEqual({ slot: 'shell.overlay', message: 'later', abdicated: false })
|
|
})
|
|
|
|
it('drops a report for a definition the reporting session does not own', async () => {
|
|
const { runner } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'ui', purpose: 'renders', client: CLIENT_CODE,
|
|
})
|
|
const started = await runner.runHostHalf(AGENT_A, pluginId, packageId, 'run', null, false)
|
|
if (!started.ok) throw new Error(started.message)
|
|
|
|
// The reporting path must never fail a render, so a report it cannot place
|
|
// is dropped rather than thrown.
|
|
await expect(runner.reportRenderFailure(
|
|
AGENT_B, pluginId, started.pluginRunId, { slot: 's', message: 'm', abdicated: true },
|
|
))
|
|
.resolves.toBeNull()
|
|
expect(runner.snapshot(AGENT_A)[0]?.activeRun?.renderFailure).toBeUndefined()
|
|
})
|
|
|
|
it('clears the report when a fresh dispatch starts and when one stops', async () => {
|
|
const { runner } = await setup()
|
|
const { pluginId, packageId } = define(runner, {
|
|
sessionId: AGENT_A.id, name: 'ui', purpose: 'renders', host: 'return () => {}',
|
|
})
|
|
const first = await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
if (!first.ok) throw new Error(first.message)
|
|
await runner.reportRenderFailure(
|
|
AGENT_A, pluginId, first.pluginRunId,
|
|
{ slot: 'settings.section', message: 'boom', abdicated: true },
|
|
)
|
|
expect(runner.snapshot(AGENT_A)[0]?.activeRun?.renderFailure).toBeDefined()
|
|
|
|
// Stop clears it: nothing is mounted to have failed any more.
|
|
await runner.stop(AGENT_A, pluginId)
|
|
expect(runner.snapshot(AGENT_A)[0]?.activeRun?.renderFailure).toBeUndefined()
|
|
|
|
await runner.reportRenderFailure(
|
|
AGENT_A, pluginId, first.pluginRunId,
|
|
{ slot: 'settings.section', message: 'boom', abdicated: true },
|
|
)
|
|
// A fresh dispatch clears it too: a failure from the previous run would
|
|
// describe something that is no longer there.
|
|
await runner.run(AGENT_A, pluginId, packageId, 'run')
|
|
expect(runner.snapshot(AGENT_A)[0]?.activeRun?.renderFailure).toBeUndefined()
|
|
})
|
|
})
|