test: improve coverage for channel.handler, interaction-manager

Author: Chuanyi Su

packages/cli/src/components/interaction-manager.test.ts

@@ -1061,4 +1061,181 @@ describe('InteractionManager', () => {
       }).not.toThrow();
     });
   });
+
+  describe('Shortcut Dispatch Coverage', () => {
+    let interactionManager: any;
+    let mockScreen: any;
+    let mockComponent: any;
+
+    beforeEach(() => {
+      mockScreen = {
+        key: jest.fn(),
+        on: jest.fn(),
+        program: { key: jest.fn(), on: jest.fn() },
+      };
+      mockComponent = {
+        getId: () => 'comp1',
+        getType: () => 'panel',
+        canFocus: () => true,
+        getFocusState: () => ({ focused: false, tabIndex: 0 }),
+        handleKey: () => false,
+        handleMouse: () => false,
+        focus: jest.fn(),
+        blur: jest.fn(),
+      };
+    });
+
+    it('should emit refresh-all action', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      // Access private method to test shortcut dispatch
+      interactionManager.registerShortcut({
+        key: 'r',
+        action: 'refresh-all',
+        description: 'Refresh all',
+      });
+      // Trigger key handler
+      interactionManager.handleKeyboardEvent({ key: 'r', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:refresh-all');
+    });
+
+    it('should emit refresh-current action', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({
+        key: 'R',
+        action: 'refresh-current',
+        description: 'Refresh current',
+      });
+      interactionManager.handleKeyboardEvent({ key: 'R', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:refresh-current');
+    });
+
+    it('should emit help action', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({ key: '?', action: 'help', description: 'Help' });
+      interactionManager.handleKeyboardEvent({ key: '?', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:help');
+    });
+
+    it('should emit exit action', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({ key: 'q', action: 'exit', description: 'Exit' });
+      interactionManager.handleKeyboardEvent({ key: 'q', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:exit');
+    });
+
+    it('should emit cancel action', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({ key: 'escape', action: 'cancel', description: 'Cancel' });
+      interactionManager.handleKeyboardEvent({ key: 'escape', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:cancel');
+    });
+
+    it('should emit fullscreen action', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({ key: 'f', action: 'fullscreen', description: 'Fullscreen' });
+      interactionManager.handleKeyboardEvent({ key: 'f', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:fullscreen');
+    });
+
+    it('should emit clear-screen action', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({ key: 'l', action: 'clear-screen', description: 'Clear' });
+      interactionManager.handleKeyboardEvent({ key: 'l', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:clear-screen');
+    });
+
+    it('should emit search action', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({ key: '/', action: 'search', description: 'Search' });
+      interactionManager.handleKeyboardEvent({ key: '/', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:search');
+    });
+
+    it('should emit layout action for layout: prefix', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({ key: '1', action: 'layout:1', description: 'Layout 1' });
+      interactionManager.handleKeyboardEvent({ key: '1', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:layout', { layout: '1' });
+    });
+
+    it('should emit panel action for panel: prefix', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({ key: 'p', action: 'panel:3', description: 'Panel 3' });
+      interactionManager.handleKeyboardEvent({ key: 'p', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:panel', { panel: '3' });
+    });
+
+    it('should emit custom action for unknown prefix', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      const emitSpy = jest.spyOn(interactionManager, 'emit');
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({ key: 'x', action: 'custom:action', description: 'Custom' });
+      interactionManager.handleKeyboardEvent({ key: 'x', shift: false, ctrl: false, alt: false, meta: false, full: '', ch: '' });
+      expect(emitSpy).toHaveBeenCalledWith('action:custom', expect.objectContaining({ action: 'custom:action' }));
+    });
+
+    it('should return all shortcuts via getAllShortcuts', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.registerShortcut({ key: 'q', action: 'exit', description: 'Exit' });
+      const shortcuts = interactionManager.getAllShortcuts();
+      expect(shortcuts.length).toBeGreaterThan(0);
+      expect(shortcuts.some(s => s.action === 'exit')).toBe(true);
+    });
+
+    it('should return current focus via getCurrentFocus', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      interactionManager.registerComponent(mockComponent);
+      interactionManager.setFocus('comp1');
+      expect(interactionManager.getCurrentFocus()).toBe('comp1');
+    });
+
+    it('should return components via getComponents', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      interactionManager.registerComponent(mockComponent);
+      expect(interactionManager.getComponents()).toHaveLength(1);
+    });
+
+    it('should return shortcuts via getShortcuts', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      interactionManager.registerShortcut({ key: 'q', action: 'exit', description: 'Exit' });
+      const shortcuts = interactionManager.getShortcuts();
+      expect(shortcuts.length).toBeGreaterThan(0);
+      expect(shortcuts.some(s => s.action === 'exit')).toBe(true);
+    });
+
+    it('should return component by id via getComponent', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      interactionManager.registerComponent(mockComponent);
+      expect(interactionManager.getComponent('comp1')).toBeDefined();
+      expect(interactionManager.getComponent('nonexistent')).toBeUndefined();
+    });
+
+    it('should return destroyed state via isInteractionManagerDestroyed', () => {
+      interactionManager = new InteractionManager(mockScreen, { keyboard: true, mouse: false, shortcuts: [] });
+      expect(interactionManager.isInteractionManagerDestroyed()).toBe(false);
+      interactionManager.destroy();
+      expect(interactionManager.isInteractionManagerDestroyed()).toBe(true);
+    });
+  });
 });

packages/cli/src/handlers/channel.handler.test.ts

@@ -1099,4 +1099,151 @@ describe('ChannelHandler', () => {
       });
     });
   });
