feat: add auth command

packages/cli/src/commands/auth/interactiveSelector.test.ts

@@ -0,0 +1,421 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { InteractiveSelector } from './interactiveSelector.js';
+import { stdin, stdout } from 'node:process';
+
+describe('InteractiveSelector', () => {
+  const mockOptions = [
+    { value: 'option1', label: 'Option 1', description: 'First option' },
+    { value: 'option2', label: 'Option 2', description: 'Second option' },
+    { value: 'option3', label: 'Option 3', description: 'Third option' },
+  ];
+
+  const mockPrompt = 'Select an option:';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create an instance with default prompt', () => {
+      const selector = new InteractiveSelector(mockOptions);
+      expect(selector).toBeInstanceOf(InteractiveSelector);
+    });
+
+    it('should create an instance with custom prompt', () => {
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+      expect(selector).toBeInstanceOf(InteractiveSelector);
+    });
+  });
+
+  describe('select', () => {
+    it('should reject if raw mode is not available', async () => {
+      // Mock stdin without setRawMode
+      const originalSetRawMode = stdin.setRawMode;
+      (stdin as any).setRawMode = undefined;
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+
+      await expect(selector.select()).rejects.toThrow(
+        'Raw mode not available. Please run in an interactive terminal.',
+      );
+
+      // Restore
+      (stdin as any).setRawMode = originalSetRawMode;
+    });
+
+    it('should select first option with Enter key', async () => {
+      const mockSetRawMode = vi.fn();
+      const mockResume = vi.fn();
+      const mockSetEncoding = vi.fn();
+      const mockRemoveListener = vi.fn();
+      const mockOn = vi.fn((event: any, callback: any) => {
+        // Simulate Enter key press
+        setTimeout(() => callback('\r'), 0);
+        return stdin;
+      });
+
+      (stdin as any).isRaw = false;
+      (stdin as any).setRawMode = mockSetRawMode;
+      (stdin as any).resume = mockResume;
+      (stdin as any).setEncoding = mockSetEncoding;
+      (stdin as any).removeListener = mockRemoveListener;
+      (stdin as any).on = mockOn;
+
+      const stdoutWriteSpy = vi
+        .spyOn(stdout, 'write')
+        .mockImplementation(() => true);
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+      const result = await selector.select();
+
+      expect(result).toBe('option1');
+      expect(mockSetRawMode).toHaveBeenCalledWith(true);
+      expect(mockResume).toHaveBeenCalled();
+
+      stdoutWriteSpy.mockRestore();
+    });
+
+    it('should select second option after arrow down then Enter', async () => {
+      let dataCallback!: (chunk: string) => void;
+
+      const mockSetRawMode = vi.fn();
+      const mockResume = vi.fn();
+      const mockOn = vi.fn((event: any, callback: any) => {
+        dataCallback = callback;
+        return stdin;
+      });
+      const mockRemoveListener = vi.fn();
+
+      (stdin as any).isRaw = false;
+      (stdin as any).setRawMode = mockSetRawMode;
+      (stdin as any).resume = mockResume;
+      (stdin as any).on = mockOn;
+      (stdin as any).removeListener = mockRemoveListener;
+
+      const stdoutWriteSpy = vi
+        .spyOn(stdout, 'write')
+        .mockImplementation(() => true);
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+      const selectPromise = selector.select();
+
+      // Simulate arrow down
+      dataCallback('\x1B[B');
+
+      // Simulate Enter
+      setTimeout(() => dataCallback('\r'), 0);
+
+      const result = await selectPromise;
+
+      expect(result).toBe('option2');
+
+      stdoutWriteSpy.mockRestore();
+    });
+
+    it('should handle arrow up navigation', async () => {
+      let dataCallback!: (chunk: string) => void;
+
+      const mockSetRawMode = vi.fn();
+      const mockResume = vi.fn();
+      const mockOn = vi.fn((event: any, callback: any) => {
+        dataCallback = callback;
+        return stdin;
+      });
+      const mockRemoveListener = vi.fn();
+
+      (stdin as any).isRaw = false;
+      (stdin as any).setRawMode = mockSetRawMode;
+      (stdin as any).resume = mockResume;
+      (stdin as any).on = mockOn;
+      (stdin as any).removeListener = mockRemoveListener;
+
+      const stdoutWriteSpy = vi
+        .spyOn(stdout, 'write')
+        .mockImplementation(() => true);
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+      const selectPromise = selector.select();
+
+      // Move down twice
+      dataCallback('\x1B[B');
+      dataCallback('\x1B[B');
+
+      // Move up once
+      dataCallback('\x1B[A');
+
+      // Simulate Enter
+      setTimeout(() => dataCallback('\r'), 0);
+
+      const result = await selectPromise;
+
+      expect(result).toBe('option2');
+
+      stdoutWriteSpy.mockRestore();
+    });
+
+    it('should reject with Ctrl+C', async () => {
+      let dataCallback!: (chunk: string) => void;
+
+      const mockSetRawMode = vi.fn();
+      const mockResume = vi.fn();
+      const mockOn = vi.fn((event: any, callback: any) => {
+        dataCallback = callback;
+        return stdin;
+      });
+      const mockRemoveListener = vi.fn();
+
+      (stdin as any).isRaw = false;
+      (stdin as any).setRawMode = mockSetRawMode;
+      (stdin as any).resume = mockResume;
+      (stdin as any).on = mockOn;
+      (stdin as any).removeListener = mockRemoveListener;
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+      const selectPromise = selector.select();
+
+      // Simulate Ctrl+C
+      setTimeout(() => dataCallback('\x03'), 0);
+
+      await expect(selectPromise).rejects.toThrow('Interrupted');
+    });
+
+    it('should wrap around when navigating past last option', async () => {
+      let dataCallback!: (chunk: string) => void;
+
+      const mockSetRawMode = vi.fn();
+      const mockResume = vi.fn();
+      const mockOn = vi.fn((event: any, callback: any) => {
+        dataCallback = callback;
+        return stdin;
+      });
+      const mockRemoveListener = vi.fn();
+
+      (stdin as any).isRaw = false;
+      (stdin as any).setRawMode = mockSetRawMode;
+      (stdin as any).resume = mockResume;
+      (stdin as any).on = mockOn;
+      (stdin as any).removeListener = mockRemoveListener;
+
+      const stdoutWriteSpy = vi
+        .spyOn(stdout, 'write')
+        .mockImplementation(() => true);
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+      const selectPromise = selector.select();
+
+      // Move down past last option (should wrap to first)
+      dataCallback('\x1B[B');
+      dataCallback('\x1B[B');
+      dataCallback('\x1B[B'); // Now at option1 again (wrapped)
+
+      // Simulate Enter
+      setTimeout(() => dataCallback('\r'), 0);
+
+      const result = await selectPromise;
+
+      expect(result).toBe('option1');
+
+      stdoutWriteSpy.mockRestore();
+    });
+
+    it('should wrap around when navigating before first option', async () => {
+      let dataCallback!: (chunk: string) => void;
+
+      const mockSetRawMode = vi.fn();
+      const mockResume = vi.fn();
+      const mockOn = vi.fn((event: any, callback: any) => {
+        dataCallback = callback;
+        return stdin;
+      });
+      const mockRemoveListener = vi.fn();
+
+      (stdin as any).isRaw = false;
+      (stdin as any).setRawMode = mockSetRawMode;
+      (stdin as any).resume = mockResume;
+      (stdin as any).on = mockOn;
+      (stdin as any).removeListener = mockRemoveListener;
+
+      const stdoutWriteSpy = vi
+        .spyOn(stdout, 'write')
+        .mockImplementation(() => true);
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+      const selectPromise = selector.select();
+
+      // Move up from first option (should wrap to last)
+      dataCallback('\x1B[A');
+
+      // Simulate Enter
+      setTimeout(() => dataCallback('\r'), 0);
+
+      const result = await selectPromise;
+
+      expect(result).toBe('option3');
+
+      stdoutWriteSpy.mockRestore();
+    });
+
+    it('should ignore arrow left/right keys', async () => {
+      let dataCallback!: (chunk: string) => void;
+
+      const mockSetRawMode = vi.fn();
+      const mockResume = vi.fn();
+      const mockOn = vi.fn((event: any, callback: any) => {
+        dataCallback = callback;
+        return stdin;
+      });
+      const mockRemoveListener = vi.fn();
+
+      (stdin as any).isRaw = false;
+      (stdin as any).setRawMode = mockSetRawMode;
+      (stdin as any).resume = mockResume;
+      (stdin as any).on = mockOn;
+      (stdin as any).removeListener = mockRemoveListener;
+
+      const stdoutWriteSpy = vi
+        .spyOn(stdout, 'write')
+        .mockImplementation(() => true);
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+      const selectPromise = selector.select();
+
+      // Press arrow right (should be ignored)
+      dataCallback('\x1B[C');
+
+      // Press arrow left (should be ignored)
+      dataCallback('\x1B[D');
+
+      // Press Enter - should still select first option
+      setTimeout(() => dataCallback('\r'), 0);
+
+      const result = await selectPromise;
+
+      expect(result).toBe('option1');
+
+      stdoutWriteSpy.mockRestore();
+    });
+
+    it('should handle newline character as Enter', async () => {
+      let dataCallback!: (chunk: string) => void;
+
+      const mockSetRawMode = vi.fn();
+      const mockResume = vi.fn();
+      const mockOn = vi.fn((event: any, callback: any) => {
+        dataCallback = callback;
+        return stdin;
+      });
+      const mockRemoveListener = vi.fn();
+
+      (stdin as any).isRaw = false;
+      (stdin as any).setRawMode = mockSetRawMode;
+      (stdin as any).resume = mockResume;
+      (stdin as any).on = mockOn;
+      (stdin as any).removeListener = mockRemoveListener;
+
+      const stdoutWriteSpy = vi
+        .spyOn(stdout, 'write')
+        .mockImplementation(() => true);
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+      const selectPromise = selector.select();
+
+      // Simulate newline
+      setTimeout(() => dataCallback('\n'), 0);
+
+      const result = await selectPromise;
+
+      expect(result).toBe('option1');
+
+      stdoutWriteSpy.mockRestore();
+    });
+  });
+
+  describe('renderMenu', () => {
+    it('should render menu with correct formatting', () => {
+      const stdoutWriteSpy = vi
+        .spyOn(stdout, 'write')
+        .mockImplementation(() => true);
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+
+      // Access private method for testing
+      (selector as any).renderMenu();
+
+      expect(stdoutWriteSpy).toHaveBeenCalled();
+      const output = stdoutWriteSpy.mock.calls.map((call) => call[0]).join('');
+
+      expect(output).toContain('Select an option:');
+      expect(output).toContain('Option 1');
+      expect(output).toContain('Option 2');
+      expect(output).toContain('Option 3');
+      expect(output).toContain('First option');
+      expect(output).toContain('Second option');
+      expect(output).toContain('Third option');
+      expect(output).toContain('↑ ↓');
+      expect(output).toContain('Enter');
+      expect(output).toContain('Ctrl+C');
+
+      stdoutWriteSpy.mockRestore();
+    });
+
+    it('should highlight selected option', () => {
+      const stdoutWriteSpy = vi
+        .spyOn(stdout, 'write')
+        .mockImplementation(() => true);
+
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+      (selector as any).selectedIndex = 1;
+      (selector as any).renderMenu();
+
+      const output = stdoutWriteSpy.mock.calls.map((call) => call[0]).join('');
+
+      // Selected option should have cyan color code
+      expect(output).toContain('\x1B[36m');
+
+      stdoutWriteSpy.mockRestore();
+    });
+
+    it('should calculate correct total lines', () => {
+      const selector = new InteractiveSelector(mockOptions, mockPrompt);
+
+      // Access private method for testing
+      (selector as any).calculateTotalLines();
+
+      // Expected: 4 (prompt + empty + empty + instructions) + 3 (options) = 7
+      expect((selector as any).calculateTotalLines()).toBe(7);
+    });
+
+    it('should handle options without descriptions', () => {
+      const simpleOptions = [
+        { value: 'a', label: 'A' },
+        { value: 'b', label: 'B' },
+      ];
+
+      const stdoutWriteSpy = vi
+        .spyOn(stdout, 'write')
+        .mockImplementation(() => true);
+
+      const selector = new InteractiveSelector(simpleOptions, mockPrompt);
+      (selector as any).renderMenu();
+
+      const output = stdoutWriteSpy.mock.calls.map((call) => call[0]).join('');
+
+      expect(output).toContain('A');
+      expect(output).toContain('B');
+
+      stdoutWriteSpy.mockRestore();
+    });
+  });
+});