test(google-serverless): Migrate to Vitest (#15567)

Co-authored-by: Abhijeet Prasad <[email protected]>

Author: timfish

packages/google-cloud-serverless/jest.config.js

@@ -55,10 +55,7 @@
   "devDependencies": {
     "@google-cloud/bigquery": "^5.3.0",
     "@google-cloud/common": "^3.4.1",
-    "@google-cloud/functions-framework": "^1.7.1",
-    "@google-cloud/pubsub": "^2.5.0",
     "@types/node": "^18.19.1",
-    "google-gax": "^2.9.0",
     "nock": "^13.5.5"
   },
   "scripts": {
@@ -77,8 +74,8 @@
     "clean": "rimraf build coverage sentry-google-cloud-*.tgz",
     "fix": "eslint . --format stylish --fix",
     "lint": "eslint . --format stylish",
-    "test": "jest",
-    "test:watch": "jest --watch",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
     "yalc:publish": "yalc publish --push --sig"
   },
   "volta": {

packages/google-cloud-serverless/package.json

@@ -3,11 +3,11 @@ import type { Client, IntegrationFn } from '@sentry/core';
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, defineIntegration, fill, getClient } from '@sentry/core';
 import { startInactiveSpan } from '@sentry/node';
 
-interface GrpcFunction extends CallableFunction {
+export interface GrpcFunction extends CallableFunction {
   (...args: unknown[]): EventEmitter;
 }
 
-interface GrpcFunctionObject extends GrpcFunction {
+export interface GrpcFunctionObject extends GrpcFunction {
   requestStream: boolean;
   responseStream: boolean;
   originalName: string;
@@ -21,7 +21,7 @@ interface CreateStubFunc extends CallableFunction {
   (createStub: unknown, options: StubOptions): PromiseLike<Stub>;
 }
 
-interface Stub {
+export interface Stub {
   [key: string]: GrpcFunctionObject;
 }
 
@@ -78,7 +78,7 @@ function wrapCreateStub(origCreate: CreateStubFunc): CreateStubFunc {
 }
 
 /** Patches the function in grpc stub to enable tracing */
-function fillGrpcFunction(stub: Stub, serviceIdentifier: string, methodName: string): void {
+export function fillGrpcFunction(stub: Stub, serviceIdentifier: string, methodName: string): void {
   const funcObj = stub[methodName];
   if (typeof funcObj !== 'function') {
     return;

packages/google-cloud-serverless/src/integrations/google-cloud-grpc.ts

@@ -1,22 +1,24 @@
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import { describe, vi, beforeEach, test, expect } from 'vitest';
 
 import { wrapCloudEventFunction } from '../../src/gcpfunction/cloud_events';
 import type { CloudEventFunction, CloudEventFunctionWithCallback } from '../../src/gcpfunction/general';
 
-const mockStartSpanManual = jest.fn((...spanArgs) => ({ ...spanArgs }));
-const mockFlush = jest.fn((...args) => Promise.resolve(args));
-const mockCaptureException = jest.fn();
+const mockStartSpanManual = vi.fn((...spanArgs) => ({ ...spanArgs }));
+const mockFlush = vi.fn((...args) => Promise.resolve(args));
+const mockCaptureException = vi.fn();
 
 const mockScope = {
-  setContext: jest.fn(),
+  setContext: vi.fn(),
 };
 
 const mockSpan = {
-  end: jest.fn(),
+  end: vi.fn(),
 };
 
-jest.mock('@sentry/node', () => {
-  const original = jest.requireActual('@sentry/node');
+vi.mock('@sentry/node', async () => {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+  const original = (await vi.importActual('@sentry/node')) as typeof import('@sentry/node');
   return {
     ...original,
     startSpanManual: (...args: unknown[]) => {
@@ -38,7 +40,7 @@ jest.mock('@sentry/node', () => {
 
 describe('wrapCloudEventFunction', () => {
   beforeEach(() => {
-    jest.clearAllMocks();
+    vi.clearAllMocks();
   });
 
   function handleCloudEvent(fn: CloudEventFunctionWithCallback): Promise<any> {

packages/google-cloud-serverless/test/__mocks__/dns.ts

@@ -1,23 +1,25 @@
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import { describe, vi, beforeEach, test, expect } from 'vitest';
 
 import type { Event } from '@sentry/core';
 import { wrapEventFunction } from '../../src/gcpfunction/events';
 import type { EventFunction, EventFunctionWithCallback } from '../../src/gcpfunction/general';
 
-const mockStartSpanManual = jest.fn((...spanArgs) => ({ ...spanArgs }));
-const mockFlush = jest.fn((...args) => Promise.resolve(args));
-const mockCaptureException = jest.fn();
+const mockStartSpanManual = vi.fn((...spanArgs) => ({ ...spanArgs }));
+const mockFlush = vi.fn((...args) => Promise.resolve(args));
+const mockCaptureException = vi.fn();
 
 const mockScope = {
-  setContext: jest.fn(),
+  setContext: vi.fn(),
 };
 
 const mockSpan = {
-  end: jest.fn(),
+  end: vi.fn(),
 };
 
-jest.mock('@sentry/node', () => {
-  const original = jest.requireActual('@sentry/node');
+vi.mock('@sentry/node', async () => {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+  const original = (await vi.importActual('@sentry/node')) as typeof import('@sentry/node');
   return {
     ...original,
     startSpanManual: (...args: unknown[]) => {
@@ -39,7 +41,7 @@ jest.mock('@sentry/node', () => {
 
 describe('wrapEventFunction', () => {
   beforeEach(() => {
-    jest.clearAllMocks();
+    vi.clearAllMocks();
   });
 
   function handleEvent(fn: EventFunctionWithCallback): Promise<any> {
@@ -238,7 +240,7 @@ describe('wrapEventFunction', () => {
     const scopeFunction = mockCaptureException.mock.calls[0][1];
     const event: Event = { exception: { values: [{}] } };
     let evtProcessor: ((e: Event) => Event) | undefined = undefined;
-    scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+    scopeFunction({ addEventProcessor: vi.fn().mockImplementation(proc => (evtProcessor = proc)) });
 
     expect(evtProcessor).toBeInstanceOf(Function);
     // @ts-expect-error just mocking around...

packages/google-cloud-serverless/test/gcpfunction/cloud_event.test.ts

@@ -1,28 +1,27 @@
 import type { Integration } from '@sentry/core';
-
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import { describe, vi, beforeEach, test, expect, type MockInstance } from 'vitest';
 
 import { wrapHttpFunction } from '../../src/gcpfunction/http';
-
 import type { HttpFunction, Request, Response } from '../../src/gcpfunction/general';
-
 import { init } from '../../src/sdk';
 
-const mockStartSpanManual = jest.fn((...spanArgs) => ({ ...spanArgs }));
-const mockFlush = jest.fn((...args) => Promise.resolve(args));
-const mockCaptureException = jest.fn();
-const mockInit = jest.fn();
+const mockStartSpanManual = vi.fn((...spanArgs) => ({ ...spanArgs }));
+const mockFlush = vi.fn((...args) => Promise.resolve(args));
+const mockCaptureException = vi.fn();
+const mockInit = vi.fn();
 
 const mockScope = {
-  setSDKProcessingMetadata: jest.fn(),
+  setSDKProcessingMetadata: vi.fn(),
 };
 
 const mockSpan = {
-  end: jest.fn(),
+  end: vi.fn(),
 };
 
-jest.mock('@sentry/node', () => {
-  const original = jest.requireActual('@sentry/node');
+vi.mock('@sentry/node', async () => {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+  const original = (await vi.importActual('@sentry/node')) as typeof import('@sentry/node');
   return {
     ...original,
     init: (options: unknown) => {
@@ -47,7 +46,7 @@ jest.mock('@sentry/node', () => {
 
 describe('GCPFunction', () => {
   beforeEach(() => {
-    jest.clearAllMocks();
+    vi.clearAllMocks();
   });
 
   async function handleHttp(fn: HttpFunction, trace_headers: { [key: string]: string } | null = null): Promise<void> {
@@ -146,7 +145,7 @@ describe('GCPFunction', () => {
         body: { foo: 'bar' },
       } as Request;
 
-      const mockEnd = jest.fn();
+      const mockEnd = vi.fn();
       const response = { end: mockEnd } as unknown as Response;
 
       mockFlush.mockImplementationOnce(async () => {
@@ -171,8 +170,8 @@ describe('GCPFunction', () => {
 
     await handleHttp(wrappedHandler);
 
-    const initOptions = (mockInit as unknown as jest.SpyInstance).mock.calls[0];
-    const defaultIntegrations = initOptions[0]?.defaultIntegrations.map((i: Integration) => i.name);
+    const initOptions = (mockInit as unknown as MockInstance).mock.calls[0];
+    const defaultIntegrations = initOptions?.[0]?.defaultIntegrations.map((i: Integration) => i.name);
 
     expect(defaultIntegrations).toContain('RequestData');
 

packages/google-cloud-serverless/test/gcpfunction/events.test.ts

@@ -1,156 +1,210 @@
-jest.mock('dns');
+import { vi, describe, beforeEach, test, expect } from 'vitest';
+import { NodeClient } from '@sentry/node';
+import { createTransport } from '@sentry/core';
+import { setCurrentClient, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { googleCloudGrpcIntegration, fillGrpcFunction } from '../../src/integrations/google-cloud-grpc';
+import type { GrpcFunctionObject, Stub, GrpcFunction } from '../../src/integrations/google-cloud-grpc';
 
-import * as dns from 'dns';
-import { EventEmitter } from 'events';
-import * as fs from 'fs';
-import * as path from 'path';
-import { PubSub } from '@google-cloud/pubsub';
-import * as http2 from 'http2';
-import * as nock from 'nock';
+const mockSpanEnd = vi.fn();
+const mockStartInactiveSpan = vi.fn();
+const mockFill = vi.fn();
 
-import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
-import { NodeClient, createTransport, setCurrentClient } from '@sentry/node';
-import { googleCloudGrpcIntegration } from '../../src/integrations/google-cloud-grpc';
+let mockClient: NodeClient;
 
-const spyConnect = jest.spyOn(http2, 'connect');
-
-const mockSpanEnd = jest.fn();
-const mockStartInactiveSpan = jest.fn(spanArgs => ({ ...spanArgs }));
+vi.mock('@sentry/core', async () => {
+  const original = await vi.importActual('@sentry/core');
+  return {
+    ...original,
+    fill: (obj: any, name: string, replacement: any) => {
+      mockFill(obj, name, replacement);
+      obj[name] = replacement(obj[name]);
+    },
+    getClient: () => mockClient,
+  };
+});
 
-jest.mock('@sentry/node', () => {
+vi.mock('@sentry/node', async () => {
+  const original = await vi.importActual('@sentry/node');
   return {
-    ...jest.requireActual('@sentry/node'),
+    ...original,
     startInactiveSpan: (ctx: unknown) => {
       mockStartInactiveSpan(ctx);
       return { end: mockSpanEnd };
     },
   };
 });
 
-/** Fake HTTP2 stream */
-class FakeStream extends EventEmitter {
-  public rstCode: number = 0;
-  close() {
-    this.emit('end');
-    this.emit('close');
-  }
-  end() {}
-  pause() {}
-  resume() {}
-  write(_data: Buffer, cb: CallableFunction) {
-    process.nextTick(cb, null);
-  }
-}
-
-/** Fake HTTP2 session for GRPC */
-class FakeSession extends EventEmitter {
-  public socket: EventEmitter = new EventEmitter();
-  public request: jest.Mock = jest.fn();
-  ping() {}
-  mockRequest(fn: (stream: FakeStream) => void): FakeStream {
-    const stream = new FakeStream();
-    this.request.mockImplementationOnce(() => {
-      process.nextTick(fn, stream);
-      return stream;
-    });
-    return stream;
-  }
-  mockUnaryRequest(responseData: Buffer) {
-    this.mockRequest(stream => {
-      stream.emit(
-        'response',
-        { ':status': 200, 'content-type': 'application/grpc', 'content-disposition': 'attachment' },
-        4,
-      );
-      stream.emit('data', responseData);
-      stream.emit('trailers', { 'grpc-status': '0', 'content-disposition': 'attachment' });
-    });
-  }
-  close() {
-    this.emit('close');
-    this.socket.emit('close');
-  }
-  ref() {}
-  unref() {}
+// Need to override mock because the integration loads google-gax as a CJS file
+async function mock(mockedUri: string, stub: any) {
+  // @ts-expect-error we are using import on purpose
+  const { Module } = await import('module');
+
+  // @ts-expect-error test
+  Module._load_original = Module._load;
+  // @ts-expect-error test
+  Module._load = (uri, parent) => {
+    if (uri === mockedUri) return stub;
+    // @ts-expect-error test
+    return Module._load_original(uri, parent);
+  };
 }
 
-function mockHttp2Session(): FakeSession {
-  const session = new FakeSession();
-  spyConnect.mockImplementationOnce(() => {
-    process.nextTick(() => session.emit('connect'));
-    return session as unknown as http2.ClientHttp2Session;
-  });
-  return session;
-}
+vi.hoisted(
+  () =>
+    void mock('google-gax', {
+      GrpcClient: {
+        prototype: {
+          createStub: vi.fn(),
+        },
+      },
+    }),
+);
 
 describe('GoogleCloudGrpc tracing', () => {
-  const mockClient = new NodeClient({
-    tracesSampleRate: 1.0,
-    integrations: [],
-    dsn: 'https://withAWSServices@domain/123',
-    transport: () => createTransport({ recordDroppedEvent: () => undefined }, _ => Promise.resolve({})),
-    stackParser: () => [],
-  });
+  beforeEach(() => {
+    mockClient = new NodeClient({
+      tracesSampleRate: 1.0,
+      integrations: [],
+      dsn: 'https://withAWSServices@domain/123',
+      transport: () => createTransport({ recordDroppedEvent: () => undefined }, _ => Promise.resolve({})),
+      stackParser: () => [],
+    });
 
-  const integration = googleCloudGrpcIntegration();
-  mockClient.addIntegration(integration);
+    const integration = googleCloudGrpcIntegration();
+    mockClient.addIntegration(integration);
+    integration.setup?.(mockClient);
 
-  beforeEach(() => {
-    nock('https://www.googleapis.com').post('/oauth2/v4/token').reply(200, []);
     setCurrentClient(mockClient);
     mockSpanEnd.mockClear();
     mockStartInactiveSpan.mockClear();
+    mockFill.mockClear();
   });
 
-  afterAll(() => {
-    nock.restore();
-    spyConnect.mockRestore();
-  });
-
-  // We use google cloud pubsub as an example of grpc service for which we can trace requests.
-  describe('pubsub', () => {
-    // @ts-expect-error see "Why @ts-expect-error" note
-    const dnsLookup = dns.lookup as jest.Mock;
-    // @ts-expect-error see "Why @ts-expect-error" note
-    const resolveTxt = dns.resolveTxt as jest.Mock;
-    dnsLookup.mockImplementation((hostname, ...args) => {
-      expect(hostname).toEqual('pubsub.googleapis.com');
-      process.nextTick(args[args.length - 1], null, [{ address: '0.0.0.0', family: 4 }]);
-    });
-    resolveTxt.mockImplementation((hostname, cb) => {
-      expect(hostname).toEqual('pubsub.googleapis.com');
-      process.nextTick(cb, null, []);
+  describe('setup', () => {
+    test('integration name is correct', () => {
+      const integration = googleCloudGrpcIntegration();
+      expect(integration.name).toBe('GoogleCloudGrpc');
     });
 
-    const pubsub = new PubSub({
-      credentials: {
-        client_email: 'client@email',
-        private_key: fs.readFileSync(path.resolve(__dirname, 'private.pem')).toString(),
-      },
-      projectId: 'project-id',
+    test('setupOnce patches GrpcClient.createStub', () => {
+      const mockCreateStub = vi.fn();
+      const mockGrpcClient = {
+        prototype: {
+          createStub: mockCreateStub,
+        },
+      };
+
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      require('google-gax').GrpcClient = mockGrpcClient;
+
+      const integration = googleCloudGrpcIntegration();
+      integration.setupOnce?.();
+      expect(mockCreateStub).toBeDefined();
     });
 
-    afterEach(() => {
-      dnsLookup.mockReset();
-      resolveTxt.mockReset();
+    test('setupOnce throws when google-gax is not available and not optional', () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      require('google-gax').GrpcClient = undefined;
+
+      const integration = googleCloudGrpcIntegration();
+      expect(() => integration.setupOnce?.()).toThrow();
     });
 
-    afterAll(async () => {
-      await pubsub.close();
+    test('setupOnce does not throw when google-gax is not available and optional', () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      require('google-gax').GrpcClient = undefined;
+
+      const optionalIntegration = googleCloudGrpcIntegration({ optional: true });
+      expect(() => optionalIntegration.setupOnce?.()).not.toThrow();
     });
+  });
 
-    test('publish', async () => {
-      mockHttp2Session().mockUnaryRequest(Buffer.from('00000000120a1031363337303834313536363233383630', 'hex'));
-      const resp = await pubsub.topic('nicetopic').publish(Buffer.from('data'));
-      expect(resp).toEqual('1637084156623860');
-      expect(mockStartInactiveSpan).toBeCalledWith({
-        op: 'grpc.pubsub',
+  describe('fillGrpcFunction', () => {
+    test('patches unary call methods with tracing', () => {
+      const mockStub: Stub = {
+        unaryMethod: Object.assign(vi.fn(), {
+          requestStream: false,
+          responseStream: false,
+          originalName: 'unaryMethod',
+        } as GrpcFunctionObject),
+      };
+
+      const mockEventEmitter = {
+        on: vi.fn(),
+      };
+
+      (mockStub.unaryMethod as any).apply = vi.fn().mockReturnValue(mockEventEmitter);
+
+      fillGrpcFunction(mockStub, 'test-service', 'unaryMethod');
+
+      const result = (mockStub.unaryMethod as GrpcFunction)();
+      expect(result).toBe(mockEventEmitter);
+      expect(mockEventEmitter.on).toHaveBeenCalledWith('status', expect.any(Function));
+      expect(mockStartInactiveSpan).toHaveBeenCalledWith({
+        name: 'unary call unaryMethod',
+        onlyIfParent: true,
+        op: 'grpc.test-service',
         attributes: {
           [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.grpc.serverless',
         },
-        name: 'unary call publish',
-        onlyIfParent: true,
       });
     });
+
+    test('does not patch non-unary call methods', () => {
+      const mockStub: Stub = {
+        clientStreamMethod: Object.assign(vi.fn(), {
+          requestStream: true,
+          responseStream: false,
+          originalName: 'clientStreamMethod',
+        } as GrpcFunctionObject),
+        serverStreamMethod: Object.assign(vi.fn(), {
+          requestStream: false,
+          responseStream: true,
+          originalName: 'serverStreamMethod',
+        } as GrpcFunctionObject),
+        bidiStreamMethod: Object.assign(vi.fn(), {
+          requestStream: true,
+          responseStream: true,
+          originalName: 'bidiStreamMethod',
+        } as GrpcFunctionObject),
+      };
+
+      fillGrpcFunction(mockStub, 'test-service', 'clientStreamMethod');
+      fillGrpcFunction(mockStub, 'test-service', 'serverStreamMethod');
+      fillGrpcFunction(mockStub, 'test-service', 'bidiStreamMethod');
+
+      expect(mockStartInactiveSpan).not.toHaveBeenCalled();
+    });
+
+    test('does not patch non-function properties', () => {
+      const mockStub: Stub = {
+        nonFunction: Object.assign(vi.fn(), {
+          requestStream: false,
+          responseStream: false,
+          originalName: 'nonFunction',
+        } as GrpcFunctionObject),
+      };
+
+      fillGrpcFunction(mockStub, 'test-service', 'nonFunction');
+      expect(mockStartInactiveSpan).not.toHaveBeenCalled();
+    });
+
+    test('does not patch methods when return value is not an EventEmitter', () => {
+      const mockStub: Stub = {
+        unaryMethod: Object.assign(vi.fn(), {
+          requestStream: false,
+          responseStream: false,
+          originalName: 'unaryMethod',
+        } as GrpcFunctionObject),
+      };
+
+      (mockStub.unaryMethod as any).apply = vi.fn().mockReturnValue({ notAnEventEmitter: true });
+
+      fillGrpcFunction(mockStub, 'test-service', 'unaryMethod');
+
+      const result = (mockStub.unaryMethod as GrpcFunction)();
+      expect(result).toEqual({ notAnEventEmitter: true });
+      expect(mockStartInactiveSpan).not.toHaveBeenCalled();
+    });
   });
 });

packages/google-cloud-serverless/test/gcpfunction/http.test.ts

@@ -1,18 +1,23 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { BigQuery } from '@google-cloud/bigquery';
-import * as nock from 'nock';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore ESM/CJS interop issue
+import nock from 'nock';
+import { describe, vi, beforeEach, test, expect, afterAll } from 'vitest';
 
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
 import { NodeClient, createTransport, setCurrentClient } from '@sentry/node';
 import { googleCloudHttpIntegration } from '../../src/integrations/google-cloud-http';
 
-const mockSpanEnd = jest.fn();
-const mockStartInactiveSpan = jest.fn(spanArgs => ({ ...spanArgs }));
+const mockSpanEnd = vi.fn();
+const mockStartInactiveSpan = vi.fn(spanArgs => ({ ...spanArgs }));
 
-jest.mock('@sentry/node', () => {
+vi.mock('@sentry/node', async () => {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+  const original = (await vi.importActual('@sentry/node')) as typeof import('@sentry/node');
   return {
-    ...jest.requireActual('@sentry/node'),
+    ...original,
     startInactiveSpan: (ctx: unknown) => {
       mockStartInactiveSpan(ctx);
       return { end: mockSpanEnd };

packages/google-cloud-serverless/test/integrations/google-cloud-grpc.test.ts

@@ -1,9 +1,12 @@
+import { vi, describe, beforeEach, test, expect } from 'vitest';
+
 import { init } from '../src/sdk';
 
-const mockInit = jest.fn();
+const mockInit = vi.fn();
 
-jest.mock('@sentry/node', () => {
-  const original = jest.requireActual('@sentry/node');
+vi.mock('@sentry/node', async () => {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+  const original = (await vi.importActual('@sentry/node')) as typeof import('@sentry/node');
   return {
     ...original,
     init: (options: unknown) => {
@@ -14,7 +17,7 @@ jest.mock('@sentry/node', () => {
 
 describe('init()', () => {
   beforeEach(() => {
-    jest.clearAllMocks();
+    vi.clearAllMocks();
   });
 
   test('calls Sentry.init with correct sdk info metadata', () => {

packages/google-cloud-serverless/test/integrations/google-cloud-http.test.ts

@@ -1,11 +1,11 @@
 {
   "extends": "./tsconfig.json",
 
-  "include": ["test/**/*"],
+  "include": ["test/**/*", "vite.config.ts"],
 
   "compilerOptions": {
     // should include all types from `./tsconfig.json` plus types for all test frameworks used
-    "types": ["node", "jest"]
+    "types": ["node"]
 
     // other package-specific, test-specific options
   }

packages/google-cloud-serverless/test/sdk.test.ts

@@ -0,0 +1,8 @@
+import baseConfig from '../../vite/vite.config';
+
+export default {
+  ...baseConfig,
+  test: {
+    ...baseConfig.test,
+  },
+};