mirror of
https://github.com/stablyai/orca.git
synced 2026-11-19 04:23:57 +00:00
test: remove 154 low-value tests and redundant relay checkpoints (#39814)
* test: remove 155 low-value tests and two relay checkpoints * test: retain schema drift protection and remove dead imports --------- Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
This commit is contained in:
@@ -1,5 +1,5 @@
|
||||
// GENERATED from the relay's SQLite schema (sqlite_master) by test/object-store-schema.test.ts.
|
||||
// Do not edit; regenerate with UPDATE_OBJECT_STORE_SCHEMA=1.
|
||||
// GENERATED from the relay's SQLite schema (sqlite_master) by test/generate-object-store-schema.ts.
|
||||
// Do not edit; regenerate with UPDATE_OBJECT_STORE_SCHEMA=1 ./node_modules/.bin/tsx test/generate-object-store-schema.ts.
|
||||
export const OBJECT_STORE_SCHEMA: readonly string[] = [
|
||||
"CREATE TABLE IF NOT EXISTS relay_audit_events (\n id TEXT PRIMARY KEY,\n at BIGINT NOT NULL,\n type TEXT NOT NULL,\n user_id TEXT,\n relay_host_id TEXT,\n relay_device_id TEXT,\n detail_json TEXT NOT NULL\n)",
|
||||
"CREATE TABLE IF NOT EXISTS relay_confirm_results (\n user_id TEXT NOT NULL,\n relay_host_id TEXT NOT NULL,\n req_id TEXT NOT NULL,\n basis_conn_id TEXT NOT NULL,\n tuple_json TEXT NOT NULL,\n result_json TEXT NOT NULL,\n committed_at BIGINT NOT NULL,\n PRIMARY KEY (user_id, relay_host_id, req_id)\n)",
|
||||
|
||||
@@ -27,7 +27,6 @@ export const EXPORT_FREEZE_MS = 30_000
|
||||
// Every table an object holds. Changing any of it (including a regenerated credential-store
|
||||
// schema) needs OBJECT_SCHEMA_VERSION bumped and the step in MIGRATIONS: existing objects keep
|
||||
// their old tables, because CREATE TABLE IF NOT EXISTS never alters them.
|
||||
// test/object-store-schema.test.ts pins the version to a hash of this DDL.
|
||||
export const OBJECT_SCHEMA_VERSION = 1
|
||||
export const MIGRATIONS: Readonly<Record<number, readonly string[]>> = {}
|
||||
const META_DDL = `CREATE TABLE IF NOT EXISTS edge_meta (
|
||||
|
||||
@@ -2,8 +2,7 @@ import { createHash, randomBytes } from 'node:crypto'
|
||||
import { SignJWT } from 'jose'
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { verifyAdminRequest, verifyWith, type AdminOp } from '../src/admin'
|
||||
import { ADMIN_JTI_MAX, ADMIN_JTI_SLACK_MS, admitJti } from '../src/admin-jti'
|
||||
import { edgeConfig, type Env } from '../src/env'
|
||||
import type { Env } from '../src/env'
|
||||
|
||||
const KEY = randomBytes(36).toString('base64url')
|
||||
const NEXT = randomBytes(36).toString('base64url')
|
||||
@@ -45,29 +44,6 @@ function request(token: string, body = BODY): Request {
|
||||
const baseEnv = { ADMIN_SIGNING_KEY: KEY, ADMIN_ISSUER: ISSUER } as Env
|
||||
|
||||
describe('admin token verify (jti)', () => {
|
||||
it('returns a replay guard for a token with a jti, bounded by exp and iat + 2 min', async () => {
|
||||
const now = Math.floor(Date.now() / 1000)
|
||||
const short = await verifyWith(await sign({ jti: JTI, iat: now, exp: now + 30 }), KEY, ISSUER, 'drain', raw())
|
||||
expect(short?.replay).toEqual({ jti: JTI, expiresAt: (now + 30) * 1000 })
|
||||
const long = await verifyWith(await sign({ jti: JTI, iat: now, exp: now + 600 }), KEY, ISSUER, 'drain', raw())
|
||||
expect(long?.replay?.expiresAt).toBe((now + 120) * 1000)
|
||||
expect(long?.body).toEqual(JSON.parse(BODY))
|
||||
})
|
||||
|
||||
it('accepts a token without a jti unless required', async () => {
|
||||
const token = await sign()
|
||||
expect((await verifyWith(token, KEY, ISSUER, 'drain', raw()))?.replay).toBeNull()
|
||||
expect(await verifyWith(token, KEY, ISSUER, 'drain', raw(), true)).toBeNull()
|
||||
expect(await verifyWith(await sign({ jti: JTI }), KEY, ISSUER, 'drain', raw(), true)).not.toBeNull()
|
||||
})
|
||||
|
||||
it('refuses a malformed jti', async () => {
|
||||
for (const jti of ['short', 'x'.repeat(129), 12345678901234567890, ['a'.repeat(20)]]) {
|
||||
expect(await verifyWith(await sign({ jti }), KEY, ISSUER, 'drain', raw())).toBeNull()
|
||||
}
|
||||
expect(await verifyWith(await sign({ jti: 'x'.repeat(16) }), KEY, ISSUER, 'drain', raw())).not.toBeNull()
|
||||
expect(await verifyWith(await sign({ jti: 'x'.repeat(128) }), KEY, ISSUER, 'drain', raw())).not.toBeNull()
|
||||
})
|
||||
|
||||
it('still binds op, body, key and age', async () => {
|
||||
const now = Math.floor(Date.now() / 1000)
|
||||
@@ -79,12 +55,6 @@ describe('admin token verify (jti)', () => {
|
||||
})
|
||||
|
||||
describe('admin request verify (keys)', () => {
|
||||
it('ADMIN_REQUIRE_JTI=1 refuses tokens without a jti', async () => {
|
||||
const env = { ...baseEnv, ADMIN_REQUIRE_JTI: '1' } as Env
|
||||
expect(await verifyAdminRequest(env, request(await sign()), 'drain')).toBeNull()
|
||||
expect(await verifyAdminRequest(env, request(await sign({ jti: JTI })), 'drain')).not.toBeNull()
|
||||
expect(await verifyAdminRequest(baseEnv, request(await sign()), 'drain')).not.toBeNull()
|
||||
})
|
||||
|
||||
it('accepts the primary or the NEXT key, nothing else', async () => {
|
||||
const env = { ...baseEnv, ADMIN_SIGNING_KEY_NEXT: NEXT } as Env
|
||||
@@ -105,37 +75,3 @@ describe('admin request verify (keys)', () => {
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
describe('admin jti single use', () => {
|
||||
const guard = { jti: JTI, expiresAt: 10_000 }
|
||||
it('records a fresh jti and refuses it again until it lapses', () => {
|
||||
const first = admitJti(undefined, guard, 1_000)
|
||||
expect(first.outcome).toBe('fresh')
|
||||
expect(first.seen[JTI]).toBe(10_000 + ADMIN_JTI_SLACK_MS)
|
||||
expect(admitJti(first.seen, guard, 5_000).outcome).toBe('replay')
|
||||
const later = admitJti(first.seen, { jti: 'other-jti-0123456789', expiresAt: 90_000 }, 10_000 + ADMIN_JTI_SLACK_MS)
|
||||
expect(later.outcome).toBe('fresh')
|
||||
expect(Object.keys(later.seen)).toEqual(['other-jti-0123456789'])
|
||||
})
|
||||
|
||||
it('refuses rather than forgets when full of live ids', () => {
|
||||
const seen = Object.fromEntries(Array.from({ length: ADMIN_JTI_MAX }, (_, i) => [`jti-${String(i).padStart(12, '0')}`, 50_000]))
|
||||
expect(admitJti(seen, guard, 1_000).outcome).toBe('jti_full')
|
||||
expect(admitJti(seen, guard, 50_000).outcome).toBe('fresh')
|
||||
})
|
||||
|
||||
it('ignores inherited property names', () => {
|
||||
expect(admitJti({}, { jti: 'propertyIsEnumerable', expiresAt: 10_000 }, 1_000).outcome).toBe('fresh')
|
||||
})
|
||||
})
|
||||
|
||||
describe('edge config (rotation keys)', () => {
|
||||
const env = (extra: Partial<Env>) =>
|
||||
({ EDGE_BACKEND: 'object', ...baseEnv, RELAY_JWKS: '{"keys":[]}', RELAY_JWT_AUDIENCE: 'orca-relay', PING_INTERVAL_MS: '1000', SILENCE_TIMEOUT_MS: '3000', ORPHAN_GRACE_MS: '1000', ...extra }) as Env
|
||||
it('a NEXT key, if set, must be at least 32 chars', () => {
|
||||
expect(() => edgeConfig(env({ ADMIN_SIGNING_KEY_NEXT: 'short' }))).toThrow('relay_edge_config_admin_next')
|
||||
expect(() => edgeConfig(env({ ERASE_SIGNING_KEY_NEXT: 'short' }))).toThrow('relay_edge_config_erase_next')
|
||||
expect(edgeConfig(env({ ADMIN_SIGNING_KEY_NEXT: NEXT, ERASE_SIGNING_KEY_NEXT: NEXT })).backend).toBe('object')
|
||||
expect(edgeConfig(env({ ADMIN_SIGNING_KEY_NEXT: '' })).backend).toBe('object')
|
||||
})
|
||||
})
|
||||
|
||||
@@ -1,147 +0,0 @@
|
||||
// Alert rules that scale with the cohort: configurable MIN_VOLUME, the reconnect surge, Cloudflare
|
||||
// GraphQL errors and the canary object probe. Analytics Engine, GraphQL, edge and webhook stubbed.
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest'
|
||||
import { evaluate } from '../src/alerts'
|
||||
import { cloudflareQuery } from '../src/alerts-cloudflare'
|
||||
import { probeObject } from '../src/alerts-probe'
|
||||
|
||||
const quiet = { phone_open: 20, control_active: 20, reconnects: 20, refuse_4401: 0, refuse_busy: 0, control_close: 5, db_ops: 0, db_failures: 0, admin_failures: 0, db_p95_ms: 0, events: 60 }
|
||||
const env = { ACCOUNT_ID: 'acct', DATASET: 'd', ENVIRONMENT: 'test', AE_READ_TOKEN: 't', ALERT_WEBHOOK_URL: 'https://hook.invalid' }
|
||||
const GRAPHQL = 'https://api.cloudflare.com/client/v4/graphql'
|
||||
const PROBE = 'https://edge.invalid'
|
||||
type Row = typeof quiet
|
||||
type Group = { sum: { requests: number }; dimensions: { status: string; namespaceId?: string } }
|
||||
type Graph = { w0?: Group[]; w1?: Group[]; o0?: Group[]; o1?: Group[] } | 'errors' | 'down'
|
||||
|
||||
const at17 = Date.UTC(2026, 10, 6, 10, 17)
|
||||
const at02 = Date.UTC(2026, 10, 6, 10, 2)
|
||||
const group = (status: string, requests: number, namespaceId?: string): Group => ({ sum: { requests }, dimensions: { status, ...(namespaceId ? { namespaceId } : {}) } })
|
||||
|
||||
function stub(now: Partial<Row>, before: Partial<Row> = {}, graph: Graph = {}) {
|
||||
const posts: string[] = []
|
||||
const graphql: { query: string; variables: Record<string, string> }[] = []
|
||||
vi.stubGlobal('fetch', async (url: string, init: RequestInit = {}) => {
|
||||
if (url === env.ALERT_WEBHOOK_URL) {
|
||||
posts.push(JSON.parse(String(init.body)).text)
|
||||
return new Response('ok')
|
||||
}
|
||||
if (url === GRAPHQL) {
|
||||
graphql.push(JSON.parse(String(init.body)))
|
||||
if (graph === 'down') { return new Response('no', { status: 403 }) }
|
||||
if (graph === 'errors') { return Response.json({ data: null, errors: [{ message: 'unknown field' }] }) }
|
||||
return Response.json({ data: { viewer: { accounts: [graph] } }, errors: null })
|
||||
}
|
||||
const sql = String(init.body)
|
||||
const row = sql.includes("INTERVAL '32' MINUTE") ? { ...quiet, ...before } : { ...quiet, ...now }
|
||||
return Response.json({ data: [sql.includes('db_p95_ms') && !sql.includes('sumIf') ? { db_p95_ms: row.db_p95_ms } : row] })
|
||||
})
|
||||
return { posts, graphql }
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
vi.unstubAllGlobals()
|
||||
})
|
||||
|
||||
describe('MIN_VOLUME', () => {
|
||||
it('scales the share rules to the cohort', async () => {
|
||||
stub({ refuse_4401: 1 })
|
||||
expect(await evaluate(env, at17)).toEqual([])
|
||||
stub({ refuse_4401: 1 })
|
||||
expect(await evaluate({ ...env, MIN_VOLUME: '20' }, at17)).toEqual(['FIRING auth-refusals: 4401 refusals 1 = 2.50% of hellos'])
|
||||
})
|
||||
})
|
||||
|
||||
describe('reconnect surge', () => {
|
||||
it('fires at 3x the previous window once above the floor', async () => {
|
||||
stub({ reconnects: 60 }, { reconnects: 20 })
|
||||
expect(await evaluate(env, at17)).toEqual(['FIRING reconnect-surge: control hellos 60 in 15 min, at least 3x the previous window'])
|
||||
})
|
||||
|
||||
it('stays quiet below the floor or below 3x', async () => {
|
||||
stub({ reconnects: 49 }, { reconnects: 0 })
|
||||
expect(await evaluate(env, at17)).toEqual([])
|
||||
stub({ reconnects: 100 }, { reconnects: 40 })
|
||||
expect(await evaluate(env, at17)).toEqual([])
|
||||
})
|
||||
|
||||
it('takes its floor from RECONNECT_SURGE_MIN', async () => {
|
||||
stub({ reconnects: 6 }, { reconnects: 2 })
|
||||
expect(await evaluate({ ...env, RECONNECT_SURGE_MIN: '5' }, at17)).toHaveLength(1)
|
||||
})
|
||||
})
|
||||
|
||||
describe('cloudflare errors', () => {
|
||||
it('is skipped without CF_GRAPHQL_TOKEN', async () => {
|
||||
const { graphql } = stub({})
|
||||
expect(await evaluate(env, at17)).toEqual([])
|
||||
expect(graphql).toHaveLength(0)
|
||||
})
|
||||
|
||||
it('fires above 20 errors and 1% of invocations, for the edge script', async () => {
|
||||
const { graphql, posts } = stub({}, {}, { w0: [group('success', 2000), group('clientDisconnected', 500), group('scriptThrewException', 30)], w1: [group('success', 2000)] })
|
||||
const fired = await evaluate({ ...env, CF_GRAPHQL_TOKEN: 'g' }, at17)
|
||||
expect(fired).toEqual(['FIRING cloudflare-errors: Worker/Durable Object errors 30 = 1.2% of 2530 invocations in 15 min'])
|
||||
expect(graphql[0].variables.script).toBe('orca-relay-edge')
|
||||
expect(graphql[0].variables.a).toBe('acct')
|
||||
expect(graphql[0].query).not.toContain('durableObjects')
|
||||
expect(posts[0]).not.toMatch(/acct|orca-relay-edge/)
|
||||
})
|
||||
|
||||
it('stays quiet under either threshold, and honours the env thresholds', async () => {
|
||||
stub({}, {}, { w0: [group('success', 20000), group('exceededResources', 30)] })
|
||||
expect(await evaluate({ ...env, CF_GRAPHQL_TOKEN: 'g' }, at17)).toEqual([])
|
||||
stub({}, {}, { w0: [group('success', 100), group('internalError', 20)] })
|
||||
expect(await evaluate({ ...env, CF_GRAPHQL_TOKEN: 'g' }, at17)).toEqual([])
|
||||
stub({}, {}, { w0: [group('success', 100), group('internalError', 20)] })
|
||||
expect(await evaluate({ ...env, CF_GRAPHQL_TOKEN: 'g', CF_ERRORS_MIN: '10' }, at17)).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('counts only the configured Durable Object namespaces', async () => {
|
||||
const { graphql } = stub({}, {}, { w0: [group('success', 100)], o0: [group('error', 50, 'ns-edge'), group('error', 500, 'ns-other'), group('success', 900, 'ns-edge')] })
|
||||
const fired = await evaluate({ ...env, CF_GRAPHQL_TOKEN: 'g', CF_DO_NAMESPACE_IDS: 'ns-edge' }, at17)
|
||||
expect(fired).toEqual(['FIRING cloudflare-errors: Worker/Durable Object errors 50 = 4.8% of 1050 invocations in 15 min'])
|
||||
expect(graphql[0].query).toContain('durableObjectsInvocationsAdaptiveGroups')
|
||||
})
|
||||
|
||||
it('reports an unreadable API hourly only, and keeps the other rules running', async () => {
|
||||
stub({ admin_failures: 3 }, {}, 'down')
|
||||
expect(await evaluate({ ...env, CF_GRAPHQL_TOKEN: 'g' }, at17)).toEqual(['FIRING admin-failures: 3 failed admin calls in 15 min'])
|
||||
stub({}, {}, 'errors')
|
||||
expect(await evaluate({ ...env, CF_GRAPHQL_TOKEN: 'g' }, at02)).toEqual(['alerts cannot read Cloudflare analytics: cloudflare analytics query returned errors'])
|
||||
})
|
||||
|
||||
it('keeps the query small: one call, both windows, documented fields only', () => {
|
||||
expect(cloudflareQuery(false)).toMatch(/w0:workersInvocationsAdaptive\(limit:50,filter:\{scriptName:\$script,datetime_geq:\$s0,datetime_lt:\$e0\}\)\{sum\{requests\} dimensions\{status\}\}/)
|
||||
expect(cloudflareQuery(true)).toContain('o1:durableObjectsInvocationsAdaptiveGroups')
|
||||
})
|
||||
})
|
||||
|
||||
describe('object probe', () => {
|
||||
const answer = (status: number, body: unknown) => vi.stubGlobal('fetch', async () => Response.json(body, { status }))
|
||||
|
||||
it('passes on 200 {ok:true} and alerts on 503 or a wrong body', async () => {
|
||||
answer(200, { ok: true })
|
||||
expect(await probeObject(PROBE)).toBeNull()
|
||||
answer(503, { ok: false })
|
||||
expect(await probeObject(PROBE)).toBe('object health check got 503, expected 200')
|
||||
answer(200, { ok: false })
|
||||
expect(await probeObject(PROBE)).toBe('object health check got 200, expected 200')
|
||||
})
|
||||
|
||||
it('alerts over 2 s', async () => {
|
||||
answer(200, { ok: true })
|
||||
let t = 0
|
||||
expect(await probeObject(PROBE, () => (t += 2_001))).toBe('object health check took 2001 ms')
|
||||
})
|
||||
|
||||
it('runs with the edge probe each cycle and fires as object-probe', async () => {
|
||||
vi.stubGlobal('fetch', async (url: string, init: RequestInit = {}) => {
|
||||
if (url === env.ALERT_WEBHOOK_URL) { return new Response('ok') }
|
||||
if (url === `${PROBE}/v1/host/control`) { return new Response(null, { status: 401 }) }
|
||||
if (url === `${PROBE}/__health/object`) { return Response.json({ ok: false }, { status: 503 }) }
|
||||
const sql = String(init.body)
|
||||
return Response.json({ data: [sql.includes('sumIf') ? quiet : { db_p95_ms: 0 }] })
|
||||
})
|
||||
expect(await evaluate({ ...env, EDGE_PROBE_URL: PROBE }, at17)).toEqual(['FIRING object-probe: object health check got 503, expected 200'])
|
||||
})
|
||||
})
|
||||
@@ -1,138 +0,0 @@
|
||||
// The absolute-count alert rules (fire below MIN_VOLUME) and the synthetic edge probe, with a
|
||||
// stubbed Analytics Engine, webhook and edge.
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest'
|
||||
import { ADMIN_SUCCESS_LABELS, evaluate } from '../src/alerts'
|
||||
import { probeEdge } from '../src/alerts-probe'
|
||||
|
||||
const quiet = { phone_open: 20, control_active: 20, refuse_4401: 0, refuse_busy: 0, control_close: 5, db_ops: 0, db_failures: 0, admin_failures: 0, db_p95_ms: 0, events: 60 }
|
||||
const env = { ACCOUNT_ID: 'a', DATASET: 'd', ENVIRONMENT: 'test', AE_READ_TOKEN: 't', ALERT_WEBHOOK_URL: 'https://hook.invalid', MIN_VOLUME: '200' }
|
||||
const PROBE = 'https://edge.invalid'
|
||||
type Row = typeof quiet
|
||||
type EdgeAnswer = number | 'network' | 'hang'
|
||||
|
||||
function stub(now: Partial<Row>, before: Partial<Row> = {}, edge: EdgeAnswer = 401) {
|
||||
const posts: string[] = []
|
||||
const probes: RequestInit[] = []
|
||||
const sqls: string[] = []
|
||||
vi.stubGlobal('fetch', async (url: string, init: RequestInit) => {
|
||||
if (url === env.ALERT_WEBHOOK_URL) {
|
||||
posts.push(JSON.parse(String(init.body)).text)
|
||||
return new Response('ok')
|
||||
}
|
||||
if (url === `${PROBE}/__health/object`) {
|
||||
if (edge === 'network') { throw new TypeError('connection refused') }
|
||||
return Response.json({ ok: true })
|
||||
}
|
||||
if (url === `${PROBE}/v1/host/control`) {
|
||||
probes.push(init)
|
||||
if (edge === 'network') { throw new TypeError('connection refused') }
|
||||
if (edge === 'hang') {
|
||||
return new Promise<Response>((_resolve, reject) => {
|
||||
init.signal?.addEventListener('abort', () => reject(init.signal?.reason))
|
||||
})
|
||||
}
|
||||
return new Response(null, { status: edge })
|
||||
}
|
||||
const sql = String(init.body)
|
||||
sqls.push(sql)
|
||||
const row = sql.includes("INTERVAL '32' MINUTE") ? { ...quiet, ...before } : { ...quiet, ...now }
|
||||
return Response.json({ data: [sql.includes('db_p95_ms') && !sql.includes('sumIf') ? { db_p95_ms: row.db_p95_ms } : row] })
|
||||
})
|
||||
return { posts, probes, sqls }
|
||||
}
|
||||
|
||||
const at17 = Date.UTC(2026, 10, 6, 10, 17)
|
||||
|
||||
afterEach(() => {
|
||||
vi.unstubAllGlobals()
|
||||
vi.useRealTimers()
|
||||
})
|
||||
|
||||
describe('absolute-count rules', () => {
|
||||
it('stay quiet on a healthy low-volume edge', async () => {
|
||||
stub({})
|
||||
expect(await evaluate(env, at17)).toEqual([])
|
||||
})
|
||||
|
||||
it('count every admin label outside the success list as a failure', async () => {
|
||||
const { sqls } = stub({})
|
||||
await evaluate(env, at17)
|
||||
const sql = sqls.find((s) => s.includes('admin_failures')) ?? ''
|
||||
for (const label of ADMIN_SUCCESS_LABELS) { expect(sql).toContain(`'${label}'`) }
|
||||
expect(sql).toMatch(/blob1 = 'admin' AND blob2 NOT IN \(/)
|
||||
expect(ADMIN_SUCCESS_LABELS).toEqual(expect.arrayContaining(['drain:drained', 'drain:idle', 'erase:mismatch', 'export:busy']))
|
||||
expect(ADMIN_SUCCESS_LABELS).not.toContain('assign:stale')
|
||||
})
|
||||
|
||||
it('fire on 3 admin failures at any volume, once', async () => {
|
||||
const { posts } = stub({ admin_failures: 3 })
|
||||
const fired = await evaluate(env, at17)
|
||||
expect(fired).toEqual(['FIRING admin-failures: 3 failed admin calls in 15 min'])
|
||||
expect(posts).toHaveLength(1)
|
||||
stub({ admin_failures: 3 }, { admin_failures: 4 })
|
||||
expect(await evaluate(env, at17)).toEqual([])
|
||||
stub({ admin_failures: 2 })
|
||||
expect(await evaluate(env, at17)).toEqual([])
|
||||
})
|
||||
|
||||
it('fire on 5 4401s below MIN_VOLUME; the share rule owns higher volume', async () => {
|
||||
stub({ refuse_4401: 5 })
|
||||
expect(await evaluate(env, at17)).toEqual(['FIRING auth-refusals-low-volume: 4401 refusals 5 in 15 min at low volume (40 hellos)'])
|
||||
stub({ refuse_4401: 4 })
|
||||
expect(await evaluate(env, at17)).toEqual([])
|
||||
stub({ refuse_4401: 5, phone_open: 1000, control_active: 1000 })
|
||||
expect(await evaluate(env, at17)).toEqual([])
|
||||
})
|
||||
})
|
||||
|
||||
describe('edge probe', () => {
|
||||
it('is skipped without EDGE_PROBE_URL', async () => {
|
||||
const { probes } = stub({})
|
||||
await evaluate(env, at17)
|
||||
expect(probes).toHaveLength(0)
|
||||
})
|
||||
|
||||
it('passes on 401 to an unauthenticated websocket upgrade', async () => {
|
||||
const { probes } = stub({})
|
||||
expect(await evaluate({ ...env, EDGE_PROBE_URL: `${PROBE}/` }, at17)).toEqual([])
|
||||
expect(probes).toHaveLength(1)
|
||||
const headers = new Headers(probes[0].headers)
|
||||
expect(headers.get('upgrade')).toBe('websocket')
|
||||
expect(headers.get('authorization')).toBeNull()
|
||||
})
|
||||
|
||||
it('alerts with the status on any other answer', async () => {
|
||||
const { posts } = stub({}, {}, 500)
|
||||
const fired = await evaluate({ ...env, EDGE_PROBE_URL: PROBE }, at17)
|
||||
expect(fired).toEqual(['FIRING edge-probe: unauthenticated control upgrade got 500, expected 401'])
|
||||
expect(posts).toEqual(['[relay-edge test] FIRING edge-probe: unauthenticated control upgrade got 500, expected 401'])
|
||||
})
|
||||
|
||||
it('alerts on a network error, and still when metrics are unreadable', async () => {
|
||||
stub({}, {}, 'network')
|
||||
expect(await probeEdge(PROBE)).toBe('unauthenticated control upgrade failed: connection refused')
|
||||
vi.stubGlobal('fetch', async (url: string) => {
|
||||
if (url === env.ALERT_WEBHOOK_URL) { return new Response('ok') }
|
||||
if (url.startsWith(PROBE)) { throw new TypeError('connection refused') }
|
||||
return new Response('no', { status: 403 })
|
||||
})
|
||||
const fired = await evaluate({ ...env, EDGE_PROBE_URL: PROBE }, at17)
|
||||
expect(fired[0]).toContain('FIRING edge-probe')
|
||||
expect(fired[1]).toContain('FIRING object-probe')
|
||||
expect(fired[2]).toContain('cannot read metrics')
|
||||
})
|
||||
|
||||
it('alerts after 5 s without an answer', async () => {
|
||||
vi.useFakeTimers()
|
||||
stub({}, {}, 'hang')
|
||||
const result = probeEdge(PROBE)
|
||||
await vi.advanceTimersByTimeAsync(5_001)
|
||||
expect(await result).toBe('unauthenticated control upgrade timed out after 5000 ms')
|
||||
})
|
||||
|
||||
it('alerts on a slow 401', async () => {
|
||||
stub({})
|
||||
let t = 0
|
||||
expect(await probeEdge(PROBE, () => (t += 5_001))).toBe('unauthenticated control upgrade took 5001 ms')
|
||||
})
|
||||
})
|
||||
@@ -1,12 +0,0 @@
|
||||
import { expect, it } from 'vitest'
|
||||
import { frameOver } from '../src/bytes'
|
||||
|
||||
it('measures frames in UTF-8 bytes, as ws maxPayload does', () => {
|
||||
expect(frameOver('a'.repeat(10), 10)).toBe(false)
|
||||
expect(frameOver('a'.repeat(11), 10)).toBe(true)
|
||||
// 4 × 3-byte characters = 12 bytes.
|
||||
expect(frameOver('€€€€', 10)).toBe(true)
|
||||
expect(frameOver('€€€', 10)).toBe(false)
|
||||
expect(frameOver(new ArrayBuffer(11), 10)).toBe(true)
|
||||
expect(frameOver(new ArrayBuffer(10), 10)).toBe(false)
|
||||
})
|
||||
@@ -0,0 +1,10 @@
|
||||
import { readFileSync, writeFileSync } from 'node:fs'
|
||||
import { relayObjectStoreSchema } from './object-store-schema'
|
||||
|
||||
const FILE = new URL('../src/object-store-schema.generated.ts', import.meta.url)
|
||||
|
||||
if (process.env.UPDATE_OBJECT_STORE_SCHEMA === '1') {
|
||||
const expected = await relayObjectStoreSchema()
|
||||
const body = `// GENERATED from the relay's SQLite schema (sqlite_master) by test/generate-object-store-schema.ts.\n// Do not edit; regenerate with UPDATE_OBJECT_STORE_SCHEMA=1 ./node_modules/.bin/tsx test/generate-object-store-schema.ts.\nexport const OBJECT_STORE_SCHEMA: readonly string[] = ${JSON.stringify(expected, null, 2)}\n`
|
||||
if (readFileSync(FILE, 'utf8') !== body) { writeFileSync(FILE, body) }
|
||||
}
|
||||
@@ -3,7 +3,6 @@
|
||||
import { SignJWT, exportJWK, generateKeyPair, type CryptoKey } from 'jose'
|
||||
import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
|
||||
import type { Env } from '../src/env'
|
||||
import { PERSISTED_JWKS_MAX_STALE_MS } from '../src/jwks-persist'
|
||||
|
||||
const ISSUER = 'https://auth.test.invalid'
|
||||
const HOST = 'AAAAAAAAAAAAAAAA'
|
||||
@@ -64,19 +63,6 @@ afterEach(() => {
|
||||
})
|
||||
|
||||
describe('relay JWT key availability', () => {
|
||||
it('reports keys_unavailable, not invalid, when a cold isolate cannot fetch and nothing is persisted', async () => {
|
||||
stubCache()
|
||||
authUp(() => false)
|
||||
const verify = await coldVerifier()
|
||||
expect(await verify(envFor(`https://auth.test.invalid/jwks/${++urlSeq}`), await mint())).toEqual({ ok: false, reason: 'keys_unavailable' })
|
||||
})
|
||||
|
||||
it('reports keys_unavailable on a non-200 answer', async () => {
|
||||
stubCache()
|
||||
vi.stubGlobal('fetch', async () => new Response('down', { status: 502 }))
|
||||
const verify = await coldVerifier()
|
||||
expect(await verify(envFor(`https://auth.test.invalid/jwks/${++urlSeq}`), await mint())).toEqual({ ok: false, reason: 'keys_unavailable' })
|
||||
})
|
||||
|
||||
it('still says invalid for a bad token when keys are available', async () => {
|
||||
stubCache()
|
||||
@@ -103,22 +89,4 @@ describe('relay JWT key availability', () => {
|
||||
// A forged token is still refused from the persisted set.
|
||||
expect(await cold(env, await mint(otherKey))).toEqual({ ok: false, reason: 'invalid' })
|
||||
})
|
||||
|
||||
it('ignores a persisted set past its max age, and one lacking the token key', async () => {
|
||||
const store = stubCache()
|
||||
authUp(() => false)
|
||||
const url = `https://auth.test.invalid/jwks/${++urlSeq}`
|
||||
const stored = (storedAt: number, keys: unknown) =>
|
||||
new Response(JSON.stringify(keys), { headers: { 'x-orca-jwks-stored-at': String(storedAt) } })
|
||||
store.set(url, stored(Date.now() - PERSISTED_JWKS_MAX_STALE_MS - 1000, jwks))
|
||||
expect(await (await coldVerifier())(envFor(url), await mint())).toEqual({ ok: false, reason: 'keys_unavailable' })
|
||||
store.set(url, stored(Date.now(), { keys: [] }))
|
||||
expect(await (await coldVerifier())(envFor(url), await mint())).toEqual({ ok: false, reason: 'keys_unavailable' })
|
||||
})
|
||||
|
||||
it('works without a Cache API (local tests)', async () => {
|
||||
authUp(() => true)
|
||||
const verify = await coldVerifier()
|
||||
expect((await verify(envFor(`https://auth.test.invalid/jwks/${++urlSeq}`), await mint())).ok).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
@@ -319,15 +319,6 @@ async function run(
|
||||
recovered.ws.close()
|
||||
}
|
||||
|
||||
// E2: the edge wrote what account erasure and director cleanup read (bases, audit events).
|
||||
const fresh = new pg.Client({ connectionString: DB_URL })
|
||||
await fresh.connect()
|
||||
const counts = (await fresh.query(`SELECT
|
||||
(SELECT count(*) FROM relay_connection_bases WHERE relay_host_id = $1) AS bases,
|
||||
(SELECT count(*) FROM relay_connection_bases WHERE relay_host_id = $1 AND active = 1) AS active_bases,
|
||||
(SELECT count(*) FROM relay_audit_events WHERE relay_host_id = $1) AS audits`, [host.relayHostId])).rows[0]
|
||||
await fresh.end()
|
||||
record('E2 connection bases recorded and deactivated on close; audit events written', Number(counts.bases) >= 2 && Number(counts.audits) >= 3, JSON.stringify(counts))
|
||||
back.client.closeNow()
|
||||
}
|
||||
|
||||
|
||||
@@ -1,29 +1,9 @@
|
||||
import { readFileSync, writeFileSync } from 'node:fs'
|
||||
import { expect, it } from 'vitest'
|
||||
import { OBJECT_STORE_SCHEMA } from '../src/object-store-schema.generated'
|
||||
import { relayObjectStoreSchema } from './object-store-schema'
|
||||
|
||||
const FILE = new URL('../src/object-store-schema.generated.ts', import.meta.url)
|
||||
|
||||
it('object store schema matches the relay schema', async () => {
|
||||
const expected = await relayObjectStoreSchema()
|
||||
if (process.env.UPDATE_OBJECT_STORE_SCHEMA === '1') {
|
||||
const body = `// GENERATED from the relay's SQLite schema (sqlite_master) by test/object-store-schema.test.ts.\n// Do not edit; regenerate with UPDATE_OBJECT_STORE_SCHEMA=1.\nexport const OBJECT_STORE_SCHEMA: readonly string[] = ${JSON.stringify(expected, null, 2)}\n`
|
||||
if (readFileSync(FILE, 'utf8') !== body) { writeFileSync(FILE, body) }
|
||||
return
|
||||
}
|
||||
expect([...OBJECT_STORE_SCHEMA]).toEqual(expected)
|
||||
})
|
||||
|
||||
// Bump OBJECT_SCHEMA_VERSION, add its MIGRATIONS step, then update this pin.
|
||||
const PINNED = { version: 1, ddlSha256: 'd4738f7d9d402cb8066ec99799e5ebe9dafd09621aba0151434e23741087828f' }
|
||||
|
||||
it('object tables change only with a schema version bump', async () => {
|
||||
const { createHash } = await import('node:crypto')
|
||||
const { OBJECT_DDL, OBJECT_SCHEMA_VERSION, MIGRATIONS } = await import('../src/object-store')
|
||||
const ddlSha256 = createHash('sha256').update(JSON.stringify(OBJECT_DDL)).digest('hex')
|
||||
expect({ version: OBJECT_SCHEMA_VERSION, ddlSha256 }).toEqual(PINNED)
|
||||
for (let v = 2; v <= OBJECT_SCHEMA_VERSION; v++) { expect(MIGRATIONS[v], `migration to v${v}`).toBeDefined() }
|
||||
expect([...OBJECT_STORE_SCHEMA]).toEqual(await relayObjectStoreSchema())
|
||||
})
|
||||
|
||||
it('stamps fresh objects, keeps pre-version ones, refuses objects newer than the code', async () => {
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
// The credential store's tables as the relay creates them: read back from an in-memory relay
|
||||
// database (schema plus migrations applied), so nothing is copied by hand. The Worker cannot import
|
||||
// the relay's database module (pg, node:sqlite), so src/object-store-schema.generated.ts holds the
|
||||
// result and test/object-store-schema.test.ts fails if it drifts. Regenerate:
|
||||
// UPDATE_OBJECT_STORE_SCHEMA=1 ./node_modules/.bin/vitest run test/object-store-schema.test.ts
|
||||
// result. Regenerate:
|
||||
// UPDATE_OBJECT_STORE_SCHEMA=1 ./node_modules/.bin/tsx test/generate-object-store-schema.ts
|
||||
import { openInMemoryRelayDatabase } from '../../relay/src/database/database'
|
||||
|
||||
export const OBJECT_STORE_TABLES = [
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import { admitPreAuth, sourceKey } from '../src/preauth'
|
||||
import type { Env } from '../src/env'
|
||||
|
||||
const req = (ip?: string) => new Request('https://edge.test/v1/connect/x', { headers: ip ? { 'cf-connecting-ip': ip } : {} })
|
||||
|
||||
describe('pre-auth source key', () => {
|
||||
it('keys IPv4 by address and IPv6 by /64, in any spelling', () => {
|
||||
expect(sourceKey(req('203.0.113.9'))).toBe('203.0.113.9')
|
||||
expect(sourceKey(req('2001:db8:0:1::5'))).toBe('2001:db8:0:1::/64')
|
||||
expect(sourceKey(req('2001:0DB8:0000:0001:aaaa:bbbb:cccc:dddd'))).toBe('2001:db8:0:1::/64')
|
||||
expect(sourceKey(req('2001:db8::1'))).toBe('2001:db8:0:0::/64')
|
||||
expect(sourceKey(req('::1'))).toBe('0:0:0:0::/64')
|
||||
expect(sourceKey(req())).toBe('unknown')
|
||||
})
|
||||
})
|
||||
|
||||
describe('pre-auth limiter', () => {
|
||||
const env = (limit: RateLimit['limit']) => ({ PREAUTH_LIMITER: { limit } }) as unknown as Env
|
||||
it('counts phone and data apart per source', async () => {
|
||||
const limit = vi.fn(async () => ({ success: true }))
|
||||
await admitPreAuth(env(limit), req('203.0.113.9'), 'phone')
|
||||
await admitPreAuth(env(limit), req('203.0.113.9'), 'data')
|
||||
expect(limit.mock.calls).toEqual([[{ key: 'phone:203.0.113.9' }], [{ key: 'data:203.0.113.9' }]])
|
||||
})
|
||||
it('refuses over the limit, fails open when the limiter errors, and passes without a binding', async () => {
|
||||
expect(await admitPreAuth(env(async () => ({ success: false })), req('203.0.113.9'), 'phone')).toBe(false)
|
||||
expect(await admitPreAuth(env(async () => { throw new Error('down') }), req('203.0.113.9'), 'phone')).toBe(true)
|
||||
expect(await admitPreAuth({} as Env, req('203.0.113.9'), 'phone')).toBe(true)
|
||||
})
|
||||
})
|
||||
@@ -80,7 +80,6 @@ async function main(): Promise<void> {
|
||||
const e2 = Number(toEdge.body.assignmentEpoch)
|
||||
record('2 director answers the edge with a newer epoch', toEdge.status === 200 && toEdge.body.cellUrl === EDGE_URL && e2 > e1, JSON.stringify({ status: toEdge.status, cellUrl: toEdge.body.cellUrl, epoch: e2, body: toEdge.status === 200 ? undefined : toEdge.body }))
|
||||
const onEdge = await online(EDGE_URL, e2)
|
||||
record('2 desktop hello accepted on the edge at that epoch', true)
|
||||
record('2 phone A (paired on the cell) resumes on the edge', resumed(await phone(EDGE_URL, tokenA)))
|
||||
const oldCell = await phone(CELL, tokenA)
|
||||
await waitFor(() => oldCell.state.closed !== null, 4000)
|
||||
|
||||
@@ -16,7 +16,6 @@ import { createRelayApp } from './app.js'
|
||||
|
||||
const EDGE_URL = 'https://edge.relay.example.test'
|
||||
const COHORT_HOST = 'edgecohorthost01'
|
||||
const OTHER_HOST = 'gcehostnotinedge'
|
||||
|
||||
const databases: RelayDatabase[] = []
|
||||
afterEach(async () => {
|
||||
@@ -105,35 +104,6 @@ async function harness(options: { seeded?: boolean } = {}) {
|
||||
}
|
||||
|
||||
describe('director routes with the relay edge', () => {
|
||||
it('answers a cohort host on the edge before any other lane, with the exact wire shape', async () => {
|
||||
const h = await harness()
|
||||
const response = await h.assign(COHORT_HOST, { reconnect: true })
|
||||
expect(response.status).toBe(200)
|
||||
const body = (await response.json()) as Record<string, unknown>
|
||||
expect(Object.keys(body).sort()).toEqual(['assignmentEpoch', 'cellUrl', 'lease', 'v'])
|
||||
expect(body).toMatchObject({ v: 1, cellUrl: EDGE_URL, assignmentEpoch: 1 })
|
||||
expect(h.plan).not.toHaveBeenCalled()
|
||||
expect(h.assignments.assign).not.toHaveBeenCalled()
|
||||
expect(h.assignments.resolve).not.toHaveBeenCalled()
|
||||
expect(h.raiseEpochFloor).toHaveBeenCalledWith({ userId: 'user-1', relayHostId: COHORT_HOST }, 1)
|
||||
// A re-ask keeps the epoch.
|
||||
expect(await (await h.assign(COHORT_HOST)).json()).toMatchObject({ assignmentEpoch: 1 })
|
||||
})
|
||||
|
||||
it('keeps today\'s path for hosts outside the cohort', async () => {
|
||||
const h = await harness()
|
||||
const response = await h.assign(OTHER_HOST)
|
||||
expect(response.status).toBe(200)
|
||||
expect(await response.json()).toMatchObject({ cellUrl: 'https://us-c1.relay.example.test' })
|
||||
expect(h.plan).toHaveBeenCalled()
|
||||
expect(h.assignments.assign).toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('keeps today\'s path for everyone until the edge cell is seeded', async () => {
|
||||
const h = await harness({ seeded: false })
|
||||
const response = await h.assign(COHORT_HOST)
|
||||
expect(await response.json()).toMatchObject({ cellUrl: 'https://us-c1.relay.example.test' })
|
||||
})
|
||||
|
||||
it('keeps a host still holding units on its old cell there (no 503), moving it on a later ask', async () => {
|
||||
const h = await harness()
|
||||
@@ -151,18 +121,6 @@ describe('director routes with the relay edge', () => {
|
||||
expect(h.assignments.assign).toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('answers a phone /v1/resolve for an edge host from the edge row, with the exact wire shape', async () => {
|
||||
const h = await harness()
|
||||
await h.assign(COHORT_HOST)
|
||||
const response = await h.resolve(COHORT_HOST)
|
||||
expect(response.status).toBe(200)
|
||||
const body = (await response.json()) as Record<string, unknown>
|
||||
expect(Object.keys(body).sort()).toEqual(['assignmentEpoch', 'cellUrl', 'leaseExpiresAt', 'v'])
|
||||
expect(body).toMatchObject({ v: 1, cellUrl: EDGE_URL, assignmentEpoch: 1 })
|
||||
expect(h.assignments.resolve).not.toHaveBeenCalled()
|
||||
expect(h.assignments.assign).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('never moves a host on a phone resolve', async () => {
|
||||
const h = await harness()
|
||||
const response = await h.resolve(COHORT_HOST)
|
||||
|
||||
@@ -1,198 +0,0 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi, type MockInstance } from 'vitest'
|
||||
import {
|
||||
EDGE_CONTROL_APPLIED_EVENT,
|
||||
EDGE_CONTROL_DEFAULTS,
|
||||
EDGE_CONTROL_OBJECT_NAME,
|
||||
parseEdgeControl,
|
||||
startEdgeControl,
|
||||
type EdgeControlFlags
|
||||
} from './edge-relay-control.js'
|
||||
import { edgeCohortBucket, edgeCohortBucketPermille, inEdgeCohort, type EdgeRelayConfig } from './edge-relay-cohort.js'
|
||||
|
||||
function edgeConfig(overrides: Partial<EdgeRelayConfig> = {}): EdgeRelayConfig {
|
||||
return {
|
||||
cellUrl: 'https://edge.relay.example.test',
|
||||
rolloutPercent: 0,
|
||||
allowHosts: new Set(),
|
||||
denyHosts: new Set(),
|
||||
regions: new Set(['us-central1']),
|
||||
...overrides
|
||||
}
|
||||
}
|
||||
|
||||
function hostId(index: number): string {
|
||||
return `host${String(index).padStart(12, '0')}`
|
||||
}
|
||||
|
||||
// Storage answers the stored object (or 404) by generation, like the cell flag channel's tests.
|
||||
function fakeGoogle() {
|
||||
const state: { object: { generation: number; body: string } | null; paths: string[] } = {
|
||||
object: null,
|
||||
paths: []
|
||||
}
|
||||
const fetchImpl: typeof fetch = async (target) => {
|
||||
const url = new URL(String(target))
|
||||
if (url.hostname === 'metadata.google.internal') {
|
||||
if (url.pathname.endsWith('/project/project-id')) { return new Response('onorca-cloud') }
|
||||
return Response.json({ access_token: 'ya29.secret-access-token', expires_in: 3_600 })
|
||||
}
|
||||
state.paths.push(decodeURIComponent(url.pathname))
|
||||
const object = state.object
|
||||
if (!object) { return new Response(null, { status: 404 }) }
|
||||
if (url.searchParams.get('ifGenerationNotMatch') === String(object.generation)) {
|
||||
return new Response(null, { status: 304 })
|
||||
}
|
||||
return new Response(object.body, { headers: { 'x-goog-generation': String(object.generation) } })
|
||||
}
|
||||
const store = (generation: number, flags: Record<string, unknown>) => {
|
||||
state.object = { generation, body: JSON.stringify({ v: 1, flags }) }
|
||||
}
|
||||
return { state, fetchImpl, store }
|
||||
}
|
||||
|
||||
describe('edge runtime control object', () => {
|
||||
let log: MockInstance<typeof console.log>
|
||||
let warn: MockInstance<typeof console.warn>
|
||||
beforeEach(() => {
|
||||
log = vi.spyOn(console, 'log').mockImplementation(() => {})
|
||||
warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
})
|
||||
afterEach(() => {
|
||||
log.mockRestore()
|
||||
warn.mockRestore()
|
||||
})
|
||||
|
||||
it('parses mode and permille, reports unknown keys, and voids the object on any bad known value', () => {
|
||||
expect(parseEdgeControl({ v: 1, flags: {} })).toEqual({ flags: { mode: 'on' }, ignoredKeys: [] })
|
||||
expect(parseEdgeControl({ v: 1, flags: { mode: 'down', rolloutPermille: 0, cohort: 'x' } })).toEqual({
|
||||
flags: { mode: 'down', rolloutPermille: 0 },
|
||||
ignoredKeys: ['cohort']
|
||||
})
|
||||
expect(parseEdgeControl({ v: 1, flags: { rolloutPermille: 1_000 } })).toEqual({
|
||||
flags: { mode: 'on', rolloutPermille: 1_000 },
|
||||
ignoredKeys: []
|
||||
})
|
||||
for (const flags of [
|
||||
{ mode: 'paused' },
|
||||
{ mode: true },
|
||||
{ rolloutPermille: 1_001 },
|
||||
{ rolloutPermille: -1 },
|
||||
{ rolloutPermille: 2.5 },
|
||||
{ rolloutPermille: '5' },
|
||||
{ mode: 'off', rolloutPermille: null }
|
||||
]) {
|
||||
expect(parseEdgeControl({ v: 1, flags })).toBeNull()
|
||||
}
|
||||
expect(parseEdgeControl({ v: 2, flags: {} })).toBeNull()
|
||||
expect(parseEdgeControl({ flags: {} })).toBeNull()
|
||||
})
|
||||
|
||||
it('reads director/edge.json, logs each applied change with no ids, and tells listeners', async () => {
|
||||
const google = fakeGoogle()
|
||||
const control = startEdgeControl({ fetch: google.fetchImpl, autoStart: false })
|
||||
const changes: EdgeControlFlags[] = []
|
||||
control.onChange(() => changes.push(control.flags()))
|
||||
await control.poll()
|
||||
expect(control.flags()).toEqual(EDGE_CONTROL_DEFAULTS)
|
||||
expect(google.state.paths.at(-1)).toBe(`/storage/v1/b/onorca-cloud-relay-control/o/${EDGE_CONTROL_OBJECT_NAME}`)
|
||||
google.store(3, { mode: 'off', rolloutPermille: 25 })
|
||||
await control.poll()
|
||||
// Unchanged object: no second change.
|
||||
await control.poll()
|
||||
google.store(4, { mode: 'down', note: 'incident' })
|
||||
await control.poll()
|
||||
// A bad value voids the object: the last applied flags stay.
|
||||
google.store(5, { mode: 'sideways' })
|
||||
await control.poll()
|
||||
expect(control.flags()).toEqual({ mode: 'down' })
|
||||
expect(changes).toEqual([{ mode: 'off', rolloutPermille: 25 }, { mode: 'down' }])
|
||||
const applied = log.mock.calls
|
||||
.map((call) => JSON.parse(String(call[0])) as Record<string, unknown>)
|
||||
.filter((line) => line.event === EDGE_CONTROL_APPLIED_EVENT)
|
||||
expect(applied).toEqual([
|
||||
{ event: EDGE_CONTROL_APPLIED_EVENT, generation: 3, flags: { mode: 'off', rolloutPermille: 25 } },
|
||||
{ event: EDGE_CONTROL_APPLIED_EVENT, generation: 4, flags: { mode: 'down' }, ignoredKeys: ['note'] }
|
||||
])
|
||||
control.stop()
|
||||
})
|
||||
|
||||
it('logs a throwing listener and still applies the flags', async () => {
|
||||
const google = fakeGoogle()
|
||||
const control = startEdgeControl({ fetch: google.fetchImpl, autoStart: false })
|
||||
control.onChange(() => {
|
||||
throw new Error('listener_broke')
|
||||
})
|
||||
google.store(2, { mode: 'off' })
|
||||
await control.poll()
|
||||
expect(control.flags()).toEqual({ mode: 'off' })
|
||||
expect(warn.mock.calls.map((call) => String(call[0])).join('\n')).toContain('orca_relay_control_flags_listener_failed')
|
||||
control.stop()
|
||||
})
|
||||
})
|
||||
|
||||
describe('edge cohort under runtime control', () => {
|
||||
it('reads the applied flags on every call: off and down empty the cohort, even allowed hosts', () => {
|
||||
const flags: EdgeControlFlags = { mode: 'on' }
|
||||
const host = hostId(1)
|
||||
const config = edgeConfig({
|
||||
rolloutPercent: 100,
|
||||
allowHosts: new Set([hostId(2)]),
|
||||
allowUsers: new Set(['user-team']),
|
||||
control: () => flags
|
||||
})
|
||||
expect(inEdgeCohort(config, host, 'us-central1')).toBe(true)
|
||||
for (const mode of ['off', 'down'] as const) {
|
||||
flags.mode = mode
|
||||
expect(inEdgeCohort(config, host, 'us-central1')).toBe(false)
|
||||
expect(inEdgeCohort(config, hostId(2), 'us-central1')).toBe(false)
|
||||
expect(inEdgeCohort(config, host, 'us-central1', 'user-team')).toBe(false)
|
||||
}
|
||||
flags.mode = 'on'
|
||||
expect(inEdgeCohort(config, hostId(2), 'us-central1')).toBe(true)
|
||||
// A permille replaces the env percent; deny, allow and region rules still apply around it.
|
||||
flags.rolloutPermille = 0
|
||||
expect(inEdgeCohort(config, host, 'us-central1')).toBe(false)
|
||||
expect(inEdgeCohort(config, hostId(2), 'us-central1')).toBe(true)
|
||||
flags.rolloutPermille = 1_000
|
||||
expect(inEdgeCohort(config, host, 'us-central1')).toBe(true)
|
||||
expect(inEdgeCohort(config, host, 'asia-east2')).toBe(false)
|
||||
expect(inEdgeCohort({ ...config, denyHosts: new Set([host]) }, host, 'us-central1')).toBe(false)
|
||||
})
|
||||
|
||||
it('keeps every host of P percent in at P × 10 permille, for every P', () => {
|
||||
// floor(permille bucket / 10) is the percent bucket, so `bucket < P × 10` iff `bucket < P`.
|
||||
const hosts = Array.from({ length: 20_000 }, (_, index) => hostId(index))
|
||||
expect(hosts.filter((host) => Math.floor(edgeCohortBucketPermille(host) / 10) !== edgeCohortBucket(host))).toEqual([])
|
||||
const sample = hosts.slice(0, 2_000)
|
||||
const moved: string[] = []
|
||||
for (let percent = 0; percent <= 100; percent += 1) {
|
||||
const byPercent = edgeConfig({ rolloutPercent: percent })
|
||||
const byPermille = edgeConfig({ rolloutPercent: 0, control: () => ({ mode: 'on', rolloutPermille: percent * 10 }) })
|
||||
for (const host of sample) {
|
||||
if (inEdgeCohort(byPercent, host, 'us-central1') !== inEdgeCohort(byPermille, host, 'us-central1')) {
|
||||
moved.push(`${percent}:${host}`)
|
||||
}
|
||||
}
|
||||
}
|
||||
expect(moved).toEqual([])
|
||||
// The env percent alone (boot, no permille flag) answers as before.
|
||||
expect(sample.filter((host) => inEdgeCohort(edgeConfig({ rolloutPercent: 10 }), host, 'us-central1')))
|
||||
.toEqual(sample.filter((host) => edgeCohortBucket(host) < 10))
|
||||
})
|
||||
|
||||
it('steps in 1 permille shares, nested, roughly evenly', () => {
|
||||
const hosts = Array.from({ length: 20_000 }, (_, index) => hostId(index))
|
||||
const share = (permille: number) =>
|
||||
hosts.filter((host) => inEdgeCohort(edgeConfig({ control: () => ({ mode: 'on', rolloutPermille: permille }) }), host, 'us-central1'))
|
||||
const one = share(1)
|
||||
const five = share(5)
|
||||
expect(one.length).toBeGreaterThan(5)
|
||||
expect(one.length).toBeLessThan(40)
|
||||
expect(five.length).toBeGreaterThan(70)
|
||||
expect(five.length).toBeLessThan(130)
|
||||
// A larger share keeps every host of a smaller one.
|
||||
expect(one.every((host) => five.includes(host))).toBe(true)
|
||||
const buckets = new Set(hosts.map((host) => edgeCohortBucketPermille(host)))
|
||||
expect(buckets.size).toBe(1_000)
|
||||
})
|
||||
})
|
||||
@@ -9,14 +9,7 @@ import {
|
||||
type EdgeAdmin,
|
||||
type EdgeDrainResult
|
||||
} from './edge-admin-client.js'
|
||||
import {
|
||||
EDGE_EVACUATION_BATCH,
|
||||
EDGE_EVACUATION_BUSY_INTERVAL_MS,
|
||||
EDGE_EVACUATION_CONCURRENCY,
|
||||
EDGE_EVACUATION_CONTROL_DELAY_MS,
|
||||
EDGE_EVACUATION_INTERVAL_MS,
|
||||
EdgeEvacuation
|
||||
} from './edge-relay-evacuation.js'
|
||||
import { EDGE_EVACUATION_BUSY_INTERVAL_MS, EDGE_EVACUATION_CONCURRENCY, EDGE_EVACUATION_CONTROL_DELAY_MS, EdgeEvacuation } from './edge-relay-evacuation.js'
|
||||
import { EDGE_CELL_ID, type EdgeRelayConfig } from './edge-relay.js'
|
||||
import type { EdgeControlFlags } from './edge-relay-control.js'
|
||||
|
||||
@@ -94,106 +87,7 @@ async function harness(overrides: Partial<EdgeRelayConfig> = {}, random = 0.5) {
|
||||
return { database, config, admin, clock, evacuation, insert, prefer }
|
||||
}
|
||||
|
||||
describe('edge evacuation sweep', () => {
|
||||
it('drains only edge rows whose host left the cohort, and logs the outcome', async () => {
|
||||
const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const h = await harness({ allowHosts: new Set([hostId(1)]), denyHosts: new Set([hostId(2)]) })
|
||||
await h.insert(hostId(1))
|
||||
await h.insert(hostId(2))
|
||||
await h.insert(hostId(3), 'us-c1')
|
||||
expect(await h.evacuation.sweep()).toBe(1)
|
||||
expect(h.admin.drained).toEqual([hostId(2)])
|
||||
const events = warn.mock.calls.map(([line]) => JSON.parse(String(line)) as Record<string, unknown>)
|
||||
expect(events).toEqual([{ event: 'orca_relay_edge_drain_sent', outcome: 'drained', controls: 1 }])
|
||||
})
|
||||
|
||||
it('reads the region from the stored preference, else the default region', async () => {
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const h = await harness({ allowUsers: new Set(['user-team']) })
|
||||
await h.insert(hostId(1), EDGE_CELL_ID, 'user-team')
|
||||
await h.insert(hostId(2), EDGE_CELL_ID, 'user-team')
|
||||
await h.insert(hostId(3), EDGE_CELL_ID, 'user-team')
|
||||
await h.prefer(hostId(1), 'asia-east2', 'user-team')
|
||||
await h.prefer(hostId(2), 'us-central1', 'user-team')
|
||||
await h.evacuation.sweep()
|
||||
expect(h.admin.drained).toEqual([hostId(1)])
|
||||
})
|
||||
|
||||
it(`drains at most ${EDGE_EVACUATION_BATCH} per tick, the rest on the next, and not again within the cooldown`, async () => {
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
for (let index = 0; index < EDGE_EVACUATION_BATCH + 25; index += 1) { await h.insert(hostId(index)) }
|
||||
h.admin.answer = { outcome: 'idle' }
|
||||
expect(await h.evacuation.sweep()).toBe(EDGE_EVACUATION_BATCH)
|
||||
expect(await h.evacuation.sweep()).toBe(25)
|
||||
expect(new Set(h.admin.drained).size).toBe(EDGE_EVACUATION_BATCH + 25)
|
||||
expect(await h.evacuation.sweep()).toBe(0)
|
||||
h.clock.now += 10 * 60_000
|
||||
expect(await h.evacuation.sweep()).toBe(EDGE_EVACUATION_BATCH)
|
||||
})
|
||||
|
||||
it('logs an unavailable edge and carries on with the next host, retrying it later', async () => {
|
||||
const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
await h.insert(hostId(1))
|
||||
await h.insert(hostId(2))
|
||||
h.admin.unavailable.add(hostId(1))
|
||||
expect(await h.evacuation.sweep()).toBe(1)
|
||||
expect(h.admin.drained).toEqual([hostId(2)])
|
||||
expect(JSON.parse(String(warn.mock.calls[0]![0]))).toEqual({
|
||||
event: 'orca_relay_edge_drain_failed',
|
||||
reason: 'relay_edge_admin_unavailable:status_404'
|
||||
})
|
||||
h.admin.unavailable.clear()
|
||||
expect(await h.evacuation.sweep()).toBe(1)
|
||||
expect(h.admin.drained).toEqual([hostId(2), hostId(1)])
|
||||
})
|
||||
|
||||
it('runs on a jittered timer from start until stop', async () => {
|
||||
vi.useFakeTimers()
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
await h.insert(hostId(1))
|
||||
const sweep = vi.spyOn(h.evacuation, 'sweep')
|
||||
h.evacuation.start()
|
||||
// First pass soon after start, then the slow interval once nothing more is queued.
|
||||
await vi.advanceTimersByTimeAsync(EDGE_EVACUATION_BUSY_INTERVAL_MS - 1)
|
||||
expect(sweep).not.toHaveBeenCalled()
|
||||
await vi.advanceTimersByTimeAsync(1)
|
||||
expect(sweep).toHaveBeenCalledTimes(1)
|
||||
await vi.advanceTimersByTimeAsync(0)
|
||||
expect(h.admin.drained).toEqual([hostId(1)])
|
||||
await vi.advanceTimersByTimeAsync(EDGE_EVACUATION_BUSY_INTERVAL_MS)
|
||||
expect(sweep).toHaveBeenCalledTimes(1)
|
||||
await vi.advanceTimersByTimeAsync(EDGE_EVACUATION_INTERVAL_MS - EDGE_EVACUATION_BUSY_INTERVAL_MS)
|
||||
expect(sweep).toHaveBeenCalledTimes(2)
|
||||
h.evacuation.stop()
|
||||
await vi.advanceTimersByTimeAsync(10 * EDGE_EVACUATION_INTERVAL_MS)
|
||||
expect(sweep).toHaveBeenCalledTimes(2)
|
||||
})
|
||||
})
|
||||
|
||||
describe('edge evacuation under runtime control', () => {
|
||||
it('re-arms an idle sweep within 5 s of a control change, so a rollback drains at once', async () => {
|
||||
vi.useFakeTimers()
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const flags: EdgeControlFlags = { mode: 'on' }
|
||||
const h = await harness({ rolloutPercent: 100, control: () => flags })
|
||||
await h.insert(hostId(1))
|
||||
const sweep = vi.spyOn(h.evacuation, 'sweep')
|
||||
h.evacuation.start()
|
||||
await vi.advanceTimersByTimeAsync(EDGE_EVACUATION_BUSY_INTERVAL_MS)
|
||||
expect(sweep).toHaveBeenCalledTimes(1)
|
||||
expect(h.admin.drained).toEqual([])
|
||||
// Idle now: the next pass would be ~10 min away.
|
||||
await vi.advanceTimersByTimeAsync(60_000)
|
||||
flags.mode = 'off'
|
||||
h.evacuation.controlChanged()
|
||||
await vi.advanceTimersByTimeAsync(EDGE_EVACUATION_CONTROL_DELAY_MS)
|
||||
expect(sweep).toHaveBeenCalledTimes(2)
|
||||
expect(h.admin.drained).toEqual([hostId(1)])
|
||||
h.evacuation.stop()
|
||||
})
|
||||
|
||||
it('re-arms after a pass that was running when the control changed', async () => {
|
||||
vi.useFakeTimers()
|
||||
@@ -233,37 +127,6 @@ describe('edge evacuation under runtime control', () => {
|
||||
expect(await pass).toBe(35)
|
||||
expect(most).toBe(EDGE_EVACUATION_CONCURRENCY)
|
||||
})
|
||||
|
||||
it('starts each pass at a random point of the keys and wraps around to it', async () => {
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const users = ['20000000-a', '60000000-a', 'a0000000-a', 'e0000000-a']
|
||||
const drainedFrom = async (random: number) => {
|
||||
const h = await harness({}, random)
|
||||
for (const [index, user] of users.entries()) { await h.insert(hostId(index), EDGE_CELL_ID, user) }
|
||||
expect(await h.evacuation.sweep()).toBe(4)
|
||||
return h.admin.drained
|
||||
}
|
||||
expect(await drainedFrom(0.5)).toEqual([hostId(2), hostId(3), hostId(0), hostId(1)])
|
||||
expect(await drainedFrom(0.1)).toEqual([hostId(0), hostId(1), hostId(2), hostId(3)])
|
||||
expect(await drainedFrom(0.3)).toEqual([hostId(1), hostId(2), hostId(3), hostId(0)])
|
||||
})
|
||||
|
||||
it('pages an idle pass: one page of edge rows per tick, then idle until the next pass', async () => {
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const h = await harness({ rolloutPercent: 100 })
|
||||
for (let index = 0; index < 1_200; index += 1) { await h.insert(hostId(index)) }
|
||||
const query = vi.spyOn(h.database, 'query')
|
||||
const pages = () => query.mock.calls.filter(([sql]) => String(sql).includes('FROM relay_assignments a')).length
|
||||
const busy = () => (h.evacuation as unknown as { busy: boolean }).busy
|
||||
await h.evacuation.sweep()
|
||||
expect([pages(), busy()]).toEqual([1, true])
|
||||
await h.evacuation.sweep()
|
||||
expect([pages(), busy()]).toEqual([2, true])
|
||||
// The short last page wraps to the start of the keys, which holds nothing before the origin.
|
||||
await h.evacuation.sweep()
|
||||
expect([pages(), busy()]).toEqual([4, false])
|
||||
expect(h.admin.drained).toEqual([])
|
||||
})
|
||||
})
|
||||
|
||||
describe('edge admin drain call', () => {
|
||||
@@ -306,16 +169,4 @@ describe('edge admin drain call', () => {
|
||||
bodySha256: createHash('sha256').update(String(first.init.body)).digest('base64url')
|
||||
})
|
||||
})
|
||||
|
||||
it('treats a network failure as unavailable', async () => {
|
||||
const admin = createEdgeAdmin({
|
||||
cellUrl: EDGE_URL,
|
||||
signingKey: SIGNING_KEY,
|
||||
issuer: 'https://relay.example.test',
|
||||
fetch: async () => {
|
||||
throw new TypeError('fetch failed')
|
||||
}
|
||||
})
|
||||
await expect(admin.drain(hostId(1))).rejects.toThrow('relay_edge_admin_unavailable:network')
|
||||
})
|
||||
})
|
||||
|
||||
@@ -1,36 +1,10 @@
|
||||
import { jwtVerify } from 'jose'
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest'
|
||||
import { openInMemoryRelayDatabase, type RelayDatabase } from './database/database.js'
|
||||
import {
|
||||
EDGE_ADMIN_AUDIENCE,
|
||||
EDGE_ADMIN_LOCKED_TIMEOUT_MS,
|
||||
EdgeAdminUnavailableError,
|
||||
createEdgeAdmin,
|
||||
type EdgeAdmin,
|
||||
type EdgeAdminCallOptions,
|
||||
type EdgeAssignBody,
|
||||
type EdgeAssignResult
|
||||
} from './edge-admin-client.js'
|
||||
import { EDGE_EVACUATION_BUSY_INTERVAL_MS, EdgeEvacuation } from './edge-relay-evacuation.js'
|
||||
import {
|
||||
EDGE_FENCE_MAX_ATTEMPTS,
|
||||
EDGE_FENCE_RETRY_BASE_MS,
|
||||
EDGE_FENCE_RETRY_BATCH,
|
||||
EDGE_FENCE_RETRY_MAX_MS,
|
||||
edgeFenceRetryDelayMs,
|
||||
recordPendingFence,
|
||||
retryPendingFences
|
||||
} from './edge-relay-fence.js'
|
||||
import {
|
||||
EDGE_CELL_ID,
|
||||
EDGE_LOCKED_CALLS_MAX,
|
||||
EdgeAssignments,
|
||||
EdgeMoveDeferredError,
|
||||
type EdgeRelayConfig
|
||||
} from './edge-relay.js'
|
||||
import { EdgeAdminUnavailableError, type EdgeAdmin, type EdgeAdminCallOptions, type EdgeAssignBody, type EdgeAssignResult } from './edge-admin-client.js'
|
||||
import { EDGE_FENCE_RETRY_BASE_MS, EDGE_FENCE_RETRY_BATCH, recordPendingFence, retryPendingFences } from './edge-relay-fence.js'
|
||||
import { EDGE_CELL_ID, EdgeAssignments, type EdgeRelayConfig } from './edge-relay.js'
|
||||
|
||||
const EDGE_URL = 'https://edge.relay.example.test'
|
||||
const SIGNING_KEY = new TextEncoder().encode('edge-admin-key-with-at-least-32-bytes!!')
|
||||
const USER = 'user-1'
|
||||
const HOST = 'fencehost0000001'
|
||||
const T0 = 1_700_000_000_000
|
||||
@@ -123,29 +97,6 @@ function logged(spy: { mock: { calls: unknown[][] } }, event: string): Record<st
|
||||
}
|
||||
|
||||
describe('relay edge fence after a host leaves', () => {
|
||||
it('treats a stale answer as a failed fence: logged with its outcome, recorded, not retried inline', async () => {
|
||||
const error = vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
h.edge.answers = ['stale']
|
||||
expect(await h.assignments.fenceAway({ userId: USER, relayHostId: HOST }, 'us-c1', 9)).toBe(false)
|
||||
expect(h.edge.calls).toHaveLength(1)
|
||||
expect(logged(error, 'orca_relay_edge_fence_failed')).toEqual([
|
||||
{ event: 'orca_relay_edge_fence_failed', outcome: 'stale', cellId: 'us-c1', assignmentEpoch: 9 }
|
||||
])
|
||||
expect(await h.pending()).toEqual([
|
||||
{ relayHostId: HOST, cellId: 'us-c1', assignmentEpoch: 9, attempts: 0, nextAttemptAt: T0 + EDGE_FENCE_RETRY_BASE_MS }
|
||||
])
|
||||
})
|
||||
|
||||
it('retries conflict and unavailable inline, then records the last outcome', async () => {
|
||||
const error = vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
h.edge.answers = ['conflict', 'down', 'conflict']
|
||||
expect(await h.assignments.fenceAway({ userId: USER, relayHostId: HOST }, 'us-c1', 9)).toBe(false)
|
||||
expect(h.edge.calls).toHaveLength(3)
|
||||
expect(logged(error, 'orca_relay_edge_fence_failed')[0]).toMatchObject({ outcome: 'conflict' })
|
||||
expect(await h.pending()).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('records nothing when the fence lands, and a newer failure replaces an older record', async () => {
|
||||
vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
@@ -163,15 +114,6 @@ describe('relay edge fence after a host leaves', () => {
|
||||
{ relayHostId: HOST, cellId: 'us-c2', assignmentEpoch: 12, attempts: 0, nextAttemptAt: h.clock.now + EDGE_FENCE_RETRY_BASE_MS }
|
||||
])
|
||||
})
|
||||
|
||||
it('still answers when the failure cannot be recorded', async () => {
|
||||
const error = vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
await h.database.query(`DROP TABLE relay_edge_fence_pending`)
|
||||
h.edge.answers = ['stale']
|
||||
expect(await h.assignments.fenceAway({ userId: USER, relayHostId: HOST }, 'us-c1', 9)).toBe(false)
|
||||
expect(logged(error, 'orca_relay_edge_fence_record_failed')).toHaveLength(1)
|
||||
})
|
||||
})
|
||||
|
||||
describe('relay edge pending fence retries', () => {
|
||||
@@ -195,75 +137,6 @@ describe('relay edge pending fence retries', () => {
|
||||
])
|
||||
})
|
||||
|
||||
it('drops the record without a call when the host is back on the edge or has no row', async () => {
|
||||
vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
h.edge.answers = ['stale', 'stale']
|
||||
await h.assignments.fenceAway({ userId: USER, relayHostId: HOST }, 'us-c1', 9)
|
||||
await h.assignments.fenceAway({ userId: USER, relayHostId: 'fencehost0000002' }, 'us-c1', 4)
|
||||
await h.placeRow(EDGE_CELL_ID, 12)
|
||||
h.edge.calls = []
|
||||
h.clock.now += EDGE_FENCE_RETRY_BASE_MS
|
||||
expect(await h.retry()).toBe(false)
|
||||
expect(h.edge.calls).toEqual([])
|
||||
expect(await h.pending()).toEqual([])
|
||||
})
|
||||
|
||||
it('backs off on each failure, logging it, and gives up after the last attempt', async () => {
|
||||
const error = vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
await h.placeRow('us-c1', 9)
|
||||
h.edge.answers = ['stale']
|
||||
await h.assignments.fenceAway({ userId: USER, relayHostId: HOST }, 'us-c1', 9)
|
||||
h.clock.now += EDGE_FENCE_RETRY_BASE_MS
|
||||
for (let attempt = 1; attempt < EDGE_FENCE_MAX_ATTEMPTS; attempt += 1) {
|
||||
h.edge.answers = [attempt % 2 === 0 ? 'down' : 'conflict']
|
||||
expect(await h.retry()).toBe(true)
|
||||
expect(await h.pending()).toMatchObject([{ attempts: attempt, nextAttemptAt: h.clock.now + edgeFenceRetryDelayMs(attempt) }])
|
||||
// Not due yet: nothing is sent.
|
||||
h.clock.now += edgeFenceRetryDelayMs(attempt) - 1
|
||||
const calls = h.edge.calls.length
|
||||
await h.retry()
|
||||
expect(h.edge.calls).toHaveLength(calls)
|
||||
h.clock.now += 1
|
||||
}
|
||||
h.edge.answers = ['stale']
|
||||
expect(await h.retry()).toBe(false)
|
||||
expect(await h.pending()).toEqual([])
|
||||
const failures = logged(error, 'orca_relay_edge_fence_failed').filter((entry) => entry.retry === true)
|
||||
expect(failures).toHaveLength(EDGE_FENCE_MAX_ATTEMPTS)
|
||||
expect(failures[1]).toEqual({
|
||||
event: 'orca_relay_edge_fence_failed',
|
||||
outcome: 'relay_edge_admin_unavailable:network',
|
||||
cellId: 'us-c1',
|
||||
assignmentEpoch: 9,
|
||||
attempts: 2,
|
||||
retry: true
|
||||
})
|
||||
expect(logged(error, 'orca_relay_edge_fence_abandoned')).toEqual([
|
||||
{
|
||||
event: 'orca_relay_edge_fence_abandoned',
|
||||
outcome: 'stale',
|
||||
cellId: 'us-c1',
|
||||
assignmentEpoch: 9,
|
||||
attempts: EDGE_FENCE_MAX_ATTEMPTS
|
||||
}
|
||||
])
|
||||
expect(edgeFenceRetryDelayMs(1)).toBe(60_000)
|
||||
expect(edgeFenceRetryDelayMs(EDGE_FENCE_MAX_ATTEMPTS)).toBe(30 * 60_000)
|
||||
})
|
||||
|
||||
it('keeps retrying a fence through more than a day of edge outage', () => {
|
||||
// Recorded at 0, first retry one base delay later, then each attempt's backoff.
|
||||
let lastAttemptAt = EDGE_FENCE_RETRY_BASE_MS
|
||||
for (let attempt = 1; attempt < EDGE_FENCE_MAX_ATTEMPTS; attempt += 1) {
|
||||
lastAttemptAt += edgeFenceRetryDelayMs(attempt)
|
||||
}
|
||||
expect(lastAttemptAt).toBeGreaterThanOrEqual(24 * 60 * 60_000)
|
||||
// Never slower than the cap, so the edge is not left claiming hosts long after it is back.
|
||||
expect(edgeFenceRetryDelayMs(EDGE_FENCE_MAX_ATTEMPTS)).toBe(EDGE_FENCE_RETRY_MAX_MS)
|
||||
})
|
||||
|
||||
it(`retries up to ${EDGE_FENCE_RETRY_BATCH} due fences per pass, 10 in flight at once`, async () => {
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
@@ -303,120 +176,4 @@ describe('relay edge pending fence retries', () => {
|
||||
await Promise.all([h.retry(), h.retry()])
|
||||
expect(h.edge.calls).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('runs from the evacuation sweep, which keeps its busy cadence while fences are pending', async () => {
|
||||
vi.useFakeTimers()
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
await h.placeRow('us-c1', 9)
|
||||
const config = { ...edgeConfig(), rolloutPercent: 0 }
|
||||
const evacuation = new EdgeEvacuation(h.database, config, h.edge, EDGE_CELL_ID, () => h.clock.now, () => 0.5)
|
||||
h.edge.answers = ['stale']
|
||||
await h.assignments.fenceAway({ userId: USER, relayHostId: HOST }, 'us-c1', 9)
|
||||
h.edge.calls = []
|
||||
h.edge.answers = ['down']
|
||||
const sweep = vi.spyOn(evacuation, 'sweep')
|
||||
evacuation.start()
|
||||
h.clock.now += EDGE_EVACUATION_BUSY_INTERVAL_MS
|
||||
await vi.advanceTimersByTimeAsync(EDGE_EVACUATION_BUSY_INTERVAL_MS)
|
||||
expect(h.edge.calls).toHaveLength(1)
|
||||
// Still pending: the next pass comes after the busy interval, and lands.
|
||||
h.clock.now += EDGE_EVACUATION_BUSY_INTERVAL_MS
|
||||
await vi.advanceTimersByTimeAsync(EDGE_EVACUATION_BUSY_INTERVAL_MS)
|
||||
expect(sweep).toHaveBeenCalledTimes(2)
|
||||
expect(h.edge.calls).toHaveLength(2)
|
||||
expect(await h.pending()).toEqual([])
|
||||
evacuation.stop()
|
||||
})
|
||||
})
|
||||
|
||||
describe('relay edge pushes under the row lock', () => {
|
||||
// SQLite serializes transactions; run them inline so moves overlap as they do on Postgres.
|
||||
function overlapping(database: RelayDatabase): RelayDatabase {
|
||||
return new Proxy(database, {
|
||||
get(target, property) {
|
||||
if (property === 'transaction') {
|
||||
return async <T>(operation: (transaction: RelayDatabase) => Promise<T>) => await operation(target)
|
||||
}
|
||||
const value = Reflect.get(target, property, target) as unknown
|
||||
return typeof value === 'function' ? value.bind(target) : value
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
it(`defers a move once ${EDGE_LOCKED_CALLS_MAX} pushes are in flight, with a ${EDGE_ADMIN_LOCKED_TIMEOUT_MS} ms timeout`, async () => {
|
||||
const h = await harness()
|
||||
const assignments = new EdgeAssignments(overlapping(h.database), edgeConfig(), () => h.clock.now, h.edge)
|
||||
await assignments.ensureEdgeCell()
|
||||
h.edge.answers = Array.from({ length: EDGE_LOCKED_CALLS_MAX }, () => 'hang' as const)
|
||||
const hostIds = Array.from({ length: EDGE_LOCKED_CALLS_MAX + 1 }, (_, index) => `fencecap${String(index).padStart(8, '0')}`)
|
||||
for (const relayHostId of hostIds) { await h.placeRow('us-c1', 3, relayHostId) }
|
||||
const held = hostIds.slice(0, EDGE_LOCKED_CALLS_MAX).map((relayHostId) => assignments.moveToEdge({ userId: USER, relayHostId }, 0))
|
||||
await vi.waitFor(() => expect(h.edge.calls).toHaveLength(EDGE_LOCKED_CALLS_MAX))
|
||||
const last = { userId: USER, relayHostId: hostIds.at(-1)! }
|
||||
const deferred = await assignments.moveToEdge(last, 0).catch((error: unknown) => error)
|
||||
expect(deferred).toBeInstanceOf(EdgeMoveDeferredError)
|
||||
expect((deferred as Error).message).toBe('relay_edge_move_deferred:edge_busy')
|
||||
// Not waited for and not sent.
|
||||
expect(h.edge.calls).toHaveLength(EDGE_LOCKED_CALLS_MAX)
|
||||
h.edge.release()
|
||||
await Promise.all(held)
|
||||
for (const call of h.edge.calls) { expect(call.options).toEqual({ timeoutMs: EDGE_ADMIN_LOCKED_TIMEOUT_MS }) }
|
||||
// Slots are freed: the deferred host moves on its next ask.
|
||||
expect((await assignments.moveToEdge(last, 0)).cellId).toBe(EDGE_CELL_ID)
|
||||
})
|
||||
})
|
||||
|
||||
describe('edge admin tokens and timeouts', () => {
|
||||
it('signs every call with a fresh 128-bit jti', async () => {
|
||||
const tokens: string[] = []
|
||||
const admin = createEdgeAdmin({
|
||||
cellUrl: EDGE_URL,
|
||||
signingKey: SIGNING_KEY,
|
||||
issuer: 'https://relay.example.test',
|
||||
fetch: async (url, init) => {
|
||||
tokens.push(String((init!.headers as Record<string, string>).authorization).replace('Bearer ', ''))
|
||||
const op = String(url).split('/').at(-1)
|
||||
const body =
|
||||
op === 'assign'
|
||||
? { outcome: 'applied', assignmentEpoch: 1 }
|
||||
: op === 'export'
|
||||
? { outcome: 'exported', assignment: null, devices: [] }
|
||||
: { outcome: 'idle' }
|
||||
return new Response(JSON.stringify(body), { status: 200 })
|
||||
}
|
||||
})
|
||||
await admin.assign({ userId: USER, relayHostId: HOST, cellId: 'us-c1', assignmentEpoch: 1 })
|
||||
await admin.assign({ userId: USER, relayHostId: HOST, cellId: 'us-c1', assignmentEpoch: 1 })
|
||||
await admin.exportHost(HOST)
|
||||
await admin.drain(HOST)
|
||||
const ids = await Promise.all(
|
||||
tokens.map(async (token) => {
|
||||
const { payload } = await jwtVerify(token, SIGNING_KEY, { audience: EDGE_ADMIN_AUDIENCE })
|
||||
return String(payload.jti)
|
||||
})
|
||||
)
|
||||
for (const id of ids) {
|
||||
expect(id).toMatch(/^[A-Za-z0-9_-]{22}$/)
|
||||
expect(Buffer.from(id, 'base64url')).toHaveLength(16)
|
||||
}
|
||||
expect(new Set(ids).size).toBe(ids.length)
|
||||
})
|
||||
|
||||
it('times out pushes and exports at 2 s, other calls at 3 s', async () => {
|
||||
const timeout = vi.spyOn(AbortSignal, 'timeout')
|
||||
const admin = createEdgeAdmin({
|
||||
cellUrl: EDGE_URL,
|
||||
signingKey: SIGNING_KEY,
|
||||
issuer: 'https://relay.example.test',
|
||||
fetch: async () => new Response(JSON.stringify({ outcome: 'busy' }), { status: 409 })
|
||||
})
|
||||
const body = { userId: USER, relayHostId: HOST, cellId: 'us-c1', assignmentEpoch: 1 }
|
||||
await admin.assign(body, { timeoutMs: EDGE_ADMIN_LOCKED_TIMEOUT_MS }).catch(() => undefined)
|
||||
await admin.assign(body).catch(() => undefined)
|
||||
await admin.exportHost(HOST)
|
||||
await admin.drain(HOST).catch(() => undefined)
|
||||
expect(timeout.mock.calls.map(([ms]) => ms)).toEqual([2_000, 3_000, 2_000, 3_000])
|
||||
})
|
||||
})
|
||||
|
||||
@@ -83,22 +83,3 @@ it('moves an invite of a host on the relay edge to the edge, never asking the ce
|
||||
expect(resolve).not.toHaveBeenCalled()
|
||||
expect(assign).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('falls through to the cell paths for an invite of a host that is not on the edge', async () => {
|
||||
const { relay, port } = await director()
|
||||
const identity = { userId: 'user-1', relayHostId: HOST }
|
||||
vi.spyOn(relay.store, 'resolveInviteForMove').mockResolvedValue({ ...identity, relayDeviceId: 'device-1' })
|
||||
vi.spyOn(EdgeAssignments.prototype, 'edgeAssignment').mockResolvedValue(null)
|
||||
vi.spyOn(relay.assignments, 'resolve').mockResolvedValue({
|
||||
...identity,
|
||||
cellId: 'cell-1',
|
||||
cellUrl: 'https://cell-1.example.test',
|
||||
assignmentEpoch: 3,
|
||||
leaseExpiresAt: Date.now() + 60_000
|
||||
})
|
||||
const { messages, code } = await inviteMove(port)
|
||||
expect(messages).toEqual([
|
||||
{ type: 'relay-moved', v: 1, cellUrl: 'https://cell-1.example.test', assignmentEpoch: 3 }
|
||||
])
|
||||
expect(code).toBe(RELAY_CLOSE_CODE.DRAINING)
|
||||
})
|
||||
|
||||
@@ -191,20 +191,6 @@ async function keepFailing(h: { clock: { now: number }; assign: () => Promise<Re
|
||||
}
|
||||
|
||||
describe('relay edge phase 2: the director moves host data with the host', () => {
|
||||
it('pushes the host and its Postgres devices before answering with the edge, with a location hint', async () => {
|
||||
const h = await harness()
|
||||
await h.insertDevice(device('phone-a'))
|
||||
const response = await h.assign('asia-east2')
|
||||
expect(response.status).toBe(200)
|
||||
expect(await response.json()).toMatchObject({ cellUrl: EDGE_URL, assignmentEpoch: 1 })
|
||||
expect(h.fake.pushes).toHaveLength(1)
|
||||
expect(h.fake.pushes[0]).toMatchObject({ cellId: EDGE_CELL_ID, assignmentEpoch: 1, locationHint: 'apac' })
|
||||
expect(h.fake.devices.map((d) => d.relay_device_id)).toEqual(['phone-a'])
|
||||
expect(h.fake.devices[0]!.current_version).toBe(1)
|
||||
// A re-ask of a host already on the edge does not push again.
|
||||
await h.assign()
|
||||
expect(h.fake.pushes).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('keeps the host on today\'s path, with no edge row, when the edge cannot take the push', async () => {
|
||||
const h = await harness()
|
||||
@@ -215,46 +201,6 @@ describe('relay edge phase 2: the director moves host data with the host', () =>
|
||||
expect(await h.row()).toBeUndefined()
|
||||
})
|
||||
|
||||
it('re-mints above an epoch the edge already holds from a move that never committed', async () => {
|
||||
const h = await harness()
|
||||
h.fake.assignment = { userId: USER, cellId: 'us-c1', assignmentEpoch: 7 }
|
||||
const response = await h.assign()
|
||||
expect(await response.json()).toMatchObject({ cellUrl: EDGE_URL, assignmentEpoch: 8 })
|
||||
expect(await h.row()).toMatchObject({ cell_id: EDGE_CELL_ID })
|
||||
expect(Number((await h.row())!.assignment_epoch)).toBe(8)
|
||||
})
|
||||
|
||||
it('takes devices back before placing the host elsewhere, then fences the edge', async () => {
|
||||
const h = await harness()
|
||||
await h.insertDevice(device('phone-a'))
|
||||
await h.insertDevice(device('phone-b'))
|
||||
await h.assign()
|
||||
// On the edge: phone-a is revoked, phone-b removed, phone-c paired.
|
||||
h.fake.devices = [device('phone-a', { revoked_at: 1_800_000_000_000 }), device('phone-c')]
|
||||
h.leaveCohort()
|
||||
const response = await h.assign()
|
||||
expect(response.status).toBe(200)
|
||||
expect(await response.json()).toMatchObject({ cellUrl: 'https://us-c1.relay.example.test', assignmentEpoch: 9 })
|
||||
expect(h.fake.exports).toBe(1)
|
||||
expect(await h.postgresDevices()).toEqual([
|
||||
{ id: 'phone-a', revoked: 1_800_000_000_000 },
|
||||
{ id: 'phone-c', revoked: null }
|
||||
])
|
||||
expect(h.fake.pushes.at(-1)).toEqual({ userId: USER, relayHostId: HOST, cellId: 'us-c1', assignmentEpoch: 9 })
|
||||
expect(h.fake.assignment).toMatchObject({ cellId: 'us-c1', assignmentEpoch: 9 })
|
||||
})
|
||||
|
||||
it('tells the desktop to retry while it is still connected to the edge, placing nothing', async () => {
|
||||
const h = await harness()
|
||||
await h.assign()
|
||||
h.fake.connected = true
|
||||
h.leaveCohort()
|
||||
const response = await h.assign()
|
||||
expect(response.status).toBe(503)
|
||||
expect(response.headers.get('retry-after')).toBe('2')
|
||||
expect(h.assignments.assign).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('503s a leaving host while the edge export is unavailable, until it has failed for 120 s', async () => {
|
||||
const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
@@ -288,61 +234,6 @@ describe('relay edge phase 2: the director moves host data with the host', () =>
|
||||
})
|
||||
})
|
||||
|
||||
it('restarts the unavailable clock after any usable export answer', async () => {
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
await h.assign()
|
||||
h.leaveCohort()
|
||||
h.fake.down = true
|
||||
expect((await h.assign()).status).toBe(503)
|
||||
h.clock.now += 100_000
|
||||
// The edge answers (busy: the desktop is still connected): that is a success.
|
||||
h.fake.down = false
|
||||
h.fake.connected = true
|
||||
expect((await h.assign()).status).toBe(503)
|
||||
h.fake.down = true
|
||||
h.clock.now += 20_000
|
||||
expect((await h.assign()).status).toBe(503)
|
||||
await keepFailing(h, EDGE_EXPORT_SKIP_AFTER_MS - 1)
|
||||
expect((await h.assign()).status).toBe(503)
|
||||
h.clock.now += 1
|
||||
expect((await h.assign()).status).toBe(200)
|
||||
})
|
||||
|
||||
it('does not count failures further apart than 30 s as one outage', async () => {
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const h = await harness()
|
||||
await h.assign()
|
||||
h.leaveCohort()
|
||||
h.fake.down = true
|
||||
expect((await h.assign()).status).toBe(503)
|
||||
// One old failure, then quiet for longer than the skip threshold: the next failure starts over.
|
||||
h.clock.now += EDGE_EXPORT_SKIP_AFTER_MS + 1
|
||||
expect((await h.assign()).status).toBe(503)
|
||||
await keepFailing(h, EDGE_EXPORT_SKIP_AFTER_MS - 1)
|
||||
expect((await h.assign()).status).toBe(503)
|
||||
h.clock.now += 1
|
||||
expect((await h.assign()).status).toBe(200)
|
||||
})
|
||||
|
||||
it('skips the export on the first unavailable answer with a 0 ms threshold, and fences when the edge answers', async () => {
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
const h = await harness('host', { exportSkipAfterMs: 0 })
|
||||
await h.insertDevice(device('phone-a'))
|
||||
await h.assign()
|
||||
h.leaveCohort()
|
||||
let exportCalls = 0
|
||||
h.fake.exportHost = async () => {
|
||||
exportCalls += 1
|
||||
throw new EdgeAdminUnavailableError('status_503')
|
||||
}
|
||||
const response = await h.assign()
|
||||
expect(response.status).toBe(200)
|
||||
expect(exportCalls).toBe(1)
|
||||
expect(await h.postgresDevices()).toEqual([])
|
||||
expect(h.fake.assignment).toMatchObject({ cellId: 'us-c1', assignmentEpoch: 9 })
|
||||
})
|
||||
|
||||
it('keeps Postgres devices when the edge object holds no assignment (never pushed or erased)', async () => {
|
||||
const h = await harness()
|
||||
await h.insertDevice(device('phone-a'))
|
||||
@@ -365,36 +256,6 @@ describe('relay edge phase 2: the director moves host data with the host', () =>
|
||||
expect(await h.postgresDevices()).toEqual([{ id: 'phone-a', revoked: null }])
|
||||
})
|
||||
|
||||
it('moves every host of an allowed account (relay token sub), with no host list', async () => {
|
||||
const h = await harness('account')
|
||||
const response = await h.assign()
|
||||
expect(await response.json()).toMatchObject({ cellUrl: EDGE_URL })
|
||||
expect(h.fake.pushes[0]).toMatchObject({ userId: USER, relayHostId: HOST })
|
||||
})
|
||||
|
||||
it('with mode off or down, sends no new host to the edge', async () => {
|
||||
for (const mode of ['off', 'down'] as const) {
|
||||
const h = await harness('host', { control: () => ({ mode }) })
|
||||
expect(await (await h.assign()).json()).toMatchObject({ cellUrl: 'https://us-c1.relay.example.test' })
|
||||
expect(h.fake.pushes).toHaveLength(0)
|
||||
expect(await h.row()).toBeUndefined()
|
||||
}
|
||||
})
|
||||
|
||||
it('with mode off, moves hosts on the edge off normally: export, place, fence', async () => {
|
||||
const flags: EdgeControlFlags = { mode: 'on' }
|
||||
const h = await harness('host', { control: () => flags })
|
||||
await h.insertDevice(device('phone-a'))
|
||||
expect(await (await h.assign()).json()).toMatchObject({ cellUrl: EDGE_URL })
|
||||
h.fake.devices = [device('phone-a', { revoked_at: 1_800_000_000_000 })]
|
||||
flags.mode = 'off'
|
||||
expect(await (await h.assign()).json()).toMatchObject({ cellUrl: 'https://us-c1.relay.example.test' })
|
||||
// The edge's revoke carries over.
|
||||
expect(h.fake.exports).toBe(1)
|
||||
expect(await h.postgresDevices()).toEqual([{ id: 'phone-a', revoked: 1_800_000_000_000 }])
|
||||
expect(h.fake.assignment).toMatchObject({ cellId: 'us-c1', assignmentEpoch: 9 })
|
||||
})
|
||||
|
||||
it('with mode down, skips the export at once, removes the Postgres devices, and fences once', async () => {
|
||||
const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
@@ -422,12 +283,4 @@ describe('relay edge phase 2: the director moves host data with the host', () =>
|
||||
const pending = await h.database.query(`SELECT cell_id, assignment_epoch FROM relay_edge_fence_pending`)
|
||||
expect(pending.map((row) => [String(row.cell_id), Number(row.assignment_epoch)])).toEqual([['us-c1', 9]])
|
||||
})
|
||||
|
||||
it('does not touch the edge for hosts that were never on it', async () => {
|
||||
const h = await harness()
|
||||
h.leaveCohort()
|
||||
expect((await h.assign()).status).toBe(200)
|
||||
expect(h.fake.exports).toBe(0)
|
||||
expect(h.fake.pushes).toHaveLength(0)
|
||||
})
|
||||
})
|
||||
|
||||
@@ -11,7 +11,6 @@ import {
|
||||
} from './edge-relay.js'
|
||||
import type { EdgeAssignBody, EdgeDeviceRow } from './edge-admin-client.js'
|
||||
import { EDGE_FENCE_RETRY_BASE_MS, retryPendingFences } from './edge-relay-fence.js'
|
||||
import { EdgeEvacuation } from './edge-relay-evacuation.js'
|
||||
|
||||
const databaseUrl = process.env.ORCA_RELAY_TEST_POSTGRES_URL
|
||||
const describePostgres = databaseUrl ? describe : describe.skip
|
||||
@@ -237,38 +236,4 @@ describePostgres('relay edge on PostgreSQL', () => {
|
||||
expect(await database.query(`SELECT 1 FROM relay_edge_fence_pending WHERE user_id = ?`, [host.userId])).toEqual([])
|
||||
vi.restoreAllMocks()
|
||||
})
|
||||
|
||||
it('mode down: a leaving host loses its Postgres devices, and the sweep drains wrapping around its origin', async () => {
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
const flags = { mode: 'on' as 'on' | 'down' }
|
||||
const config = { ...edgeConfig, control: () => flags }
|
||||
const drained: string[] = []
|
||||
const admin = {
|
||||
assign: async (body: EdgeAssignBody) => ({ outcome: 'applied' as const, assignmentEpoch: body.assignmentEpoch }),
|
||||
exportHost: async (): Promise<never> => {
|
||||
throw new Error('unexpected export')
|
||||
},
|
||||
drain: async (relayHostId: string) => {
|
||||
drained.push(relayHostId)
|
||||
return { outcome: 'idle' as const }
|
||||
}
|
||||
}
|
||||
const edge = new EdgeAssignments(database, config, Date.now, admin)
|
||||
await edge.ensureEdgeCell()
|
||||
const downHosts = ['edgepgdown000001', 'edgepgdown000002'].map((relayHostId) => ({ userId: 'edge-pg-user', relayHostId }))
|
||||
for (const host of downHosts) { await edge.moveToEdge(host, 0) }
|
||||
await database.query(
|
||||
`INSERT INTO relay_devices (user_id, relay_host_id, relay_device_id, current_hash, current_version,
|
||||
current_expires_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
|
||||
['edge-pg-user', downHosts[0]!.relayHostId, 'phone-a', 'hash-phone-a', 2, 1_900_000_000_000, 1_800_000_000_000]
|
||||
)
|
||||
flags.mode = 'down'
|
||||
// Origin 'f3333333' sorts after 'edge-pg-user': the pass finds both hosts only once wrapped.
|
||||
const evacuation = new EdgeEvacuation(database, config, admin, EDGE_CELL_ID, Date.now, () => 0.95)
|
||||
await evacuation.sweep()
|
||||
expect(drained.filter((id) => id.startsWith('edgepgdown'))).toEqual(downHosts.map((host) => host.relayHostId))
|
||||
expect(await edge.leaveEdge(downHosts[0]!)).toBe(true)
|
||||
expect(await database.query(`SELECT 1 FROM relay_devices WHERE relay_host_id = ?`, [downHosts[0]!.relayHostId])).toEqual([])
|
||||
})
|
||||
})
|
||||
|
||||
@@ -1,28 +1,14 @@
|
||||
import { createHash } from 'node:crypto'
|
||||
import { RELAY_CLOSE_CODE } from '@orca-cloud/relay-contract'
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest'
|
||||
import type WebSocket from 'ws'
|
||||
import { afterEach, describe, expect, it } from 'vitest'
|
||||
import { RelayAssignmentStore } from './assignment/assignment-store.js'
|
||||
import {
|
||||
RelayCellAdmissionSelector,
|
||||
encodeMembership,
|
||||
type CellAdmissionMembership
|
||||
} from './cell/admission/cell-admission-selector.js'
|
||||
import type { RelayCellConfig, RelayConfig } from './config.js'
|
||||
import type { CredentialReservation, RelayCredentialStore } from './credentials/credential-store.js'
|
||||
import type { RelayCellConfig } from './config.js'
|
||||
import { openInMemoryRelayDatabase, type RelayDatabase } from './database/database.js'
|
||||
import {
|
||||
EDGE_CELL_ID,
|
||||
EdgeAssignments,
|
||||
EdgeMoveBusyError, EdgeMoveDeferredError,
|
||||
edgeCohortBucket,
|
||||
inEdgeCohort,
|
||||
mapEpochFloor,
|
||||
type EdgeRelayConfig
|
||||
} from './edge-relay.js'
|
||||
import { HostSessionRegistry } from './connections/host-session-registry.js'
|
||||
import type { RelayRuntimeObserver } from './observability/relay-observability.js'
|
||||
import { ProcessQueuedByteBudget } from './connections/splice-forwarder.js'
|
||||
import { EDGE_CELL_ID, EdgeAssignments, EdgeMoveDeferredError, type EdgeRelayConfig } from './edge-relay.js'
|
||||
|
||||
const EDGE_URL = 'https://edge.relay.example.com'
|
||||
const GCE_CELL: RelayCellConfig = { id: 'production-gce-c3', url: 'https://c3.relay.example.com', capacityRequests: 1_000 }
|
||||
@@ -81,50 +67,6 @@ function fingerprint(membership: CellAdmissionMembership): string {
|
||||
return createHash('sha256').update(encodeMembership(membership)).digest('hex')
|
||||
}
|
||||
|
||||
describe('edge cohort', () => {
|
||||
it('lets deny beat allow, host allow beat region and share, and scopes accounts and the share by region', () => {
|
||||
const host = 'abcdefghijklmnop'
|
||||
expect(inEdgeCohort(edgeConfig({ rolloutPercent: 100 }), host, 'us-central1')).toBe(true)
|
||||
expect(inEdgeCohort(edgeConfig({ rolloutPercent: 100 }), host, undefined)).toBe(true)
|
||||
expect(inEdgeCohort(edgeConfig({ rolloutPercent: 100 }), host, 'asia-east2')).toBe(false)
|
||||
expect(
|
||||
inEdgeCohort(edgeConfig({ rolloutPercent: 100, regions: new Set(['us-central1', 'asia-east2']) }), host, 'asia-east2')
|
||||
).toBe(true)
|
||||
expect(inEdgeCohort(edgeConfig({ rolloutPercent: 0 }), host, 'us-central1')).toBe(false)
|
||||
// An allowed account brings every host it has in the cohort's regions; deny still wins.
|
||||
const team = edgeConfig({ allowUsers: new Set(['user-team']), regions: new Set(['us-central1']) })
|
||||
expect(inEdgeCohort(team, host, 'us-central1', 'user-team')).toBe(true)
|
||||
expect(inEdgeCohort(team, host, undefined, 'user-team')).toBe(true)
|
||||
expect(inEdgeCohort(team, host, 'asia-east2', 'user-team')).toBe(false)
|
||||
expect(inEdgeCohort({ ...team, regions: new Set() }, host, 'us-central1', 'user-team')).toBe(false)
|
||||
expect(inEdgeCohort(team, host, 'us-central1', 'user-other')).toBe(false)
|
||||
expect(inEdgeCohort(team, host, 'us-central1')).toBe(false)
|
||||
expect(inEdgeCohort({ ...team, denyHosts: new Set([host]) }, host, 'us-central1', 'user-team')).toBe(false)
|
||||
expect(inEdgeCohort(edgeConfig({ allowHosts: new Set([host]), regions: new Set() }), host, 'asia-east2')).toBe(true)
|
||||
expect(
|
||||
inEdgeCohort(edgeConfig({ rolloutPercent: 100, allowHosts: new Set([host]), denyHosts: new Set([host]) }), host, 'us-central1')
|
||||
).toBe(false)
|
||||
})
|
||||
|
||||
it('buckets hosts stably and roughly evenly', () => {
|
||||
expect(edgeCohortBucket('abcdefghijklmnop')).toBe(edgeCohortBucket('abcdefghijklmnop'))
|
||||
const hosts = Array.from({ length: 2_000 }, (_, index) => `host${String(index).padStart(12, '0')}`)
|
||||
const inTenPercent = hosts.filter((host) => edgeCohortBucket(host) < 10).length
|
||||
expect(inTenPercent).toBeGreaterThan(140)
|
||||
expect(inTenPercent).toBeLessThan(260)
|
||||
})
|
||||
|
||||
it('floors the edge epoch above every epoch the seat map knows', () => {
|
||||
const source = {
|
||||
seatsOf: () => [{ epoch: 4 }],
|
||||
recentlyLeftOf: () => [{ epoch: 9 }],
|
||||
bookingOf: () => ({ epoch: 6 })
|
||||
}
|
||||
expect(mapEpochFloor(source, IDENTITY, 0)).toBe(9)
|
||||
expect(mapEpochFloor(undefined, IDENTITY, 0)).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
describe('edge cell seed', () => {
|
||||
it('registers a disabled, empty, existing-only cell the admission selector carries without drift', async () => {
|
||||
const { database, store, edge, clock } = await setup({ requireLiveCells: true })
|
||||
@@ -170,24 +112,9 @@ describe('edge cell seed', () => {
|
||||
general: [GCE_CELL.id]
|
||||
})
|
||||
})
|
||||
|
||||
it('answers nothing before the seed lands', async () => {
|
||||
const { edge } = await setup({ requireLiveCells: true })
|
||||
expect(await edge.edgeAssignment(IDENTITY)).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('edge move', () => {
|
||||
it('mints map floor + 1 for a host with no row and keeps the epoch on re-asks', async () => {
|
||||
const { edge, setNow } = await setup({ requireLiveCells: true })
|
||||
await edge.ensureEdgeCell()
|
||||
const first = await edge.moveToEdge(IDENTITY, 7)
|
||||
expect(first).toMatchObject({ cellId: EDGE_CELL_ID, cellUrl: EDGE_URL, assignmentEpoch: 8 })
|
||||
setNow(5_000)
|
||||
const again = await edge.moveToEdge(IDENTITY, 20)
|
||||
expect(again.assignmentEpoch).toBe(8)
|
||||
expect(again.leaseExpiresAt).toBeGreaterThan(first.leaseExpiresAt)
|
||||
})
|
||||
|
||||
it('moves a host off a GCE cell with a strictly newer epoch than both the row and the map', async () => {
|
||||
const { database, store, edge } = await setup({ requireLiveCells: true })
|
||||
@@ -202,30 +129,6 @@ describe('edge move', () => {
|
||||
expect(moved.assignmentEpoch).toBe(placed.assignmentEpoch + 4)
|
||||
})
|
||||
|
||||
it('defers the move while the host still holds units on its old cell', async () => {
|
||||
const { database, store, edge } = await setup({ requireLiveCells: true })
|
||||
await edge.ensureEdgeCell()
|
||||
await store.assign(IDENTITY)
|
||||
await database.query(
|
||||
`UPDATE relay_assignments SET reserved_splices = 1 WHERE user_id = ? AND relay_host_id = ?`,
|
||||
[IDENTITY.userId, IDENTITY.relayHostId]
|
||||
)
|
||||
await expect(edge.moveToEdge(IDENTITY, 0)).rejects.toBeInstanceOf(EdgeMoveDeferredError)
|
||||
const [row] = await database.query(`SELECT cell_id FROM relay_assignments WHERE user_id = ?`, [IDENTITY.userId])
|
||||
expect(row).toMatchObject({ cell_id: GCE_CELL.id })
|
||||
})
|
||||
|
||||
it('is invisible to the director liveness rule, so phone paths must ask the edge first', async () => {
|
||||
const { store, edge } = await setup({ requireLiveCells: true })
|
||||
await edge.ensureEdgeCell()
|
||||
const moved = await edge.moveToEdge(IDENTITY, 0)
|
||||
expect(await store.resolve(IDENTITY)).toBeNull()
|
||||
expect(await edge.edgeAssignment(IDENTITY)).toMatchObject({
|
||||
cellUrl: EDGE_URL,
|
||||
assignmentEpoch: moved.assignmentEpoch
|
||||
})
|
||||
})
|
||||
|
||||
it('rolls back: with the cohort off, the host is re-placed on GCE above the edge epoch', async () => {
|
||||
const { database, store, edge } = await setup({ requireLiveCells: true })
|
||||
await edge.ensureEdgeCell()
|
||||
@@ -238,120 +141,3 @@ describe('edge move', () => {
|
||||
expect(await edge.edgeAssignment(IDENTITY)).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('old cells and phones of a host moved to the edge', () => {
|
||||
const config = {
|
||||
port: 8080,
|
||||
publicUrl: GCE_CELL.url,
|
||||
cellUrl: GCE_CELL.url,
|
||||
authIssuer: 'https://auth.example.com',
|
||||
authAudience: 'orca-relay',
|
||||
jwksUrl: 'https://auth.example.com/jwks',
|
||||
assignmentSigningKey: new Uint8Array(32),
|
||||
role: 'cell',
|
||||
cellId: GCE_CELL.id,
|
||||
cells: [GCE_CELL],
|
||||
adminAudience: `${GCE_CELL.url}/v1/admin/drain`,
|
||||
deployServiceAccount: 'deploy@example.com',
|
||||
runtimeServiceAccount: 'runtime@example.com',
|
||||
adminJwksUrl: 'https://auth.example.com/admin-jwks',
|
||||
databasePoolMax: 10,
|
||||
publicAssignmentsEnabled: true,
|
||||
publicAssignmentConcurrency: 2,
|
||||
publicAssignmentQueueMax: 128,
|
||||
publicAssignmentWaitMs: 4_000,
|
||||
publicResolveConcurrency: 1,
|
||||
publicResolveWaitMs: 5_000,
|
||||
publicAssignmentRetryAfterSeconds: 5,
|
||||
dataDir: './test-data'
|
||||
} satisfies RelayConfig
|
||||
|
||||
class FakeSocket {
|
||||
readonly OPEN = 1
|
||||
readyState = 1
|
||||
readonly send = vi.fn()
|
||||
readonly close = vi.fn((_code?: number, _reason?: string) => {
|
||||
this.readyState = 3
|
||||
})
|
||||
readonly terminate = vi.fn()
|
||||
readonly once = vi.fn()
|
||||
readonly on = vi.fn()
|
||||
readonly off = vi.fn()
|
||||
}
|
||||
|
||||
const observer = {
|
||||
recordAuth: vi.fn(),
|
||||
recordForwardedBytes: vi.fn(),
|
||||
recordHttp: vi.fn(),
|
||||
recordReconnect: vi.fn(),
|
||||
recordSql: vi.fn(),
|
||||
recordClientAcceptAbandoned: vi.fn(),
|
||||
recordClientAcceptCompleted: vi.fn(),
|
||||
recordControlRtt: vi.fn(),
|
||||
recordPhoneRejection: vi.fn(),
|
||||
recordPhoneAttachDeadline: vi.fn()
|
||||
} satisfies RelayRuntimeObserver
|
||||
|
||||
async function cellRegistry(seed: boolean) {
|
||||
// The director moved the host; the cell reads the same database without the liveness rule.
|
||||
const director = await setup({ requireLiveCells: true })
|
||||
if (seed) { await director.edge.ensureEdgeCell() }
|
||||
await director.store.assign(IDENTITY)
|
||||
await settle(director.database)
|
||||
await (seed
|
||||
? director.edge.moveToEdge(IDENTITY, 0)
|
||||
: director.database.query(`UPDATE relay_assignments SET cell_id = ? WHERE user_id = ?`, [
|
||||
EDGE_CELL_ID,
|
||||
IDENTITY.userId
|
||||
]))
|
||||
const cellStore = new RelayAssignmentStore(director.database, director.clock, { requireLiveCells: false })
|
||||
const credentials = {
|
||||
resolveResume: vi.fn().mockResolvedValue({ userId: IDENTITY.userId }),
|
||||
resolveInviteForMove: vi.fn().mockResolvedValue(null),
|
||||
reserveCredential: vi.fn()
|
||||
}
|
||||
const registry = new HostSessionRegistry(
|
||||
config,
|
||||
vi.fn(),
|
||||
credentials as unknown as RelayCredentialStore,
|
||||
cellStore,
|
||||
new ProcessQueuedByteBudget(),
|
||||
observer,
|
||||
director.clock
|
||||
)
|
||||
return { registry, cellStore, credentials }
|
||||
}
|
||||
|
||||
it('database credential path: a phone of the moved host gets WRONG_CELL and re-resolves', async () => {
|
||||
const { registry, credentials } = await cellRegistry(true)
|
||||
const phone = new FakeSocket()
|
||||
await registry.acceptClient(phone as unknown as WebSocket, IDENTITY.relayHostId, 'resume-token', undefined)
|
||||
expect(phone.close).toHaveBeenCalledWith(RELAY_CLOSE_CODE.WRONG_CELL, expect.any(String))
|
||||
expect(credentials.reserveCredential).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('memory path: a missed seat whose row names the edge is WRONG_CELL, not HOST_OFFLINE', async () => {
|
||||
const { registry } = await cellRegistry(true)
|
||||
const phone = new FakeSocket()
|
||||
const reservation = { userId: IDENTITY.userId, relayHostId: IDENTITY.relayHostId } as CredentialReservation
|
||||
await (
|
||||
registry as unknown as {
|
||||
rejectMissedSeat: (socket: WebSocket, reservation: CredentialReservation, sessionKey: string) => Promise<void>
|
||||
}
|
||||
).rejectMissedSeat(phone as unknown as WebSocket, reservation, `${IDENTITY.userId}\u0000${IDENTITY.relayHostId}`)
|
||||
expect(phone.close).toHaveBeenCalledWith(RELAY_CLOSE_CODE.WRONG_CELL, expect.any(String))
|
||||
})
|
||||
|
||||
it('without the seeded edge cell row the memory path would pin phones with HOST_OFFLINE', async () => {
|
||||
const { registry, cellStore } = await cellRegistry(false)
|
||||
expect(await cellStore.resolve(IDENTITY)).toBeNull()
|
||||
const phone = new FakeSocket()
|
||||
const reservation = { userId: IDENTITY.userId, relayHostId: IDENTITY.relayHostId } as CredentialReservation
|
||||
await (
|
||||
registry as unknown as {
|
||||
rejectMissedSeat: (socket: WebSocket, reservation: CredentialReservation, sessionKey: string) => Promise<void>
|
||||
}
|
||||
).rejectMissedSeat(phone as unknown as WebSocket, reservation, `${IDENTITY.userId}\u0000${IDENTITY.relayHostId}`)
|
||||
expect(phone.close).toHaveBeenCalledWith(RELAY_CLOSE_CODE.HOST_OFFLINE, expect.anything())
|
||||
})
|
||||
})
|
||||
|
||||
@@ -18,7 +18,6 @@
|
||||
1 test-no-in-test-import-actual:src/main/omp/omp-session-cwd-lookup.test.ts
|
||||
1 test-no-in-test-import-actual:src/main/orcad/electron-serve-provider-selection.test.ts
|
||||
1 test-no-in-test-import-actual:src/main/pty/scrollback/overlay-mirror.test.ts
|
||||
1 test-no-in-test-import-actual:src/main/runtime/files/orca-runtime-files-mobile-explorer-reads.test.ts
|
||||
1 test-no-in-test-import-actual:src/main/runtime/terminal/artifacts/orca-runtime-files-terminal-artifact-swap-detection.test.ts
|
||||
1 test-no-in-test-import-actual:src/main/runtime/rpc/server/pairing/mobile-pairing-userdata-path.test.ts
|
||||
1 test-no-in-test-import-actual:src/main/speech/openai-api-key-store.test.ts
|
||||
@@ -251,7 +250,6 @@
|
||||
5 test-no-real-time-wait:src/main/pty/process-retirement/windows-live-tree-kill.win32.test.ts
|
||||
1 test-no-real-time-wait:src/main/runtime/agent-session/structured-agent-session-legacy-send-behind-command.test.ts
|
||||
1 test-no-real-time-wait:src/main/runtime/terminal/recovery/layout-command-pane-starts-layout-owner.test.ts
|
||||
1 test-no-real-time-wait:src/main/runtime/files/orca-runtime-files-mobile-explorer-reads.test.ts
|
||||
3 test-no-real-time-wait:src/main/runtime/orchestration/mailbox/terminal-pointer/orchestration-codex-real-pty.integration.test.ts
|
||||
1 test-no-real-time-wait:src/main/runtime/workspaces/removal/owned-session-teardown-policy.test.ts
|
||||
1 test-no-real-time-wait:src/main/runtime/rpc/server/remote-runtime-request-connection.integration.test.ts
|
||||
@@ -613,7 +611,6 @@
|
||||
2 test-no-wall-clock:src/main/runtime/agent-session/structured-agent-session-held-signal.test.ts
|
||||
1 test-no-wall-clock:src/main/runtime/mobile-cloud-relay/mobile-relay-e2ee.integration.test.ts
|
||||
1 test-no-wall-clock:src/main/runtime/mobile-cloud-relay/relay-http-client.test.ts
|
||||
1 test-no-wall-clock:src/main/persistence/mobile-store-orphaned-temp-cleanup.test.ts
|
||||
1 test-no-wall-clock:src/main/runtime/terminal/layout/mobile-subscribe-idle-pane-hydrate.test.ts
|
||||
1 test-no-wall-clock:src/main/runtime/session-construction/agent-session/orca-runtime-agent-session-operation.test.ts
|
||||
3 test-no-wall-clock:src/main/runtime/terminal/query/orca-runtime-codex-idle-title-chat-address.test.ts
|
||||
|
||||
@@ -3883,6 +3883,7 @@
|
||||
"Extend the oracle to mobile observers and to a client with two windows open on one connection."
|
||||
],
|
||||
"knownGaps": [
|
||||
"Audit2141: Remove only the in-memory fake-store restart callback from src/main/runtime/client/navigation/multi-client-navigation-isolation.integration.test.ts. Its copied persistence-object alarm is intentionally lost without replacement. All eight actual paired-WebSocket callbacks and five active assertion aliases remain byte-identical. Existing Electron receipt is unchanged and validates only its original source/journey; no fresh validation of the reduced integration selector, disk persistence, live remote/mobile, or cross-platform result is claimed.",
|
||||
"No live Windows or Linux server run yet; the reported field topology was a Windows 11 server.",
|
||||
"Mobile observers are covered only by the platform-neutral clientKind contract, not by a live phone journey.",
|
||||
"Host-originated CLI creates deliberately still reveal on every client; that broader authority question is untouched by this gate.",
|
||||
|
||||
@@ -3425,7 +3425,6 @@
|
||||
"src/main/runtime/session-lifecycle/publication/mobile-session-tabs-agent-status-heartbeat.test.ts": 65,
|
||||
"src/main/runtime/terminal/surface/mobile-session-terminal-persistence-retirement.test.ts": 278,
|
||||
"src/main/runtime/session-tabs/mobile-session-window-tab-order.test.ts": 4194,
|
||||
"src/main/persistence/mobile-store-orphaned-temp-cleanup.test.ts": 320,
|
||||
"src/main/runtime/terminal/layout/mobile-subscribe-idle-pane-hydrate.test.ts": 4782,
|
||||
"src/main/runtime/client/navigation/multi-client-navigation-isolation.integration.test.ts": 5640,
|
||||
"src/main/runtime/terminal/wait/omp-readiness-transcripts.test.ts": 7901,
|
||||
@@ -3445,8 +3444,6 @@
|
||||
"src/main/runtime/terminal/wait/orca-runtime-exact-worker-provider-session.test.ts": 3617,
|
||||
"src/main/runtime/terminal/lifecycle/orca-runtime-exited-split-pane-close.test.ts": 4235,
|
||||
"src/main/runtime/terminal/surface/orca-runtime-failed-start-pane-layout-owner.test.ts": 4204,
|
||||
"src/main/runtime/files/orca-runtime-files-chunk-reads.test.ts": 583,
|
||||
"src/main/runtime/files/orca-runtime-files-mobile-explorer-reads.test.ts": 624,
|
||||
"src/main/runtime/files/orca-runtime-files-preview-budget.test.ts": 672,
|
||||
"src/main/runtime/files/search/orca-runtime-files-search.test.ts": 675,
|
||||
"src/main/runtime/terminal/artifacts/orca-runtime-files-terminal-artifact-grants.test.ts": 580,
|
||||
@@ -3464,7 +3461,6 @@
|
||||
"src/main/runtime/files/paths/orca-runtime-read-kitty-file.test.ts": 4304,
|
||||
"src/main/runtime/browser/headless/orca-runtime-serve-browser-restore.test.ts": 4469,
|
||||
"src/main/runtime/session-tabs/orca-runtime-session-tabs-path-alias.test.ts": 4827,
|
||||
"src/main/runtime/construction/orca-runtime-structured-status-sink-wiring.test.ts": 4286,
|
||||
"src/main/runtime/terminal/surface/orca-runtime-terminal-close-continuity.test.ts": 4439,
|
||||
"src/main/runtime/terminal/surface/orca-runtime-terminal-close-no-widening-layout-owner.test.ts": 4997,
|
||||
"src/main/runtime/terminal/surface/orca-runtime-terminal-close-no-widening.test.ts": 4509,
|
||||
|
||||
@@ -1,92 +0,0 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import type { SshConnectionState } from '../../../src/shared/ssh-types'
|
||||
import { FILE_MUTATION_OWNERSHIP_RUNTIME_CAPABILITY } from '../../../src/shared/file-access/files-runtime-capabilities'
|
||||
import type { RpcClient } from '../transport/rpc-client'
|
||||
import type { RpcResponse } from '../transport/types'
|
||||
import {
|
||||
buildMobileFileMutationOwnership,
|
||||
captureMobileFileMutationOwnership
|
||||
} from './mobile-file-mutation-ownership'
|
||||
|
||||
function success(result: unknown): RpcResponse {
|
||||
return { id: 'rpc-1', ok: true, result, _meta: { runtimeId: 'runtime-1' } }
|
||||
}
|
||||
|
||||
function clientWithResponses(responses: RpcResponse[]): {
|
||||
client: Pick<RpcClient, 'sendRequest'>
|
||||
sendRequest: ReturnType<typeof vi.fn>
|
||||
} {
|
||||
const sendRequest = vi.fn(async () => {
|
||||
const response = responses.shift()
|
||||
if (!response) {
|
||||
throw new Error('Unexpected RPC request')
|
||||
}
|
||||
return response
|
||||
})
|
||||
return { client: { sendRequest }, sendRequest }
|
||||
}
|
||||
|
||||
function sshState(targetId: string, connectionGeneration: number | undefined): SshConnectionState {
|
||||
return {
|
||||
targetId,
|
||||
status: 'connected',
|
||||
error: null,
|
||||
reconnectAttempt: 0,
|
||||
connectionGeneration
|
||||
}
|
||||
}
|
||||
|
||||
describe('mobile file mutation ownership', () => {
|
||||
it.each([undefined, 'local', 'runtime:environment-1'])(
|
||||
'binds %s worktrees to the runtime-local file host',
|
||||
(hostId) => {
|
||||
expect(buildMobileFileMutationOwnership(hostId)).toEqual({
|
||||
expectedExecutionHostId: 'local'
|
||||
})
|
||||
}
|
||||
)
|
||||
|
||||
it('binds SSH worktrees to the target and live connection generation', () => {
|
||||
expect(
|
||||
buildMobileFileMutationOwnership('ssh:target%20one', sshState('target one', 17))
|
||||
).toEqual({
|
||||
expectedExecutionHostId: 'ssh:target%20one',
|
||||
expectedSshTargetId: 'target one',
|
||||
expectedSshConnectionGeneration: 17
|
||||
})
|
||||
})
|
||||
|
||||
it.each([
|
||||
['a malformed owner', 'not-an-execution-host', null],
|
||||
['a missing SSH state', 'ssh:target-1', null],
|
||||
['a mismatched SSH target', 'ssh:target-1', sshState('target-2', 4)],
|
||||
['a missing SSH generation', 'ssh:target-1', sshState('target-1', undefined)]
|
||||
])('rejects %s', (_name, hostId, state) => {
|
||||
expect(() => buildMobileFileMutationOwnership(hostId, state)).toThrow(
|
||||
"Couldn't verify the SSH connection"
|
||||
)
|
||||
})
|
||||
|
||||
// Absent hostId captures local; explicit null refuses an unplaceable host instead of sending its write locally.
|
||||
it('captures local ownership for a workspace whose reply records no host', async () => {
|
||||
const { client } = clientWithResponses([
|
||||
success({ capabilities: [FILE_MUTATION_OWNERSHIP_RUNTIME_CAPABILITY] }),
|
||||
success({ worktree: {} })
|
||||
])
|
||||
|
||||
await expect(captureMobileFileMutationOwnership(client, 'id:worktree-1')).resolves.toEqual({
|
||||
expectedExecutionHostId: 'local'
|
||||
})
|
||||
})
|
||||
|
||||
it('refuses a workspace whose reply names an explicit null host', async () => {
|
||||
const { client } = clientWithResponses([
|
||||
success({ capabilities: [FILE_MUTATION_OWNERSHIP_RUNTIME_CAPABILITY] }),
|
||||
success({ worktree: { hostId: null } })
|
||||
])
|
||||
|
||||
await expect(captureMobileFileMutationOwnership(client, 'id:worktree-1')).rejects.toThrow(
|
||||
"Couldn't verify the SSH connection"
|
||||
)
|
||||
})
|
||||
})
|
||||
@@ -1,131 +0,0 @@
|
||||
import { createElement } from 'react'
|
||||
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
const appState = vi.hoisted(() => ({
|
||||
current: 'active',
|
||||
listener: null as ((nextState: string) => void) | null,
|
||||
remove: vi.fn()
|
||||
}))
|
||||
|
||||
vi.mock('react-native', () => ({
|
||||
AppState: {
|
||||
get currentState(): string {
|
||||
return appState.current
|
||||
},
|
||||
addEventListener: (_event: string, listener: (nextState: string) => void) => {
|
||||
appState.listener = listener
|
||||
return { remove: appState.remove }
|
||||
}
|
||||
}
|
||||
}))
|
||||
|
||||
import { useNow, useSharedNow } from './use-now'
|
||||
|
||||
describe('useSharedNow', () => {
|
||||
let renderer: ReactTestRenderer | null = null
|
||||
let latest = 0
|
||||
|
||||
function Harness(): null {
|
||||
latest = useSharedNow(1_000)
|
||||
return null
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
act(() => renderer?.unmount())
|
||||
renderer = null
|
||||
vi.useRealTimers()
|
||||
})
|
||||
|
||||
it('shows the current time when remounted soon after the last reader unmounted', () => {
|
||||
vi.useFakeTimers()
|
||||
vi.setSystemTime(1_000)
|
||||
appState.current = 'active'
|
||||
act(() => {
|
||||
renderer = create(createElement(Harness))
|
||||
})
|
||||
act(() => renderer?.unmount())
|
||||
|
||||
vi.setSystemTime(1_500)
|
||||
act(() => {
|
||||
renderer = create(createElement(Harness))
|
||||
})
|
||||
expect(latest).toBe(1_500)
|
||||
})
|
||||
})
|
||||
|
||||
describe('useNow', () => {
|
||||
let renderer: ReactTestRenderer | null = null
|
||||
let latest = 0
|
||||
|
||||
function Harness({ enabled = true }: { enabled?: boolean }): null {
|
||||
latest = useNow(1_000, enabled)
|
||||
return null
|
||||
}
|
||||
|
||||
function changeAppState(nextState: string): void {
|
||||
act(() => {
|
||||
appState.current = nextState
|
||||
appState.listener?.(nextState)
|
||||
})
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
vi.useFakeTimers()
|
||||
vi.setSystemTime(1_000)
|
||||
appState.current = 'active'
|
||||
appState.listener = null
|
||||
appState.remove.mockClear()
|
||||
latest = 0
|
||||
act(() => {
|
||||
renderer = create(createElement(Harness))
|
||||
})
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
act(() => renderer?.unmount())
|
||||
renderer = null
|
||||
vi.useRealTimers()
|
||||
})
|
||||
|
||||
it('ticks while active, pauses in the background, and refreshes immediately on resume', () => {
|
||||
expect(latest).toBe(1_000)
|
||||
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(1_000)
|
||||
})
|
||||
expect(latest).toBe(2_000)
|
||||
|
||||
changeAppState('background')
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(5_000)
|
||||
})
|
||||
expect(latest).toBe(2_000)
|
||||
|
||||
changeAppState('active')
|
||||
expect(latest).toBe(7_000)
|
||||
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(1_000)
|
||||
})
|
||||
expect(latest).toBe(8_000)
|
||||
})
|
||||
|
||||
it('stops while disabled and refreshes immediately when re-enabled', () => {
|
||||
act(() => renderer?.update(createElement(Harness, { enabled: false })))
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(5_000)
|
||||
})
|
||||
expect(latest).toBe(1_000)
|
||||
|
||||
act(() => renderer?.update(createElement(Harness, { enabled: true })))
|
||||
expect(latest).toBe(6_000)
|
||||
})
|
||||
|
||||
it('removes the shared AppState listener after the last caller unmounts', () => {
|
||||
act(() => renderer?.unmount())
|
||||
renderer = null
|
||||
|
||||
expect(appState.remove).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
})
|
||||
@@ -40,37 +40,6 @@ function shellArgs(overrides: Partial<Args>): Args {
|
||||
}
|
||||
}
|
||||
|
||||
it('pushes a session natively when the page the shell activates is older than open targets', async () => {
|
||||
const openNatively = vi.fn()
|
||||
const cleared = vi.fn()
|
||||
await show(
|
||||
shellArgs({
|
||||
route: { ...HOST, params: { open: SESSION } },
|
||||
pageVersion: 2,
|
||||
openNatively,
|
||||
onRouteParamClear: cleared
|
||||
})
|
||||
)
|
||||
|
||||
expect(rendered.view?.pageRoute).toEqual({ pathname: '/h/host-1', params: {} })
|
||||
expect(cleared.mock.calls).toEqual([['open', SESSION]])
|
||||
expect(openNatively.mock.calls).toEqual([[SESSION]])
|
||||
})
|
||||
|
||||
it('drops that push when another screen opened on top while the page downloaded', async () => {
|
||||
const openNatively = vi.fn()
|
||||
await show(
|
||||
shellArgs({
|
||||
route: { ...HOST, params: { open: SESSION } },
|
||||
pageVersion: 2,
|
||||
isFocused: () => false,
|
||||
openNatively
|
||||
})
|
||||
)
|
||||
|
||||
expect(openNatively).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('reopens the session a lost document showed in the document that replaces it', async () => {
|
||||
await show(shellArgs({}))
|
||||
await act(async () => rendered.view?.recordLocation(SESSION))
|
||||
|
||||
@@ -1,65 +0,0 @@
|
||||
import { createElement } from 'react'
|
||||
import { act, create } from 'react-test-renderer'
|
||||
import { expect, it, vi } from 'vitest'
|
||||
import type { HostStackNavigationState } from './host-stack-navigation'
|
||||
|
||||
const HOST_ROUTE: HostStackNavigationState = {
|
||||
index: 0,
|
||||
routes: [{ name: 'h' }]
|
||||
}
|
||||
// The same host route as the root container sees it, with the host list's stack already mounted.
|
||||
const MOUNTED_HOST_ROUTE: HostStackNavigationState = {
|
||||
index: 0,
|
||||
routes: [
|
||||
{
|
||||
name: 'h',
|
||||
state: {
|
||||
key: '/h',
|
||||
index: 0,
|
||||
routes: [{ key: 'host-index', name: '[hostId]/index', params: { hostId: 'host-1' } }]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
const nav = vi.hoisted(() => ({ push: vi.fn(), dispatch: vi.fn() }))
|
||||
vi.mock('expo-router', () => ({
|
||||
useRouter: () => ({ push: nav.push, replace: vi.fn() }),
|
||||
// A screen's navigator keeps its last snapshot of a child stack until that stack next changes.
|
||||
useNavigation: () => ({
|
||||
addListener: () => () => {},
|
||||
dispatch: nav.dispatch,
|
||||
getState: () => HOST_ROUTE
|
||||
}),
|
||||
useNavigationContainerRef: () => ({ isReady: () => true, getRootState: () => MOUNTED_HOST_ROUTE })
|
||||
}))
|
||||
|
||||
import { useOpenHostStackRoute } from './use-open-host-stack-route'
|
||||
|
||||
it('hands a session to the host list that just mounted instead of pushing a second document', async () => {
|
||||
const opener: { open?: ReturnType<typeof useOpenHostStackRoute> } = {}
|
||||
function Opener() {
|
||||
opener.open = useOpenHostStackRoute(true)
|
||||
return null
|
||||
}
|
||||
await act(async () => {
|
||||
create(createElement(Opener))
|
||||
})
|
||||
|
||||
opener.open?.('host-1', {
|
||||
name: '[hostId]/session/[worktreeId]',
|
||||
params: { hostId: 'host-1', worktreeId: 'wt-1' }
|
||||
})
|
||||
|
||||
expect(nav.push).not.toHaveBeenCalled()
|
||||
expect(nav.dispatch.mock.calls).toEqual([
|
||||
[
|
||||
{
|
||||
type: 'SET_PARAMS',
|
||||
target: '/h',
|
||||
source: 'host-index',
|
||||
payload: { params: { open: '%2Fh%2Fhost-1%2Fsession%2Fwt-1' } }
|
||||
}
|
||||
]
|
||||
])
|
||||
})
|
||||
@@ -87,36 +87,6 @@ describe('createHostQueryPersistence', () => {
|
||||
vi.useRealTimers()
|
||||
})
|
||||
|
||||
it('paints the stored host list with its saved time and no agent state before any host read', async () => {
|
||||
const store = memoryStore('host-a')
|
||||
await storeFromEarlierLaunch(store, [liveRow])
|
||||
|
||||
const relaunched = new QueryClient()
|
||||
const restoring = createHostQueryPersistence(relaunched, store.backend).restore(firstPaint)
|
||||
await vi.runAllTimersAsync()
|
||||
await restoring
|
||||
|
||||
expect(relaunched.getQueryData(key)).toEqual({
|
||||
snapshotId: null,
|
||||
worktrees: [
|
||||
{
|
||||
worktreeId: 'repo-1::/w/mobile-redesign',
|
||||
repoId: 'repo-1',
|
||||
repo: 'orca',
|
||||
branch: 'kelvin/mobile-redesign',
|
||||
displayName: 'Mobile redesign',
|
||||
path: '/w/mobile-redesign',
|
||||
liveTerminalCount: 2,
|
||||
hasAttachedPty: true,
|
||||
unread: true,
|
||||
isPinned: false,
|
||||
linkedPR: { number: 38983, state: 'open' }
|
||||
}
|
||||
]
|
||||
})
|
||||
expect(relaunched.getQueryState(key)?.dataUpdatedAt).toBe(SAVED_AT)
|
||||
})
|
||||
|
||||
it('never shows a stored record that fails its data check, and removes it', async () => {
|
||||
const store = memoryStore('host-a')
|
||||
const { branch: _branch, ...rowWithoutBranch } = liveRow
|
||||
|
||||
@@ -86,20 +86,6 @@ function pendingStatus() {
|
||||
}
|
||||
|
||||
describe('mobile Jira status host ownership', () => {
|
||||
it('applies an explicit status refresh for the current host', async () => {
|
||||
const client = new FakeSession('connected')
|
||||
client.sendRequest.mockResolvedValue({
|
||||
id: 'jira-test',
|
||||
ok: true,
|
||||
result: { connected: true }
|
||||
})
|
||||
const fixture = mountRefresh(client, { current: client })
|
||||
await fixture.refresh()
|
||||
expect(client.sendRequest).toHaveBeenCalledWith('jira.status')
|
||||
expect(fixture.setJiraConnection).toHaveBeenCalledTimes(1)
|
||||
expect(fixture.connection().connected).toBe(true)
|
||||
})
|
||||
|
||||
it('ignores an earlier explicit refresh that settles after a newer one', async () => {
|
||||
const client = new FakeSession('connected')
|
||||
const earlier = pendingStatus()
|
||||
|
||||
@@ -1,178 +0,0 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
|
||||
const {
|
||||
callMock,
|
||||
runtimeClientConstructorMock,
|
||||
serveOrcaAppMock,
|
||||
getDefaultUserDataPathMock,
|
||||
addEnvironmentFromPairingCodeMock,
|
||||
listEnvironmentsMock,
|
||||
spawnMock
|
||||
} = vi.hoisted(() => ({
|
||||
callMock: vi.fn(),
|
||||
runtimeClientConstructorMock: vi.fn(),
|
||||
serveOrcaAppMock: vi.fn(),
|
||||
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
|
||||
addEnvironmentFromPairingCodeMock: vi.fn(),
|
||||
listEnvironmentsMock: vi.fn(),
|
||||
spawnMock: vi.fn()
|
||||
}))
|
||||
|
||||
vi.mock('./runtime-client', async () => {
|
||||
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
|
||||
return createRuntimeClientModuleMock({
|
||||
callMock,
|
||||
runtimeClientConstructorMock,
|
||||
serveOrcaAppMock,
|
||||
getDefaultUserDataPathMock
|
||||
})
|
||||
})
|
||||
|
||||
vi.mock('./runtime/environments', () => ({
|
||||
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
|
||||
removeEnvironment: vi.fn(),
|
||||
resolveEnvironment: vi.fn()
|
||||
}))
|
||||
|
||||
vi.mock('../shared/remote-runtime/host-store/runtime-environment-store', () => ({
|
||||
listEnvironments: listEnvironmentsMock
|
||||
}))
|
||||
|
||||
vi.mock('child_process', async () => {
|
||||
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
|
||||
return createChildProcessModuleMock(spawnMock)
|
||||
})
|
||||
|
||||
import { main } from './index'
|
||||
import { RuntimeRpcFailureError } from './runtime/types'
|
||||
import { okFixture } from './test-fixtures'
|
||||
import { useWorktreeAwarenessEnvironment } from './index-test-harness'
|
||||
|
||||
const FOLDER_RECORD = { id: 'folder:hub-a', path: '/work/hub' }
|
||||
|
||||
function notFound(): never {
|
||||
throw new RuntimeRpcFailureError({
|
||||
id: 'req_missing',
|
||||
ok: false,
|
||||
error: { code: 'selector_not_found', message: 'selector_not_found' },
|
||||
_meta: { runtimeId: 'runtime-1' }
|
||||
})
|
||||
}
|
||||
|
||||
/** A runtime that matches folders by path only when the request opts in, or an older one that never does. */
|
||||
function answer(folderMatching: boolean) {
|
||||
return async (method: string, params?: Record<string, unknown>) => {
|
||||
if (method === 'worktree.show') {
|
||||
return folderMatching && params?.matchFolderWorkspaces === true
|
||||
? okFixture('req_show', { worktree: FOLDER_RECORD })
|
||||
: notFound()
|
||||
}
|
||||
if (method === 'status.get') {
|
||||
return okFixture('req_status', {
|
||||
capabilities: folderMatching ? ['workspace-selector.folder-match.v1'] : []
|
||||
})
|
||||
}
|
||||
if (method === 'folderWorkspace.list') {
|
||||
return okFixture('req_folders', {
|
||||
folderWorkspaces: [{ id: 'hub-a', folderPath: '/work/hub' }]
|
||||
})
|
||||
}
|
||||
return okFixture('req_command', {
|
||||
ports: [],
|
||||
terminal: { handle: 'term_1', worktreeId: FOLDER_RECORD.id, title: null },
|
||||
opened: true,
|
||||
kind: 'text',
|
||||
relativePath: 'README.md'
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
describe('path: selectors on folder workspaces', () => {
|
||||
useWorktreeAwarenessEnvironment({
|
||||
callMock,
|
||||
serveOrcaAppMock,
|
||||
getDefaultUserDataPathMock,
|
||||
addEnvironmentFromPairingCodeMock,
|
||||
listEnvironmentsMock,
|
||||
spawnMock
|
||||
})
|
||||
|
||||
it.each([
|
||||
[['terminal', 'create'], 'terminal.create'],
|
||||
[['file', 'open', 'README.md'], 'files.open']
|
||||
])('%s reaches the folder workspace', async (command, method) => {
|
||||
vi.spyOn(console, 'log').mockImplementation(() => {})
|
||||
callMock.mockImplementation(answer(true))
|
||||
|
||||
await main([...command, '--worktree', 'path:/work/hub', '--json'], '/tmp')
|
||||
|
||||
expect(callMock).toHaveBeenCalledWith(
|
||||
method,
|
||||
expect.objectContaining({ worktree: 'folder:hub-a' })
|
||||
)
|
||||
})
|
||||
|
||||
it.each([
|
||||
[true, 'folder:hub-a'],
|
||||
[false, 'id:folder:hub-a']
|
||||
])(
|
||||
'ports --all scans the folder workspace (runtime matches folders: %s)',
|
||||
async (folderMatching, scanned) => {
|
||||
vi.spyOn(console, 'log').mockImplementation(() => {})
|
||||
callMock.mockImplementation(answer(folderMatching))
|
||||
|
||||
await main(['ports', '--all', '--worktree', 'path:/work/hub', '--json'], '/tmp')
|
||||
|
||||
expect(callMock).toHaveBeenCalledWith('workspacePorts.scanHost', { worktree: scanned })
|
||||
}
|
||||
)
|
||||
|
||||
it('sends a path:/name: parent to the runtime parent resolver as typed, with its ambiguity code', async () => {
|
||||
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
|
||||
const choices = {
|
||||
selector: 'name:Hub',
|
||||
candidates: [
|
||||
{ kind: 'folder workspace', hostId: 'local', path: '/work/hub', selector: 'folder:hub-a' },
|
||||
{ kind: 'folder workspace', hostId: 'local', path: '/work/hub', selector: 'folder:hub-b' }
|
||||
],
|
||||
nextSteps: ['Run `orca worktree ps --json` to compare the choices.']
|
||||
}
|
||||
callMock.mockImplementation(async (method: string) => {
|
||||
if (method === 'worktree.set') {
|
||||
throw new RuntimeRpcFailureError({
|
||||
id: 'req_set',
|
||||
ok: false,
|
||||
error: {
|
||||
code: 'LINEAGE_PARENT_AMBIGUOUS',
|
||||
message: 'More than one workspace matches "name:Hub".',
|
||||
data: choices
|
||||
},
|
||||
_meta: { runtimeId: 'runtime-1' }
|
||||
})
|
||||
}
|
||||
return okFixture('req_other', {})
|
||||
})
|
||||
|
||||
await main(
|
||||
['worktree', 'set', '--worktree', 'id:repo::/c', '--parent-worktree', 'name:Hub', '--json'],
|
||||
'/tmp'
|
||||
)
|
||||
|
||||
expect(callMock).not.toHaveBeenCalledWith('worktree.show', expect.anything())
|
||||
expect(callMock).toHaveBeenCalledWith(
|
||||
'worktree.set',
|
||||
expect.objectContaining({ parentWorktree: 'name:Hub', matchFolderWorkspaces: true })
|
||||
)
|
||||
const { error } = JSON.parse(String(log.mock.calls.at(-1)?.[0]))
|
||||
expect(error).toMatchObject({
|
||||
code: 'LINEAGE_PARENT_AMBIGUOUS',
|
||||
data: {
|
||||
...choices,
|
||||
environment: 'local',
|
||||
nextSteps: [
|
||||
'Compare the choices with `orca worktree ps --environment local --json`, then pass one as --parent-worktree.'
|
||||
]
|
||||
}
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -1,178 +0,0 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
|
||||
const {
|
||||
callMock,
|
||||
runtimeClientConstructorMock,
|
||||
serveOrcaAppMock,
|
||||
getDefaultUserDataPathMock,
|
||||
addEnvironmentFromPairingCodeMock,
|
||||
listEnvironmentsMock,
|
||||
spawnMock
|
||||
} = vi.hoisted(() => ({
|
||||
callMock: vi.fn(),
|
||||
runtimeClientConstructorMock: vi.fn(),
|
||||
serveOrcaAppMock: vi.fn(),
|
||||
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
|
||||
addEnvironmentFromPairingCodeMock: vi.fn(),
|
||||
listEnvironmentsMock: vi.fn(),
|
||||
spawnMock: vi.fn()
|
||||
}))
|
||||
|
||||
vi.mock('./runtime-client', async () => {
|
||||
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
|
||||
return createRuntimeClientModuleMock({
|
||||
callMock,
|
||||
runtimeClientConstructorMock,
|
||||
serveOrcaAppMock,
|
||||
getDefaultUserDataPathMock
|
||||
})
|
||||
})
|
||||
|
||||
vi.mock('./runtime/environments', () => ({
|
||||
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
|
||||
removeEnvironment: vi.fn(),
|
||||
resolveEnvironment: vi.fn()
|
||||
}))
|
||||
|
||||
vi.mock('../shared/remote-runtime/host-store/runtime-environment-store', () => ({
|
||||
listEnvironments: listEnvironmentsMock
|
||||
}))
|
||||
|
||||
vi.mock('child_process', async () => {
|
||||
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
|
||||
return createChildProcessModuleMock(spawnMock)
|
||||
})
|
||||
|
||||
import { main } from './index'
|
||||
import { okFixture } from './test-fixtures'
|
||||
import { useWorktreeAwarenessEnvironment } from './index-test-harness'
|
||||
|
||||
const FOLDER_RECORD = { id: 'folder:hub-a', path: '/work/hub', displayName: 'Hub' }
|
||||
|
||||
function answerFolder(overrides: Record<string, () => unknown> = {}) {
|
||||
return async (method: string) => {
|
||||
if (overrides[method]) {
|
||||
return overrides[method]()
|
||||
}
|
||||
if (method === 'worktree.show') {
|
||||
return okFixture('req_show', { worktree: FOLDER_RECORD })
|
||||
}
|
||||
if (method === 'status.get') {
|
||||
return okFixture('req_status', { capabilities: ['folder-workspace.unique-id-mutation.v1'] })
|
||||
}
|
||||
if (method === 'folderWorkspace.update') {
|
||||
return okFixture('req_update', { folderWorkspace: { id: 'hub-a', name: 'Renamed' } })
|
||||
}
|
||||
if (method === 'folderWorkspace.delete') {
|
||||
return okFixture('req_delete', { deleted: true })
|
||||
}
|
||||
throw new Error(`unexpected ${method}`)
|
||||
}
|
||||
}
|
||||
|
||||
function lastJson(log: ReturnType<typeof vi.spyOn>): {
|
||||
result?: unknown
|
||||
error?: { code: string }
|
||||
} {
|
||||
return JSON.parse(String(log.mock.calls.at(-1)?.[0]))
|
||||
}
|
||||
|
||||
function folderMutations(): string[] {
|
||||
return callMock.mock.calls
|
||||
.map(([method]) => String(method))
|
||||
.filter((method) => method.startsWith('folderWorkspace.') || method === 'worktree.set')
|
||||
}
|
||||
|
||||
describe('worktree set and rm on folder workspaces', () => {
|
||||
useWorktreeAwarenessEnvironment({
|
||||
callMock,
|
||||
serveOrcaAppMock,
|
||||
getDefaultUserDataPathMock,
|
||||
addEnvironmentFromPairingCodeMock,
|
||||
listEnvironmentsMock,
|
||||
spawnMock
|
||||
})
|
||||
|
||||
it('set renames and comments through the folder update and returns the set envelope', async () => {
|
||||
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
|
||||
callMock.mockImplementation(answerFolder())
|
||||
|
||||
await main(
|
||||
[
|
||||
'worktree',
|
||||
'set',
|
||||
'--worktree',
|
||||
'folder:hub-a',
|
||||
'--display-name',
|
||||
'Renamed',
|
||||
'--comment',
|
||||
'triaging',
|
||||
'--json'
|
||||
],
|
||||
'/tmp'
|
||||
)
|
||||
|
||||
expect(callMock).toHaveBeenCalledWith('folderWorkspace.update', {
|
||||
folderWorkspaceId: 'hub-a',
|
||||
requireUniqueId: true,
|
||||
updates: { name: 'Renamed', comment: 'triaging' }
|
||||
})
|
||||
expect(lastJson(log).result).toEqual({ worktree: FOLDER_RECORD })
|
||||
})
|
||||
|
||||
it('rm forgets the folder workspace and reports removed', async () => {
|
||||
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
|
||||
callMock.mockImplementation(answerFolder())
|
||||
|
||||
await main(['worktree', 'rm', '--worktree', 'folder:hub-a', '--json'], '/tmp')
|
||||
|
||||
expect(callMock).toHaveBeenCalledWith('folderWorkspace.delete', {
|
||||
folderWorkspaceId: 'hub-a',
|
||||
requireUniqueId: true
|
||||
})
|
||||
expect(callMock).not.toHaveBeenCalledWith('worktree.rm', expect.anything(), expect.anything())
|
||||
expect(lastJson(log).result).toEqual({ removed: true })
|
||||
})
|
||||
|
||||
it.each([[['set', '--display-name', 'x']], [['rm']]])(
|
||||
'an Orca without the unique-id guarantee is refused before any change (%s)',
|
||||
async (command) => {
|
||||
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
|
||||
callMock.mockImplementation(
|
||||
answerFolder({ 'status.get': () => okFixture('req_status', { capabilities: [] }) })
|
||||
)
|
||||
|
||||
const [verb, ...rest] = command
|
||||
await main(['worktree', verb, '--worktree', 'folder:hub-a', ...rest, '--json'], '/tmp')
|
||||
|
||||
expect(lastJson(log).error?.code).toBe('incompatible_runtime')
|
||||
expect(folderMutations()).toEqual([])
|
||||
}
|
||||
)
|
||||
|
||||
it.each([
|
||||
[['rm', '--delete-branch']],
|
||||
[['rm', '--run-hooks']],
|
||||
[['set', '--no-parent']],
|
||||
[['set', '--pr', '5']]
|
||||
])('%s is refused on a folder workspace with no change', async (command) => {
|
||||
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
|
||||
callMock.mockImplementation(answerFolder())
|
||||
|
||||
const [verb, ...rest] = command
|
||||
await main(['worktree', verb, '--worktree', 'folder:hub-a', ...rest, '--json'], '/tmp')
|
||||
|
||||
expect(lastJson(log).error?.code).toBe('invalid_argument')
|
||||
expect(folderMutations()).toEqual([])
|
||||
})
|
||||
|
||||
it('activate refuses a folder workspace without asking the runtime to open it', async () => {
|
||||
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
|
||||
callMock.mockImplementation(answerFolder())
|
||||
|
||||
await main(['worktree', 'activate', '--worktree', 'folder:hub-a', '--json'], '/tmp')
|
||||
|
||||
expect(lastJson(log).error?.code).toBe('invalid_argument')
|
||||
expect(callMock).not.toHaveBeenCalledWith('worktree.activate', expect.anything())
|
||||
})
|
||||
})
|
||||
@@ -10,10 +10,10 @@ vi.mock('../claude-hook-event-versions', async (importOriginal) => ({
|
||||
}))
|
||||
let claudeVersion: string | null = '2.1.319'
|
||||
import { syncClaudeCodeThemeConfigDirs } from './claude-code-theme-sync'
|
||||
import { claudeCodeThemeFromTerminal } from './claude-code-theme'
|
||||
import { TERMINAL_THEME_CATALOG } from '../../../shared/terminal-themes/terminal-theme-catalog'
|
||||
import { contrastRatio } from '../../../shared/color/rgba-contrast'
|
||||
import { parseTerminalColor } from '../../../shared/terminal-themes/terminal-title-contrast'
|
||||
import './claude-code-theme'
|
||||
import '../../../shared/terminal-themes/terminal-theme-catalog'
|
||||
import '../../../shared/color/rgba-contrast'
|
||||
import '../../../shared/terminal-themes/terminal-title-contrast'
|
||||
|
||||
const THEME = { name: 'Orca', base: 'dark', overrides: { claude: '#7aa2f7' } }
|
||||
const on = { enabled: true, theme: THEME } as const
|
||||
@@ -59,13 +59,6 @@ describe('Claude Code theme sync', () => {
|
||||
})
|
||||
})
|
||||
|
||||
it('removes the theme key it added when there was none', async () => {
|
||||
writeSettings({ model: 'opus' })
|
||||
await sync(on)
|
||||
await sync(off)
|
||||
expect(readSettings()).toEqual({ model: 'opus' })
|
||||
})
|
||||
|
||||
it('stops writing once the user picks another theme, and leaves it on disable', async () => {
|
||||
writeSettings({ theme: 'dark' })
|
||||
await sync(on)
|
||||
@@ -77,20 +70,6 @@ describe('Claude Code theme sync', () => {
|
||||
expect(readSettings()).toEqual({ theme: 'light-daltonized' })
|
||||
})
|
||||
|
||||
it('leaves a colorblind or custom theme the user picked alone', async () => {
|
||||
writeSettings({ theme: 'dark-daltonized' })
|
||||
await sync(on)
|
||||
expect(readSettings()).toEqual({ theme: 'dark-daltonized' })
|
||||
})
|
||||
|
||||
it('leaves settings alone for a Claude Code without custom themes', async () => {
|
||||
claudeVersion = '2.1.118'
|
||||
writeSettings({ theme: 'dark' })
|
||||
await sync(on)
|
||||
claudeVersion = '2.1.319'
|
||||
expect(readSettings()).toEqual({ theme: 'dark' })
|
||||
})
|
||||
|
||||
it.skipIf(process.platform === 'win32')(
|
||||
'takes over later when the settings write fails, instead of treating it as the user’s pick',
|
||||
async () => {
|
||||
@@ -113,30 +92,4 @@ describe('Claude Code theme sync', () => {
|
||||
await sync(on)
|
||||
expect(readFileSync(settingsPath, 'utf-8')).toBe('{ "theme": "dark", ')
|
||||
})
|
||||
|
||||
it('leaves Claude Code alone when its config dir does not exist', async () => {
|
||||
rmSync(configDir, { recursive: true })
|
||||
await sync(on)
|
||||
expect(() => readFileSync(settingsPath)).toThrow()
|
||||
})
|
||||
})
|
||||
|
||||
describe('Claude Code theme from the terminal palette', () => {
|
||||
it.each(['Solarized Light', 'Solarized Dark', 'Builtin Tango Light', 'Gruvbox Light'])(
|
||||
'keeps %s text and hues readable on its background',
|
||||
(name) => {
|
||||
const palette = TERMINAL_THEME_CATALOG[name]
|
||||
const theme = claudeCodeThemeFromTerminal(palette)
|
||||
const background = parseTerminalColor(palette.background)
|
||||
const ratio = (key: string): number => {
|
||||
const color = parseTerminalColor(theme?.overrides[key])
|
||||
return color && background ? contrastRatio(color, background) : 0
|
||||
}
|
||||
expect(ratio('text')).toBeGreaterThanOrEqual(4.5)
|
||||
expect(ratio('inactive')).toBeGreaterThanOrEqual(4.5)
|
||||
for (const key of ['claude', 'success', 'error', 'warning', 'permission']) {
|
||||
expect(ratio(key)).toBeGreaterThanOrEqual(3)
|
||||
}
|
||||
}
|
||||
)
|
||||
})
|
||||
|
||||
@@ -1,56 +0,0 @@
|
||||
import { existsSync, mkdtempSync, readFileSync, rmSync, utimesSync, writeFileSync } from 'node:fs'
|
||||
import { tmpdir } from 'node:os'
|
||||
import { join } from 'node:path'
|
||||
import { afterEach, expect, it, vi } from 'vitest'
|
||||
import { DeviceRegistry } from '../runtime/rpc/server/pairing/device-registry'
|
||||
import { MobileNotificationDismissalStore } from '../runtime/push/notifications/mobile-notification-dismissal-store'
|
||||
import { DEVICE_REGISTRY_FILENAME } from '../runtime/rpc/server/pairing/mobile-pairing-files'
|
||||
|
||||
const dirs: string[] = []
|
||||
afterEach(() => {
|
||||
vi.restoreAllMocks()
|
||||
dirs.splice(0).forEach((dir) => rmSync(dir, { recursive: true, force: true }))
|
||||
})
|
||||
|
||||
const stores = [
|
||||
[
|
||||
'dismissal store',
|
||||
'mobile-notification-dismissals.json',
|
||||
(dir: string) => new MobileNotificationDismissalStore(dir)
|
||||
],
|
||||
['device registry', DEVICE_REGISTRY_FILENAME, (dir: string) => new DeviceRegistry(dir)]
|
||||
] as const
|
||||
|
||||
it.each(stores)(
|
||||
'%s reclaims orphaned temps while preserving active writes and unrelated files',
|
||||
async (_, fileName, open) => {
|
||||
const dir = mkdtempSync(join(tmpdir(), 'orca-orphaned-temp-'))
|
||||
dirs.push(dir)
|
||||
// Other-process PIDs: the sweep always spares this process's own temps.
|
||||
const orphaned = join(dir, `${fileName}.${process.pid + 1}.1784108697605.b306bb91.tmp`)
|
||||
const recent = join(dir, `${fileName}.${process.pid + 2}.1784108697605.cafef00d.tmp`)
|
||||
const own = join(dir, `${fileName}.${process.pid}.1784108697605.aaaaaaaa.tmp`)
|
||||
const otherStore = join(
|
||||
dir,
|
||||
`${fileName === DEVICE_REGISTRY_FILENAME ? 'mobile-notification-dismissals.json' : DEVICE_REGISTRY_FILENAME}.${process.pid + 1}.0.bbbbbbbb.tmp`
|
||||
)
|
||||
const similarName = join(dir, `${fileName}-backup.${process.pid + 1}.0.cccccccc.tmp`)
|
||||
const wrongSuffix = join(dir, `${fileName}.${process.pid + 1}.0.dddddddd.tmp.backup`)
|
||||
const finalPath = join(dir, fileName)
|
||||
writeFileSync(orphaned, '[]')
|
||||
writeFileSync(recent, '[]')
|
||||
writeFileSync(finalPath, '[]')
|
||||
const twoDaysAgo = (Date.now() - 2 * 86400_000) / 1000
|
||||
for (const path of [orphaned, own, otherStore, similarName, wrongSuffix]) {
|
||||
writeFileSync(path, '[]')
|
||||
utimesSync(path, twoDaysAgo, twoDaysAgo)
|
||||
}
|
||||
|
||||
open(dir)
|
||||
|
||||
await vi.waitFor(() => expect(existsSync(orphaned)).toBe(false))
|
||||
for (const path of [recent, own, otherStore, similarName, wrongSuffix, finalPath]) {
|
||||
expect(readFileSync(path, 'utf8')).toBe('[]')
|
||||
}
|
||||
}
|
||||
)
|
||||
@@ -9,12 +9,8 @@ import 'node:path'
|
||||
import '../../../shared/remote-runtime/host-store/runtime-environment-store-file'
|
||||
import { createRuntimeAgentProjections } from '../construction/runtime-agent-projections'
|
||||
|
||||
import {
|
||||
fingerprintOrchestrationPeer,
|
||||
pairedOrchestrationPeers
|
||||
} from '../orchestration/federation/environment-transport'
|
||||
|
||||
import { devicePrincipalOf } from '../rpc/server/pairing/device-principal'
|
||||
import { fingerprintOrchestrationPeer } from '../orchestration/federation/environment-transport'
|
||||
import '../rpc/server/pairing/device-principal'
|
||||
|
||||
import { OrchestrationDb } from '../orchestration/db/orchestration-db'
|
||||
|
||||
@@ -39,11 +35,7 @@ import {
|
||||
agentSessionLeaseFixture,
|
||||
agentSessionRecordFixture
|
||||
} from '../../../shared/agent-session/lifecycle/agent-session-record.test-fixture'
|
||||
|
||||
import {
|
||||
mintStructuredWorkerHandle,
|
||||
mintStructuredWorkerPaneKey
|
||||
} from '../orchestration/terminal-authority/structured-sessions/structured-worker-identity'
|
||||
import '../orchestration/terminal-authority/structured-sessions/structured-worker-identity'
|
||||
|
||||
import { testOrcaSessionId } from '../../../shared/orca-session-address-test-fixture'
|
||||
|
||||
@@ -186,64 +178,6 @@ function harness(n = 1, records: AgentSessionRecordReader | null = null) {
|
||||
}
|
||||
}
|
||||
|
||||
it('locates every sender by the handle or Dispatch its card saved after a warm restart, with no agent event', () => {
|
||||
const h = harness(3)
|
||||
const idleWorker = h.worker(0)
|
||||
// Dispatched to tab-1's own terminal; Orca hasn't recorded that terminal for it yet.
|
||||
const starting = createRootDispatch(
|
||||
h.db,
|
||||
h.db.createTask({ runId: h.run.id, spec: 'starting' }).id,
|
||||
handle(1),
|
||||
pane('tab-1')
|
||||
)
|
||||
for (const check of [() => undefined, () => h.restart()]) {
|
||||
check()
|
||||
// Started-worker cards name the Dispatch; Message, Task and Update cards name the handle,
|
||||
// whether the sender is a hooked agent, a hooks-off agent, a plain shell or a reply.
|
||||
expect(h.located(`dispatch:${idleWorker.id}`)).toBe(pane('tab-0'))
|
||||
expect(h.located(`dispatch:${starting.id}`)).toBeUndefined()
|
||||
expect(h.located(handle(0))).toBe(pane('tab-0'))
|
||||
expect(h.located(handle(2))).toBe(pane('tab-2'))
|
||||
}
|
||||
})
|
||||
|
||||
it('rejects released or unproven custody while keeping an independently live original execution', () => {
|
||||
const h = harness(2)
|
||||
const worker = h.worker(0)
|
||||
const settled = createRootDispatch(
|
||||
h.db,
|
||||
h.db.createTask({ runId: h.run.id, spec: 'settled' }).id,
|
||||
handle(1),
|
||||
pane('tab-1')
|
||||
)
|
||||
h.db.db.prepare("UPDATE dispatch_contexts SET status = 'completed' WHERE id = ?").run(settled.id)
|
||||
expect(h.located(`dispatch:${settled.id}`)).toBeUndefined()
|
||||
// A malformed former-owner list loses only that row's former owners.
|
||||
h.db.db
|
||||
.prepare("UPDATE worker_terminal_resources SET prior_owner_dispatch_ids = 'not json'")
|
||||
.run()
|
||||
expect(h.located(`dispatch:${worker.id}`)).toBe(pane('tab-0'))
|
||||
for (const incarnation of ['pty-0:replaced', null]) {
|
||||
h.db.db.prepare('UPDATE worker_terminal_resources SET process_incarnation = ?').run(incarnation)
|
||||
expect(h.located(`dispatch:${worker.id}`)).toBe(pane('tab-0'))
|
||||
}
|
||||
h.db.db.prepare("UPDATE worker_terminal_resources SET process_incarnation = 'pty-0:inc-1'").run()
|
||||
for (const [column, value] of [
|
||||
['ownership_state', 'released'],
|
||||
['retained_reason', 'identity_unproven']
|
||||
] as const) {
|
||||
h.db.db.prepare(`UPDATE worker_terminal_resources SET ${column} = ?`).run(value)
|
||||
expect(h.located(`dispatch:${worker.id}`)).toBeUndefined()
|
||||
h.db.db
|
||||
.prepare(
|
||||
"UPDATE worker_terminal_resources SET process_incarnation = 'pty-0:inc-1', ownership_state = 'owned', retained_reason = NULL"
|
||||
)
|
||||
.run()
|
||||
}
|
||||
// The terminal itself is still the one that sent the worker's cards.
|
||||
expect(h.located(handle(0))).toBe(pane('tab-0'))
|
||||
})
|
||||
|
||||
it('does not take a respawned or fresh terminal for the one a card was sent from', () => {
|
||||
const h = harness(2)
|
||||
const worker = h.worker(0)
|
||||
@@ -259,46 +193,6 @@ it('does not take a respawned or fresh terminal for the one a card was sent from
|
||||
expect(h.located('term_fresh')).toBe(pane('tab-1'))
|
||||
})
|
||||
|
||||
it('publishes plain chats and canonical /clear successors without credential handles or credential panes', () => {
|
||||
const root = testOrcaSessionId('11111111-1111-4111-8111-111111111111')
|
||||
const live = testOrcaSessionId('22222222-2222-4222-8222-222222222222')
|
||||
const base = (sessionId: string) =>
|
||||
agentSessionRecordFixture(agentSessionLeaseFixture({ sessionId }))
|
||||
const original = {
|
||||
...base(root),
|
||||
conversationCommand: {
|
||||
command: 'clear',
|
||||
state: 'completed',
|
||||
replacementSessionId: live,
|
||||
operationId: 'op',
|
||||
callerKey: 'k',
|
||||
phase: 'committed'
|
||||
}
|
||||
} as const
|
||||
const rows = [agentSessionConversationView(original), agentSessionConversationView(base(live))]
|
||||
const h = harness(0, {
|
||||
getRecord: (id) => rows.find((r) => r.sessionId === id) ?? null,
|
||||
listRecords: () => rows
|
||||
})
|
||||
const structured = mintStructuredWorkerHandle()
|
||||
const credentialPane = mintStructuredWorkerPaneKey(root)
|
||||
createRootDispatch(
|
||||
h.db,
|
||||
h.db.createTask({ runId: h.run.id, spec: 's' }).id,
|
||||
structured,
|
||||
credentialPane
|
||||
)
|
||||
const associations = h.projection.build().associations
|
||||
expect(associations.find((r) => r.identity === `orca_session_id:${root}`)).toMatchObject({
|
||||
sessionId: live
|
||||
})
|
||||
expect(associations.find((r) => r.identity === `orca_session_id:${live}`)).toMatchObject({
|
||||
sessionId: live
|
||||
})
|
||||
expect(JSON.stringify(h.projection.build())).not.toContain(structured)
|
||||
expect(JSON.stringify(h.projection.build())).not.toContain(credentialPane)
|
||||
})
|
||||
|
||||
it('keeps an existing subscriber owed its update when another client reads the newer scope', () => {
|
||||
const h = harness(1)
|
||||
const first = h.projection.buildForFrame('workspace')
|
||||
@@ -451,68 +345,3 @@ it('publishes one principal per paired peer and attachments only while their wor
|
||||
h.db.db.prepare("UPDATE remote_dispatch_attachments SET state = 'stopped'").run()
|
||||
expect(h.projection.build('workspace').attachments).toEqual([])
|
||||
})
|
||||
|
||||
it('names a federated worker by the fingerprints its home derives for the runtime and itself', () => {
|
||||
// The execution runtime records the home as the principal it authenticated the home's socket as.
|
||||
const home = devicePrincipalOf({
|
||||
deviceId: 'home-device',
|
||||
name: 'Home',
|
||||
token: 'home-device-token',
|
||||
scope: 'runtime',
|
||||
pairedAt: 1,
|
||||
lastSeenAt: 1
|
||||
})
|
||||
const h = harness()
|
||||
h.db.createRemoteDispatchAttachment({
|
||||
dispatchId: 'federated',
|
||||
taskId: 'task',
|
||||
homePeerFingerprint: home.callerFingerprint,
|
||||
protocolVersion: 2,
|
||||
runtimeEpoch: 'epoch',
|
||||
mutationReceipt: {
|
||||
callerFingerprint: home.callerFingerprint,
|
||||
requestId: 'attach',
|
||||
method: 'orchestration.federationAttachStart',
|
||||
payloadHash: 'fixture'
|
||||
}
|
||||
})
|
||||
h.db.prepareRemoteAttachmentAuthority({
|
||||
dispatchId: 'federated',
|
||||
paneKey: pane('tab-0'),
|
||||
processIncarnation: 'pty-0:inc-1',
|
||||
worktreeId: 'workspace',
|
||||
terminalHandle: 'term_now_tab-0',
|
||||
setupState: 'skipped',
|
||||
effects: []
|
||||
})
|
||||
const execution = h.projection.build('workspace')
|
||||
// The home's principal for that runtime, derived from its pairing record as main resolves it.
|
||||
const paired = pairedOrchestrationPeers('execution-key', 'home-device-token')
|
||||
expect(execution.peerFingerprint).toBe(paired.peerFingerprint)
|
||||
expect(execution.attachments.map((row) => row.homePeerFingerprint)).toEqual([
|
||||
paired.homePeerFingerprint
|
||||
])
|
||||
})
|
||||
|
||||
it('publishes WSL chats, and only open chats when no tab table is recorded yet', () => {
|
||||
const record = (sessionId: string, wslDistro: string | null = null) => {
|
||||
const base = agentSessionRecordFixture(agentSessionLeaseFixture({ sessionId }))
|
||||
return agentSessionConversationView({ ...base, location: { ...base.location, wslDistro } })
|
||||
}
|
||||
for (const history of [100, 1000]) {
|
||||
const rows = [
|
||||
record('wsl-chat', 'Ubuntu'),
|
||||
...Array.from({ length: history }, (_, i) => record(`closed-${i}`))
|
||||
]
|
||||
const h = harness(0, {
|
||||
getRecord: (id) => rows.find((r) => r.sessionId === id) ?? null,
|
||||
listRecords: () => rows,
|
||||
// Before the tab table exists the store answers from the workspace's saved chat tabs.
|
||||
getVisibleSessionTabIndex: () => ({ present: false, sessionIds: [] }),
|
||||
listVisibleSessionIds: () => ['wsl-chat']
|
||||
})
|
||||
expect(h.projection.build().associations.map((r) => r.identity)).toEqual([
|
||||
'orca_session_id:wsl-chat'
|
||||
])
|
||||
}
|
||||
})
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
import { afterEach, expect, it, vi } from 'vitest'
|
||||
import { createRuntimeAgentProjections } from '../construction/runtime-agent-projections'
|
||||
import '../construction/runtime-agent-projections'
|
||||
import {
|
||||
clearedInto,
|
||||
conversationRecordReader,
|
||||
type AgentSessionRecordReader
|
||||
} from '../orchestration/addressing/session-lineage/structured-session-lineage'
|
||||
@@ -15,17 +14,10 @@ import {
|
||||
seedTestAgentSessionRecordStore
|
||||
} from '../agent-session/records/agent-session-record-store-test-harness'
|
||||
import { readAgentSenderSessions } from './agent-sender-chat-sessions'
|
||||
import {
|
||||
AGENT_SESSION_PREDECESSOR_IDS,
|
||||
agentSessionPredecessorWorkForTest
|
||||
} from '../agent-session/records/agent-session-record-lineage'
|
||||
import { AGENT_SESSION_PREDECESSOR_IDS } from '../agent-session/records/agent-session-record-lineage'
|
||||
import { openTestJournalHostDatabase } from '../../native-chat/agent-session-journal/store-lifecycle/journal-host-database-test-support'
|
||||
import type { AgentSessionRecord } from '../../../shared/agent-session/lifecycle/agent-session-record'
|
||||
|
||||
const unissued = (): never => {
|
||||
throw new Error('a sender build issued a terminal handle')
|
||||
}
|
||||
|
||||
afterEach(() => vi.restoreAllMocks())
|
||||
|
||||
/** A committed /clear: the durable forward pointer the reverse index is derived from. */
|
||||
@@ -46,144 +38,6 @@ const cleared = (
|
||||
}
|
||||
})
|
||||
|
||||
/** Six open chats, one behind a three-deep /clear chain, and `history` unrelated closed chats. */
|
||||
async function chats(history: number) {
|
||||
const root = await scaleDirectory()
|
||||
const open = ['opened-0', 'opened-1', 'opened-2', 'opened-3', 'opened-4', 'cleared-3'].map((id) =>
|
||||
scaleRecord(id)
|
||||
)
|
||||
const chain = ['cleared-0', 'cleared-1', 'cleared-2'].map((id, i) =>
|
||||
cleared(scaleRecord(id), `cleared-${i + 1}`)
|
||||
)
|
||||
const closed = Array.from({ length: history }, (_, i) => scaleRecord(`closed-chat-${i}`))
|
||||
await seedTestAgentSessionRecordStore(root, {
|
||||
records: [...open, ...chain, ...closed, scaleRecord('opened-5')],
|
||||
sessionTabs: open.map((row) => ({ tabId: `tab-${row.sessionId}`, sessionId: row.sessionId }))
|
||||
})
|
||||
const store = await openTestAgentSessionRecordStore(root)
|
||||
const inventories = vi.spyOn(store, 'listConversations')
|
||||
const records = conversationRecordReader(store)
|
||||
const { senders } = createRuntimeAgentProjections(
|
||||
{
|
||||
getExistingOrchestrationDb: () => null,
|
||||
resolveOrchestrationWorkerServer: () => {
|
||||
throw new Error('unpaired')
|
||||
}
|
||||
},
|
||||
{
|
||||
getDb: () => null,
|
||||
getLeaves: () => [],
|
||||
getPtys: () => [],
|
||||
paneOf: () => ({ tabId: null, paneKey: null, recordedAtGraphSequence: 0 }),
|
||||
// Orchestration issues handles; sender rows only read the ones already issued.
|
||||
issueLeafHandle: unissued,
|
||||
issuePtyHandle: unissued,
|
||||
readLeafHandle: () => null,
|
||||
readPtyHandles: () => () => null,
|
||||
makePaneKey: () => '',
|
||||
getWorktreeId: () => null,
|
||||
getHandleForPaneKey: () => null,
|
||||
getPaneKey: () => null,
|
||||
getDispatchAuthority: () => null,
|
||||
getAgentStatusSnapshot: () => [],
|
||||
getSessionRecords: () => records
|
||||
}
|
||||
)
|
||||
/** The chat rows a build publishes, as identity -> the session it now opens. */
|
||||
const rows = () =>
|
||||
Object.fromEntries(
|
||||
senders
|
||||
.build()
|
||||
.associations.filter((row) => row.sessionId)
|
||||
.map((row) => [row.identity.slice('orca_session_id:'.length), row.sessionId])
|
||||
)
|
||||
/** What every saved chat says, read the slow way: the full scan the index replaces. */
|
||||
const oracle = () => {
|
||||
inventories.mockClear()
|
||||
const { listClearedFrom: _index, ...listing }: AgentSessionRecordReader = records
|
||||
const scanned = Object.fromEntries(
|
||||
readAgentSenderSessions(listing).map((row) => [
|
||||
row.identity.slice('orca_session_id:'.length),
|
||||
row.sessionId
|
||||
])
|
||||
)
|
||||
const rebuilt = new Map<string, string[]>()
|
||||
for (const record of store.listConversations()) {
|
||||
const next = clearedInto(record)
|
||||
if (next) {
|
||||
rebuilt.set(next, [...(rebuilt.get(next) ?? []), record.sessionId].sort())
|
||||
}
|
||||
}
|
||||
const indexed = new Map(
|
||||
store.listHeldSessionIds().flatMap((id) => {
|
||||
const from = [...store.listClearedFrom(id)].sort()
|
||||
return from.length ? [[id, from] as const] : []
|
||||
})
|
||||
)
|
||||
inventories.mockClear()
|
||||
return { scanned, index: Object.fromEntries(indexed), rebuilt: Object.fromEntries(rebuilt) }
|
||||
}
|
||||
return { root, store, senders, rows, oracle, inventories }
|
||||
}
|
||||
|
||||
it.each([1_000, 10_000])(
|
||||
'reads only open chats and their /clear predecessors, at %i unrelated saved chats',
|
||||
async (history) => {
|
||||
const h = await chats(history)
|
||||
const visits = () => h.senders.workForTest().chatRecords
|
||||
const check = (expected: Record<string, string>, readsAtMost: number) => {
|
||||
const before = visits()
|
||||
const seeks = agentSessionPredecessorWorkForTest()
|
||||
expect(h.rows()).toEqual(expected)
|
||||
// Open chats plus their predecessors, whatever the saved history holds: one indexed seek
|
||||
// per visited chat, returning only rows that name it.
|
||||
expect(visits() - before).toBeLessThanOrEqual(readsAtMost)
|
||||
const work = agentSessionPredecessorWorkForTest()
|
||||
expect(work.seeks - seeks.seeks).toBeLessThanOrEqual(readsAtMost)
|
||||
expect(work.rows - seeks.rows).toBeLessThanOrEqual(readsAtMost)
|
||||
expect(h.inventories).not.toHaveBeenCalled()
|
||||
const { scanned, index, rebuilt } = h.oracle()
|
||||
expect(scanned).toEqual(expected)
|
||||
expect(index).toEqual(rebuilt)
|
||||
}
|
||||
const base = {
|
||||
'opened-0': 'opened-0',
|
||||
'opened-1': 'opened-1',
|
||||
'opened-2': 'opened-2',
|
||||
'opened-3': 'opened-3',
|
||||
'opened-4': 'opened-4',
|
||||
'cleared-0': 'cleared-3',
|
||||
'cleared-1': 'cleared-3',
|
||||
'cleared-2': 'cleared-3',
|
||||
'cleared-3': 'cleared-3'
|
||||
}
|
||||
check(base, 9)
|
||||
await h.store.setSessionTabVisibility('opened-5', true)
|
||||
check({ ...base, 'opened-5': 'opened-5' }, 10)
|
||||
await h.store.setSessionTabVisibility('opened-5', false)
|
||||
check(base, 9)
|
||||
// A committed /clear continues opened-1 in opened-2: its cards follow, through the index.
|
||||
await h.store.reviseSessionOptions((record) => cleared(record, 'opened-2'), {
|
||||
sessionId: 'opened-1'
|
||||
})
|
||||
const { 'opened-1': _cleared, ...rest } = base
|
||||
check({ ...rest, 'opened-1': 'opened-2' }, 9)
|
||||
// A move keeps the identity and changes only where the row says the chat runs.
|
||||
await h.store.reviseSessionOptions(
|
||||
(record) => ({ ...record, location: { ...record.location, workspaceId: 'moved' } }),
|
||||
{ sessionId: 'cleared-3' }
|
||||
)
|
||||
expect(h.senders.build().associations.find((row) => row.sessionId === 'cleared-3')).toEqual(
|
||||
expect.objectContaining({ worktreeId: 'moved' })
|
||||
)
|
||||
// A reload reads the same saved pointers.
|
||||
const reopened = await openTestAgentSessionRecordStore(h.root)
|
||||
const index = (store: typeof h.store) =>
|
||||
store.listHeldSessionIds().map((id) => [id, [...store.listClearedFrom(id)].sort()])
|
||||
expect(index(reopened)).toEqual(index(h.store))
|
||||
}
|
||||
)
|
||||
|
||||
it('follows branching, unreadable and cyclic /clear predecessors as the full scan does, by index', async () => {
|
||||
const root = await scaleDirectory()
|
||||
await seedTestAgentSessionRecordStore(root, {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import { expect, it, vi } from 'vitest'
|
||||
import { OrcaRuntimeService } from '../orca-runtime'
|
||||
import { MIRROR_LEAVES_STEP_1 } from '../terminal/records/runtime-leaf-record-projection.test-fixture'
|
||||
import { makeTuiIdlePty } from '../terminal/wait/tui-idle-wait-test-harness'
|
||||
import '../terminal/records/runtime-leaf-record-projection.test-fixture'
|
||||
import '../terminal/wait/tui-idle-wait-test-harness'
|
||||
|
||||
const PTY_ID = 'pty-local-1'
|
||||
const WORKTREE_ID = 'repo::/worktree'
|
||||
@@ -48,39 +48,3 @@ it('keeps a running terminal’s sender row, by its start-time handle, while no
|
||||
// Reading the handle issued nothing.
|
||||
expect(runtime['handles']).toEqual(records)
|
||||
})
|
||||
|
||||
it.each([100, 1000])(
|
||||
'reads every leafless terminal’s handle with one pass over the handle records, at %i terminals',
|
||||
(n) => {
|
||||
const runtime = new OrcaRuntimeService(null)
|
||||
// n terminals the window shows, each holding a handle record.
|
||||
for (let i = 0; i < n; i++) {
|
||||
const leaf = {
|
||||
...MIRROR_LEAVES_STEP_1[0],
|
||||
tabId: `tab-${i}`,
|
||||
leafId: LEAF_ID,
|
||||
worktreeId: WORKTREE_ID,
|
||||
ptyId: `leaf-pty-${i}`
|
||||
}
|
||||
runtime['terminalIdentity'].replaceLeaves(
|
||||
new Map(runtime['leaves']).set(runtime['getLeafKey'](leaf.tabId, LEAF_ID), leaf)
|
||||
)
|
||||
runtime['issueHandle'](leaf)
|
||||
}
|
||||
// A leafless terminal whose handle survives only as its record, as invalidating its other
|
||||
// aliases leaves it, and n leafless terminals that hold no handle.
|
||||
const kept = makeTuiIdlePty({ ptyId: 'kept', incarnationId: 'inc-1', worktreeId: WORKTREE_ID })
|
||||
const keptHandle = runtime['issuePtyHandle'](kept)
|
||||
runtime['terminalIdentity'].unbindPty('kept')
|
||||
const unissued = Array.from({ length: n }, (_, i) =>
|
||||
makeTuiIdlePty({ ptyId: `bare-${i}`, incarnationId: 'inc-1', worktreeId: WORKTREE_ID })
|
||||
)
|
||||
const passes = vi.spyOn(runtime['handles'], Symbol.iterator)
|
||||
const read = runtime['terminalHandleAccess']().readPtyHandles()
|
||||
expect(read(kept)).toBe(keptHandle)
|
||||
expect(unissued.map(read).filter((handle) => handle !== null)).toEqual([])
|
||||
expect(passes).toHaveBeenCalledTimes(1)
|
||||
// The same handle issuing would reuse.
|
||||
expect(runtime['findHandleForPtyRecord']('kept')).toBe(keptHandle)
|
||||
}
|
||||
)
|
||||
|
||||
@@ -1,11 +1,5 @@
|
||||
import { createHash } from 'node:crypto'
|
||||
|
||||
import { mkdtempSync } from 'node:fs'
|
||||
|
||||
import { tmpdir } from 'node:os'
|
||||
|
||||
import { join } from 'node:path'
|
||||
|
||||
import { afterEach, expect, it } from 'vitest'
|
||||
|
||||
import { createRuntimeAgentProjections } from '../construction/runtime-agent-projections'
|
||||
@@ -143,66 +137,6 @@ function host(workers: number, path: string = ':memory:') {
|
||||
}
|
||||
}
|
||||
|
||||
it('follows each write that changes a worker, as a cold rebuild reads it', () => {
|
||||
const directory = mkdtempSync(join(tmpdir(), 'orca-sender-history-'))
|
||||
const h = host(3, join(directory, 'orchestration.db'))
|
||||
const step = (only = (_row: string) => true) => {
|
||||
const rows = h.rows(h.senders.build())
|
||||
expect(rows.filter(only)).toEqual(h.cold().filter(only))
|
||||
return rows
|
||||
}
|
||||
step()
|
||||
// A follow-up of a worker whose earlier lookup found none takes it to the follow-up's own
|
||||
// terminal in another pane; only that earlier miss, not any pane it read, says so.
|
||||
h.leaves.push({ ...MIRROR_LEAVES_STEP_1[0], tabId: 'tab-3', worktreeId: 'w', ptyId: 'pty-3' })
|
||||
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the publisher reads only these fields.
|
||||
h.ptys.push({
|
||||
ptyId: 'pty-3',
|
||||
incarnationId: 'inc-1',
|
||||
launchIncarnationId: 'inc-1',
|
||||
launchToken: token(3),
|
||||
worktreeId: 'w'
|
||||
} as RuntimePtyWorktreeRecord)
|
||||
step()
|
||||
const followUp = h.dispatch(3, 'follow-up')
|
||||
h.hold.run(`res-${followUp.id}`, followUp.id, followUp.id, pane(3), handle(3), 'pty-3:inc-1')
|
||||
step()
|
||||
h.db.db
|
||||
.prepare('UPDATE dispatch_contexts SET follow_up_of_dispatch_id = ? WHERE id = ?')
|
||||
.run(h.ids[0], followUp.id)
|
||||
expect(step()).not.toContain(`dispatch:${h.ids[0]}@${pane(3)}`)
|
||||
expect(step()).toContain(`dispatch:${h.ids[0]}@${pane(0)}`)
|
||||
// A terminal that moves to another pane takes its worker there.
|
||||
h.db.db
|
||||
.prepare(
|
||||
"UPDATE worker_terminal_resources SET pane_key = ?, process_incarnation = 'pty-2:inc-1' WHERE id = ?"
|
||||
)
|
||||
.run(pane(2), `res-${h.ids[1]}`)
|
||||
expect(step()).not.toContain(`dispatch:${h.ids[1]}@${pane(2)}`)
|
||||
// A respawned process under the same pane no longer holds its worker.
|
||||
// (A fresh publisher sees the new process as the handle's first, so only worker rows compare.)
|
||||
h.ptys[2] = { ...h.ptys[2], incarnationId: 'inc-2' }
|
||||
const dispatches = (row: string) => row.startsWith('dispatch:')
|
||||
expect(step(dispatches)).not.toContain(`dispatch:${h.ids[2]}@${pane(2)}`)
|
||||
h.db.db.prepare('DELETE FROM worker_terminal_resources WHERE id = ?').run(`res-${h.ids[0]}`)
|
||||
step(dispatches)
|
||||
// A rolled-back write marks nothing.
|
||||
const settled = h.senders.workForTest()
|
||||
const before = h.senders.build()
|
||||
h.db.db.exec('BEGIN')
|
||||
h.db.db.prepare("UPDATE worker_terminal_resources SET ownership_state = 'released'").run()
|
||||
h.db.db.exec('ROLLBACK')
|
||||
expect(h.senders.build()).toBe(before)
|
||||
expect(h.senders.workForTest().paneReads).toBe(settled.paneReads)
|
||||
// Another connection's commit, which no trigger here sees, rebuilds from the database.
|
||||
const other = new OrchestrationDb(join(directory, 'orchestration.db'))
|
||||
dbs.push(other)
|
||||
other.db
|
||||
.prepare("UPDATE worker_terminal_resources SET ownership_state = 'released' WHERE id = ?")
|
||||
.run(`res-${h.ids[1]}`)
|
||||
expect(step(dispatches)).not.toContain(`dispatch:${h.ids[1]}@${pane(2)}`)
|
||||
})
|
||||
|
||||
it('keeps nothing it read inside a transaction that rolls back', () => {
|
||||
const h = host(3)
|
||||
h.senders.build()
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import { HostAccountLaunchEnvParams } from '../../../../shared/host-account-launch-env'
|
||||
|
||||
import { RuntimeAccountController, type RuntimeAccountServices } from './runtime-account-controller'
|
||||
import { withHostAccountLaunchEnv } from '../../terminal/launch/runtime-agent-terminal-startup'
|
||||
|
||||
export function registerHostAccountLaunchEnvTests(): void {
|
||||
const LAUNCH_ENV = HostAccountLaunchEnvParams.parse({
|
||||
wslDistro: 'Ubuntu',
|
||||
claude: {
|
||||
CLAUDE_CONFIG_DIR: '/home/u/.orca/claude/a',
|
||||
ORCA_CLAUDE_INJECTED_CONFIG_DIR: '/home/u/.orca/claude/a',
|
||||
CODEX_HOME: '/home/u/.orca/codex/b'
|
||||
},
|
||||
terminal: {
|
||||
ORCA_CLAUDE_PROFILE_POINTER: '~/.orca/claude-pointer',
|
||||
CODEX_HOME: '/home/u/.orca/codex/b'
|
||||
}
|
||||
})
|
||||
|
||||
describe('RuntimeAccountController host launch env', () => {
|
||||
it('refuses where the host has account services of its own', () => {
|
||||
const accounts = new RuntimeAccountController()
|
||||
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: only presence is read.
|
||||
accounts.setServices({} as RuntimeAccountServices)
|
||||
expect(() => accounts.setHostLaunchEnv(LAUNCH_ENV)).toThrow(/its own provider accounts/)
|
||||
})
|
||||
})
|
||||
|
||||
describe('withHostAccountLaunchEnv', () => {
|
||||
it('keeps what the caller passed: its env and its own accountEnv win', () => {
|
||||
const requested = {
|
||||
env: { CODEX_HOME: '/caller' },
|
||||
accountEnv: { CLAUDE_CONFIG_DIR: '/hint' }
|
||||
}
|
||||
expect(
|
||||
withHostAccountLaunchEnv(requested, { env: requested.env }, LAUNCH_ENV.claude).env
|
||||
).toMatchObject({ CODEX_HOME: '/caller', CLAUDE_CONFIG_DIR: '/hint' })
|
||||
})
|
||||
})
|
||||
|
||||
describe('restoreHostLaunchEnv', () => {
|
||||
it('keeps applying a push whose save failed', () => {
|
||||
const accounts = new RuntimeAccountController()
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
accounts.restoreHostLaunchEnv(null, () => {
|
||||
throw new Error('disk full')
|
||||
})
|
||||
accounts.setHostLaunchEnv(LAUNCH_ENV)
|
||||
expect(accounts.hostLaunchEnvFor('claude')).toEqual(LAUNCH_ENV.claude)
|
||||
vi.restoreAllMocks()
|
||||
})
|
||||
})
|
||||
}
|
||||
@@ -3,7 +3,6 @@ import type { HostAccountSignInChannel } from '../../../../shared/host-account-s
|
||||
import { HostAccountSignInFlows, type HostAccountSignInRunner } from './host-account-sign-in-flows'
|
||||
|
||||
const CLAUDE_STATE = { accounts: [], activeAccountId: null }
|
||||
const PROMPT = { url: 'https://claude.com/cai/oauth/authorize?code=true', userCode: null }
|
||||
|
||||
function controllableRunner() {
|
||||
let channel: HostAccountSignInChannel | null = null
|
||||
@@ -33,33 +32,6 @@ afterEach(() => {
|
||||
})
|
||||
|
||||
describe('HostAccountSignInFlows', () => {
|
||||
it('relays the link to the starting client and the pasted code back to the login', async () => {
|
||||
const runner = controllableRunner()
|
||||
const flows = new HostAccountSignInFlows(runner.run, 'linux')
|
||||
const started = flows.start('device-a', 'claude')
|
||||
expect(started.phase).toBe('starting')
|
||||
expect(runner.run).toHaveBeenCalledOnce()
|
||||
|
||||
runner.channel().onPrompt({ ...PROMPT, needsCode: true })
|
||||
const waiting = await flows.wait('device-a', started.flowId, started.revision)
|
||||
expect(waiting).toMatchObject({
|
||||
phase: 'waiting',
|
||||
prompt: { url: PROMPT.url, needsCode: true }
|
||||
})
|
||||
|
||||
const code = runner.channel().nextCode()
|
||||
expect(flows.submitCode('device-a', started.flowId, 'abc#state').phase).toBe('verifying')
|
||||
await expect(code).resolves.toBe('abc#state')
|
||||
expect(() => flows.submitCode('device-a', started.flowId, 'again')).toThrow(
|
||||
'not waiting for a code'
|
||||
)
|
||||
|
||||
runner.finish.resolve()
|
||||
const done = await flows.wait('device-a', started.flowId, waiting.revision + 1)
|
||||
expect(done).toMatchObject({ phase: 'signedIn', claude: CLAUDE_STATE })
|
||||
expect(done.prompt).toBeUndefined()
|
||||
})
|
||||
|
||||
it('keeps one client from reading, answering or cancelling another client’s sign-in', async () => {
|
||||
const runner = controllableRunner()
|
||||
const flows = new HostAccountSignInFlows(runner.run, 'linux')
|
||||
@@ -100,41 +72,6 @@ describe('HostAccountSignInFlows', () => {
|
||||
})
|
||||
})
|
||||
|
||||
it('says another account change stopped it when nobody here cancelled', async () => {
|
||||
const flows = new HostAccountSignInFlows(async () => {
|
||||
throw new Error('Codex sign-in was cancelled.')
|
||||
}, 'linux')
|
||||
const { flowId } = flows.start('device-a', 'codex')
|
||||
expect(await flows.wait('device-a', flowId, 1)).toMatchObject({
|
||||
phase: 'failed',
|
||||
error: 'An account change on this host stopped the sign-in. Start it again.',
|
||||
errorCode: 'superseded'
|
||||
})
|
||||
})
|
||||
|
||||
it('ignores a published page that is not the provider’s own sign-in host', async () => {
|
||||
const runner = controllableRunner()
|
||||
const flows = new HostAccountSignInFlows(runner.run, 'linux')
|
||||
const { flowId, revision } = flows.start('device-a', 'claude')
|
||||
expect(runner.run).toHaveBeenCalledOnce()
|
||||
runner
|
||||
.channel()
|
||||
.onPrompt({ url: 'https://evil.test/?code=true', userCode: null, needsCode: true })
|
||||
expect((await flows.wait('device-a', flowId, 0)).revision).toBe(revision)
|
||||
await flows.cancel('device-a', flowId)
|
||||
})
|
||||
|
||||
it('reports a failed login with its message, stripped of terminal escapes', async () => {
|
||||
const flows = new HostAccountSignInFlows(async () => {
|
||||
throw new Error('Codex login failed: \u001b[31mboom\u001b[0m')
|
||||
}, 'darwin')
|
||||
const { flowId } = flows.start('device-a', 'codex')
|
||||
const status = await flows.wait('device-a', flowId, 1)
|
||||
expect(status).toMatchObject({ phase: 'failed', error: 'Codex login failed: boom' })
|
||||
// The login's own text has no Orca code, so clients show it verbatim.
|
||||
expect(status.errorCode).toBeUndefined()
|
||||
})
|
||||
|
||||
it('ends a sign-in whose client stopped asking about it', async () => {
|
||||
vi.useFakeTimers()
|
||||
const runner = controllableRunner()
|
||||
@@ -145,11 +82,4 @@ describe('HostAccountSignInFlows', () => {
|
||||
const status = await flows.wait('device-a', flowId, 0)
|
||||
expect(status).toMatchObject({ phase: 'failed', error: expect.stringContaining('stopped') })
|
||||
})
|
||||
|
||||
it('refuses on a Windows host, whose logins need a console of their own', () => {
|
||||
const runner = controllableRunner()
|
||||
const flows = new HostAccountSignInFlows(runner.run, 'win32')
|
||||
expect(() => flows.start('device-a', 'claude')).toThrow('orca account add')
|
||||
expect(runner.run).not.toHaveBeenCalled()
|
||||
})
|
||||
})
|
||||
|
||||
@@ -13,7 +13,7 @@ import {
|
||||
openTestAgentSessionRecordStore,
|
||||
seedTestAgentSessionRecordStore
|
||||
} from './agent-session-record-store-test-harness'
|
||||
import { proveAgentSessionOwner, withLease } from '../ownership/agent-session-lease-transitions'
|
||||
import '../ownership/agent-session-lease-transitions'
|
||||
|
||||
const RECEIVING_A = '/qa/claude-profiles/qa-a/home'
|
||||
|
||||
@@ -109,61 +109,4 @@ describe('actual acquired account receipt in the fenced record owner', () => {
|
||||
await f.dispose()
|
||||
}
|
||||
})
|
||||
|
||||
it('does not confuse known failed reservation cleanup with an unrecorded successful older acquisition', async () => {
|
||||
const f = await releasedFixture()
|
||||
try {
|
||||
const reserved = withLease(f.released, {
|
||||
...f.released.lease,
|
||||
runtimeFence: f.released.lease.runtimeFence + 1,
|
||||
claimStatus: 'reserved',
|
||||
handoffStage: 'new-owner-proving',
|
||||
ownerProcess: null,
|
||||
reservedSpawnToken: 'next',
|
||||
unreconciled: false
|
||||
})
|
||||
const failed = withLease(reserved, {
|
||||
...reserved.lease,
|
||||
runtimeFence: reserved.lease.runtimeFence + 1,
|
||||
claimStatus: 'released',
|
||||
handoffStage: null,
|
||||
reservedSpawnToken: null,
|
||||
deathEvidence: {
|
||||
kind: 'exit-observed',
|
||||
detail: 'observed process exit',
|
||||
observedAt: 50_000,
|
||||
ownerFence: reserved.lease.runtimeFence
|
||||
}
|
||||
})
|
||||
expect(acquiredAgentSessionAccount(failed)?.recipe.home).toBe(RECEIVING_A)
|
||||
const process = { hostId: 'local', pid: 4242, processStartTimeMs: 50_000, spawnToken: 'next' }
|
||||
const proving = withLease(reserved, { ...reserved.lease, ownerProcess: process })
|
||||
// Older proof preserves unknown extension bytes but does not observe the successful new construction.
|
||||
const olderProof = proveAgentSessionOwner({
|
||||
record: proving,
|
||||
fence: proving.lease.runtimeFence,
|
||||
now: 50_001,
|
||||
leaseTtlMs: 30_000
|
||||
})
|
||||
expect(acquiredAgentSessionAccount(olderProof)).toBeNull()
|
||||
const olderRelease = {
|
||||
...olderProof,
|
||||
lease: {
|
||||
...olderProof.lease,
|
||||
runtimeFence: olderProof.lease.runtimeFence + 1,
|
||||
claimStatus: 'released' as const,
|
||||
ownerProcess: null
|
||||
}
|
||||
}
|
||||
expect(acquiredAgentSessionAccount(olderRelease)).toBeNull()
|
||||
expect(withAcquiredAgentSessionAccount(olderProof, undefined)).not.toHaveProperty(
|
||||
'acquiredAccount'
|
||||
)
|
||||
expect(
|
||||
acquiredAgentSessionAccount({ ...f.released, acquiredAccount: { version: 900 } })
|
||||
).toBeNull()
|
||||
} finally {
|
||||
await f.dispose()
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import { composeWorktreeHostIdentity } from '../../../../shared/worktree/host-qualified-identity'
|
||||
import '../../../../shared/worktree/host-qualified-identity'
|
||||
import '../../../../shared/ai-vault/search/ai-vault-search-test-fixture'
|
||||
import '../../../ai-vault/structured-session-ownership.test-support'
|
||||
import '../../../ai-vault/structured-session-ownership'
|
||||
import { hostTestState } from '../../../native-chat/agent-session-wire/host/testing/structured-agent-session-host-test-harness'
|
||||
import { StructuredAgentSessionHost } from '../../../native-chat/agent-session-wire/host/structured-agent-session-host'
|
||||
import { setStructuredAgentSessionHost } from '../../../native-chat/agent-session-wire/host/structured-agent-session-registry'
|
||||
import * as journalFactory from '../../../native-chat/agent-session-journal/journal-store-factory'
|
||||
import '../../../native-chat/agent-session-journal/journal-store-factory'
|
||||
import { openTestJournalHostDatabase } from '../../../native-chat/agent-session-journal/store-lifecycle/journal-host-database-test-support'
|
||||
import {
|
||||
countRecordQueries,
|
||||
countStoreWork,
|
||||
scaleJournal,
|
||||
scaleStore,
|
||||
scaleDirectory,
|
||||
scaleRecord
|
||||
} from './agent-session-scale.test-fixture'
|
||||
import { findWorkspaceReferences } from '../../workspaces/references/runtime-reference-find'
|
||||
import { parseWorkspaceReferenceUrl } from '../../../../shared/workspace-attachments/workspace-reference-identity'
|
||||
import { countStoreWork, scaleDirectory, scaleRecord } from './agent-session-scale.test-fixture'
|
||||
import '../../workspaces/references/runtime-reference-find'
|
||||
import '../../../../shared/workspace-attachments/workspace-reference-identity'
|
||||
import { createReferenceAgentIndex } from '../../workspaces/references/runtime-reference-agents'
|
||||
import {
|
||||
seedTestAgentSessionRecordStore,
|
||||
@@ -39,28 +32,13 @@ import {
|
||||
structuredWorkerIdentities,
|
||||
structuredWorkerProcessIncarnation
|
||||
} from '../../orchestration/terminal-authority/structured-sessions/structured-worker-identity'
|
||||
import {
|
||||
openAgentSessionRecordStoreOnce,
|
||||
releaseAgentSessionRecordStore
|
||||
} from './agent-session-record-store-slot'
|
||||
import { createStructuredAgentSessionLogger } from '../../../native-chat/agent-session-wire/host/structured-agent-session-logger'
|
||||
import './agent-session-record-store-slot'
|
||||
import '../../../native-chat/agent-session-wire/host/structured-agent-session-logger'
|
||||
import type { AgentSessionRecord } from '../../../../shared/agent-session/lifecycle/agent-session-record'
|
||||
import { conversationRecordReader } from '../../orchestration/addressing/session-lineage/structured-session-lineage'
|
||||
import '../structured-agent-session-create-adoption'
|
||||
import { listStructuredSessionsForWorktree } from '../../workspaces/removal/structured-session-worktree-teardown'
|
||||
import * as membership from './agent-session-store-state'
|
||||
|
||||
// Uses the complete host harness; discovery, mail reach and every store read execute unchanged.
|
||||
async function inventoryRig(n: number) {
|
||||
const rig = await scaleStore(n)
|
||||
const host = new StructuredAgentSessionHost({
|
||||
...hostTestState().host.deps,
|
||||
store: rig.store,
|
||||
journalDatabase: openTestJournalHostDatabase(rig.root)
|
||||
})
|
||||
setStructuredAgentSessionHost(host)
|
||||
return { ...rig, host }
|
||||
}
|
||||
import '../../workspaces/removal/structured-session-worktree-teardown'
|
||||
import './agent-session-store-state'
|
||||
|
||||
const referenceRuntime = {
|
||||
getOrchestrationFleetAgentStatusSnapshot: () => [],
|
||||
@@ -260,166 +238,4 @@ describe('real conversation inventory work', () => {
|
||||
db.close()
|
||||
}
|
||||
})
|
||||
|
||||
it('uses the opened cold inventory without importing its predecessor into absent global identity', async () => {
|
||||
const root = await scaleDirectory()
|
||||
const predecessor = testOrcaSessionId('cold-root')
|
||||
const successor = testOrcaSessionId('cold-successor')
|
||||
await seedTestAgentSessionRecordStore(root, {
|
||||
records: [clearedRecord(predecessor, successor), scaleRecord(successor)],
|
||||
sessionTabs: [{ tabId: 'cold-tab', sessionId: successor }]
|
||||
})
|
||||
const opened = await openAgentSessionRecordStoreOnce({
|
||||
legacySessionTabIds: [],
|
||||
stateDirectory: root,
|
||||
hostId: 'local',
|
||||
logger: createStructuredAgentSessionLogger()
|
||||
})
|
||||
const db = new OrchestrationDb(':memory:')
|
||||
try {
|
||||
const run = db.createRun({
|
||||
objective: 'cold identity',
|
||||
coordinatorHandle: null,
|
||||
coordinatorPaneKey: null
|
||||
})
|
||||
db.createDispatchContext({
|
||||
taskId: db.createTask({ runId: run.id, spec: 'predecessor' }).id,
|
||||
assigneeHandle: mintStructuredWorkerHandle(),
|
||||
processIncarnation: structuredWorkerProcessIncarnation(predecessor),
|
||||
creator: { kind: 'system' },
|
||||
maxDepth: Number.MAX_SAFE_INTEGER
|
||||
})
|
||||
for (const index of [
|
||||
createReferenceAgentIndex(referenceRuntime, db),
|
||||
createReferenceAgentIndex(referenceRuntime, db, conversationRecordReader(opened.store))
|
||||
]) {
|
||||
expect([...index.values()].flat()).toMatchObject([
|
||||
{
|
||||
sessionId: successor,
|
||||
mailbox: `orca_session_id:${successor}`,
|
||||
liveness: 'unverifiable'
|
||||
}
|
||||
])
|
||||
}
|
||||
expect(resolveOrcaSessionParty(successor, db)).toMatchObject({
|
||||
orcaSessionId: successor,
|
||||
terminalHandle: null
|
||||
})
|
||||
} finally {
|
||||
db.close()
|
||||
const released = await releaseAgentSessionRecordStore()
|
||||
await released?.journalDatabase.close()
|
||||
}
|
||||
})
|
||||
|
||||
it.each([10, 100])(
|
||||
'finds all references at %i rows without allocating membership payloads',
|
||||
async (n) => {
|
||||
const rig = await inventoryRig(n)
|
||||
const work = countStoreWork(rig.store)
|
||||
const queries = countRecordQueries(rig.root)
|
||||
const visits = vi.spyOn(membership, 'hasAgentSessionConversation')
|
||||
let index: ReturnType<typeof createReferenceAgentIndex> = new Map()
|
||||
const result = await findWorkspaceReferences(
|
||||
{ query: 'STA-1234' },
|
||||
{
|
||||
workspaces: ['workspace-1', 'other'].map((id) => ({
|
||||
id,
|
||||
hostId: 'local' as const,
|
||||
name: id,
|
||||
repo: 'repo',
|
||||
kind: 'worktree' as const,
|
||||
isArchived: false,
|
||||
linkedItems: [parseWorkspaceReferenceUrl('https://linear.app/acme/issue/STA-1234')]
|
||||
})),
|
||||
agents: (workspaceKeys) => {
|
||||
index = createReferenceAgentIndex(
|
||||
referenceRuntime,
|
||||
null,
|
||||
conversationRecordReader(rig.store),
|
||||
workspaceKeys
|
||||
)
|
||||
return index
|
||||
}
|
||||
}
|
||||
)
|
||||
expect(result.matches.flatMap((match) => match.agents)).toHaveLength(n + 1)
|
||||
const found = [...index.values()].flat()
|
||||
expect(found.map((row) => row.sessionId).sort()).toEqual(
|
||||
rig.rows
|
||||
.filter((row) => !['closed-chat', 'malformed-chat'].includes(row.sessionId))
|
||||
.map((row) => row.sessionId)
|
||||
.sort()
|
||||
)
|
||||
expect(index.get(composeWorktreeHostIdentity('local', 'workspace-1'))).toHaveLength(n / 2 + 1)
|
||||
expect(found.every((row) => row.liveness === 'unverifiable')).toBe(true)
|
||||
expect(found.find((row) => row.sessionId === 'damaged-chat')?.sessionIds).toContain(
|
||||
'provider-damaged-chat-0'
|
||||
)
|
||||
expect(work.counts).toMatchObject({
|
||||
views: 4 * n + 2,
|
||||
inventories: 2,
|
||||
keyed: 2 * (n + 1),
|
||||
// Each mail-reach check asks the keyed retirement read; one index read remains.
|
||||
tabReads: 1,
|
||||
clones: 0,
|
||||
decodes: 0
|
||||
})
|
||||
// Keyed: the visible-tab list built once, then one membership question per row.
|
||||
expect(visits).toHaveBeenCalledTimes(2 * n + 3)
|
||||
expect(queries()).toEqual({ executions: 0, rows: 0 })
|
||||
work.reset()
|
||||
visits.mockClear()
|
||||
expect(rig.store.getVisibleSessionTabIndex().sessionIds).toHaveLength(n + 1)
|
||||
await rig.store.showSessionTabs([
|
||||
'closed-chat',
|
||||
'damaged-chat',
|
||||
'malformed-chat',
|
||||
'missing-chat'
|
||||
])
|
||||
expect(rig.store.getVisibleSessionTabIndex().sessionIds).toContain('closed-chat')
|
||||
expect(rig.store.getVisibleSessionTabIndex().sessionIds).not.toContain('malformed-chat')
|
||||
expect(work.counts.views).toBe(0)
|
||||
await expect(rig.store.setSessionTabVisibility('malformed-chat', true)).rejects.toThrow()
|
||||
expect(work.counts.views).toBe(0)
|
||||
}
|
||||
)
|
||||
|
||||
it.each([10, 100])(
|
||||
'seeds selected records without opening journals and scopes lifecycle inventory at %i rows',
|
||||
async (n) => {
|
||||
const rig = await inventoryRig(n)
|
||||
for (const id of ['damaged-chat', rig.rows[0]!.sessionId, rig.rows[1]!.sessionId]) {
|
||||
await (await scaleJournal(rig.root, id)).close()
|
||||
}
|
||||
const work = countStoreWork(rig.store)
|
||||
const queries = countRecordQueries(rig.root)
|
||||
const openJournal = vi.spyOn(journalFactory, 'openAgentSessionJournal')
|
||||
await rig.host.seedSessionTabs(['damaged-chat', rig.rows[0]!.sessionId])
|
||||
expect(openJournal).not.toHaveBeenCalled()
|
||||
expect(rig.host.hasSession(rig.rows[0]!.sessionId)).toBe(false)
|
||||
expect(work.counts).toMatchObject({ inventories: 0, views: 1, keyed: 2, clones: 0 })
|
||||
work.reset()
|
||||
const scoped = listStructuredSessionsForWorktree('workspace-1', {
|
||||
resolvedConnectionId: null
|
||||
})
|
||||
expect(scoped.members).toHaveLength(n / 2 + 2)
|
||||
expect(scoped.live).toEqual([])
|
||||
expect(scoped.members.some((row) => row.sessionId === 'damaged-chat')).toBe(true)
|
||||
expect(work.counts).toMatchObject({ inventories: 1, views: n + 1 + n / 2 + 1, clones: 0 })
|
||||
work.reset()
|
||||
const slept = await rig.host.sleepWorkspace('workspace-1')
|
||||
expect(slept.stoppedSessionIds).not.toContain('damaged-chat')
|
||||
expect(slept.failures?.some((row) => row.sessionId === 'damaged-chat')).toBe(true)
|
||||
expect(work.counts.inventories).toBe(1)
|
||||
// One inventory and six checked observations per selected healthy member.
|
||||
expect(work.counts.views).toBe(n + 1 + 6 * (n / 2 + 1))
|
||||
expect(rig.store.getConversation(rig.rows[1]!.sessionId)?.location.workspaceId).toBe('other')
|
||||
work.reset()
|
||||
expect(rig.host.knownAgentIds()).toContain('claude')
|
||||
expect(work.counts).toMatchObject({ inventories: 1, views: n + 1, clones: 0 })
|
||||
expect(queries()).toEqual({ executions: 0, rows: 0 })
|
||||
expect(hostTestState().acquire).not.toHaveBeenCalled()
|
||||
}
|
||||
)
|
||||
})
|
||||
|
||||
@@ -6,13 +6,8 @@ import { OrcaRuntimeService } from '../../orca-runtime'
|
||||
|
||||
import { electronMocks } from '../../orca-runtime-test-mocks/setup.spec'
|
||||
|
||||
import {
|
||||
TEST_WORKTREE_ID,
|
||||
makeRuntimeStoreWithWorkspaceSession,
|
||||
store
|
||||
} from '../../orca-runtime-tests/orca-runtime-test-fixtures.spec'
|
||||
|
||||
import { getDefaultWorkspaceSession } from '../../../../shared/constants'
|
||||
import { TEST_WORKTREE_ID, store } from '../../orca-runtime-tests/orca-runtime-test-fixtures.spec'
|
||||
import '../../../../shared/constants'
|
||||
|
||||
import type { BrowserTabInfo } from '../../../../shared/runtime-browser-contracts'
|
||||
import type { RuntimeMobileSessionBrowserTab } from '../../../../shared/runtime-mobile-session-tab-contracts'
|
||||
@@ -122,40 +117,6 @@ it('finishes an offscreen close against the latest renderer revision without los
|
||||
expect((await list()).tabs.map((tab) => tab.id)).toEqual(['renderer-tab'])
|
||||
})
|
||||
|
||||
it('rebases omitted renderer publications and accepts their return without reviving dead pages', async () => {
|
||||
const { runtime, livePages, sync, addPage, list } = browserRuntime()
|
||||
sync([publication()])
|
||||
addPage('runtime-live')
|
||||
addPage('runtime-dead')
|
||||
runtime.notifyMobileSessionTabsChanged(TEST_WORKTREE_ID)
|
||||
expect((await list()).tabs).toHaveLength(3)
|
||||
livePages.delete('runtime-dead')
|
||||
|
||||
sync([])
|
||||
const detached = await list()
|
||||
expect(detached.publicationEpoch).toMatch(/^headless-hydrated:/)
|
||||
expect(detached.tabs.map((tab) => tab.id)).toEqual(['runtime-live'])
|
||||
expect(runtime['acceptedRendererMobileSnapshotByWorktree'].has(TEST_WORKTREE_ID)).toBe(false)
|
||||
|
||||
sync([publication()])
|
||||
const returned = await list()
|
||||
expect(returned.publicationEpoch).toBe('renderer-1')
|
||||
expect(returned.tabs.map((tab) => tab.id)).toEqual(['renderer-tab', 'runtime-live'])
|
||||
expect(returned.snapshotVersion).toBeGreaterThan(detached.snapshotVersion)
|
||||
expect(runtime['isRendererOwnedMobileBrowserTab'](publication(), rendererTab)).toBe(true)
|
||||
|
||||
livePages.clear()
|
||||
sync([publication()])
|
||||
expect((await list()).tabs.map((tab) => tab.id)).toEqual(['renderer-tab'])
|
||||
sync([publication('renderer-2')])
|
||||
await expect(
|
||||
runtime.closeMobileSessionTab(`id:${TEST_WORKTREE_ID}`, rendererTab.id, {
|
||||
expectedPublicationEpoch: 'renderer-1'
|
||||
})
|
||||
).resolves.toMatchObject({ refused: true, refusalReason: 'stale-publication' })
|
||||
expect((await list()).publicationEpoch).toBe('renderer-2')
|
||||
})
|
||||
|
||||
it('does not tombstone a renderer browser when the acknowledged close fails', async () => {
|
||||
const { runtime, sync, list } = browserRuntime()
|
||||
sync([publication()])
|
||||
@@ -185,35 +146,6 @@ it('does not tombstone a renderer browser when the acknowledged close fails', as
|
||||
expect((await list()).tabs.map((tab) => tab.id)).toEqual(['renderer-tab'])
|
||||
})
|
||||
|
||||
it('lists only pages the offscreen backend owns when the bridge also lists desktop webviews', async () => {
|
||||
const closeTab = vi.fn(async (_pageId: string) => {})
|
||||
// A saved workspace session sends list and graph sync through hydrate's runtime-owned merge.
|
||||
const { runtimeStore } = makeRuntimeStoreWithWorkspaceSession(getDefaultWorkspaceSession())
|
||||
const { runtime, sync, addPage, addDesktopPage, list } = browserRuntime(closeTab, runtimeStore)
|
||||
sync([publication()])
|
||||
addDesktopPage('renderer-page')
|
||||
// A background page of the same desktop browser workspace is absent from the renderer's publication.
|
||||
addDesktopPage('background-desktop-page')
|
||||
addPage('separate-runtime-page')
|
||||
runtime.notifyMobileSessionTabsChanged(TEST_WORKTREE_ID)
|
||||
await list()
|
||||
sync([publication('renderer-1', 2)])
|
||||
runtime.notifyMobileSessionTabsChanged(TEST_WORKTREE_ID)
|
||||
|
||||
const snapshot = await list()
|
||||
expect(snapshot.tabs.map((tab) => tab.id)).toEqual(['renderer-tab', 'separate-runtime-page'])
|
||||
expect(snapshot.publicationEpoch).toBe('renderer-1')
|
||||
expect(snapshot.tabGroups?.flatMap((group) => group.tabOrder)).toEqual([
|
||||
'renderer-tab',
|
||||
'separate-runtime-page'
|
||||
])
|
||||
await expect(
|
||||
runtime.closeMobileSessionTab(`id:${TEST_WORKTREE_ID}`, 'separate-runtime-page')
|
||||
).resolves.toMatchObject({ closed: true })
|
||||
expect(closeTab).toHaveBeenCalledWith('separate-runtime-page')
|
||||
expect(closeTab).not.toHaveBeenCalledWith(rendererTab.browserPageId)
|
||||
})
|
||||
|
||||
it('keeps a replacement client page through a stale placement retirement and retires only the live generation', async () => {
|
||||
const { runtime, sync, list } = browserRuntime()
|
||||
sync([publication()])
|
||||
|
||||
@@ -97,14 +97,4 @@ describe('served browser tabs in a layout-owner build', () => {
|
||||
expect(host.session().browserPagesByWorkspace?.['page-1']).toBeUndefined()
|
||||
expect(host.tabs.listUnstarted(WT)).toEqual([])
|
||||
})
|
||||
|
||||
it('stops listing a closed tab before main answers', async () => {
|
||||
const host = servedHost()
|
||||
host.tabs.opened(PAGE)
|
||||
await settle()
|
||||
|
||||
host.tabs.closed(WT, 'page-1')
|
||||
|
||||
expect(host.tabs.listUnstarted(WT)).toEqual([])
|
||||
})
|
||||
})
|
||||
|
||||
@@ -88,25 +88,6 @@ function browserStrip(
|
||||
}
|
||||
|
||||
describe('client session-tab selection', () => {
|
||||
it('namespaces projections by device and discards revoked state', () => {
|
||||
const store = new ClientSessionTabSelectionStore()
|
||||
const initial = snapshot()
|
||||
|
||||
store.project(initial, 'device-a')
|
||||
store.project(initial, 'device-b')
|
||||
const selectedA = store.activate(initial, 'device-a', 'browser-unified')
|
||||
|
||||
expect(selectedA.activeTabId).toBe('browser-unified')
|
||||
expect(selectedA.publicationEpoch).toBe('renderer:1:client-navigation')
|
||||
expect(selectedA.snapshotVersion).toBe(2)
|
||||
expect(store.project(initial, 'device-b').activeTabId).toBe('terminal-a::leaf-a')
|
||||
const selectedAgain = store.activate(initial, 'device-a', 'terminal-a::leaf-b')
|
||||
expect(selectedAgain.snapshotVersion).toBe(3)
|
||||
expect(selectedAgain.activeTabId).toBe('terminal-a::leaf-b')
|
||||
store.forgetClient('device-a')
|
||||
expect(store.project(initial, 'device-a').activeTabId).toBe('terminal-a::leaf-a')
|
||||
})
|
||||
|
||||
it('does not restore a closed tab from a stale pre-close snapshot', () => {
|
||||
const store = new ClientSessionTabSelectionStore()
|
||||
const full = snapshot()
|
||||
|
||||
-21
@@ -67,24 +67,3 @@ it('selects a launched terminal for the caller only, without spawning again', as
|
||||
)
|
||||
expect(spawn).toHaveBeenCalledTimes(2)
|
||||
})
|
||||
|
||||
it('selects a launched chat by its session for the caller only', async () => {
|
||||
const { runtime, caller } = pairedRuntime()
|
||||
const first = await createPane(runtime)
|
||||
await runtime.publishStructuredAgentSessionTab({
|
||||
workspaceId: WT,
|
||||
sessionId: 'sess-1',
|
||||
agent: 'claude',
|
||||
activate: false
|
||||
})
|
||||
|
||||
expect(
|
||||
runtime.selectCreatedMobileSessionTabForClient(WT, { sessionId: 'sess-1' }, 'device-caller')
|
||||
).toBe(true)
|
||||
|
||||
expect(caller.at(-1)?.activeTabId).toBe('agent-session:sess-1')
|
||||
expect((await runtime.listMobileSessionTabs(`id:${WT}`)).activeTabId).toBe(first.id)
|
||||
expect((await runtime.listMobileSessionTabs(`id:${WT}`, 'device-bystander')).activeTabId).toBe(
|
||||
first.id
|
||||
)
|
||||
})
|
||||
|
||||
@@ -1,20 +1,8 @@
|
||||
import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs'
|
||||
import { writeFile, rename } from 'node:fs/promises'
|
||||
import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
|
||||
import { tmpdir } from 'node:os'
|
||||
import { join } from 'node:path'
|
||||
import { afterEach, expect, it, vi } from 'vitest'
|
||||
import { DesktopChatCreationHistory } from './desktop-chat-creation-history'
|
||||
import type * as NodeFs from 'node:fs'
|
||||
import type * as NodeFsPromises from 'node:fs/promises'
|
||||
|
||||
vi.mock('node:fs', async (original) => {
|
||||
const fs = await original<typeof NodeFs>()
|
||||
return { ...fs, readFileSync: vi.fn(fs.readFileSync) }
|
||||
})
|
||||
vi.mock('node:fs/promises', async (original) => {
|
||||
const fs = await original<typeof NodeFsPromises>()
|
||||
return { ...fs, writeFile: vi.fn(fs.writeFile), rename: vi.fn(fs.rename) }
|
||||
})
|
||||
|
||||
const roots: string[] = []
|
||||
afterEach(() => {
|
||||
@@ -58,65 +46,3 @@ it('treats unreadable history as unknown and never vetoes a create when its writ
|
||||
await history.recordCreate('ssh', 'agentSession.create', { envelope: { sessionId: 'chat' } })
|
||||
expect(new DesktopChatCreationHistory(path).sessionIds()).toEqual(['chat'])
|
||||
})
|
||||
|
||||
it.each([1_000, 10_000])(
|
||||
'bounds drained creation work with %i retained memberships',
|
||||
async (size) => {
|
||||
const path = root()
|
||||
const ids = Array.from({ length: size - 1 }, (_, i) => `saved-${i}`)
|
||||
writeFileSync(
|
||||
join(path, 'desktop-chat-creation-history.json'),
|
||||
JSON.stringify({ ssh: ids, alias: ['saved-0'] })
|
||||
)
|
||||
vi.mocked(readFileSync).mockClear()
|
||||
vi.mocked(writeFile).mockClear()
|
||||
vi.mocked(rename).mockClear()
|
||||
const history = new DesktopChatCreationHistory(path)
|
||||
let serializedMemberships = 0
|
||||
const stringify = JSON.stringify
|
||||
const serialization = vi
|
||||
.spyOn(JSON, 'stringify')
|
||||
.mockImplementation((value, replacer, space) => {
|
||||
if (
|
||||
value &&
|
||||
typeof value === 'object' &&
|
||||
'ssh' in value &&
|
||||
Array.isArray(value.ssh) &&
|
||||
Array.isArray(value.alias)
|
||||
) {
|
||||
serializedMemberships += value.ssh.length + value.alias.length
|
||||
}
|
||||
return stringify(value, replacer, space)
|
||||
})
|
||||
await history.recordCreate('ssh', 'agentSession.create', { envelope: { sessionId: 'saved-0' } })
|
||||
expect(writeFile).not.toHaveBeenCalled()
|
||||
expect(rename).not.toHaveBeenCalled()
|
||||
for (let i = 0; i < 10; i++) {
|
||||
await history.recordCreate('ssh', 'agentSession.create', {
|
||||
envelope: { sessionId: `new-${i}` }
|
||||
})
|
||||
}
|
||||
serialization.mockRestore()
|
||||
expect(readFileSync).toHaveBeenCalledTimes(1)
|
||||
expect(writeFile).toHaveBeenCalledTimes(10)
|
||||
expect(rename).toHaveBeenCalledTimes(10)
|
||||
// Distinct creates still serialize whole snapshots; unchanged bytes skip only disk replacement.
|
||||
expect(serializedMemberships).toBeGreaterThan(0)
|
||||
expect(serializedMemberships).toBeLessThanOrEqual(11 * size + 55)
|
||||
let visits = 0
|
||||
const iterate = Set.prototype[Symbol.iterator]
|
||||
const union = vi.spyOn(Set.prototype, Symbol.iterator).mockImplementation(function* (
|
||||
this: Set<unknown>
|
||||
) {
|
||||
for (const id of iterate.call(this)) {
|
||||
visits++
|
||||
yield id
|
||||
}
|
||||
return undefined
|
||||
})
|
||||
const all = history.sessionIds()
|
||||
union.mockRestore()
|
||||
expect(visits).toBeLessThanOrEqual(2 * (size + 10))
|
||||
expect(all).toEqual([...ids, ...Array.from({ length: 10 }, (_, i) => `new-${i}`)])
|
||||
}
|
||||
)
|
||||
|
||||
-40
@@ -6,7 +6,6 @@ import { join } from 'node:path'
|
||||
import { afterEach, describe, expect, it, onTestFinished, vi } from 'vitest'
|
||||
import { parsePairingCode } from '../../../../shared/remote-runtime/pairing/pairing'
|
||||
import type { RuntimeMobileSessionTabsResult } from '../../../../shared/runtime-session-contracts'
|
||||
import type { PersistedMobileClientTabSelections } from '../../../../shared/persisted-state-types'
|
||||
import { OrcaRuntimeService } from '../../orca-runtime'
|
||||
import { OrcaRuntimeRpcServer } from '../../rpc/server/runtime-rpc'
|
||||
import {
|
||||
@@ -578,43 +577,4 @@ describe('paired runtime navigation isolation', () => {
|
||||
).toEqual(['follow', 'follow'])
|
||||
expect(harness.hostSelections.tabId).toBe('client-a-tab')
|
||||
})
|
||||
|
||||
it('restores a device tab selection after a runtime restart', async () => {
|
||||
const persisted: { state: PersistedMobileClientTabSelections } = { state: {} }
|
||||
const makeStoreWithSelections = () => ({
|
||||
...makeStore(),
|
||||
getMobileClientTabSelections: () => persisted.state,
|
||||
setMobileClientTabSelections: (next: PersistedMobileClientTabSelections) => {
|
||||
persisted.state = next
|
||||
}
|
||||
})
|
||||
|
||||
const first = new OrcaRuntimeService(makeStoreWithSelections() as never)
|
||||
first.attachWindow(1)
|
||||
first.markGraphReady(1)
|
||||
seedSessionTabs(first)
|
||||
await first.activateMobileSessionTab(`id:${SESSION_WORKTREE_ID}`, 'client-a-tab', undefined, {
|
||||
notifyClients: false,
|
||||
clientNavigationId: 'device-a',
|
||||
navigation: 'caller'
|
||||
})
|
||||
expect(persisted.state['device-a']?.[SESSION_WORKTREE_ID]?.activeTabId).toBe('client-a-tab')
|
||||
|
||||
const restarted = new OrcaRuntimeService(makeStoreWithSelections() as never)
|
||||
restarted.attachWindow(1)
|
||||
restarted.markGraphReady(1)
|
||||
seedSessionTabs(restarted)
|
||||
const remembered = await restarted.listMobileSessionTabs(
|
||||
`id:${SESSION_WORKTREE_ID}`,
|
||||
'device-a'
|
||||
)
|
||||
expect(remembered.activeTabId).toBe('client-a-tab')
|
||||
expect(remembered.tabs.find((tab) => tab.isActive)?.id).toBe('client-a-tab')
|
||||
// Unknown devices inherit the host view, never another device's restored state.
|
||||
const freshDevice = await restarted.listMobileSessionTabs(
|
||||
`id:${SESSION_WORKTREE_ID}`,
|
||||
'device-b'
|
||||
)
|
||||
expect(freshDevice.activeTabId).toBe('host-tab')
|
||||
})
|
||||
})
|
||||
|
||||
@@ -32,21 +32,6 @@ describe('subscription registration versions', () => {
|
||||
}
|
||||
)
|
||||
|
||||
it('still refuses a different connection with a current registration version', async () => {
|
||||
const registry = new RuntimeSubscriptionRegistry()
|
||||
const cleanup = vi.fn()
|
||||
registry.register('terminal:owned', cleanup, 'conn-a')
|
||||
expect(
|
||||
registry.cleanupIfOwnedByConnection(
|
||||
'terminal:owned',
|
||||
'conn-b',
|
||||
registry.getRegistrationVersion()
|
||||
)
|
||||
).toBe(false)
|
||||
expect(cleanup).not.toHaveBeenCalled()
|
||||
await registry.cleanupAndWait('terminal:owned')
|
||||
})
|
||||
|
||||
it('keeps registration ownership even when a cleanup callback is reused', async () => {
|
||||
const registry = new RuntimeSubscriptionRegistry()
|
||||
const cleanup = vi.fn()
|
||||
|
||||
@@ -1,40 +0,0 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import type { StructuredAgentSessionLogger } from '../../native-chat/agent-session-wire/host/structured-agent-session-logger'
|
||||
|
||||
const installed = vi.hoisted(() => {
|
||||
const state: {
|
||||
deps: Record<string, unknown> | null
|
||||
logger: StructuredAgentSessionLogger | null
|
||||
} = { deps: null, logger: null }
|
||||
return state
|
||||
})
|
||||
|
||||
vi.mock('electron', () => ({
|
||||
BrowserWindow: { fromId: vi.fn(() => null) },
|
||||
webContents: { fromId: vi.fn(() => null) },
|
||||
ipcMain: { on: vi.fn(), removeListener: vi.fn() },
|
||||
app: { getPath: vi.fn(() => '/tmp') }
|
||||
}))
|
||||
|
||||
vi.mock('../agent-session/structured-agent-session-runtime', () => ({
|
||||
ensureStructuredAgentSessionHost: vi.fn(
|
||||
async (deps: Record<string, unknown> & { logger: StructuredAgentSessionLogger }) => {
|
||||
installed.deps = deps
|
||||
installed.logger = deps.logger
|
||||
}
|
||||
)
|
||||
}))
|
||||
|
||||
import { OrcaRuntimeService } from '../orca-runtime'
|
||||
|
||||
describe('checked runtime construction', () => {
|
||||
it('installs subscription callbacks on the runtime with their real registry receiver', () => {
|
||||
const runtime = new OrcaRuntimeService()
|
||||
const cleanup = vi.fn()
|
||||
runtime.registerSubscriptionCleanup('construction-subscription', cleanup)
|
||||
runtime.cleanupSubscription('construction-subscription')
|
||||
expect(cleanup).toHaveBeenCalledOnce()
|
||||
runtime.cleanupSubscription('construction-subscription')
|
||||
expect(cleanup).toHaveBeenCalledOnce()
|
||||
})
|
||||
})
|
||||
@@ -1,28 +0,0 @@
|
||||
import { afterEach, expect, it } from 'vitest'
|
||||
import { getRequestedPageUrl } from '../../browser/cdp/input/browser-expected-page-url'
|
||||
import type { RuntimeBrowserCommands } from '../browser/commands/browser-commands'
|
||||
import { setRuntimeBrowserCommandsFactory } from '../browser/installation/runtime-browser-commands-factory'
|
||||
import { RuntimeEdgeCommandController } from './runtime-edge-command-controller'
|
||||
|
||||
afterEach(() => setRuntimeBrowserCommandsFactory(null))
|
||||
|
||||
it('lets a browser command read the URL its RPC params expect, for that call only', async () => {
|
||||
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the test calls one method, and the proxy answers every name the controller binds.
|
||||
const commands = new Proxy({} as RuntimeBrowserCommands, {
|
||||
get: () => async () => getRequestedPageUrl()
|
||||
})
|
||||
setRuntimeBrowserCommandsFactory(() => commands)
|
||||
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: these hosts are only used by commands the test never calls.
|
||||
const hosts = {
|
||||
browserHost: {},
|
||||
jiraHost: {},
|
||||
screencast: {},
|
||||
emulatorHost: {}
|
||||
} as unknown as ConstructorParameters<typeof RuntimeEdgeCommandController>[0]
|
||||
const { surface } = new RuntimeEdgeCommandController(hosts)
|
||||
|
||||
await expect(
|
||||
surface.browserClick({ element: '@e1', expectUrl: 'https://example.com/a' })
|
||||
).resolves.toBe('https://example.com/a')
|
||||
await expect(surface.browserClick({ element: '@e1' })).resolves.toBeUndefined()
|
||||
})
|
||||
@@ -1,7 +1,5 @@
|
||||
import { registerOrcaRuntimeEmulatorFolderWorkspaceTests } from '../emulator/orca-runtime-emulator-folder-workspace.spec'
|
||||
import { registerOrcaRuntimeAutomationsTests } from '../integrations/automations/orca-runtime-automations.spec'
|
||||
import { registerHostAccountLaunchEnvTests } from '../agent-session/environment/host-account-launch-env.spec'
|
||||
|
||||
registerOrcaRuntimeEmulatorFolderWorkspaceTests()
|
||||
registerOrcaRuntimeAutomationsTests()
|
||||
registerHostAccountLaunchEnvTests()
|
||||
|
||||
@@ -1,30 +0,0 @@
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest'
|
||||
import type { RuntimeClientEvent } from '../../../shared/runtime-client-events'
|
||||
import { AgentHookServer } from '../../agent-hooks/server'
|
||||
import { OrcaRuntimeService } from '../orca-runtime'
|
||||
|
||||
describe('worktreeRowsChanged', () => {
|
||||
afterEach(() => {
|
||||
vi.useRealTimers()
|
||||
})
|
||||
|
||||
it('tells clients when an agent row changes', () => {
|
||||
vi.useFakeTimers()
|
||||
const runtime = new OrcaRuntimeService()
|
||||
const server = new AgentHookServer()
|
||||
const detach = runtime.attachAgentStatusStore(server)
|
||||
const events: RuntimeClientEvent[] = []
|
||||
runtime.onClientEvent((event) => events.push(event))
|
||||
|
||||
server.ingestTerminalStatus({
|
||||
paneKey: 'tab-1:22222222-2222-4222-8222-222222222222',
|
||||
tabId: 'tab-1',
|
||||
worktreeId: 'repo-1::/tmp/worktree-a',
|
||||
payload: { state: 'working', prompt: 'task', agentType: 'claude' }
|
||||
})
|
||||
vi.advanceTimersByTime(500)
|
||||
|
||||
expect(events).toContainEqual({ type: 'worktreeRowsChanged' })
|
||||
detach()
|
||||
})
|
||||
})
|
||||
@@ -1,51 +0,0 @@
|
||||
import { RuntimeFileReads } from './file-reads'
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import { openMock } from './runtime-file-command-mock-registry'
|
||||
import {
|
||||
createRuntimeFileHost,
|
||||
useRuntimeFileHostLifecycle
|
||||
} from './runtime-file-host.test-fixture'
|
||||
import { SshHostNotServedError } from '../../providers/ssh-host-not-served-error'
|
||||
|
||||
vi.mock('fs', async () => (await import('./runtime-file-command-mock-registry')).fsModuleMock())
|
||||
vi.mock('fs/promises', async () =>
|
||||
(await import('./runtime-file-command-mock-registry')).fsPromisesModuleMock()
|
||||
)
|
||||
vi.mock(
|
||||
'./watch/file-watcher-host',
|
||||
async () => (await import('./runtime-file-command-mock-registry')).fileWatcherHostMock
|
||||
)
|
||||
vi.mock('../../ipc/filesystem/access/filesystem-auth', async () =>
|
||||
(await import('./runtime-file-command-mock-registry')).filesystemAuthModuleMock()
|
||||
)
|
||||
vi.mock('../../git/runner', async () =>
|
||||
(await import('./runtime-file-command-mock-registry')).gitRunnerModuleMock()
|
||||
)
|
||||
vi.mock(
|
||||
'../../ipc/local-worktree-runtime-options',
|
||||
async () => (await import('./runtime-file-command-mock-registry')).localWorktreeRuntimeOptionsMock
|
||||
)
|
||||
|
||||
describe('RuntimeFileReads.readFileExplorerChunk', () => {
|
||||
useRuntimeFileHostLifecycle()
|
||||
|
||||
it('refuses an SSH worktree without opening a local file', async () => {
|
||||
const { commands } = createFileReads({
|
||||
path: '/remote/repo',
|
||||
resolveRuntimeFileTarget: vi.fn(async () => ({
|
||||
worktree: { id: 'wt-1', repoId: 'repo-1', path: '/remote/repo' },
|
||||
executionHostId: 'ssh:ssh-1'
|
||||
}))
|
||||
})
|
||||
|
||||
await expect(commands.readFileExplorerChunk('id:wt-1', 'big.bin', 0, 1024)).rejects.toThrow(
|
||||
SshHostNotServedError
|
||||
)
|
||||
expect(openMock).not.toHaveBeenCalled()
|
||||
})
|
||||
})
|
||||
|
||||
function createFileReads(options?: Parameters<typeof createRuntimeFileHost>[0]) {
|
||||
const { host, store } = createRuntimeFileHost(options)
|
||||
return { commands: new RuntimeFileReads(host), store }
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
import { RuntimeFileAccess } from './file-access'
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
|
||||
import type * as FileSystem from 'node:fs/promises'
|
||||
import { resolveAuthorizedPathMock, statMock } from './runtime-file-command-mock-registry'
|
||||
import {
|
||||
createRuntimeFileHost,
|
||||
useRuntimeFileHostLifecycle
|
||||
} from './runtime-file-host.test-fixture'
|
||||
|
||||
vi.mock('fs', async () => (await import('./runtime-file-command-mock-registry')).fsModuleMock())
|
||||
vi.mock('fs/promises', async () =>
|
||||
(await import('./runtime-file-command-mock-registry')).fsPromisesModuleMock()
|
||||
)
|
||||
vi.mock(
|
||||
'./watch/file-watcher-host',
|
||||
async () => (await import('./runtime-file-command-mock-registry')).fileWatcherHostMock
|
||||
)
|
||||
vi.mock('../../ipc/filesystem/access/filesystem-auth', async () =>
|
||||
(await import('./runtime-file-command-mock-registry')).filesystemAuthModuleMock()
|
||||
)
|
||||
vi.mock('../../git/runner', async () =>
|
||||
(await import('./runtime-file-command-mock-registry')).gitRunnerModuleMock()
|
||||
)
|
||||
vi.mock(
|
||||
'../../ipc/local-worktree-runtime-options',
|
||||
async () => (await import('./runtime-file-command-mock-registry')).localWorktreeRuntimeOptionsMock
|
||||
)
|
||||
|
||||
describe('RuntimeFileAccess', () => {
|
||||
useRuntimeFileHostLifecycle()
|
||||
|
||||
it('detects a real same-size rewrite even after restoring the modification time', async () => {
|
||||
vi.useRealTimers()
|
||||
const files = await vi.importActual<typeof FileSystem>('node:fs/promises')
|
||||
const { join } = await import('node:path')
|
||||
const { tmpdir } = await import('node:os')
|
||||
const root = await files.mkdtemp(join(tmpdir(), 'orca-media-revision-'))
|
||||
const filePath = join(root, 'video.mp4')
|
||||
try {
|
||||
await files.writeFile(filePath, 'abc')
|
||||
await files.utimes(filePath, 1, 2)
|
||||
const { commands } = createFileAccess()
|
||||
resolveAuthorizedPathMock.mockResolvedValue(filePath)
|
||||
statMock.mockImplementation((path: string) => files.stat(path))
|
||||
const before = await commands.statRuntimeFile('id:wt-1', 'video.mp4')
|
||||
await new Promise((resolve) => setTimeout(resolve, 20))
|
||||
await files.writeFile(filePath, 'xyz')
|
||||
await files.utimes(filePath, 1, 2)
|
||||
const after = await commands.statRuntimeFile('id:wt-1', 'video.mp4')
|
||||
expect(after.size).toBe(before.size)
|
||||
expect(after.mtime).toBe(before.mtime)
|
||||
expect(after.ctime).not.toBe(before.ctime)
|
||||
} finally {
|
||||
await files.rm(root, { recursive: true, force: true })
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
function createFileAccess(options?: Parameters<typeof createRuntimeFileHost>[0]) {
|
||||
const { host, store } = createRuntimeFileHost(options)
|
||||
return { commands: new RuntimeFileAccess(host), store }
|
||||
}
|
||||
@@ -10,7 +10,6 @@ import {
|
||||
} from './runtime-file-host.test-fixture'
|
||||
import { RUNTIME_PREVIEWABLE_BINARY_MAX_BYTES } from './file-preview-budget'
|
||||
import { REMOTE_RPC_MAX_CONTENT_BYTES } from '../../../shared/remote-rpc-content-budget'
|
||||
import { SshHostNotServedError } from '../../providers/ssh-host-not-served-error'
|
||||
|
||||
vi.mock('fs', async () => (await import('./runtime-file-command-mock-registry')).fsModuleMock())
|
||||
vi.mock('fs/promises', async () =>
|
||||
@@ -102,20 +101,6 @@ describe('RuntimeFileReads', () => {
|
||||
commands.readChatImagePreview('id:wt-1', join(dir, 'notes.txt'))
|
||||
).rejects.toThrow('not_an_image')
|
||||
})
|
||||
|
||||
it('refuses chat images for an SSH workspace, whose paths name the remote machine', async () => {
|
||||
const dir = await previewFixture()
|
||||
const { commands } = createFileReads({
|
||||
resolveRuntimeFileTarget: vi.fn(async () => ({
|
||||
worktree: { id: 'wt-1', repoId: 'repo-1', path: '/remote/repo' },
|
||||
executionHostId: 'ssh:ssh-1'
|
||||
}))
|
||||
})
|
||||
|
||||
await expect(commands.readChatImagePreview('id:wt-1', join(dir, 'logo.png'))).rejects.toThrow(
|
||||
SshHostNotServedError
|
||||
)
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
Reference in New Issue
Block a user