PriceUpdaterAppv2/tests/tui/windows/windowsPerformance.test.js

/**
 * Windows Performance Tests
 * Tests TUI performance specifically on Windows systems
 */

const {
	detectWindowsTerminal,
	getWindowsTerminalCapabilities,
} = require("../../../src/tui/utils/modernTerminal.js");

// Mock Windows environment
const mockWindowsEnvironment = (terminalType = "windows-terminal") => {
	Object.defineProperty(process, "platform", {
		value: "win32",
		writable: true,
	});

	// Clear environment first
	delete process.env.WT_SESSION;
	delete process.env.TERM_PROGRAM;
	delete process.env.PSModulePath;
	delete process.env.COMSPEC;
	delete process.env.COLORTERM;

	switch (terminalType) {
		case "windows-terminal":
			process.env.WT_SESSION = "test-session";
			process.env.TERM_PROGRAM = "Windows Terminal";
			process.env.COLORTERM = "truecolor";
			break;
		case "cmd":
			process.env.COMSPEC = "C:\\Windows\\system32\\cmd.exe";
			break;
		case "powershell":
			process.env.PSModulePath = "C:\\Program Files\\PowerShell\\Modules";
			process.env.TERM_PROGRAM = "PowerShell";
			break;
	}
};

describe("Windows Performance Tests", () => {
	const originalPlatform = process.platform;
	const originalEnv = process.env;

	afterEach(() => {
		process.env = originalEnv;
		Object.defineProperty(process, "platform", {
			value: originalPlatform,
			writable: true,
		});
	});

	describe("Terminal Detection Performance", () => {
		test("should detect Windows Terminal capabilities quickly", () => {
			mockWindowsEnvironment("windows-terminal");

			const startTime = Date.now();
			const capabilities = getWindowsTerminalCapabilities();
			const detectionTime = Date.now() - startTime;

			expect(detectionTime).toBeLessThan(10); // Should detect within 10ms
			expect(capabilities.isWindowsTerminal).toBe(true);
			expect(capabilities.supportsUnicode).toBe(true);
			expect(capabilities.supportsTrueColor).toBe(true);
		});

		test("should detect Command Prompt capabilities efficiently", () => {
			mockWindowsEnvironment("cmd");

			const startTime = Date.now();
			const capabilities = getWindowsTerminalCapabilities();
			const detectionTime = Date.now() - startTime;

			expect(detectionTime).toBeLessThan(10);
			expect(capabilities.isCommandPrompt).toBe(true);
			expect(capabilities.supportsUnicode).toBe(false);
			expect(capabilities.supportsTrueColor).toBe(false);
		});

		test("should detect PowerShell capabilities quickly", () => {
			mockWindowsEnvironment("powershell");

			const startTime = Date.now();
			const capabilities = getWindowsTerminalCapabilities();
			const detectionTime = Date.now() - startTime;

			expect(detectionTime).toBeLessThan(10);
			expect(capabilities.isPowerShell).toBe(true);
			expect(capabilities.supportsUnicode).toBe(true);
			expect(capabilities.supports256Color).toBe(true);
		});
	});

	describe("Memory Usage", () => {
		test("should not leak memory during Windows Terminal detection", () => {
			mockWindowsEnvironment("windows-terminal");

			const initialMemory = process.memoryUsage().heapUsed;

			// Run detection multiple times
			for (let i = 0; i < 1000; i++) {
				detectWindowsTerminal();
				getWindowsTerminalCapabilities();
			}

			// Force garbage collection if available
			if (global.gc) {
				global.gc();
			}

			const finalMemory = process.memoryUsage().heapUsed;
			const memoryIncrease = finalMemory - initialMemory;

			// Memory increase should be minimal (less than 1MB)
			expect(memoryIncrease).toBeLessThan(1024 * 1024);
		});

		test("should handle rapid terminal capability checks", () => {
			const terminals = ["windows-terminal", "cmd", "powershell"];
			const startTime = Date.now();

			// Rapidly switch between terminal types
			for (let i = 0; i < 100; i++) {
				const terminalType = terminals[i % terminals.length];
				mockWindowsEnvironment(terminalType);
				getWindowsTerminalCapabilities();
			}

			const totalTime = Date.now() - startTime;

			// Should complete 300 operations in less than 1 second
			expect(totalTime).toBeLessThan(1000);
		});
	});

	describe("Character Rendering Performance", () => {
		test("should generate character fallbacks efficiently", () => {
			mockWindowsEnvironment("cmd");

			const startTime = Date.now();
			const capabilities = getWindowsTerminalCapabilities();

			// Generate character mappings
			const chars = {
				progress: capabilities.supportsUnicode ? "█" : "#",
				empty: capabilities.supportsUnicode ? "░" : "-",
				status: capabilities.supportsUnicode ? "●" : "*",
				arrow: capabilities.supportsUnicode ? "►" : ">",
				check: capabilities.supportsUnicode ? "✓" : "v",
				cross: capabilities.supportsUnicode ? "✗" : "x",
			};

			// Generate progress bar strings
			const progressBars = [];
			for (let i = 0; i <= 100; i += 10) {
				const filled = Math.round((i / 100) * 20);
				progressBars.push(
					chars.progress.repeat(filled) + chars.empty.repeat(20 - filled)
				);
			}

			const generationTime = Date.now() - startTime;

			expect(generationTime).toBeLessThan(50);
			expect(progressBars).toHaveLength(11);
			expect(progressBars[0]).toBe("--------------------"); // 0% with fallback chars
			expect(progressBars[10]).toBe("####################"); // 100% with fallback chars
		});

		test("should handle Unicode character generation efficiently", () => {
			mockWindowsEnvironment("windows-terminal");

			const startTime = Date.now();
			const capabilities = getWindowsTerminalCapabilities();

			// Generate Unicode character strings
			const unicodeStrings = [];
			for (let i = 0; i < 100; i++) {
				const progressChar = capabilities.supportsUnicode ? "█" : "#";
				const emptyChar = capabilities.supportsUnicode ? "░" : "-";
				unicodeStrings.push(progressChar.repeat(10) + emptyChar.repeat(10));
			}

			const generationTime = Date.now() - startTime;

			expect(generationTime).toBeLessThan(50);
			expect(unicodeStrings).toHaveLength(100);
			expect(unicodeStrings[0]).toBe("██████████░░░░░░░░░░");
		});
	});

	describe("Windows-Specific Optimizations", () => {
		test("should optimize for Windows file path handling", () => {
			const windowsPaths = [
				"C:\\Users\\Test\\AppData\\Local\\Temp\\test.log",
				"D:\\Projects\\MyApp\\logs\\error.log",
				"\\\\server\\share\\file.txt",
				"C:\\Program Files\\App\\config.json",
			];

			const startTime = Date.now();

			const normalizedPaths = windowsPaths.map((path) => {
				// Simulate path normalization
				return path.replace(/\\/g, "/");
			});

			const processingTime = Date.now() - startTime;

			expect(processingTime).toBeLessThan(10);
			expect(normalizedPaths).toEqual([
				"C:/Users/Test/AppData/Local/Temp/test.log",
				"D:/Projects/MyApp/logs/error.log",
				"//server/share/file.txt",
				"C:/Program Files/App/config.json",
			]);
		});

		test("should handle Windows environment variable processing efficiently", () => {
			const windowsEnvVars = {
				USERPROFILE: "C:\\Users\\TestUser",
				APPDATA: "C:\\Users\\TestUser\\AppData\\Roaming",
				LOCALAPPDATA: "C:\\Users\\TestUser\\AppData\\Local",
				PROGRAMFILES: "C:\\Program Files",
				SYSTEMROOT: "C:\\Windows",
			};

			const startTime = Date.now();

			// Simulate environment variable processing
			Object.entries(windowsEnvVars).forEach(([key, value]) => {
				expect(typeof value).toBe("string");
				expect(value.length).toBeGreaterThan(0);
				expect(value).toMatch(/^[A-Z]:\\/); // Windows path format
			});

			const processingTime = Date.now() - startTime;
			expect(processingTime).toBeLessThan(10);
		});

		test("should efficiently detect Windows version compatibility", () => {
			const startTime = Date.now();

			// Simulate Windows version detection
			const isWindows = process.platform === "win32";
			const hasModernTerminal = Boolean(process.env.WT_SESSION);
			const hasLegacyTerminal = Boolean(process.env.COMSPEC);

			const detectionTime = Date.now() - startTime;

			expect(detectionTime).toBeLessThan(5);
			expect(typeof isWindows).toBe("boolean");
			expect(typeof hasModernTerminal).toBe("boolean");
			expect(typeof hasLegacyTerminal).toBe("boolean");
		});
	});

	describe("Stress Testing", () => {
		test("should handle repeated terminal type switching", () => {
			const terminals = ["windows-terminal", "cmd", "powershell"];
			const results = [];

			const startTime = Date.now();

			for (let i = 0; i < 1000; i++) {
				const terminalType = terminals[i % terminals.length];
				mockWindowsEnvironment(terminalType);
				const capabilities = getWindowsTerminalCapabilities();
				results.push(capabilities.terminalType);
			}

			const totalTime = Date.now() - startTime;

			expect(totalTime).toBeLessThan(500); // 1000 switches in less than 500ms
			expect(results).toHaveLength(1000);

			// Verify correct distribution
			const windowsTerminalCount = results.filter(
				(t) => t === "windows-terminal"
			).length;
			const cmdCount = results.filter((t) => t === "cmd").length;
			const powershellCount = results.filter((t) => t === "powershell").length;

			expect(windowsTerminalCount).toBeGreaterThan(300);
			expect(windowsTerminalCount).toBeLessThan(350);
			expect(cmdCount).toBeGreaterThan(300);
			expect(cmdCount).toBeLessThan(350);
			expect(powershellCount).toBeGreaterThan(300);
			expect(powershellCount).toBeLessThan(350);
		});

		test("should maintain performance under concurrent capability checks", async () => {
			mockWindowsEnvironment("windows-terminal");

			const startTime = Date.now();

			// Simulate concurrent capability checks
			const promises = Array.from({ length: 100 }, () =>
				Promise.resolve(getWindowsTerminalCapabilities())
			);

			const results = await Promise.all(promises);
			const totalTime = Date.now() - startTime;

			expect(totalTime).toBeLessThan(100);
			expect(results).toHaveLength(100);

			// All results should be identical
			results.forEach((result) => {
				expect(result.isWindowsTerminal).toBe(true);
				expect(result.supportsUnicode).toBe(true);
				expect(result.supportsTrueColor).toBe(true);
			});
		});
	});
});