DeepSource MCP Server

/** * @vitest-environment node */ import { ErrorCategory } from '../utils/errors/categories.js'; import { MetricThresholdStatus } from '../types/metrics.js'; import { ReportType } from '../deepsource.js'; import { AuthError, NetworkError, ServerError, ClientError, ApiResponse, SuccessResponse, ErrorResponse, PendingRun, RunningRun, SuccessfulRun, FailedRun, TimedOutRun, CancelledRun, SkippedRun, RunState, OwaspTop10Report, SansTop25Report, CodeCoverageReport, IssuesPreventedReport, ComplianceReport, PassingMetric, FailingMetric, MetricState, isErrorOfCategory, isSuccessResponse, isRunInState, isReportOfType, isMetricInState, } from '../types/discriminated-unions.js'; import { asRunId, asBranchName, asCommitOid } from '../types/branded.js'; describe('Discriminated Unions', () => { const runId = asRunId('run-123'); const commitOid = asCommitOid('abcdef123456'); const branchName = asBranchName('main'); describe('ApiError Union', () => { it('should create different error types with correct discriminants', () => { // Auth error const authError: AuthError = { category: ErrorCategory.AUTH, message: 'Invalid API key', token: { present: true, expired: true, }, }; // Network error const networkError: NetworkError = { category: ErrorCategory.NETWORK, message: 'Connection failed', url: 'https://api.deepsource.io', connection: { established: false, timeSpent: 5000, }, }; // Server error const serverError: ServerError = { category: ErrorCategory.SERVER, message: 'Internal server error', statusCode: 500, response: { error: 'unexpected error' }, }; expect(authError.category).toBe(ErrorCategory.AUTH); expect(networkError.category).toBe(ErrorCategory.NETWORK); expect(serverError.category).toBe(ErrorCategory.SERVER); // Type guard should correctly identify error categories expect(isErrorOfCategory(authError, ErrorCategory.AUTH)).toBe(true); expect(isErrorOfCategory(networkError, ErrorCategory.AUTH)).toBe(false); expect(isErrorOfCategory(serverError, ErrorCategory.SERVER)).toBe(true); }); it('should handle errors with metadata', () => { const errorWithMetadata: ClientError = { category: ErrorCategory.CLIENT, message: 'Validation failed', statusCode: 400, metadata: { requestId: '1234', timestamp: new Date().toISOString(), }, validationErrors: { field1: 'Required field', field2: 'Invalid format', }, }; expect(errorWithMetadata.metadata).toBeDefined(); expect(errorWithMetadata.validationErrors).toBeDefined(); expect(errorWithMetadata.validationErrors?.field1).toBe('Required field'); }); }); describe('ApiResponse Union', () => { it('should handle successful responses', () => { const successResponse: SuccessResponse<string> = { success: true, data: 'Response data', }; expect(isSuccessResponse(successResponse)).toBe(true); expect(successResponse.data).toBe('Response data'); }); it('should handle error responses', () => { const errorResponse: ErrorResponse = { success: false, error: { category: ErrorCategory.SERVER, message: 'Server error occurred', }, }; expect(isSuccessResponse(errorResponse)).toBe(false); expect(errorResponse.error.message).toBe('Server error occurred'); }); it('should discriminate based on success property', () => { const handleResponse = (response: ApiResponse<string>): string => { if (isSuccessResponse(response)) { return `Success: ${response.data}`; } else { return `Error: ${response.error.message}`; } }; const successResponse: SuccessResponse<string> = { success: true, data: 'Data received', }; const errorResponse: ErrorResponse = { success: false, error: { category: ErrorCategory.NOT_FOUND, message: 'Resource not found', }, }; expect(handleResponse(successResponse)).toBe('Success: Data received'); expect(handleResponse(errorResponse)).toBe('Error: Resource not found'); }); }); describe('RunState Union', () => { it('should create different run states with correct discriminants', () => { // Pending run const pendingRun: PendingRun = { status: 'PENDING', runId, commitOid, branchName, baseOid: commitOid, createdAt: '2023-05-20T10:00:00Z', updatedAt: '2023-05-20T10:00:00Z', queuePosition: 3, estimatedStartTime: '2023-05-20T10:05:00Z', }; // Running run const runningRun: RunningRun = { status: 'READY', runId, commitOid, branchName, baseOid: commitOid, createdAt: '2023-05-20T10:00:00Z', updatedAt: '2023-05-20T10:05:00Z', progress: 45, currentStage: 'analyzing', estimatedCompletionTime: '2023-05-20T10:15:00Z', }; // Successful run const successfulRun: SuccessfulRun = { status: 'SUCCESS', runId, commitOid, branchName, baseOid: commitOid, createdAt: '2023-05-20T10:00:00Z', updatedAt: '2023-05-20T10:15:00Z', finishedAt: '2023-05-20T10:15:00Z', summary: { occurrencesIntroduced: 5, occurrencesResolved: 10, occurrencesSuppressed: 2, analyzerDistribution: [ { analyzer: 'python', count: 3 }, { analyzer: 'javascript', count: 2 }, ], categoryDistribution: [ { category: 'security', count: 1 }, { category: 'maintainability', count: 4 }, ], }, }; expect(pendingRun.status).toBe('PENDING'); expect(runningRun.status).toBe('READY'); expect(successfulRun.status).toBe('SUCCESS'); // Type guard should correctly identify run states expect(isRunInState<PendingRun>(pendingRun, 'PENDING')).toBe(true); expect(isRunInState<RunningRun>(runningRun, 'READY')).toBe(true); expect(isRunInState<SuccessfulRun>(successfulRun, 'SUCCESS')).toBe(true); expect(isRunInState<FailedRun>(successfulRun, 'FAILURE')).toBe(false); }); it('should handle run state specific properties', () => { // Function that returns different messages based on run state const getRunMessage = (run: RunState): string => { switch (run.status) { case 'PENDING': return `Run ${run.runId} is pending in position ${(run as PendingRun).queuePosition || 'unknown'}`; case 'READY': return `Run ${run.runId} is in progress (${(run as RunningRun).progress || 0}% complete)`; case 'SUCCESS': return `Run ${run.runId} succeeded with ${(run as SuccessfulRun).summary.occurrencesIntroduced} new issues`; case 'FAILURE': return `Run ${run.runId} failed: ${(run as FailedRun).error?.message || 'Unknown error'}`; case 'TIMEOUT': return `Run ${run.runId} timed out after ${(run as TimedOutRun).timeout?.limitSeconds || 'unknown'} seconds`; case 'CANCEL': return `Run ${run.runId} was cancelled by ${(run as CancelledRun).cancelledBy || 'unknown'}`; case 'SKIPPED': return `Run ${run.runId} was skipped: ${(run as SkippedRun).skipReason || 'No reason provided'}`; default: return `Run ${run.runId} has unknown status: ${run.status}`; } }; const pendingRun: PendingRun = { status: 'PENDING', runId, commitOid, branchName, baseOid: commitOid, createdAt: '2023-05-20T10:00:00Z', updatedAt: '2023-05-20T10:00:00Z', queuePosition: 3, }; const failedRun: FailedRun = { status: 'FAILURE', runId, commitOid, branchName, baseOid: commitOid, createdAt: '2023-05-20T10:00:00Z', updatedAt: '2023-05-20T10:05:00Z', finishedAt: '2023-05-20T10:05:00Z', error: { message: 'Permission denied', code: 'ACCESS_DENIED', }, }; expect(getRunMessage(pendingRun)).toBe('Run run-123 is pending in position 3'); expect(getRunMessage(failedRun)).toBe('Run run-123 failed: Permission denied'); }); }); describe('ComplianceReport Union', () => { it('should create different report types with correct discriminants', () => { // OWASP report const owaspReport: OwaspTop10Report = { type: ReportType.OWASP_TOP_10, title: 'OWASP Top 10', currentValue: 85, status: 'PASSING', categories: [ { key: 'A01:2021', title: 'Broken Access Control', issues: { critical: 0, major: 2, minor: 1, total: 3, }, }, { key: 'A02:2021', title: 'Cryptographic Failures', issues: { critical: 1, major: 0, minor: 0, total: 1, }, }, ], }; // Code coverage report const coverageReport: CodeCoverageReport = { type: ReportType.CODE_COVERAGE, title: 'Code Coverage', currentValue: 78.5, status: 'PASSING', coverage: { line: 80.2, branch: 75.6, statement: 81.3, function: 90.0, }, trend: [ { date: '2023-04-20', value: 75.0 }, { date: '2023-05-01', value: 76.2 }, { date: '2023-05-15', value: 78.5 }, ], }; expect(owaspReport.type).toBe(ReportType.OWASP_TOP_10); expect(coverageReport.type).toBe(ReportType.CODE_COVERAGE); // Type guard should correctly identify report types expect(isReportOfType<OwaspTop10Report>(owaspReport, ReportType.OWASP_TOP_10)).toBe(true); expect(isReportOfType<CodeCoverageReport>(coverageReport, ReportType.CODE_COVERAGE)).toBe( true ); expect(isReportOfType<SansTop25Report>(owaspReport, ReportType.SANS_TOP_25)).toBe(false); }); it('should handle report-specific properties', () => { // Function that processes report based on type const getReportSummary = (report: ComplianceReport): string => { switch (report.type) { case ReportType.OWASP_TOP_10: return `OWASP compliance: ${report.currentValue}%, issues in ${(report as OwaspTop10Report).categories.length} categories`; case ReportType.SANS_TOP_25: return `SANS compliance: ${report.currentValue}%`; case ReportType.MISRA_C: return `MISRA-C compliance: ${report.currentValue}%`; case ReportType.CODE_COVERAGE: return `Code coverage: ${report.currentValue}% (Line: ${(report as CodeCoverageReport).coverage.line}%)`; case ReportType.ISSUES_PREVENTED: return `Issues prevented: ${(report as IssuesPreventedReport).prevented.total}`; default: return `Unknown report type: ${report.type}, value: ${report.currentValue}%`; } }; const owaspReport: OwaspTop10Report = { type: ReportType.OWASP_TOP_10, title: 'OWASP Top 10', currentValue: 85, status: 'PASSING', categories: [ { key: 'A01:2021', title: 'Broken Access Control', issues: { critical: 0, major: 2, minor: 1, total: 3, }, }, ], }; const coverageReport: CodeCoverageReport = { type: ReportType.CODE_COVERAGE, title: 'Code Coverage', currentValue: 78.5, status: 'PASSING', coverage: { line: 80.2, branch: 75.6, statement: 81.3, function: 90.0, }, }; expect(getReportSummary(owaspReport)).toBe('OWASP compliance: 85%, issues in 1 categories'); expect(getReportSummary(coverageReport)).toBe('Code coverage: 78.5% (Line: 80.2%)'); }); }); describe('MetricState Union', () => { it('should create different metric states with correct discriminants', () => { // Passing metric const passingMetric: PassingMetric = { shortcode: 'LCV', name: 'Line Coverage', unit: '%', positiveDirection: 'UPWARD', value: 85.2, status: MetricThresholdStatus.PASSING, threshold: 80.0, margin: 5.2, }; // Failing metric const failingMetric: FailingMetric = { shortcode: 'DDP', name: 'Duplicate Code Percentage', unit: '%', positiveDirection: 'DOWNWARD', value: 12.5, status: MetricThresholdStatus.FAILING, threshold: 10.0, gap: 2.5, recommendations: [ 'Extract common code into shared functions', 'Use inheritance or composition to reduce duplication', ], }; expect(passingMetric.status).toBe(MetricThresholdStatus.PASSING); expect(failingMetric.status).toBe(MetricThresholdStatus.FAILING); // Type guard should correctly identify metric states expect(isMetricInState<PassingMetric>(passingMetric, MetricThresholdStatus.PASSING)).toBe( true ); expect(isMetricInState<FailingMetric>(failingMetric, MetricThresholdStatus.FAILING)).toBe( true ); expect(isMetricInState<FailingMetric>(passingMetric, MetricThresholdStatus.FAILING)).toBe( false ); }); it('should handle metric state specific properties', () => { // Function that returns different messages based on metric state const getMetricMessage = (metric: MetricState): string => { switch (metric.status) { case MetricThresholdStatus.PASSING: return `${metric.name} is passing at ${metric.value}${metric.unit} (exceeds threshold by ${(metric as PassingMetric).margin}${metric.unit})`; case MetricThresholdStatus.FAILING: return `${metric.name} is failing at ${metric.value}${metric.unit} (below threshold by ${(metric as FailingMetric).gap}${metric.unit})`; case MetricThresholdStatus.UNKNOWN: return `${metric.name} has no threshold set, current value is ${metric.value}${metric.unit}`; default: return `${metric.name} has unknown status: ${metric.status}, value: ${metric.value}${metric.unit}`; } }; const passingMetric: PassingMetric = { shortcode: 'LCV', name: 'Line Coverage', unit: '%', positiveDirection: 'UPWARD', value: 85.2, status: MetricThresholdStatus.PASSING, threshold: 80.0, margin: 5.2, }; const failingMetric: FailingMetric = { shortcode: 'DDP', name: 'Duplicate Code Percentage', unit: '%', positiveDirection: 'DOWNWARD', value: 12.5, status: MetricThresholdStatus.FAILING, threshold: 10.0, gap: 2.5, }; expect(getMetricMessage(passingMetric)).toBe( 'Line Coverage is passing at 85.2% (exceeds threshold by 5.2%)' ); expect(getMetricMessage(failingMetric)).toBe( 'Duplicate Code Percentage is failing at 12.5% (below threshold by 2.5%)' ); }); }); });