yaver-feedback-react-native 0.2.0

package/src/__tests__/Discovery.test.ts

@@ -0,0 +1,187 @@
+import { YaverDiscovery, DiscoveryResult } from '../Discovery';
+
+// Mock fetch globally
+const mockFetch = jest.fn();
+global.fetch = mockFetch as any;
+
+// Mock AsyncStorage
+const mockStorage: Record<string, string> = {};
+jest.mock('@react-native-async-storage/async-storage', () => ({
+  getItem: jest.fn((key: string) => Promise.resolve(mockStorage[key] || null)),
+  setItem: jest.fn((key: string, value: string) => {
+    mockStorage[key] = value;
+    return Promise.resolve();
+  }),
+  removeItem: jest.fn((key: string) => {
+    delete mockStorage[key];
+    return Promise.resolve();
+  }),
+}));
+
+// Mock AbortController
+class MockAbortController {
+  signal = {};
+  abort = jest.fn();
+}
+global.AbortController = MockAbortController as any;
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockFetch.mockReset();
+  // Clear mock storage
+  Object.keys(mockStorage).forEach((key) => delete mockStorage[key]);
+});
+
+describe('YaverDiscovery', () => {
+  describe('probe()', () => {
+    it('returns null for unreachable URLs', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'));
+
+      const result = await YaverDiscovery.probe('http://192.168.1.99:18080');
+      expect(result).toBeNull();
+    });
+
+    it('returns null for non-ok responses', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+      });
+
+      const result = await YaverDiscovery.probe('http://192.168.1.1:18080');
+      expect(result).toBeNull();
+    });
+
+    it('returns DiscoveryResult for a reachable agent', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ hostname: 'MacBook-Air', version: '1.44.0' }),
+      });
+
+      const result = await YaverDiscovery.probe('http://192.168.1.10:18080');
+      expect(result).not.toBeNull();
+      expect(result!.url).toBe('http://192.168.1.10:18080');
+      expect(result!.hostname).toBe('MacBook-Air');
+      expect(result!.version).toBe('1.44.0');
+      expect(typeof result!.latency).toBe('number');
+    });
+
+    it('strips trailing slash from URL', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ hostname: 'test', version: '1.0' }),
+      });
+
+      const result = await YaverDiscovery.probe('http://192.168.1.10:18080/');
+      expect(result!.url).toBe('http://192.168.1.10:18080');
+    });
+
+    it('handles health endpoint returning non-JSON gracefully', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.reject(new Error('not JSON')),
+      });
+
+      const result = await YaverDiscovery.probe('http://192.168.1.10:18080');
+      expect(result).not.toBeNull();
+      expect(result!.hostname).toBe('Unknown');
+      expect(result!.version).toBe('unknown');
+    });
+  });
+
+  describe('getStored()', () => {
+    it('returns null when no stored connection', async () => {
+      const result = await YaverDiscovery.getStored();
+      expect(result).toBeNull();
+    });
+
+    it('returns stored connection when available', async () => {
+      const AsyncStorage = require('@react-native-async-storage/async-storage');
+      mockStorage['yaver_feedback_agent'] = JSON.stringify({
+        url: 'http://192.168.1.10:18080',
+        hostname: 'MacBook',
+      });
+
+      const result = await YaverDiscovery.getStored();
+      expect(result).not.toBeNull();
+      expect(result!.url).toBe('http://192.168.1.10:18080');
+      expect(result!.hostname).toBe('MacBook');
+    });
+
+    it('returns null for invalid stored JSON', async () => {
+      mockStorage['yaver_feedback_agent'] = 'not-json';
+
+      const result = await YaverDiscovery.getStored();
+      expect(result).toBeNull();
+    });
+
+    it('returns null for stored data without url field', async () => {
+      mockStorage['yaver_feedback_agent'] = JSON.stringify({ hostname: 'test' });
+
+      const result = await YaverDiscovery.getStored();
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('store() and getStored() round-trip', () => {
+    it('stores and retrieves a DiscoveryResult', async () => {
+      const discovery: DiscoveryResult = {
+        url: 'http://10.0.0.50:18080',
+        hostname: 'DevMachine',
+        version: '1.44.0',
+        latency: 5,
+      };
+
+      await YaverDiscovery.store(discovery);
+
+      const stored = await YaverDiscovery.getStored();
+      expect(stored).not.toBeNull();
+      expect(stored!.url).toBe('http://10.0.0.50:18080');
+      expect(stored!.hostname).toBe('DevMachine');
+    });
+  });
+
+  describe('clear()', () => {
+    it('removes stored connection', async () => {
+      const discovery: DiscoveryResult = {
+        url: 'http://10.0.0.1:18080',
+        hostname: 'Test',
+        version: '1.0',
+        latency: 3,
+      };
+
+      await YaverDiscovery.store(discovery);
+      const beforeClear = await YaverDiscovery.getStored();
+      expect(beforeClear).not.toBeNull();
+
+      await YaverDiscovery.clear();
+
+      const afterClear = await YaverDiscovery.getStored();
+      expect(afterClear).toBeNull();
+    });
+  });
+
+  describe('connect()', () => {
+    it('probes and stores on success', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ hostname: 'Agent', version: '2.0' }),
+      });
+
+      const result = await YaverDiscovery.connect('http://192.168.1.5:18080');
+      expect(result).not.toBeNull();
+      expect(result!.hostname).toBe('Agent');
+
+      // Should be stored
+      const stored = await YaverDiscovery.getStored();
+      expect(stored).not.toBeNull();
+      expect(stored!.url).toBe('http://192.168.1.5:18080');
+    });
+
+    it('returns null and does not store on failure', async () => {
+      mockFetch.mockRejectedValue(new Error('unreachable'));
+
+      const result = await YaverDiscovery.connect('http://192.168.1.99:18080');
+      expect(result).toBeNull();
+    });
+  });
+});

