yaver-feedback-react-native 0.9.2 → 0.9.3

package/src/__tests__/DogfoodRuntime.test.ts

@@ -0,0 +1,135 @@
+import {
+  DogfoodController,
+  DogfoodRuntimeError,
+  defaultDogfoodLane,
+  dogfoodLaneOptions,
+  dogfoodLogLinesFromDevEvent,
+  validateDogfoodProject,
+  type DogfoodDriver,
+  type DogfoodProject,
+} from '../DogfoodRuntime';
+
+const expo: DogfoodProject = {
+  name: 'Example', workDir: '/workspace/example', framework: 'expo', lane: 'browser',
+};
+
+describe('DogfoodController', () => {
+  test('does no work before the explicit trigger', () => {
+    const driver: DogfoodDriver = { start: jest.fn(async () => ({ lane: 'browser' as const })) };
+    const controller = new DogfoodController(expo, driver);
+    expect(driver.start).not.toHaveBeenCalled();
+    expect(controller.snapshot().phase).toBe('idle');
+  });
+
+  test('preserves raw npm output and hands a live session to the host', async () => {
+    const stop = jest.fn();
+    const closeLogs = jest.fn();
+    const controller = new DogfoodController(expo, {
+      async start(ctx) {
+        ctx.registerCleanup(stop, 'session');
+        ctx.registerCleanup(closeLogs, 'transient');
+        ctx.log('$ npm install --legacy-peer-deps');
+        ctx.log('npm warn deprecated example@1.0.0');
+        return { lane: 'browser', sessionId: 's1', url: 'http://agent/dev/' };
+      },
+    });
+
+    await controller.trigger();
+    expect(controller.snapshot().logs.map((line) => line.text)).toEqual([
+      '$ npm install --legacy-peer-deps',
+      'npm warn deprecated example@1.0.0',
+    ]);
+    expect(await controller.handoff()).toMatchObject({ sessionId: 's1' });
+    expect(closeLogs).toHaveBeenCalledTimes(1);
+    expect(stop).not.toHaveBeenCalled();
+  });
+
+  test('cleans a partial session before exposing a structured failure', async () => {
+    const stop = jest.fn();
+    const controller = new DogfoodController(expo, {
+      async start(ctx) {
+        ctx.registerCleanup(stop);
+        throw new DogfoodRuntimeError({
+          code: 'DOGFOOD_RENDER_FAILED', error: 'Metro exited', remedy: 'Fix Metro and retry.', retryable: true,
+        });
+      },
+    });
+    await expect(controller.trigger()).rejects.toThrow('Metro exited');
+    expect(stop).toHaveBeenCalledTimes(1);
+    expect(controller.snapshot()).toMatchObject({ phase: 'failed', failure: { code: 'DOGFOOD_RENDER_FAILED' } });
+  });
+
+  test('an obsolete attempt cannot clean up the replacement attempt', async () => {
+    let releaseFirst!: () => void;
+    const firstGate = new Promise<void>((resolve) => { releaseFirst = resolve; });
+    let firstStarted!: () => void;
+    const firstStartedGate = new Promise<void>((resolve) => { firstStarted = resolve; });
+    const stopFirst = jest.fn();
+    const stopSecond = jest.fn();
+    let starts = 0;
+    const controller = new DogfoodController(expo, {
+      async start(ctx) {
+        starts += 1;
+        if (starts === 1) {
+          ctx.registerCleanup(stopFirst);
+          firstStarted();
+          await firstGate;
+          return { lane: 'browser', sessionId: 'old' };
+        }
+        ctx.registerCleanup(stopSecond);
+        return { lane: 'browser', sessionId: 'new' };
+      },
+    });
+
+    const old = controller.trigger();
+    await firstStartedGate;
+    await controller.stop();
+    await expect(controller.trigger()).resolves.toMatchObject({ sessionId: 'new' });
+    releaseFirst();
+    await expect(old).rejects.toMatchObject({ failure: { code: 'DOGFOOD_ATTEMPT_REPLACED' } });
+    expect(stopFirst).toHaveBeenCalledTimes(1);
+    expect(stopSecond).not.toHaveBeenCalled();
+    await controller.stop();
+    expect(stopSecond).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('Dogfood lanes and console events', () => {
+  test('Flutter is first-class on browser but cannot be mislabeled Hermes', () => {
+    expect(validateDogfoodProject({ ...expo, framework: 'flutter', lane: 'browser' })).toBeNull();
+    expect(validateDogfoodProject({ ...expo, framework: 'flutter', lane: 'hermes' })?.code)
+      .toBe('DOGFOOD_HERMES_FRAMEWORK_UNSUPPORTED');
+  });
+
+  test('uses one three-lane matrix with browser default for React Native and Flutter', () => {
+    const rn = dogfoodLaneOptions('expo', { nativeRuntimeAvailable: true });
+    expect(defaultDogfoodLane('expo')).toBe('browser');
+    expect(rn.map((option) => [option.lane, option.supported])).toEqual([
+      ['browser', true], ['hermes', true], ['webrtc', true],
+    ]);
+    const flutter = dogfoodLaneOptions('flutter', { nativeRuntimeAvailable: true });
+    expect(defaultDogfoodLane('flutter')).toBe('browser');
+    expect(flutter.find((option) => option.lane === 'hermes')?.supported).toBe(false);
+  });
+
+  test('keeps Yaver self-development on the same RN three-lane contract', () => {
+    const options = dogfoodLaneOptions('expo', { nativeRuntimeAvailable: true, selfDevelopment: true });
+    expect(options).toHaveLength(3);
+    expect(options.find((option) => option.lane === 'hermes')).toMatchObject({ supported: true });
+    expect(options.find((option) => option.lane === 'webrtc')).toMatchObject({ supported: true });
+  });
+
+  test('native-only projects use WebRTC rather than fake browser or Hermes lanes', () => {
+    const swift = dogfoodLaneOptions('swift', { nativeRuntimeAvailable: true });
+    expect(swift.map((option) => [option.lane, option.supported])).toEqual([
+      ['browser', false], ['hermes', false], ['webrtc', true],
+    ]);
+  });
+
+  test('reads raw and replayed package-manager logs from /dev/events', () => {
+    expect(dogfoodLogLinesFromDevEvent({ type: 'log', logLine: '$ npm ci\u001b[0m' }))
+      .toEqual(['$ npm ci\u001b[0m']);
+    expect(dogfoodLogLinesFromDevEvent({ type: 'snapshot', snapshot: { recentLogs: ['npm warn x', 'Metro ready'] } }))
+      .toEqual(['npm warn x', 'Metro ready']);
+  });
+});

package/src/__tests__/P2PDogfoodDriver.test.ts

@@ -0,0 +1,80 @@
+import { DogfoodController } from '../DogfoodRuntime';
+import { createP2PDogfoodDriver } from '../P2PDogfoodDriver';
+import type { P2PClient } from '../P2PClient';
+
+describe('createP2PDogfoodDriver', () => {
+  it('keeps the browser lane compiling until the ordinary Projects status reports a URL', async () => {
+    const stop = jest.fn(async () => {});
+    const status = jest.fn()
+      .mockResolvedValueOnce({ building: true, framework: 'flutter' })
+      .mockResolvedValueOnce({ running: true, serving: true, framework: 'flutter', bundleUrl: '/dev/' });
+    const client = {
+      subscribeDogfoodDevEvents: (onEvent: (event: unknown) => void) => {
+        onEvent({ type: 'log', logLine: '$ flutter run -d web-server' });
+        return jest.fn();
+      },
+      startDogfoodDevServer: jest.fn(async () => ({ starting: true, framework: 'flutter' })),
+      getDogfoodDevServerStatus: status,
+      stopDogfoodDevServer: stop,
+      resolveDogfoodUrl: (path: string) => `http://agent.test${path}`,
+    } as unknown as P2PClient;
+    const snapshots: string[][] = [];
+    const controller = new DogfoodController(
+      { name: 'Flutter app', framework: 'flutter', workDir: '/workspace/app', lane: 'browser' },
+      createP2PDogfoodDriver(client, { pollIntervalMs: 1, startupTimeoutMs: 100 }),
+      { onChange: (snapshot) => snapshots.push(snapshot.logs.map((line) => line.text)) },
+    );
+
+    const result = await controller.trigger();
+
+    expect(result.url).toBe('http://agent.test/dev/');
+    expect(status).toHaveBeenCalledTimes(2);
+    expect(snapshots.flat()).toContain('$ flutter run -d web-server');
+    expect(stop).not.toHaveBeenCalled();
+    await controller.stop();
+    expect(stop).toHaveBeenCalledTimes(1);
+  });
+
+  it('starts and cleans up an available native WebRTC runtime', async () => {
+    const closeRuntime = jest.fn(async () => {});
+    const client = {
+      subscribeDogfoodDevEvents: () => jest.fn(),
+      getDogfoodRemoteRuntimeCapabilities: jest.fn(async () => ({
+        targets: [
+          { id: 'browser-window', label: 'Browser', enabled: true },
+          { id: 'ios-simulator', label: 'iPhone simulator', enabled: true },
+        ],
+      })),
+      startDogfoodRemoteRuntime: jest.fn(async () => ({
+        id: 'runtime-1', status: 'starting', targetId: 'ios-simulator',
+      })),
+      stopDogfoodRemoteRuntime: closeRuntime,
+    } as unknown as P2PClient;
+    const controller = new DogfoodController(
+      { name: 'Native app', framework: 'flutter', workDir: '/workspace/app', lane: 'webrtc' },
+      createP2PDogfoodDriver(client),
+    );
+
+    await expect(controller.trigger()).resolves.toMatchObject({ lane: 'webrtc', sessionId: 'runtime-1' });
+    expect(closeRuntime).not.toHaveBeenCalled();
+    await controller.stop();
+    expect(closeRuntime).toHaveBeenCalledWith('runtime-1');
+  });
+
+  it('delivers Hermes without stopping an unrelated dev server on exit', async () => {
+    const stop = jest.fn(async () => {});
+    const client = {
+      subscribeDogfoodDevEvents: () => jest.fn(),
+      startDogfoodDevServer: jest.fn(async () => ({ running: true, framework: 'expo', workDir: '/workspace/app' })),
+      stopDogfoodDevServer: stop,
+    } as unknown as P2PClient;
+    const controller = new DogfoodController(
+      { name: 'RN app', framework: 'expo', workDir: '/workspace/app', lane: 'hermes' },
+      createP2PDogfoodDriver(client),
+    );
+
+    await expect(controller.trigger()).resolves.toMatchObject({ lane: 'hermes', metadata: { delivered: true } });
+    await controller.stop();
+    expect(stop).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/ReportIdentity.test.ts

@@ -1,15 +1,17 @@
-import { resolveReportIdentity } from '../P2PClient';
-
 // resolveAppIdentity() has always fed /vibing/execute and /dev/reload-app so
 // the agent could route "vibe on THIS app" to the right repo, but nothing fed
 // /feedback — reports carried no identity at all, so the agent's fix router
 // had nothing to resolve and fell back to whatever directory it was sitting
 // in. resolveReportIdentity() closes that gap for the feedback path.
 
-jest.mock('react-native', () => ({
+const mockReactNative = {
   Platform: { OS: 'ios' },
   NativeModules: {},
-}));
+};
+const mockExpoModule: { default: Record<string, unknown> } = { default: {} };
+
+jest.mock('react-native', () => mockReactNative);
+jest.mock('expo-constants', () => mockExpoModule, { virtual: true });
 
 /** Mirrors mobile/app.json in the Talos repo — the SDK's first external consumer. */
 const EXPO_CONFIG = {
@@ -21,17 +23,33 @@ const EXPO_CONFIG = {
 };
 
 function mockExpoConstants(expoConfig: unknown, extra: Record<string, unknown> = {}) {
-  jest.doMock('expo-constants', () => ({ default: { expoConfig, ...extra } }), { virtual: true });
+  mockExpoModule.default = { expoConfig, ...extra };
+}
+
+function loadResolve(): typeof import('../P2PClient').resolveReportIdentity {
+  let resolve!: typeof import('../P2PClient').resolveReportIdentity;
+  jest.isolateModules(() => {
+    jest.doMock('react-native', () => mockReactNative);
+    jest.doMock('expo-constants', () => mockExpoModule, { virtual: true });
+    resolve = require('../P2PClient').resolveReportIdentity;
+  });
+  return resolve;
 }
 
 beforeEach(() => {
+  // P2PClient is imported by many suites with different virtual RN/Expo
+  // modules. Re-evaluate it against this suite's mutable modules every time;
+  // an order-dependent green test is not an identity-routing guard.
   jest.resetModules();
+  mockReactNative.Platform.OS = 'ios';
+  mockReactNative.NativeModules = {};
+  mockExpoModule.default = {};
 });
 
 describe('resolveReportIdentity', () => {
   it('resolves app name and bundle id from the Expo config', () => {
     mockExpoConstants(EXPO_CONFIG);
-    const { resolveReportIdentity: resolve } = require('../P2PClient');
+    const resolve = loadResolve();
 
     const identity = resolve();
 
@@ -47,7 +65,7 @@ describe('resolveReportIdentity', () => {
 
   it('never reports a project path', () => {
     mockExpoConstants(EXPO_CONFIG);
-    const { resolveReportIdentity: resolve } = require('../P2PClient');
+    const resolve = loadResolve();
 
     // The agent ignores client-supplied paths on feedback reports (an
     // untrusted guest could otherwise aim the fix task's CWD at ~/.ssh).
@@ -57,7 +75,7 @@ describe('resolveReportIdentity', () => {
 
   it('prefers the native runtime version over the manifest version', () => {
     mockExpoConstants(EXPO_CONFIG, { nativeAppVersion: '1.9.158', nativeBuildVersion: '428' });
-    const { resolveReportIdentity: resolve } = require('../P2PClient');
+    const resolve = loadResolve();
 
     const identity = resolve();
     // A stale manifest shouldn't misreport which build is actually running.
@@ -67,7 +85,7 @@ describe('resolveReportIdentity', () => {
 
   it('falls back to the manifest version when no native version is exposed', () => {
     mockExpoConstants(EXPO_CONFIG);
-    const { resolveReportIdentity: resolve } = require('../P2PClient');
+    const resolve = loadResolve();
 
     const identity = resolve();
     expect(identity.app.version).toBe('1.9.157');
@@ -86,17 +104,14 @@ describe('resolveReportIdentity', () => {
     };
 
     function mockContainer(yaverInfo: Record<string, unknown>) {
-      jest.doMock('react-native', () => ({
-        Platform: { OS: 'ios' },
-        NativeModules: { YaverInfo: { isYaver: true, ...yaverInfo } },
-      }));
+      mockReactNative.NativeModules = { YaverInfo: { isYaver: true, ...yaverInfo } };
       // The host's manifest — what expo-constants answers for a guest bundle.
       mockExpoConstants(YAVER_CONFIG);
     }
 
     it("never reports the host's bundle id as the guest's", () => {
       mockContainer({ inheritedGuestProjectName: 'talos / mobile' });
-      const { resolveReportIdentity: resolve } = require('../P2PClient');
+      const resolve = loadResolve();
 
       const identity = resolve();
 
@@ -110,7 +125,7 @@ describe('resolveReportIdentity', () => {
 
     it('reports the guest project Yaver pinned', () => {
       mockContainer({ inheritedGuestProjectName: 'talos / mobile' });
-      const { resolveReportIdentity: resolve } = require('../P2PClient');
+      const resolve = loadResolve();
 
       const identity = resolve();
       expect(identity.appName).toBe('talos / mobile');
@@ -119,7 +134,7 @@ describe('resolveReportIdentity', () => {
 
     it("lets the app's own declaration win over the pinned project", () => {
       mockContainer({ inheritedGuestProjectName: 'something-else' });
-      const { resolveReportIdentity: resolve } = require('../P2PClient');
+      const resolve = loadResolve();
 
       // A bundle knows its own identity; nothing ambient should override it.
       const identity = resolve({ projectName: 'Talos', bundleId: 'works.talos.mobile' });
@@ -129,7 +144,7 @@ describe('resolveReportIdentity', () => {
 
     it('reports nothing rather than something wrong when no project is pinned', () => {
       mockContainer({});
-      const { resolveReportIdentity: resolve } = require('../P2PClient');
+      const resolve = loadResolve();
 
       // Better for the agent to reject/fall back than to confidently edit
       // the wrong repo.
@@ -142,7 +157,7 @@ describe('resolveReportIdentity', () => {
 
   it('lets an explicit declaration override the ambient identity', () => {
     mockExpoConstants(EXPO_CONFIG);
-    const { resolveReportIdentity: resolve } = require('../P2PClient');
+    const resolve = loadResolve();
 
     const identity = resolve({ projectName: 'Override', bundleId: 'com.override.app' });
     expect(identity.appName).toBe('Override');
@@ -151,7 +166,7 @@ describe('resolveReportIdentity', () => {
 
   it('passes declared surfaces stacks and voice metadata through', () => {
     mockExpoConstants(EXPO_CONFIG);
-    const { resolveReportIdentity: resolve } = require('../P2PClient');
+    const resolve = loadResolve();
 
     const identity = resolve({
       projectName: 'Omni',
@@ -186,14 +201,8 @@ describe('resolveReportIdentity', () => {
   it('omits the project block when nothing identifies the app', () => {
     // Bare RN with no expo-constants and no native modules. The report must
     // still upload — the agent just resolves it by its own means.
-    jest.doMock(
-      'expo-constants',
-      () => {
-        throw new Error('not installed');
-      },
-      { virtual: true },
-    );
-    const { resolveReportIdentity: resolve } = require('../P2PClient');
+    mockExpoModule.default = {};
+    const resolve = loadResolve();
 
     const identity = resolve();
     expect(identity.project).toBeUndefined();

package/src/__tests__/YaverFeedback.test.ts

@@ -1,3 +1,4 @@
+import { DeviceEventEmitter } from 'react-native';
 import { YaverFeedback } from '../YaverFeedback';
 
 // Mock react-native: DeviceEventEmitter for event dispatch + Platform so
@@ -34,13 +35,10 @@ jest.mock('../auth', () => ({
         needsAuth: false,
         runnerDown: false,
         lastHeartbeat: Date.now(),
-        isGuest: false,
-        accessScope: 'owner',
         quicHost: '127.0.0.1',
         quicPort: 18080,
       },
     ],
-    shared: [],
   })),
   DEFAULT_CONVEX_SITE_URL: 'https://example.convex.site',
 }));
@@ -54,6 +52,20 @@ beforeEach(() => {
 });
 
 describe('YaverFeedback', () => {
+  describe('Dogfood onboarding', () => {
+    it('starts with Yaver OAuth when the host has no session', () => {
+      YaverFeedback.init({ enabled: true });
+      YaverFeedback.beginDogfoodOnboarding({ appId: 'io.example.app', label: 'Example' });
+      expect(DeviceEventEmitter.emit).toHaveBeenCalledWith('yaverFeedback:startLogin');
+    });
+
+    it('asks for a machine after an existing OAuth session', () => {
+      YaverFeedback.init({ enabled: true, authToken: 'owner-token' });
+      YaverFeedback.beginDogfoodOnboarding({ appId: 'io.example.app', label: 'Example' });
+      expect(DeviceEventEmitter.emit).toHaveBeenCalledWith('yaverFeedback:startMachinePicker');
+    });
+  });
+
   describe('init()', () => {
     it('sets config correctly with defaults', () => {
       YaverFeedback.init({

package/src/__tests__/deviceDogfood.test.ts

@@ -0,0 +1,77 @@
+import nacl from 'tweetnacl';
+import { Buffer } from 'buffer';
+import { webcrypto } from 'crypto';
+import { YaverDeviceDogfood } from '../deviceDogfood';
+
+class MemorySecureStore {
+  values = new Map<string, string>();
+  async getItemAsync(key: string) { return this.values.get(key) ?? null; }
+  async setItemAsync(key: string, value: string) { this.values.set(key, value); }
+  async deleteItemAsync(key: string) { this.values.delete(key); }
+}
+
+function response(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });
+}
+
+describe('YaverDeviceDogfood', () => {
+  beforeAll(() => {
+    if (!(globalThis as any).crypto) (globalThis as any).crypto = webcrypto;
+  });
+
+  afterEach(() => { jest.restoreAllMocks(); });
+
+  test('keeps identity stable and proves possession rather than trusting the UUID', async () => {
+    const store = new MemorySecureStore();
+    const client = new YaverDeviceDogfood({ appId: 'io.example.test', secureStore: store, backendUrl: 'https://dogfood.test' });
+    const first = await client.enrollmentInfo();
+    const second = await client.enrollmentInfo();
+    expect(second).toEqual(first);
+
+    let proof: any;
+    jest.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
+      const url = String(input);
+      if (url.endsWith('/dogfood/enroll/start')) return response({ status: 'pending', challenge: 'server-nonce' });
+      if (url.endsWith('/dogfood/enroll/prove')) { proof = JSON.parse(String(init?.body)); return response({ status: 'pending', proofVerified: true }); }
+      throw new Error(`unexpected URL ${url}`);
+    });
+    await client.enroll('ios');
+    const message = new TextEncoder().encode(`yaver-dogfood-enroll-v1\nio.example.test\n${first.installationId}\nserver-nonce`);
+    expect(nacl.sign.detached.verify(message, new Uint8Array(Buffer.from(proof.signature, 'base64')), new Uint8Array(Buffer.from(first.publicKey, 'base64')))).toBe(true);
+
+    const attacker = nacl.sign.keyPair();
+    expect(nacl.sign.detached.verify(message, new Uint8Array(Buffer.from(proof.signature, 'base64')), attacker.publicKey)).toBe(false);
+  });
+
+  test('re-register rotates key and installation while preserving only the logical slot', async () => {
+    const store = new MemorySecureStore();
+    const client = new YaverDeviceDogfood({ appId: 'io.example.test', secureStore: store, backendUrl: 'https://dogfood.test' });
+    const before = await client.enrollmentInfo();
+    jest.spyOn(globalThis, 'fetch').mockImplementation(async (input) => {
+      if (String(input).endsWith('/dogfood/enroll/start')) return response({ status: 'pending', challenge: 'rotate-nonce' });
+      return response({ status: 'pending', proofVerified: true });
+    });
+    await client.reRegister('ios');
+    const after = await client.enrollmentInfo();
+    expect(after.registrationSlot).toBe(before.registrationSlot);
+    expect(after.installationId).not.toBe(before.installationId);
+    expect(after.publicKey).not.toBe(before.publicKey);
+  });
+
+  test('exchanges an approved key proof for a short-lived scoped session', async () => {
+    const client = new YaverDeviceDogfood({ appId: 'io.example.test', secureStore: new MemorySecureStore(), backendUrl: 'https://dogfood.test' });
+    const identity = await client.enrollmentInfo();
+    let sessionProof: any;
+    jest.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
+      const url = String(input);
+      if (url.includes('/dogfood/enroll/status')) return response({ status: 'active' });
+      if (url.endsWith('/dogfood/session/challenge')) return response({ challenge: 'session-nonce' });
+      if (url.endsWith('/dogfood/session')) { sessionProof = JSON.parse(String(init?.body)); return response({ token: 'short-token', expiresAt: 123, scopes: ['feedback', 'blackbox'], projectSlug: 'example' }); }
+      throw new Error(`unexpected URL ${url}`);
+    });
+    const session = await client.session();
+    expect(session).toMatchObject({ active: true, token: 'short-token', scopes: ['feedback', 'blackbox'] });
+    const message = new TextEncoder().encode(`yaver-dogfood-session-v1\nio.example.test\n${identity.installationId}\nsession-nonce`);
+    expect(nacl.sign.detached.verify(message, new Uint8Array(Buffer.from(sessionProof.signature, 'base64')), new Uint8Array(Buffer.from(identity.publicKey, 'base64')))).toBe(true);
+  });
+});

package/src/__tests__/dogfoodPolicy.test.ts

@@ -0,0 +1,34 @@
+import { resolveSDKDogfood } from '../dogfoodPolicy';
+
+describe('resolveSDKDogfood', () => {
+  it('fails closed unless Dogfood is explicitly enabled', () => {
+    expect(resolveSDKDogfood({ accountIds: ['acct-1'], currentAccountId: 'acct-1' })).toMatchObject({
+      active: false,
+      code: 'SDK_DOGFOOD_DISABLED',
+    });
+  });
+
+  it('requires an exact approved app-account ID', () => {
+    expect(resolveSDKDogfood({ enabled: true, accountIds: ['acct-1'], currentAccountId: '' }).code)
+      .toBe('SDK_DOGFOOD_ACCOUNT_REQUIRED');
+    expect(resolveSDKDogfood({ enabled: true, accountIds: ['acct-1'], currentAccountId: 'acct-10' }).code)
+      .toBe('SDK_DOGFOOD_ACCOUNT_NOT_ALLOWED');
+    expect(resolveSDKDogfood({ enabled: true, accountIds: ['acct-1'], currentAccountId: 'acct-1' })).toMatchObject({
+      active: true,
+      code: 'SDK_DOGFOOD_ACTIVE',
+      accountId: 'acct-1',
+    });
+  });
+
+  it('supports a key-enrolled installation without an app account', () => {
+    expect(resolveSDKDogfood({ enabled: true, appId: 'io.example', installationStatus: 'active' }).code)
+      .toBe('SDK_DOGFOOD_INSTALLATION_REQUIRED');
+    expect(resolveSDKDogfood({ enabled: true, appId: 'io.example', installationId: 'install-1', installationStatus: 'pending' }).code)
+      .toBe('SDK_DOGFOOD_INSTALLATION_NOT_ACTIVE');
+    expect(resolveSDKDogfood({ enabled: true, appId: 'io.example', installationId: 'install-1', installationStatus: 'active' })).toMatchObject({
+      active: true,
+      code: 'SDK_DOGFOOD_ACTIVE',
+      accountId: 'install-1',
+    });
+  });
+});