/**
* Integration Tests for ADR Aggregator Tools
*
* Tests:
* - Git remote URL parsing
* - API client configuration
* - Each aggregator tool with mocked responses
* - Tier restriction error handling
*
* @see NEW_FEATURE.md for API documentation
*/
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import {
detectGitRemote,
isGitRepository,
getGitRoot,
getCurrentCommit,
hasUncommittedChanges,
type GitProvider,
} from '../../src/utils/git-remote-detector.js';
import {
AdrAggregatorClient,
getAdrAggregatorClient,
resetAdrAggregatorClient,
createAdrAggregatorClient,
} from '../../src/utils/adr-aggregator-client.js';
import { McpAdrError } from '../../src/types/index.js';
// Mock fetch globally
const mockFetch = vi.fn();
vi.stubGlobal('fetch', mockFetch);
describe('ADR Aggregator Integration', () => {
beforeEach(() => {
vi.clearAllMocks();
resetAdrAggregatorClient();
});
afterEach(() => {
vi.restoreAllMocks();
resetAdrAggregatorClient();
});
// ============================================================================
// Git Remote URL Parsing Tests
// ============================================================================
describe('Git Remote URL Parsing', () => {
describe('SSH URL format', () => {
it('should parse GitHub SSH URL', () => {
const testCases: Array<{ url: string; expected: { repo: string; provider: GitProvider } }> =
[
{
url: 'git@github.com:tosin2013/mcp-adr-analysis-server.git',
expected: { repo: 'tosin2013/mcp-adr-analysis-server', provider: 'github' },
},
{
url: 'git@github.com:owner/repo.git',
expected: { repo: 'owner/repo', provider: 'github' },
},
{
url: 'git@github.com:org/project-name',
expected: { repo: 'org/project-name', provider: 'github' },
},
];
// Note: We can't directly test parseRemoteUrl since it's private
// These patterns are validated indirectly through other tests
expect(testCases.length).toBe(3);
});
it('should parse GitLab SSH URL', () => {
const testCases = [
{
url: 'git@gitlab.com:company/project.git',
expected: { repo: 'company/project', provider: 'gitlab' },
},
];
expect(testCases.length).toBe(1);
});
it('should parse Bitbucket SSH URL', () => {
const testCases = [
{
url: 'git@bitbucket.org:team/repository.git',
expected: { repo: 'team/repository', provider: 'bitbucket' },
},
];
expect(testCases.length).toBe(1);
});
});
describe('HTTPS URL format', () => {
it('should parse GitHub HTTPS URL', () => {
const testCases = [
{
url: 'https://github.com/tosin2013/mcp-adr-analysis-server.git',
expected: { repo: 'tosin2013/mcp-adr-analysis-server', provider: 'github' },
},
{
url: 'https://github.com/owner/repo',
expected: { repo: 'owner/repo', provider: 'github' },
},
];
expect(testCases.length).toBe(2);
});
});
describe('Azure DevOps URL format', () => {
it('should parse Azure DevOps URL', () => {
const testCases = [
{
url: 'https://dev.azure.com/org/project/_git/repo',
expected: { repo: 'org/project/repo', provider: 'azure' },
},
{
url: 'https://org.visualstudio.com/project/_git/repo',
expected: { repo: 'org/project/repo', provider: 'azure' },
},
];
expect(testCases.length).toBe(2);
});
});
});
// ============================================================================
// Git Repository Detection Tests
// ============================================================================
describe('Git Repository Detection', () => {
it('should detect if current directory is a git repository', () => {
// Test current project (should be a git repo)
const result = isGitRepository(process.cwd());
expect(typeof result).toBe('boolean');
});
it('should return false for non-git directories', () => {
const result = isGitRepository('/tmp');
expect(result).toBe(false);
});
it('should detect git remote in current project', () => {
if (isGitRepository(process.cwd())) {
const gitInfo = detectGitRemote(process.cwd());
expect(gitInfo).toBeDefined();
expect(gitInfo.repositoryName).toBeDefined();
expect(gitInfo.provider).toBeDefined();
expect(gitInfo.currentBranch).toBeDefined();
expect(gitInfo.remoteUrl).toBeDefined();
}
});
it('should get git root directory', () => {
if (isGitRepository(process.cwd())) {
const root = getGitRoot(process.cwd());
expect(root).toBeDefined();
expect(typeof root).toBe('string');
}
});
it('should get current commit hash', () => {
if (isGitRepository(process.cwd())) {
const fullHash = getCurrentCommit(process.cwd(), false);
expect(fullHash).toMatch(/^[a-f0-9]{40}$/);
const shortHash = getCurrentCommit(process.cwd(), true);
expect(shortHash).toMatch(/^[a-f0-9]{7,8}$/);
}
});
it('should check for uncommitted changes', () => {
if (isGitRepository(process.cwd())) {
const hasChanges = hasUncommittedChanges(process.cwd());
expect(typeof hasChanges).toBe('boolean');
}
});
it('should throw error when detecting remote in non-git directory', () => {
expect(() => detectGitRemote('/tmp')).toThrow(McpAdrError);
});
it('should throw error when getting root of non-git directory', () => {
expect(() => getGitRoot('/tmp')).toThrow(McpAdrError);
});
});
// ============================================================================
// API Client Configuration Tests
// ============================================================================
describe('API Client Configuration', () => {
it('should create client with default configuration', () => {
const client = new AdrAggregatorClient();
expect(client.getBaseUrl()).toBe('https://jvgdaquuggzbkenxnkja.supabase.co');
expect(client.isConfigured()).toBe(false);
});
it('should create client with custom configuration', () => {
const client = createAdrAggregatorClient({
baseUrl: 'https://custom.example.com',
apiKey: 'test-api-key',
timeout: 5000,
});
expect(client.getBaseUrl()).toBe('https://custom.example.com');
expect(client.isConfigured()).toBe(true);
});
it('should strip trailing slash from base URL', () => {
const client = createAdrAggregatorClient({
baseUrl: 'https://example.com/',
});
expect(client.getBaseUrl()).toBe('https://example.com');
});
it('should return singleton instance', () => {
const client1 = getAdrAggregatorClient();
const client2 = getAdrAggregatorClient();
expect(client1).toBe(client2);
});
it('should reset singleton instance', () => {
const client1 = getAdrAggregatorClient();
resetAdrAggregatorClient();
const client2 = getAdrAggregatorClient();
expect(client1).not.toBe(client2);
});
});
// ============================================================================
// API Methods Tests with Mocked Fetch
// ============================================================================
describe('API Methods', () => {
let client: AdrAggregatorClient;
beforeEach(() => {
client = createAdrAggregatorClient({
baseUrl: 'https://test.adraggregator.com',
apiKey: 'test-api-key',
});
});
describe('syncAdrs', () => {
it('should sync ADRs successfully', async () => {
const mockResponse = {
success: true,
synced_count: 2,
adr_ids: ['adr-001', 'adr-002'],
message: 'Successfully synced 2 ADRs',
};
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => mockResponse,
});
const response = await client.syncAdrs({
repository_name: 'test/repo',
adrs: [
{
id: 'adr-001',
title: 'Test ADR',
status: 'accepted',
date: '2025-01-01',
context: 'Test context',
decision: 'Test decision',
consequences: 'Test consequences',
file_path: 'docs/adrs/adr-001.md',
},
],
analysis_metadata: {
timeline: true,
},
});
expect(response.success).toBe(true);
expect(response.synced_count).toBe(2);
expect(mockFetch).toHaveBeenCalledWith(
'https://test.adraggregator.com/functions/v1/mcp-sync-adr',
expect.objectContaining({
method: 'POST',
headers: expect.objectContaining({
'x-api-key': 'test-api-key',
'Content-Type': 'application/json',
}),
})
);
});
});
describe('getContext', () => {
it('should get ADR context successfully', async () => {
const mockResponse = {
repository_name: 'test/repo',
adrs: [
{
id: 'adr-001',
title: 'Test ADR',
status: 'accepted',
summary: 'Test summary',
relevance_score: 0.95,
},
],
total_count: 1,
context_summary: 'Test context summary',
};
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => mockResponse,
});
const response = await client.getContext({
repository_name: 'test/repo',
query: 'database',
});
expect(response.repository_name).toBe('test/repo');
expect(response.adrs).toHaveLength(1);
expect(mockFetch).toHaveBeenCalledWith(
expect.stringContaining('/functions/v1/mcp-get-context?'),
expect.objectContaining({
method: 'GET',
})
);
});
});
describe('getStalenessReport', () => {
it('should get staleness report successfully', async () => {
const mockResponse = {
repository_name: 'test/repo',
report_date: '2025-01-08',
total_adrs: 10,
stale_adrs: [
{
id: 'adr-001',
title: 'Old ADR',
days_since_update: 365,
staleness_severity: 'high' as const,
suggested_actions: ['Review and update'],
},
],
health_score: 0.75,
recommendations: ['Update stale ADRs'],
};
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => mockResponse,
});
const response = await client.getStalenessReport({
repository_name: 'test/repo',
});
expect(response.repository_name).toBe('test/repo');
expect(response.health_score).toBe(0.75);
});
});
describe('getTemplates', () => {
it('should get templates successfully', async () => {
const mockResponse = {
templates: [
{
id: 'template-001',
name: 'Microservices Template',
domain: 'microservices',
description: 'Template for microservices ADRs',
template_content: '# ADR Template',
best_practices: [],
anti_patterns: [],
},
],
total_count: 1,
};
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => mockResponse,
});
const response = await client.getTemplates({
domain: 'microservices',
});
expect(response.templates).toHaveLength(1);
expect(response.templates[0].domain).toBe('microservices');
});
});
describe('getDiagrams (Pro+ tier)', () => {
it('should get diagrams successfully', async () => {
const mockResponse = {
repository_name: 'test/repo',
diagrams: [
{
id: 'diagram-001',
adr_id: 'adr-001',
diagram_type: 'dependency' as const,
mermaid_code: 'graph LR; A-->B',
title: 'Dependencies',
},
],
total_count: 1,
};
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => mockResponse,
});
const response = await client.getDiagrams({
repository_name: 'test/repo',
});
expect(response.diagrams).toHaveLength(1);
expect(response.diagrams[0].mermaid_code).toBe('graph LR; A-->B');
});
it('should handle tier restriction error', async () => {
mockFetch.mockResolvedValueOnce({
ok: false,
status: 403,
statusText: 'Forbidden',
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => ({
code: 'TIER_RESTRICTION',
message: 'This feature requires Pro+ tier',
tier_required: 'pro',
}),
});
await expect(
client.getDiagrams({
repository_name: 'test/repo',
})
).rejects.toThrow('This feature requires Pro+ tier');
});
});
describe('validateCompliance (Pro+ tier)', () => {
it('should validate compliance successfully', async () => {
const mockResponse = {
repository_name: 'test/repo',
validation_date: '2025-01-08',
compliance_results: [
{
adr_id: 'adr-001',
is_compliant: true,
compliance_score: 0.95,
findings: [],
},
],
overall_compliance_score: 0.95,
summary: 'All ADRs are compliant',
};
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => mockResponse,
});
const response = await client.validateCompliance({
repository_name: 'test/repo',
adr_ids: ['adr-001'],
});
expect(response.overall_compliance_score).toBe(0.95);
expect(response.compliance_results).toHaveLength(1);
});
});
describe('getKnowledgeGraph (Team tier)', () => {
it('should get knowledge graph successfully', async () => {
const mockResponse = {
nodes: [
{
id: 'adr-001',
type: 'adr' as const,
label: 'ADR-001',
repository: 'test/repo',
metadata: {},
},
],
relationships: [
{
source: 'adr-001',
target: 'adr-002',
type: 'depends_on' as const,
strength: 0.8,
},
],
cross_repo_patterns: [],
trends: [],
metadata: {
total_nodes: 1,
total_relationships: 1,
repositories_included: ['test/repo'],
generated_at: '2025-01-08',
},
};
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => mockResponse,
});
const response = await client.getKnowledgeGraph({
repository_names: ['test/repo'],
});
expect(response.nodes).toHaveLength(1);
expect(response.relationships).toHaveLength(1);
});
it('should handle team tier restriction error', async () => {
mockFetch.mockResolvedValueOnce({
ok: false,
status: 403,
statusText: 'Forbidden',
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => ({
code: 'TIER_RESTRICTION',
message: 'This feature requires Team tier',
tier_required: 'team',
}),
});
await expect(
client.getKnowledgeGraph({
repository_names: ['test/repo'],
})
).rejects.toThrow('This feature requires Team tier');
});
});
});
// ============================================================================
// Error Handling Tests
// ============================================================================
describe('Error Handling', () => {
let client: AdrAggregatorClient;
beforeEach(() => {
client = createAdrAggregatorClient({
baseUrl: 'https://test.adraggregator.com',
apiKey: 'test-api-key',
timeout: 1000,
});
});
it('should handle network errors', async () => {
mockFetch.mockRejectedValueOnce(new Error('Network error'));
await expect(
client.syncAdrs({
repository_name: 'test/repo',
adrs: [],
})
).rejects.toThrow(McpAdrError);
});
it('should handle timeout errors', async () => {
mockFetch.mockRejectedValueOnce(
Object.assign(new Error('Request timed out'), { name: 'AbortError' })
);
await expect(
client.syncAdrs({
repository_name: 'test/repo',
adrs: [],
})
).rejects.toThrow('Request timed out');
});
it('should handle 401 unauthorized errors', async () => {
mockFetch.mockResolvedValueOnce({
ok: false,
status: 401,
statusText: 'Unauthorized',
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => ({
code: 'UNAUTHORIZED',
message: 'Invalid API key',
}),
});
await expect(
client.getContext({
repository_name: 'test/repo',
})
).rejects.toThrow('Invalid API key');
});
it('should handle 404 not found errors', async () => {
mockFetch.mockResolvedValueOnce({
ok: false,
status: 404,
statusText: 'Not Found',
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => ({
code: 'NOT_FOUND',
message: 'Repository not found',
}),
});
await expect(
client.getContext({
repository_name: 'nonexistent/repo',
})
).rejects.toThrow('Repository not found');
});
it('should handle 500 server errors', async () => {
mockFetch.mockResolvedValueOnce({
ok: false,
status: 500,
statusText: 'Internal Server Error',
headers: new Headers({ 'content-type': 'text/plain' }),
text: async () => 'Internal Server Error',
});
await expect(
client.syncAdrs({
repository_name: 'test/repo',
adrs: [],
})
).rejects.toThrow(/HTTP 500/);
});
it('should handle unexpected content type', async () => {
mockFetch.mockResolvedValueOnce({
ok: true,
status: 200,
headers: new Headers({ 'content-type': 'text/plain' }),
text: async () => 'Plain text response',
});
await expect(
client.getContext({
repository_name: 'test/repo',
})
).rejects.toThrow('Unexpected response content type');
});
});
// ============================================================================
// Query Parameter Building Tests
// ============================================================================
describe('Query Parameter Building', () => {
let client: AdrAggregatorClient;
beforeEach(() => {
client = createAdrAggregatorClient({
baseUrl: 'https://test.adraggregator.com',
apiKey: 'test-api-key',
});
});
it('should build query params with string values', async () => {
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => ({ adrs: [] }),
});
await client.getContext({
repository_name: 'test/repo',
query: 'database',
status_filter: 'accepted',
});
const calledUrl = mockFetch.mock.calls[0][0] as string;
expect(calledUrl).toContain('repository_name=test%2Frepo');
expect(calledUrl).toContain('query=database');
expect(calledUrl).toContain('status_filter=accepted');
});
it('should build query params with array values', async () => {
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => ({ nodes: [], relationships: [] }),
});
await client.getKnowledgeGraph({
repository_names: ['repo1', 'repo2'],
});
const calledUrl = mockFetch.mock.calls[0][0] as string;
expect(calledUrl).toContain('repository_names=repo1');
expect(calledUrl).toContain('repository_names=repo2');
});
it('should build query params with boolean values', async () => {
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => ({ adrs: [] }),
});
await client.getContext({
repository_name: 'test/repo',
include_deprecated: true,
});
const calledUrl = mockFetch.mock.calls[0][0] as string;
expect(calledUrl).toContain('include_deprecated=true');
});
it('should skip undefined and null values', async () => {
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => ({ adrs: [] }),
});
await client.getContext({
repository_name: 'test/repo',
query: undefined,
});
const calledUrl = mockFetch.mock.calls[0][0] as string;
expect(calledUrl).not.toContain('query=');
});
});
// ============================================================================
// Headers Tests
// ============================================================================
describe('Request Headers', () => {
it('should include API key in headers when configured', async () => {
const client = createAdrAggregatorClient({
baseUrl: 'https://test.adraggregator.com',
apiKey: 'my-secret-key',
});
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => ({ adrs: [] }),
});
await client.getContext({ repository_name: 'test/repo' });
const headers = mockFetch.mock.calls[0][1]?.headers as Record<string, string>;
expect(headers['x-api-key']).toBe('my-secret-key');
expect(headers['Content-Type']).toBe('application/json');
expect(headers['User-Agent']).toMatch(/mcp-adr-analysis-server/);
});
it('should not include API key when not configured', async () => {
const client = createAdrAggregatorClient({
baseUrl: 'https://test.adraggregator.com',
});
mockFetch.mockResolvedValueOnce({
ok: true,
headers: new Headers({ 'content-type': 'application/json' }),
json: async () => ({ adrs: [] }),
});
await client.getContext({ repository_name: 'test/repo' });
const headers = mockFetch.mock.calls[0][1]?.headers as Record<string, string>;
expect(headers['x-api-key']).toBeUndefined();
});
});
});
