mirror of
https://github.com/proffesor-for-testing/agentic-qe.git
synced 2026-09-19 08:45:47 +08:00
Profa
5a2883a4a0
Agentic Quality Engineering Fleet - AI-driven quality management platform Features: - 16 specialized QE agents for comprehensive testing - AI-powered test generation with 95% coverage targets - O(log n) sublinear algorithms for massive scale - Parallel test execution with intelligent orchestration - Real-time coverage analysis and gap detection - Smart quality gates with ML-driven decisions - Security scanning (SAST, DAST, dependency analysis) - Performance testing with load orchestration - Flaky test detection with automatic stabilization - API contract validation with breaking change detection - Test data generation (10,000+ records/sec) - Production intelligence (convert incidents to tests) - Chaos engineering for resilience testing - MCP integration with Claude Code - Multi-framework support (Jest, Mocha, Cypress, Playwright) Architecture: - TypeScript implementation - MCP (Model Context Protocol) integration - Claude Code agent orchestration - Event-driven agent coordination - Distributed fleet management - Cross-session memory persistence Documentation: - Complete API documentation (TypeDoc) - User guides (Getting Started, MCP Integration, Test Generation, etc.) - Architecture deep-dive - CLI reference - Contributing guidelines - MIT License Tech Stack: - TypeScript 5.3+ - Node.js 18+ - @anthropic-ai/sdk ^0.64.0 - @modelcontextprotocol/sdk ^1.18.2 - Jest for testing - Winston for logging - SQLite for persistence Project Structure: - src/ - Source code (agents, core, MCP, CLI) - tests/ - Comprehensive test suite - docs/ - Complete documentation - .claude/ - Agent definitions and commands - config/ - Configuration files 🤖 Generated with Claude Code https://claude.com/claude-code Co-Authored-By: Claude <noreply@anthropic.com>
1217 lines
38 KiB
TypeScript
1217 lines
38 KiB
TypeScript
/**
|
|
* Unit tests for DeploymentReadinessAgent
|
|
* Tests deployment readiness checks, confidence calculations, and risk assessments
|
|
*/
|
|
|
|
import { DeploymentReadinessAgent, DeploymentReadinessAgentConfig } from '../../src/agents/DeploymentReadinessAgent';
|
|
import { EventEmitter } from 'events';
|
|
import { QEAgentType, AgentStatus } from '../../src/types';
|
|
|
|
// ============================================================================
|
|
// Mock Implementations
|
|
// ============================================================================
|
|
|
|
class MockMemoryStore {
|
|
private data = new Map<string, any>();
|
|
|
|
async store(key: string, value: any): Promise<void> {
|
|
this.data.set(key, value);
|
|
}
|
|
|
|
async retrieve(key: string): Promise<any> {
|
|
return this.data.get(key);
|
|
}
|
|
|
|
async set(key: string, value: any): Promise<void> {
|
|
this.data.set(key, value);
|
|
}
|
|
|
|
async get(key: string): Promise<any> {
|
|
return this.data.get(key);
|
|
}
|
|
|
|
async delete(key: string): Promise<boolean> {
|
|
if (key.includes('*')) {
|
|
// Handle wildcard deletions
|
|
const prefix = key.replace('*', '');
|
|
let deleted = false;
|
|
for (const k of Array.from(this.data.keys())) {
|
|
if (k.startsWith(prefix)) {
|
|
this.data.delete(k);
|
|
deleted = true;
|
|
}
|
|
}
|
|
return deleted;
|
|
}
|
|
return this.data.delete(key);
|
|
}
|
|
|
|
async clear(): Promise<void> {
|
|
this.data.clear();
|
|
}
|
|
|
|
// Helper for tests
|
|
has(key: string): boolean {
|
|
return this.data.has(key);
|
|
}
|
|
|
|
getAll(): Map<string, any> {
|
|
return new Map(this.data);
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// Test Fixtures
|
|
// ============================================================================
|
|
|
|
const createMockQualitySignals = (scenario: 'excellent' | 'good' | 'warning' | 'critical') => {
|
|
const signals = {
|
|
excellent: {
|
|
qualityGate: {
|
|
status: 'passed' as const,
|
|
score: 95,
|
|
violations: []
|
|
},
|
|
performance: {
|
|
p50: 120,
|
|
p95: 380,
|
|
p99: 450,
|
|
throughput: 1500,
|
|
errorRate: 0.05,
|
|
status: 'passed' as const
|
|
},
|
|
security: {
|
|
vulnerabilities: { critical: 0, high: 0, medium: 2, low: 5 },
|
|
status: 'passed' as const
|
|
},
|
|
coverage: { line: 92, branch: 88, function: 90, statement: 91 },
|
|
testResults: { total: 500, passed: 500, failed: 0, skipped: 0, flakyCount: 2 }
|
|
},
|
|
good: {
|
|
qualityGate: {
|
|
status: 'passed' as const,
|
|
score: 85,
|
|
violations: [{ severity: 'minor' as const, type: 'code-smell', count: 5 }]
|
|
},
|
|
performance: {
|
|
p50: 180,
|
|
p95: 480,
|
|
p99: 550,
|
|
throughput: 1200,
|
|
errorRate: 0.08,
|
|
status: 'passed' as const
|
|
},
|
|
security: {
|
|
vulnerabilities: { critical: 0, high: 0, medium: 5, low: 10 },
|
|
status: 'passed' as const
|
|
},
|
|
coverage: { line: 87, branch: 82, function: 85, statement: 86 },
|
|
testResults: { total: 500, passed: 495, failed: 2, skipped: 3, flakyCount: 5 }
|
|
},
|
|
warning: {
|
|
qualityGate: {
|
|
status: 'warning' as const,
|
|
score: 70,
|
|
violations: [
|
|
{ severity: 'major' as const, type: 'bug', count: 3 },
|
|
{ severity: 'minor' as const, type: 'code-smell', count: 15 }
|
|
]
|
|
},
|
|
performance: {
|
|
p50: 250,
|
|
p95: 520,
|
|
p99: 680,
|
|
throughput: 900,
|
|
errorRate: 0.15,
|
|
status: 'warning' as const
|
|
},
|
|
security: {
|
|
vulnerabilities: { critical: 0, high: 1, medium: 12, low: 20 },
|
|
status: 'warning' as const
|
|
},
|
|
coverage: { line: 78, branch: 72, function: 75, statement: 77 },
|
|
testResults: { total: 500, passed: 480, failed: 15, skipped: 5, flakyCount: 12 }
|
|
},
|
|
critical: {
|
|
qualityGate: {
|
|
status: 'failed' as const,
|
|
score: 45,
|
|
violations: [
|
|
{ severity: 'blocker' as const, type: 'bug', count: 2 },
|
|
{ severity: 'critical' as const, type: 'vulnerability', count: 5 },
|
|
{ severity: 'major' as const, type: 'code-smell', count: 25 }
|
|
]
|
|
},
|
|
performance: {
|
|
p50: 450,
|
|
p95: 1200,
|
|
p99: 1850,
|
|
throughput: 500,
|
|
errorRate: 0.5,
|
|
status: 'failed' as const
|
|
},
|
|
security: {
|
|
vulnerabilities: { critical: 3, high: 8, medium: 20, low: 35 },
|
|
status: 'failed' as const
|
|
},
|
|
coverage: { line: 65, branch: 58, function: 62, statement: 64 },
|
|
testResults: { total: 500, passed: 420, failed: 65, skipped: 15, flakyCount: 28 }
|
|
}
|
|
};
|
|
|
|
return signals[scenario];
|
|
};
|
|
|
|
const createMockDeploymentMetadata = (
|
|
scenario: 'small' | 'medium' | 'large' = 'medium'
|
|
) => {
|
|
const metadata = {
|
|
small: {
|
|
deploymentId: 'deploy-small-123',
|
|
version: 'v1.2.3',
|
|
environment: 'production',
|
|
changeSize: 500,
|
|
filesModified: 8,
|
|
timestamp: new Date()
|
|
},
|
|
medium: {
|
|
deploymentId: 'deploy-medium-456',
|
|
version: 'v2.0.0',
|
|
environment: 'production',
|
|
changeSize: 3000,
|
|
filesModified: 35,
|
|
timestamp: new Date()
|
|
},
|
|
large: {
|
|
deploymentId: 'deploy-large-789',
|
|
version: 'v3.0.0',
|
|
environment: 'production',
|
|
changeSize: 15000,
|
|
filesModified: 120,
|
|
timestamp: new Date()
|
|
}
|
|
};
|
|
|
|
return metadata[scenario];
|
|
};
|
|
|
|
// ============================================================================
|
|
// Test Suite
|
|
// ============================================================================
|
|
|
|
describe('DeploymentReadinessAgent', () => {
|
|
let agent: DeploymentReadinessAgent;
|
|
let mockMemoryStore: MockMemoryStore;
|
|
let mockEventBus: EventEmitter;
|
|
|
|
beforeEach(async () => {
|
|
mockMemoryStore = new MockMemoryStore();
|
|
mockEventBus = new EventEmitter();
|
|
|
|
const config: DeploymentReadinessAgentConfig = {
|
|
type: QEAgentType.DEPLOYMENT_READINESS,
|
|
capabilities: [],
|
|
context: { id: 'test', type: 'test', status: AgentStatus.IDLE },
|
|
memoryStore: mockMemoryStore as any,
|
|
eventBus: mockEventBus,
|
|
integrations: {
|
|
qualityGate: true,
|
|
performance: true,
|
|
security: true,
|
|
monitoring: ['datadog', 'newrelic']
|
|
},
|
|
thresholds: {
|
|
minConfidenceScore: 95,
|
|
reviewThreshold: 70,
|
|
maxRollbackRisk: 0.3,
|
|
maxOpenIncidents: 0
|
|
},
|
|
checklist: {
|
|
requiredApprovals: ['lead', 'security'],
|
|
requiredTests: ['unit', 'integration', 'e2e'],
|
|
requiredMetrics: ['coverage', 'complexity']
|
|
}
|
|
};
|
|
|
|
agent = new DeploymentReadinessAgent(config);
|
|
await agent.initialize();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await agent.terminate();
|
|
mockEventBus.removeAllListeners();
|
|
});
|
|
|
|
// ============================================================================
|
|
// Initialization Tests
|
|
// ============================================================================
|
|
|
|
describe('initialization', () => {
|
|
it('should initialize successfully', () => {
|
|
const status = agent.getStatus();
|
|
expect(status.status).toBe(AgentStatus.ACTIVE);
|
|
expect(status.agentId.type).toBe(QEAgentType.DEPLOYMENT_READINESS);
|
|
});
|
|
|
|
it('should have all required capabilities', () => {
|
|
expect(agent.hasCapability('risk-scoring')).toBe(true);
|
|
expect(agent.hasCapability('confidence-calculation')).toBe(true);
|
|
expect(agent.hasCapability('checklist-automation')).toBe(true);
|
|
expect(agent.hasCapability('rollback-prediction')).toBe(true);
|
|
expect(agent.hasCapability('stakeholder-reporting')).toBe(true);
|
|
expect(agent.hasCapability('deployment-gate-enforcement')).toBe(true);
|
|
expect(agent.hasCapability('post-deployment-monitoring')).toBe(true);
|
|
});
|
|
|
|
it('should initialize with default thresholds', async () => {
|
|
const configWithDefaults: DeploymentReadinessAgentConfig = {
|
|
type: QEAgentType.DEPLOYMENT_READINESS,
|
|
capabilities: [],
|
|
context: { id: 'test2', type: 'test', status: AgentStatus.IDLE },
|
|
memoryStore: mockMemoryStore as any,
|
|
eventBus: mockEventBus
|
|
};
|
|
|
|
const agentWithDefaults = new DeploymentReadinessAgent(configWithDefaults);
|
|
await agentWithDefaults.initialize();
|
|
|
|
const status = agentWithDefaults.getStatus();
|
|
expect(status.status).toBe(AgentStatus.ACTIVE);
|
|
|
|
await agentWithDefaults.terminate();
|
|
});
|
|
|
|
it('should load historical deployment data', async () => {
|
|
const history = [
|
|
{ deploymentId: 'deploy-1', success: true, signals: createMockQualitySignals('excellent') },
|
|
{ deploymentId: 'deploy-2', success: true, signals: createMockQualitySignals('good') }
|
|
];
|
|
|
|
await mockMemoryStore.store('aqe/deployment/history', history);
|
|
|
|
const newAgent = new DeploymentReadinessAgent({
|
|
type: QEAgentType.DEPLOYMENT_READINESS,
|
|
capabilities: [],
|
|
context: { id: 'test3', type: 'test', status: AgentStatus.IDLE },
|
|
memoryStore: mockMemoryStore as any,
|
|
eventBus: mockEventBus
|
|
});
|
|
|
|
await newAgent.initialize();
|
|
const status = newAgent.getStatus();
|
|
expect(status.status).toBe(AgentStatus.ACTIVE);
|
|
|
|
await newAgent.terminate();
|
|
});
|
|
});
|
|
|
|
// ============================================================================
|
|
// Deployment Readiness Check Tests
|
|
// ============================================================================
|
|
|
|
describe('deployment readiness check', () => {
|
|
it('should perform complete readiness check with GO decision for excellent signals', async () => {
|
|
const metadata = createMockDeploymentMetadata('small');
|
|
const signals = createMockQualitySignals('excellent');
|
|
|
|
// Mock quality signals in shared memory
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.QUALITY_GATE}:evaluation/${metadata.version}`,
|
|
signals.qualityGate
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.PERFORMANCE_TESTER}:results/${metadata.version}`,
|
|
signals.performance
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.SECURITY_SCANNER}:scan/${metadata.version}`,
|
|
signals.security
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.COVERAGE_ANALYZER}:coverage/${metadata.version}`,
|
|
signals.coverage
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.TEST_EXECUTOR}:results/${metadata.version}`,
|
|
signals.testResults
|
|
);
|
|
|
|
const task = {
|
|
id: 'task-1',
|
|
type: 'deployment-readiness-check',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-1',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
expect(result).toBeDefined();
|
|
expect(result.deploymentId).toBe(metadata.deploymentId);
|
|
expect(result.decision).toBe('GO');
|
|
expect(result.confidenceScore).toBeGreaterThanOrEqual(95);
|
|
expect(result.riskLevel).toBe('low');
|
|
expect(result.reasons.some((r: string) => r.includes('Confidence score'))).toBe(true);
|
|
expect(result.recommendations.some((r: string) => r.includes('Proceed'))).toBe(true);
|
|
|
|
// Verify report stored in memory
|
|
const storedReport = await mockMemoryStore.retrieve(
|
|
`aqe/deployment/reports/${metadata.deploymentId}`
|
|
);
|
|
expect(storedReport).toBeDefined();
|
|
expect(storedReport.decision).toBe('GO');
|
|
});
|
|
|
|
it('should return REVIEW decision for good but not excellent signals', async () => {
|
|
const metadata = createMockDeploymentMetadata('small');
|
|
const signals = createMockQualitySignals('good');
|
|
|
|
// Mock quality signals
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.QUALITY_GATE}:evaluation/${metadata.version}`,
|
|
signals.qualityGate
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.PERFORMANCE_TESTER}:results/${metadata.version}`,
|
|
signals.performance
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.SECURITY_SCANNER}:scan/${metadata.version}`,
|
|
signals.security
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.COVERAGE_ANALYZER}:coverage/${metadata.version}`,
|
|
signals.coverage
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.TEST_EXECUTOR}:results/${metadata.version}`,
|
|
signals.testResults
|
|
);
|
|
|
|
const task = {
|
|
id: 'task-2',
|
|
type: 'deployment-readiness-check',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-2',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
// Good signals may produce GO, REVIEW, or BLOCK depending on exact scores
|
|
// With small deployment and good signals, confidence can reach 95% (GO threshold)
|
|
expect(['GO', 'REVIEW', 'BLOCK']).toContain(result.decision);
|
|
expect(result.confidenceScore).toBeLessThanOrEqual(95);
|
|
if (result.decision === 'REVIEW') {
|
|
expect(result.confidenceScore).toBeGreaterThanOrEqual(70);
|
|
expect(result.recommendations.some((r: string) => r.includes('Manual review') || r.includes('review'))).toBe(true);
|
|
}
|
|
});
|
|
|
|
it('should return BLOCK decision for critical issues', async () => {
|
|
const metadata = createMockDeploymentMetadata('large');
|
|
const signals = createMockQualitySignals('critical');
|
|
|
|
// Mock quality signals
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.QUALITY_GATE}:evaluation/${metadata.version}`,
|
|
signals.qualityGate
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.PERFORMANCE_TESTER}:results/${metadata.version}`,
|
|
signals.performance
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.SECURITY_SCANNER}:scan/${metadata.version}`,
|
|
signals.security
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.COVERAGE_ANALYZER}:coverage/${metadata.version}`,
|
|
signals.coverage
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.TEST_EXECUTOR}:results/${metadata.version}`,
|
|
signals.testResults
|
|
);
|
|
|
|
const task = {
|
|
id: 'task-3',
|
|
type: 'deployment-readiness-check',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-3',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
expect(result.decision).toBe('BLOCK');
|
|
expect(result.confidenceScore).toBeLessThan(70);
|
|
expect(result.riskLevel).toMatch(/high|critical/);
|
|
expect(result.reasons.some((r: string) => r.includes('critical security vulnerabilities'))).toBe(true);
|
|
expect(result.recommendations.some((r: string) => r.includes('Address all blocking issues'))).toBe(true);
|
|
});
|
|
|
|
it('should emit deployment.ready event for GO decision', async () => {
|
|
const metadata = createMockDeploymentMetadata('small');
|
|
const signals = createMockQualitySignals('excellent');
|
|
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.QUALITY_GATE}:evaluation/${metadata.version}`,
|
|
signals.qualityGate
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.PERFORMANCE_TESTER}:results/${metadata.version}`,
|
|
signals.performance
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.SECURITY_SCANNER}:scan/${metadata.version}`,
|
|
signals.security
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.COVERAGE_ANALYZER}:coverage/${metadata.version}`,
|
|
signals.coverage
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.TEST_EXECUTOR}:results/${metadata.version}`,
|
|
signals.testResults
|
|
);
|
|
|
|
const eventPromise = new Promise<any>(resolve => {
|
|
mockEventBus.once('deployment.ready', resolve);
|
|
});
|
|
|
|
const task = {
|
|
id: 'task-4',
|
|
type: 'deployment-readiness-check',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-4',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
await agent.executeTask(assignment);
|
|
|
|
const event = await eventPromise;
|
|
expect(event.data.deploymentId).toBe(metadata.deploymentId);
|
|
expect(event.data.decision).toBe('GO');
|
|
});
|
|
|
|
it('should emit deployment.blocked event for BLOCK decision', async () => {
|
|
const metadata = createMockDeploymentMetadata('large');
|
|
const signals = createMockQualitySignals('critical');
|
|
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.QUALITY_GATE}:evaluation/${metadata.version}`,
|
|
signals.qualityGate
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.PERFORMANCE_TESTER}:results/${metadata.version}`,
|
|
signals.performance
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.SECURITY_SCANNER}:scan/${metadata.version}`,
|
|
signals.security
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.COVERAGE_ANALYZER}:coverage/${metadata.version}`,
|
|
signals.coverage
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.TEST_EXECUTOR}:results/${metadata.version}`,
|
|
signals.testResults
|
|
);
|
|
|
|
const eventPromise = new Promise<any>(resolve => {
|
|
mockEventBus.once('deployment.blocked', resolve);
|
|
});
|
|
|
|
const task = {
|
|
id: 'task-5',
|
|
type: 'deployment-readiness-check',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-5',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
await agent.executeTask(assignment);
|
|
|
|
const event = await eventPromise;
|
|
expect(event.data.deploymentId).toBe(metadata.deploymentId);
|
|
expect(event.data.reasons).toBeDefined();
|
|
});
|
|
});
|
|
|
|
// ============================================================================
|
|
// Confidence Score Calculation Tests
|
|
// ============================================================================
|
|
|
|
describe('confidence score calculation', () => {
|
|
it('should calculate high confidence for excellent signals', async () => {
|
|
const metadata = createMockDeploymentMetadata('small');
|
|
const signals = createMockQualitySignals('excellent');
|
|
|
|
const task = {
|
|
id: 'task-6',
|
|
type: 'calculate-confidence-score',
|
|
payload: { signals, metadata },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-6',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
expect(result.score).toBeGreaterThanOrEqual(90);
|
|
expect(result.level).toMatch(/high|very_high/);
|
|
expect(result.factors.qualityScore).toBeGreaterThanOrEqual(90);
|
|
expect(result.factors.performanceScore).toBeGreaterThanOrEqual(90);
|
|
expect(result.factors.securityScore).toBeGreaterThanOrEqual(90);
|
|
expect(result.recommendation).toContain('DEPLOY');
|
|
});
|
|
|
|
it('should calculate medium confidence for warning signals', async () => {
|
|
const metadata = createMockDeploymentMetadata('medium');
|
|
const signals = createMockQualitySignals('warning');
|
|
|
|
const task = {
|
|
id: 'task-7',
|
|
type: 'calculate-confidence-score',
|
|
payload: { signals, metadata },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-7',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
expect(result.score).toBeLessThan(90);
|
|
expect(result.score).toBeGreaterThanOrEqual(50);
|
|
expect(result.level).toMatch(/low|medium|high/);
|
|
});
|
|
|
|
it('should calculate low confidence for critical signals', async () => {
|
|
const metadata = createMockDeploymentMetadata('large');
|
|
const signals = createMockQualitySignals('critical');
|
|
|
|
const task = {
|
|
id: 'task-8',
|
|
type: 'calculate-confidence-score',
|
|
payload: { signals, metadata },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-8',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
expect(result.score).toBeLessThan(60);
|
|
expect(result.level).toMatch(/low|very_low/);
|
|
expect(result.recommendation).toContain('DO NOT DEPLOY');
|
|
});
|
|
|
|
it('should store confidence calculation in memory', async () => {
|
|
const metadata = createMockDeploymentMetadata('small');
|
|
const signals = createMockQualitySignals('good');
|
|
|
|
const task = {
|
|
id: 'task-9',
|
|
type: 'calculate-confidence-score',
|
|
payload: { signals, metadata },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-9',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
await agent.executeTask(assignment);
|
|
|
|
const stored = await mockMemoryStore.retrieve(
|
|
`aqe/deployment/confidence-scores/${metadata.deploymentId}`
|
|
);
|
|
expect(stored).toBeDefined();
|
|
expect(stored.score).toBeDefined();
|
|
expect(stored.factors).toBeDefined();
|
|
});
|
|
});
|
|
|
|
// ============================================================================
|
|
// Rollback Risk Prediction Tests
|
|
// ============================================================================
|
|
|
|
describe('rollback risk prediction', () => {
|
|
it('should predict low risk for small, well-tested deployments', async () => {
|
|
const metadata = createMockDeploymentMetadata('small');
|
|
const signals = createMockQualitySignals('excellent');
|
|
|
|
const task = {
|
|
id: 'task-10',
|
|
type: 'predict-rollback-risk',
|
|
payload: { signals, metadata },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-10',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
expect(result.probability).toBeLessThan(0.3);
|
|
expect(result.level).toBe('low');
|
|
expect(result.estimatedRecoveryTime).toBeLessThanOrEqual(15);
|
|
expect(result.rollbackPlan).toBeDefined();
|
|
expect(result.rollbackPlan.method).toBe('Blue-Green Deployment');
|
|
});
|
|
|
|
it('should predict high risk for large, complex deployments', async () => {
|
|
const metadata = createMockDeploymentMetadata('large');
|
|
const signals = createMockQualitySignals('warning');
|
|
|
|
const task = {
|
|
id: 'task-11',
|
|
type: 'predict-rollback-risk',
|
|
payload: { signals, metadata },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-11',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
expect(result.probability).toBeGreaterThanOrEqual(0.3);
|
|
expect(result.level).toMatch(/medium|high|critical/);
|
|
expect(result.mitigationStrategies.length).toBeGreaterThan(0);
|
|
expect(result.factors.changeSize).toBeGreaterThanOrEqual(5);
|
|
});
|
|
|
|
it('should generate mitigation strategies for risky deployments', async () => {
|
|
const metadata = createMockDeploymentMetadata('large');
|
|
const signals = createMockQualitySignals('warning');
|
|
|
|
const task = {
|
|
id: 'task-12',
|
|
type: 'predict-rollback-risk',
|
|
payload: { signals, metadata },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-12',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
expect(result.mitigationStrategies.length).toBeGreaterThan(1);
|
|
expect(result.mitigationStrategies.some(s => s.includes('canary'))).toBe(true);
|
|
});
|
|
|
|
it('should enable automated rollback for high-risk deployments', async () => {
|
|
const metadata = createMockDeploymentMetadata('large');
|
|
const signals = createMockQualitySignals('critical');
|
|
|
|
const task = {
|
|
id: 'task-13',
|
|
type: 'predict-rollback-risk',
|
|
payload: { signals, metadata },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-13',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
if (result.level === 'high' || result.level === 'critical') {
|
|
expect(result.rollbackPlan.automated).toBe(true);
|
|
}
|
|
});
|
|
});
|
|
|
|
// ============================================================================
|
|
// Checklist Validation Tests
|
|
// ============================================================================
|
|
|
|
describe('checklist validation', () => {
|
|
it('should validate deployment checklist and return passed status', async () => {
|
|
const metadata = createMockDeploymentMetadata('small');
|
|
|
|
// Mock quality signals for checklist validation
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.QUALITY_GATE}:evaluation/${metadata.version}`,
|
|
{ status: 'passed' }
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.COVERAGE_ANALYZER}:coverage/${metadata.version}`,
|
|
{ line: 90, branch: 85, function: 88, statement: 89 }
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.TEST_EXECUTOR}:results/${metadata.version}`,
|
|
{ total: 500, passed: 500, failed: 0, skipped: 0 }
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.PERFORMANCE_TESTER}:results/${metadata.version}`,
|
|
{ status: 'passed', p95: 450 }
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.SECURITY_SCANNER}:scan/${metadata.version}`,
|
|
{ vulnerabilities: { critical: 0, high: 0, medium: 2, low: 5 } }
|
|
);
|
|
|
|
const task = {
|
|
id: 'task-14',
|
|
type: 'validate-checklist',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-14',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
expect(result.overallStatus).toMatch(/passed|partial/);
|
|
expect(result.passedCount).toBeGreaterThan(0);
|
|
expect(result.items).toBeDefined();
|
|
expect(result.items.length).toBeGreaterThan(10); // Should have multiple checklist items
|
|
});
|
|
|
|
it('should identify failed checklist items', async () => {
|
|
const metadata = createMockDeploymentMetadata('medium');
|
|
|
|
// Mock failed quality signals
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.QUALITY_GATE}:evaluation/${metadata.version}`,
|
|
{ status: 'failed' }
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.COVERAGE_ANALYZER}:coverage/${metadata.version}`,
|
|
{ line: 70, branch: 65, function: 68, statement: 69 } // Below threshold
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.TEST_EXECUTOR}:results/${metadata.version}`,
|
|
{ total: 500, passed: 450, failed: 50, skipped: 0 } // Failed tests
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.SECURITY_SCANNER}:scan/${metadata.version}`,
|
|
{ vulnerabilities: { critical: 2, high: 5, medium: 10, low: 15 } } // Critical vulns
|
|
);
|
|
|
|
const task = {
|
|
id: 'task-15',
|
|
type: 'validate-checklist',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-15',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const result = await agent.executeTask(assignment);
|
|
|
|
expect(result.overallStatus).toBe('failed');
|
|
expect(result.failedCount).toBeGreaterThan(0);
|
|
const failedItems = result.items.filter(item => item.status === 'failed');
|
|
expect(failedItems.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it('should store checklist result in memory', async () => {
|
|
const metadata = createMockDeploymentMetadata('small');
|
|
|
|
const task = {
|
|
id: 'task-16',
|
|
type: 'validate-checklist',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-16',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
await agent.executeTask(assignment);
|
|
|
|
const stored = await mockMemoryStore.retrieve(
|
|
`aqe/deployment/checklists/${metadata.deploymentId}`
|
|
);
|
|
expect(stored).toBeDefined();
|
|
expect(stored.items).toBeDefined();
|
|
});
|
|
});
|
|
|
|
// ============================================================================
|
|
// Report Generation Tests
|
|
// ============================================================================
|
|
|
|
describe('report generation', () => {
|
|
it('should generate deployment readiness report', async () => {
|
|
const metadata = createMockDeploymentMetadata('small');
|
|
|
|
// First perform readiness check
|
|
const signals = createMockQualitySignals('excellent');
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.QUALITY_GATE}:evaluation/${metadata.version}`,
|
|
signals.qualityGate
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.PERFORMANCE_TESTER}:results/${metadata.version}`,
|
|
signals.performance
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.SECURITY_SCANNER}:scan/${metadata.version}`,
|
|
signals.security
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.COVERAGE_ANALYZER}:coverage/${metadata.version}`,
|
|
signals.coverage
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.TEST_EXECUTOR}:results/${metadata.version}`,
|
|
signals.testResults
|
|
);
|
|
|
|
const checkTask = {
|
|
id: 'task-17',
|
|
type: 'deployment-readiness-check',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
await agent.executeTask({
|
|
id: 'assignment-17',
|
|
task: checkTask,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
});
|
|
|
|
// Now generate report
|
|
const reportTask = {
|
|
id: 'task-18',
|
|
type: 'generate-readiness-report',
|
|
payload: { deploymentId: metadata.deploymentId, format: 'markdown' },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const report = await agent.executeTask({
|
|
id: 'assignment-18',
|
|
task: reportTask,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
});
|
|
|
|
expect(report).toBeDefined();
|
|
expect(report.deploymentId).toBe(metadata.deploymentId);
|
|
expect(report.decision).toBe('GO');
|
|
expect(report.executiveSummary).toBeDefined();
|
|
expect(report.keyMetrics).toBeDefined();
|
|
expect(report.recommendation).toBeDefined();
|
|
});
|
|
|
|
it('should store stakeholder report in memory', async () => {
|
|
const metadata = createMockDeploymentMetadata('small');
|
|
|
|
// Perform readiness check first
|
|
const signals = createMockQualitySignals('good');
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.QUALITY_GATE}:evaluation/${metadata.version}`,
|
|
signals.qualityGate
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.PERFORMANCE_TESTER}:results/${metadata.version}`,
|
|
signals.performance
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.SECURITY_SCANNER}:scan/${metadata.version}`,
|
|
signals.security
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.COVERAGE_ANALYZER}:coverage/${metadata.version}`,
|
|
signals.coverage
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.TEST_EXECUTOR}:results/${metadata.version}`,
|
|
signals.testResults
|
|
);
|
|
|
|
const checkTask = {
|
|
id: 'task-19',
|
|
type: 'deployment-readiness-check',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
await agent.executeTask({
|
|
id: 'assignment-19',
|
|
task: checkTask,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
});
|
|
|
|
const reportTask = {
|
|
id: 'task-20',
|
|
type: 'generate-readiness-report',
|
|
payload: { deploymentId: metadata.deploymentId },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
await agent.executeTask({
|
|
id: 'assignment-20',
|
|
task: reportTask,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
});
|
|
|
|
const stored = await mockMemoryStore.retrieve(
|
|
`aqe/deployment/stakeholder-reports/${metadata.deploymentId}`
|
|
);
|
|
expect(stored).toBeDefined();
|
|
});
|
|
});
|
|
|
|
// ============================================================================
|
|
// Error Handling Tests
|
|
// ============================================================================
|
|
|
|
describe('error handling', () => {
|
|
it('should handle unknown task type', async () => {
|
|
const task = {
|
|
id: 'task-21',
|
|
type: 'unknown-task-type',
|
|
payload: {},
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-21',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
await expect(agent.executeTask(assignment)).rejects.toThrow('Unsupported task type');
|
|
});
|
|
|
|
it('should handle missing deployment data gracefully', async () => {
|
|
const reportTask = {
|
|
id: 'task-22',
|
|
type: 'generate-readiness-report',
|
|
payload: { deploymentId: 'non-existent-deployment' },
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-22',
|
|
task: reportTask,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
await expect(agent.executeTask(assignment)).rejects.toThrow('No readiness check found');
|
|
});
|
|
});
|
|
|
|
// ============================================================================
|
|
// Integration Tests
|
|
// ============================================================================
|
|
|
|
describe('integration with other agents', () => {
|
|
it('should aggregate signals from multiple agents', async () => {
|
|
const metadata = createMockDeploymentMetadata('medium');
|
|
|
|
// Mock signals from different agents
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.QUALITY_GATE}:evaluation/${metadata.version}`,
|
|
{ status: 'passed', score: 90, violations: [] }
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.PERFORMANCE_TESTER}:results/${metadata.version}`,
|
|
{ p95: 450, status: 'passed', errorRate: 0.05 }
|
|
);
|
|
await mockMemoryStore.store(
|
|
`shared:${QEAgentType.SECURITY_SCANNER}:scan/${metadata.version}`,
|
|
{ vulnerabilities: { critical: 0, high: 0, medium: 3, low: 5 }, status: 'passed' }
|
|
);
|
|
|
|
const task = {
|
|
id: 'task-23',
|
|
type: 'aggregate-quality-signals',
|
|
payload: metadata,
|
|
priority: 1,
|
|
status: 'pending'
|
|
};
|
|
|
|
const assignment = {
|
|
id: 'assignment-23',
|
|
task,
|
|
agentId: agent.getStatus().agentId.id,
|
|
assignedAt: new Date(),
|
|
status: 'assigned'
|
|
};
|
|
|
|
const signals = await agent.executeTask(assignment);
|
|
|
|
expect(signals.qualityGate).toBeDefined();
|
|
expect(signals.performance).toBeDefined();
|
|
expect(signals.security).toBeDefined();
|
|
});
|
|
|
|
it('should handle event from quality-gate agent', async () => {
|
|
const eventReceived = new Promise<void>(resolve => {
|
|
// Simulate event handler execution
|
|
setTimeout(() => resolve(), 100);
|
|
});
|
|
|
|
mockEventBus.emit('quality-gate.evaluated', {
|
|
type: 'quality-gate.evaluated',
|
|
data: { version: 'v1.0.0', status: 'passed' }
|
|
});
|
|
|
|
await eventReceived;
|
|
expect(true).toBe(true); // Event was processed
|
|
});
|
|
});
|
|
|
|
// ============================================================================
|
|
// Cleanup Tests
|
|
// ============================================================================
|
|
|
|
describe('cleanup', () => {
|
|
it('should cleanup resources on termination', async () => {
|
|
await agent.terminate();
|
|
|
|
const status = agent.getStatus();
|
|
expect(status.status).toBe(AgentStatus.TERMINATED);
|
|
});
|
|
|
|
it('should save deployment history on cleanup', async () => {
|
|
// Simulate some deployments
|
|
await mockMemoryStore.store('aqe/deployment/history', [
|
|
{ deploymentId: 'deploy-1', success: true, signals: {} },
|
|
{ deploymentId: 'deploy-2', success: false, signals: {} }
|
|
]);
|
|
|
|
await agent.terminate();
|
|
|
|
// Verify history was saved
|
|
const history = await mockMemoryStore.retrieve('aqe/deployment/history');
|
|
expect(history).toBeDefined();
|
|
});
|
|
});
|
|
}); |