cortexweaver
Version:
CortexWeaver is a command-line interface (CLI) tool that orchestrates a swarm of specialized AI agents, powered by Claude Code and Gemini CLI, to assist in software development. It transforms a high-level project plan (plan.md) into a series of coordinate
306 lines (302 loc) • 12.8 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ChicagoTester = void 0;
const agent_1 = require("../agent");
class ChicagoTester extends agent_1.Agent {
getPromptTemplate() {
return `Chicago School TDD Agent specializing in interaction-based testing with extensive mocking and behavior verification. Focus on testing object interactions, dependencies, and protocols rather than state. Context: {{sourceFiles}}, Dependencies: {{dependencies}}.`;
}
async executeTask() {
if (!this.currentTask || !this.taskContext) {
throw new Error('No task or context available');
}
const metadata = this.currentTask.metadata || {};
const { files, dependencies = [] } = this.taskContext;
const sourceFiles = await this.readSourceFiles(files || []);
const testSuite = await this.generateChicagoTestSuite(metadata?.targetClass || 'UnknownClass', sourceFiles, dependencies);
const testFilePath = this.generateTestFilePath(metadata?.targetClass || 'UnknownClass');
await this.writeFile(testFilePath, this.generateTestCode(testSuite));
return {
testSuite,
mockObjects: testSuite.mockObjects,
interactions: testSuite.interactions,
coverage: testSuite.coverage,
message: 'Generated Chicago-style tests with comprehensive mocking and interaction verification'
};
}
async identifyDependencies(sourceCode) {
const dependencies = [];
const importMatches = sourceCode.match(/import\s+.*\s+from\s+['"`]([^'"`]+)['"`]/g);
if (importMatches) {
for (const match of importMatches) {
const moduleMatch = match.match(/from\s+['"`]([^'"`]+)['"`]/);
if (moduleMatch && !moduleMatch[1].startsWith('.')) {
dependencies.push(moduleMatch[1]);
}
}
}
const constructorMatches = sourceCode.match(/constructor\s*\([^)]*\)/g);
if (constructorMatches) {
for (const match of constructorMatches) {
const paramMatches = match.match(/(\w+):\s*(\w+)/g);
if (paramMatches) {
paramMatches.forEach(param => {
const [, , type] = param.match(/(\w+):\s*(\w+)/) || [];
if (type && type !== 'string' && type !== 'number' && type !== 'boolean') {
dependencies.push(type);
}
});
}
}
}
return [...new Set(dependencies)];
}
async generateMockObjects(dependencies, sourceCode) {
const mocks = [];
for (const dep of dependencies) {
const mockMethods = this.extractMethodsForDependency(dep, sourceCode);
const mockProperties = this.extractPropertiesForDependency(dep, sourceCode);
mocks.push({
name: `${dep}Mock`,
type: dep,
methods: mockMethods,
properties: mockProperties,
behavior: 'strict-verification'
});
}
return mocks;
}
async createTestDoubles(dependencies) {
const testDoubles = [];
for (const dep of dependencies) {
testDoubles.push({
name: `${dep.toLowerCase()}Mock`,
type: 'mock',
purpose: `Mock implementation for ${dep} dependency`,
implementation: this.generateMockImplementation(dep)
});
testDoubles.push({
name: `${dep.toLowerCase()}Spy`,
type: 'spy',
purpose: `Spy for monitoring ${dep} interactions`,
implementation: this.generateSpyImplementation(dep)
});
}
return testDoubles;
}
async generateInteractionVerifications(methods, dependencies) {
const verifications = [];
for (const method of methods) {
for (const dep of dependencies) {
verifications.push({
description: `Verify ${method} calls ${dep} with correct parameters`,
target: `${dep.toLowerCase()}Mock`,
method: this.inferMethodCall(method, dep),
parameters: ['expectedParam1', 'expectedParam2'],
expectedCalls: 1,
order: verifications.length + 1
});
}
}
return verifications;
}
async analyzeInteractionPatterns(sourceCode) {
const patterns = [];
if (sourceCode.includes('async') || sourceCode.includes('await')) {
patterns.push('asynchronous-interactions');
}
if (sourceCode.includes('event') || sourceCode.includes('emit')) {
patterns.push('event-driven');
}
if (sourceCode.includes('observer') || sourceCode.includes('subscribe')) {
patterns.push('observer-pattern');
}
if (sourceCode.includes('factory') || sourceCode.includes('create')) {
patterns.push('factory-pattern');
}
return patterns;
}
async readSourceFiles(files) {
const sourceFiles = [];
for (const file of files) {
try {
const content = await this.readFile(file);
sourceFiles.push(content);
}
catch (error) {
console.warn(`Could not read file ${file}: ${error.message}`);
}
}
return sourceFiles;
}
async generateChicagoTestSuite(className, sourceFiles, dependencies) {
const sourceCode = sourceFiles.join('\n');
const extractedDependencies = await this.identifyDependencies(sourceCode);
const allDependencies = [...extractedDependencies, ...dependencies.map((dep) => typeof dep === 'string' ? dep : dep.name)];
const promptContext = {
sourceFiles: sourceCode,
dependencies: JSON.stringify(allDependencies)
};
const prompt = this.formatPrompt(this.getPromptTemplate(), promptContext) + `
SOURCE CODE:
${sourceCode}
DEPENDENCIES:
${JSON.stringify(allDependencies, null, 2)}
Generate Chicago-style test suite focusing on:
1. Interaction-based testing with extensive mocking
2. Behavior verification over state verification
3. Test doubles for all external dependencies
4. Protocol and contract verification
5. Isolation through mocking
Create tests that verify object interactions and communications rather than final state.
Include comprehensive mock objects and interaction verifications.`;
const response = await this.sendToClaude(prompt);
const mockObjects = await this.generateMockObjects(allDependencies, sourceCode);
const testDoubles = await this.createTestDoubles(allDependencies);
const methods = this.extractMethods(sourceCode);
const interactions = await this.generateInteractionVerifications(methods, allDependencies);
return {
suiteName: `${className}ChicagoTests`,
testCases: this.parseTestCases(response.content),
mockObjects,
testDoubles,
interactions,
coverage: {
behavioral: 85,
interaction: 90,
state: 40
}
};
}
extractMethodsForDependency(dependency, sourceCode) {
const methods = [];
const methodPattern = new RegExp(`\\b${dependency}\\w*\\.\\w+\\(`, 'g');
const matches = sourceCode.match(methodPattern);
if (matches) {
const uniqueMethods = [...new Set(matches.map(match => {
const methodName = match.split('.')[1].replace('(', '');
return methodName;
}))];
uniqueMethods.forEach(methodName => {
methods.push({
name: methodName,
parameters: ['param1', 'param2'],
returnType: 'any',
behavior: 'returns-expected-value',
verifications: [`verify ${methodName} called with correct parameters`]
});
});
}
return methods;
}
extractPropertiesForDependency(dependency, sourceCode) {
const properties = [];
const propertyPattern = new RegExp(`\\b${dependency}\\w*\\.\\w+(?!\\()`, 'g');
const matches = sourceCode.match(propertyPattern);
if (matches) {
const uniqueProperties = [...new Set(matches.map(match => {
return match.split('.')[1];
}))];
uniqueProperties.forEach(propertyName => {
properties.push({
name: propertyName,
type: 'any',
defaultValue: null,
behavior: 'returns-mock-value'
});
});
}
return properties;
}
generateMockImplementation(dependency) {
return `const ${dependency.toLowerCase()}Mock = {
// Mock implementation for ${dependency}
setup: () => mockSetup(),
verify: () => mockVerify(),
reset: () => mockReset()
};`;
}
generateSpyImplementation(dependency) {
return `const ${dependency.toLowerCase()}Spy = jasmine.createSpy('${dependency}');`;
}
inferMethodCall(method, dependency) {
const commonMethods = ['get', 'set', 'save', 'delete', 'update', 'create', 'find'];
const methodLower = method.toLowerCase();
for (const common of commonMethods) {
if (methodLower.includes(common)) {
return common;
}
}
return 'execute';
}
extractMethods(sourceCode) {
const methods = [];
const methodMatches = sourceCode.match(/\b\w+\s*\([^)]*\)\s*:/g);
if (methodMatches) {
methodMatches.forEach(match => {
const methodName = match.split('(')[0].trim();
if (methodName && !['constructor', 'get', 'set'].includes(methodName)) {
methods.push(methodName);
}
});
}
return [...new Set(methods)];
}
parseTestCases(content) {
const testCases = [];
const testBlocks = content.split(/(?=describe|it|test)/);
for (const block of testBlocks) {
if (block.includes('it(') || block.includes('test(')) {
const nameMatch = block.match(/(?:it|test)\(['"`]([^'"`]+)['"`]/);
const testName = nameMatch ? nameMatch[1] : 'Generated test';
testCases.push({
name: testName,
description: `Chicago-style test for ${testName}`,
setup: 'Mock dependencies and setup test doubles',
execution: 'Execute method under test',
verification: 'Verify interactions and mock expectations',
mockingStrategy: 'strict',
dependencies: ['mock1', 'mock2']
});
}
}
if (testCases.length === 0) {
testCases.push({
name: 'Default Chicago Test',
description: 'Generated Chicago-style interaction test',
setup: 'Setup mocks and dependencies',
execution: 'Call method under test',
verification: 'Verify all interactions',
mockingStrategy: 'strict',
dependencies: []
});
}
return testCases;
}
generateTestCode(testSuite) {
let testCode = `// ${testSuite.suiteName} - Chicago School TDD\n\n`;
testSuite.mockObjects.forEach(mock => {
testCode += `const ${mock.name} = {\n`;
mock.methods.forEach(method => {
testCode += ` ${method.name}: jest.fn(),\n`;
});
testCode += `};\n\n`;
});
testCode += `describe('${testSuite.suiteName}', () => {\n`;
testSuite.testCases.forEach(testCase => {
testCode += ` it('${testCase.name}', () => {\n`;
testCode += ` // ${testCase.setup}\n`;
testCode += ` // ${testCase.execution}\n`;
testCode += ` // ${testCase.verification}\n`;
testCode += ` });\n\n`;
});
testCode += `});\n`;
return testCode;
}
generateTestFilePath(className) {
const testFileName = `${className.toLowerCase()}.chicago.test.ts`;
return `tests/chicago/${testFileName}`;
}
}
exports.ChicagoTester = ChicagoTester;
//# sourceMappingURL=chicago-tester.js.map