@kb-labs/gateway-app 0.2.0 → 0.3.0

package/src/__tests__/execution-registry.test.ts

@@ -1,218 +0,0 @@
-/**
- * Unit tests for ExecutionRegistry (CC2 — Cancellation).
- */
-import { describe, it, expect, beforeEach } from 'vitest';
-import { ExecutionRegistry } from '../execute/execution-registry.js';
-
-function makeEntry(overrides: Partial<{
-  executionId: string;
-  requestId: string;
-  namespaceId: string;
-  hostId: string;
-  pluginId: string;
-  handlerRef: string;
-}> = {}) {
-  return {
-    executionId: 'exec-1',
-    requestId: 'req-1',
-    namespaceId: 'ns-1',
-    hostId: 'host-1',
-    pluginId: 'plugin-a',
-    handlerRef: 'handlers/run.ts',
-    ...overrides,
-  };
-}
-
-describe('ExecutionRegistry', () => {
-  let registry: ExecutionRegistry;
-
-  beforeEach(() => {
-    registry = new ExecutionRegistry();
-  });
-
-  // ── register ──────────────────────────────────────────────────────────────
-
-  describe('register()', () => {
-    it('returns an AbortSignal', () => {
-      const signal = registry.register(makeEntry());
-      expect(signal).toBeInstanceOf(AbortSignal);
-    });
-
-    it('signal is not aborted initially', () => {
-      const signal = registry.register(makeEntry());
-      expect(signal.aborted).toBe(false);
-    });
-
-    it('stores execution metadata', () => {
-      registry.register(makeEntry({ executionId: 'exec-x' }));
-      const entry = registry.get('exec-x');
-      expect(entry?.namespaceId).toBe('ns-1');
-      expect(entry?.hostId).toBe('host-1');
-      expect(entry?.pluginId).toBe('plugin-a');
-      expect(entry?.startedAt).toBeTypeOf('number');
-    });
-
-    it('increments size', () => {
-      registry.register(makeEntry({ executionId: 'a' }));
-      registry.register(makeEntry({ executionId: 'b' }));
-      expect(registry.size).toBe(2);
-    });
-  });
-
-  // ── cancel ────────────────────────────────────────────────────────────────
-
-  describe('cancel()', () => {
-    it('returns true and aborts signal', () => {
-      const signal = registry.register(makeEntry());
-      const result = registry.cancel('exec-1', 'user');
-      expect(result).toBe(true);
-      expect(signal.aborted).toBe(true);
-    });
-
-    it('stores cancellation reason on the entry', () => {
-      registry.register(makeEntry());
-      registry.cancel('exec-1', 'timeout');
-      expect(registry.get('exec-1')?.cancelledReason).toBe('timeout');
-    });
-
-    it('returns false for non-existent executionId', () => {
-      expect(registry.cancel('does-not-exist', 'user')).toBe(false);
-    });
-
-    it('returns false when already cancelled (idempotent)', () => {
-      registry.register(makeEntry());
-      expect(registry.cancel('exec-1', 'user')).toBe(true);
-      expect(registry.cancel('exec-1', 'timeout')).toBe(false);
-    });
-
-    it('abort signal reason matches provided reason', () => {
-      const signal = registry.register(makeEntry());
-      registry.cancel('exec-1', 'disconnect');
-      expect(signal.reason).toBe('disconnect');
-    });
-  });
-
-  // ── remove ────────────────────────────────────────────────────────────────
-
-  describe('remove()', () => {
-    it('removes execution from registry', () => {
-      registry.register(makeEntry());
-      registry.remove('exec-1');
-      expect(registry.get('exec-1')).toBeUndefined();
-    });
-
-    it('decrements size', () => {
-      registry.register(makeEntry({ executionId: 'a' }));
-      registry.register(makeEntry({ executionId: 'b' }));
-      registry.remove('a');
-      expect(registry.size).toBe(1);
-    });
-
-    it('is no-op for non-existent id', () => {
-      expect(() => registry.remove('ghost')).not.toThrow();
-    });
-  });
-
-  // ── get ───────────────────────────────────────────────────────────────────
-
-  describe('get()', () => {
-    it('returns undefined for unknown id', () => {
-      expect(registry.get('unknown')).toBeUndefined();
-    });
-
-    it('returns the active execution', () => {
-      registry.register(makeEntry({ executionId: 'exec-abc' }));
-      const entry = registry.get('exec-abc');
-      expect(entry?.executionId).toBe('exec-abc');
-    });
-  });
-
-  // ── cancelByHost ──────────────────────────────────────────────────────────
-
-  describe('cancelByHost()', () => {
-    it('cancels all executions for given hostId', () => {
-      const sig1 = registry.register(makeEntry({ executionId: 'e1', hostId: 'host-A' }));
-      const sig2 = registry.register(makeEntry({ executionId: 'e2', hostId: 'host-A' }));
-      const sig3 = registry.register(makeEntry({ executionId: 'e3', hostId: 'host-B' }));
-
-      const cancelled = registry.cancelByHost('host-A', 'disconnect');
-
-      expect(cancelled).toContain('e1');
-      expect(cancelled).toContain('e2');
-      expect(cancelled).not.toContain('e3');
-      expect(sig1.aborted).toBe(true);
-      expect(sig2.aborted).toBe(true);
-      expect(sig3.aborted).toBe(false);
-    });
-
-    it('returns empty array when no executions for host', () => {
-      registry.register(makeEntry({ executionId: 'e1', hostId: 'host-X' }));
-      const result = registry.cancelByHost('host-Z', 'disconnect');
-      expect(result).toEqual([]);
-    });
-
-    it('skips already-aborted executions', () => {
-      registry.register(makeEntry({ executionId: 'e1', hostId: 'host-A' }));
-      registry.cancel('e1', 'user'); // pre-cancel
-      const cancelled = registry.cancelByHost('host-A', 'disconnect');
-      expect(cancelled).not.toContain('e1');
-    });
-
-    it('returns executionIds of cancelled executions', () => {
-      registry.register(makeEntry({ executionId: 'alpha', hostId: 'host-1' }));
-      const result = registry.cancelByHost('host-1', 'disconnect');
-      expect(result).toEqual(['alpha']);
-    });
-  });
-
-  // ── size ──────────────────────────────────────────────────────────────────
-
-  describe('size', () => {
-    it('starts at 0', () => {
-      expect(registry.size).toBe(0);
-    });
-
-    it('tracks additions and removals correctly', () => {
-      registry.register(makeEntry({ executionId: 'a' }));
-      registry.register(makeEntry({ executionId: 'b' }));
-      registry.register(makeEntry({ executionId: 'c' }));
-      registry.remove('b');
-      expect(registry.size).toBe(2);
-    });
-  });
-});
-
-// ── CancelledError ────────────────────────────────────────────────────────────
-
-import { CancelledError } from '../execute/errors.js';
-
-describe('CancelledError', () => {
-  it('stores reason', () => {
-    const err = new CancelledError('timeout');
-    expect(err.reason).toBe('timeout');
-  });
-
-  it('has descriptive message', () => {
-    const err = new CancelledError('user');
-    expect(err.message).toContain('Execution cancelled');
-    expect(err.message).toContain('user');
-  });
-
-  it('has correct name', () => {
-    expect(new CancelledError('disconnect').name).toBe('CancelledError');
-  });
-
-  it('is instanceof Error', () => {
-    expect(new CancelledError('user')).toBeInstanceOf(Error);
-  });
-
-  it('is instanceof CancelledError', () => {
-    expect(new CancelledError('user')).toBeInstanceOf(CancelledError);
-  });
-
-  it('supports all cancellation reasons', () => {
-    for (const reason of ['user', 'timeout', 'disconnect'] as const) {
-      expect(() => new CancelledError(reason)).not.toThrow();
-    }
-  });
-});

