fix tests, refactor deviceId

Author: nirinchev

src/helpers/deviceId.ts

@@ -5,89 +5,58 @@ import { LogId, LoggerBase } from "../common/logger.js";
 export const DEVICE_ID_TIMEOUT = 3000;
 
 export class DeviceId {
-    private deviceId: string | undefined = undefined;
-    private deviceIdPromise: Promise<string> | undefined = undefined;
-    private abortController: AbortController | undefined = undefined;
+    private static readonly UnknownDeviceId = Promise.resolve("unknown");
+
+    private deviceIdPromise: Promise<string>;
+    private abortController: AbortController;
     private logger: LoggerBase;
     private readonly getMachineId: () => Promise<string>;
     private timeout: number;
-    private static instance: DeviceId | undefined = undefined;
 
     private constructor(logger: LoggerBase, timeout: number = DEVICE_ID_TIMEOUT) {
         this.logger = logger;
         this.timeout = timeout;
         this.getMachineId = (): Promise<string> => nodeMachineId.machineId(true);
+        this.abortController = new AbortController();
+
+        this.deviceIdPromise = DeviceId.UnknownDeviceId;
     }
 
-    public static create(logger: LoggerBase, timeout?: number): DeviceId {
-        if (this.instance) {
-            throw new Error("DeviceId instance already exists, use get() to retrieve the device ID");
-        }
+    private initialize(): void {
+        this.deviceIdPromise = getDeviceId({
+            getMachineId: this.getMachineId,
+            onError: (reason, error) => {
+                this.handleDeviceIdError(reason, String(error));
+            },
+            timeout: this.timeout,
+            abortSignal: this.abortController.signal,
+        });
+    }
 
+    public static create(logger: LoggerBase, timeout?: number): DeviceId {
         const instance = new DeviceId(logger, timeout ?? DEVICE_ID_TIMEOUT);
-        instance.setup();
-
-        this.instance = instance;
+        instance.initialize();
 
         return instance;
     }
 
-    private setup(): void {
-        this.deviceIdPromise = this.calculateDeviceId();
-    }
-
     /**
      * Closes the device ID calculation promise and abort controller.
      */
     public close(): void {
-        if (this.abortController) {
-            this.abortController.abort();
-            this.abortController = undefined;
-        }
-
-        this.deviceId = undefined;
-        this.deviceIdPromise = undefined;
-        DeviceId.instance = undefined;
+        this.abortController.abort();
     }
 
     /**
      * Gets the device ID, waiting for the calculation to complete if necessary.
      * @returns Promise that resolves to the device ID string
      */
     public get(): Promise<string> {
-        if (this.deviceId) {
-            return Promise.resolve(this.deviceId);
-        }
-
-        if (this.deviceIdPromise) {
-            return this.deviceIdPromise;
-        }
-
-        return this.calculateDeviceId();
-    }
-
-    /**
-     * Internal method that performs the actual device ID calculation.
-     */
-    private async calculateDeviceId(): Promise<string> {
-        if (!this.abortController) {
-            this.abortController = new AbortController();
-        }
-
-        this.deviceIdPromise = getDeviceId({
-            getMachineId: this.getMachineId,
-            onError: (reason, error) => {
-                this.handleDeviceIdError(reason, String(error));
-            },
-            timeout: this.timeout,
-            abortSignal: this.abortController.signal,
-        });
-
         return this.deviceIdPromise;
     }
 
     private handleDeviceIdError(reason: string, error: string): void {
-        this.deviceIdPromise = Promise.resolve("unknown");
+        this.deviceIdPromise = DeviceId.UnknownDeviceId;
 
         switch (reason) {
             case "resolutionError":

tests/integration/transports/streamableHttp.test.ts

@@ -17,12 +17,6 @@ describe("StreamableHttpRunner", () => {
         config.httpPort = 0; // Use a random port for testing
     });
 
-    afterAll(async () => {
-        await runner.close();
-        config.telemetry = oldTelemetry;
-        config.loggers = oldLoggers;
-    });
-
     const headerTestCases: { headers: Record<string, string>; description: string }[] = [
         { headers: {}, description: "without headers" },
         { headers: { "x-custom-header": "test-value" }, description: "with headers" },
@@ -36,6 +30,13 @@ describe("StreamableHttpRunner", () => {
                 await runner.start();
             });
 
+            afterAll(async () => {
+                await runner.close();
+                config.telemetry = oldTelemetry;
+                config.loggers = oldLoggers;
+                config.httpHeaders = {};
+            });
+
             const clientHeaderTestCases = [
                 {
                     headers: {},
@@ -100,4 +101,23 @@ describe("StreamableHttpRunner", () => {
             }
         });
     }
+
+    it("can create multiple runners", async () => {
+        const runners: StreamableHttpRunner[] = [];
+        try {
+            for (let i = 0; i < 3; i++) {
+                config.httpPort = 0; // Use a random port for each runner
+                const runner = new StreamableHttpRunner(config);
+                await runner.start();
+                runners.push(runner);
+            }
+
+            const addresses = new Set<string>(runners.map((r) => r.address));
+            expect(addresses.size).toBe(runners.length);
+        } finally {
+            for (const runner of runners) {
+                await runner.close();
+            }
+        }
+    });
 });

tests/unit/helpers/deviceId.test.ts

@@ -22,11 +22,16 @@ describe("deviceId", () => {
         deviceId.close();
     });
 
-    it("should fail to create separate instances", () => {
+    it("should return different instance from create", async () => {
         deviceId = DeviceId.create(testLogger);
-
-        // try to create a new device id and see it raises an error
-        expect(() => DeviceId.create(testLogger)).toThrow("DeviceId instance already exists");
+        let second: DeviceId | undefined;
+        try {
+            second = DeviceId.create(testLogger);
+            expect(second === deviceId).toBe(false);
+            expect(await second.get()).toBe(await deviceId.get());
+        } finally {
+            second?.close();
+        }
     });
 
     it("should successfully retrieve device ID", async () => {