@topolo/sdk 0.7.0 → 0.8.1

package/src/modules/p2p.test.ts

@@ -1,540 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { TopoloClient } from '../client.js';
-import { P2PModule } from './p2p.js';
-
-const AGENT = { clientName: 'topolo-sdk-test', clientVersion: '0.0.0' };
-
-function stubFetch(responses: Array<{ status?: number; body?: unknown }>) {
-  const calls: Array<{ url: string; init: RequestInit }> = [];
-  const impl = vi.fn(async (url: string, init: RequestInit) => {
-    calls.push({ url, init });
-    if (String(url).includes('/api/services/by-slug/')) {
-      return new Response(JSON.stringify({ success: true, data: { app_id: 'service_p2p' } }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-    if (String(url).includes('/api/services/catalog')) {
-      return new Response(JSON.stringify({
-        data: {
-          services: [
-            {
-              app_id: 'app_p2p',
-              app_slug: 'topolo-p2p',
-              name: 'Topolo P2P',
-              api_base_url: 'https://p2p.topolo.app',
-              launch_url: 'https://p2p.topolo.app',
-              surface_kind: 'api',
-              status: 'active',
-              granted_permissions: ['app_p2p.directory:read'],
-            },
-          ],
-        },
-      }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-    const next = responses.shift() ?? { status: 200, body: { success: true, data: {} } };
-    return new Response(JSON.stringify(next.body ?? { success: true, data: {} }), {
-      status: next.status ?? 200,
-      headers: { 'Content-Type': 'application/json' },
-    });
-  });
-  return { impl: impl as unknown as typeof fetch, calls };
-}
-
-function requestCalls(calls: Array<{ url: string; init: RequestInit }>) {
-  return calls.filter((call) =>
-    !call.url.includes('/api/services/by-slug/') &&
-    !call.url.includes('/api/services/catalog')
-  );
-}
-
-function clientWith(impl: typeof fetch) {
-  return new TopoloClient({
-    credential: { kind: 'access_token', accessToken: 'tok_test' },
-    agent: AGENT,
-    fetch: impl,
-  });
-}
-
-describe('P2PModule.listDirectory', () => {
-  beforeEach(() => {
-    TopoloClient.clearAppIdCache();
-  });
-
-  it('GETs /api/directory/capabilities and unwraps the envelope', async () => {
-    const { impl, calls } = stubFetch([
-      {
-        body: {
-          success: true,
-          data: {
-            capabilities: [
-              {
-                capability_id: 'cap_1',
-                publisher_org_id: 'org_a',
-                app_id: 'app_x',
-                name: 'Demo',
-                description: 'A capability',
-                category: 'other',
-                pricing_model: 'free',
-                pricing_amount_minor: null,
-                currency: null,
-                requires_human_approval: false,
-                supported_contexts: ['agent'],
-                trust_level: 'standard',
-                source_revision: 'rev_1',
-                synced_at: 1,
-              },
-            ],
-          },
-        },
-      },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-
-    const capabilities = await p2p.listDirectory({ limit: 10 });
-    expect(capabilities).toHaveLength(1);
-    expect(capabilities[0]!.capability_id).toBe('cap_1');
-    const call = requestCalls(calls)[0]!;
-    const url = new URL(call.url);
-    expect(url.pathname).toBe('/api/directory/capabilities');
-    expect(url.searchParams.get('limit')).toBe('10');
-    expect((call.init.method ?? 'GET').toUpperCase()).toBe('GET');
-  });
-});
-
-describe('P2PModule.publishCapability', () => {
-  it('POSTs to the internal sync route with the publisher_org_id and acting_for_org_id default', async () => {
-    const { impl, calls } = stubFetch([
-      {
-        body: {
-          success: true,
-          data: {
-            capability: {
-              capability_id: 'cap_z',
-              publisher_org_id: 'org_p',
-              app_id: 'app_x',
-              name: 'Demo',
-              description: 'A capability',
-              category: 'other',
-              pricing_model: 'fixed',
-              pricing_amount_minor: 500,
-              currency: 'USD',
-              requires_human_approval: false,
-              supported_contexts: ['agent'],
-              trust_level: 'standard',
-              source_revision: 'rev_2',
-              synced_at: 1,
-            },
-          },
-        },
-      },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-
-    const capability = await p2p.publishCapability({
-      capability_id: 'cap_z',
-      publisher_org_id: 'org_p',
-      app_id: 'app_x',
-      name: 'Demo',
-      description: 'A capability',
-      category: 'other',
-      pricing_model: 'fixed',
-      pricing_amount_minor: 500,
-      currency: 'USD',
-      supported_contexts: ['agent'],
-      public_directory_visible: true,
-      source_revision: 'rev_2',
-    });
-    expect(capability.capability_id).toBe('cap_z');
-
-    const call = requestCalls(calls)[0]!;
-    const sent = JSON.parse(String(call.init.body));
-    expect(sent.publisher_org_id).toBe('org_p');
-    expect(sent.acting_for_org_id).toBe('org_p');
-    expect(sent.public_directory_visible).toBe(true);
-    expect(sent.requires_human_approval).toBe(false);
-    expect(sent.trust_level).toBe('standard');
-    const url = new URL(call.url);
-    expect(url.pathname).toBe('/api/p2p/internal/capabilities/sync');
-    expect((call.init.method ?? '').toUpperCase()).toBe('POST');
-  });
-
-  it('honours an explicit acting_for_org_id when the platform key is publishing for another org', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { capability: null } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    await p2p.publishCapability({
-      capability_id: 'cap_other',
-      publisher_org_id: 'org_target',
-      app_id: 'app_x',
-      name: 'Demo',
-      description: '...',
-      category: 'other',
-      pricing_model: 'free',
-      supported_contexts: ['agent'],
-      public_directory_visible: true,
-      source_revision: 'rev_1',
-      acting_for_org_id: 'org_target',
-    });
-    const sent = JSON.parse(String(requestCalls(calls)[0]!.init.body));
-    expect(sent.acting_for_org_id).toBe('org_target');
-  });
-});
-
-describe('P2PModule.requestAction', () => {
-  it('rejects without an idempotency_key', async () => {
-    const { impl } = stubFetch([]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(
-      p2p.requestAction({ capability_id: 'cap_1', idempotency_key: '', inputs: {} }),
-    ).rejects.toThrow(/idempotency_key/);
-  });
-
-  it('returns the worker decision payload', async () => {
-    const { impl } = stubFetch([
-      {
-        body: {
-          success: true,
-          data: {
-            decision: 'auto_accepted',
-            idempotent: false,
-            request: { request_id: 'req_1', state: 'auto_accepted' },
-            run: null,
-          },
-        },
-      },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const result = await p2p.requestAction({
-      capability_id: 'cap_1',
-      idempotency_key: 'key_1',
-      inputs: { foo: 'bar' },
-    });
-    expect(result.decision).toBe('auto_accepted');
-    expect(result.idempotent).toBe(false);
-    expect(result.request.request_id).toBe('req_1');
-  });
-});
-
-describe('P2PModule.getCapability', () => {
-  it('returns null on a 404 from the worker', async () => {
-    const { impl } = stubFetch([{ status: 404, body: { success: false, error: 'capability_not_found' } }]);
-    const p2p = new P2PModule(clientWith(impl));
-    const capability = await p2p.getCapability('cap_missing');
-    expect(capability).toBeNull();
-  });
-});
-
-describe('P2PModule.releaseHold', () => {
-  it('POSTs the resolution + reason and returns hold + cancel entries', async () => {
-    const { impl, calls } = stubFetch([
-      {
-        body: {
-          success: true,
-          data: {
-            hold: { hold_id: 'hold_1', status: 'released' },
-            resolution: 'seller',
-            cancel_entries: [{ entry_id: 'led_1', amount_minor: 500 }],
-          },
-        },
-      },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const result = await p2p.releaseHold('hold_1', 'seller', { reason: 'arbitration' });
-    expect(result.resolution).toBe('seller');
-    expect(result.cancel_entries[0]!.entry_id).toBe('led_1');
-    const sent = JSON.parse(String(requestCalls(calls)[0]!.init.body));
-    expect(sent.resolution).toBe('seller');
-    expect(sent.reason).toBe('arbitration');
-  });
-
-  it('rejects an empty holdId', async () => {
-    const { impl } = stubFetch([]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(p2p.releaseHold('', 'buyer')).rejects.toThrow('holdId is required');
-  });
-
-  it('defaults reason to null when omitted', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { hold: { hold_id: 'h2' }, resolution: 'buyer', cancel_entries: [] } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    await p2p.releaseHold('h2', 'buyer');
-    const sent = JSON.parse(String(requestCalls(calls)[0]!.init.body));
-    expect(sent.reason).toBeNull();
-  });
-});
-
-describe('P2PModule.getCapability (additional)', () => {
-  it('rejects an empty capabilityId', async () => {
-    const { impl } = stubFetch([]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(p2p.getCapability('')).rejects.toThrow('capabilityId is required');
-  });
-
-  it('returns the unwrapped capability on success', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { capability: { capability_id: 'cap_ok' } } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const cap = await p2p.getCapability('cap ok/1');
-    expect(cap!.capability_id).toBe('cap_ok');
-    expect(requestCalls(calls)[0]!.url).toContain('/api/directory/capabilities/cap%20ok%2F1');
-  });
-
-  it('rethrows non-404 errors', async () => {
-    const { impl } = stubFetch([{ status: 500, body: { success: false, error: 'boom' } }]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(p2p.getCapability('cap_x')).rejects.toThrow();
-  });
-});
-
-describe('P2PModule.listActions', () => {
-  it('GETs /api/actions forwarding state + limit', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { actions: [{ request_id: 'req_1' }] } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const actions = await p2p.listActions({ state: 'pending', limit: 5 });
-    expect(actions).toHaveLength(1);
-    const url = new URL(requestCalls(calls)[0]!.url);
-    expect(url.pathname).toBe('/api/actions');
-    expect(url.searchParams.get('state')).toBe('pending');
-    expect(url.searchParams.get('limit')).toBe('5');
-  });
-});
-
-describe('P2PModule.getAction', () => {
-  it('rejects an empty requestId', async () => {
-    const { impl } = stubFetch([]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(p2p.getAction('')).rejects.toThrow('requestId is required');
-  });
-
-  it('returns the action detail on success', async () => {
-    const { impl } = stubFetch([
-      { body: { success: true, data: { request: { request_id: 'req_2' } } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const detail = await p2p.getAction('req_2');
-    expect(detail).toMatchObject({ request: { request_id: 'req_2' } });
-  });
-
-  it('returns null on 404', async () => {
-    const { impl } = stubFetch([{ status: 404, body: { success: false, error: 'not_found' } }]);
-    const p2p = new P2PModule(clientWith(impl));
-    expect(await p2p.getAction('req_missing')).toBeNull();
-  });
-});
-
-describe('P2PModule.requestAction (validation + happy path)', () => {
-  it('rejects a missing capability_id', async () => {
-    const { impl } = stubFetch([]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(
-      p2p.requestAction({ capability_id: '', idempotency_key: 'k', inputs: {} }),
-    ).rejects.toThrow('capability_id is required');
-  });
-
-  it('POSTs the request and defaults inputs to {}', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { request_id: 'req_new', status: 'requested' } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const result = await p2p.requestAction({ capability_id: 'cap_1', idempotency_key: 'idem_1' });
-    expect(result).toMatchObject({ request_id: 'req_new' });
-    const call = requestCalls(calls)[0]!;
-    expect(new URL(call.url).pathname).toBe('/api/actions/request');
-    const sent = JSON.parse(String(call.init.body));
-    expect(sent.idempotency_key).toBe('idem_1');
-    expect(sent.inputs).toEqual({});
-  });
-});
-
-describe('P2PModule.respondAction / completeAction / disputeAction', () => {
-  it('respondAction POSTs response + extras and unwraps request', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { request: { request_id: 'req_3', state: 'accepted' } } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const row = await p2p.respondAction('req_3', 'accepted', { quote_minor: 100 });
-    expect(row).toMatchObject({ request_id: 'req_3', state: 'accepted' });
-    const call = requestCalls(calls)[0]!;
-    expect(new URL(call.url).pathname).toBe('/api/actions/req_3/respond');
-    const sent = JSON.parse(String(call.init.body));
-    expect(sent.response).toBe('accepted');
-    expect(sent.quote_minor).toBe(100);
-  });
-
-  it('respondAction rejects an empty requestId', async () => {
-    const { impl } = stubFetch([]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(p2p.respondAction('', 'rejected')).rejects.toThrow('requestId is required');
-  });
-
-  it('completeAction POSTs the result payload', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { request: { request_id: 'req_4' } } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    await p2p.completeAction('req_4', { output: 'done' });
-    const call = requestCalls(calls)[0]!;
-    expect(new URL(call.url).pathname).toBe('/api/actions/req_4/complete');
-    expect(JSON.parse(String(call.init.body)).result).toEqual({ output: 'done' });
-  });
-
-  it('completeAction rejects an empty requestId', async () => {
-    const { impl } = stubFetch([]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(p2p.completeAction('')).rejects.toThrow('requestId is required');
-  });
-
-  it('disputeAction POSTs the reason', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { request: { request_id: 'req_5' } } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    await p2p.disputeAction('req_5', 'wrong output');
-    const call = requestCalls(calls)[0]!;
-    expect(new URL(call.url).pathname).toBe('/api/actions/req_5/dispute');
-    expect(JSON.parse(String(call.init.body)).reason).toBe('wrong output');
-  });
-
-  it('disputeAction rejects an empty requestId', async () => {
-    const { impl } = stubFetch([]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(p2p.disputeAction('', 'reason')).rejects.toThrow('requestId is required');
-  });
-});
-
-describe('P2PModule.getPolicy / updatePolicy', () => {
-  it('getPolicy GETs /api/policies and unwraps the policy', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { policy: { organization_id: 'org_a', auto_accept: false } } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const policy = await p2p.getPolicy();
-    expect(policy).toMatchObject({ organization_id: 'org_a' });
-    expect(new URL(requestCalls(calls)[0]!.url).pathname).toBe('/api/policies');
-  });
-
-  it('updatePolicy PUTs the partial policy', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { policy: { organization_id: 'org_a', auto_accept: true } } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const policy = await p2p.updatePolicy({ auto_accept: true } as never);
-    expect(policy).toMatchObject({ auto_accept: true });
-    const call = requestCalls(calls)[0]!;
-    expect((call.init.method ?? '').toUpperCase()).toBe('PUT');
-    expect(JSON.parse(String(call.init.body)).auto_accept).toBe(true);
-  });
-});
-
-describe('P2PModule connections', () => {
-  it('listConnections GETs /api/connections', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { connections: [{ connection_id: 'conn_1' }] } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const conns = await p2p.listConnections();
-    expect(conns).toHaveLength(1);
-    expect(new URL(requestCalls(calls)[0]!.url).pathname).toBe('/api/connections');
-  });
-
-  it('createConnection POSTs counterparty + default active status', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { connection: { connection_id: 'conn_2', status: 'active' } } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const conn = await p2p.createConnection('org_other');
-    expect(conn.status).toBe('active');
-    const sent = JSON.parse(String(requestCalls(calls)[0]!.init.body));
-    expect(sent.counterparty_org_id).toBe('org_other');
-    expect(sent.status).toBe('active');
-  });
-
-  it('createConnection honors an explicit status', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { connection: { connection_id: 'conn_3', status: 'pending' } } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    await p2p.createConnection('org_other', { status: 'pending' });
-    expect(JSON.parse(String(requestCalls(calls)[0]!.init.body)).status).toBe('pending');
-  });
-
-  it('createConnection rejects an empty counterpartyOrgId', async () => {
-    const { impl } = stubFetch([]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(p2p.createConnection('')).rejects.toThrow('counterpartyOrgId is required');
-  });
-
-  it('revokeConnection DELETEs the encoded connection id', async () => {
-    const { impl, calls } = stubFetch([{ body: { success: true, data: {} } }]);
-    const p2p = new P2PModule(clientWith(impl));
-    await p2p.revokeConnection('conn/9');
-    const call = requestCalls(calls)[0]!;
-    expect((call.init.method ?? '').toUpperCase()).toBe('DELETE');
-    expect(call.url).toContain('/api/connections/conn%2F9');
-  });
-
-  it('revokeConnection rejects an empty connectionId', async () => {
-    const { impl } = stubFetch([]);
-    const p2p = new P2PModule(clientWith(impl));
-    await expect(p2p.revokeConnection('')).rejects.toThrow('connectionId is required');
-  });
-});
-
-describe('P2PModule ledger + settlements', () => {
-  it('listLedger GETs /api/ledger and unwraps entries', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { ledger_entries: [{ entry_id: 'led_1' }] } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const entries = await p2p.listLedger();
-    expect(entries).toHaveLength(1);
-    expect(new URL(requestCalls(calls)[0]!.url).pathname).toBe('/api/ledger');
-  });
-
-  it('previewSettlements POSTs filters and unwraps groups', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { groups: [{ buyer_org_id: 'org_b', seller_org_id: 'org_s' }] } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const groups = await p2p.previewSettlements({ currency: 'USD' });
-    expect(groups).toHaveLength(1);
-    const call = requestCalls(calls)[0]!;
-    expect(new URL(call.url).pathname).toBe('/api/settlements/preview');
-    expect(JSON.parse(String(call.init.body)).currency).toBe('USD');
-  });
-
-  it('createSettlement defaults trigger to manual and unwraps batch + group', async () => {
-    const { impl, calls } = stubFetch([
-      {
-        body: {
-          success: true,
-          data: { batch: { batch_id: 'bat_1' }, group: { buyer_org_id: 'org_b' } },
-        },
-      },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    const result = await p2p.createSettlement({ buyer_org_id: 'org_b' });
-    expect(result.batch.batch_id).toBe('bat_1');
-    const sent = JSON.parse(String(requestCalls(calls)[0]!.init.body));
-    expect(sent.trigger).toBe('manual');
-    expect(sent.buyer_org_id).toBe('org_b');
-  });
-
-  it('createSettlement honors an explicit trigger override', async () => {
-    const { impl, calls } = stubFetch([
-      { body: { success: true, data: { batch: { batch_id: 'bat_2' }, group: {} } } },
-    ]);
-    const p2p = new P2PModule(clientWith(impl));
-    await p2p.createSettlement({ trigger: 'schedule' });
-    expect(JSON.parse(String(requestCalls(calls)[0]!.init.body)).trigger).toBe('schedule');
-  });
-});