mirror of
https://github.com/stablyai/orca.git
synced 2026-11-17 03:15:01 +00:00
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:
@@ -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,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 }
|
||||
|
||||
Reference in New Issue
Block a user