DeepSource MCP Server

/** * @fileoverview Tests for QualityMetrics aggregate */ import { describe, it, expect, beforeEach } from 'vitest'; import { QualityMetrics } from '../quality-metrics.aggregate.js'; import type { CreateQualityMetricsParams, MetricConfiguration, UpdateMetricConfigParams, RecordMeasurementParams, MetricHistoryEntry, } from '../quality-metrics.types.js'; import type { ProjectKey, GraphQLNodeId } from '../../../../types/branded.js'; import { MetricShortcode, MetricKey } from '../../../../models/metrics.js'; import { ThresholdValue } from '../../../value-objects/threshold-value.js'; import { MetricValue } from '../../../value-objects/metric-value.js'; describe('QualityMetrics Aggregate', () => { let validParams: CreateQualityMetricsParams; let projectKey: ProjectKey; let repositoryId: GraphQLNodeId; let configuration: MetricConfiguration; beforeEach(() => { projectKey = 'test-project' as ProjectKey; repositoryId = 'repo-456' as GraphQLNodeId; configuration = { name: 'Line Coverage', description: 'Percentage of lines covered by tests', shortcode: MetricShortcode.LCV, metricKey: MetricKey.AGGREGATE, unit: '%', minAllowed: 0, maxAllowed: 100, positiveDirection: 'UPWARD', isReported: true, isThresholdEnforced: true, threshold: ThresholdValue.createPercentage(80), }; validParams = { projectKey, repositoryId, configuration, }; }); describe('create', () => { it('should create quality metrics with valid parameters', () => { const metrics = QualityMetrics.create(validParams); expect(metrics.projectKey).toBe(projectKey); expect(metrics.repositoryId).toBe(repositoryId); expect(metrics.configuration).toEqual(configuration); expect(metrics.currentValue).toBeNull(); expect(metrics.history).toHaveLength(0); expect(metrics.domainEvents).toHaveLength(1); expect(metrics.domainEvents[0].eventType).toBe('QualityMetricsCreated'); }); it('should create metrics with current value', () => { const currentValue = MetricValue.create(85.5, '%'); const params = { ...validParams, currentValue, }; const metrics = QualityMetrics.create(params); expect(metrics.currentValue).toEqual(currentValue); }); it('should create metrics with history', () => { const history: MetricHistoryEntry[] = [ { value: MetricValue.create(75, '%'), threshold: ThresholdValue.createPercentage(80), thresholdStatus: 'FAILING', commitOid: 'commit1', recordedAt: new Date('2024-01-01'), }, ]; const params = { ...validParams, history, }; const metrics = QualityMetrics.create(params); expect(metrics.history).toHaveLength(1); expect(metrics.history[0]).toEqual(history[0]); }); it('should create composite ID from project key, metric key, and shortcode', () => { const metrics = QualityMetrics.create(validParams); // The ID should be a composite of projectKey:metricKey:shortcode expect(metrics.id).toBe(`${projectKey}:${MetricKey.AGGREGATE}:${MetricShortcode.LCV}`); }); it('should throw error for empty metric name', () => { const params = { ...validParams, configuration: { ...configuration, name: '', }, }; expect(() => QualityMetrics.create(params)).toThrow('Metric name cannot be empty'); }); it('should throw error for whitespace-only metric name', () => { const params = { ...validParams, configuration: { ...configuration, name: ' ', }, }; expect(() => QualityMetrics.create(params)).toThrow('Metric name cannot be empty'); }); it('should throw error when min allowed >= max allowed', () => { const params = { ...validParams, configuration: { ...configuration, minAllowed: 100, maxAllowed: 100, }, }; expect(() => QualityMetrics.create(params)).toThrow( 'Min allowed value must be less than max allowed value' ); }); it('should create metrics without threshold', () => { const params = { ...validParams, configuration: { ...configuration, threshold: null, }, }; const metrics = QualityMetrics.create(params); expect(metrics.configuration.threshold).toBeNull(); }); it('should emit QualityMetricsCreated event with correct payload', () => { const metrics = QualityMetrics.create(validParams); const events = metrics.domainEvents; expect(events).toHaveLength(1); const event = events[0]; expect(event.eventType).toBe('QualityMetricsCreated'); expect(event.payload).toEqual({ projectKey, metricKey: MetricKey.AGGREGATE, shortcode: MetricShortcode.LCV, threshold: 80, }); }); }); describe('fromPersistence', () => { it('should recreate metrics from persistence without events', () => { const currentValue = MetricValue.create(85.5, '%'); const history: MetricHistoryEntry[] = [ { value: MetricValue.create(80, '%'), threshold: ThresholdValue.createPercentage(80), thresholdStatus: 'PASSING', commitOid: 'commit1', recordedAt: new Date('2024-01-01'), }, ]; const persistenceData = { id: `${projectKey}:${MetricKey.AGGREGATE}:${MetricShortcode.LCV}`, projectKey, repositoryId, configuration, currentValue, history, lastUpdated: new Date('2024-01-02'), }; const metrics = QualityMetrics.fromPersistence(persistenceData); expect(metrics.projectKey).toBe(projectKey); expect(metrics.currentValue).toEqual(currentValue); expect(metrics.history).toEqual(history); expect(metrics.domainEvents).toHaveLength(0); // No events when loading expect(metrics.lastUpdated).toEqual(persistenceData.lastUpdated); }); }); describe('threshold management', () => { describe('updateThreshold', () => { it('should update threshold to new value', () => { const metrics = QualityMetrics.create(validParams); metrics.clearEvents(); const newThreshold = ThresholdValue.createPercentage(90); metrics.updateThreshold(newThreshold); expect(metrics.configuration.threshold).toEqual(newThreshold); expect(metrics.domainEvents).toHaveLength(2); // MetricThresholdUpdated + AggregateModified expect(metrics.domainEvents[0].eventType).toBe('MetricThresholdUpdated'); expect(metrics.domainEvents[0].payload).toEqual({ oldThreshold: 80, newThreshold: 90, unit: '%', }); }); it('should allow removing threshold', () => { const metrics = QualityMetrics.create(validParams); metrics.clearEvents(); metrics.updateThreshold(null); expect(metrics.configuration.threshold).toBeNull(); expect(metrics.domainEvents[0].payload).toEqual({ oldThreshold: 80, newThreshold: undefined, unit: '%', }); }); it('should throw error for mismatched units', () => { const metrics = QualityMetrics.create(validParams); const wrongThreshold = ThresholdValue.create(80, 'ms', 0, 1000); expect(() => metrics.updateThreshold(wrongThreshold)).toThrow( "Threshold unit 'ms' does not match metric unit '%'" ); }); it('should throw error for threshold outside allowed range', () => { const metrics = QualityMetrics.create(validParams); const outOfRangeThreshold = ThresholdValue.create(150, '%', 0, 200); expect(() => metrics.updateThreshold(outOfRangeThreshold)).toThrow( 'Threshold value is outside allowed range for this metric' ); }); it('should update lastUpdated timestamp', async () => { const metrics = QualityMetrics.create(validParams); const originalLastUpdated = metrics.lastUpdated; // Wait a bit to ensure timestamp difference await new Promise((resolve) => setTimeout(resolve, 10)); metrics.updateThreshold(ThresholdValue.createPercentage(85)); expect(metrics.lastUpdated.getTime()).toBeGreaterThan(originalLastUpdated.getTime()); }); }); }); describe('configuration management', () => { describe('updateConfiguration', () => { it('should update metric name', () => { const metrics = QualityMetrics.create(validParams); metrics.clearEvents(); const params: UpdateMetricConfigParams = { name: 'Updated Line Coverage', }; metrics.updateConfiguration(params); expect(metrics.configuration.name).toBe('Updated Line Coverage'); expect(metrics.domainEvents[0].eventType).toBe('MetricConfigurationUpdated'); expect(metrics.domainEvents[0].payload).toEqual(params); }); it('should trim metric name', () => { const metrics = QualityMetrics.create(validParams); metrics.updateConfiguration({ name: ' New Name ' }); expect(metrics.configuration.name).toBe('New Name'); }); it('should throw error for empty name update', () => { const metrics = QualityMetrics.create(validParams); expect(() => metrics.updateConfiguration({ name: '' })).toThrow( 'Metric name cannot be empty' ); }); it('should update description', () => { const metrics = QualityMetrics.create(validParams); metrics.updateConfiguration({ description: 'New description' }); expect(metrics.configuration.description).toBe('New description'); }); it('should update isReported flag', () => { const metrics = QualityMetrics.create(validParams); metrics.updateConfiguration({ isReported: false }); expect(metrics.configuration.isReported).toBe(false); }); it('should update isThresholdEnforced flag', () => { const metrics = QualityMetrics.create(validParams); metrics.updateConfiguration({ isThresholdEnforced: false }); expect(metrics.configuration.isThresholdEnforced).toBe(false); }); it('should update multiple fields at once', () => { const metrics = QualityMetrics.create(validParams); metrics.clearEvents(); const params: UpdateMetricConfigParams = { name: 'New Name', description: 'New description', isReported: false, isThresholdEnforced: false, }; metrics.updateConfiguration(params); expect(metrics.configuration.name).toBe('New Name'); expect(metrics.configuration.description).toBe('New description'); expect(metrics.configuration.isReported).toBe(false); expect(metrics.configuration.isThresholdEnforced).toBe(false); expect(metrics.domainEvents).toHaveLength(2); }); it('should not emit event when no changes made', () => { const metrics = QualityMetrics.create(validParams); metrics.clearEvents(); // Update with same values metrics.updateConfiguration({ name: configuration.name, isReported: configuration.isReported, }); expect(metrics.domainEvents).toHaveLength(0); }); it('should update lastUpdated timestamp on change', async () => { const metrics = QualityMetrics.create(validParams); const originalLastUpdated = metrics.lastUpdated; await new Promise((resolve) => setTimeout(resolve, 10)); metrics.updateConfiguration({ name: 'New Name' }); expect(metrics.lastUpdated.getTime()).toBeGreaterThan(originalLastUpdated.getTime()); }); }); }); describe('measurement recording', () => { describe('recordMeasurement', () => { it('should record a new measurement', () => { const metrics = QualityMetrics.create(validParams); metrics.clearEvents(); const params: RecordMeasurementParams = { value: 85.5, commitOid: 'abc123', }; metrics.recordMeasurement(params); expect(metrics.currentValue).not.toBeNull(); expect(metrics.currentValue?.value).toBe(85.5); expect(metrics.currentValue?.unit).toBe('%'); expect(metrics.history).toHaveLength(1); expect(metrics.history[0].commitOid).toBe('abc123'); expect(metrics.domainEvents[0].eventType).toBe('MeasurementRecorded'); }); it('should use provided timestamp', () => { const metrics = QualityMetrics.create(validParams); const customDate = new Date('2024-01-15'); metrics.recordMeasurement({ value: 85.5, commitOid: 'abc123', measuredAt: customDate, }); expect(metrics.history[0].recordedAt).toEqual(customDate); expect(metrics.currentValue?.measuredAt).toEqual(customDate); }); it('should throw error for value outside allowed range', () => { const metrics = QualityMetrics.create(validParams); expect(() => metrics.recordMeasurement({ value: 150, commitOid: 'abc123', }) ).toThrow('Value 150 is outside allowed range [0, 100]'); expect(() => metrics.recordMeasurement({ value: -10, commitOid: 'abc123', }) ).toThrow('Value -10 is outside allowed range [0, 100]'); }); it('should update threshold status in history', () => { const metrics = QualityMetrics.create(validParams); // Record passing value metrics.recordMeasurement({ value: 85, commitOid: 'commit1', }); expect(metrics.history[0].thresholdStatus).toBe('PASSING'); // Record failing value metrics.recordMeasurement({ value: 75, commitOid: 'commit2', }); expect(metrics.history[1].thresholdStatus).toBe('FAILING'); }); it('should handle metrics without threshold', () => { const params = { ...validParams, configuration: { ...configuration, threshold: null, }, }; const metrics = QualityMetrics.create(params); metrics.recordMeasurement({ value: 85, commitOid: 'commit1', }); expect(metrics.history[0].thresholdStatus).toBe('UNKNOWN'); }); it('should trim history to max entries', () => { const metrics = QualityMetrics.create(validParams); // Record more than MAX_HISTORY_ENTRIES (100) for (let i = 0; i < 105; i++) { metrics.recordMeasurement({ value: 80 + (i % 20), commitOid: `commit${i}`, }); } expect(metrics.history).toHaveLength(100); // First entries should be removed expect(metrics.history[0].commitOid).toBe('commit5'); expect(metrics.history[99].commitOid).toBe('commit104'); }); it('should emit MeasurementRecorded event with correct payload', () => { const metrics = QualityMetrics.create(validParams); metrics.clearEvents(); metrics.recordMeasurement({ value: 85.5, commitOid: 'abc123', }); const event = metrics.domainEvents[0]; expect(event.eventType).toBe('MeasurementRecorded'); expect(event.payload).toEqual({ value: 85.5, unit: '%', commitOid: 'abc123', thresholdStatus: 'PASSING', }); }); }); }); describe('compliance evaluation', () => { it('should evaluate as compliant when value meets upward threshold', () => { const metrics = QualityMetrics.create(validParams); metrics.recordMeasurement({ value: 85, commitOid: 'commit1', }); expect(metrics.isCompliant).toBe(true); expect(metrics.thresholdStatus).toBe('PASSING'); }); it('should evaluate as non-compliant when value fails upward threshold', () => { const metrics = QualityMetrics.create(validParams); metrics.recordMeasurement({ value: 75, commitOid: 'commit1', }); expect(metrics.isCompliant).toBe(false); expect(metrics.thresholdStatus).toBe('FAILING'); }); it('should evaluate downward metrics correctly', () => { const params = { ...validParams, configuration: { ...configuration, shortcode: MetricShortcode.DDP, // Duplicate code percentage positiveDirection: 'DOWNWARD' as const, threshold: ThresholdValue.createPercentage(10), // Max 10% duplication }, }; const metrics = QualityMetrics.create(params); // 5% duplication - should pass metrics.recordMeasurement({ value: 5, commitOid: 'commit1', }); expect(metrics.isCompliant).toBe(true); // 15% duplication - should fail metrics.recordMeasurement({ value: 15, commitOid: 'commit2', }); expect(metrics.isCompliant).toBe(false); }); it('should be compliant when no threshold set', () => { const params = { ...validParams, configuration: { ...configuration, threshold: null, }, }; const metrics = QualityMetrics.create(params); metrics.recordMeasurement({ value: 50, commitOid: 'commit1', }); expect(metrics.isCompliant).toBe(true); expect(metrics.thresholdStatus).toBe('UNKNOWN'); }); it('should be compliant when no value recorded', () => { const metrics = QualityMetrics.create(validParams); expect(metrics.isCompliant).toBe(true); expect(metrics.thresholdStatus).toBe('UNKNOWN'); }); describe('evaluateCompliance', () => { it('should evaluate arbitrary values', () => { const metrics = QualityMetrics.create(validParams); expect(metrics.evaluateCompliance(90)).toBe(true); expect(metrics.evaluateCompliance(70)).toBe(false); expect(metrics.evaluateCompliance(80)).toBe(true); // Exactly at threshold }); it('should return true when no threshold', () => { const params = { ...validParams, configuration: { ...configuration, threshold: null, }, }; const metrics = QualityMetrics.create(params); expect(metrics.evaluateCompliance(50)).toBe(true); expect(metrics.evaluateCompliance(0)).toBe(true); }); }); }); describe('trend analysis', () => { describe('getTrend', () => { it('should return null with insufficient data', () => { const metrics = QualityMetrics.create(validParams); expect(metrics.getTrend()).toBeNull(); metrics.recordMeasurement({ value: 80, commitOid: 'commit1', }); expect(metrics.getTrend()).toBeNull(); // Still only 1 entry }); it('should calculate improving trend for upward metrics', () => { const metrics = QualityMetrics.create(validParams); const now = new Date(); const daysAgo = (days: number) => { const date = new Date(now); date.setDate(date.getDate() - days); return date; }; // Record measurements over time metrics.recordMeasurement({ value: 70, commitOid: 'commit1', measuredAt: daysAgo(20), }); metrics.recordMeasurement({ value: 75, commitOid: 'commit2', measuredAt: daysAgo(10), }); metrics.recordMeasurement({ value: 80, commitOid: 'commit3', measuredAt: daysAgo(5), }); metrics.recordMeasurement({ value: 85, commitOid: 'commit4', measuredAt: now, }); const trend = metrics.getTrend(30); expect(trend).not.toBeNull(); expect(trend?.direction).toBe('IMPROVING'); expect(trend?.changePercentage).toBeCloseTo(21.43, 1); // (85-70)/70 * 100 expect(trend?.periodDays).toBe(30); }); it('should calculate degrading trend for upward metrics', () => { const metrics = QualityMetrics.create(validParams); const now = new Date(); const daysAgo = (days: number) => { const date = new Date(now); date.setDate(date.getDate() - days); return date; }; metrics.recordMeasurement({ value: 90, commitOid: 'commit1', measuredAt: daysAgo(20), }); metrics.recordMeasurement({ value: 80, commitOid: 'commit2', measuredAt: now, }); const trend = metrics.getTrend(30); expect(trend?.direction).toBe('DEGRADING'); expect(trend?.changePercentage).toBeCloseTo(-11.11, 1); }); it('should calculate stable trend for minimal changes', () => { const metrics = QualityMetrics.create(validParams); const now = new Date(); const daysAgo = (days: number) => { const date = new Date(now); date.setDate(date.getDate() - days); return date; }; metrics.recordMeasurement({ value: 80, commitOid: 'commit1', measuredAt: daysAgo(20), }); metrics.recordMeasurement({ value: 80.5, commitOid: 'commit2', measuredAt: now, }); const trend = metrics.getTrend(30); expect(trend?.direction).toBe('STABLE'); // Less than 1% change }); it('should handle downward metrics correctly', () => { const params = { ...validParams, configuration: { ...configuration, positiveDirection: 'DOWNWARD' as const, }, }; const metrics = QualityMetrics.create(params); const now = new Date(); const daysAgo = (days: number) => { const date = new Date(now); date.setDate(date.getDate() - days); return date; }; // For downward metrics, decreasing values are improving metrics.recordMeasurement({ value: 20, commitOid: 'commit1', measuredAt: daysAgo(20), }); metrics.recordMeasurement({ value: 15, commitOid: 'commit2', measuredAt: now, }); const trend = metrics.getTrend(30); expect(trend?.direction).toBe('IMPROVING'); // Decreasing is good for downward metrics }); it('should respect period parameter', () => { const metrics = QualityMetrics.create(validParams); const now = new Date(); const daysAgo = (days: number) => { const date = new Date(now); date.setDate(date.getDate() - days); return date; }; // Old measurement outside period metrics.recordMeasurement({ value: 60, commitOid: 'commit1', measuredAt: daysAgo(40), }); // Recent measurements metrics.recordMeasurement({ value: 80, commitOid: 'commit2', measuredAt: daysAgo(20), }); metrics.recordMeasurement({ value: 85, commitOid: 'commit3', measuredAt: now, }); const trend = metrics.getTrend(30); // Only last 30 days // Should only consider last two measurements expect(trend?.changePercentage).toBeCloseTo(6.25, 1); // (85-80)/80 * 100 }); }); }); describe('getters', () => { it('should return immutable configuration', () => { const metrics = QualityMetrics.create(validParams); const config = metrics.configuration; // Verify it's a copy expect(config).not.toBe(configuration); expect(config).toEqual(configuration); }); it('should return history as array', () => { const metrics = QualityMetrics.create(validParams); metrics.recordMeasurement({ value: 80, commitOid: 'commit1', }); metrics.recordMeasurement({ value: 85, commitOid: 'commit2', }); const history = metrics.history; expect(Array.isArray(history)).toBe(true); expect(history).toHaveLength(2); }); }); describe('toPersistence', () => { it('should convert to persistence format', () => { const metrics = QualityMetrics.create(validParams); metrics.recordMeasurement({ value: 85.5, commitOid: 'abc123', }); const persistence = metrics.toPersistence(); expect(persistence).toEqual({ id: `${projectKey}:${MetricKey.AGGREGATE}:${MetricShortcode.LCV}`, projectKey, repositoryId, configuration, currentValue: expect.objectContaining({ value: 85.5, unit: '%', }), history: expect.arrayContaining([ expect.objectContaining({ value: expect.objectContaining({ value: 85.5 }), commitOid: 'abc123', }), ]), lastUpdated: expect.any(Date), }); }); it('should preserve all data through persistence round-trip', () => { const metrics = QualityMetrics.create(validParams); metrics.recordMeasurement({ value: 75, commitOid: 'commit1', }); metrics.updateThreshold(ThresholdValue.createPercentage(70)); metrics.recordMeasurement({ value: 85, commitOid: 'commit2', }); const persistence = metrics.toPersistence(); const reconstructed = QualityMetrics.fromPersistence(persistence); expect(reconstructed.projectKey).toBe(metrics.projectKey); expect(reconstructed.configuration).toEqual(metrics.configuration); expect(reconstructed.currentValue?.value).toBe(85); expect(reconstructed.history).toHaveLength(2); expect(reconstructed.lastUpdated).toEqual(metrics.lastUpdated); }); }); describe('domain events', () => { it('should accumulate multiple events', () => { const metrics = QualityMetrics.create(validParams); metrics.clearEvents(); metrics.updateThreshold(ThresholdValue.createPercentage(90)); metrics.recordMeasurement({ value: 95, commitOid: 'commit1', }); metrics.updateConfiguration({ name: 'New Name' }); // Each operation emits 2 events (operation + AggregateModified) expect(metrics.domainEvents).toHaveLength(6); const eventTypes = metrics.domainEvents.map((e) => e.eventType); expect(eventTypes).toEqual([ 'MetricThresholdUpdated', 'AggregateModified', 'MeasurementRecorded', 'AggregateModified', 'MetricConfigurationUpdated', 'AggregateModified', ]); }); }); describe('edge cases', () => { it('should handle all metric shortcodes', () => { const shortcodes = [ MetricShortcode.LCV, MetricShortcode.BCV, MetricShortcode.DCV, MetricShortcode.DDP, MetricShortcode.SCV, MetricShortcode.TCV, MetricShortcode.CMP, ]; shortcodes.forEach((shortcode) => { const params = { ...validParams, configuration: { ...configuration, shortcode, }, }; const metrics = QualityMetrics.create(params); expect(metrics.configuration.shortcode).toBe(shortcode); }); }); it('should handle all metric keys', () => { const metricKeys = [ MetricKey.AGGREGATE, MetricKey.PYTHON, MetricKey.JAVASCRIPT, MetricKey.TYPESCRIPT, MetricKey.GO, MetricKey.JAVA, MetricKey.RUBY, MetricKey.RUST, ]; metricKeys.forEach((metricKey) => { const params = { ...validParams, configuration: { ...configuration, metricKey, }, }; const metrics = QualityMetrics.create(params); expect(metrics.configuration.metricKey).toBe(metricKey); }); }); it('should handle negative value ranges', () => { const params = { ...validParams, configuration: { ...configuration, minAllowed: -100, maxAllowed: 100, threshold: ThresholdValue.create(0, 'delta', -100, 100), }, }; const metrics = QualityMetrics.create(params); metrics.recordMeasurement({ value: -50, commitOid: 'commit1', }); expect(metrics.currentValue?.value).toBe(-50); }); it('should handle exact threshold values', () => { const metrics = QualityMetrics.create(validParams); // Record value exactly at threshold metrics.recordMeasurement({ value: 80, commitOid: 'commit1', }); expect(metrics.isCompliant).toBe(true); // Threshold is inclusive expect(metrics.thresholdStatus).toBe('PASSING'); }); }); });