add more tests

Author: iscekic

cli/src/state/atoms/__tests__/shell.test.ts

@@ -3,11 +3,18 @@ import { createStore } from "jotai"
 import { shellModeActiveAtom, toggleShellModeAtom, executeShellCommandAtom, keyboardHandlerAtom } from "../keyboard.js"
 import { inputModeAtom } from "../ui.js"
 import type { Key } from "../../../types/keyboard.js"
-import { shellHistoryAtom, shellHistoryIndexAtom } from "../shell.js"
+import {
+	shellHistoryAtom,
+	shellHistoryIndexAtom,
+	navigateShellHistoryUpAtom,
+	navigateShellHistoryDownAtom,
+	addToShellHistoryAtom,
+} from "../shell.js"
+import { textBufferStringAtom } from "../textBuffer.js"
 
 // Mock child_process to avoid actual command execution
 vi.mock("child_process", () => ({
-	exec: vi.fn((command, callback) => {
+	exec: vi.fn((command) => {
 		// Simulate successful command execution
 		const stdout = `Mock output for: ${command}`
 		const stderr = ""
@@ -32,14 +39,11 @@ vi.mock("child_process", () => ({
 				}
 			}),
 		}
-		if (callback) {
-			callback(process)
-		}
 		return process
 	}),
 }))
 
-describe("shell mode - essential tests", () => {
+describe("shell mode - comprehensive tests", () => {
 	let store: ReturnType<typeof createStore>
 
 	beforeEach(() => {
@@ -48,6 +52,7 @@ describe("shell mode - essential tests", () => {
 		store.set(shellHistoryAtom, [])
 		store.set(shellModeActiveAtom, false)
 		store.set(inputModeAtom, "normal" as const)
+		store.set(shellHistoryIndexAtom, -1)
 	})
 
 	describe("shell mode activation", () => {
@@ -67,6 +72,50 @@ describe("shell mode - essential tests", () => {
 			expect(store.get(inputModeAtom)).toBe("normal")
 		})
 
+		it("should reset history index when toggling on", () => {
+			// Set a non-default history index
+			store.set(shellHistoryIndexAtom, 5)
+
+			// Toggle on
+			store.set(toggleShellModeAtom)
+
+			// Index should be reset
+			expect(store.get(shellHistoryIndexAtom)).toBe(-1)
+		})
+
+		it("should reset history index when toggling off", () => {
+			// Activate shell mode and set history index
+			store.set(toggleShellModeAtom)
+			store.set(shellHistoryIndexAtom, 3)
+
+			// Toggle off
+			store.set(toggleShellModeAtom)
+
+			// Index should be reset
+			expect(store.get(shellHistoryIndexAtom)).toBe(-1)
+		})
+
+		it("should handle multiple rapid toggles", () => {
+			// Toggle multiple times
+			store.set(toggleShellModeAtom)
+			expect(store.get(shellModeActiveAtom)).toBe(true)
+
+			store.set(toggleShellModeAtom)
+			expect(store.get(shellModeActiveAtom)).toBe(false)
+
+			store.set(toggleShellModeAtom)
+			expect(store.get(shellModeActiveAtom)).toBe(true)
+
+			store.set(toggleShellModeAtom)
+			expect(store.get(shellModeActiveAtom)).toBe(false)
+
+			// Final state should be consistent
+			expect(store.get(inputModeAtom)).toBe("normal")
+			expect(store.get(shellHistoryIndexAtom)).toBe(-1)
+		})
+	})
+
+	describe("shell command execution", () => {
 		it("should add commands to history", async () => {
 			const command = "echo 'test'"
 			await store.set(executeShellCommandAtom, command)
@@ -84,6 +133,23 @@ describe("shell mode - essential tests", () => {
 			expect(history).toHaveLength(0)
 		})
 
+		it("should trim whitespace from commands before adding to history", async () => {
+			const command = "  echo 'test'  "
+			await store.set(executeShellCommandAtom, command)
+
+			const history = store.get(shellHistoryAtom)
+			expect(history[0]).toBe("echo 'test'")
+		})
+
+		it("should add multiple unique commands to history", async () => {
+			await store.set(executeShellCommandAtom, "ls")
+			await store.set(executeShellCommandAtom, "pwd")
+			await store.set(executeShellCommandAtom, "echo test")
+
+			const history = store.get(shellHistoryAtom)
+			expect(history).toEqual(["ls", "pwd", "echo test"])
+		})
+
 		it("should reset history navigation index after command execution", async () => {
 			// Add a few commands to history
 			await store.set(executeShellCommandAtom, "echo 'test1'")
@@ -99,6 +165,189 @@ describe("shell mode - essential tests", () => {
 			// History index should be reset to -1
 			expect(store.get(shellHistoryIndexAtom)).toBe(-1)
 		})
+
+		it("should allow duplicate commands in history", async () => {
+			await store.set(executeShellCommandAtom, "echo test")
+			await store.set(executeShellCommandAtom, "ls")
+			await store.set(executeShellCommandAtom, "echo test")
+
+			const history = store.get(shellHistoryAtom)
+			expect(history).toEqual(["echo test", "ls", "echo test"])
+		})
+	})
+
+	describe("shell history management", () => {
+		it("should limit history to 100 commands", async () => {
+			// Add 105 commands
+			for (let i = 0; i < 105; i++) {
+				await store.set(executeShellCommandAtom, `command${i}`)
+			}
+
+			const history = store.get(shellHistoryAtom)
+			expect(history).toHaveLength(100)
+			// Should keep the most recent 100
+			expect(history[0]).toBe("command5")
+			expect(history[99]).toBe("command104")
+		})
+
+		it("should add command to history with addToShellHistoryAtom", () => {
+			store.set(addToShellHistoryAtom, "test command")
+			const history = store.get(shellHistoryAtom)
+			expect(history).toContain("test command")
+		})
+
+		it("should maintain history order (newest last)", async () => {
+			await store.set(executeShellCommandAtom, "first")
+			await store.set(executeShellCommandAtom, "second")
+			await store.set(executeShellCommandAtom, "third")
+
+			const history = store.get(shellHistoryAtom)
+			expect(history).toEqual(["first", "second", "third"])
+		})
+	})
+
+	describe("history navigation - up", () => {
+		it("should navigate to most recent command on first up", () => {
+			// Add commands to history
+			store.set(shellHistoryAtom, ["cmd1", "cmd2", "cmd3"])
+
+			// Navigate up
+			store.set(navigateShellHistoryUpAtom)
+
+			expect(store.get(shellHistoryIndexAtom)).toBe(2)
+			expect(store.get(textBufferStringAtom)).toBe("cmd3")
+		})
+
+		it("should navigate to older commands with successive up presses", () => {
+			store.set(shellHistoryAtom, ["cmd1", "cmd2", "cmd3"])
+
+			// First up - most recent
+			store.set(navigateShellHistoryUpAtom)
+			expect(store.get(shellHistoryIndexAtom)).toBe(2)
+			expect(store.get(textBufferStringAtom)).toBe("cmd3")
+
+			// Second up - older
+			store.set(navigateShellHistoryUpAtom)
+			expect(store.get(shellHistoryIndexAtom)).toBe(1)
+			expect(store.get(textBufferStringAtom)).toBe("cmd2")
+
+			// Third up - oldest
+			store.set(navigateShellHistoryUpAtom)
+			expect(store.get(shellHistoryIndexAtom)).toBe(0)
+			expect(store.get(textBufferStringAtom)).toBe("cmd1")
+		})
+
+		it("should stop at oldest command", () => {
+			store.set(shellHistoryAtom, ["cmd1", "cmd2"])
+
+			// Navigate to oldest
+			store.set(navigateShellHistoryUpAtom)
+			store.set(navigateShellHistoryUpAtom)
+			expect(store.get(shellHistoryIndexAtom)).toBe(0)
+
+			// Try to go further up
+			store.set(navigateShellHistoryUpAtom)
+			expect(store.get(shellHistoryIndexAtom)).toBe(0)
+			expect(store.get(textBufferStringAtom)).toBe("cmd1")
+		})
+
+		it("should do nothing when history is empty", () => {
+			store.set(shellHistoryAtom, [])
+
+			store.set(navigateShellHistoryUpAtom)
+
+			expect(store.get(shellHistoryIndexAtom)).toBe(-1)
+			expect(store.get(textBufferStringAtom)).toBe("")
+		})
+
+		it("should handle single command history", () => {
+			store.set(shellHistoryAtom, ["only-cmd"])
+
+			store.set(navigateShellHistoryUpAtom)
+			expect(store.get(shellHistoryIndexAtom)).toBe(0)
+			expect(store.get(textBufferStringAtom)).toBe("only-cmd")
+
+			// Try to go up again
+			store.set(navigateShellHistoryUpAtom)
+			expect(store.get(shellHistoryIndexAtom)).toBe(0)
+		})
+	})
+
+	describe("history navigation - down", () => {
+		it("should do nothing when at default index", () => {
+			store.set(shellHistoryAtom, ["cmd1", "cmd2", "cmd3"])
+			expect(store.get(shellHistoryIndexAtom)).toBe(-1)
+
+			store.set(navigateShellHistoryDownAtom)
+
+			expect(store.get(shellHistoryIndexAtom)).toBe(-1)
+		})
+
+		it("should navigate to newer commands", () => {
+			store.set(shellHistoryAtom, ["cmd1", "cmd2", "cmd3", "cmd4"])
+
+			// Go to oldest
+			store.set(shellHistoryIndexAtom, 0)
+
+			// Navigate down to newer
+			store.set(navigateShellHistoryDownAtom)
+			expect(store.get(shellHistoryIndexAtom)).toBe(1)
+			expect(store.get(textBufferStringAtom)).toBe("cmd2")
+
+			store.set(navigateShellHistoryDownAtom)
+			expect(store.get(shellHistoryIndexAtom)).toBe(2)
+			expect(store.get(textBufferStringAtom)).toBe("cmd3")
+		})
+
+		it("should clear input when reaching most recent", () => {
+			store.set(shellHistoryAtom, ["cmd1", "cmd2"])
+
+			// Navigate up and then back down
+			store.set(navigateShellHistoryUpAtom) // index 1 (cmd2)
+			store.set(navigateShellHistoryUpAtom) // index 0 (cmd1)
+			store.set(navigateShellHistoryDownAtom) // index 1 (cmd2)
+			store.set(navigateShellHistoryDownAtom) // index -1 (clear)
+
+			expect(store.get(shellHistoryIndexAtom)).toBe(-1)
+			expect(store.get(textBufferStringAtom)).toBe("")
+		})
+
+		it("should handle navigation cycle: up then all the way down", () => {
+			store.set(shellHistoryAtom, ["cmd1", "cmd2", "cmd3"])
+
+			// Go up to recent
+			store.set(navigateShellHistoryUpAtom)
+			expect(store.get(textBufferStringAtom)).toBe("cmd3")
+
+			// Go all the way down to clear
+			store.set(navigateShellHistoryDownAtom)
+			expect(store.get(shellHistoryIndexAtom)).toBe(-1)
+			expect(store.get(textBufferStringAtom)).toBe("")
+		})
+	})
+
+	describe("history navigation - combined up/down", () => {
+		it("should handle mixed up/down navigation", () => {
+			store.set(shellHistoryAtom, ["cmd1", "cmd2", "cmd3", "cmd4"])
+
+			// Up twice
+			store.set(navigateShellHistoryUpAtom) // cmd4
+			store.set(navigateShellHistoryUpAtom) // cmd3
+			expect(store.get(textBufferStringAtom)).toBe("cmd3")
+
+			// Down once
+			store.set(navigateShellHistoryDownAtom) // cmd4
+			expect(store.get(textBufferStringAtom)).toBe("cmd4")
+
+			// Up once
+			store.set(navigateShellHistoryUpAtom) // cmd3
+			expect(store.get(textBufferStringAtom)).toBe("cmd3")
+
+			// Up to oldest
+			store.set(navigateShellHistoryUpAtom) // cmd2
+			store.set(navigateShellHistoryUpAtom) // cmd1
+			expect(store.get(textBufferStringAtom)).toBe("cmd1")
+		})
 	})
 
 	describe("Shift+1 key detection", () => {
@@ -119,5 +368,66 @@ describe("shell mode - essential tests", () => {
 			expect(store.get(shellModeActiveAtom)).toBe(true)
 			expect(store.get(inputModeAtom)).toBe("shell")
 		})
+
+		it("should toggle shell mode off with second Shift+1", async () => {
+			const shift1Key: Key = {
+				name: "shift-1",
+				sequence: "!",
+				ctrl: false,
+				meta: false,
+				shift: true,
+				paste: false,
+			}
+
+			// Activate
+			await store.set(keyboardHandlerAtom, shift1Key)
+			expect(store.get(shellModeActiveAtom)).toBe(true)
+
+			// Deactivate
+			await store.set(keyboardHandlerAtom, shift1Key)
+			expect(store.get(shellModeActiveAtom)).toBe(false)
+			expect(store.get(inputModeAtom)).toBe("normal")
+		})
+	})
+
+	describe("edge cases", () => {
+		it("should handle empty string command gracefully", async () => {
+			await store.set(executeShellCommandAtom, "")
+			const history = store.get(shellHistoryAtom)
+			expect(history).toHaveLength(0)
+		})
+
+		it("should handle only whitespace command", async () => {
+			await store.set(executeShellCommandAtom, "   \t\n  ")
+			const history = store.get(shellHistoryAtom)
+			expect(history).toHaveLength(0)
+		})
+
+		it("should preserve history when toggling shell mode", () => {
+			store.set(shellHistoryAtom, ["cmd1", "cmd2"])
+
+			// Toggle on and off
+			store.set(toggleShellModeAtom)
+			store.set(toggleShellModeAtom)
+
+			// History should be preserved
+			const history = store.get(shellHistoryAtom)
+			expect(history).toEqual(["cmd1", "cmd2"])
+		})
+
+		it("should handle history navigation after clearing history", () => {
+			store.set(shellHistoryAtom, ["cmd1", "cmd2"])
+			store.set(navigateShellHistoryUpAtom)
+			expect(store.get(textBufferStringAtom)).toBe("cmd2")
+			const indexBeforeClear = store.get(shellHistoryIndexAtom)
+
+			// Clear history
+			store.set(shellHistoryAtom, [])
+
+			// Try to navigate - should return early and not change index
+			store.set(navigateShellHistoryUpAtom)
+			// Index should remain unchanged when history is empty
+			expect(store.get(shellHistoryIndexAtom)).toBe(indexBeforeClear)
+		})
 	})
 })