Add actor mock helper and tests

transphorm · transphorm · commit 547cf6e9fca2 · 2025-07-06T18:22:54.000-07:00
diff --git a/app/tests/utils/proving/actorMock.ts b/app/tests/utils/proving/actorMock.ts
@@ -0,0 +1,20 @@
+import { jest } from '@jest/globals';
+
+// Minimal actor stub used to observe send calls and emit state transitions
+
+export const actorMock = {
+  start: jest.fn(),
+  stop: jest.fn(),
+  send: jest.fn(),
+  subscribe: jest.fn((cb: (state: any) => void) => {
+    (actorMock as any)._callback = cb;
+    return { unsubscribe: jest.fn() };
+  }),
+};
+
+export function emitState(stateValue: string) {
+  const cb = (actorMock as any)._callback;
+  if (cb) {
+    cb({ value: stateValue, matches: (v: string) => v === stateValue });
+  }
+}
diff --git a/app/tests/utils/proving/provingMachine.generatePayload.test.ts b/app/tests/utils/proving/provingMachine.generatePayload.test.ts
@@ -0,0 +1,92 @@
+import { jest } from '@jest/globals';
+import { useProvingStore } from '../../../src/utils/proving/provingMachine';
+import { useProtocolStore } from '../../../src/stores/protocolStore';
+import { useSelfAppStore } from '../../../src/stores/selfAppStore';
+
+jest.mock('xstate', () => {
+  const actual = jest.requireActual('xstate');
+  const { actorMock } = require('./actorMock');
+  return { ...actual, createActor: jest.fn(() => actorMock) };
+});
+
+jest.mock('../../../src/utils/analytics', () => () => ({ trackEvent: jest.fn() }));
+
+jest.mock('@selfxyz/common', () => {
+  const actual = jest.requireActual('@selfxyz/common');
+  return { ...actual, getSolidityPackedUserContextData: jest.fn(() => '0x1234') };
+});
+
+jest.mock('../../../src/utils/proving/provingInputs', () => ({
+  generateTEEInputsRegister: jest.fn(() => ({
+    inputs: { r: 1 },
+    circuitName: 'reg',
+    endpointType: 'celo',
+    endpoint: 'https://reg',
+  })),
+  generateTEEInputsDSC: jest.fn(() => ({
+    inputs: { d: 1 },
+    circuitName: 'dsc',
+    endpointType: 'celo',
+    endpoint: 'https://dsc',
+  })),
+  generateTEEInputsDisclose: jest.fn(() => ({
+    inputs: { s: 1 },
+    circuitName: 'vc_and_disclose',
+    endpointType: 'https',
+    endpoint: 'https://dis',
+  })),
+}));
+
+jest.mock('../../../src/utils/proving/provingUtils', () => {
+  const actual = jest.requireActual('../../../src/utils/proving/provingUtils');
+  return {
+    ...actual,
+    getPayload: jest.fn(() => ({ mocked: true })),
+    encryptAES256GCM: jest.fn(() => ({ nonce: [0], cipher_text: [1], auth_tag: [2] })),
+  };
+});
+
+const { getPayload, encryptAES256GCM } = require('../../../src/utils/proving/provingUtils');
+const { generateTEEInputsRegister, generateTEEInputsDSC, generateTEEInputsDisclose } = require('../../../src/utils/proving/provingInputs');
+
+describe('_generatePayload', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useProvingStore.setState({
+      circuitType: 'register',
+      passportData: { documentCategory: 'passport', mock: false },
+      secret: 'sec',
+      uuid: '123',
+      sharedKey: Buffer.alloc(32, 1),
+      env: 'prod',
+    });
+    useSelfAppStore.setState({ selfApp: { chainID: 1, userId: 'u', userDefinedData: '0x0', endpointType: 'https', endpoint: 'https://e', scope: 's', sessionId: '', appName: '', logoBase64: '', header: '', userIdType: 'uuid', devMode: false, disclosures: {}, version: 1 } });
+    useProtocolStore.setState({ passport: { dsc_tree: 'tree', csca_tree: [['a']], commitment_tree: null, deployed_circuits: null, circuits_dns_mapping: null, alternative_csca: {} }, id_card: { commitment_tree: null, dsc_tree: null, csca_tree: null, deployed_circuits: null, circuits_dns_mapping: null, alternative_csca: {} } });
+  });
+
+  it('register circuit', async () => {
+    useProvingStore.setState({ circuitType: 'register' });
+    const payload = await useProvingStore.getState()._generatePayload();
+    expect(generateTEEInputsRegister).toHaveBeenCalled();
+    expect(getPayload).toHaveBeenCalled();
+    expect(encryptAES256GCM).toHaveBeenCalled();
+    expect(useProvingStore.getState().endpointType).toBe('celo');
+    expect(payload.params).toEqual({ uuid: '123', nonce: [0], cipher_text: [1], auth_tag: [2] });
+  });
+
+  it('dsc circuit', async () => {
+    useProvingStore.setState({ circuitType: 'dsc' });
+    const payload = await useProvingStore.getState()._generatePayload();
+    expect(generateTEEInputsDSC).toHaveBeenCalled();
+    expect(useProvingStore.getState().endpointType).toBe('celo');
+    expect(payload.params.uuid).toBe('123');
+  });
+
+  it('disclose circuit', async () => {
+    useProvingStore.setState({ circuitType: 'disclose' });
+    const payload = await useProvingStore.getState()._generatePayload();
+    expect(generateTEEInputsDisclose).toHaveBeenCalled();
+    expect(useProvingStore.getState().endpointType).toBe('https');
+    expect(payload.params.uuid).toBe('123');
+  });
+});
diff --git a/app/tests/utils/proving/provingMachine.init.test.ts b/app/tests/utils/proving/provingMachine.init.test.ts
@@ -0,0 +1,48 @@
+import { jest } from '@jest/globals';
+import { useProvingStore } from '../../../src/utils/proving/provingMachine';
+import { emitState } from './actorMock';
+
+jest.mock('xstate', () => {
+  const actual = jest.requireActual('xstate');
+  const { actorMock } = require('./actorMock');
+  return { ...actual, createActor: jest.fn(() => actorMock) };
+});
+
+jest.mock('../../../src/providers/passportDataProvider', () => ({
+  loadSelectedDocument: jest.fn(),
+}));
+
+jest.mock('../../../src/providers/authProvider', () => ({
+  unsafe_getPrivateKey: jest.fn(),
+}));
+
+jest.mock('../../../src/utils/analytics', () => () => ({ trackEvent: jest.fn() }));
+
+const { loadSelectedDocument } = require('../../../src/providers/passportDataProvider');
+const { unsafe_getPrivateKey } = require('../../../src/providers/authProvider');
+const { actorMock } = require('./actorMock');
+
+describe('provingMachine init', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useProvingStore.setState({});
+  });
+
+  it('handles missing document', async () => {
+    loadSelectedDocument.mockResolvedValue(null);
+    await useProvingStore.getState().init('register');
+    expect(actorMock.send).toHaveBeenCalledWith({ type: 'PASSPORT_DATA_NOT_FOUND' });
+    emitState('passport_data_not_found');
+    expect(useProvingStore.getState().currentState).toBe('passport_data_not_found');
+  });
+
+  it('initializes state with document and secret', async () => {
+    loadSelectedDocument.mockResolvedValue({ data: { documentCategory: 'passport', mock: false } });
+    unsafe_getPrivateKey.mockResolvedValue('mysecret');
+    await useProvingStore.getState().init('register');
+    expect(useProvingStore.getState().passportData).toEqual({ documentCategory: 'passport', mock: false });
+    expect(useProvingStore.getState().secret).toBe('mysecret');
+    expect(useProvingStore.getState().env).toBe('prod');
+    expect(useProvingStore.getState().circuitType).toBe('register');
+  });
+});
diff --git a/app/tests/utils/proving/provingMachine.websocket.test.ts b/app/tests/utils/proving/provingMachine.websocket.test.ts
@@ -0,0 +1,74 @@
+import { jest } from '@jest/globals';
+import { useProvingStore } from '../../../src/utils/proving/provingMachine';
+
+
+jest.mock('xstate', () => {
+  const actual = jest.requireActual('xstate');
+  const { actorMock } = require('./actorMock');
+  return { ...actual, createActor: jest.fn(() => actorMock) };
+});
+
+jest.mock('../../../src/utils/analytics', () => () => ({ trackEvent: jest.fn() }));
+jest.mock('uuid', () => ({ v4: jest.fn(() => 'uuid') }));
+
+jest.mock('../../../src/utils/proving/attest', () => ({
+  getPublicKey: jest.fn(() => '04' + 'a'.repeat(128)),
+  verifyAttestation: jest.fn(() => Promise.resolve(true)),
+}));
+jest.mock('../../../src/utils/proving/provingUtils', () => ({
+  ec: { keyFromPublic: jest.fn(() => ({ getPublic: jest.fn() })) },
+  clientKey: { derive: jest.fn(() => ({ toArray: () => Array(32).fill(1) })) },
+  clientPublicKeyHex: '00',
+}));
+
+jest.mock('../../../src/providers/passportDataProvider', () => ({
+  loadSelectedDocument: jest.fn(() => Promise.resolve({ data: { documentCategory: 'passport', mock: false } })),
+}));
+
+jest.mock('../../../src/providers/authProvider', () => ({
+  unsafe_getPrivateKey: jest.fn(() => Promise.resolve('sec')),
+}));
+
+const { actorMock } = require('./actorMock');
+
+const { verifyAttestation } = require('../../../src/utils/proving/attest');
+
+describe('websocket handlers', () => {
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    useProvingStore.setState({ wsConnection: { send: jest.fn(), addEventListener: jest.fn(), removeEventListener: jest.fn(), close: jest.fn() } as any });
+    await useProvingStore.getState().init('register');
+    useProvingStore.setState({ wsConnection: { send: jest.fn(), addEventListener: jest.fn(), removeEventListener: jest.fn(), close: jest.fn() } as any });
+  });
+
+  it('_handleWsOpen sends hello', () => {
+    useProvingStore.getState()._handleWsOpen();
+    const ws = useProvingStore.getState().wsConnection as any;
+    expect(ws.send).toHaveBeenCalled();
+    const sent = JSON.parse(ws.send.mock.calls[0][0]);
+    expect(sent.params.uuid).toBe('uuid');
+    expect(useProvingStore.getState().uuid).toBe('uuid');
+  });
+
+  it('_handleWebSocketMessage processes attestation', async () => {
+    const message = new MessageEvent('message', { data: JSON.stringify({ result: { attestation: 'a' } }) });
+    await useProvingStore.getState()._handleWebSocketMessage(message);
+    expect(verifyAttestation).toHaveBeenCalled();
+    expect(actorMock.send.mock.calls.some(c => c[0].type === 'CONNECT_SUCCESS')).toBe(true);
+  });
+
+  it('_handleWebSocketMessage handles error', async () => {
+    const message = new MessageEvent('message', { data: JSON.stringify({ error: 'oops' }) });
+    await useProvingStore.getState()._handleWebSocketMessage(message);
+    const lastCall = actorMock.send.mock.calls.pop();
+    expect(lastCall[0]).toEqual({ type: 'PROVE_ERROR' });
+  });
+
+  it('_handleWsClose triggers failure during proving', () => {
+    useProvingStore.setState({ currentState: 'proving' });
+    const event: any = { code: 1000, reason: '', type: 'close' };
+    useProvingStore.getState()._handleWsClose(event);
+    const last = actorMock.send.mock.calls.pop();
+    expect(last[0]).toEqual({ type: 'PROVE_ERROR' });
+  });
+});
diff --git a/app/tests/utils/proving/provingUtils.test.ts b/app/tests/utils/proving/provingUtils.test.ts
@@ -0,0 +1,73 @@
+import forge from 'node-forge';
+import {
+  encryptAES256GCM,
+  getPayload,
+  getWSDbRelayerUrl,
+} from '../../../src/utils/proving/provingUtils';
+
+describe('provingUtils', () => {
+  it('encryptAES256GCM encrypts and decrypts correctly', () => {
+    const key = forge.random.getBytesSync(32);
+    const plaintext = 'hello world';
+    const encrypted = encryptAES256GCM(plaintext, forge.util.createBuffer(key));
+
+    const decipher = forge.cipher.createDecipher('AES-GCM', forge.util.createBuffer(key));
+    decipher.start({
+      iv: Buffer.from(encrypted.nonce).toString('binary'),
+      tagLength: 128,
+      tag: forge.util.createBuffer(Buffer.from(encrypted.auth_tag).toString('binary')),
+    });
+    decipher.update(
+      forge.util.createBuffer(Buffer.from(encrypted.cipher_text).toString('binary')),
+    );
+    const success = decipher.finish();
+    const decrypted = decipher.output.toString();
+
+    expect(success).toBe(true);
+    expect(decrypted).toBe(plaintext);
+  });
+
+  it('getPayload returns disclose payload', () => {
+    const inputs = { foo: 'bar' };
+    const payload = getPayload(
+      inputs,
+      'disclose',
+      'vc_and_disclose',
+      'https',
+      'https://example.com',
+      2,
+      '0xabc',
+    );
+    expect(payload).toEqual({
+      type: 'disclose',
+      endpointType: 'https',
+      endpoint: 'https://example.com',
+      onchain: false,
+      circuit: { name: 'vc_and_disclose', inputs: JSON.stringify(inputs) },
+      version: 2,
+      userDefinedData: '0xabc',
+    });
+  });
+
+  it('getPayload returns register payload', () => {
+    const payload = getPayload(
+      { a: 1 },
+      'register',
+      'register_circuit',
+      'celo',
+      'https://self.xyz',
+    );
+    expect(payload).toEqual({
+      type: 'register',
+      onchain: true,
+      endpointType: 'celo',
+      circuit: { name: 'register_circuit', inputs: JSON.stringify({ a: 1 }) },
+    });
+  });
+
+  it('getWSDbRelayerUrl handles endpoint types', () => {
+    expect(getWSDbRelayerUrl('celo')).toContain('websocket.self.xyz');
+    expect(getWSDbRelayerUrl('https')).toContain('websocket.self.xyz');
+    expect(getWSDbRelayerUrl('staging_celo')).toContain('websocket.staging.self.xyz');
+  });
+});
