@pheem49/mint 1.4.0 → 1.4.1

package/tests/file_operations.test.js

@@ -0,0 +1,57 @@
+/**
+ * Tests: file_operations helpers
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('file_operations findPath', () => {
+    let tempDir;
+    let originalCwd;
+
+    beforeEach(() => {
+        jest.resetModules();
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-file-ops-'));
+        originalCwd = process.cwd();
+        process.chdir(tempDir);
+    });
+
+    afterEach(() => {
+        process.chdir(originalCwd);
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    test('finds directory matches by name', () => {
+        const targetDir = path.join(tempDir, 'nested', 'xidaidai');
+        fs.mkdirSync(targetDir, { recursive: true });
+
+        const { findPath } = require('../src/Automation_Layer/file_operations');
+        const result = findPath('xidaidai', { type: 'dir', maxResults: 10, roots: [tempDir] });
+
+        expect(result.success).toBe(true);
+        expect(result.matches.some(match => match.path === targetDir && match.type === 'dir')).toBe(true);
+    });
+
+    test('returns not found message when no path matches', () => {
+        const { findPath } = require('../src/Automation_Layer/file_operations');
+        const result = findPath('does-not-exist', { type: 'dir', maxResults: 10, roots: [tempDir] });
+
+        expect(result.success).toBe(false);
+        expect(result.message).toContain('ไม่พบ');
+    });
+
+    test('prefers exact directory name matches over nested partial matches', () => {
+        const exactDir = path.join(tempDir, 'xidaidai');
+        const nestedPartial = path.join(tempDir, 'xidaidai collection', 'xidaidai gif');
+        fs.mkdirSync(exactDir, { recursive: true });
+        fs.mkdirSync(nestedPartial, { recursive: true });
+
+        const { findPath } = require('../src/Automation_Layer/file_operations');
+        const result = findPath('xidaidai', { type: 'dir', maxResults: 10, roots: [tempDir] });
+
+        expect(result.success).toBe(true);
+        expect(result.matches.length).toBe(1);
+        expect(result.matches[0].path).toBe(exactDir);
+    });
+});

package/tests/provider_routing.test.js

@@ -0,0 +1,67 @@
+/**
+ * Tests: Gemini_API provider routing helpers
+ */
+
+jest.mock('@google/genai', () => ({
+    GoogleGenAI: jest.fn(() => ({
+        chats: {
+            create: jest.fn(() => ({
+                sendMessage: jest.fn(),
+                sendMessageStream: jest.fn(),
+                getHistory: jest.fn(async () => [])
+            }))
+        },
+        models: {
+            generateContent: jest.fn()
+        }
+    }))
+}));
+
+jest.mock('../src/System/chat_history_manager', () => ({
+    readChatHistory: jest.fn(() => []),
+    writeChatHistory: jest.fn(),
+    clearChatHistory: jest.fn()
+}));
+
+jest.mock('../src/System/config_manager', () => ({
+    readConfig: jest.fn(() => ({})),
+    getAvailableProviders: jest.fn(() => ['ollama', 'gemini'])
+}));
+
+jest.mock('../src/Plugins/plugin_manager', () => ({
+    loadPlugins: jest.fn(),
+    getPromptDescriptions: jest.fn(() => '')
+}));
+
+jest.mock('../src/Plugins/mcp_manager', () => ({
+    getAllTools: jest.fn(() => [])
+}));
+
+jest.mock('../src/AI_Brain/memory_store', () => ({
+    getUserContext: jest.fn(() => ''),
+    getCachedResponse: jest.fn(),
+    recordInteraction: jest.fn(),
+    cacheResponse: jest.fn()
+}));
+
+jest.mock('../src/AI_Brain/agent_orchestrator', () => ({
+    getCurrentAgent: jest.fn(() => ({ name: 'Mint Default', instruction: 'default' }))
+}));
+
+jest.mock('../src/CLI/workspace_manager', () => ({
+    getWorkspaceByPath: jest.fn(() => null)
+}));
+
+describe('Gemini_API provider routing helpers', () => {
+    test('prioritizes configured provider, then falls back to available providers', () => {
+        const geminiApi = require('../src/AI_Brain/Gemini_API');
+        const order = geminiApi._helpers.getProviderAttemptOrder({
+            aiProvider: 'openai',
+            openaiApiKey: 'key',
+            localApiBaseUrl: 'http://localhost:1234/v1'
+        });
+
+        expect(order[0]).toBe('openai');
+        expect(order).toContain('ollama');
+    });
+});

package/tests/workspace_manager.test.js

@@ -9,13 +9,17 @@ const os = require('os');
 
 describe('Workspace Manager', () => {
     let tempDir;
+    let workspaceFile;
 
     beforeEach(() => {
         // Create a temp workspace directory
         tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-ws-test-'));
+        workspaceFile = path.join(tempDir, 'workspaces.json');
+        process.env.MINT_WORKSPACE_FILE = workspaceFile;
     });
 
     afterEach(() => {
+        delete process.env.MINT_WORKSPACE_FILE;
         fs.rmSync(tempDir, { recursive: true, force: true });
     });
 
@@ -32,6 +36,17 @@ describe('Workspace Manager', () => {
         expect(ws.name).toBe('test-ws');
     });
 
+    test('does not match sibling paths with same prefix', () => {
+        const workspaceRoot = path.join(tempDir, 'project');
+        const siblingPath = path.join(tempDir, 'project-two');
+        fs.mkdirSync(workspaceRoot, { recursive: true });
+        fs.mkdirSync(siblingPath, { recursive: true });
+
+        wsManager.addWorkspace('test-ws', workspaceRoot);
+        const ws = wsManager.getWorkspaceByPath(siblingPath);
+        expect(ws).toBeNull();
+    });
+
     test('removes workspaces', () => {
         wsManager.addWorkspace('test-ws', tempDir);
         wsManager.removeWorkspace('test-ws');