mongodb-mcp-server 0.1.1 → 0.1.2

package/tests/unit/telemetry.test.ts

@@ -1,6 +1,6 @@
 import { ApiClient } from "../../src/common/atlas/apiClient.js";
 import { Session } from "../../src/session.js";
-import { DEVICE_ID_TIMEOUT, Telemetry } from "../../src/telemetry/telemetry.js";
+import { Telemetry } from "../../src/telemetry/telemetry.js";
 import { BaseEvent, TelemetryResult } from "../../src/telemetry/types.js";
 import { EventCache } from "../../src/telemetry/eventCache.js";
 import { config } from "../../src/config.js";
@@ -16,6 +16,8 @@ const MockApiClient = ApiClient as jest.MockedClass<typeof ApiClient>;
 jest.mock("../../src/telemetry/eventCache.js");
 const MockEventCache = EventCache as jest.MockedClass<typeof EventCache>;
 
+const nextTick = () => new Promise((resolve) => process.nextTick(resolve));
+
 describe("Telemetry", () => {
     const machineId = "test-machine-id";
     const hashedMachineId = createHmac("sha256", machineId.toUpperCase()).update("atlascli").digest("hex");
@@ -24,6 +26,11 @@ describe("Telemetry", () => {
     let mockEventCache: jest.Mocked<EventCache>;
     let session: Session;
     let telemetry: Telemetry;
+    let telemetryConfig: {
+        eventCache: EventCache;
+        getRawMachineId: () => Promise<string>;
+        getContainerEnv: () => Promise<boolean>;
+    };
 
     // Helper function to create properly typed test events
     function createTestEvent(options?: {
@@ -77,19 +84,11 @@ describe("Telemetry", () => {
         expect(appendEvents.length).toBe(appendEventsCalls);
 
         if (sendEventsCalledWith) {
-            expect(sendEvents[0]?.[0]).toEqual(
-                sendEventsCalledWith.map((event) => ({
-                    ...event,
-                    properties: {
-                        ...telemetry.getCommonProperties(),
-                        ...event.properties,
-                    },
-                }))
-            );
+            expect(sendEvents[0]?.[0]).toMatchObject(sendEventsCalledWith);
         }
 
         if (appendEventsCalledWith) {
-            expect(appendEvents[0]?.[0]).toEqual(appendEventsCalledWith);
+            expect(appendEvents[0]?.[0]).toMatchObject(appendEventsCalledWith);
         }
     }
 
@@ -125,10 +124,13 @@ describe("Telemetry", () => {
             setAgentRunner: jest.fn().mockResolvedValue(undefined),
         } as unknown as Session;
 
-        telemetry = Telemetry.create(session, config, {
+        telemetryConfig = {
             eventCache: mockEventCache,
             getRawMachineId: () => Promise.resolve(machineId),
-        });
+            getContainerEnv: () => Promise.resolve(false),
+        };
+
+        telemetry = Telemetry.create(session, config, telemetryConfig);
 
         config.telemetry = "enabled";
     });
@@ -138,7 +140,8 @@ describe("Telemetry", () => {
             it("should send events successfully", async () => {
                 const testEvent = createTestEvent();
 
-                await telemetry.emitEvents([testEvent]);
+                telemetry.emitEvents([testEvent]);
+                await nextTick(); // wait for the event to be sent
 
                 verifyMockCalls({
                     sendEventsCalls: 1,
@@ -152,7 +155,8 @@ describe("Telemetry", () => {
 
                 const testEvent = createTestEvent();
 
-                await telemetry.emitEvents([testEvent]);
+                telemetry.emitEvents([testEvent]);
+                await nextTick(); // wait for the event to be sent
 
                 verifyMockCalls({
                     sendEventsCalls: 1,
@@ -175,7 +179,8 @@ describe("Telemetry", () => {
                 // Set up mock to return cached events
                 mockEventCache.getEvents.mockReturnValueOnce([cachedEvent]);
 
-                await telemetry.emitEvents([newEvent]);
+                telemetry.emitEvents([newEvent]);
+                await nextTick(); // wait for the event to be sent
 
                 verifyMockCalls({
                     sendEventsCalls: 1,
@@ -184,9 +189,7 @@ describe("Telemetry", () => {
                 });
             });
 
-            it("should correctly add common properties to events", () => {
-                const commonProps = telemetry.getCommonProperties();
-
+            it("should correctly add common properties to events", async () => {
                 // Use explicit type assertion
                 const expectedProps: Record<string, string> = {
                     mcp_client_version: "1.0.0",
@@ -197,48 +200,86 @@ describe("Telemetry", () => {
                     device_id: hashedMachineId,
                 };
 
-                expect(commonProps).toMatchObject(expectedProps);
+                const testEvent = createTestEvent();
+
+                telemetry.emitEvents([testEvent]);
+                await nextTick(); // wait for the event to be sent
+
+                const checkEvent = {
+                    ...testEvent,
+                    properties: {
+                        ...testEvent.properties,
+                        ...expectedProps,
+                    },
+                };
+
+                verifyMockCalls({
+                    sendEventsCalls: 1,
+                    clearEventsCalls: 1,
+                    sendEventsCalledWith: [checkEvent],
+                });
             });
 
-            describe("machine ID resolution", () => {
-                beforeEach(() => {
-                    jest.clearAllMocks();
-                    jest.useFakeTimers();
+            it("should send cache new event while sending another event", async () => {
+                const newEvent = createTestEvent({
+                    command: "new-command",
+                    component: "new-component",
                 });
 
-                afterEach(() => {
-                    jest.clearAllMocks();
-                    jest.useRealTimers();
+                const newEvent2 = createTestEvent({
+                    command: "new-command-2",
+                    component: "new-component-2",
                 });
 
-                it("should successfully resolve the machine ID", async () => {
-                    telemetry = Telemetry.create(session, config, {
-                        getRawMachineId: () => Promise.resolve(machineId),
-                    });
+                telemetry.emitEvents([newEvent]);
+                telemetry.emitEvents([newEvent2]);
 
-                    expect(telemetry["isBufferingEvents"]).toBe(true);
-                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
+                await nextTick(); // wait for the event to be sent
 
-                    await telemetry.deviceIdPromise;
+                verifyMockCalls({
+                    sendEventsCalls: 1,
+                    clearEventsCalls: 1,
+                    appendEventsCalls: 1,
+                    sendEventsCalledWith: [newEvent],
+                    appendEventsCalledWith: [newEvent2],
+                });
+            });
 
-                    expect(telemetry["isBufferingEvents"]).toBe(false);
-                    expect(telemetry.getCommonProperties().device_id).toBe(hashedMachineId);
+            describe("machine ID resolution", () => {
+                it("should successfully resolve the machine ID", async () => {
+                    const testEvent = createTestEvent();
+
+                    telemetry.emitEvents([testEvent]);
+                    await nextTick(); // wait for the event to be sent
+
+                    const checkEvent = {
+                        ...testEvent,
+                        properties: {
+                            ...testEvent.properties,
+                            device_id: hashedMachineId,
+                        },
+                    };
+
+                    verifyMockCalls({
+                        sendEventsCalls: 1,
+                        clearEventsCalls: 1,
+                        sendEventsCalledWith: [checkEvent],
+                    });
                 });
 
                 it("should handle machine ID resolution failure", async () => {
                     const loggerSpy = jest.spyOn(logger, "debug");
 
                     telemetry = Telemetry.create(session, config, {
+                        ...telemetryConfig,
                         getRawMachineId: () => Promise.reject(new Error("Failed to get device ID")),
                     });
 
-                    expect(telemetry["isBufferingEvents"]).toBe(true);
-                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
+                    const testEvent = createTestEvent();
 
-                    await telemetry.deviceIdPromise;
+                    telemetry.emitEvents([testEvent]);
 
-                    expect(telemetry["isBufferingEvents"]).toBe(false);
-                    expect(telemetry.getCommonProperties().device_id).toBe("unknown");
+                    await nextTick(); // wait for the event to be sent
 
                     expect(loggerSpy).toHaveBeenCalledWith(
                         LogId.telemetryDeviceIdFailure,
@@ -247,27 +288,28 @@ describe("Telemetry", () => {
                     );
                 });
 
-                it("should timeout if machine ID resolution takes too long", async () => {
+                it("should timeout if machine ID resolution takes too long", () => {
                     const loggerSpy = jest.spyOn(logger, "debug");
 
-                    telemetry = Telemetry.create(session, config, { getRawMachineId: () => new Promise(() => {}) });
+                    jest.useFakeTimers();
 
-                    expect(telemetry["isBufferingEvents"]).toBe(true);
-                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
+                    telemetry = Telemetry.create(session, config, {
+                        ...telemetryConfig,
+                        getRawMachineId: () => new Promise(() => {}), // Never resolves
+                    });
 
-                    jest.advanceTimersByTime(DEVICE_ID_TIMEOUT / 2);
+                    const testEvent = createTestEvent();
 
-                    // Make sure the timeout doesn't happen prematurely.
-                    expect(telemetry["isBufferingEvents"]).toBe(true);
-                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
+                    telemetry.emitEvents([testEvent]);
 
-                    jest.advanceTimersByTime(DEVICE_ID_TIMEOUT);
+                    jest.advanceTimersByTime(5000);
 
-                    await telemetry.deviceIdPromise;
+                    jest.useRealTimers();
 
-                    expect(telemetry.getCommonProperties().device_id).toBe("unknown");
-                    expect(telemetry["isBufferingEvents"]).toBe(false);
-                    expect(loggerSpy).toHaveBeenCalledWith(
+                    expect(loggerSpy).toHaveBeenCalledTimes(2);
+
+                    expect(loggerSpy).toHaveBeenNthCalledWith(
+                        2,
                         LogId.telemetryDeviceIdTimeout,
                         "telemetry",
                         "Device ID retrieval timed out"
@@ -288,9 +330,12 @@ describe("Telemetry", () => {
             it("should not send events", async () => {
                 const testEvent = createTestEvent();
 
-                await telemetry.emitEvents([testEvent]);
+                telemetry.emitEvents([testEvent]);
+                await nextTick(); // wait for the event to be sent
 
-                verifyMockCalls();
+                verifyMockCalls({
+                    sendEventsCalls: 0,
+                });
             });
         });
 
@@ -313,9 +358,12 @@ describe("Telemetry", () => {
             it("should not send events", async () => {
                 const testEvent = createTestEvent();
 
-                await telemetry.emitEvents([testEvent]);
+                telemetry.emitEvents([testEvent]);
+                await nextTick(); // wait for the event to be sent
 
-                verifyMockCalls();
+                verifyMockCalls({
+                    sendEventsCalls: 0,
+                });
             });
         });
     });

package/tsconfig.build.json

@@ -7,6 +7,7 @@
     "outDir": "./dist",
     "strict": true,
     "strictNullChecks": true,
+    "noUncheckedIndexedAccess": true,
     "esModuleInterop": true,
     "types": ["node"],
     "sourceMap": true,

package/tests/integration/telemetry.test.ts

@@ -1,28 +0,0 @@
-import { createHmac } from "crypto";
-import { Telemetry } from "../../src/telemetry/telemetry.js";
-import { Session } from "../../src/session.js";
-import { config } from "../../src/config.js";
-import nodeMachineId from "node-machine-id";
-
-describe("Telemetry", () => {
-    it("should resolve the actual machine ID", async () => {
-        const actualId: string = await nodeMachineId.machineId(true);
-
-        const actualHashedId = createHmac("sha256", actualId.toUpperCase()).update("atlascli").digest("hex");
-
-        const telemetry = Telemetry.create(
-            new Session({
-                apiBaseUrl: "",
-            }),
-            config
-        );
-
-        expect(telemetry.getCommonProperties().device_id).toBe(undefined);
-        expect(telemetry["isBufferingEvents"]).toBe(true);
-
-        await telemetry.deviceIdPromise;
-
-        expect(telemetry.getCommonProperties().device_id).toBe(actualHashedId);
-        expect(telemetry["isBufferingEvents"]).toBe(false);
-    });
-});