add tests

Author: s1gr1d

packages/cloudflare/src/integrations/hono.ts

@@ -22,31 +22,35 @@ export function getHonoIntegration(): ReturnType<typeof _honoIntegration> | unde
   if (!client) {
     return undefined;
   } else {
-    return client.getIntegrationByName(_honoIntegration.name);
+    return client.getIntegrationByName(INTEGRATION_NAME) as ReturnType<typeof _honoIntegration> | undefined;
   }
 }
 
-// todo: implement this
 function isHonoError(err: unknown): err is HonoError {
-  // @ts-ignore
-  return 'status' in err;
+  if (err instanceof Error) {
+    return true;
+  }
+  return typeof err === 'object' && err !== null && 'status' in (err as Record<string, unknown>);
 }
 
-const _honoIntegration = ((options: Partial<Options> = {}) => {
-  let _shouldHandleError: (error: Error) => boolean;
+// outside of integration to prevent resetting the variable
+let _shouldHandleError: (error: Error) => boolean;
 
+const _honoIntegration = ((options: Partial<Options> = {}) => {
   return {
     name: INTEGRATION_NAME,
     setupOnce() {
       _shouldHandleError = options.shouldHandleError || defaultShouldHandleError;
     },
     handleHonoException(err: HonoError): void {
-      if (!isHonoError) {
-        DEBUG_BUILD && debug.log('Hono integration could not detect a Hono error');
+      if (!isHonoError(err)) {
+        DEBUG_BUILD && debug.log("[Hono] Won't capture exception in `onError` because it's not a Hono error.", err);
         return;
       }
       if (_shouldHandleError(err)) {
         captureException(err, { mechanism: { handled: false, type: 'auto.faas.cloudflare.error_handler' } });
+      } else {
+        DEBUG_BUILD && debug.log('[Hono] Not capturing exception because `shouldHandleError` returned `false`.', err);
       }
     },
   };
@@ -55,7 +59,14 @@ const _honoIntegration = ((options: Partial<Options> = {}) => {
 /**
  * Automatically captures exceptions caught with the `onError` handler in Hono.
  *
- * The integration is added by default.
+ * The integration is enabled by default.
+ *
+ * @example
+ * integrations: [
+ *   honoIntegration({
+ *     shouldHandleError: (err) => true; // always capture exceptions in onError
+ *   })
+ * ]
  */
 export const honoIntegration = defineIntegration(_honoIntegration);
 
@@ -65,7 +76,6 @@ export const honoIntegration = defineIntegration(_honoIntegration);
  * 3xx and 4xx errors are not sent by default.
  */
 function defaultShouldHandleError(error: HonoError): boolean {
-  // todo: add test for checking error without status
   const statusCode = error?.status;
   // 3xx and 4xx errors are not sent by default.
   return statusCode ? statusCode >= 500 || statusCode <= 299 : true;

packages/cloudflare/test/integrations/hono.test.ts

@@ -0,0 +1,97 @@
+import * as sentryCore from '@sentry/core';
+import { type Client, createStackParser } from '@sentry/core';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CloudflareClient } from '../../src/client';
+import { honoIntegration } from '../../src/integrations/hono';
+
+class FakeClient extends CloudflareClient {
+  public getIntegrationByName(name: string) {
+    return name === 'Hono' ? (honoIntegration() as any) : undefined;
+  }
+}
+
+vi.mock('../../src/debug-build', () => ({
+  DEBUG_BUILD: true,
+}));
+
+type MockHonoIntegrationType = { handleHonoException: (err: Error) => void };
+
+describe('Hono integration', () => {
+  let client: FakeClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    client = new FakeClient({
+      dsn: 'https://[email protected]/1337',
+      integrations: [],
+      transport: () => ({ send: () => Promise.resolve({}), flush: () => Promise.resolve(true) }),
+      stackParser: createStackParser(),
+    });
+    vi.spyOn(sentryCore, 'getClient').mockImplementation(() => client as Client);
+  });
+
+  it('captures in errorHandler when onError exists', () => {
+    const captureExceptionSpy = vi.spyOn(sentryCore, 'captureException');
+    const integration = honoIntegration();
+    integration.setupOnce?.();
+
+    const error = new Error('hono boom');
+    // simulate withSentry wrapping of errorHandler calling back into integration
+    (integration as unknown as MockHonoIntegrationType).handleHonoException(error);
+
+    expect(captureExceptionSpy).toHaveBeenCalledTimes(1);
+    expect(captureExceptionSpy).toHaveBeenLastCalledWith(error, {
+      mechanism: { handled: false, type: 'auto.faas.cloudflare.error_handler' },
+    });
+  });
+
+  it('does not capture for 4xx status', () => {
+    const captureExceptionSpy = vi.spyOn(sentryCore, 'captureException');
+    const integration = honoIntegration();
+    integration.setupOnce?.();
+
+    (integration as unknown as MockHonoIntegrationType).handleHonoException(
+      Object.assign(new Error('client err'), { status: 404 }),
+    );
+    expect(captureExceptionSpy).not.toHaveBeenCalled();
+  });
+
+  it('does not capture for 3xx status', () => {
+    const captureExceptionSpy = vi.spyOn(sentryCore, 'captureException');
+    const integration = honoIntegration();
+    integration.setupOnce?.();
+
+    (integration as unknown as MockHonoIntegrationType).handleHonoException(
+      Object.assign(new Error('redirect'), { status: 302 }),
+    );
+    expect(captureExceptionSpy).not.toHaveBeenCalled();
+  });
+
+  it('captures for 5xx status', () => {
+    const captureExceptionSpy = vi.spyOn(sentryCore, 'captureException');
+    const integration = honoIntegration();
+    integration.setupOnce?.();
+
+    const err = Object.assign(new Error('server err'), { status: 500 });
+    (integration as unknown as MockHonoIntegrationType).handleHonoException(err);
+    expect(captureExceptionSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('captures if no status is present on Error', () => {
+    const captureExceptionSpy = vi.spyOn(sentryCore, 'captureException');
+    const integration = honoIntegration();
+    integration.setupOnce?.();
+
+    (integration as unknown as MockHonoIntegrationType).handleHonoException(new Error('no status'));
+    expect(captureExceptionSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('supports custom shouldHandleError option', () => {
+    const captureExceptionSpy = vi.spyOn(sentryCore, 'captureException');
+    const integration = honoIntegration({ shouldHandleError: () => false });
+    integration.setupOnce?.();
+
+    (integration as unknown as MockHonoIntegrationType).handleHonoException(new Error('blocked'));
+    expect(captureExceptionSpy).not.toHaveBeenCalled();
+  });
+});