/**
* Unit Tests for Contact Tools
* Tests all 7 contact management MCP tools
*/
import { describe, it, expect, beforeEach, jest } from '@jest/globals';
import { ContactTools } from '../../src/tools/contact-tools.js';
import { MockGHLApiClient, mockContact } from '../mocks/ghl-api-client.mock.js';
describe('ContactTools', () => {
let contactTools: ContactTools;
let mockGhlClient: MockGHLApiClient;
beforeEach(() => {
mockGhlClient = new MockGHLApiClient();
contactTools = new ContactTools(mockGhlClient as any);
});
describe('getToolDefinitions', () => {
it('should return 7 contact tool definitions', () => {
const tools = contactTools.getToolDefinitions();
expect(tools).toHaveLength(7);
const toolNames = tools.map(tool => tool.name);
expect(toolNames).toEqual([
'create_contact',
'search_contacts',
'get_contact',
'update_contact',
'add_contact_tags',
'remove_contact_tags',
'delete_contact'
]);
});
it('should have proper schema definitions for all tools', () => {
const tools = contactTools.getToolDefinitions();
tools.forEach(tool => {
expect(tool.name).toBeDefined();
expect(tool.description).toBeDefined();
expect(tool.inputSchema).toBeDefined();
expect(tool.inputSchema.type).toBe('object');
expect(tool.inputSchema.properties).toBeDefined();
});
});
});
describe('executeTool', () => {
it('should route tool calls correctly', async () => {
const createSpy = jest.spyOn(contactTools as any, 'createContact');
const getSpy = jest.spyOn(contactTools as any, 'getContact');
await contactTools.executeTool('create_contact', { email: 'test@example.com' });
await contactTools.executeTool('get_contact', { contactId: 'contact_123' });
expect(createSpy).toHaveBeenCalledWith({ email: 'test@example.com' });
expect(getSpy).toHaveBeenCalledWith('contact_123');
});
it('should throw error for unknown tool', async () => {
await expect(
contactTools.executeTool('unknown_tool', {})
).rejects.toThrow('Unknown tool: unknown_tool');
});
});
describe('create_contact', () => {
it('should create contact successfully', async () => {
const contactData = {
firstName: 'Jane',
lastName: 'Doe',
email: 'jane.doe@example.com',
phone: '+1-555-987-6543'
};
const result = await contactTools.executeTool('create_contact', contactData);
expect(result.success).toBe(true);
expect(result.contact).toBeDefined();
expect(result.contact.email).toBe(contactData.email);
expect(result.message).toContain('Contact created successfully');
});
it('should handle API errors', async () => {
const mockError = new Error('GHL API Error (400): Invalid email');
jest.spyOn(mockGhlClient, 'createContact').mockRejectedValueOnce(mockError);
await expect(
contactTools.executeTool('create_contact', { email: 'invalid-email' })
).rejects.toThrow('Failed to create contact');
});
it('should set default source if not provided', async () => {
const spy = jest.spyOn(mockGhlClient, 'createContact');
await contactTools.executeTool('create_contact', {
firstName: 'John',
email: 'john@example.com'
});
expect(spy).toHaveBeenCalledWith(
expect.objectContaining({
source: 'ChatGPT MCP'
})
);
});
});
describe('search_contacts', () => {
it('should search contacts successfully', async () => {
const searchParams = {
query: 'John Doe',
limit: 10
};
const result = await contactTools.executeTool('search_contacts', searchParams);
expect(result.success).toBe(true);
expect(result.contacts).toBeDefined();
expect(Array.isArray(result.contacts)).toBe(true);
expect(result.total).toBeDefined();
expect(result.message).toContain('Found');
});
it('should use default limit if not provided', async () => {
const spy = jest.spyOn(mockGhlClient, 'searchContacts');
await contactTools.executeTool('search_contacts', { query: 'test' });
expect(spy).toHaveBeenCalledWith(
expect.objectContaining({
limit: 25
})
);
});
it('should handle search with email filter', async () => {
const result = await contactTools.executeTool('search_contacts', {
email: 'john@example.com'
});
expect(result.success).toBe(true);
expect(result.contacts).toBeDefined();
});
});
describe('get_contact', () => {
it('should get contact by ID successfully', async () => {
const result = await contactTools.executeTool('get_contact', {
contactId: 'contact_123'
});
expect(result.success).toBe(true);
expect(result.contact).toBeDefined();
expect(result.contact.id).toBe('contact_123');
expect(result.message).toBe('Contact retrieved successfully');
});
it('should handle contact not found', async () => {
await expect(
contactTools.executeTool('get_contact', { contactId: 'not_found' })
).rejects.toThrow('Failed to get contact');
});
});
describe('update_contact', () => {
it('should update contact successfully', async () => {
const updateData = {
contactId: 'contact_123',
firstName: 'Updated',
lastName: 'Name'
};
const result = await contactTools.executeTool('update_contact', updateData);
expect(result.success).toBe(true);
expect(result.contact).toBeDefined();
expect(result.contact.firstName).toBe('Updated');
expect(result.message).toBe('Contact updated successfully');
});
it('should handle partial updates', async () => {
const spy = jest.spyOn(mockGhlClient, 'updateContact');
await contactTools.executeTool('update_contact', {
contactId: 'contact_123',
email: 'newemail@example.com'
});
expect(spy).toHaveBeenCalledWith('contact_123', {
email: 'newemail@example.com'
});
});
});
describe('add_contact_tags', () => {
it('should add tags successfully', async () => {
const result = await contactTools.executeTool('add_contact_tags', {
contactId: 'contact_123',
tags: ['vip', 'premium']
});
expect(result.success).toBe(true);
expect(result.tags).toBeDefined();
expect(Array.isArray(result.tags)).toBe(true);
expect(result.message).toContain('Successfully added 2 tags');
});
it('should validate required parameters', async () => {
await expect(
contactTools.executeTool('add_contact_tags', { contactId: 'contact_123' })
).rejects.toThrow();
});
});
describe('remove_contact_tags', () => {
it('should remove tags successfully', async () => {
const result = await contactTools.executeTool('remove_contact_tags', {
contactId: 'contact_123',
tags: ['old-tag']
});
expect(result.success).toBe(true);
expect(result.tags).toBeDefined();
expect(result.message).toContain('Successfully removed 1 tags');
});
it('should handle empty tags array', async () => {
const spy = jest.spyOn(mockGhlClient, 'removeContactTags');
await contactTools.executeTool('remove_contact_tags', {
contactId: 'contact_123',
tags: []
});
expect(spy).toHaveBeenCalledWith('contact_123', []);
});
});
describe('delete_contact', () => {
it('should delete contact successfully', async () => {
const result = await contactTools.executeTool('delete_contact', {
contactId: 'contact_123'
});
expect(result.success).toBe(true);
expect(result.message).toBe('Contact deleted successfully');
});
it('should handle deletion errors', async () => {
const mockError = new Error('GHL API Error (404): Contact not found');
jest.spyOn(mockGhlClient, 'deleteContact').mockRejectedValueOnce(mockError);
await expect(
contactTools.executeTool('delete_contact', { contactId: 'not_found' })
).rejects.toThrow('Failed to delete contact');
});
});
describe('error handling', () => {
it('should propagate API client errors', async () => {
const mockError = new Error('Network error');
jest.spyOn(mockGhlClient, 'createContact').mockRejectedValueOnce(mockError);
await expect(
contactTools.executeTool('create_contact', { email: 'test@example.com' })
).rejects.toThrow('Failed to create contact: Error: Network error');
});
it('should handle missing required fields', async () => {
// Test with missing email (required field)
await expect(
contactTools.executeTool('create_contact', { firstName: 'John' })
).rejects.toThrow();
});
});
describe('input validation', () => {
it('should validate email format in schema', () => {
const tools = contactTools.getToolDefinitions();
const createContactTool = tools.find(tool => tool.name === 'create_contact');
expect(createContactTool?.inputSchema.properties.email.format).toBe('email');
});
it('should validate required fields in schema', () => {
const tools = contactTools.getToolDefinitions();
const createContactTool = tools.find(tool => tool.name === 'create_contact');
expect(createContactTool?.inputSchema.required).toEqual(['email']);
});
});
});