package/src/__tests__/P2PClient.test.ts

@@ -0,0 +1,218 @@
+import { P2PClient } from '../P2PClient';
+
+// Mock react-native Platform
+jest.mock('react-native', () => ({
+  Platform: { OS: 'ios' },
+}));
+
+// Mock fetch globally
+const mockFetch = jest.fn();
+global.fetch = mockFetch as any;
+
+// Mock AbortController
+class MockAbortController {
+  signal = {};
+  abort = jest.fn();
+}
+global.AbortController = MockAbortController as any;
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockFetch.mockReset();
+});
+
+describe('P2PClient', () => {
+  describe('constructor', () => {
+    it('sets baseUrl and authToken', () => {
+      const client = new P2PClient('http://192.168.1.10:18080', 'my-token');
+      // Verify via getArtifactUrl which uses baseUrl
+      expect(client.getArtifactUrl('build-123')).toBe(
+        'http://192.168.1.10:18080/builds/build-123/artifact'
+      );
+    });
+
+    it('strips trailing slash from baseUrl', () => {
+      const client = new P2PClient('http://192.168.1.10:18080/', 'tok');
+      expect(client.getArtifactUrl('b1')).toBe(
+        'http://192.168.1.10:18080/builds/b1/artifact'
+      );
+    });
+  });
+
+  describe('health()', () => {
+    it('returns false for unreachable agent', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'));
+
+      const client = new P2PClient('http://192.168.1.99:18080', 'tok');
+      const result = await client.health();
+      expect(result).toBe(false);
+    });
+
+    it('returns true when agent is reachable', async () => {
+      mockFetch.mockResolvedValue({ ok: true });
+
+      const client = new P2PClient('http://192.168.1.10:18080', 'tok');
+      const result = await client.health();
+      expect(result).toBe(true);
+    });
+
+    it('returns false for non-ok response', async () => {
+      mockFetch.mockResolvedValue({ ok: false, status: 503 });
+
+      const client = new P2PClient('http://192.168.1.10:18080', 'tok');
+      const result = await client.health();
+      expect(result).toBe(false);
+    });
+
+    it('calls /health endpoint', async () => {
+      mockFetch.mockResolvedValue({ ok: true });
+
+      const client = new P2PClient('http://10.0.0.1:18080', 'tok');
+      await client.health();
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://10.0.0.1:18080/health',
+        expect.objectContaining({ method: 'GET' })
+      );
+    });
+  });
+
+  describe('getArtifactUrl()', () => {
+    it('constructs correct URL for a build ID', () => {
+      const client = new P2PClient('http://192.168.1.10:18080', 'tok');
+      expect(client.getArtifactUrl('abc-123')).toBe(
+        'http://192.168.1.10:18080/builds/abc-123/artifact'
+      );
+    });
+
+    it('works with different base URLs', () => {
+      const client = new P2PClient('http://10.0.0.50:9090', 'tok');
+      expect(client.getArtifactUrl('xyz')).toBe(
+        'http://10.0.0.50:9090/builds/xyz/artifact'
+      );
+    });
+  });
+
+  describe('setBaseUrl()', () => {
+    it('updates the base URL used by subsequent calls', () => {
+      const client = new P2PClient('http://old-host:18080', 'tok');
+      client.setBaseUrl('http://new-host:18080');
+      expect(client.getArtifactUrl('b1')).toBe(
+        'http://new-host:18080/builds/b1/artifact'
+      );
+    });
+
+    it('strips trailing slash from new URL', () => {
+      const client = new P2PClient('http://old:18080', 'tok');
+      client.setBaseUrl('http://new:18080/');
+      expect(client.getArtifactUrl('b1')).toBe(
+        'http://new:18080/builds/b1/artifact'
+      );
+    });
+  });
+
+  describe('info()', () => {
+    it('returns agent info on success', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ hostname: 'MacBook', version: '1.44.0', platform: 'darwin' }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'tok');
+      const info = await client.info();
+      expect(info.hostname).toBe('MacBook');
+      expect(info.version).toBe('1.44.0');
+      expect(info.platform).toBe('darwin');
+    });
+
+    it('sends Authorization header', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ hostname: 'test' }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'my-secret-token');
+      await client.info();
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:18080/health',
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer my-secret-token',
+          }),
+        })
+      );
+    });
+  });
+
+  describe('uploadFeedback()', () => {
+    it('sends a POST request to /feedback', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ id: 'report-456' }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'tok');
+      const bundle = {
+        metadata: {
+          timestamp: '2026-03-24T00:00:00Z',
+          device: {
+            platform: 'ios',
+            osVersion: '18.0',
+            model: 'iPhone 16',
+            screenWidth: 393,
+            screenHeight: 852,
+          },
+          app: { bundleId: 'com.test', version: '1.0' },
+          userNote: 'Button is broken',
+        },
+        screenshots: [],
+      };
+
+      const reportId = await client.uploadFeedback(bundle);
+      expect(reportId).toBe('report-456');
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:18080/feedback',
+        expect.objectContaining({ method: 'POST' })
+      );
+    });
+
+    it('throws on non-ok response', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        text: () => Promise.resolve('Internal Server Error'),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'tok');
+      const bundle = {
+        metadata: {
+          timestamp: '2026-03-24T00:00:00Z',
+          device: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
+          app: {},
+        },
+        screenshots: [],
+      };
+
+      await expect(client.uploadFeedback(bundle)).rejects.toThrow('Upload failed');
+    });
+  });
+
+  describe('listBuilds()', () => {
+    it('returns builds array on success', async () => {
+      const builds = [{ id: '1', platform: 'ios', status: 'complete' }];
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ builds }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'tok');
+      const result = await client.listBuilds();
+      expect(result).toEqual(builds);
+    });
+  });
+});

