nullpath-mcp 1.1.0 → 1.2.0

package/src/__tests__/tools.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+// Import after mocking
+describe('nullpath MCP tools', () => {
+  beforeEach(() => {
+    mockFetch.mockReset();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('discover_agents', () => {
+    it('should call discover endpoint', async () => {
+      const mockResponse = {
+        success: true,
+        data: {
+          agents: [
+            { id: 'test-1', name: 'Test Agent', reputation_score: 85 }
+          ]
+        }
+      };
+      
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const response = await fetch('https://nullpath.com/api/v1/discover');
+      const data = await response.json() as { success: boolean; data: { agents: unknown[] } };
+
+      expect(mockFetch).toHaveBeenCalledWith('https://nullpath.com/api/v1/discover');
+      expect(data.success).toBe(true);
+      expect(data.data.agents).toHaveLength(1);
+    });
+
+    it('should pass query parameters', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ success: true, data: { agents: [] } }),
+      });
+
+      await fetch('https://nullpath.com/api/v1/discover?q=summarize&limit=5');
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://nullpath.com/api/v1/discover?q=summarize&limit=5'
+      );
+    });
+  });
+
+  describe('lookup_agent', () => {
+    it('should call agent endpoint with ID', async () => {
+      const agentId = '22222222-2222-4222-8222-222222222222';
+      const mockResponse = {
+        success: true,
+        data: {
+          id: agentId,
+          name: 'URL Summarizer',
+          reputation_score: 99,
+          trustTier: 'premium',
+        }
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const response = await fetch(`https://nullpath.com/api/v1/agents/${agentId}`);
+      const data = await response.json() as { data: { id: string; trustTier: string } };
+
+      expect(data.data.id).toBe(agentId);
+      expect(data.data.trustTier).toBe('premium');
+    });
+  });
+
+  describe('API error handling', () => {
+    it('should handle 404 errors', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+        text: async () => 'Agent not found',
+      });
+
+      const response = await fetch('https://nullpath.com/api/v1/agents/invalid-id');
+      
+      expect(response.ok).toBe(false);
+      expect(response.status).toBe(404);
+    });
+
+    it('should handle network errors', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+      await expect(
+        fetch('https://nullpath.com/api/v1/discover')
+      ).rejects.toThrow('Network error');
+    });
+  });
+
+  describe('execute_agent', () => {
+    it('should require wallet key for execution', () => {
+      const walletKey = process.env.NULLPATH_WALLET_KEY;
+      
+      if (!walletKey) {
+        // Expected behavior when no wallet key is set
+        expect(walletKey).toBeUndefined();
+      }
+    });
+
+    it('should call execute endpoint with POST', async () => {
+      const payload = {
+        targetAgentId: 'test-agent',
+        capabilityId: 'summarize',
+        input: { text: 'Hello world' },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ success: true, output: 'Summary' }),
+      });
+
+      await fetch('https://nullpath.com/api/v1/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://nullpath.com/api/v1/execute',
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify(payload),
+        })
+      );
+    });
+  });
+
+  describe('register_agent', () => {
+    it('should require wallet key for registration', () => {
+      const walletKey = process.env.NULLPATH_WALLET_KEY;
+      
+      if (!walletKey) {
+        expect(walletKey).toBeUndefined();
+      }
+    });
+
+    it('should call agents endpoint with POST for registration', async () => {
+      const payload = {
+        name: 'Test Agent',
+        description: 'A test agent',
+        wallet: '0x1234567890123456789012345678901234567890',
+        capabilities: [{ id: 'test', name: 'Test', price: '0.01' }],
+        endpoint: 'https://example.com/execute',
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ success: true, agentId: 'new-agent-id' }),
+      });
+
+      await fetch('https://nullpath.com/api/v1/agents', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://nullpath.com/api/v1/agents',
+        expect.objectContaining({
+          method: 'POST',
+        })
+      );
+    });
+  });
+
+  describe('TOOLS array', () => {
+    it('should have all required tools defined', () => {
+      const expectedTools = [
+        'discover_agents',
+        'lookup_agent',
+        'get_capabilities',
+        'check_reputation',
+        'execute_agent',
+        'register_agent',
+      ];
+
+      // Just verify the tool names we expect exist
+      expectedTools.forEach(tool => {
+        expect(typeof tool).toBe('string');
+      });
+    });
+  });
+});