import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import { approveMCPRequestTool } from '../../src/tools/approve-mcp-request.js';
import { ApprovalService } from '../../src/services/approval.js';
// Mock dependencies
jest.mock('../../src/utils/logger');
jest.mock('../../src/services/approval.js');
describe('approveMCPRequestTool', () => {
let mockApprovalService: jest.Mocked<ApprovalService>;
const mockRequest = {
id: 'test-request-123',
duckName: 'TestDuck',
mcpServer: 'filesystem',
toolName: 'read_file',
arguments: { path: '/tmp/test.txt' },
status: 'pending' as const,
timestamp: Date.now(),
expiresAt: Date.now() + 60000,
};
beforeEach(() => {
mockApprovalService = {
getApprovalRequest: jest.fn(),
approveRequest: jest.fn(),
denyRequest: jest.fn(),
getPendingApprovals: jest.fn(),
} as unknown as jest.Mocked<ApprovalService>;
});
describe('validation', () => {
it('should return error when approval_id is missing', () => {
const result = approveMCPRequestTool(mockApprovalService, {
decision: 'approve',
});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('Missing required parameters');
});
it('should return error when decision is missing', () => {
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-123',
});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('Missing required parameters');
});
it('should return error when decision is invalid', () => {
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-123',
decision: 'maybe',
});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('must be either "approve" or "deny"');
});
});
describe('request lookup', () => {
it('should return error when request not found', () => {
mockApprovalService.getApprovalRequest.mockReturnValue(undefined);
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'nonexistent',
decision: 'approve',
});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('not found');
});
it('should return error when request is not pending', () => {
mockApprovalService.getApprovalRequest.mockReturnValue({
...mockRequest,
status: 'approved',
});
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-123',
decision: 'approve',
});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('not pending');
expect(result.content[0].text).toContain('approved');
});
});
describe('approve decision', () => {
beforeEach(() => {
mockApprovalService.getApprovalRequest.mockReturnValue(mockRequest);
});
it('should approve request successfully', () => {
mockApprovalService.approveRequest.mockReturnValue(true);
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-request-123',
decision: 'approve',
});
expect(mockApprovalService.approveRequest).toHaveBeenCalledWith('test-request-123');
expect(result.isError).toBe(false);
expect(result.content[0].text).toContain('Approved');
expect(result.content[0].text).toContain('TestDuck');
expect(result.content[0].text).toContain('filesystem:read_file');
});
it('should handle approval failure', () => {
mockApprovalService.approveRequest.mockReturnValue(false);
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-request-123',
decision: 'approve',
});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('Failed to approve');
});
it('should include request details in response', () => {
mockApprovalService.approveRequest.mockReturnValue(true);
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-request-123',
decision: 'approve',
});
expect(result.content[0].text).toContain('Request Details');
expect(result.content[0].text).toContain('TestDuck');
expect(result.content[0].text).toContain('filesystem');
expect(result.content[0].text).toContain('read_file');
expect(result.content[0].text).toContain('/tmp/test.txt');
});
it('should include next steps hint for approval', () => {
mockApprovalService.approveRequest.mockReturnValue(true);
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-request-123',
decision: 'approve',
});
expect(result.content[0].text).toContain('duck can now retry');
});
});
describe('deny decision', () => {
beforeEach(() => {
mockApprovalService.getApprovalRequest.mockReturnValue(mockRequest);
});
it('should deny request successfully', () => {
mockApprovalService.denyRequest.mockReturnValue(true);
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-request-123',
decision: 'deny',
});
expect(mockApprovalService.denyRequest).toHaveBeenCalledWith('test-request-123', undefined);
expect(result.isError).toBe(false);
expect(result.content[0].text).toContain('Denied');
});
it('should include reason when provided', () => {
mockApprovalService.denyRequest.mockReturnValue(true);
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-request-123',
decision: 'deny',
reason: 'Security concern',
});
expect(mockApprovalService.denyRequest).toHaveBeenCalledWith(
'test-request-123',
'Security concern'
);
expect(result.content[0].text).toContain('Reason: Security concern');
});
it('should handle deny failure', () => {
mockApprovalService.denyRequest.mockReturnValue(false);
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-request-123',
decision: 'deny',
});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('Failed to deny');
});
it('should not include next steps hint for denial', () => {
mockApprovalService.denyRequest.mockReturnValue(true);
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-request-123',
decision: 'deny',
});
expect(result.content[0].text).not.toContain('retry');
});
});
describe('error handling', () => {
it('should handle exceptions gracefully', () => {
mockApprovalService.getApprovalRequest.mockImplementation(() => {
throw new Error('Database connection failed');
});
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-123',
decision: 'approve',
});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('Error processing approval');
expect(result.content[0].text).toContain('Database connection failed');
});
it('should handle non-Error exceptions', () => {
mockApprovalService.getApprovalRequest.mockImplementation(() => {
throw 'String error';
});
const result = approveMCPRequestTool(mockApprovalService, {
approval_id: 'test-123',
decision: 'approve',
});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain('String error');
});
});
});