package/src/__tests__/SDKToken.test.ts

@@ -0,0 +1,268 @@
+import { P2PClient } from '../P2PClient';
+
+// Mock react-native Platform
+jest.mock('react-native', () => ({
+  Platform: { OS: 'ios' },
+}));
+
+// Mock fetch globally
+const mockFetch = jest.fn();
+global.fetch = mockFetch as any;
+
+// Mock AbortController
+class MockAbortController {
+  signal = {};
+  abort = jest.fn();
+}
+global.AbortController = MockAbortController as any;
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockFetch.mockReset();
+});
+
+describe('SDK Token Auth', () => {
+  describe('Bearer token in requests', () => {
+    it('sends SDK token in Authorization header for feedback', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ id: 'report-1' }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://192.168.1.10:18080', 'sdk-token-abc123');
+      const bundle = {
+        metadata: {
+          timestamp: '2026-03-25T00:00:00Z',
+          device: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
+          app: {},
+        },
+        screenshots: [],
+      };
+      await client.uploadFeedback(bundle);
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://192.168.1.10:18080/feedback',
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer sdk-token-abc123',
+          }),
+        })
+      );
+    });
+
+    it('sends SDK token in Authorization header for voice', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ voiceInputEnabled: true }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'my-sdk-token');
+      await client.voiceStatus();
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:18080/voice/status',
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer my-sdk-token',
+          }),
+        })
+      );
+    });
+
+    it('sends SDK token for test session', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ sessionId: 'sess-1' }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'test-sdk-token');
+      await client.startTestSession();
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:18080/test-app/start',
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-sdk-token',
+          }),
+        })
+      );
+    });
+  });
+
+  describe('setAuthToken()', () => {
+    it('updates token for subsequent requests', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ hostname: 'test' }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'old-token');
+      client.setAuthToken('new-sdk-token');
+      await client.info();
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer new-sdk-token',
+          }),
+        })
+      );
+    });
+  });
+
+  describe('Error handling for SDK token auth failures', () => {
+    it('throws on 403 Forbidden (scope violation)', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 403,
+        text: () => Promise.resolve('SDK token scope does not allow this endpoint'),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'limited-sdk');
+      await expect(client.info()).rejects.toThrow('403');
+    });
+
+    it('throws on 403 Forbidden (IP binding)', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 403,
+        text: () => Promise.resolve('SDK token not allowed from this IP'),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'ip-bound-sdk');
+      await expect(client.info()).rejects.toThrow('403');
+    });
+
+    it('throws on 401 Unauthorized (expired token)', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 401,
+        text: () => Promise.resolve('Invalid or expired SDK token'),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'expired-sdk');
+      await expect(client.info()).rejects.toThrow('401');
+    });
+  });
+
+  describe('Token rotation', () => {
+    it('rotateToken() calls POST /sdk/token/rotate', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          token: 'new-rotated-token',
+          expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000,
+        }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'current-sdk-token');
+      const result = await client.rotateToken();
+
+      expect(result.token).toBe('new-rotated-token');
+      expect(result.expiresAt).toBeGreaterThan(Date.now());
+
+      // Verify the request was made correctly
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:18080/sdk/token/rotate',
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer current-sdk-token',
+          }),
+        })
+      );
+    });
+
+    it('rotateToken() auto-updates internal token', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({
+          token: 'rotated-token-xyz',
+          expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000,
+        }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'old-token');
+      await client.rotateToken();
+
+      // Now make another request — should use the new token
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ hostname: 'test' }),
+        text: () => Promise.resolve(''),
+      });
+      await client.info();
+
+      // Second call should use the rotated token
+      expect(mockFetch).toHaveBeenLastCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer rotated-token-xyz',
+          }),
+        })
+      );
+    });
+
+    it('rotateToken() throws on failure', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 401,
+        text: () => Promise.resolve('Token already rotated'),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'already-rotated');
+      await expect(client.rotateToken()).rejects.toThrow('Token rotation failed');
+    });
+  });
+
+  describe('Health endpoint with TLS info', () => {
+    it('health response includes TLS fingerprint', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          ok: true,
+          hostname: 'MacBook',
+          version: '1.45.0',
+          tlsFingerprint: 'abc123def456789',
+          tlsPort: 18443,
+        }),
+        text: () => Promise.resolve(''),
+      });
+
+      const client = new P2PClient('http://localhost:18080', 'tok');
+      const info = await client.info();
+      expect(info.hostname).toBe('MacBook');
+      expect(info.version).toBe('1.45.0');
+    });
+  });
+
+  describe('Multiple SDK token scenarios', () => {
+    it('works with long token strings', async () => {
+      const longToken = 'a'.repeat(64); // 64-char hex token
+      mockFetch.mockResolvedValue({ ok: true });
+
+      const client = new P2PClient('http://localhost:18080', longToken);
+      const healthy = await client.health();
+      expect(healthy).toBe(true);
+    });
+
+    it('health check does not send auth header', async () => {
+      mockFetch.mockResolvedValue({ ok: true });
+
+      const client = new P2PClient('http://localhost:18080', 'secret-sdk');
+      await client.health();
+
+      // health() should NOT send Authorization header
+      const call = mockFetch.mock.calls[0];
+      expect(call[1].headers).toBeUndefined();
+    });
+  });
+});