test: remove plugin testing-kit suites and repeated concurrency cases (#42248)

* test: remove redundant plugin schema and testing-kit suites

* test: remove repeated concurrency cases and runtime bookkeeping assertions

---------

Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
This commit is contained in:
OrcaWin
2026-11-13 18:35:16 -08:00
committed by GitHub
co-authored by OrcaWin
parent e784f9803d
commit a6b2a0803a
13 changed files with 16 additions and 461 deletions
@@ -12,26 +12,6 @@ function deferred<T>() {
}
describe('createCoalescingKeyedRunner', () => {
it('folds a burst that arrives mid-run into one trailing run that every burst caller shares', async () => {
const run = createCoalescingKeyedRunner<string>()
const first = deferred<string>()
const firstWork = vi.fn(() => first.promise)
const leading = run('repo', 'target', firstWork)
await vi.waitFor(() => expect(firstWork).toHaveBeenCalledTimes(1))
const burstWork = Array.from({ length: 5 }, (_, index) =>
vi.fn(async () => `trailing-${index}`)
)
const burst = burstWork.map((work) => run('repo', 'target', work))
expect(burstWork.every((work) => work.mock.calls.length === 0)).toBe(true)
first.resolve('leading')
await expect(leading).resolves.toBe('leading')
await expect(Promise.all(burst)).resolves.toEqual(Array(5).fill('trailing-4'))
expect(burstWork.slice(0, 4).every((work) => work.mock.calls.length === 0)).toBe(true)
expect(burstWork[4]).toHaveBeenCalledTimes(1)
})
it('queues a caller with a different share key behind the run in flight, never beside it', async () => {
const run = createCoalescingKeyedRunner<string>()
const first = deferred<string>()
@@ -100,7 +80,6 @@ describe('createCoalescingKeyedRunner', () => {
const other = vi.fn(async () => 'other')
await expect(run('repo-b', 'target', other)).resolves.toBe('other')
expect(other).toHaveBeenCalledTimes(1)
held.resolve('held')
await expect(heldResult).resolves.toBe('held')
})
+1 -91
View File
@@ -1,10 +1,5 @@
import { describe, expect, it, vi } from 'vitest'
import {
InFlightPromiseDedupe,
MAX_IN_FLIGHT_PROMISE_DEDUPE_ENTRIES,
MAX_IN_FLIGHT_PROMISE_DEDUPE_KEY_CODE_UNITS,
stableInFlightKey
} from './in-flight-promise-dedupe'
import { InFlightPromiseDedupe, stableInFlightKey } from './in-flight-promise-dedupe'
function deferred<T>(): { promise: Promise<T>; resolve: (value: T) => void } {
let resolve!: (value: T) => void
@@ -28,38 +23,8 @@ describe('InFlightPromiseDedupe', () => {
expect(first).toBe(second)
await expect(first).rejects.toThrow('transient failure')
expect(load).toHaveBeenCalledTimes(1)
await expect(dedupe.run(key, load)).resolves.toBe('fresh')
expect(load).toHaveBeenCalledTimes(2)
})
it('uses exact keys for distinct input parts', async () => {
const dedupe = new InFlightPromiseDedupe<string>()
const load = vi.fn(async () => 'value')
await Promise.all([
dedupe.run(stableInFlightKey(['diff', '/repo', 'src/file.ts', true]), load),
dedupe.run(stableInFlightKey(['diff', '/repo', 'src/file.ts', false]), load)
])
expect(load).toHaveBeenCalledTimes(2)
})
it('clears entries after synchronous loader failures', async () => {
const dedupe = new InFlightPromiseDedupe<string>()
const load = vi
.fn<() => Promise<string> | string>()
.mockImplementationOnce(() => {
throw new Error('sync failure')
})
.mockResolvedValueOnce('fresh')
const key = stableInFlightKey(['diff', '/repo', 'src/file.ts'])
await expect(dedupe.run(key, () => Promise.resolve(load()))).rejects.toThrow('sync failure')
await expect(dedupe.run(key, () => Promise.resolve(load()))).resolves.toBe('fresh')
expect(load).toHaveBeenCalledTimes(2)
})
it('clear drops pending entries so later calls start fresh work', async () => {
@@ -72,7 +37,6 @@ describe('InFlightPromiseDedupe', () => {
dedupe.clear()
await expect(dedupe.run(key, load)).resolves.toBe('fresh')
expect(load).toHaveBeenCalledTimes(2)
})
it('expires hung entries so retries can start fresh work', async () => {
@@ -88,39 +52,11 @@ describe('InFlightPromiseDedupe', () => {
vi.advanceTimersByTime(5)
await expect(dedupe.run(key, load)).resolves.toBe('fresh')
expect(load).toHaveBeenCalledTimes(2)
} finally {
vi.useRealTimers()
}
})
it('admits exactly the entry limit and bypasses new keys above it', async () => {
const dedupe = new InFlightPromiseDedupe<string>()
const pending = Array.from({ length: MAX_IN_FLIGHT_PROMISE_DEDUPE_ENTRIES }, () =>
deferred<string>()
)
const admittedLoads = pending.map((item) => vi.fn(() => item.promise))
for (let index = 0; index < pending.length; index += 1) {
const first = dedupe.run(`key-${index}`, admittedLoads[index])
const second = dedupe.run(`key-${index}`, admittedLoads[index])
expect(second).toBe(first)
}
const overflowLoad = vi.fn(async () => 'overflow')
const firstOverflow = dedupe.run('overflow', overflowLoad)
const secondOverflow = dedupe.run('overflow', overflowLoad)
expect(secondOverflow).not.toBe(firstOverflow)
await expect(Promise.all([firstOverflow, secondOverflow])).resolves.toEqual([
'overflow',
'overflow'
])
expect(overflowLoad).toHaveBeenCalledTimes(2)
pending.forEach((item) => item.resolve('settled'))
await Promise.all(pending.map((item) => item.promise))
})
it('admits a new key after a retained entry settles', async () => {
const dedupe = new InFlightPromiseDedupe<string>(30_000, 1)
const firstPending = deferred<string>()
@@ -134,31 +70,5 @@ describe('InFlightPromiseDedupe', () => {
expect(dedupe.run('next', load)).toBe(next)
nextPending.resolve('next-result')
await expect(next).resolves.toBe('next-result')
expect(load).toHaveBeenCalledTimes(1)
})
it('keeps stable keys inline through the size limit and digests larger keys', () => {
const exactInput = 'x'.repeat(MAX_IN_FLIGHT_PROMISE_DEDUPE_KEY_CODE_UNITS - 4)
const oversizedInput = `${exactInput}x`
expect(stableInFlightKey([exactInput])).toBe(JSON.stringify([exactInput]))
const firstDigest = stableInFlightKey([oversizedInput])
expect(firstDigest).toMatch(/^sha256:[a-f0-9]{64}$/)
expect(stableInFlightKey([oversizedInput])).toBe(firstDigest)
expect(stableInFlightKey([`${oversizedInput}x`])).not.toBe(firstDigest)
})
it('coalesces direct oversized keys through their bounded identity', async () => {
const dedupe = new InFlightPromiseDedupe<string>()
const pending = deferred<string>()
const load = vi.fn(() => pending.promise)
const oversizedKey = 'x'.repeat(MAX_IN_FLIGHT_PROMISE_DEDUPE_KEY_CODE_UNITS + 1)
const first = dedupe.run(oversizedKey, load)
expect(dedupe.run(oversizedKey, load)).toBe(first)
pending.resolve('result')
await expect(first).resolves.toBe('result')
expect(load).toHaveBeenCalledTimes(1)
})
})
@@ -1,44 +0,0 @@
import { describe, expect, it } from 'vitest'
import { pluginManifestSchema } from '../manifest/plugin-manifest'
function manifest(contributes: Record<string, unknown>): Record<string, unknown> {
return {
manifestVersion: 1,
id: 'content-pack',
publisher: 'samples',
name: 'Content pack',
version: '1.0.0',
engines: { orca: '>=1.0.0' },
pluginApi: 1,
contributes,
capabilities: []
}
}
describe('content-pack manifest contributions', () => {
it('rejects duplicate ids, locales, paths, and bindings', () => {
const parsed = pluginManifestSchema.safeParse(
manifest({
languagePacks: [
{ locale: 'pt-BR', path: 'pt-br.json' },
{ locale: 'pt-br', path: 'other.json' }
],
commands: [{ id: 'open', title: 'Open', action: 'view.tasks' }],
keybindings: [
{ command: 'open', key: 'Mod+T' },
{ command: 'open', key: 'mod+t' }
]
})
)
expect(parsed.success).toBe(false)
if (!parsed.success) {
expect(parsed.error.issues.map((issue) => issue.message)).toEqual(
expect.arrayContaining([
'duplicate language pack locale: pt-br',
'duplicate keybinding: mod+t'
])
)
}
})
})
@@ -2,7 +2,6 @@ import { describe, expect, it } from 'vitest'
import { parsePluginManifest } from '../manifest/plugin-manifest'
import { PLUGIN_MANIFEST_V2_SINCE } from '../manifest/plugin-schema-field-docs'
import { matchPluginFile, pluginFileMatchRank } from './plugin-file-match'
import { requiresPluginContentApproval } from '../approval/plugin-consent-fingerprint'
import { pluginUpdateAccessGrowth } from '../approval/plugin-update-access-growth'
const excalidraw = {
@@ -35,9 +34,8 @@ function parsed(overrides: Record<string, unknown> = {}) {
}
describe('contributes.customEditors', () => {
it('binds approval to the editor bytes and counts a new file type as more reach', () => {
it('counts a new file type as more reach', () => {
const plugin = parsed()
expect(requiresPluginContentApproval(plugin)).toBe(true)
const wider = parsed({
contributes: { customEditors: [{ ...excalidraw, extensions: ['.excalidraw', '.svg'] }] }
})
@@ -86,6 +84,5 @@ describe('matchPluginFile', () => {
expect(pluginFileMatchRank(byName)).toBeGreaterThan(
pluginFileMatchRank(matchPluginFile('/repo/gleam.toml', match(['.toml'])))
)
expect(pluginFileMatchRank(null)).toBe(0)
})
})
@@ -1,40 +0,0 @@
import { describe, expect, it } from 'vitest'
import { PLUGIN_DECLARATIVE_LIMITS as LIMITS } from './plugin-declarative-limits'
import { parsePluginDeclarativeTree } from './plugin-declarative-tree'
const node = (type: string, props: Record<string, unknown> = {}, children: unknown[] = []) => ({
type,
props,
children
})
const parse = (raw: unknown) => parsePluginDeclarativeTree(raw)
const columns = [{ key: 'name', label: 'Name', sortable: true }]
describe('catalog 2 components', () => {
it('draws a placeholder for a Table or Tree with unusable data, and keeps the rest', () => {
const duplicateRows = node('Table', {
label: 'T',
columns,
rows: [
{ key: 'r', cells: {} },
{ key: 'r', cells: {} }
]
})
type Item = { key: string; label: string; children: Item[] }
const tooDeep: Item = { key: 'x0', label: 'x', children: [] }
let cursor = tooDeep
for (let depth = 1; depth <= LIMITS.maxTreeItemDepth; depth++) {
const next: Item = { key: `x${depth}`, label: 'x', children: [] }
cursor.children.push(next)
cursor = next
}
const deepTree = node('Tree', { label: 'T', items: [tooDeep] })
const result = parse(node('Stack', {}, [duplicateRows, deepTree, node('Text', {}, ['kept'])]))
expect(result.ok).toBe(true)
if (result.ok) {
expect(result.tree?.children.map((child) => typeof child !== 'string' && child.type)).toEqual(
['Unsupported', 'Unsupported', 'Text']
)
}
})
})
@@ -37,20 +37,3 @@ describe('parsePluginDeclarativeTree', () => {
])
})
})
describe('ui.* payloads', () => {
it('counts text children toward the aggregate node cap', () => {
const many = (count: number) => ({
type: 'Text',
props: {},
children: Array.from({ length: count }, () => '')
})
expect(parsePluginDeclarativeTree(many(4000)).ok).toBe(true)
const flood = parsePluginDeclarativeTree({
type: 'Stack',
props: {},
children: [many(4000), many(4000)]
})
expect(flood).toMatchObject({ ok: false, error: expect.stringContaining('nodes') })
})
})
@@ -24,16 +24,6 @@ function booted() {
return { runtime, posted, send, retained }
}
function entryKeys(payload: unknown): unknown[] {
const entries =
typeof payload === 'object' && payload !== null && 'entries' in payload ? payload.entries : null
return Array.isArray(entries)
? entries.map((each: unknown) =>
typeof each === 'object' && each !== null && 'key' in each ? each.key : null
)
: []
}
afterEach(() => {
vi.useRealTimers()
})
@@ -43,7 +33,6 @@ describe('dev hot reload of keyed memory atoms', () => {
const { runtime, send } = booted()
const draft = atom('hot.draft', '')
const bumped = atom('hot.bumped', { n: 0 }, { version: 2, migrate: () => ({ n: 99 }) })
const unkeyed = atom('kept out')
send('ui.hydrate', {
memory: {
'hot.draft': { version: 1, value: 'half a thought' },
@@ -53,9 +42,6 @@ describe('dev hot reload of keyed memory atoms', () => {
// A version bump starts the atom over; migrate is for persisted values only.
expect(read(bumped)).toEqual({ n: 0 })
expect(read(draft)).toBe('half a thought')
expect(read(unkeyed)).toBe('kept out')
// Atoms created after hydration (a lazily imported module) seed from it too.
expect(read(atom('hot.late', 'initial'))).toBe('initial')
await runtime.boot({ default: () => h('Text', null, read(draft)) })
runtime.dispose()
})
@@ -97,20 +83,4 @@ describe('dev hot reload of keyed memory atoms', () => {
vi.advanceTimersByTime(100)
expect(retained()).toHaveLength(2)
})
it('never posts persisted atoms as retained, nor memory atoms as persisted', () => {
vi.useFakeTimers()
const { runtime, send, posted } = booted()
const saved = atom('hot.saved', 'a', { persist: 'plugin' })
const kept = atom('hot.kept', 'a')
send('ui.hydrate', { retain: true })
set(saved, 'b')
set(kept, 'b')
vi.advanceTimersByTime(500)
const keysOf = (event: string) =>
posted.filter((entry) => entry.event === event).flatMap((entry) => entryKeys(entry.payload))
expect(keysOf('ui.persist')).toEqual(['hot.saved'])
expect(keysOf('ui.retain')).toEqual(['hot.kept'])
runtime.dispose()
})
})
@@ -103,7 +103,7 @@ describe('declarative runtime', () => {
expect(deleted).toEqual(['A', 'B'])
})
it('ignores events and acks for another document', () => {
it('ignores events for another document', () => {
const { runtime, tree } = setup()
const onPress = vi.fn()
runtime.mount(() => h('Button', { onPress }, 'x'))
@@ -266,15 +266,6 @@ describe('declarative runtime', () => {
handlers.get('theme')?.({ colorScheme: 'light' })
drain()
expect(last()).toMatchObject({ tree: { children: ['light'] } })
expect([...handlers.keys()].sort()).toEqual([
'theme',
'ui.ack',
'ui.event',
'ui.hydrate',
'ui.restore',
'ui.snapshot',
'ui.visibility'
])
runtime.dispose()
expect(handlers.size).toBe(0)
})
@@ -1,48 +0,0 @@
import { afterEach, describe, expect, it } from 'vitest'
import { h } from '../runtime/declarative-elements'
import { mount, type TestPanel } from './orca-testing'
let panel: TestPanel | null = null
afterEach(async () => {
await panel?.unmount()
panel = null
})
function Status() {
return h(
'Box',
{ key: 'page', gap: 'md' },
h(
'Box',
{ key: 'header', direction: 'row', justify: 'between', background: 'muted' },
h('Heading', null, 'Services'),
h('Button', { onPress: () => undefined }, 'Refresh')
),
h(
'Box',
{ key: 'billing', border: 'danger', padding: 'sm' },
h('Text', null, 'billing'),
h('Badge', { tone: 'danger' }, 'Down')
)
)
}
describe('orca/testing reads Box', () => {
it('finds Boxes by type, role, text and testId, and controls inside them', async () => {
panel = await mount({ default: Status })
// Innermost matches only: the page Box holds the other two.
expect(panel.findAll({ type: 'Box' }).map((box) => box.key)).toEqual(['header', 'billing'])
expect(panel.find({ testId: 'page' })?.text).toBe('Services Refresh billing Down')
expect(panel.find({ testId: 'billing' })).toMatchObject({
type: 'Box',
role: 'group',
text: 'billing Down',
props: { border: 'danger', padding: 'sm' }
})
// The innermost match wins: the button, not the Boxes around it.
expect(panel.find({ text: 'Refresh' })?.type).toBe('Button')
expect(panel.find({ role: 'button', text: 'Refresh' })?.path).toBe('page/header/#1')
expect(panel.errors).toEqual([])
expect(panel.warnings).toEqual([])
})
})
@@ -1,39 +0,0 @@
import { describe, expect, it } from 'vitest'
import { mountWorker } from './orca-testing'
type HookOrca = {
hooks: { on(hook: string, handler: (event: unknown) => unknown): unknown }
}
const send = { terminalId: 't', text: 'rm -rf /', enter: true, inputKind: 'driving' }
const throwingGuard = {
default(orca: HookOrca) {
orca.hooks.on('terminal.send', () => {
throw new Error('status bar down')
})
}
}
describe('orca/testing hooks', () => {
it('fails closed for a hook listed with onError: deny, and open otherwise', async () => {
const closed = await mountWorker(throwingGuard, {
events: [],
commands: [],
hooks: [{ event: 'terminal.send', onError: 'deny' }]
})
await expect(closed.hooks.fire('terminal.send', send)).resolves.toEqual({
kind: 'deny',
reason: 'worker failed and denies on error: status bar down'
})
const open = await mountWorker(throwingGuard, {
events: [],
commands: [],
hooks: ['terminal.send']
})
await expect(open.hooks.fire('terminal.send', send)).resolves.toEqual({
kind: 'continue',
event: send
})
})
})
@@ -1,59 +0,0 @@
import { afterEach, describe, expect, it } from 'vitest'
import { atom, read, set } from '../runtime/declarative-atoms'
import { h } from '../runtime/declarative-elements'
import { plugin } from '../runtime/orca-module'
import { mockHost, mount, mountWorker, type TestPanel } from './orca-testing'
type Orca = {
log(message: string): void
host: { call(method: string, params?: unknown): Promise<unknown> }
events: { on(event: string, handler: (payload: unknown) => unknown): unknown }
commands: { register(id: string, handler: (args: unknown) => unknown): unknown }
panels: {
handle(
name: string,
handler: (input: unknown, context: { panel: { contributionId: string } }) => unknown
): unknown
post(event: string, payload?: unknown): void
}
storage: { set(key: string, value: unknown): Promise<void> }
}
let panel: TestPanel | null = null
afterEach(async () => {
await panel?.unmount()
panel = null
})
describe('a panel and its worker on one host', () => {
it("routes the panel's plugin.request to the mounted worker, unless `requests` stubs it", async () => {
const host = mockHost({ capabilities: [], requests: { stubbed: 'from the stub' } })
const worker = await mountWorker(
{
default: (orca: Orca) => {
orca.panels.handle('stats', (input) => ({ asked: input }))
orca.panels.handle('stubbed', () => 'from the worker')
}
},
{ host, events: [], commands: [] }
)
const answers = atom<unknown[]>([])
panel = await mount(
{
setup: () => {
void Promise.all([
plugin.request('stats', { n: 1 }),
plugin.request('stubbed'),
plugin.request('missing').catch((error: { code?: string }) => error.code)
]).then((values) => set(answers, values))
},
default: () => h('Text', null, JSON.stringify(read(answers)))
},
{ host }
)
expect(panel.find({ role: 'text' })?.text).toBe(
JSON.stringify([{ asked: { n: 1 } }, 'from the stub', 'unknown_method'])
)
await worker.deactivate()
})
})
@@ -1,38 +0,0 @@
import { afterEach, describe, expect, it } from 'vitest'
import { mockEditorHost, type MockEditorHost } from './testing-editor-host'
import type { MockEditorSession, MockEditorSessionOptions } from './testing-editor-frame-api'
/** `orca.document.session(options)` on the installed host, as an editor would call it. */
function session(options: MockEditorSessionOptions = {}): Promise<MockEditorSession> {
if (!host) {
throw new Error('no mockEditorHost')
}
return host.orca.document.session({ debounceMs: 0, ...options })
}
let host: MockEditorHost | null = null
afterEach(() => {
host?.dispose()
host = null
})
describe('mockEditorHost', () => {
it('sends outside changes and refuses the next edit on conflictNext', async () => {
host = mockEditorHost({ text: 'a' })
const replaced: unknown[] = []
const doc = await session({
merge: (_base: string, outside: string, mine: string) => outside + mine
})
doc.onReplace((value) => replaced.push(value))
host.replace('outside')
await new Promise((resolve) => setTimeout(resolve, 0))
expect(replaced).toEqual(['outside'])
host.conflictNext('agent')
doc.change('outside!')
await doc.flush()
expect(host.edits.map((edit) => edit.refused ?? 'applied')).toEqual(['conflict', 'applied'])
expect(host.text).toBe('agentoutside!')
expect(replaced.at(-1)).toBe('agentoutside!')
doc.dispose()
})
})
@@ -15,17 +15,16 @@ function chain(
plugins: Record<string, PluginHookHandler[]>,
overrides: Partial<PluginHookChainInput> = {}
) {
const logs: string[] = []
const outcome = runPluginHookChain({
event: 'terminal.send',
payload: send,
participants: Object.keys(plugins),
invoke: (pluginKey, payload) => runPluginWorkerHookHandlers(plugins[pluginKey] ?? [], payload),
log: (pluginKey, line) => void logs.push(`${pluginKey}: ${line}`),
log: () => undefined,
now: () => 0,
...overrides
})
return { outcome, logs }
return { outcome }
}
afterEach(() => {
@@ -61,25 +60,21 @@ describe('runPluginHookChain', () => {
expect(later).not.toHaveBeenCalled()
})
it('treats a throw as passing and logs plugin, event and duration', async () => {
const { outcome, logs } = chain(
{
'a.one': [
() => {
throw new Error('boom')
}
],
'a.two': [(event, next) => next({ ...read(event), text: 'pwd' })]
},
{ now: vi.fn().mockReturnValueOnce(10).mockReturnValue(42) }
)
it('continues to the next plugin after a handler throws', async () => {
const { outcome } = chain({
'a.one': [
() => {
throw new Error('boom')
}
],
'a.two': [(event, next) => next({ ...read(event), text: 'pwd' })]
})
await expect(outcome).resolves.toEqual({ kind: 'continue', payload: { ...send, text: 'pwd' } })
expect(logs).toEqual(['a.one: hook terminal.send skipped after 32ms: boom'])
})
it('carries on past a plugin that misses its deadline', async () => {
vi.useFakeTimers()
const { outcome, logs } = chain(
const { outcome } = chain(
{ 'a.slow': [], 'a.next': [] },
{
invoke: (pluginKey, payload) =>
@@ -91,10 +86,9 @@ describe('runPluginHookChain', () => {
)
await vi.advanceTimersByTimeAsync(2_000)
await expect(outcome).resolves.toEqual({ kind: 'deny', pluginKey: 'a.next', reason: 'second' })
expect(logs).toEqual(['a.slow: hook terminal.send skipped after 0ms: timed out after 2000ms'])
})
it('refuses when a fail-closed plugin throws, misses its deadline or answers nonsense', async () => {
it('refuses when a fail-closed plugin throws or answers nonsense', async () => {
const failsClosed = () => true
const thrown = chain(
{
@@ -111,7 +105,6 @@ describe('runPluginHookChain', () => {
pluginKey: 'a.guard',
reason: 'a.guard failed and denies on error: status bar down'
})
expect(thrown.logs[0]).toMatch(/denied after 0ms \(onError: deny\)/)
const nonsense = chain(
{},
{ participants: ['a.guard'], invoke: async () => 'nope', failsClosed }