@talkpilot/core-db 1.3.89 → 1.3.90

package/src/talkpilot/calls/__tests__/calls.statistics.getters.spec.ts

@@ -1,559 +0,0 @@
-import { ObjectId } from "mongodb";
-import {
-  aggregateActiveCallsSummary,
-  aggregateTodayCallsSummary,
-  aggregateClientCallStats,
-  aggregateSessionCallStats,
-  findLastCallDatesByClientIds,
-  findClientIdsWithCalls,
-  findClientIdsByCallSids,
-  getCallsCollection,
-} from "../calls.getters";
-import { getClientsCollection } from "../../clients/clients.getters";
-import { getSessionsCollection } from "../../sessions/sessions.getter";
-import type { Call } from "../calls.types";
-import { INCOMING_SESSION_ID, UNKNOWN_SESSION_ID } from "../calls.constants";
-import {
-  createOutGoingCallDoc,
-  createIncomingCallDoc,
-  createSession,
-  createClient,
-} from "../../../test-utils/factories";
-
-const insertCall = (call: Call) =>
-  getCallsCollection().insertOne({ ...call, env: call.env ?? "test" });
-
-const insertClients = (...clientIds: string[]) =>
-  getClientsCollection().insertMany(clientIds.map((clientId) => createClient({ clientId })));
-
-describe("calls.getters statistics", () => {
-  describe("aggregateActiveCallsSummary", () => {
-    it("should count distinct active calls within the last 2 hours, split incoming/outgoing", async () => {
-      const now = new Date();
-      await Promise.all([
-        insertCall(createIncomingCallDoc({ clientId: "clientA", status: "in-progress", updatedAt: now })),
-        insertCall(createOutGoingCallDoc({ clientId: "clientB", status: "in-progress", updatedAt: now })),
-        insertCall(createIncomingCallDoc({ clientId: "clientC", status: "completed", updatedAt: now })),
-      ]);
-
-      const summary = await aggregateActiveCallsSummary();
-
-      expect(summary.total).toBe(2);
-      expect(summary.incoming).toBe(1);
-      expect(summary.outgoing).toBe(1);
-      expect(summary.activeClientIds.sort()).toEqual(["clientA", "clientB"]);
-    });
-
-    it("should filter by clientId when provided", async () => {
-      const now = new Date();
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "onlyThisClient", status: "in-progress", updatedAt: now })),
-        insertCall(createOutGoingCallDoc({ clientId: "otherClient", status: "in-progress", updatedAt: now })),
-      ]);
-
-      const summary = await aggregateActiveCallsSummary("onlyThisClient");
-      expect(summary.total).toBe(1);
-      expect(summary.activeClientIds).toEqual(["onlyThisClient"]);
-    });
-
-    it("should exclude calls whose updatedAt is older than 2 hours", async () => {
-      const threeHoursAgo = new Date(Date.now() - 3 * 60 * 60 * 1000);
-      await insertCall(createOutGoingCallDoc({ status: "in-progress", updatedAt: threeHoursAgo }));
-
-      const summary = await aggregateActiveCallsSummary();
-      expect(summary.total).toBe(0);
-    });
-  });
-
-  describe("aggregateTodayCallsSummary", () => {
-    it("should aggregate status/type counts and total minutes within the given date range", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await Promise.all([
-        insertCall(createIncomingCallDoc({ status: "completed", callLength: 120, createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ status: "failed", callLength: 30, createdAt: new Date() })),
-      ]);
-
-      const summary = await aggregateTodayCallsSummary({ dateFrom: today, dateTo: today });
-
-      expect(summary.total).toBe(2);
-      expect(summary.incoming).toBe(1);
-      expect(summary.outgoing).toBe(1);
-      expect(summary.completed).toBe(1);
-      expect(summary.failed).toBe(1);
-      expect(summary.totalMinutes).toBe(3); // ceil(150/60)
-    });
-
-    it("should respect the given timezone when resolving an explicit date", async () => {
-      // 23:30 UTC on 2026-01-01 is already 2026-01-02 in Asia/Jerusalem (+2).
-      const lateUtc = new Date("2026-01-01T23:30:00.000Z");
-      await insertCall(createOutGoingCallDoc({ status: "completed", createdAt: lateUtc }));
-
-      const summaryUtc = await aggregateTodayCallsSummary({
-        dateFrom: "2026-01-01",
-        dateTo: "2026-01-01",
-        timezone: "UTC",
-      });
-      expect(summaryUtc.total).toBe(1);
-
-      const summaryJerusalem = await aggregateTodayCallsSummary({
-        dateFrom: "2026-01-01",
-        dateTo: "2026-01-01",
-        timezone: "Asia/Jerusalem",
-      });
-      expect(summaryJerusalem.total).toBe(0);
-    });
-
-    it("should include a call's full history (not just today) when no date range is given", async () => {
-      const sixMonthsAgo = new Date(Date.now() - 180 * 24 * 60 * 60 * 1000);
-      await insertCall(createOutGoingCallDoc({ status: "completed", createdAt: sixMonthsAgo }));
-
-      const summary = await aggregateTodayCallsSummary({});
-      expect(summary.total).toBe(1);
-    });
-  });
-
-  describe("aggregateClientCallStats", () => {
-    beforeEach(async () => {
-      await insertClients(
-        "clientX",
-        "wantedClient",
-        "unwantedClient",
-        "longHistoryClient",
-        "lastCallDateClient",
-        "onlyThisClientNoRange",
-        "otherClientNoRange",
-        "statusBucketClient",
-      );
-    });
-
-    it("should group call counts and minutes by clientId", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await Promise.all([
-        insertCall(
-          createOutGoingCallDoc({ clientId: "clientX", status: "completed", callLength: 60, createdAt: new Date() }),
-        ),
-        insertCall(
-          createOutGoingCallDoc({ clientId: "clientX", status: "failed", callLength: 60, createdAt: new Date() }),
-        ),
-      ]);
-
-      const { rows } = await aggregateClientCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.clientId === "clientX");
-
-      expect(row?.totalCalls).toBe(2);
-      expect(row?.statusCounts).toMatchObject({ completed: 1, failed: 1 });
-      expect(row?.totalMinutes).toBe(2);
-    });
-
-    it("should not include other clients when filtered by clientId", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "wantedClient", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "unwantedClient", status: "completed", createdAt: new Date() })),
-      ]);
-
-      const { rows } = await aggregateClientCallStats({
-        dateFrom: today,
-        dateTo: today,
-        clientId: "wantedClient",
-      });
-
-      expect(rows).toHaveLength(1);
-      expect(rows[0].clientId).toBe("wantedClient");
-    });
-
-    it("should include a client's full history when no date range is given", async () => {
-      const sixMonthsAgo = new Date(Date.now() - 180 * 24 * 60 * 60 * 1000);
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "longHistoryClient", status: "completed", createdAt: sixMonthsAgo })),
-        insertCall(createOutGoingCallDoc({ clientId: "longHistoryClient", status: "completed", createdAt: new Date() })),
-      ]);
-
-      const { rows } = await aggregateClientCallStats({});
-      const row = rows.find((r) => r.clientId === "longHistoryClient");
-
-      expect(row?.totalCalls).toBe(2);
-    });
-
-    it("should set lastCallDate to the most recent call", async () => {
-      const earlierCall = new Date("2026-01-01T00:00:00.000Z");
-      const laterCall = new Date("2026-03-10T00:00:00.000Z");
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "lastCallDateClient", status: "completed", createdAt: earlierCall })),
-        insertCall(createOutGoingCallDoc({ clientId: "lastCallDateClient", status: "completed", createdAt: laterCall })),
-      ]);
-
-      const { rows } = await aggregateClientCallStats({});
-      const row = rows.find((r) => r.clientId === "lastCallDateClient");
-
-      expect(row?.lastCallDate).toEqual(laterCall);
-    });
-
-    it("should filter by clientId alone when no date range is given", async () => {
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "onlyThisClientNoRange", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "otherClientNoRange", status: "completed", createdAt: new Date() })),
-      ]);
-
-      const { rows } = await aggregateClientCallStats({ clientId: "onlyThisClientNoRange" });
-
-      expect(rows).toHaveLength(1);
-      expect(rows[0].clientId).toBe("onlyThisClientNoRange");
-    });
-
-    it("should count every real status separately, including queued; a missing status only inflates totalCalls", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "canceled", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "queued" as any, createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "ringing", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "initiated", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "answered", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: undefined, createdAt: new Date() })),
-      ]);
-
-      const { rows } = await aggregateClientCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.clientId === "statusBucketClient");
-
-      expect(row?.totalCalls).toBe(7);
-      expect(row?.statusCounts).toMatchObject({
-        completed: 1,
-        canceled: 1,
-        queued: 1,
-        ringing: 1,
-        initiated: 1,
-        answered: 1,
-      });
-    });
-
-    it("should leave out clients that no longer exist in the clients collection", async () => {
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "clientX", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "deletedClient", status: "completed", createdAt: new Date() })),
-      ]);
-
-      const { rows, total } = await aggregateClientCallStats({});
-
-      expect(rows.map((r) => r.clientId)).toEqual(["clientX"]);
-      expect(total).toBe(1);
-    });
-
-    it("should return one page sorted by call count, with the total across all pages", async () => {
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "clientX", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "wantedClient", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "wantedClient", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "unwantedClient", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "unwantedClient", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "unwantedClient", status: "completed", createdAt: new Date() })),
-      ]);
-
-      const firstPage = await aggregateClientCallStats({ skip: 0, limit: 2 });
-      const secondPage = await aggregateClientCallStats({ skip: 2, limit: 2 });
-
-      expect(firstPage.rows.map((r) => r.clientId)).toEqual(["unwantedClient", "wantedClient"]);
-      expect(secondPage.rows.map((r) => r.clientId)).toEqual(["clientX"]);
-      expect(firstPage.total).toBe(3);
-    });
-
-    it("should restrict to clientIds when given", async () => {
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "wantedClient", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "unwantedClient", status: "completed", createdAt: new Date() })),
-      ]);
-
-      const { rows } = await aggregateClientCallStats({ clientIds: ["wantedClient"] });
-
-      expect(rows.map((r) => r.clientId)).toEqual(["wantedClient"]);
-    });
-
-    it("should apply both clientId and clientIds when given together", async () => {
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "wantedClient", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "unwantedClient", status: "completed", createdAt: new Date() })),
-      ]);
-
-      const inList = await aggregateClientCallStats({
-        clientId: "wantedClient",
-        clientIds: ["wantedClient", "unwantedClient"],
-      });
-      const notInList = await aggregateClientCallStats({
-        clientId: "wantedClient",
-        clientIds: ["unwantedClient"],
-      });
-
-      expect(inList.rows.map((r) => r.clientId)).toEqual(["wantedClient"]);
-      expect(notInList.rows).toEqual([]);
-    });
-  });
-
-  describe("aggregateSessionCallStats", () => {
-    it("should group by sessionId and resolve the session's current name via the sessions collection", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sessionId = new ObjectId();
-      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "My Session" }));
-      await insertCall(
-        createOutGoingCallDoc({ sessionId, status: "completed", createdAt: new Date() }),
-      );
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.sessionId === sessionId.toString());
-
-      expect(row).toMatchObject({ sessionName: "My Session", totalCalls: 1 });
-      expect(row?.statusCounts).toMatchObject({ completed: 1 });
-    });
-
-    it("should always show the session's current name, even if it was renamed after some calls happened", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sessionId = new ObjectId();
-      const earlierCall = new Date(Date.now() - 60 * 60 * 1000);
-      const laterCall = new Date();
-
-      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "New Name" }));
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: earlierCall })),
-        insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: laterCall })),
-      ]);
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-      const merged = rows.find((r) => r.sessionId === sessionId.toString());
-
-      expect(merged).toMatchObject({ sessionName: "New Name", totalCalls: 2 });
-      expect(merged?.statusCounts).toMatchObject({ completed: 2 });
-    });
-
-    it("should show 'Unknown' when the session no longer exists in the sessions collection", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const orphanedSessionId = new ObjectId();
-      await insertCall(createOutGoingCallDoc({ sessionId: orphanedSessionId, status: "completed", createdAt: new Date() }));
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.sessionId === orphanedSessionId.toString());
-
-      expect(row?.sessionName).toBe("Unknown");
-    });
-
-    it("should count every call flagged isIncomingCall as 'Incoming Call', even if it carries a sessionId", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sessionId = new ObjectId();
-      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "Some Session" }));
-      await Promise.all([
-        insertCall(createIncomingCallDoc({ sessionId, status: "completed", createdAt: new Date() })),
-        insertCall(createIncomingCallDoc({ status: "completed", createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-
-      expect(rows).toHaveLength(1);
-      expect(rows[0]).toMatchObject({ sessionId: INCOMING_SESSION_ID, sessionName: "Incoming Call", totalCalls: 2 });
-    });
-
-    it("should label a call with no session as 'Incoming Call' only when it is flagged isIncomingCall", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await Promise.all([
-        insertCall(createIncomingCallDoc({ status: "completed", createdAt: new Date() })),
-        insertCall(createIncomingCallDoc({ status: "failed", createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.sessionName === "Incoming Call");
-
-      expect(rows).toHaveLength(1);
-      expect(row).toMatchObject({ sessionId: INCOMING_SESSION_ID, totalCalls: 2 });
-      expect(row?.statusCounts).toMatchObject({ completed: 1, failed: 1 });
-    });
-
-    it("should put a call with no session that is not flagged incoming under 'Unknown', not 'Incoming Call'", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      await insertCall(createOutGoingCallDoc({ sessionId: null, status: "completed", createdAt: new Date() }));
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-
-      expect(rows).toHaveLength(1);
-      expect(rows[0]).toMatchObject({
-        sessionId: UNKNOWN_SESSION_ID,
-        sessionName: "Unknown",
-        totalCalls: 1,
-      });
-      expect(rows.find((r) => r.sessionName === "Incoming Call")).toBeUndefined();
-    });
-
-    it("should treat a call with no isIncomingCall flag at all as unknown, not incoming", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const { isIncomingCall: _omitted, ...withoutFlag } = createOutGoingCallDoc({
-        sessionId: null,
-        status: "completed",
-        createdAt: new Date(),
-      });
-      await insertCall(withoutFlag as Call);
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-
-      expect(rows.map((r) => r.sessionName)).toEqual(["Unknown"]);
-    });
-
-    it("should keep 'Incoming Call', calls without a session and a deleted session as separate rows", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const orphanedSessionId = new ObjectId();
-      await Promise.all([
-        insertCall(createIncomingCallDoc({ status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ sessionId: null, status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ sessionId: orphanedSessionId, status: "failed", createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-
-      expect(rows).toHaveLength(3);
-      expect(rows.find((r) => r.sessionId === INCOMING_SESSION_ID)).toMatchObject({ sessionName: "Incoming Call", totalCalls: 1 });
-      expect(rows.find((r) => r.sessionId === UNKNOWN_SESSION_ID)).toMatchObject({ sessionName: "Unknown", totalCalls: 1 });
-      expect(rows.find((r) => r.sessionId === orphanedSessionId.toString())).toMatchObject({ sessionName: "Unknown", totalCalls: 1 });
-    });
-
-    it("should show 'Unknown' for a session that exists but has no name, keeping its own sessionId", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sessionId = new ObjectId();
-      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "" }));
-      await insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: new Date() }));
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-
-      expect(rows).toHaveLength(1);
-      expect(rows[0]).toMatchObject({ sessionId: sessionId.toString(), sessionName: "Unknown" });
-    });
-
-    it("should only include the given client's sessions when clientId is provided", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sessionA = new ObjectId();
-      const sessionB = new ObjectId();
-      await getSessionsCollection().insertMany([
-        createSession({ _id: sessionA, session_name: "Session A" }),
-        createSession({ _id: sessionB, session_name: "Session B" }),
-      ]);
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "clientA", sessionId: sessionA, status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "clientB", sessionId: sessionB, status: "completed", createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateSessionCallStats({
-        dateFrom: today,
-        dateTo: today,
-        clientId: "clientA",
-      });
-
-      expect(rows).toHaveLength(1);
-      expect(rows[0]).toMatchObject({ sessionId: sessionA.toString(), sessionName: "Session A" });
-    });
-
-    it("should exclude a session with no calls in the given date range", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const longAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
-      const oldSessionId = new ObjectId();
-      await getSessionsCollection().insertOne(createSession({ _id: oldSessionId, session_name: "Old Session" }));
-      await insertCall(createOutGoingCallDoc({ sessionId: oldSessionId, status: "completed", createdAt: longAgo }));
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-
-      expect(rows.find((r) => r.sessionId === oldSessionId.toString())).toBeUndefined();
-    });
-
-    it("should include a session's full history when no date range is given", async () => {
-      const longAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
-      const sessionId = new ObjectId();
-      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "All Time Session" }));
-      await insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: longAgo }));
-
-      const rows = await aggregateSessionCallStats({});
-      const row = rows.find((r) => r.sessionId === sessionId.toString());
-
-      expect(row?.totalCalls).toBe(1);
-    });
-
-    it("should count each real status separately, including queued", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sessionId = new ObjectId();
-      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "Bucket Session" }));
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ sessionId, status: "canceled", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ sessionId, status: "queued" as any, createdAt: new Date() })),
-      ]);
-
-      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
-      const row = rows.find((r) => r.sessionId === sessionId.toString());
-
-      expect(row?.totalCalls).toBe(3);
-      expect(row?.statusCounts).toMatchObject({ completed: 1, canceled: 1, queued: 1 });
-    });
-  });
-
-  describe("findLastCallDatesByClientIds", () => {
-    it("should map each requested clientId to its most recent call", async () => {
-      const earlierCall = new Date("2026-01-01T00:00:00.000Z");
-      const laterCall = new Date("2026-03-10T00:00:00.000Z");
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "lastCallMapClientA", status: "completed", createdAt: earlierCall })),
-        insertCall(createOutGoingCallDoc({ clientId: "lastCallMapClientA", status: "completed", createdAt: laterCall })),
-        insertCall(createOutGoingCallDoc({ clientId: "lastCallMapClientB", status: "completed", createdAt: earlierCall })),
-      ]);
-
-      const map = await findLastCallDatesByClientIds(["lastCallMapClientA"]);
-
-      expect(map.get("lastCallMapClientA")).toEqual(laterCall);
-      expect(map.has("lastCallMapClientB")).toBe(false);
-    });
-
-    it("should return an empty map when given no clientIds", async () => {
-      const map = await findLastCallDatesByClientIds([]);
-      expect(map.size).toBe(0);
-    });
-  });
-
-  describe("findClientIdsWithCalls", () => {
-    it("should return each client with a call in the range once", async () => {
-      const today = new Date().toISOString().slice(0, 10);
-      const sixMonthsAgo = new Date(Date.now() - 180 * 24 * 60 * 60 * 1000);
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "recentCaller", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "recentCaller", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "oldCaller", status: "completed", createdAt: sixMonthsAgo })),
-      ]);
-
-      const clientIds = await findClientIdsWithCalls({ dateFrom: today, dateTo: today });
-
-      expect(clientIds).toEqual(["recentCaller"]);
-    });
-
-    it("should return every client with any call when no range is given", async () => {
-      const sixMonthsAgo = new Date(Date.now() - 180 * 24 * 60 * 60 * 1000);
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "recentCaller", status: "completed", createdAt: new Date() })),
-        insertCall(createOutGoingCallDoc({ clientId: "oldCaller", status: "completed", createdAt: sixMonthsAgo })),
-      ]);
-
-      const clientIds = await findClientIdsWithCalls({});
-
-      expect(clientIds.sort()).toEqual(["oldCaller", "recentCaller"]);
-    });
-  });
-
-  describe("findClientIdsByCallSids", () => {
-    it("should map each callSid to the clientId that owns it", async () => {
-      await Promise.all([
-        insertCall(createOutGoingCallDoc({ clientId: "clientA", callSid: "CAaaa" })),
-        insertCall(createOutGoingCallDoc({ clientId: "clientB", callSid: "CAbbb" })),
-      ]);
-
-      const map = await findClientIdsByCallSids(["CAaaa", "CAbbb", "CAunknown"]);
-
-      expect(map.get("CAaaa")).toBe("clientA");
-      expect(map.get("CAbbb")).toBe("clientB");
-      expect(map.has("CAunknown")).toBe(false);
-    });
-
-    it("should return an empty map when given no callSids", async () => {
-      const map = await findClientIdsByCallSids([]);
-      expect(map.size).toBe(0);
-    });
-  });
-});