pi-lens 3.6.2 → 3.6.4

package/clients/lsp/__tests__/launch.test.js

@@ -1,313 +0,0 @@
-/**
- * LSP Launch Utilities Test Suite
- *
- * Tests for launching LSP servers including:
- * - Direct binary execution
- * - Package manager execution (npx/bun)
- * - Node.js script execution
- * - Python module execution
- * - Process cleanup
- */
-import { spawn } from "node:child_process";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { launchLSP, launchViaNode, launchViaPackageManager, launchViaPython, stopLSP, } from "../launch.js";
-// Mock child_process
-vi.mock("child_process", () => ({
-    spawn: vi.fn(),
-}));
-const mockSpawn = vi.mocked(spawn);
-// Helper to create mock child process
-function createMockChildProcess(pid = 123) {
-    const handlers = new Map();
-    const mockObj = {
-        pid,
-        stdin: { write: vi.fn() },
-        stdout: { on: vi.fn(), pipe: vi.fn() },
-        stderr: { on: vi.fn(), pipe: vi.fn() },
-        kill: vi.fn(),
-        exitCode: null,
-        killed: false,
-        on(event, handler) {
-            if (!handlers.has(event)) {
-                handlers.set(event, []);
-            }
-            handlers.get(event)?.push(handler);
-            return mockObj;
-        },
-        _emit(event, ...args) {
-            handlers.get(event)?.forEach((h) => h(...args));
-        },
-    };
-    return mockObj;
-}
-describe("launchLSP", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should spawn process with correct parameters", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        // Start the async operation
-        const launchPromise = launchLSP("typescript-language-server", ["--stdio"], {
-            cwd: "/test",
-        });
-        // Let the 50ms timeout pass
-        await new Promise((r) => setTimeout(r, 60));
-        // Now complete by resolving
-        const _result = await launchPromise;
-        expect(mockSpawn).toHaveBeenCalled();
-        const [cmd, _args, options] = mockSpawn.mock.calls[0];
-        // Command should be provided (format depends on platform)
-        expect(cmd).toBeTruthy();
-        expect(options).toMatchObject({
-            cwd: "/test",
-            stdio: ["pipe", "pipe", "pipe"],
-            detached: false,
-            windowsHide: true,
-        });
-    });
-    it("should merge environment variables", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        const customEnv = { CUSTOM_VAR: "value" };
-        const launchPromise = launchLSP("server", [], { env: customEnv });
-        await new Promise((r) => setTimeout(r, 60));
-        await launchPromise;
-        const [, , options] = mockSpawn.mock.calls[0];
-        expect(options?.env).toMatchObject({
-            CUSTOM_VAR: "value",
-        });
-    });
-    it("should return LSPProcess with all streams", async () => {
-        const mockProcess = createMockChildProcess(456);
-        mockSpawn.mockReturnValue(mockProcess);
-        const launchPromise = launchLSP("server", [], {});
-        await new Promise((r) => setTimeout(r, 60));
-        const result = await launchPromise;
-        expect(result.pid).toBe(456);
-        expect(result.stdin).toBeDefined();
-        expect(result.stdout).toBeDefined();
-        expect(result.stderr).toBeDefined();
-    });
-    it("should throw if stdin is not available", async () => {
-        const baseMock = createMockChildProcess();
-        const mockProcess = {
-            ...baseMock,
-            stdin: null,
-            on: baseMock.on,
-            _emit: baseMock._emit,
-        };
-        mockSpawn.mockReturnValue(mockProcess);
-        // Use wrapper function for proper async error catching
-        const launchFn = async () => launchLSP("server", [], {});
-        await expect(launchFn()).rejects.toThrow("Failed to spawn LSP server");
-    });
-    it("should throw if stdout is not available", async () => {
-        const baseMock = createMockChildProcess();
-        const mockProcess = {
-            ...baseMock,
-            stdout: null,
-            on: baseMock.on,
-            _emit: baseMock._emit,
-        };
-        mockSpawn.mockReturnValue(mockProcess);
-        const launchFn = async () => launchLSP("server", [], {});
-        await expect(launchFn()).rejects.toThrow("Failed to spawn LSP server");
-    });
-    it("should throw if stderr is not available", async () => {
-        const baseMock = createMockChildProcess();
-        const mockProcess = {
-            ...baseMock,
-            stderr: null,
-            on: baseMock.on,
-            _emit: baseMock._emit,
-        };
-        mockSpawn.mockReturnValue(mockProcess);
-        const launchFn = async () => launchLSP("server", [], {});
-        await expect(launchFn()).rejects.toThrow("Failed to spawn LSP server");
-    });
-    it("should default to process.cwd() when cwd not provided", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        const launchPromise = launchLSP("server", [], {});
-        await new Promise((r) => setTimeout(r, 60));
-        await launchPromise;
-        const [, , options] = mockSpawn.mock.calls[0];
-        expect(options?.cwd).toBe(process.cwd());
-    });
-    it("should use shell mode on Windows for .cmd files", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        // Save original platform
-        const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform");
-        Object.defineProperty(process, "platform", { value: "win32" });
-        try {
-            const launchPromise = launchLSP("server.cmd", ["--arg"], {});
-            await new Promise((r) => setTimeout(r, 60));
-            await launchPromise;
-            const [, , options] = mockSpawn.mock.calls[0];
-            expect(options?.shell).toBe(true);
-        }
-        finally {
-            // Restore original platform
-            if (originalPlatform) {
-                Object.defineProperty(process, "platform", originalPlatform);
-            }
-        }
-    });
-});
-describe("launchViaPackageManager", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Clear BUN_INSTALL env var
-        delete process.env.BUN_INSTALL;
-    });
-    it("should spawn via package manager", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchViaPackageManager("typescript-language-server", ["--stdio"], {});
-        expect(mockSpawn).toHaveBeenCalled();
-        const [cmd] = mockSpawn.mock.calls[0];
-        // Command should contain npx or bun
-        expect(String(cmd)).toMatch(/npx|bun/);
-    });
-    it("should use bun when BUN_INSTALL is set", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        process.env.BUN_INSTALL = "/path/to/bun";
-        launchViaPackageManager("typescript-language-server", ["--stdio"], {});
-        const [cmd, args] = mockSpawn.mock.calls[0];
-        // On Windows with shell mode, args may be concatenated into cmd
-        const cmdStr = String(cmd);
-        const hasBun = cmdStr.includes("bun") || args?.some((a) => a?.includes("bun"));
-        const _hasX = cmdStr.includes(" x ") || args?.includes("x");
-        expect(hasBun).toBe(true);
-        // Note: 'x' arg may be in command string on Windows
-    });
-    it("should pass through options", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchViaPackageManager("server", ["--flag"], { cwd: "/test" });
-        const [, , options] = mockSpawn.mock.calls[0];
-        expect(options?.cwd).toBe("/test");
-    });
-});
-describe("launchViaNode", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should spawn node with script path", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchViaNode("/path/to/script.js", ["--arg"], { cwd: "/test" });
-        expect(mockSpawn).toHaveBeenCalled();
-        const [cmd, _args, options] = mockSpawn.mock.calls[0];
-        // On Windows, command is combined; on Unix, it's separate
-        expect(String(cmd)).toContain("node");
-        expect(options?.cwd).toBe("/test");
-    });
-});
-describe("launchViaPython", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should spawn Python module", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchViaPython("pylsp", [], {});
-        expect(mockSpawn).toHaveBeenCalled();
-        const [cmd] = mockSpawn.mock.calls[0];
-        expect(String(cmd)).toMatch(/python|py/);
-    });
-    it("should pass args to module", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        await launchViaPython("pylsp", ["--verbose", "--log-file", "/tmp/log"], {});
-        expect(mockSpawn).toHaveBeenCalled();
-        const [cmd, args] = mockSpawn.mock.calls[0];
-        // On Windows with shell mode, args may be combined into cmd string
-        // Check that the command contains all expected parts
-        const fullCommand = typeof cmd === "string" && Array.isArray(args) && args.length === 0
-            ? cmd // shell mode: everything in cmd
-            : `${cmd} ${args.join(" ")}`; // normal mode
-        expect(fullCommand).toContain("-m");
-        expect(fullCommand).toContain("pylsp");
-        expect(fullCommand).toContain("--verbose");
-    });
-});
-describe("stopLSP", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.useFakeTimers({ shouldAdvanceTime: true });
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it("should send SIGTERM first", async () => {
-        const mockKill = vi.fn();
-        const exitHandlers = [];
-        const mockProcess = {
-            ...createMockChildProcess(),
-            kill: mockKill,
-            on: vi.fn((event, handler) => {
-                if (event === "exit") {
-                    exitHandlers.push(handler);
-                    // Simulate immediate exit
-                    setTimeout(() => handler(), 10);
-                }
-            }),
-        };
-        const _stopPromise = stopLSP({
-            process: mockProcess,
-            stdin: {},
-            stdout: {},
-            stderr: {},
-            pid: 123,
-        });
-        // Let the exit handler fire
-        await new Promise((r) => setTimeout(r, 20));
-        expect(mockKill).toHaveBeenCalledWith("SIGTERM");
-    });
-    it.skip("should send SIGKILL if process doesn't exit in time", async () => {
-        // This test is flaky with fake timers - skipping for now
-        // The actual implementation works correctly in production
-    }, 15000);
-    it("should resolve immediately on exit", async () => {
-        const mockProcess = {
-            ...createMockChildProcess(),
-            on: vi.fn((event, handler) => {
-                if (event === "exit") {
-                    // Call handler immediately
-                    handler();
-                }
-            }),
-        };
-        await expect(stopLSP({
-            process: mockProcess,
-            stdin: {},
-            stdout: {},
-            stderr: {},
-            pid: 123,
-        })).resolves.toBeUndefined();
-    });
-    it("should resolve on error event", async () => {
-        const mockProcess = {
-            ...createMockChildProcess(),
-            on: vi.fn((event, handler) => {
-                if (event === "error") {
-                    setTimeout(handler, 10);
-                }
-            }),
-        };
-        const stopPromise = stopLSP({
-            process: mockProcess,
-            stdin: {},
-            stdout: {},
-            stderr: {},
-            pid: 123,
-        });
-        // Let the error handler fire
-        await new Promise((r) => setTimeout(r, 20));
-        await expect(stopPromise).resolves.toBeUndefined();
-    });
-});

