|
| 1 | +import { test, expect, vi, beforeEach } from 'vitest'; |
| 2 | +import os from 'node:os'; |
| 3 | +import path from 'node:path'; |
| 4 | + |
| 5 | +vi.mock('../../core/dispatch.ts', async (importOriginal) => { |
| 6 | + const actual = await importOriginal<typeof import('../../core/dispatch.ts')>(); |
| 7 | + return { ...actual, dispatchCommand: vi.fn(async () => ({})) }; |
| 8 | +}); |
| 9 | + |
| 10 | +vi.mock('../../platforms/ios/runner-client.ts', async (importOriginal) => { |
| 11 | + const actual = await importOriginal<typeof import('../../platforms/ios/runner-client.ts')>(); |
| 12 | + return { ...actual, stopIosRunnerSession: vi.fn(async () => {}) }; |
| 13 | +}); |
| 14 | + |
| 15 | +vi.mock('../device-ready.ts', () => ({ ensureDeviceReady: vi.fn(async () => {}) })); |
| 16 | + |
| 17 | +// Register a test view on a command that flows through the (mocked) generic |
| 18 | +// dispatch path, so the router graft mechanics can be exercised end to end |
| 19 | +// without the real snapshot handler (the actual snapshot view is unit-tested in |
| 20 | +// response-views.test.ts). |
| 21 | +vi.mock('../response-views.ts', async (importOriginal) => { |
| 22 | + const actual = await importOriginal<typeof import('../response-views.ts')>(); |
| 23 | + return { |
| 24 | + ...actual, |
| 25 | + RESPONSE_VIEWS: { |
| 26 | + ...actual.RESPONSE_VIEWS, |
| 27 | + home: (data: Record<string, unknown>, level: string) => |
| 28 | + level === 'digest' ? { homeDigest: true, hadItems: Array.isArray(data.items) } : data, |
| 29 | + }, |
| 30 | + }; |
| 31 | +}); |
| 32 | + |
| 33 | +import { dispatchCommand } from '../../core/dispatch.ts'; |
| 34 | +import { createRequestHandler } from '../request-router.ts'; |
| 35 | +import type { DaemonRequest, SessionState } from '../types.ts'; |
| 36 | +import { LeaseRegistry } from '../lease-registry.ts'; |
| 37 | +import { makeSessionStore } from '../../__tests__/test-utils/store-factory.ts'; |
| 38 | +import { daemonCommandRequestSchema } from '../../contracts.ts'; |
| 39 | + |
| 40 | +const mockDispatch = vi.mocked(dispatchCommand); |
| 41 | + |
| 42 | +const REPRESENTATIVE_PAYLOAD = { message: 'home-ok', items: [1, 2, 3] } as const; |
| 43 | + |
| 44 | +function makeIosSession(name: string): SessionState { |
| 45 | + return { |
| 46 | + name, |
| 47 | + createdAt: 1_700_000_000_000, |
| 48 | + actions: [], |
| 49 | + device: { |
| 50 | + platform: 'ios', |
| 51 | + target: 'mobile', |
| 52 | + id: 'SIM-001', |
| 53 | + name: 'iPhone 16', |
| 54 | + kind: 'simulator', |
| 55 | + booted: true, |
| 56 | + simulatorSetPath: '/tmp/tenant-a/set', |
| 57 | + }, |
| 58 | + }; |
| 59 | +} |
| 60 | + |
| 61 | +function makeHandler() { |
| 62 | + const sessionStore = makeSessionStore('agent-device-router-level-'); |
| 63 | + sessionStore.set('level-session', makeIosSession('level-session')); |
| 64 | + return { |
| 65 | + sessionStore, |
| 66 | + handler: createRequestHandler({ |
| 67 | + logPath: path.join(os.tmpdir(), 'daemon.log'), |
| 68 | + token: 'test-token', |
| 69 | + sessionStore, |
| 70 | + leaseRegistry: new LeaseRegistry(), |
| 71 | + trackDownloadableArtifact: () => 'artifact-id', |
| 72 | + }), |
| 73 | + }; |
| 74 | +} |
| 75 | + |
| 76 | +function request(command: string, overrides: Partial<DaemonRequest> = {}): DaemonRequest { |
| 77 | + return { |
| 78 | + token: 'test-token', |
| 79 | + session: 'level-session', |
| 80 | + command, |
| 81 | + positionals: [], |
| 82 | + flags: {}, |
| 83 | + ...overrides, |
| 84 | + }; |
| 85 | +} |
| 86 | + |
| 87 | +beforeEach(() => { |
| 88 | + mockDispatch.mockReset(); |
| 89 | + mockDispatch.mockImplementation(async () => ({ ...REPRESENTATIVE_PAYLOAD })); |
| 90 | +}); |
| 91 | + |
| 92 | +test('(a) default identity: responseLevel absent === default === no meta, byte-identical', async () => { |
| 93 | + const { handler } = makeHandler(); |
| 94 | + const noMeta = await handler(request('home')); |
| 95 | + const emptyMeta = await handler(request('home', { meta: {} })); |
| 96 | + const explicitDefault = await handler(request('home', { meta: { responseLevel: 'default' } })); |
| 97 | + |
| 98 | + expect(JSON.stringify(noMeta)).toBe(JSON.stringify(emptyMeta)); |
| 99 | + expect(JSON.stringify(noMeta)).toBe(JSON.stringify(explicitDefault)); |
| 100 | + if (noMeta.ok) expect(noMeta.data).toEqual(REPRESENTATIVE_PAYLOAD); |
| 101 | +}); |
| 102 | + |
| 103 | +test('(b) digest applies the registered view, dropping the full payload', async () => { |
| 104 | + const { handler } = makeHandler(); |
| 105 | + const resp = await handler(request('home', { meta: { responseLevel: 'digest' } })); |
| 106 | + expect(resp.ok).toBe(true); |
| 107 | + if (!resp.ok) return; |
| 108 | + expect(resp.data).toEqual({ homeDigest: true, hadItems: true }); |
| 109 | + expect('message' in (resp.data ?? {})).toBe(false); |
| 110 | +}); |
| 111 | + |
| 112 | +test('(c) full returns today’s shape (view passthrough) — byte-identical to default', async () => { |
| 113 | + const { handler } = makeHandler(); |
| 114 | + const full = await handler(request('home', { meta: { responseLevel: 'full' } })); |
| 115 | + const def = await handler(request('home', { meta: { responseLevel: 'default' } })); |
| 116 | + expect(JSON.stringify(full)).toBe(JSON.stringify(def)); |
| 117 | +}); |
| 118 | + |
| 119 | +test('(d) digest composes with --cost: viewed data plus an additive cost block', async () => { |
| 120 | + const { handler } = makeHandler(); |
| 121 | + const resp = await handler( |
| 122 | + request('home', { meta: { responseLevel: 'digest', includeCost: true } }), |
| 123 | + ); |
| 124 | + expect(resp.ok).toBe(true); |
| 125 | + if (!resp.ok) return; |
| 126 | + expect(resp.data).toMatchObject({ homeDigest: true, hadItems: true }); |
| 127 | + expect(typeof resp.data?.cost?.wallClockMs).toBe('number'); |
| 128 | + expect(resp.data?.cost?.runnerRoundTrips).toBe(0); |
| 129 | +}); |
| 130 | + |
| 131 | +test('(e) digest on a command with no registered view is byte-identical to default', async () => { |
| 132 | + const { handler } = makeHandler(); |
| 133 | + const digest = await handler(request('back', { meta: { responseLevel: 'digest' } })); |
| 134 | + const def = await handler(request('back', { meta: {} })); |
| 135 | + expect(JSON.stringify(digest)).toBe(JSON.stringify(def)); |
| 136 | + if (digest.ok) expect(digest.data).toEqual(REPRESENTATIVE_PAYLOAD); |
| 137 | +}); |
| 138 | + |
| 139 | +test('(f) boundary survival: meta.responseLevel survives daemonCommandRequestSchema parsing', () => { |
| 140 | + const parsed = daemonCommandRequestSchema.parse({ |
| 141 | + command: 'snapshot', |
| 142 | + positionals: [], |
| 143 | + meta: { responseLevel: 'digest' }, |
| 144 | + }); |
| 145 | + expect(parsed.meta?.responseLevel).toBe('digest'); |
| 146 | + |
| 147 | + const parsedOff = daemonCommandRequestSchema.parse({ |
| 148 | + command: 'snapshot', |
| 149 | + positionals: [], |
| 150 | + meta: {}, |
| 151 | + }); |
| 152 | + expect(parsedOff.meta?.responseLevel).toBeUndefined(); |
| 153 | +}); |
0 commit comments