Files
orca/tests/e2e/cross-version-wire/preflight-workspace-scoped-downgrade.unit.test.ts

164 lines
6.7 KiB
TypeScript

// Pair workspace-scoped preflight across builds: old clients keep host defaults; old hosts strip unsupported worktreeId.
// Remove the capability from released lists so rolling releases cannot erase the downgrade case.
import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
import {
PREFLIGHT_WORKSPACE_SCOPED_RUNTIME_CAPABILITY,
RUNTIME_CAPABILITIES
} from '../../../src/shared/protocol-version'
import { RPC_PARAMS_BY_METHOD } from '../../../src/shared/rpc-contract/rpc-params-catalog.generated'
import { parseRpcRequestParams } from '../../../src/main/runtime/rpc/dispatcher-request-parsing'
import type { RpcAnyMethodDeclaration, RpcRequest } from '../../../src/main/runtime/rpc/core'
import { getRuntimeAgentInventoryKey } from '../../../src/renderer/src/store/slices/agent-inventory/runtime-agent-inventory-key'
import {
importReleaseCheckoutModule,
materializeReleaseCheckout,
resolveBaselineReleaseRef,
releaseModuleExport
} from './release-checkout'
const SUITE_TIMEOUT_MS = 180_000
const WORKTREE = 'repo-1::\\\\wsl.localhost\\Ubuntu\\home\\me\\repo'
type ParseParams = (
request: RpcRequest,
method: Pick<RpcAnyMethodDeclaration, 'params'>,
meta: unknown
) => { value?: unknown; error?: unknown }
type HostBuild = {
capabilities: readonly string[]
parse: (method: string, params: unknown) => unknown
}
const wire = vi.hoisted(() => {
const state: {
host: null | { capabilities: readonly string[]; parse: (m: string, p: unknown) => unknown }
sent: { method: string; params: unknown; hostSaw: unknown }[]
} = { host: null, sent: [] }
return state
})
vi.mock('@/runtime/rpc/compatibility/runtime-capability-proof', async (importOriginal) => {
const actual = await importOriginal<Record<string, unknown>>()
return {
...actual,
runtimeEnvironmentSupportsCapability: async (_environmentId: string, capability: string) =>
wire.host?.capabilities.includes(capability) ?? false
}
})
vi.mock('@/runtime/rpc/compatibility/runtime-compatibility-probe', async (importOriginal) => {
const actual = await importOriginal<Record<string, unknown>>()
return {
...actual,
// Why linux: an old Windows host is asked to update instead of answering its default list.
getRuntimeEnvironmentStatus: async () => ({
capabilities: wire.host?.capabilities ?? [],
hostPlatform: 'linux'
})
}
})
vi.mock('@/runtime/rpc/calls/runtime-rpc-call', async (importOriginal) => {
const actual = await importOriginal<Record<string, unknown>>()
return {
...actual,
callRuntimeRpc: async (_target: unknown, method: string, params?: unknown) => {
const hostSaw = wire.host?.parse(method, params)
wire.sent.push({ method, params, hostSaw })
const scoped = typeof hostSaw === 'object' && hostSaw !== null && 'worktreeId' in hostSaw
const agents = scoped ? ['claude', 'codex'] : ['claude']
return method === 'preflight.refreshAgents' ? { agents } : agents
}
}
})
// @ts-expect-error -- minimal window.api stub for the store under test
globalThis.window = { api: {} }
const { createTestStore } =
await import('../../../src/renderer/src/store/testing/app-store-test-fixture')
function hostBuild(
capabilities: readonly string[],
catalog: Record<string, unknown>,
parse: ParseParams
): HostBuild {
return {
capabilities,
parse: (method, params) => {
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: catalog entries are the Zod schema or null each build's dispatcher reads.
const schema = (catalog[method] ?? null) as RpcAnyMethodDeclaration['params']
const parsed = parse({ id: '1', authToken: 't', method, params }, { params: schema }, {})
if (parsed.error) {
throw new Error(`${method} refused ${JSON.stringify(params)}`)
}
return parsed.value
}
}
}
let oldHost: HostBuild
let newHost: HostBuild
beforeAll(async () => {
const checkout = await materializeReleaseCheckout(resolveBaselineReleaseRef())
const [protocol, catalog, parsing] = await Promise.all([
importReleaseCheckoutModule(checkout, 'src/shared/protocol-version.ts'),
importReleaseCheckoutModule(
checkout,
'src/shared/rpc-contract/rpc-params-catalog.generated.ts'
),
importReleaseCheckoutModule(checkout, 'src/main/runtime/rpc/dispatcher-request-parsing.ts')
])
const oldCatalog = releaseModuleExport<Record<string, unknown>>(catalog, 'RPC_PARAMS_BY_METHOD')
oldHost = hostBuild(
releaseModuleExport<readonly string[]>(protocol, 'RUNTIME_CAPABILITIES').filter(
(capability) => capability !== PREFLIGHT_WORKSPACE_SCOPED_RUNTIME_CAPABILITY
),
// Why null: once a release ships the schema, the old side must still be the pre-schema host.
{ ...oldCatalog, 'preflight.detectAgents': null, 'preflight.refreshAgents': null },
releaseModuleExport<ParseParams>(parsing, 'parseRpcRequestParams')
)
newHost = hostBuild(RUNTIME_CAPABILITIES, RPC_PARAMS_BY_METHOD, (request, method, meta) =>
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the parser only reads `params` from the declaration.
parseRpcRequestParams(request, method as RpcAnyMethodDeclaration, meta as never)
)
}, SUITE_TIMEOUT_MS)
beforeEach(() => {
wire.sent.length = 0
})
describe('workspace-scoped agent detection across versions', () => {
it('a new client asks an old host only for its default list', async () => {
wire.host = oldHost
const store = createTestStore()
const detected = await store.getState().ensureRuntimeDetectedAgents('env-1', WORKTREE)
const refreshed = await store.getState().refreshRuntimeDetectedAgents('env-1', WORKTREE)
expect(wire.sent.map(({ method, params }) => ({ method, params }))).toEqual([
{ method: 'preflight.detectAgents', params: undefined },
{ method: 'preflight.refreshAgents', params: undefined }
])
expect(detected).toEqual(['claude'])
expect(refreshed).toEqual(['claude'])
expect(
store.getState().runtimeDetectedAgentIds[getRuntimeAgentInventoryKey('env-1', WORKTREE)]
).toEqual(['claude'])
})
it('an old client gets the host default from a new host', async () => {
wire.host = newHost
for (const params of [undefined, null]) {
expect(newHost.parse('preflight.detectAgents', params)).toEqual({})
expect(newHost.parse('preflight.refreshAgents', params)).toEqual({})
}
// The host-default list keeps its environment-only key, which existing readers index by.
const store = createTestStore()
expect(await store.getState().ensureRuntimeDetectedAgents('env-1')).toEqual(['claude'])
expect(wire.sent[0]?.params).toBeUndefined()
expect(store.getState().runtimeDetectedAgentIds['env-1']).toEqual(['claude'])
})
})