middleware.test.ts

import { expect, test } from '@playwright/test';
import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
import { type SpanJSON } from '@sentry/core';
import { APP_NAME } from './constants';

const SCENARIOS = [
  {
    name: 'root app middleware',
    prefix: '/test-middleware',
  },
  {
    name: 'sub-app middleware (route group)',
    prefix: '/test-subapp-middleware',
  },
] as const;

for (const { name, prefix } of SCENARIOS) {
  test.describe(name, () => {
    test('creates a span for named middleware', async ({ baseURL }) => {
      const transactionPromise = waitForTransaction(APP_NAME, event => {
        return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${prefix}/named`;
      });

      const response = await fetch(`${baseURL}${prefix}/named`);
      expect(response.status).toBe(200);

      const transaction = await transactionPromise;
      const spans = transaction.spans || [];

      const middlewareSpan = spans.find(
        (span: { description?: string; op?: string }) =>
          span.op === 'middleware.hono' && span.description === 'middlewareA',
      );

      expect(middlewareSpan).toEqual(
        expect.objectContaining({
          description: 'middlewareA',
          op: 'middleware.hono',
          origin: 'auto.middleware.hono',
          status: 'ok',
        }),
      );

      // @ts-expect-error timestamp is defined
      const durationMs = (middlewareSpan?.timestamp - middlewareSpan?.start_timestamp) * 1000;
      expect(durationMs).toBeGreaterThanOrEqual(49);
    });

    test('creates a span for anonymous middleware', async ({ baseURL }) => {
      const transactionPromise = waitForTransaction(APP_NAME, event => {
        return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${prefix}/anonymous`;
      });

      const response = await fetch(`${baseURL}${prefix}/anonymous`);
      expect(response.status).toBe(200);

      const transaction = await transactionPromise;
      const spans = transaction.spans || [];

      expect(spans).toContainEqual(
        expect.objectContaining({
          description: '<anonymous>',
          op: 'middleware.hono',
          origin: 'auto.middleware.hono',
          status: 'ok',
        }),
      );
    });

    test('multiple middleware are sibling spans under the same parent', async ({ baseURL }) => {
      const transactionPromise = waitForTransaction(APP_NAME, event => {
        return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${prefix}/multi`;
      });

      const response = await fetch(`${baseURL}${prefix}/multi`);
      expect(response.status).toBe(200);

      const transaction = await transactionPromise;
      const spans = transaction.spans || [];

      const middlewareSpans = spans.sort((a, b) => (a.start_timestamp ?? 0) - (b.start_timestamp ?? 0));

      expect(middlewareSpans).toHaveLength(2);
      expect(middlewareSpans[0]?.description).toBe('middlewareA');
      expect(middlewareSpans[1]?.description).toBe('middlewareB');

      expect(middlewareSpans[0]?.parent_span_id).toBe(middlewareSpans[1]?.parent_span_id);

      // middlewareA has a 50ms delay, middlewareB has a 60ms delay
      // @ts-expect-error timestamp is defined
      const aDurationMs = (middlewareSpans[0]?.timestamp - middlewareSpans[0]?.start_timestamp) * 1000;
      // @ts-expect-error timestamp is defined
      const bDurationMs = (middlewareSpans[1]?.timestamp - middlewareSpans[1]?.start_timestamp) * 1000;
      expect(aDurationMs).toBeGreaterThanOrEqual(49);
      expect(bDurationMs).toBeGreaterThanOrEqual(59);
    });

    test('captures error thrown in middleware', async ({ baseURL }) => {
      const errorPromise = waitForError(APP_NAME, event => {
        return event.exception?.values?.[0]?.value === 'Middleware error';
      });

      const response = await fetch(`${baseURL}${prefix}/error`);
      expect(response.status).toBe(500);

      const errorEvent = await errorPromise;
      expect(errorEvent.exception?.values?.[0]?.value).toBe('Middleware error');
      expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual(
        expect.objectContaining({
          handled: false,
          type: 'auto.middleware.hono',
        }),
      );
    });

    test('sets error status on middleware span when middleware throws', async ({ baseURL }) => {
      const transactionPromise = waitForTransaction(APP_NAME, event => {
        return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${prefix}/error/*`;
      });

      await fetch(`${baseURL}${prefix}/error`);

      const transaction = await transactionPromise;
      const spans = transaction.spans || [];

      const failingSpan = spans.find(
        (span: SpanJSON) => span.op === 'middleware.hono' && span.status === 'internal_error',
      );

      expect(failingSpan).toBeDefined();
      expect(failingSpan?.status).toBe('internal_error');
    });

    test('includes request data on error events from middleware', async ({ baseURL }) => {
      const errorPromise = waitForError(APP_NAME, event => {
        return event.exception?.values?.[0]?.value === 'Middleware error' && !!event.request?.url?.includes(prefix);
      });

      await fetch(`${baseURL}${prefix}/error`);

      const errorEvent = await errorPromise;
      expect(errorEvent.request).toEqual(
        expect.objectContaining({
          method: 'GET',
          url: expect.stringContaining(`${prefix}/error`),
        }),
      );
    });
  });
}

test.describe('.all() handler in sub-app', () => {
  test('does not create middleware span for .all() route handler', async ({ baseURL }) => {
    const transactionPromise = waitForTransaction(APP_NAME, event => {
      return (
        event.contexts?.trace?.op === 'http.server' && event.transaction === 'GET /test-subapp-middleware/all-handler'
      );
    });

    const response = await fetch(`${baseURL}/test-subapp-middleware/all-handler`);
    expect(response.status).toBe(200);

    const body = await response.json();
    expect(body).toEqual({ handler: 'all' });

    const transaction = await transactionPromise;
    const spans = transaction.spans || [];

    // No middleware is called for this route, so there should be no spans.
    expect(spans).toEqual([]);
  });
});

const INLINE_PREFIX = '/test-inline-middleware';

const REGISTRATION_STYLES = [
  { name: 'direct method (.get())', path: '/direct' },
  { name: '.all()', path: '/all' },
  { name: '.on()', path: '/on' },
] as const;

const MIDDLEWARE_STYLES = [
  { name: 'inline', path: '' },
  { name: 'separately registered', path: '/separately' },
] as const;

test.describe('inline middleware spans (sub-app)', () => {
  for (const { name: regName, path: regPath } of REGISTRATION_STYLES) {
    for (const { name: mwName, path: mwPath } of MIDDLEWARE_STYLES) {
      test(`creates middleware span for ${mwName} middleware via ${regName}`, async ({ baseURL }) => {
        const fullPath = `${INLINE_PREFIX}${regPath}${mwPath}`;

        const transactionPromise = waitForTransaction(APP_NAME, event => {
          return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${fullPath}`;
        });

        const response = await fetch(`${baseURL}${fullPath}`);
        expect(response.status).toBe(200);

        const transaction = await transactionPromise;

        const EXPECTED_DESCRIPTIONS: Record<string, Record<string, string>> = {
          '/direct': { '': 'inlineMiddleware', '/separately': 'inlineSeparateMiddleware' },
          '/all': { '': 'inlineMiddlewareAll', '/separately': 'inlineSeparateMiddlewareAll' },
          '/on': { '': 'inlineMiddlewareOn', '/separately': 'inlineSeparateMiddlewareOn' },
        };
        const expectedDescription = EXPECTED_DESCRIPTIONS[regPath]![mwPath]!;

        expect(transaction.spans).toContainEqual(
          expect.objectContaining({
            description: expectedDescription,
            op: 'middleware.hono',
            origin: 'auto.middleware.hono',
            status: 'ok',
          }),
        );
      });
    }
  }
});