imccyu
7ad54e7791
A test file under packages/client now says which face it covers:
`*.client.spec.{ts,tsx}` and its `*.client.{ts,tsx}` helpers belong to the
Client aggregate, `*.host.spec.ts` to the host aggregate. The carrier's four
node-half specs take the Host suffix.
The two suffixes are mutually exclusive, so each aggregate excludes the
other's and both keep one broad test glob: `exclude` wins over `include`, and
`packages/client/**` no longer has to be excluded wholesale from the host
program with per-file `files` entries carved back out of it. A Host-face spec
that reaches only Host source therefore needs no cross-face project
reference, which the split-project rule rejects.
vitest still discovers every file through `**/*.spec.{ts,tsx}`.
85 lines
2.9 KiB
TypeScript
85 lines
2.9 KiB
TypeScript
/**
|
|
* Agent-scope primitive spec: the actx minted by createScope carries the
|
|
* tag and the dispatch filter itself, so plain cordis dispatch with the actx
|
|
* as subject routes by agent — same-agent tagged listeners receive,
|
|
* foreign-agent ones are filtered out, untagged listeners hear everything,
|
|
* and a subject-less root dispatch stays unfiltered. Scope-owned listeners
|
|
* dispose with the fiber.
|
|
*/
|
|
import { Context } from '@deepseek-ai/cordis'
|
|
import { describe, expect, it } from 'vitest'
|
|
import type { SessionId } from '@deepseek-ai/dsh-api-remotes/client'
|
|
import { createScope, scopeOf } from '../src/client/agents/scope.ts'
|
|
|
|
const sid = (k: string): SessionId => k as SessionId
|
|
|
|
declare module '@deepseek-ai/cordis' {
|
|
interface Events {
|
|
/**
|
|
* Test-only routed probe event.
|
|
* @param payload - marker payload.
|
|
* @mode bail
|
|
*/
|
|
'test/scope-probe'(payload: { from: string }): true | undefined
|
|
}
|
|
}
|
|
|
|
function bench() {
|
|
const root = new Context()
|
|
const a = createScope(root, sid('a'))
|
|
const b = createScope(root, sid('b'))
|
|
const seen: string[] = []
|
|
const listen = (label: string, ctx: Context, answer?: true) => {
|
|
ctx.on('test/scope-probe', (payload) => {
|
|
seen.push(`${label}:${payload.from}`)
|
|
return answer
|
|
})
|
|
}
|
|
return { root, a, b, seen, listen }
|
|
}
|
|
|
|
describe('createScope', () => {
|
|
it('tags the ctx (scopeOf) and leaves the root untagged', () => {
|
|
const { root, a } = bench()
|
|
expect(scopeOf(a.ctx)).toBe(sid('a'))
|
|
expect(scopeOf(root)).toBeUndefined()
|
|
})
|
|
|
|
it('scoped dispatch reaches same-session and untagged listeners, never a foreign session', () => {
|
|
const { root, a, b, seen, listen } = bench()
|
|
listen('a', a.ctx)
|
|
listen('b', b.ctx)
|
|
listen('root', root)
|
|
a.ctx.bail(a.ctx, 'test/scope-probe', { from: 'a' })
|
|
expect(seen).toEqual(['a:a', 'root:a'])
|
|
seen.length = 0
|
|
b.ctx.emit(b.ctx, 'test/scope-probe', { from: 'b' })
|
|
expect(seen).toEqual(['b:b', 'root:b'])
|
|
})
|
|
|
|
it('bail answers the first same-scope listener and skips filtered foreign ones', () => {
|
|
const { a, b, listen } = bench()
|
|
listen('b', b.ctx, true) // registered first, but foreign → filtered out
|
|
expect(a.ctx.bail(a.ctx, 'test/scope-probe', { from: 'a' })).toBeUndefined()
|
|
listen('a', a.ctx, true)
|
|
expect(a.ctx.bail(a.ctx, 'test/scope-probe', { from: 'a' })).toBe(true)
|
|
})
|
|
|
|
it('a subject-less root dispatch is unfiltered (every listener hears it)', () => {
|
|
const { root, a, b, seen, listen } = bench()
|
|
listen('a', a.ctx)
|
|
listen('b', b.ctx)
|
|
listen('root', root)
|
|
root.emit('test/scope-probe', { from: 'root' })
|
|
expect(seen).toEqual(['a:root', 'b:root', 'root:root'])
|
|
})
|
|
|
|
it('fiber disposal removes scope-owned listeners', async () => {
|
|
const { a, seen, listen } = bench()
|
|
listen('a', a.ctx)
|
|
await a.fiber.dispose()
|
|
a.ctx.emit(a.ctx, 'test/scope-probe', { from: 'late' })
|
|
expect(seen).toEqual([])
|
|
})
|
|
})
|