chore: add telemetry unit tests

Author: blva

tests/unit/telemetry/mocks/apiClient.mock.ts

@@ -0,0 +1,18 @@
+import { jest } from "@jest/globals";
+import { ApiClient } from "../../../../src/common/atlas/apiClient.js";
+import { BaseEvent } from "../../../../src/telemetry/types.js";
+
+/**
+ * Mock implementation of the ApiClient for unit testing
+ */
+export const mockApiClient = {
+    sendEvents: jest.fn<(events: BaseEvent[]) => Promise<void>>(),
+    hasCredentials: jest.fn<() => boolean>(),
+};
+
+/**
+ * Creates a mocked ApiClient instance for testing
+ */
+export function createMockApiClient(): jest.Mocked<Partial<ApiClient>> {
+    return mockApiClient as jest.Mocked<Partial<ApiClient>>;
+}

tests/unit/telemetry/mocks/eventCache.mock.ts

@@ -0,0 +1,20 @@
+import { jest } from "@jest/globals";
+import { EventCache } from "../../../../src/telemetry/eventCache.js";
+import { BaseEvent } from "../../../../src/telemetry/types.js";
+
+/**
+ * Creates a mocked EventCache instance for testing
+ */
+export function createMockEventCache(initialEvents: BaseEvent[] = []): jest.Mocked<Partial<EventCache>> {
+    let events = [...initialEvents];
+
+    return {
+        getEvents: jest.fn().mockImplementation(() => [...events]),
+        appendEvents: jest.fn().mockImplementation((newEvents: BaseEvent[]) => {
+            events.push(...newEvents);
+        }),
+        clearEvents: jest.fn().mockImplementation(() => {
+            events = [];
+        }),
+    } as jest.Mocked<Partial<EventCache>>;
+}

tests/unit/telemetry/mocks/session.mock.ts

@@ -0,0 +1,18 @@
+import { jest } from "@jest/globals";
+import { Session } from "../../../../src/session.js";
+import { createMockApiClient } from "./apiClient.mock.js";
+
+/**
+ * Creates a mocked Session instance for testing
+ */
+export function createMockSession(): jest.Mocked<Partial<Session>> {
+    return {
+        apiClient: createMockApiClient(),
+        sessionId: "test-session-id",
+        agentRunner: {
+            name: "test-agent",
+            version: "1.0.0",
+        },
+        close: jest.fn().mockResolvedValue(undefined),
+    } as jest.Mocked<Partial<Session>>;
+}

tests/unit/telemetry/telemetry.test.ts

@@ -0,0 +1,86 @@
+import { jest } from "@jest/globals";
+import { Telemetry } from "../../../src/telemetry/telemetry.js";
+import { BaseEvent } from "../../../src/telemetry/types.js";
+import { mockApiClient, createMockApiClient } from "./mocks/apiClient.mock.js";
+import { createMockEventCache } from "./mocks/eventCache.mock.js";
+import { createMockSession } from "./mocks/session.mock.js";
+
+// Mock the config module
+jest.mock("../../../src/config.js", () => ({
+    config: {
+        telemetry: "enabled",
+    },
+}));
+
+// Mock the constants module
+jest.mock("../../../src/telemetry/constants.js", () => ({
+    MACHINE_METADATA: {
+        device_id: "mock-device-id",
+        mcp_server_version: "1.0.0",
+        mcp_server_name: "atlas-mcp-server",
+        platform: "test-platform",
+        arch: "test-arch",
+        os_type: "test-os",
+        os_version: "test-version",
+    },
+}));
+
+// Helper function to create a test event
+const createTestEvent = (overrides: Partial<BaseEvent> = {}): BaseEvent => ({
+    timestamp: new Date().toISOString(),
+    source: "mdbmcp",
+    properties: {
+        device_id: "mock-device-id",
+        mcp_server_version: "1.0.0",
+        mcp_server_name: "atlas-mcp-server",
+        platform: "test-platform",
+        arch: "test-arch",
+        os_type: "test-os",
+        component: "test",
+        duration_ms: 100,
+        result: "success",
+        category: "test",
+        ...overrides.properties,
+    },
+    ...overrides,
+});
+
+describe("Telemetry", () => {
+    // Save and restore environment variables between tests
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+        jest.clearAllMocks();
+
+        // Reset mocked API client
+        mockApiClient.sendEvents.mockReset();
+        mockApiClient.hasCredentials.mockReset();
+        mockApiClient.sendEvents.mockResolvedValue(undefined);
+        mockApiClient.hasCredentials.mockReturnValue(true);
+    });
+
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+
+    describe("emitEvents", () => {
+        it("should send events successfully and clear cache", async () => {
+            // Arrange
+            mockApiClient.sendEvents.mockResolvedValue(undefined);
+            const mockSession = createMockSession();
+            const cachedEvents = [createTestEvent({ properties: { command: "list-clusters" } })];
+            const mockEventCache = createMockEventCache(cachedEvents);
+            const telemetry = new Telemetry(mockSession as any, mockEventCache as any);
+            const newEvents = [createTestEvent({ properties: { command: "new" } })];
+
+            // Act
+            await telemetry.emitEvents(newEvents);
+
+            // Assert
+            expect(mockApiClient.sendEvents).toHaveBeenCalledWith([...cachedEvents, ...newEvents]);
+            expect(mockEventCache.clearEvents).toHaveBeenCalled();
+            expect(mockEventCache.appendEvents).not.toHaveBeenCalled();
+        });
+    });
+});