Add unit tests

Author: lforst

packages/nextjs/src/edge/withSentryAPI.ts

@@ -13,14 +13,14 @@ export function withSentryAPI<H extends EdgeRouteHandler>(
   return async function (this: unknown, ...args: Parameters<H>): Promise<ReturnType<H>> {
     const req = args[0];
 
-    const isCalledByUser = getCurrentHub().getScope()?.getTransaction();
+    const activeSpan = !!getCurrentHub().getScope()?.getSpan();
 
     const wrappedHandler = withEdgeWrapping(handler, {
       spanDescription:
-        isCalledByUser || !(req instanceof Request)
+        activeSpan || !(req instanceof Request)
           ? `handler (${parameterizedRoute})`
           : `${req.method} ${parameterizedRoute}`,
-      spanOp: isCalledByUser ? 'function' : 'http.server',
+      spanOp: activeSpan ? 'function' : 'http.server',
       mechanismFunctionName: 'withSentryAPI',
     });
 

packages/nextjs/test/edge/edgeWrapperUtils.test.ts

@@ -3,8 +3,6 @@ import * as sentryTracing from '@sentry/tracing';
 
 import { withEdgeWrapping } from '../../src/edge/utils/edgeWrapperUtils';
 
-jest.spyOn(sentryTracing, 'hasTracingEnabled').mockImplementation(() => true);
-
 // @ts-ignore Request does not exist on type Global
 const origRequest = global.Request;
 // @ts-ignore Response does not exist on type Global
@@ -29,6 +27,12 @@ afterAll(() => {
   global.Response = origResponse;
 });
 
+beforeEach(() => {
+  jest.clearAllMocks();
+  jest.resetAllMocks();
+  jest.spyOn(sentryTracing, 'hasTracingEnabled').mockImplementation(() => true);
+});
+
 describe('withEdgeWrapping', () => {
   it('should return a function that calls the passed function', async () => {
     const origFunctionReturnValue = new Response();

packages/nextjs/test/edge/withSentryAPI.test.ts

@@ -0,0 +1,95 @@
+import * as coreSdk from '@sentry/core';
+import * as sentryTracing from '@sentry/tracing';
+
+import { withSentryAPI } from '../../src/edge';
+
+// @ts-ignore Request does not exist on type Global
+const origRequest = global.Request;
+// @ts-ignore Response does not exist on type Global
+const origResponse = global.Response;
+
+// @ts-ignore Request does not exist on type Global
+global.Request = class Request {
+  headers = {
+    get() {
+      return null;
+    },
+  };
+
+  method = 'POST';
+};
+
+// @ts-ignore Response does not exist on type Global
+global.Response = class Request {};
+
+afterAll(() => {
+  // @ts-ignore Request does not exist on type Global
+  global.Request = origRequest;
+  // @ts-ignore Response does not exist on type Global
+  global.Response = origResponse;
+});
+
+beforeEach(() => {
+  jest.resetAllMocks();
+  jest.restoreAllMocks();
+  jest.spyOn(sentryTracing, 'hasTracingEnabled').mockImplementation(() => true);
+});
+
+describe('withSentryAPI', () => {
+  it('should return a function that starts a transaction with the correct name when there is no active transaction and a request is being passed', async () => {
+    const startTransactionSpy = jest.spyOn(coreSdk, 'startTransaction');
+
+    const origFunctionReturnValue = new Response();
+    const origFunction = jest.fn(_req => origFunctionReturnValue);
+
+    const wrappedFunction = withSentryAPI(origFunction, '/user/[userId]/post/[postId]');
+
+    const request = new Request('https://sentry.io/');
+    await wrappedFunction(request);
+    expect(startTransactionSpy).toHaveBeenCalledTimes(1);
+    expect(startTransactionSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metadata: { source: 'route' },
+        name: 'POST /user/[userId]/post/[postId]',
+        op: 'http.server',
+      }),
+      { request },
+    );
+  });
+
+  it('should return a function that should not start a transaction when there is no active span and no request is being passed', async () => {
+    const startTransactionSpy = jest.spyOn(coreSdk, 'startTransaction');
+
+    const origFunctionReturnValue = new Response();
+    const origFunction = jest.fn(() => origFunctionReturnValue);
+
+    const wrappedFunction = withSentryAPI(origFunction, '/user/[userId]/post/[postId]');
+
+    await wrappedFunction();
+    expect(startTransactionSpy).not.toHaveBeenCalled();
+  });
+
+  it('should return a function that starts a span on the current transaction with the correct description when there is an active transaction and no request is being passed', async () => {
+    const testTransaction = coreSdk.startTransaction({ name: 'testTransaction' });
+    coreSdk.getCurrentHub().getScope()?.setSpan(testTransaction);
+
+    const startChildSpy = jest.spyOn(testTransaction, 'startChild');
+
+    const origFunctionReturnValue = new Response();
+    const origFunction = jest.fn(() => origFunctionReturnValue);
+
+    const wrappedFunction = withSentryAPI(origFunction, '/user/[userId]/post/[postId]');
+
+    await wrappedFunction();
+    expect(startChildSpy).toHaveBeenCalledTimes(1);
+    expect(startChildSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        description: 'handler (/user/[userId]/post/[postId])',
+        op: 'function',
+      }),
+    );
+
+    testTransaction.finish();
+    coreSdk.getCurrentHub().getScope()?.setSpan(undefined);
+  });
+});