import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import {
DocumentationBatchProcessor,
BatchProcessorOptions,
BatchProcessorResult,
} from '@/community/documentation-batch-processor';
import type { NodeRepository } from '@/database/node-repository';
import type { CommunityNodeFetcher } from '@/community/community-node-fetcher';
import type { DocumentationGenerator, DocumentationResult } from '@/community/documentation-generator';
// Mock logger to suppress output during tests
vi.mock('@/utils/logger', () => ({
logger: {
info: vi.fn(),
warn: vi.fn(),
error: vi.fn(),
debug: vi.fn(),
},
}));
/**
* Factory for creating mock community nodes
*/
function createMockCommunityNode(overrides: Partial<{
nodeType: string;
displayName: string;
description: string;
npmPackageName: string;
npmReadme: string | null;
aiDocumentationSummary: object | null;
npmDownloads: number;
}> = {}) {
return {
nodeType: overrides.nodeType || 'n8n-nodes-test.testNode',
displayName: overrides.displayName || 'Test Node',
description: overrides.description || 'A test community node',
npmPackageName: overrides.npmPackageName || 'n8n-nodes-test',
npmReadme: overrides.npmReadme === undefined ? null : overrides.npmReadme,
aiDocumentationSummary: overrides.aiDocumentationSummary || null,
npmDownloads: overrides.npmDownloads || 1000,
};
}
/**
* Factory for creating mock documentation summaries
*/
function createMockDocumentationSummary(nodeType: string) {
return {
purpose: `Node ${nodeType} does something useful`,
capabilities: ['capability1', 'capability2'],
authentication: 'API key required',
commonUseCases: ['use case 1'],
limitations: [],
relatedNodes: [],
};
}
/**
* Create mock NodeRepository
*/
function createMockRepository(): NodeRepository {
return {
getCommunityNodes: vi.fn().mockReturnValue([]),
getCommunityNodesWithoutReadme: vi.fn().mockReturnValue([]),
getCommunityNodesWithoutAISummary: vi.fn().mockReturnValue([]),
updateNodeReadme: vi.fn(),
updateNodeAISummary: vi.fn(),
getDocumentationStats: vi.fn().mockReturnValue({
total: 10,
withReadme: 5,
withAISummary: 3,
needingReadme: 5,
needingAISummary: 2,
}),
} as unknown as NodeRepository;
}
/**
* Create mock CommunityNodeFetcher
*/
function createMockFetcher(): CommunityNodeFetcher {
return {
fetchReadmesBatch: vi.fn().mockResolvedValue(new Map()),
} as unknown as CommunityNodeFetcher;
}
/**
* Create mock DocumentationGenerator
*/
function createMockGenerator(): DocumentationGenerator {
return {
testConnection: vi.fn().mockResolvedValue({ success: true, message: 'Connected' }),
generateBatch: vi.fn().mockResolvedValue([]),
generateSummary: vi.fn(),
} as unknown as DocumentationGenerator;
}
describe('DocumentationBatchProcessor', () => {
let processor: DocumentationBatchProcessor;
let mockRepository: ReturnType<typeof createMockRepository>;
let mockFetcher: ReturnType<typeof createMockFetcher>;
let mockGenerator: ReturnType<typeof createMockGenerator>;
beforeEach(() => {
vi.clearAllMocks();
mockRepository = createMockRepository();
mockFetcher = createMockFetcher();
mockGenerator = createMockGenerator();
processor = new DocumentationBatchProcessor(mockRepository, mockFetcher, mockGenerator);
});
afterEach(() => {
vi.restoreAllMocks();
});
describe('constructor', () => {
it('should create instance with all dependencies', () => {
expect(processor).toBeDefined();
});
it('should use provided repository', () => {
const customRepo = createMockRepository();
const proc = new DocumentationBatchProcessor(customRepo);
expect(proc).toBeDefined();
});
});
describe('processAll - default options', () => {
it('should process both READMEs and summaries with default options', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
createMockCommunityNode({ nodeType: 'node2', npmPackageName: 'pkg2' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(
new Map([
['pkg1', '# README for pkg1'],
['pkg2', '# README for pkg2'],
])
);
const nodesWithReadme = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1', npmReadme: '# README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodesWithReadme);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([
{
nodeType: 'node1',
summary: createMockDocumentationSummary('node1'),
},
]);
const result = await processor.processAll();
expect(result).toBeDefined();
expect(result.errors).toEqual([]);
expect(result.durationSeconds).toBeGreaterThanOrEqual(0);
});
it('should return result with duration even when no nodes to process', async () => {
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue([]);
const result = await processor.processAll();
expect(result.readmesFetched).toBe(0);
expect(result.readmesFailed).toBe(0);
expect(result.summariesGenerated).toBe(0);
expect(result.summariesFailed).toBe(0);
expect(result.durationSeconds).toBeGreaterThanOrEqual(0);
});
it('should accumulate skipped counts from both phases', async () => {
const result = await processor.processAll({
skipExistingReadme: true,
skipExistingSummary: true,
});
expect(result).toBeDefined();
expect(typeof result.skipped).toBe('number');
});
});
describe('processAll - readmeOnly option', () => {
it('should skip AI generation when readmeOnly is true', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(
new Map([['pkg1', '# README content']])
);
const result = await processor.processAll({ readmeOnly: true });
expect(mockGenerator.testConnection).not.toHaveBeenCalled();
expect(mockGenerator.generateBatch).not.toHaveBeenCalled();
expect(result.summariesGenerated).toBe(0);
expect(result.summariesFailed).toBe(0);
});
it('should still fetch READMEs when readmeOnly is true', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(
new Map([['pkg1', '# README content']])
);
await processor.processAll({ readmeOnly: true });
expect(mockFetcher.fetchReadmesBatch).toHaveBeenCalledTimes(1);
expect(mockRepository.updateNodeReadme).toHaveBeenCalledWith('node1', '# README content');
});
});
describe('processAll - summaryOnly option', () => {
it('should skip README fetching when summaryOnly is true', async () => {
const nodesWithReadme = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# Existing README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodesWithReadme);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([
{
nodeType: 'node1',
summary: createMockDocumentationSummary('node1'),
},
]);
const result = await processor.processAll({ summaryOnly: true });
expect(mockFetcher.fetchReadmesBatch).not.toHaveBeenCalled();
expect(result.readmesFetched).toBe(0);
expect(result.readmesFailed).toBe(0);
});
it('should still generate summaries when summaryOnly is true', async () => {
const nodesWithReadme = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodesWithReadme);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([
{
nodeType: 'node1',
summary: createMockDocumentationSummary('node1'),
},
]);
await processor.processAll({ summaryOnly: true });
expect(mockGenerator.testConnection).toHaveBeenCalled();
expect(mockGenerator.generateBatch).toHaveBeenCalled();
});
});
describe('processAll - skipExistingReadme option', () => {
it('should use getCommunityNodesWithoutReadme when skipExistingReadme is true', async () => {
const nodesWithoutReadme = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1', npmReadme: null }),
];
vi.mocked(mockRepository.getCommunityNodesWithoutReadme).mockReturnValue(nodesWithoutReadme);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(
new Map([['pkg1', '# New README']])
);
await processor.processAll({ skipExistingReadme: true, readmeOnly: true });
expect(mockRepository.getCommunityNodesWithoutReadme).toHaveBeenCalled();
expect(mockRepository.getCommunityNodes).not.toHaveBeenCalled();
});
it('should use getCommunityNodes when skipExistingReadme is false', async () => {
const allNodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1', npmReadme: '# Old' }),
createMockCommunityNode({ nodeType: 'node2', npmPackageName: 'pkg2', npmReadme: null }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(allNodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(new Map());
await processor.processAll({ skipExistingReadme: false, readmeOnly: true });
expect(mockRepository.getCommunityNodes).toHaveBeenCalledWith({ orderBy: 'downloads' });
expect(mockRepository.getCommunityNodesWithoutReadme).not.toHaveBeenCalled();
});
});
describe('processAll - skipExistingSummary option', () => {
it('should use getCommunityNodesWithoutAISummary when skipExistingSummary is true', async () => {
const nodesWithoutSummary = [
createMockCommunityNode({
nodeType: 'node1',
npmReadme: '# README',
aiDocumentationSummary: null,
}),
];
vi.mocked(mockRepository.getCommunityNodesWithoutAISummary).mockReturnValue(nodesWithoutSummary);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([
{ nodeType: 'node1', summary: createMockDocumentationSummary('node1') },
]);
await processor.processAll({ skipExistingSummary: true, summaryOnly: true });
expect(mockRepository.getCommunityNodesWithoutAISummary).toHaveBeenCalled();
});
it('should filter nodes by existing README when skipExistingSummary is false', async () => {
const allNodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README1' }),
createMockCommunityNode({ nodeType: 'node2', npmReadme: '' }), // Empty README
createMockCommunityNode({ nodeType: 'node3', npmReadme: null }), // No README
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(allNodes);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([
{ nodeType: 'node1', summary: createMockDocumentationSummary('node1') },
]);
await processor.processAll({ skipExistingSummary: false, summaryOnly: true });
// Should filter to only nodes with non-empty README
expect(mockGenerator.generateBatch).toHaveBeenCalled();
const callArgs = vi.mocked(mockGenerator.generateBatch).mock.calls[0];
expect(callArgs[0]).toHaveLength(1);
expect(callArgs[0][0].nodeType).toBe('node1');
});
});
describe('processAll - limit option', () => {
it('should limit number of nodes processed for READMEs', async () => {
const manyNodes = Array.from({ length: 10 }, (_, i) =>
createMockCommunityNode({
nodeType: `node${i}`,
npmPackageName: `pkg${i}`,
})
);
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(manyNodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(new Map());
await processor.processAll({ limit: 3, readmeOnly: true });
expect(mockFetcher.fetchReadmesBatch).toHaveBeenCalled();
const packageNames = vi.mocked(mockFetcher.fetchReadmesBatch).mock.calls[0][0];
expect(packageNames).toHaveLength(3);
});
it('should limit number of nodes processed for summaries', async () => {
const manyNodes = Array.from({ length: 10 }, (_, i) =>
createMockCommunityNode({
nodeType: `node${i}`,
npmReadme: `# README ${i}`,
})
);
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(manyNodes);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([]);
await processor.processAll({ limit: 5, summaryOnly: true });
expect(mockGenerator.generateBatch).toHaveBeenCalled();
const inputs = vi.mocked(mockGenerator.generateBatch).mock.calls[0][0];
expect(inputs).toHaveLength(5);
});
});
describe('fetchReadmes - progress tracking', () => {
it('should call progress callback during README fetching', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
createMockCommunityNode({ nodeType: 'node2', npmPackageName: 'pkg2' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockImplementation(
async (packageNames, progressCallback) => {
if (progressCallback) {
progressCallback('Fetching READMEs', 1, 2);
progressCallback('Fetching READMEs', 2, 2);
}
return new Map([
['pkg1', '# README 1'],
['pkg2', '# README 2'],
]);
}
);
const progressCallback = vi.fn();
await processor.processAll({ readmeOnly: true, progressCallback });
expect(mockFetcher.fetchReadmesBatch).toHaveBeenCalledWith(
expect.any(Array),
progressCallback,
expect.any(Number)
);
});
it('should pass concurrency option to fetchReadmesBatch', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(new Map());
await processor.processAll({ readmeOnly: true, readmeConcurrency: 10 });
expect(mockFetcher.fetchReadmesBatch).toHaveBeenCalledWith(
['pkg1'],
undefined,
10
);
});
it('should use default concurrency of 5 for README fetching', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(new Map());
await processor.processAll({ readmeOnly: true });
expect(mockFetcher.fetchReadmesBatch).toHaveBeenCalledWith(
['pkg1'],
undefined,
5
);
});
});
describe('generateSummaries - LLM connection test failure', () => {
it('should fail all summaries when LLM connection fails', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README 1' }),
createMockCommunityNode({ nodeType: 'node2', npmReadme: '# README 2' }),
createMockCommunityNode({ nodeType: 'node3', npmReadme: '# README 3' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockGenerator.testConnection).mockResolvedValue({
success: false,
message: 'Connection refused: ECONNREFUSED',
});
const result = await processor.processAll({ summaryOnly: true });
expect(result.summariesGenerated).toBe(0);
expect(result.summariesFailed).toBe(3);
expect(result.errors).toHaveLength(1);
expect(result.errors[0]).toContain('LLM connection failed');
expect(result.errors[0]).toContain('Connection refused');
});
it('should not call generateBatch when connection test fails', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockGenerator.testConnection).mockResolvedValue({
success: false,
message: 'Model not found',
});
await processor.processAll({ summaryOnly: true });
expect(mockGenerator.generateBatch).not.toHaveBeenCalled();
});
it('should proceed with generation when connection test succeeds', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockGenerator.testConnection).mockResolvedValue({
success: true,
message: 'Connected to qwen3-4b',
});
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([
{ nodeType: 'node1', summary: createMockDocumentationSummary('node1') },
]);
const result = await processor.processAll({ summaryOnly: true });
expect(mockGenerator.generateBatch).toHaveBeenCalled();
expect(result.summariesGenerated).toBe(1);
});
});
describe('getStats', () => {
it('should return documentation statistics from repository', () => {
const expectedStats = {
total: 25,
withReadme: 20,
withAISummary: 15,
needingReadme: 5,
needingAISummary: 5,
};
vi.mocked(mockRepository.getDocumentationStats).mockReturnValue(expectedStats);
const stats = processor.getStats();
expect(stats).toEqual(expectedStats);
expect(mockRepository.getDocumentationStats).toHaveBeenCalled();
});
it('should handle empty statistics', () => {
const emptyStats = {
total: 0,
withReadme: 0,
withAISummary: 0,
needingReadme: 0,
needingAISummary: 0,
};
vi.mocked(mockRepository.getDocumentationStats).mockReturnValue(emptyStats);
const stats = processor.getStats();
expect(stats.total).toBe(0);
expect(stats.withReadme).toBe(0);
});
});
describe('error handling', () => {
it('should collect errors when README update fails', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(
new Map([['pkg1', '# README']])
);
vi.mocked(mockRepository.updateNodeReadme).mockImplementation(() => {
throw new Error('Database write error');
});
const result = await processor.processAll({ readmeOnly: true });
expect(result.readmesFetched).toBe(0);
expect(result.readmesFailed).toBe(1);
expect(result.errors).toHaveLength(1);
expect(result.errors[0]).toContain('Failed to save README');
expect(result.errors[0]).toContain('Database write error');
});
it('should collect errors when summary generation fails', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([
{
nodeType: 'node1',
summary: createMockDocumentationSummary('node1'),
error: 'LLM timeout',
},
]);
const result = await processor.processAll({ summaryOnly: true });
expect(result.summariesGenerated).toBe(0);
expect(result.summariesFailed).toBe(1);
expect(result.errors).toContain('node1: LLM timeout');
});
it('should collect errors when summary storage fails', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([
{ nodeType: 'node1', summary: createMockDocumentationSummary('node1') },
]);
vi.mocked(mockRepository.updateNodeAISummary).mockImplementation(() => {
throw new Error('Database constraint violation');
});
const result = await processor.processAll({ summaryOnly: true });
expect(result.summariesGenerated).toBe(0);
expect(result.summariesFailed).toBe(1);
expect(result.errors).toHaveLength(1);
expect(result.errors[0]).toContain('Failed to save summary');
});
it('should handle batch processing exception gracefully', async () => {
vi.mocked(mockRepository.getCommunityNodes).mockImplementation(() => {
throw new Error('Database connection lost');
});
const result = await processor.processAll();
expect(result.errors).toHaveLength(1);
expect(result.errors[0]).toContain('Batch processing failed');
expect(result.errors[0]).toContain('Database connection lost');
expect(result.durationSeconds).toBeGreaterThanOrEqual(0);
});
it('should accumulate errors from both README and summary phases', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(new Map());
// First call for README phase returns nodes, subsequent calls for summary phase
vi.mocked(mockRepository.getCommunityNodes)
.mockReturnValueOnce(nodes) // README phase
.mockReturnValue([]); // Summary phase (no nodes with README)
const result = await processor.processAll();
// Should complete without errors since no READMEs fetched means no summary phase
expect(result.errors).toEqual([]);
});
});
describe('README fetching edge cases', () => {
it('should skip nodes without npmPackageName', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
{ ...createMockCommunityNode({ nodeType: 'node2' }), npmPackageName: undefined },
{ ...createMockCommunityNode({ nodeType: 'node3' }), npmPackageName: null },
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes as any);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(
new Map([['pkg1', '# README']])
);
await processor.processAll({ readmeOnly: true });
// Should only request README for pkg1
expect(mockFetcher.fetchReadmesBatch).toHaveBeenCalledWith(
['pkg1'],
undefined,
5
);
});
it('should handle failed README fetches (null in map)', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
createMockCommunityNode({ nodeType: 'node2', npmPackageName: 'pkg2' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(
new Map([
['pkg1', '# README'],
['pkg2', null], // Failed to fetch
])
);
const result = await processor.processAll({ readmeOnly: true });
expect(result.readmesFetched).toBe(1);
expect(result.readmesFailed).toBe(1);
expect(mockRepository.updateNodeReadme).toHaveBeenCalledTimes(1);
});
it('should handle empty package name list', async () => {
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue([]);
const result = await processor.processAll({ readmeOnly: true });
expect(mockFetcher.fetchReadmesBatch).not.toHaveBeenCalled();
expect(result.readmesFetched).toBe(0);
expect(result.readmesFailed).toBe(0);
});
});
describe('summary generation edge cases', () => {
it('should skip nodes without README for summary generation', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README' }),
createMockCommunityNode({ nodeType: 'node2', npmReadme: '' }),
createMockCommunityNode({ nodeType: 'node3', npmReadme: null }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([
{ nodeType: 'node1', summary: createMockDocumentationSummary('node1') },
]);
await processor.processAll({ summaryOnly: true });
const inputs = vi.mocked(mockGenerator.generateBatch).mock.calls[0][0];
expect(inputs).toHaveLength(1);
expect(inputs[0].nodeType).toBe('node1');
});
it('should pass correct concurrency to generateBatch', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([]);
await processor.processAll({ summaryOnly: true, llmConcurrency: 10 });
expect(mockGenerator.generateBatch).toHaveBeenCalledWith(
expect.any(Array),
10,
undefined
);
});
it('should use default LLM concurrency of 3', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([]);
await processor.processAll({ summaryOnly: true });
expect(mockGenerator.generateBatch).toHaveBeenCalledWith(
expect.any(Array),
3,
undefined
);
});
it('should handle empty node list for summary generation', async () => {
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue([]);
const result = await processor.processAll({ summaryOnly: true });
expect(mockGenerator.testConnection).not.toHaveBeenCalled();
expect(mockGenerator.generateBatch).not.toHaveBeenCalled();
expect(result.summariesGenerated).toBe(0);
});
});
describe('concurrency options', () => {
it('should respect custom readmeConcurrency option', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(new Map());
await processor.processAll({ readmeOnly: true, readmeConcurrency: 1 });
expect(mockFetcher.fetchReadmesBatch).toHaveBeenCalledWith(
expect.any(Array),
undefined,
1
);
});
it('should respect custom llmConcurrency option', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([]);
await processor.processAll({ summaryOnly: true, llmConcurrency: 1 });
expect(mockGenerator.generateBatch).toHaveBeenCalledWith(
expect.any(Array),
1,
undefined
);
});
});
describe('progress callback propagation', () => {
it('should pass progress callback to summary generation', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmReadme: '# README' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([]);
const progressCallback = vi.fn();
await processor.processAll({ summaryOnly: true, progressCallback });
expect(mockGenerator.generateBatch).toHaveBeenCalledWith(
expect.any(Array),
expect.any(Number),
progressCallback
);
});
it('should pass progress callback to README fetching', async () => {
const nodes = [
createMockCommunityNode({ nodeType: 'node1', npmPackageName: 'pkg1' }),
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes);
vi.mocked(mockFetcher.fetchReadmesBatch).mockResolvedValue(new Map());
const progressCallback = vi.fn();
await processor.processAll({ readmeOnly: true, progressCallback });
expect(mockFetcher.fetchReadmesBatch).toHaveBeenCalledWith(
expect.any(Array),
progressCallback,
expect.any(Number)
);
});
});
describe('documentation input preparation', () => {
it('should prepare correct input for documentation generator', async () => {
const nodes = [
{
nodeType: 'n8n-nodes-test.testNode',
displayName: 'Test Node',
description: 'A test node',
npmPackageName: 'n8n-nodes-test',
npmReadme: '# Test README\nThis is a test.',
},
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes as any);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([
{ nodeType: 'n8n-nodes-test.testNode', summary: createMockDocumentationSummary('test') },
]);
await processor.processAll({ summaryOnly: true });
const inputs = vi.mocked(mockGenerator.generateBatch).mock.calls[0][0];
expect(inputs[0]).toEqual({
nodeType: 'n8n-nodes-test.testNode',
displayName: 'Test Node',
description: 'A test node',
readme: '# Test README\nThis is a test.',
npmPackageName: 'n8n-nodes-test',
});
});
it('should handle missing optional fields', async () => {
const nodes = [
{
nodeType: 'node1',
displayName: 'Node 1',
npmReadme: '# README',
// Missing description and npmPackageName
},
];
vi.mocked(mockRepository.getCommunityNodes).mockReturnValue(nodes as any);
vi.mocked(mockGenerator.generateBatch).mockResolvedValue([]);
await processor.processAll({ summaryOnly: true });
const inputs = vi.mocked(mockGenerator.generateBatch).mock.calls[0][0];
expect(inputs[0].description).toBeUndefined();
expect(inputs[0].npmPackageName).toBeUndefined();
});
});
});