+
+  // ============================================
+  // deleteChannel Tests
+  // ============================================
+
+  describe('deleteChannel', () => {
+    it('should delete single channel successfully', async () => {
+      const mockChannelService = {
+        deleteChannel: jest.fn().mockResolvedValue({}),
+      };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await handler.deleteChannel({ channelId: '123456', force: true });
+
+      expect(mockChannelService.deleteChannel).toHaveBeenCalled();
+    });
+
+    it('should throw PolyVValidationError for missing channelId', async () => {
+      const mockChannelService = { deleteChannel: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannel({ channelId: '' }))
+        .rejects.toThrow(PolyVValidationError);
+    });
+
+    it('should throw PolyVValidationError for non-string channelId', async () => {
+      const mockChannelService = { deleteChannel: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannel({ channelId: 123 as any }))
+        .rejects.toThrow(PolyVValidationError);
+    });
+
+    it('should throw PolyVValidationError for invalid force flag', async () => {
+      const mockChannelService = { deleteChannel: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannel({ channelId: '123', force: 'yes' as any }))
+        .rejects.toThrow(PolyVValidationError);
+    });
+
+    it('should throw PolyVValidationError for invalid output format', async () => {
+      const mockChannelService = { deleteChannel: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannel({ channelId: '123', output: 'xml' as any }))
+        .rejects.toThrow(PolyVValidationError);
+    });
+
+    it('should throw PolyVError when service fails', async () => {
+      const mockChannelService = {
+        deleteChannel: jest.fn().mockRejectedValue(new PolyVError('API error')),
+      };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannel({ channelId: '123', force: true }))
+        .rejects.toThrow(PolyVError);
+    });
+  });
+
+  // ============================================
+  // deleteChannels (batch) Tests
+  // ============================================
+
+  describe('deleteChannels', () => {
+    it('should delete multiple channels successfully', async () => {
+      const mockChannelService = {
+        batchDeleteChannels: jest.fn().mockResolvedValue({}),
+      };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await handler.deleteChannels({ channelIds: ['111', '222', '333'] });
+
+      expect(mockChannelService.batchDeleteChannels).toHaveBeenCalled();
+    });
+
+    it('should throw for missing channelIds', async () => {
+      const mockChannelService = { batchDeleteChannels: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannels({}))
+        .rejects.toThrow(PolyVValidationError);
+    });
+
+    it('should throw for non-array channelIds', async () => {
+      const mockChannelService = { batchDeleteChannels: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannels({ channelIds: '123' as any }))
+        .rejects.toThrow(PolyVValidationError);
+    });
+
+    it('should throw for empty channelIds array', async () => {
+      const mockChannelService = { batchDeleteChannels: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannels({ channelIds: [] }))
+        .rejects.toThrow(PolyVValidationError);
+    });
+
+    it('should throw for more than 100 channelIds', async () => {
+      const mockChannelService = { batchDeleteChannels: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      const ids = Array.from({ length: 101 }, (_, i) => `ch${i}`);
+      await expect(handler.deleteChannels({ channelIds: ids }))
+        .rejects.toThrow(PolyVValidationError);
+    });
+
+    it('should throw for non-string channelId in array', async () => {
+      const mockChannelService = { batchDeleteChannels: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannels({ channelIds: [123 as any] }))
+        .rejects.toThrow(PolyVValidationError);
+    });
+
+    it('should throw for empty string channelId in array', async () => {
+      const mockChannelService = { batchDeleteChannels: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannels({ channelIds: [''] }))
+        .rejects.toThrow(PolyVValidationError);
+    });
+
+    it('should throw for invalid output format in batch delete', async () => {
+      const mockChannelService = { batchDeleteChannels: jest.fn() };
+      MockedChannelService.mockImplementation(() => mockChannelService as any);
+      const handler = new ChannelHandler(mockAuthConfig, mockServiceConfig);
+
+      await expect(handler.deleteChannels({ channelIds: ['123'], output: 'xml' as any }))
+        .rejects.toThrow(PolyVValidationError);
+    });
+  });
 });