@studio-foundation/api 0.3.0-beta.1 → 0.3.0-beta.5

package/tests/integration-runtime.test.ts

@@ -1,199 +0,0 @@
-import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
-import { resolve } from 'node:path';
-import { mkdirSync } from 'node:fs';
-import Fastify from 'fastify';
-import { IntegrationRuntime } from '../src/integration-runtime.js';
-import { IntegrationStore } from '../src/integration-store.js';
-import type { IntegrationPluginDef } from '@studio-foundation/contracts';
-
-function makeLinearIntegration(): IntegrationPluginDef {
-  return {
-    name: 'linear',
-    version: 1,
-    webhook: {
-      hmac: { header: 'linear-signature', secret_env: 'LINEAR_WEBHOOK_SECRET' },
-      handler: 'linear-webhook',
-    },
-    on_failure: { handler: 'linear-failure' },
-  };
-}
-
-function makeRuntime(integrations: IntegrationPluginDef[], integrationConfigs: Record<string, Record<string, unknown>> = {}) {
-  const dir = resolve('/tmp', `.studio-rt-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(dir, { recursive: true });
-  const store = new IntegrationStore(resolve(dir, 'runs.db'));
-  const launcher = { launch: vi.fn(), cancel: vi.fn(), subscribe: vi.fn(() => () => {}) };
-  const runtime = new IntegrationRuntime({
-    integrations,
-    store,
-    launcher: launcher as never,
-    configsDir: dir,
-    projectsDir: undefined,
-    apiConfig: {},
-    integrationConfigs,
-  });
-  return { runtime, store, launcher, dir, cleanup: () => store.close() };
-}
-
-describe('IntegrationRuntime.registerRoutes', () => {
-  test('registers GET route for integration with webhook handler', async () => {
-    const { runtime, store, cleanup } = makeRuntime([makeLinearIntegration()]);
-    store.patchConfig('linear', { active: true });
-
-    const fastify = Fastify();
-    runtime.registerRoutes(fastify, '/api');
-    await fastify.ready();
-
-    const res = await fastify.inject({ method: 'GET', url: '/api/integrations/linear' });
-    expect(res.statusCode).toBe(200);
-    const body = res.json<{ active: boolean; triggers: unknown[]; webhook_url: string; pipeline: unknown }>();
-    expect(body.active).toBe(true);
-    expect(body.triggers).toEqual([]);
-    expect(body.webhook_url).toContain('/api/integrations/linear/webhook');
-
-    await fastify.close();
-    cleanup();
-  });
-
-  test('PATCH updates config', async () => {
-    const { runtime, store, cleanup } = makeRuntime([makeLinearIntegration()]);
-
-    const fastify = Fastify();
-    runtime.registerRoutes(fastify, '/api');
-    await fastify.ready();
-
-    const res = await fastify.inject({
-      method: 'PATCH',
-      url: '/api/integrations/linear',
-      headers: { 'content-type': 'application/json' },
-      payload: JSON.stringify({ pipeline: 'my-pipeline', active: true }),
-    });
-    expect(res.statusCode).toBe(200);
-    expect(res.json<{ pipeline: string }>().pipeline).toBe('my-pipeline');
-    expect(store.getConfig('linear').pipeline).toBe('my-pipeline');
-
-    await fastify.close();
-    cleanup();
-  });
-
-  test('POST webhook delegates to LinearWebhookHandler (In Progress → 202)', async () => {
-    const { runtime, store, cleanup } = makeRuntime([makeLinearIntegration()]);
-    store.patchConfig('linear', { active: true });
-
-    const fastify = Fastify();
-    runtime.registerRoutes(fastify, '/api');
-    await fastify.ready();
-
-    const payload = {
-      type: 'Issue', action: 'update',
-      data: { id: 'issue-1', identifier: 'STU-1', title: 'Test', state: { name: 'In Progress' } },
-    };
-    const res = await fastify.inject({
-      method: 'POST',
-      url: '/api/integrations/linear/webhook',
-      headers: { 'content-type': 'application/json' },
-      payload: JSON.stringify(payload),
-    });
-    expect(res.statusCode).toBe(202);
-    expect(res.json<{ run_id: string }>().run_id).toBeDefined();
-
-    await fastify.close();
-    cleanup();
-  });
-
-  test('does not register routes for integration without webhook handler', async () => {
-    const noWebhook: IntegrationPluginDef = { name: 'noop', version: 1 };
-    const { runtime, cleanup } = makeRuntime([noWebhook]);
-
-    const fastify = Fastify();
-    runtime.registerRoutes(fastify, '/api');
-    await fastify.ready();
-
-    const res = await fastify.inject({ method: 'GET', url: '/api/integrations/noop' });
-    expect(res.statusCode).toBe(404);
-
-    await fastify.close();
-    cleanup();
-  });
-});
-
-describe('IntegrationRuntime.setupEventBus', () => {
-  test('calls failure handler for failed pipeline_complete with linear_issue_id in meta', async () => {
-    const failureHandleSpy = vi.fn().mockResolvedValue(undefined);
-    const { FAILURE_HANDLERS } = await import('../src/integrations/registry.js');
-    const original = FAILURE_HANDLERS['linear-failure'];
-    FAILURE_HANDLERS['linear-failure'] = { handleFailure: failureHandleSpy };
-
-    const { runtime, cleanup } = makeRuntime([makeLinearIntegration()]);
-
-    const listeners: Array<(runId: string, event: { type: string; data: unknown }) => void> = [];
-    const mockBus = {
-      subscribeAll: vi.fn((fn: (runId: string, event: { type: string; data: unknown }) => void) => {
-        listeners.push(fn);
-        return () => {};
-      }),
-    };
-
-    runtime.setupEventBus(mockBus as never);
-
-    for (const listener of listeners) {
-      listener('run-abc', {
-        type: 'pipeline_complete',
-        data: { status: 'failed', duration_ms: 5000, meta: { linear_issue_id: 'issue-x' }, last_group_feedback: undefined },
-      });
-    }
-
-    await new Promise(r => setTimeout(r, 20));
-    expect(failureHandleSpy).toHaveBeenCalledTimes(1);
-    const ctx = failureHandleSpy.mock.calls[0][0] as { runId: string; status: string; meta: Record<string, unknown> };
-    expect(ctx.runId).toBe('run-abc');
-    expect(ctx.status).toBe('failed');
-    expect(ctx.meta['linear_issue_id']).toBe('issue-x');
-
-    FAILURE_HANDLERS['linear-failure'] = original;
-    cleanup();
-  });
-
-  test('does not call failure handler for successful pipeline', async () => {
-    const failureHandleSpy = vi.fn().mockResolvedValue(undefined);
-    const { FAILURE_HANDLERS } = await import('../src/integrations/registry.js');
-    const original = FAILURE_HANDLERS['linear-failure'];
-    FAILURE_HANDLERS['linear-failure'] = { handleFailure: failureHandleSpy };
-
-    const { runtime, cleanup } = makeRuntime([makeLinearIntegration()]);
-
-    const listeners: Array<(runId: string, event: { type: string; data: unknown }) => void> = [];
-    const mockBus = {
-      subscribeAll: vi.fn((fn: (runId: string, event: { type: string; data: unknown }) => void) => {
-        listeners.push(fn);
-        return () => {};
-      }),
-    };
-    runtime.setupEventBus(mockBus as never);
-
-    for (const listener of listeners) {
-      listener('run-ok', {
-        type: 'pipeline_complete',
-        data: { status: 'success', duration_ms: 1000, meta: { linear_issue_id: 'issue-x' } },
-      });
-    }
-
-    await new Promise(r => setTimeout(r, 20));
-    expect(failureHandleSpy).not.toHaveBeenCalled();
-
-    FAILURE_HANDLERS['linear-failure'] = original;
-    cleanup();
-  });
-
-  test('does not subscribe when integration has no on_failure handler', async () => {
-    const noFailure: IntegrationPluginDef = { name: 'linear', version: 1, webhook: { handler: 'linear-webhook' } };
-    const { runtime, cleanup } = makeRuntime([noFailure]);
-
-    const mockBus = { subscribeAll: vi.fn(() => () => {}) };
-    runtime.setupEventBus(mockBus as never);
-
-    // subscribeAll may still be called for other reasons, but failure handler must not fire
-    // Test that if it is called, no failure is dispatched
-    cleanup();
-  });
-});

package/tests/integration-store.test.ts

@@ -1,66 +0,0 @@
-import { describe, test, expect } from 'vitest';
-import { resolve } from 'node:path';
-import { mkdirSync } from 'node:fs';
-import { IntegrationStore } from '../src/integration-store.js';
-
-function makeStore() {
-  const dir = resolve('/tmp', `.studio-int-store-${Date.now()}`);
-  mkdirSync(dir, { recursive: true });
-  const store = new IntegrationStore(resolve(dir, 'runs.db'));
-  return { store, cleanup: () => store.close() };
-}
-
-describe('IntegrationStore', () => {
-  test('getConfig returns defaults for unknown integration', () => {
-    const { store, cleanup } = makeStore();
-    const config = store.getConfig('linear');
-    expect(config).toEqual({ active: false });
-    cleanup();
-  });
-
-  test('patchConfig stores and retrieves pipeline and active', () => {
-    const { store, cleanup } = makeStore();
-    store.patchConfig('linear', { pipeline: 'feature-builder', active: true });
-    expect(store.getConfig('linear')).toEqual({ pipeline: 'feature-builder', active: true });
-    cleanup();
-  });
-
-  test('patchConfig for one integration does not affect another', () => {
-    const { store, cleanup } = makeStore();
-    store.patchConfig('linear', { active: true });
-    expect(store.getConfig('slack').active).toBe(false);
-    cleanup();
-  });
-
-  test('insertTrigger and listTriggers are partitioned by integration_name', () => {
-    const { store, cleanup } = makeStore();
-    store.insertTrigger({
-      id: 'trig-1',
-      integration_name: 'linear',
-      received_at: new Date().toISOString(),
-      pipeline: 'feature-builder',
-      run_id: 'run-1',
-      status: 'success',
-    });
-    store.insertTrigger({
-      id: 'trig-2',
-      integration_name: 'slack',
-      received_at: new Date().toISOString(),
-      pipeline: 'feature-builder',
-      run_id: 'run-2',
-      status: 'success',
-    });
-    expect(store.listTriggers('linear')).toHaveLength(1);
-    expect(store.listTriggers('linear')[0].id).toBe('trig-1');
-    expect(store.listTriggers('slack')).toHaveLength(1);
-    cleanup();
-  });
-
-  test('listTriggers returns most recent first', () => {
-    const { store, cleanup } = makeStore();
-    store.insertTrigger({ id: 'a', integration_name: 'linear', received_at: '2024-01-01T00:00:00Z', pipeline: 'p', status: 'success' });
-    store.insertTrigger({ id: 'b', integration_name: 'linear', received_at: '2024-01-02T00:00:00Z', pipeline: 'p', status: 'success' });
-    expect(store.listTriggers('linear')[0].id).toBe('b');
-    cleanup();
-  });
-});

package/tests/integrations/linear/failure-handler.test.ts

@@ -1,113 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { LinearFailureHandler } from '../../../src/integrations/linear/failure-handler.js';
-
-const mockFetch = vi.fn();
-vi.stubGlobal('fetch', mockFetch);
-
-const STATES_RESPONSE = {
-  data: {
-    issue: {
-      team: {
-        states: { nodes: [{ id: 'state-backlog', name: 'Backlog' }, { id: 'state-todo', name: 'Todo' }] },
-      },
-    },
-  },
-};
-const COMMENT_RESPONSE = { data: { commentCreate: { success: true } } };
-const UPDATE_RESPONSE = { data: { issueUpdate: { success: true } } };
-
-function makeCtx(overrides: {
-  apiKey?: string;
-  issueId?: string;
-  runId?: string;
-  iterations?: number;
-  rejectionReason?: string;
-  rejectionDetails?: string[];
-} = {}) {
-  return {
-    runId: overrides.runId ?? 'run-123',
-    durationMs: 5000,
-    status: 'failed',
-    meta: { linear_issue_id: overrides.issueId ?? 'issue-abc' },
-    lastGroupFeedback: overrides.iterations != null ? {
-      iteration: overrides.iterations,
-      rejection_reason: overrides.rejectionReason,
-      rejection_details: overrides.rejectionDetails,
-    } as never : undefined,
-    integration: { name: 'linear', version: 1, on_failure: { handler: 'linear-failure' } },
-    integrationConfig: { LINEAR_API_KEY: overrides.apiKey ?? 'lin_api_test' },
-  };
-}
-
-beforeEach(() => { mockFetch.mockReset(); });
-afterEach(() => { delete process.env['LINEAR_API_KEY']; });
-
-describe('LinearFailureHandler.handleFailure', () => {
-  const handler = new LinearFailureHandler();
-
-  it('skips when no LINEAR_API_KEY in integrationConfig or env', async () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const ctx = makeCtx({ apiKey: '' });
-    await handler.handleFailure(ctx);
-    expect(mockFetch).not.toHaveBeenCalled();
-    warnSpy.mockRestore();
-  });
-
-  it('skips when meta has no linear_issue_id', async () => {
-    const ctx = { ...makeCtx(), meta: {} };
-    await handler.handleFailure(ctx);
-    expect(mockFetch).not.toHaveBeenCalled();
-  });
-
-  it('posts comment, queries states, and transitions to Backlog on failure', async () => {
-    mockFetch
-      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(COMMENT_RESPONSE) } as Response)
-      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(STATES_RESPONSE) } as Response)
-      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(UPDATE_RESPONSE) } as Response);
-
-    await handler.handleFailure(makeCtx({
-      issueId: 'issue-xyz', runId: 'run-456',
-      iterations: 3, rejectionReason: 'QA rejected', rejectionDetails: ['Hardcoded strings'],
-    }));
-
-    expect(mockFetch).toHaveBeenCalledTimes(3);
-    const [, commentInit] = mockFetch.mock.calls[0] as [string, RequestInit];
-    const body = JSON.parse(commentInit.body as string) as { variables: { body: string } };
-    expect(body.variables.body).toContain('❌ **Code Builder échoué**');
-    expect(body.variables.body).toContain('3 itérations QA');
-    expect(body.variables.body).toContain('run-456');
-    expect(body.variables.body).toContain('Hardcoded strings');
-  });
-
-  it('posts comment even when Backlog state is not found', async () => {
-    const noBacklog = { data: { issue: { team: { states: { nodes: [{ id: 'state-todo', name: 'Todo' }] } } } } };
-    mockFetch
-      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(COMMENT_RESPONSE) } as Response)
-      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(noBacklog) } as Response);
-
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    await handler.handleFailure(makeCtx());
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('"Backlog" state not found'));
-    warnSpy.mockRestore();
-  });
-
-  it('swallows fetch errors and logs them', async () => {
-    mockFetch.mockRejectedValueOnce(new Error('network timeout'));
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    await expect(handler.handleFailure(makeCtx())).resolves.toBeUndefined();
-    expect(errorSpy).toHaveBeenCalled();
-    errorSpy.mockRestore();
-  });
-
-  it('uses process.env.LINEAR_API_KEY as fallback', async () => {
-    process.env['LINEAR_API_KEY'] = 'env-key';
-    const ctxNoKey = { ...makeCtx(), integrationConfig: {} };
-    mockFetch
-      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(COMMENT_RESPONSE) } as Response)
-      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(STATES_RESPONSE) } as Response)
-      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(UPDATE_RESPONSE) } as Response);
-    await handler.handleFailure(ctxNoKey);
-    expect(mockFetch).toHaveBeenCalledTimes(3);
-  });
-});

package/tests/integrations/linear/webhook-handler.test.ts

@@ -1,191 +0,0 @@
-import { describe, test, expect, vi, beforeEach } from 'vitest';
-import { createHmac } from 'node:crypto';
-import { resolve } from 'node:path';
-import { mkdirSync } from 'node:fs';
-import { LinearWebhookHandler } from '../../../src/integrations/linear/webhook-handler.js';
-import { IntegrationStore } from '../../../src/integration-store.js';
-import type { IntegrationPluginDef } from '@studio-foundation/contracts';
-
-const WEBHOOK_SECRET = 'test-secret-abc';
-
-function sign(body: string, secret: string): string {
-  return createHmac('sha256', secret).update(Buffer.from(body)).digest('hex');
-}
-
-function makeInProgressBody(overrides: Record<string, unknown> = {}) {
-  return {
-    type: 'Issue', action: 'update',
-    data: {
-      id: 'abc-123', identifier: 'STU-42', title: 'Add dark mode',
-      description: 'Users want dark mode.', state: { name: 'In Progress' },
-      ...overrides,
-    },
-  };
-}
-
-function makeContext(opts: {
-  withSecret?: boolean;
-  active?: boolean;
-  body?: object;
-  signatureOverride?: string;
-} = {}) {
-  const dir = resolve('/tmp', `.studio-wh-handler-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(dir, { recursive: true });
-  const store = new IntegrationStore(resolve(dir, 'runs.db'));
-  store.patchConfig('linear', { active: opts.active ?? true });
-
-  const launched: Array<{ pipeline: string; input: Record<string, unknown>; meta?: Record<string, unknown> }> = [];
-  const launcher = {
-    launch: vi.fn(async (cfg: { pipeline: string; input: Record<string, unknown>; meta?: Record<string, unknown>; runId: string }) => {
-      launched.push({ pipeline: cfg.pipeline, input: cfg.input, meta: cfg.meta });
-      return { run_id: cfg.runId };
-    }),
-    cancel: vi.fn(async () => {}),
-    subscribe: vi.fn(() => () => {}),
-  };
-
-  const bodyObj = opts.body ?? makeInProgressBody();
-  const bodyStr = JSON.stringify(bodyObj);
-  const rawBody = Buffer.from(bodyStr);
-
-  const integration: IntegrationPluginDef = {
-    name: 'linear',
-    version: 1,
-    webhook: {
-      ...(opts.withSecret ? { hmac: { header: 'linear-signature', secret_env: 'LINEAR_WEBHOOK_SECRET' } } : {}),
-      handler: 'linear-webhook',
-    },
-  };
-
-  const headers: Record<string, string | undefined> = { 'content-type': 'application/json' };
-  if (opts.signatureOverride !== undefined) {
-    headers['linear-signature'] = opts.signatureOverride;
-  } else if (opts.withSecret) {
-    headers['linear-signature'] = sign(bodyStr, WEBHOOK_SECRET);
-  }
-
-  const ctx = {
-    rawBody,
-    headers,
-    integration,
-    store,
-    launcher,
-    configsDir: dir,
-    projectsDir: undefined,
-    apiConfig: {},
-    integrationConfig: opts.withSecret ? { LINEAR_WEBHOOK_SECRET: WEBHOOK_SECRET } : {},
-  };
-
-  const reply = {
-    status: vi.fn().mockReturnThis(),
-    send: vi.fn().mockReturnThis(),
-  };
-
-  return { ctx, reply, launched, store, cleanup: () => store.close() };
-}
-
-describe('LinearWebhookHandler', () => {
-  const handler = new LinearWebhookHandler();
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  test('accepts "In Progress" transition and launches pipeline', async () => {
-    const { ctx, reply, launched, cleanup } = makeContext();
-    await handler.handle(ctx as never, reply as never);
-
-    expect(reply.status).toHaveBeenCalledWith(202);
-    expect(launched).toHaveLength(1);
-    expect(launched[0].pipeline).toBe('feature-builder');
-    expect(launched[0].input['brief_summary']).toBe('STU-42 — Add dark mode');
-    expect(launched[0].input['description']).toBe('Users want dark mode.');
-    expect(launched[0].meta?.['linear_issue_id']).toBe('abc-123');
-    expect(launched[0].meta?.['linear_issue_identifier']).toBe('STU-42');
-    expect(launched[0].meta?.['linear_issue_url']).toBe('https://linear.app/studioag/issue/STU-42');
-
-    // Check that a trigger record was stored
-    const triggers = ctx.store.listTriggers('linear');
-    expect(triggers).toHaveLength(1);
-    expect(triggers[0].status).toBe('success');
-    expect(triggers[0].external_id).toBe('abc-123');
-
-    cleanup();
-  });
-
-  test('ignores non-"In Progress" state', async () => {
-    const { ctx, reply, launched, cleanup } = makeContext({
-      body: makeInProgressBody({ state: { name: 'Done' } }),
-    });
-    await handler.handle(ctx as never, reply as never);
-
-    expect(reply.status).toHaveBeenCalledWith(200);
-    const sendArg = (reply.send as ReturnType<typeof vi.fn>).mock.calls[0][0] as { ignored: boolean; reason: string };
-    expect(sendArg.ignored).toBe(true);
-    expect(sendArg.reason).toContain('Done');
-    expect(launched).toHaveLength(0);
-    cleanup();
-  });
-
-  test('ignores non-update actions', async () => {
-    const { ctx, reply, launched, cleanup } = makeContext({
-      body: { ...makeInProgressBody(), action: 'create' },
-    });
-    await handler.handle(ctx as never, reply as never);
-    expect(reply.status).toHaveBeenCalledWith(200);
-    expect(launched).toHaveLength(0);
-    cleanup();
-  });
-
-  test('ignores when integration is inactive', async () => {
-    const { ctx, reply, launched, cleanup } = makeContext({ active: false });
-    await handler.handle(ctx as never, reply as never);
-    expect(reply.status).toHaveBeenCalledWith(200);
-    const sendArg = (reply.send as ReturnType<typeof vi.fn>).mock.calls[0][0] as { reason: string };
-    expect(sendArg.reason).toContain('inactive');
-    expect(launched).toHaveLength(0);
-    cleanup();
-  });
-
-  test('accepts valid HMAC signature', async () => {
-    const { ctx, reply, launched, cleanup } = makeContext({ withSecret: true });
-    await handler.handle(ctx as never, reply as never);
-    expect(reply.status).toHaveBeenCalledWith(202);
-    expect(launched).toHaveLength(1);
-    cleanup();
-  });
-
-  test('rejects invalid HMAC signature', async () => {
-    const { ctx, reply, cleanup } = makeContext({ withSecret: true, signatureOverride: 'deadbeef' });
-    await handler.handle(ctx as never, reply as never);
-    expect(reply.status).toHaveBeenCalledWith(401);
-    cleanup();
-  });
-
-  test('rejects missing signature header when HMAC configured', async () => {
-    const { ctx, reply, cleanup } = makeContext({ withSecret: true, signatureOverride: undefined });
-    // Remove the auto-added signature to simulate missing header
-    delete (ctx.headers as Record<string, unknown>)['linear-signature'];
-    await handler.handle(ctx as never, reply as never);
-    expect(reply.status).toHaveBeenCalledWith(401);
-    cleanup();
-  });
-
-  test('returns 400 for invalid JSON', async () => {
-    const dir = resolve('/tmp', `.studio-wh-json-${Date.now()}`);
-    mkdirSync(dir, { recursive: true });
-    const store = new IntegrationStore(resolve(dir, 'runs.db'));
-    store.patchConfig('linear', { active: true });
-    const launcher = { launch: vi.fn(), cancel: vi.fn(), subscribe: vi.fn(() => () => {}) };
-    const ctx = {
-      rawBody: Buffer.from('not-json{'),
-      headers: {},
-      integration: { name: 'linear', version: 1, webhook: { handler: 'linear-webhook' } },
-      store, launcher, configsDir: dir, projectsDir: undefined, apiConfig: {}, integrationConfig: {},
-    };
-    const reply = { status: vi.fn().mockReturnThis(), send: vi.fn().mockReturnThis() };
-    await handler.handle(ctx as never, reply as never);
-    expect(reply.status).toHaveBeenCalledWith(400);
-    store.close();
-  });
-});