fix: adjust mocks to fit ESM

Author: gagik

src/telemetry/telemetry.ts

@@ -20,21 +20,35 @@ export class Telemetry {
     private isBufferingEvents: boolean = true;
     /** Resolves when the device ID is retrieved or timeout occurs */
     public deviceIdPromise: DeferredPromise<string> | undefined;
+    private eventCache: EventCache;
+    private getRawMachineId: () => Promise<string>;
 
     private constructor(
         private readonly session: Session,
         private readonly userConfig: UserConfig,
         private readonly commonProperties: CommonProperties,
-        private readonly eventCache: EventCache
-    ) {}
+        { eventCache, getRawMachineId }: { eventCache: EventCache; getRawMachineId: () => Promise<string> }
+    ) {
+        this.eventCache = eventCache;
+        this.getRawMachineId = getRawMachineId;
+    }
 
     static create(
         session: Session,
         userConfig: UserConfig,
-        commonProperties: CommonProperties = { ...MACHINE_METADATA },
-        eventCache: EventCache = EventCache.getInstance()
+        {
+            commonProperties = { ...MACHINE_METADATA },
+            eventCache = EventCache.getInstance(),
+
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+            getRawMachineId = () => nodeMachineId.machineId(true),
+        }: {
+            eventCache?: EventCache;
+            getRawMachineId?: () => Promise<string>;
+            commonProperties?: CommonProperties;
+        } = {}
     ): Telemetry {
-        const instance = new Telemetry(session, userConfig, commonProperties, eventCache);
+        const instance = new Telemetry(session, userConfig, commonProperties, { eventCache, getRawMachineId });
 
         void instance.start();
         return instance;
@@ -71,8 +85,7 @@ export class Telemetry {
                 return this.commonProperties.device_id;
             }
 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-            const originalId: string = await nodeMachineId.machineId(true);
+            const originalId: string = await this.getRawMachineId();
 
             // Create a hashed format from the all uppercase version of the machine ID
             // to match it exactly with the denisbrodbeck/machineid library that Atlas CLI uses.

tests/integration/telemetry.test.ts

@@ -1,13 +1,14 @@
 import { createHmac } from "crypto";
-import nodeMachineId from "node-machine-id";
 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 () => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         const actualId: string = await nodeMachineId.machineId(true);
+
         const actualHashedId = createHmac("sha256", actualId.toUpperCase()).update("atlascli").digest("hex");
 
         const telemetry = Telemetry.create(

tests/unit/telemetry.test.ts

@@ -1,19 +1,12 @@
-// Mock node-machine-id to simulate machine ID resolution
-jest.mock("node-machine-id", () => ({
-    machineId: jest.fn(),
-}));
-
 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 { BaseEvent, TelemetryResult } from "../../src/telemetry/types.js";
 import { EventCache } from "../../src/telemetry/eventCache.js";
 import { config } from "../../src/config.js";
-import { MACHINE_METADATA } from "../../src/telemetry/constants.js";
 import { jest } from "@jest/globals";
-import { createHmac } from "crypto";
 import logger, { LogId } from "../../src/logger.js";
-import nodeMachineId from "node-machine-id";
+import { createHmac } from "crypto";
 
 // Mock the ApiClient to avoid real API calls
 jest.mock("../../src/common/atlas/apiClient.js");
@@ -23,9 +16,10 @@ const MockApiClient = ApiClient as jest.MockedClass<typeof ApiClient>;
 jest.mock("../../src/telemetry/eventCache.js");
 const MockEventCache = EventCache as jest.MockedClass<typeof EventCache>;
 
-const mockMachineId = jest.spyOn(nodeMachineId, "machineId");
-
 describe("Telemetry", () => {
+    const machineId = "test-machine-id";
+    const hashedMachineId = createHmac("sha256", machineId.toUpperCase()).update("atlascli").digest("hex");
+
     let mockApiClient: jest.Mocked<ApiClient>;
     let mockEventCache: jest.Mocked<EventCache>;
     let session: Session;
@@ -131,26 +125,15 @@ describe("Telemetry", () => {
             setAgentRunner: jest.fn().mockResolvedValue(undefined),
         } as unknown as Session;
 
-        // Create the telemetry instance with mocked dependencies
-        telemetry = Telemetry.create(
-            session,
-            config,
-            {
-                ...MACHINE_METADATA,
-            },
-            mockEventCache
-        );
+        telemetry = Telemetry.create(session, config, {
+            eventCache: mockEventCache,
+            getRawMachineId: () => Promise.resolve(machineId),
+        });
 
         config.telemetry = "enabled";
     });
 
     describe("sending events", () => {
-        beforeEach(() => {
-            // @ts-expect-error This is a workaround
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            mockMachineId.mockResolvedValue("test-machine-id");
-        });
-
         describe("when telemetry is enabled", () => {
             it("should send events successfully", async () => {
                 const testEvent = createTestEvent();
@@ -200,141 +183,136 @@ describe("Telemetry", () => {
                     sendEventsCalledWith: [cachedEvent, newEvent],
                 });
             });
-        });
 
-        describe("when telemetry is disabled", () => {
-            beforeEach(() => {
-                config.telemetry = "disabled";
-            });
+            it("should correctly add common properties to events", () => {
+                const commonProps = telemetry.getCommonProperties();
 
-            it("should not send events", async () => {
-                const testEvent = createTestEvent();
-
-                await telemetry.emitEvents([testEvent]);
+                // Use explicit type assertion
+                const expectedProps: Record<string, string> = {
+                    mcp_client_version: "1.0.0",
+                    mcp_client_name: "test-agent",
+                    session_id: "test-session-id",
+                    config_atlas_auth: "true",
+                    config_connection_string: expect.any(String) as unknown as string,
+                    device_id: hashedMachineId,
+                };
 
-                verifyMockCalls();
+                expect(commonProps).toMatchObject(expectedProps);
             });
-        });
 
-        it("should correctly add common properties to events", () => {
-            const commonProps = telemetry.getCommonProperties();
+            describe("machine ID resolution", () => {
+                beforeEach(() => {
+                    jest.clearAllMocks();
+                    jest.useFakeTimers();
+                });
 
-            // Use explicit type assertion
-            const expectedProps: Record<string, string> = {
-                mcp_client_version: "1.0.0",
-                mcp_client_name: "test-agent",
-                session_id: "test-session-id",
-                config_atlas_auth: "true",
-                config_connection_string: expect.any(String) as unknown as string,
-            };
+                afterEach(() => {
+                    jest.clearAllMocks();
+                    jest.useRealTimers();
+                });
 
-            expect(commonProps).toMatchObject(expectedProps);
-        });
+                it("should successfully resolve the machine ID", async () => {
+                    telemetry = Telemetry.create(session, config, {
+                        getRawMachineId: () => Promise.resolve(machineId),
+                    });
 
-        describe("when DO_NOT_TRACK environment variable is set", () => {
-            let originalEnv: string | undefined;
+                    expect(telemetry["isBufferingEvents"]).toBe(true);
+                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
 
-            beforeEach(() => {
-                originalEnv = process.env.DO_NOT_TRACK;
-                process.env.DO_NOT_TRACK = "1";
-            });
+                    await telemetry.deviceIdPromise;
 
-            afterEach(() => {
-                process.env.DO_NOT_TRACK = originalEnv;
-            });
+                    expect(telemetry["isBufferingEvents"]).toBe(false);
+                    expect(telemetry.getCommonProperties().device_id).toBe(hashedMachineId);
+                });
 
-            it("should not send events", async () => {
-                const testEvent = createTestEvent();
+                it("should handle machine ID resolution failure", async () => {
+                    const loggerSpy = jest.spyOn(logger, "debug");
 
-                await telemetry.emitEvents([testEvent]);
+                    telemetry = Telemetry.create(session, config, {
+                        getRawMachineId: () => Promise.reject(new Error("Failed to get device ID")),
+                    });
 
-                verifyMockCalls();
-            });
-        });
-    });
+                    expect(telemetry["isBufferingEvents"]).toBe(true);
+                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
 
-    describe("machine ID resolution", () => {
-        const machineId = "test-machine-id";
-        const hashedMachineId = createHmac("sha256", machineId.toUpperCase()).update("atlascli").digest("hex");
+                    await telemetry.deviceIdPromise;
 
-        beforeEach(() => {
-            jest.useFakeTimers();
-            jest.clearAllMocks();
-        });
+                    expect(telemetry["isBufferingEvents"]).toBe(false);
+                    expect(telemetry.getCommonProperties().device_id).toBe("unknown");
 
-        afterEach(() => {
-            jest.useRealTimers();
-            jest.clearAllMocks();
-        });
+                    expect(loggerSpy).toHaveBeenCalledWith(
+                        LogId.telemetryDeviceIdFailure,
+                        "telemetry",
+                        "Error: Failed to get device ID"
+                    );
+                });
 
-        it("should successfully resolve the machine ID", async () => {
-            // @ts-expect-error This is a workaround
-            mockMachineId.mockResolvedValue(machineId);
-            telemetry = Telemetry.create(session, config);
+                it("should timeout if machine ID resolution takes too long", async () => {
+                    const loggerSpy = jest.spyOn(logger, "debug");
 
-            expect(telemetry["isBufferingEvents"]).toBe(true);
-            expect(telemetry.getCommonProperties().device_id).toBe(undefined);
+                    telemetry = Telemetry.create(session, config, { getRawMachineId: () => new Promise(() => {}) });
 
-            await telemetry.deviceIdPromise;
+                    expect(telemetry["isBufferingEvents"]).toBe(true);
+                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
 
-            expect(telemetry["isBufferingEvents"]).toBe(false);
-            expect(telemetry.getCommonProperties().device_id).toBe(hashedMachineId);
-        });
+                    jest.advanceTimersByTime(DEVICE_ID_TIMEOUT / 2);
 
-        it("should handle machine ID resolution failure", async () => {
-            const loggerSpy = jest.spyOn(logger, "debug");
+                    // Make sure the timeout doesn't happen prematurely.
+                    expect(telemetry["isBufferingEvents"]).toBe(true);
+                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
 
-            // @ts-expect-error This is a workaround
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            mockMachineId.mockRejectedValue(new Error("Failed to get device ID"));
+                    jest.advanceTimersByTime(DEVICE_ID_TIMEOUT);
 
-            telemetry = Telemetry.create(session, config);
+                    await telemetry.deviceIdPromise;
 
-            expect(telemetry["isBufferingEvents"]).toBe(true);
-            expect(telemetry.getCommonProperties().device_id).toBe(undefined);
+                    expect(telemetry.getCommonProperties().device_id).toBe("unknown");
+                    expect(telemetry["isBufferingEvents"]).toBe(false);
+                    expect(loggerSpy).toHaveBeenCalledWith(
+                        LogId.telemetryDeviceIdTimeout,
+                        "telemetry",
+                        "Device ID retrieval timed out"
+                    );
+                });
+            });
+        });
 
-            await telemetry.deviceIdPromise;
+        describe("when telemetry is disabled", () => {
+            beforeEach(() => {
+                config.telemetry = "disabled";
+            });
 
-            expect(telemetry["isBufferingEvents"]).toBe(false);
-            expect(telemetry.getCommonProperties().device_id).toBe("unknown");
+            afterEach(() => {
+                config.telemetry = "enabled";
+            });
 
-            expect(loggerSpy).toHaveBeenCalledWith(
-                LogId.telemetryDeviceIdFailure,
-                "telemetry",
-                "Error: Failed to get device ID"
-            );
-        });
+            it("should not send events", async () => {
+                const testEvent = createTestEvent();
 
-        it("should timeout if machine ID resolution takes too long", async () => {
-            const loggerSpy = jest.spyOn(logger, "debug");
+                await telemetry.emitEvents([testEvent]);
 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            mockMachineId.mockImplementation(() => {
-                return new Promise(() => {});
+                verifyMockCalls();
             });
+        });
 
-            telemetry = Telemetry.create(session, config);
-
-            expect(telemetry["isBufferingEvents"]).toBe(true);
-            expect(telemetry.getCommonProperties().device_id).toBe(undefined);
+        describe("when DO_NOT_TRACK environment variable is set", () => {
+            let originalEnv: string | undefined;
 
-            jest.advanceTimersByTime(DEVICE_ID_TIMEOUT / 2);
+            beforeEach(() => {
+                originalEnv = process.env.DO_NOT_TRACK;
+                process.env.DO_NOT_TRACK = "1";
+            });
 
-            // Make sure the timeout doesn't happen prematurely.
-            expect(telemetry["isBufferingEvents"]).toBe(true);
-            expect(telemetry.getCommonProperties().device_id).toBe(undefined);
+            afterEach(() => {
+                process.env.DO_NOT_TRACK = originalEnv;
+            });
 
-            jest.advanceTimersByTime(DEVICE_ID_TIMEOUT);
+            it("should not send events", async () => {
+                const testEvent = createTestEvent();
 
-            await telemetry.deviceIdPromise;
+                await telemetry.emitEvents([testEvent]);
 
-            expect(telemetry.getCommonProperties().device_id).toBe("unknown");
-            expect(telemetry["isBufferingEvents"]).toBe(false);
-            expect(loggerSpy).toHaveBeenCalledWith(
-                LogId.telemetryDeviceIdTimeout,
-                "telemetry",
-                "Device ID retrieval timed out"
-            );
+                verifyMockCalls();
+            });
         });
     });
 });