package/src/__tests__/health.test.ts

@@ -1,215 +0,0 @@
-/**
- * Integration tests for Gateway /health endpoint.
- *
- * Covers:
- *   GET /health
- *     - healthy when all adapters available
- *     - degraded when non-critical adapter missing
- *     - unhealthy when LLM unavailable
- *     - includes uptime and timestamp
- *     - adapter latency reported
- *     - upstream health probing
- */
-import { describe, it, expect, vi, afterEach } from 'vitest';
-import type { ICache, ILogger } from '@kb-labs/core-platform';
-import type { JwtConfig } from '@kb-labs/gateway-auth';
-import type { GatewayConfig } from '@kb-labs/gateway-contracts';
-
-// ── Mocks ─────────────────────────────────────────────────────────────────
-
-let mockAdapters: Record<string, unknown> = {};
-
-vi.mock('@kb-labs/core-runtime', () => ({
-  platform: new Proxy(
-    {},
-    {
-      get(_target, prop) {
-        return mockAdapters[prop as string];
-      },
-    },
-  ),
-}));
-
-// Mock fetch for upstream probing
-const mockFetch = vi.fn();
-vi.stubGlobal('fetch', mockFetch);
-
-function makeCache(): ICache {
-  const store = new Map<string, unknown>();
-  return {
-    async get<T>(k: string) { return (store.get(k) as T) ?? null; },
-    async set(k: string, v: unknown) { store.set(k, v); },
-    async delete(k: string) { store.delete(k); },
-    async clear() { store.clear(); },
-  } as unknown as ICache;
-}
-
-const noopLogger: ILogger = {
-  info: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn(),
-  debug: vi.fn(),
-  child: vi.fn(() => noopLogger),
-} as unknown as ILogger;
-
-const stubJwtConfig: JwtConfig = { secret: 'test-secret' };
-
-// ── App builder ───────────────────────────────────────────────────────────
-
-async function buildHealthApp(
-  config: Partial<GatewayConfig> = {},
-) {
-  // Dynamically import createServer — it uses the mocked platform
-  const { createServer } = await import('../server.js');
-
-  const fullConfig: GatewayConfig = {
-    port: 0,
-    upstreams: {},
-    staticTokens: {},
-    ...config,
-  };
-
-  const cache = makeCache();
-  return createServer(fullConfig, cache, noopLogger, stubJwtConfig);
-}
-
-// ── Tests ─────────────────────────────────────────────────────────────────
-
-describe('Gateway /health endpoint', () => {
-  let app: Awaited<ReturnType<typeof buildHealthApp>>;
-
-  afterEach(async () => {
-    if (app) {await app.close();}
-    vi.clearAllMocks();
-  });
-
-  it('returns healthy when all adapters available', async () => {
-    mockAdapters = {
-      llm: { complete: vi.fn() },
-      cache: { get: vi.fn() },
-      analytics: { track: vi.fn() },
-      vectorStore: { search: vi.fn() },
-      embeddings: { embed: vi.fn() },
-    };
-    app = await buildHealthApp();
-
-    const res = await app.inject({ method: 'GET', url: '/health' });
-    expect(res.statusCode).toBe(200);
-
-    const body = res.json();
-    expect(body.status).toBe('healthy');
-    expect(body.version).toBe('1.0');
-    expect(body.adapters.llm.available).toBe(true);
-    expect(body.adapters.cache.available).toBe(true);
-    expect(body.adapters.analytics.available).toBe(true);
-    expect(body.adapters.vectorStore.available).toBe(true);
-    expect(body.adapters.embeddings.available).toBe(true);
-  });
-
-  it('returns degraded when non-critical adapter missing', async () => {
-    mockAdapters = {
-      llm: { complete: vi.fn() },
-      cache: { get: vi.fn() },
-      analytics: undefined,       // missing
-      vectorStore: undefined,     // missing
-      embeddings: undefined,      // missing
-    };
-    app = await buildHealthApp();
-
-    const res = await app.inject({ method: 'GET', url: '/health' });
-    const body = res.json();
-    expect(body.status).toBe('degraded');
-    expect(body.adapters.llm.available).toBe(true);
-    expect(body.adapters.analytics.available).toBe(false);
-  });
-
-  it('returns unhealthy when LLM unavailable', async () => {
-    mockAdapters = {
-      llm: undefined,             // critical missing
-      cache: { get: vi.fn() },
-      analytics: { track: vi.fn() },
-      vectorStore: undefined,
-      embeddings: undefined,
-    };
-    app = await buildHealthApp();
-
-    const res = await app.inject({ method: 'GET', url: '/health' });
-    const body = res.json();
-    expect(body.status).toBe('unhealthy');
-  });
-
-  it('includes uptime and timestamp', async () => {
-    mockAdapters = { llm: { complete: vi.fn() } };
-    app = await buildHealthApp();
-
-    const res = await app.inject({ method: 'GET', url: '/health' });
-    const body = res.json();
-    expect(typeof body.uptime).toBe('number');
-    expect(body.uptime).toBeGreaterThanOrEqual(0);
-    expect(typeof body.timestamp).toBe('string');
-    expect(new Date(body.timestamp).getTime()).toBeGreaterThan(0);
-  });
-
-  it('reports adapter latency', async () => {
-    mockAdapters = {
-      llm: { complete: vi.fn() },
-      cache: { get: vi.fn() },
-    };
-    app = await buildHealthApp();
-
-    const res = await app.inject({ method: 'GET', url: '/health' });
-    const body = res.json();
-    expect(typeof body.adapters.llm.latencyMs).toBe('number');
-    expect(body.adapters.llm.latencyMs).toBeGreaterThanOrEqual(0);
-  });
-
-  it('probes upstream health', async () => {
-    mockAdapters = { llm: { complete: vi.fn() } };
-    mockFetch.mockResolvedValueOnce({ ok: true });
-
-    app = await buildHealthApp({
-      upstreams: {
-        'rest-api': {
-          url: 'http://localhost:5050',
-          prefix: '/api/v1',
-        },
-      },
-    });
-
-    const res = await app.inject({ method: 'GET', url: '/health' });
-    const body = res.json();
-    expect(body.upstreams['rest-api']).toBeDefined();
-    expect(body.upstreams['rest-api'].status).toBe('up');
-    expect(typeof body.upstreams['rest-api'].latencyMs).toBe('number');
-  });
-
-  it('logs structured diagnostics when upstream health probe fails', async () => {
-    mockAdapters = { llm: { complete: vi.fn() } };
-    mockFetch.mockRejectedValueOnce(new Error('connect ETIMEDOUT'));
-
-    app = await buildHealthApp({
-      upstreams: {
-        workflow: {
-          url: 'http://localhost:7778',
-          prefix: '/api/v1/workflow',
-        },
-      },
-    });
-
-    const res = await app.inject({ method: 'GET', url: '/health' });
-    expect(res.statusCode).toBe(200);
-    expect(noopLogger.warn).toHaveBeenCalledWith(
-      'Gateway upstream health probe failed',
-      expect.objectContaining({
-        diagnosticEvent: 'gateway.upstream.health',
-        reasonCode: 'upstream_unavailable',
-        serviceId: 'gateway',
-        route: '/api/v1/workflow/health',
-        evidence: expect.objectContaining({
-          upstreamId: 'workflow',
-          upstreamUrl: 'http://localhost:7778',
-        }),
-      }),
-    );
-  });
-});