diff --git a/packages/features/insights/server/__tests__/routing-events.test.ts b/packages/features/insights/server/__tests__/routing-events.test.ts
new file mode 100644
index 0000000000..29f3cabb6d
--- /dev/null
+++ b/packages/features/insights/server/__tests__/routing-events.test.ts
@@ -0,0 +1,212 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+import { readonlyPrisma } from "@calcom/prisma";
+
+import { RoutingEventsInsights } from "../routing-events";
+
+vi.mock("@calcom/prisma", () => ({
+  readonlyPrisma: {
+    team: {
+      findMany: vi.fn(),
+    },
+    membership: {
+      findMany: vi.fn(),
+    },
+  },
+}));
+
+describe("RoutingEventsInsights", () => {
+  class TestRoutingEventsInsights extends RoutingEventsInsights {
+    static async testGetWhereForTeamOrAllTeams(params: {
+      userId?: number | null;
+      teamId?: number | null;
+      isAll: boolean;
+      organizationId?: number | null;
+      routingFormId?: string | null;
+    }) {
+      return super.getWhereForTeamOrAllTeams(params);
+    }
+  }
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("getWhereForTeamOrAllTeams", () => {
+    describe("Basic filtering scenarios", () => {
+      it("should return correct where condition when isAll is true with organizationId", async () => {
+        vi.mocked(readonlyPrisma.team.findMany).mockResolvedValue([{ id: 1 }, { id: 2 }]);
+        vi.mocked(readonlyPrisma.membership.findMany).mockResolvedValue([{ teamId: 1 }, { teamId: 2 }]);
+
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          userId: 1,
+          isAll: true,
+          organizationId: 1,
+        });
+
+        expect(result).toEqual({
+          teamId: {
+            in: [1, 2],
+          },
+        });
+      });
+
+      it("should return correct where condition when teamId is provided", async () => {
+        vi.mocked(readonlyPrisma.membership.findMany).mockResolvedValue([{ teamId: 5 }]);
+
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          userId: 1,
+          teamId: 5,
+          isAll: false,
+        });
+
+        expect(result).toEqual({
+          teamId: {
+            in: [5],
+          },
+        });
+      });
+
+      it("should return correct where condition when neither teamId nor organizationId is provided", async () => {
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          userId: 1,
+          isAll: false,
+        });
+
+        expect(result).toEqual({
+          userId: 1,
+          teamId: null,
+        });
+      });
+    });
+
+    describe("Edge cases", () => {
+      it("should return correct where condition when user has no access to teams", async () => {
+        vi.mocked(readonlyPrisma.team.findMany).mockResolvedValue([{ id: 2 }, { id: 3 }]);
+        vi.mocked(readonlyPrisma.membership.findMany).mockResolvedValue([]);
+
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          userId: 1,
+          isAll: true,
+          organizationId: 1,
+        });
+
+        expect(result).toEqual({
+          userId: 1,
+          teamId: null,
+        });
+      });
+
+      it("should return correct where condition when routingFormId is provided", async () => {
+        vi.mocked(readonlyPrisma.membership.findMany).mockResolvedValue([{ teamId: 5 }]);
+
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          userId: 1,
+          teamId: 5,
+          isAll: false,
+          routingFormId: "form-123",
+        });
+
+        expect(result).toEqual({
+          teamId: {
+            in: [5],
+          },
+          id: "form-123",
+        });
+      });
+
+      it("should handle null userId by using default value", async () => {
+        vi.mocked(readonlyPrisma.membership.findMany).mockResolvedValue([{ teamId: 5 }]);
+
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          userId: null,
+          teamId: 5,
+          isAll: false,
+        });
+
+        expect(result).toEqual({
+          teamId: {
+            in: [5],
+          },
+        });
+      });
+
+      it("should handle empty parameters with only isAll provided", async () => {
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          isAll: false,
+        });
+
+        expect(result).toEqual({
+          userId: -1,
+          teamId: null,
+        });
+      });
+    });
+
+    describe("Invalid parameter combinations", () => {
+      it("should handle when isAll is true but no organizationId is provided", async () => {
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          userId: 1,
+          isAll: true,
+        });
+
+        expect(result).toEqual({
+          userId: 1,
+          teamId: null,
+        });
+      });
+
+      it("should handle when both teamId and organizationId are provided", async () => {
+        vi.mocked(readonlyPrisma.membership.findMany).mockResolvedValue([{ teamId: 5 }]);
+
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          userId: 1,
+          teamId: 5,
+          isAll: false,
+          organizationId: 10,
+        });
+
+        expect(result).toEqual({
+          teamId: {
+            in: [5],
+          },
+        });
+      });
+
+      it("should handle when both teamId and organizationId are provided with isAll true", async () => {
+        vi.mocked(readonlyPrisma.team.findMany).mockResolvedValue([{ id: 1 }, { id: 2 }]);
+        vi.mocked(readonlyPrisma.membership.findMany).mockResolvedValue([{ teamId: 1 }, { teamId: 2 }]);
+
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          userId: 1,
+          teamId: 5,
+          isAll: true,
+          organizationId: 1,
+        });
+
+        expect(result).toEqual({
+          teamId: {
+            in: [1, 2],
+          },
+        });
+      });
+
+      it("should handle undefined teamId with isAll true", async () => {
+        vi.mocked(readonlyPrisma.team.findMany).mockResolvedValue([]);
+        vi.mocked(readonlyPrisma.membership.findMany).mockResolvedValue([]);
+
+        const result = await TestRoutingEventsInsights.testGetWhereForTeamOrAllTeams({
+          userId: 1,
+          teamId: undefined,
+          isAll: true,
+          organizationId: 1,
+        });
+
+        expect(result).toEqual({
+          userId: 1,
+          teamId: null,
+        });
+      });
+    });
+  });
+});