vibecodingmachine-core 1.0.1 → 2025.11.2-7.1239

package/src/ide-integration/__tests__/applescript-manager-thread-closure.test.js

@@ -1,227 +1,227 @@
-/**
- * Jest tests for AppleScript Manager thread closure functionality
- * Tests the ability to close previous chat threads when starting new ones
- */
-
-import { AppleScriptManager } from '../applescript-manager.js';
-import { execSync } from 'child_process';
-
-// Mock child_process
-jest.mock('child_process', () => ({
-  execSync: jest.fn()
-}));Windsurf: Open Chat
-
-
-
-
-
-// Mock fs
-jest.mock('fs', () => ({
-  writeFileSync: jest.fn(),
-  unlinkSync: jest.fn()
-}));
-
-// Mock os
-jest.mock('os', () => ({
-  tmpdir: () => '/tmp'
-}));
-
-describe('AppleScriptManager - Thread Closure', () => {
-  let appleScriptManager;
-  let mockExecSync;
-
-  beforeEach(() => {
-    appleScriptManager = new AppleScriptManager();
-    mockExecSync = execSync;
-    mockExecSync.mockClear();
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('closePreviousChatThread', () => {
-    it('should close previous chat thread in Cursor', async () => {
-      // Mock successful execution
-      mockExecSync.mockReturnValue('Previous chat thread closed');
-
-      const result = await appleScriptManager.closePreviousChatThread('cursor');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Previous chat thread closed');
-      expect(result.method).toBe('applescript');
-      expect(mockExecSync).toHaveBeenCalled();
-    });
-
-    it('should close previous chat thread in VS Code', async () => {
-      // Mock successful execution
-      mockExecSync.mockReturnValue('Previous chat thread closed');
-
-      const result = await appleScriptManager.closePreviousChatThread('vscode');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Previous chat thread closed');
-      expect(result.method).toBe('applescript');
-      expect(mockExecSync).toHaveBeenCalled();
-    });
-
-    it('should close previous chat thread in Windsurf', async () => {
-      // Mock successful execution
-      mockExecSync.mockReturnValue('Previous chat thread closed');
-
-      const result = await appleScriptManager.closePreviousChatThread('windsurf');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Previous chat thread closed');
-      expect(result.method).toBe('applescript');
-      expect(mockExecSync).toHaveBeenCalled();
-    });
-
-    it('should handle errors gracefully when closing threads', async () => {
-      // Mock execution error
-      mockExecSync.mockImplementation(() => {
-        throw new Error('Failed to close thread');
-      });
-
-      const result = await appleScriptManager.closePreviousChatThread('cursor');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Failed to close thread');
-      expect(result.method).toBe('applescript');
-    });
-
-    it('should return error for unsupported IDE', async () => {
-      const result = await appleScriptManager.closePreviousChatThread('unsupported');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Unsupported IDE');
-      expect(mockExecSync).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('sendTextWithThreadClosure', () => {
-    it('should close previous thread before sending new message to Cursor', async () => {
-      // Mock successful executions
-      mockExecSync
-        .mockReturnValueOnce('Previous chat thread closed')
-        .mockReturnValueOnce('Message sent to Cursor: Test message')
-        .mockReturnValueOnce('Message sent to Cursor: Test message');
-
-      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Test message');
-      expect(mockExecSync).toHaveBeenCalledTimes(3); // Once for close, twice for send (sendText calls execSync twice)
-    });
-
-    it('should close previous thread before sending new message to VS Code', async () => {
-      // Mock successful executions
-      mockExecSync
-        .mockReturnValueOnce('Previous chat thread closed')
-        .mockImplementationOnce(() => {
-          // Simulate successful AppleScript execution for text sending
-          return 'Message sent via AppleScript to VS Code GitHub Copilot Chat';
-        });
-
-      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'vscode');
-
-      expect(result.success).toBe(true); // VS Code is now supported by AppleScript manager
-      expect(result.method).toBe('applescript');
-      expect(result.threadClosure).toContain('Previous thread closed');
-      expect(mockExecSync).toHaveBeenCalledTimes(2); // Once for thread closure, once for sending
-    });
-
-    it('should close previous thread before sending new message to Windsurf', async () => {
-      // Mock successful executions
-      mockExecSync
-        .mockReturnValueOnce('Previous chat thread closed')
-        .mockImplementationOnce(() => {
-          throw new Error('AppleScript failed');
-        });
-
-      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'windsurf');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Test message');
-      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once for thread closure
-    });
-
-    it('should handle thread closure failure gracefully', async () => {
-      // Mock thread closure failure but successful message send
-      mockExecSync
-        .mockImplementationOnce(() => {
-          throw new Error('Failed to close thread');
-        })
-        .mockImplementationOnce(() => {
-          throw new Error('AppleScript failed');
-        });
-
-      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Test message');
-      expect(result.warning).toContain('Failed to close previous thread');
-      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once
-    });
-
-    it('should handle both thread closure and message send failures', async () => {
-      // Mock both failures
-      mockExecSync
-        .mockImplementationOnce(() => {
-          throw new Error('Failed to close thread');
-        })
-        .mockImplementationOnce(() => {
-          throw new Error('AppleScript failed');
-        });
-
-      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
-
-      expect(result.success).toBe(true); // Should still succeed due to simulated fallback
-      expect(result.message).toContain('Test message');
-      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once
-    });
-
-    it('should validate input parameters', async () => {
-      const result = await appleScriptManager.sendTextWithThreadClosure('', 'cursor');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Invalid text');
-      expect(mockExecSync).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('AppleScript Content Validation', () => {
-    it('should generate correct AppleScript for Cursor thread closure', async () => {
-      mockExecSync.mockReturnValue('Success');
-
-      await appleScriptManager.closePreviousChatThread('cursor');
-
-      const callArgs = mockExecSync.mock.calls[0][0];
-      expect(callArgs).toContain('osascript');
-      // The script content is written to a temp file, so we check the osascript call
-      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
-    });
-
-    it('should generate correct AppleScript for VS Code thread closure', async () => {
-      mockExecSync.mockReturnValue('Success');
-
-      await appleScriptManager.closePreviousChatThread('vscode');
-
-      const callArgs = mockExecSync.mock.calls[0][0];
-      expect(callArgs).toContain('osascript');
-      // The script content is written to a temp file, so we check the osascript call
-      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
-    });
-
-    it('should generate correct AppleScript for Windsurf thread closure', async () => {
-      mockExecSync.mockReturnValue('Success');
-
-      await appleScriptManager.closePreviousChatThread('windsurf');
-
-      const callArgs = mockExecSync.mock.calls[0][0];
-      expect(callArgs).toContain('osascript');
-      // The script content is written to a temp file, so we check the osascript call
-      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
-    });
-  });
-});
+/**
+ * Jest tests for AppleScript Manager thread closure functionality
+ * Tests the ability to close previous chat threads when starting new ones
+ */
+
+import { AppleScriptManager } from '../applescript-manager.js';
+import { execSync } from 'child_process';
+
+// Mock child_process
+jest.mock('child_process', () => ({
+  execSync: jest.fn()
+}));Windsurf: Open Chat
+
+
+
+
+
+// Mock fs
+jest.mock('fs', () => ({
+  writeFileSync: jest.fn(),
+  unlinkSync: jest.fn()
+}));
+
+// Mock os
+jest.mock('os', () => ({
+  tmpdir: () => '/tmp'
+}));
+
+describe('AppleScriptManager - Thread Closure', () => {
+  let appleScriptManager;
+  let mockExecSync;
+
+  beforeEach(() => {
+    appleScriptManager = new AppleScriptManager();
+    mockExecSync = execSync;
+    mockExecSync.mockClear();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('closePreviousChatThread', () => {
+    it('should close previous chat thread in Cursor', async () => {
+      // Mock successful execution
+      mockExecSync.mockReturnValue('Previous chat thread closed');
+
+      const result = await appleScriptManager.closePreviousChatThread('cursor');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Previous chat thread closed');
+      expect(result.method).toBe('applescript');
+      expect(mockExecSync).toHaveBeenCalled();
+    });
+
+    it('should close previous chat thread in VS Code', async () => {
+      // Mock successful execution
+      mockExecSync.mockReturnValue('Previous chat thread closed');
+
+      const result = await appleScriptManager.closePreviousChatThread('vscode');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Previous chat thread closed');
+      expect(result.method).toBe('applescript');
+      expect(mockExecSync).toHaveBeenCalled();
+    });
+
+    it('should close previous chat thread in Windsurf', async () => {
+      // Mock successful execution
+      mockExecSync.mockReturnValue('Previous chat thread closed');
+
+      const result = await appleScriptManager.closePreviousChatThread('windsurf');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Previous chat thread closed');
+      expect(result.method).toBe('applescript');
+      expect(mockExecSync).toHaveBeenCalled();
+    });
+
+    it('should handle errors gracefully when closing threads', async () => {
+      // Mock execution error
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Failed to close thread');
+      });
+
+      const result = await appleScriptManager.closePreviousChatThread('cursor');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Failed to close thread');
+      expect(result.method).toBe('applescript');
+    });
+
+    it('should return error for unsupported IDE', async () => {
+      const result = await appleScriptManager.closePreviousChatThread('unsupported');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Unsupported IDE');
+      expect(mockExecSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('sendTextWithThreadClosure', () => {
+    it('should close previous thread before sending new message to Cursor', async () => {
+      // Mock successful executions
+      mockExecSync
+        .mockReturnValueOnce('Previous chat thread closed')
+        .mockReturnValueOnce('Message sent to Cursor: Test message')
+        .mockReturnValueOnce('Message sent to Cursor: Test message');
+
+      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Test message');
+      expect(mockExecSync).toHaveBeenCalledTimes(3); // Once for close, twice for send (sendText calls execSync twice)
+    });
+
+    it('should close previous thread before sending new message to VS Code', async () => {
+      // Mock successful executions
+      mockExecSync
+        .mockReturnValueOnce('Previous chat thread closed')
+        .mockImplementationOnce(() => {
+          // Simulate successful AppleScript execution for text sending
+          return 'Message sent via AppleScript to VS Code GitHub Copilot Chat';
+        });
+
+      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'vscode');
+
+      expect(result.success).toBe(true); // VS Code is now supported by AppleScript manager
+      expect(result.method).toBe('applescript');
+      expect(result.threadClosure).toContain('Previous thread closed');
+      expect(mockExecSync).toHaveBeenCalledTimes(2); // Once for thread closure, once for sending
+    });
+
+    it('should close previous thread before sending new message to Windsurf', async () => {
+      // Mock successful executions
+      mockExecSync
+        .mockReturnValueOnce('Previous chat thread closed')
+        .mockImplementationOnce(() => {
+          throw new Error('AppleScript failed');
+        });
+
+      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'windsurf');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Test message');
+      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once for thread closure
+    });
+
+    it('should handle thread closure failure gracefully', async () => {
+      // Mock thread closure failure but successful message send
+      mockExecSync
+        .mockImplementationOnce(() => {
+          throw new Error('Failed to close thread');
+        })
+        .mockImplementationOnce(() => {
+          throw new Error('AppleScript failed');
+        });
+
+      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Test message');
+      expect(result.warning).toContain('Failed to close previous thread');
+      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once
+    });
+
+    it('should handle both thread closure and message send failures', async () => {
+      // Mock both failures
+      mockExecSync
+        .mockImplementationOnce(() => {
+          throw new Error('Failed to close thread');
+        })
+        .mockImplementationOnce(() => {
+          throw new Error('AppleScript failed');
+        });
+
+      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
+
+      expect(result.success).toBe(true); // Should still succeed due to simulated fallback
+      expect(result.message).toContain('Test message');
+      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once
+    });
+
+    it('should validate input parameters', async () => {
+      const result = await appleScriptManager.sendTextWithThreadClosure('', 'cursor');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid text');
+      expect(mockExecSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('AppleScript Content Validation', () => {
+    it('should generate correct AppleScript for Cursor thread closure', async () => {
+      mockExecSync.mockReturnValue('Success');
+
+      await appleScriptManager.closePreviousChatThread('cursor');
+
+      const callArgs = mockExecSync.mock.calls[0][0];
+      expect(callArgs).toContain('osascript');
+      // The script content is written to a temp file, so we check the osascript call
+      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
+    });
+
+    it('should generate correct AppleScript for VS Code thread closure', async () => {
+      mockExecSync.mockReturnValue('Success');
+
+      await appleScriptManager.closePreviousChatThread('vscode');
+
+      const callArgs = mockExecSync.mock.calls[0][0];
+      expect(callArgs).toContain('osascript');
+      // The script content is written to a temp file, so we check the osascript call
+      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
+    });
+
+    it('should generate correct AppleScript for Windsurf thread closure', async () => {
+      mockExecSync.mockReturnValue('Success');
+
+      await appleScriptManager.closePreviousChatThread('windsurf');
+
+      const callArgs = mockExecSync.mock.calls[0][0];
+      expect(callArgs).toContain('osascript');
+      // The script content is written to a temp file, so we check the osascript call
+      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
+    });
+  });
+});