@intelmesh/sdk 0.1.0

package/tests/testkit/harness.test.ts

@@ -0,0 +1,291 @@
+// ---------------------------------------------------------------------------
+// Harness unit tests — mock fetch, no network calls
+// ---------------------------------------------------------------------------
+
+import { describe, expect, it, vi } from 'vitest';
+import { Harness, withHarness } from '../../src/testkit/harness.js';
+import { Provisioner } from '../../src/provision/provisioner.js';
+
+/** Tracks API key lifecycle counts. */
+interface MockState {
+  keysCreated: number;
+  keysDeleted: number;
+  eventsIngested: number;
+  idSeq: number;
+}
+
+/**
+ * Resolves the URL string from a fetch input.
+ * @param input
+ */
+function resolveUrl(input: string | URL | Request): string {
+  if (typeof input === 'string') return input;
+  if (input instanceof URL) return input.toString();
+  return input.url;
+}
+
+/**
+ * Handles POST requests in the mock fetch.
+ * @param url
+ * @param state
+ */
+// eslint-disable-next-line max-lines-per-function -- each branch is a simple JSON fixture; splitting further would obscure test data
+function handlePost(url: string, state: MockState): Response | null {
+  if (url.includes('/api/v1/api-keys')) {
+    state.keysCreated++;
+    state.idSeq++;
+    return jsonResponse({
+      data: {
+        id: `key-${String(state.idSeq)}`,
+        name: 'testkit',
+        key: 'sk-test-ephemeral',
+        enabled: true,
+        permissions: [
+          'events:write',
+          'events:simulate',
+          'rules:read',
+          'rules:write',
+          'scopes:read',
+          'scopes:write',
+          'lists:read',
+          'lists:write',
+          'scores:read',
+          'scores:write',
+          'api_keys:manage',
+          'evaluations:read',
+          'audit:read',
+        ],
+      },
+    });
+  }
+  if (url.includes('/api/v1/events/ingest')) {
+    state.eventsIngested++;
+    return jsonResponse({
+      data: {
+        event_id: `evt-${String(state.eventsIngested)}`,
+        decision: { action: 'block', severity: 'critical' },
+        transient_score: 42,
+        duration_ms: 5,
+      },
+    });
+  }
+  if (url.includes('/api/v1/events/simulate')) {
+    return jsonResponse({
+      data: {
+        event_id: 'evt-sim-1',
+        decision: { action: '', severity: '' },
+        transient_score: 0,
+        duration_ms: 3,
+      },
+    });
+  }
+  if (url.includes('/api/v1/phases')) {
+    state.idSeq++;
+    return jsonResponse({
+      data: {
+        id: `phase-${String(state.idSeq)}`,
+        name: 'p',
+        position: 1,
+        created_at: '2025-01-01T00:00:00Z',
+      },
+    });
+  }
+  if (url.includes('/api/v1/rules')) {
+    state.idSeq++;
+    return jsonResponse({
+      data: {
+        id: `rule-${String(state.idSeq)}`,
+        name: 'r',
+        phase_id: 'p1',
+        priority: 1,
+        expression: 'true',
+        applicable_when: '',
+        actions: {},
+        enabled: true,
+        dry_run: false,
+        current_version_id: 'v1',
+        created_at: '2025-01-01T00:00:00Z',
+        updated_at: '2025-01-01T00:00:00Z',
+      },
+    });
+  }
+  return null;
+}
+
+/**
+ * Creates a mock fetch for harness tests.
+ * @param state
+ */
+function createMockFetch(state: MockState): typeof globalThis.fetch {
+  return vi.fn((input: string | URL | Request, init?: RequestInit) => {
+    const url = resolveUrl(input);
+    const method = init?.method ?? 'GET';
+
+    if (method === 'POST') {
+      const res = handlePost(url, state);
+      if (res) return Promise.resolve(res);
+    }
+
+    if (method === 'DELETE') {
+      state.keysDeleted += url.includes('/api/v1/api-keys/') ? 1 : 0;
+      return Promise.resolve(jsonResponse({ data: null }));
+    }
+
+    if (method === 'GET' && url.includes('/api/v1/lists/')) {
+      return Promise.resolve(
+        jsonResponse({
+          data: {
+            id: 'list-1',
+            name: 'test-list',
+            description: '',
+            created_at: '2025-01-01T00:00:00Z',
+            updated_at: '2025-01-01T00:00:00Z',
+          },
+        }),
+      );
+    }
+
+    return Promise.resolve(new Response('Not Found', { status: 404 }));
+  }) as typeof globalThis.fetch;
+}
+
+/**
+ * Creates a JSON Response.
+ * @param body
+ */
+function jsonResponse(body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+// eslint-disable-next-line max-lines-per-function -- describe block spans multiple related test cases; splitting would fragment cohesive coverage
+describe('Harness', () => {
+  it('creates and deletes ephemeral API key', async () => {
+    const state: MockState = { keysCreated: 0, keysDeleted: 0, eventsIngested: 0, idSeq: 0 };
+    const h = createHarnessWithMockFetch(state);
+    await h.setup();
+
+    expect(state.keysCreated).toBe(1);
+    expect(h.client()).toBeTruthy();
+
+    await h.cleanup();
+    expect(state.keysDeleted).toBe(1);
+  });
+
+  it('throws when client() called before setup()', () => {
+    const state: MockState = { keysCreated: 0, keysDeleted: 0, eventsIngested: 0, idSeq: 0 };
+    const h = createHarnessWithMockFetch(state);
+    expect(() => h.client()).toThrow('call setup() first');
+  });
+
+  it('sends events and returns assertions', async () => {
+    const state: MockState = { keysCreated: 0, keysDeleted: 0, eventsIngested: 0, idSeq: 0 };
+    const h = createHarnessWithMockFetch(state);
+    await h.setup();
+
+    const assertion = await h.send('transaction.pix', { amount: 5000 });
+    assertion.expectDecision('block', 'critical');
+    assertion.expectScore(42);
+
+    expect(state.eventsIngested).toBe(1);
+    await h.cleanup();
+  });
+
+  it('expectNoDecision works for empty decisions', async () => {
+    const state: MockState = { keysCreated: 0, keysDeleted: 0, eventsIngested: 0, idSeq: 0 };
+    const h = createHarnessWithMockFetch(state);
+    await h.setup();
+
+    const assertion = await h.sendSimulate('login.success', { user: 'test' });
+    assertion.expectNoDecision();
+    assertion.expectScore(0);
+
+    await h.cleanup();
+  });
+
+  it('expectDecision throws on mismatch', async () => {
+    const state: MockState = { keysCreated: 0, keysDeleted: 0, eventsIngested: 0, idSeq: 0 };
+    const h = createHarnessWithMockFetch(state);
+    await h.setup();
+
+    const assertion = await h.send('transaction.pix', { amount: 5000 });
+    expect(() => assertion.expectDecision('allow', 'low')).toThrow('decision action');
+
+    await h.cleanup();
+  });
+
+  it('expectScore throws on mismatch', async () => {
+    const state: MockState = { keysCreated: 0, keysDeleted: 0, eventsIngested: 0, idSeq: 0 };
+    const h = createHarnessWithMockFetch(state);
+    await h.setup();
+
+    const assertion = await h.send('transaction.pix', { amount: 5000 });
+    expect(() => assertion.expectScore(99)).toThrow('score');
+
+    await h.cleanup();
+  });
+});
+
+describe('withHarness', () => {
+  it('runs setup and cleanup automatically', async () => {
+    await withHarness(
+      {
+        baseURL: 'http://localhost:8080',
+        adminKey: 'admin-key',
+      },
+      async (_harness) => {
+        // The withHarness function uses the real IntelMesh constructor,
+        // so we cannot inject mock fetch here without refactoring.
+        // This test validates the wrapper pattern compiles correctly.
+      },
+    ).catch(() => {
+      // Expected: real fetch will fail in test environment.
+    });
+  });
+});
+
+describe('Harness with Provisioner', () => {
+  it('provisions and tears down resources', async () => {
+    const state: MockState = { keysCreated: 0, keysDeleted: 0, eventsIngested: 0, idSeq: 0 };
+    const h = createHarnessWithMockFetch(state);
+    await h.setup();
+
+    const client = h.client();
+    const p = new Provisioner(client)
+      .phase('screening', 1)
+      .rule('block-rule')
+      .inPhase('screening')
+      .priority(1)
+      .when('true')
+      .decide('block', 'critical')
+      .halt()
+      .done();
+
+    await h.provision(p);
+
+    expect(p.phaseId('screening')).toBeTruthy();
+    expect(p.ruleId('block-rule')).toBeTruthy();
+
+    await h.cleanup();
+  });
+});
+
+/**
+ * Helper to create a Harness backed by mock fetch.
+ * We use the IntelMesh constructor's custom fetch option.
+ * @param state
+ */
+function createHarnessWithMockFetch(state: MockState): Harness {
+  const mockFetch = createMockFetch(state);
+
+  // Patch globalThis.fetch so the Harness (which creates IntelMesh clients
+  // internally without a custom fetch option) uses the mock.
+  globalThis.fetch = mockFetch;
+
+  return new Harness({
+    baseURL: 'http://localhost:8080',
+    adminKey: 'admin-key',
+  });
+}

package/tsconfig.eslint.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": ["node"]
+  },
+  "include": ["src", "tests"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "ignoreDeprecations": "6.0",
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "exactOptionalPropertyTypes": false,
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: false,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: ['src/generated/**'],
+    },
+  },
+});