package/clients/lsp/__tests__/launch.test.ts

@@ -1,394 +0,0 @@
-/**
- * LSP Launch Utilities Test Suite
- *
- * Tests for launching LSP servers including:
- * - Direct binary execution
- * - Package manager execution (npx/bun)
- * - Node.js script execution
- * - Python module execution
- * - Process cleanup
- */
-
-import { type ChildProcess, spawn } from "node:child_process";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-	launchLSP,
-	launchViaNode,
-	launchViaPackageManager,
-	launchViaPython,
-	stopLSP,
-} from "../launch.js";
-
-// Mock child_process
-vi.mock("child_process", () => ({
-	spawn: vi.fn(),
-}));
-
-const mockSpawn = vi.mocked(spawn);
-
-// Helper to create mock child process
-function createMockChildProcess(
-	pid: number = 123,
-): Partial<ChildProcess> & { _emit: (event: string, ...args: any[]) => void } {
-	const handlers = new Map<string, Array<(...args: any[]) => void>>();
-	const mockObj: any = {
-		pid,
-		stdin: { write: vi.fn() } as any,
-		stdout: { on: vi.fn(), pipe: vi.fn() } as any,
-		stderr: { on: vi.fn(), pipe: vi.fn() } as any,
-		kill: vi.fn(),
-		exitCode: null,
-		killed: false,
-		on(event: string, handler: (...args: any[]) => void) {
-			if (!handlers.has(event)) {
-				handlers.set(event, []);
-			}
-			handlers.get(event)?.push(handler);
-			return mockObj;
-		},
-		_emit(event: string, ...args: any[]) {
-			handlers.get(event)?.forEach((h) => h(...args));
-		},
-	};
-	return mockObj;
-}
-
-describe("launchLSP", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	it("should spawn process with correct parameters", async () => {
-		const mockProcess = createMockChildProcess();
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		// Start the async operation
-		const launchPromise = launchLSP("typescript-language-server", ["--stdio"], {
-			cwd: "/test",
-		});
-
-		// Let the 50ms timeout pass
-		await new Promise((r) => setTimeout(r, 60));
-
-		// Now complete by resolving
-		const _result = await launchPromise;
-
-		expect(mockSpawn).toHaveBeenCalled();
-		const [cmd, _args, options] = mockSpawn.mock.calls[0];
-
-		// Command should be provided (format depends on platform)
-		expect(cmd).toBeTruthy();
-		expect(options).toMatchObject({
-			cwd: "/test",
-			stdio: ["pipe", "pipe", "pipe"],
-			detached: false,
-			windowsHide: true,
-		});
-	});
-
-	it("should merge environment variables", async () => {
-		const mockProcess = createMockChildProcess();
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		const customEnv = { CUSTOM_VAR: "value" };
-		const launchPromise = launchLSP("server", [], { env: customEnv });
-
-		await new Promise((r) => setTimeout(r, 60));
-		await launchPromise;
-
-		const [, , options] = mockSpawn.mock.calls[0];
-		expect(options?.env).toMatchObject({
-			CUSTOM_VAR: "value",
-		});
-	});
-
-	it("should return LSPProcess with all streams", async () => {
-		const mockProcess = createMockChildProcess(456);
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		const launchPromise = launchLSP("server", [], {});
-		await new Promise((r) => setTimeout(r, 60));
-		const result = await launchPromise;
-
-		expect(result.pid).toBe(456);
-		expect(result.stdin).toBeDefined();
-		expect(result.stdout).toBeDefined();
-		expect(result.stderr).toBeDefined();
-	});
-
-	it("should throw if stdin is not available", async () => {
-		const baseMock = createMockChildProcess();
-		const mockProcess = {
-			...baseMock,
-			stdin: null,
-			on: baseMock.on,
-			_emit: baseMock._emit,
-		};
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		// Use wrapper function for proper async error catching
-		const launchFn = async () => launchLSP("server", [], {});
-		await expect(launchFn()).rejects.toThrow("Failed to spawn LSP server");
-	});
-
-	it("should throw if stdout is not available", async () => {
-		const baseMock = createMockChildProcess();
-		const mockProcess = {
-			...baseMock,
-			stdout: null,
-			on: baseMock.on,
-			_emit: baseMock._emit,
-		};
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		const launchFn = async () => launchLSP("server", [], {});
-		await expect(launchFn()).rejects.toThrow("Failed to spawn LSP server");
-	});
-
-	it("should throw if stderr is not available", async () => {
-		const baseMock = createMockChildProcess();
-		const mockProcess = {
-			...baseMock,
-			stderr: null,
-			on: baseMock.on,
-			_emit: baseMock._emit,
-		};
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		const launchFn = async () => launchLSP("server", [], {});
-		await expect(launchFn()).rejects.toThrow("Failed to spawn LSP server");
-	});
-
-	it("should default to process.cwd() when cwd not provided", async () => {
-		const mockProcess = createMockChildProcess();
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		const launchPromise = launchLSP("server", [], {});
-		await new Promise((r) => setTimeout(r, 60));
-		await launchPromise;
-
-		const [, , options] = mockSpawn.mock.calls[0];
-		expect(options?.cwd).toBe(process.cwd());
-	});
-
-	it("should use shell mode on Windows for .cmd files", async () => {
-		const mockProcess = createMockChildProcess();
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		// Save original platform
-		const originalPlatform = Object.getOwnPropertyDescriptor(
-			process,
-			"platform",
-		);
-		Object.defineProperty(process, "platform", { value: "win32" });
-
-		try {
-			const launchPromise = launchLSP("server.cmd", ["--arg"], {});
-			await new Promise((r) => setTimeout(r, 60));
-			await launchPromise;
-
-			const [, , options] = mockSpawn.mock.calls[0];
-			expect(options?.shell).toBe(true);
-		} finally {
-			// Restore original platform
-			if (originalPlatform) {
-				Object.defineProperty(process, "platform", originalPlatform);
-			}
-		}
-	});
-});
-
-describe("launchViaPackageManager", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-		// Clear BUN_INSTALL env var
-		delete process.env.BUN_INSTALL;
-	});
-
-	it("should spawn via package manager", async () => {
-		const mockProcess = createMockChildProcess();
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		launchViaPackageManager("typescript-language-server", ["--stdio"], {});
-
-		expect(mockSpawn).toHaveBeenCalled();
-		const [cmd] = mockSpawn.mock.calls[0];
-		// Command should contain npx or bun
-		expect(String(cmd)).toMatch(/npx|bun/);
-	});
-
-	it("should use bun when BUN_INSTALL is set", async () => {
-		const mockProcess = createMockChildProcess();
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		process.env.BUN_INSTALL = "/path/to/bun";
-
-		launchViaPackageManager("typescript-language-server", ["--stdio"], {});
-
-		const [cmd, args] = mockSpawn.mock.calls[0];
-		// On Windows with shell mode, args may be concatenated into cmd
-		const cmdStr = String(cmd);
-		const hasBun =
-			cmdStr.includes("bun") || args?.some((a: string) => a?.includes("bun"));
-		const _hasX = cmdStr.includes(" x ") || args?.includes("x");
-		expect(hasBun).toBe(true);
-		// Note: 'x' arg may be in command string on Windows
-	});
-
-	it("should pass through options", async () => {
-		const mockProcess = createMockChildProcess();
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		launchViaPackageManager("server", ["--flag"], { cwd: "/test" });
-
-		const [, , options] = mockSpawn.mock.calls[0];
-		expect(options?.cwd).toBe("/test");
-	});
-});
-
-describe("launchViaNode", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	it("should spawn node with script path", async () => {
-		const mockProcess = createMockChildProcess();
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		launchViaNode("/path/to/script.js", ["--arg"], { cwd: "/test" });
-
-		expect(mockSpawn).toHaveBeenCalled();
-		const [cmd, _args, options] = mockSpawn.mock.calls[0];
-
-		// On Windows, command is combined; on Unix, it's separate
-		expect(String(cmd)).toContain("node");
-		expect(options?.cwd).toBe("/test");
-	});
-});
-
-describe("launchViaPython", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	it("should spawn Python module", async () => {
-		const mockProcess = createMockChildProcess();
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		launchViaPython("pylsp", [], {});
-
-		expect(mockSpawn).toHaveBeenCalled();
-		const [cmd] = mockSpawn.mock.calls[0];
-		expect(String(cmd)).toMatch(/python|py/);
-	});
-
-	it("should pass args to module", async () => {
-		const mockProcess = createMockChildProcess();
-		mockSpawn.mockReturnValue(mockProcess as ChildProcess);
-
-		await launchViaPython("pylsp", ["--verbose", "--log-file", "/tmp/log"], {});
-
-		expect(mockSpawn).toHaveBeenCalled();
-		const [cmd, args] = mockSpawn.mock.calls[0];
-		// On Windows with shell mode, args may be combined into cmd string
-		// Check that the command contains all expected parts
-		const fullCommand =
-			typeof cmd === "string" && Array.isArray(args) && args.length === 0
-				? cmd // shell mode: everything in cmd
-				: `${cmd} ${args.join(" ")}`; // normal mode
-		expect(fullCommand).toContain("-m");
-		expect(fullCommand).toContain("pylsp");
-		expect(fullCommand).toContain("--verbose");
-	});
-});
-
-describe("stopLSP", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-		vi.useFakeTimers({ shouldAdvanceTime: true });
-	});
-
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	it("should send SIGTERM first", async () => {
-		const mockKill = vi.fn();
-		const exitHandlers: Array<() => void> = [];
-
-		const mockProcess = {
-			...createMockChildProcess(),
-			kill: mockKill,
-			on: vi.fn((event: string, handler: () => void) => {
-				if (event === "exit") {
-					exitHandlers.push(handler);
-					// Simulate immediate exit
-					setTimeout(() => handler(), 10);
-				}
-			}),
-		};
-
-		const _stopPromise = stopLSP({
-			process: mockProcess as any,
-			stdin: {} as any,
-			stdout: {} as any,
-			stderr: {} as any,
-			pid: 123,
-		});
-
-		// Let the exit handler fire
-		await new Promise((r) => setTimeout(r, 20));
-
-		expect(mockKill).toHaveBeenCalledWith("SIGTERM");
-	});
-
-	it.skip("should send SIGKILL if process doesn't exit in time", async () => {
-		// This test is flaky with fake timers - skipping for now
-		// The actual implementation works correctly in production
-	}, 15000);
-
-	it("should resolve immediately on exit", async () => {
-		const mockProcess = {
-			...createMockChildProcess(),
-			on: vi.fn((event: string, handler: () => void) => {
-				if (event === "exit") {
-					// Call handler immediately
-					handler();
-				}
-			}),
-		};
-
-		await expect(
-			stopLSP({
-				process: mockProcess as any,
-				stdin: {} as any,
-				stdout: {} as any,
-				stderr: {} as any,
-				pid: 123,
-			}),
-		).resolves.toBeUndefined();
-	});
-
-	it("should resolve on error event", async () => {
-		const mockProcess = {
-			...createMockChildProcess(),
-			on: vi.fn((event: string, handler: () => void) => {
-				if (event === "error") {
-					setTimeout(handler, 10);
-				}
-			}),
-		};
-
-		const stopPromise = stopLSP({
-			process: mockProcess as any,
-			stdin: {} as any,
-			stdout: {} as any,
-			stderr: {} as any,
-			pid: 123,
-		});
-
-		// Let the error handler fire
-		await new Promise((r) => setTimeout(r, 20));
-		await expect(stopPromise).resolves.toBeUndefined();
-	});
-});