8장: AI QA 파이프라인 구축

interface ChangeImpact {
  changedFiles: string[];
  directlyAffectedTests: string[];
  indirectlyAffectedTests: string[];
  riskScore: number;
  recommendation: "full" | "selective" | "smoke";
}
 
async function analyzeImpact(prDiff: string): Promise<ChangeImpact> {
  const changedFiles = parseDiffFiles(prDiff);
 
  // 1단계: 정적 의존성 분석
  const importGraph = await buildImportGraph("src/");
  const directDeps = changedFiles.flatMap((f) =>
    importGraph.getReverseDependencies(f)
  );
 
  // 2단계: 테스트-코드 매핑
  const testMap = await loadTestCoverageMap();
  const directlyAffectedTests = directDeps
    .flatMap((dep) => testMap.getTestsForFile(dep))
    .filter(unique);
 
  // 3단계: AI 기반 간접 영향 추론
  const indirectlyAffectedTests = await predictIndirectImpact(
    changedFiles,
    directlyAffectedTests
  );
 
  // 4단계: 위험도 계산
  const riskScore = calculateRiskScore(changedFiles, {
    defectHistory: await getDefectHistory(changedFiles),
    changeFrequency: await getChangeFrequency(changedFiles),
    complexity: await getComplexity(changedFiles),
  });
 
  return {
    changedFiles,
    directlyAffectedTests,
    indirectlyAffectedTests,
    riskScore,
    recommendation:
      riskScore > 0.8 ? "full" : riskScore > 0.4 ? "selective" : "smoke",
  };
}

interface TestPriority {
  testId: string;
  testFile: string;
  priority: number;
  reasons: string[];
}
 
function prioritizeTests(
  tests: string[],
  context: PrioritizationContext
): TestPriority[] {
  return tests
    .map((testId) => {
      let priority = 0;
      const reasons: string[] = [];
 
      // 최근 실패 이력 (+30점)
      if (context.recentFailures.has(testId)) {
        priority += 30;
        reasons.push("최근 실패 이력 있음");
      }
 
      // 변경 코드 직접 관련 (+25점)
      if (context.directlyAffected.has(testId)) {
        priority += 25;
        reasons.push("변경 코드와 직접 관련");
      }
 
      // 결함 발견 빈도 (+20점)
      const defectCount = context.defectDiscoveryCount.get(testId) ?? 0;
      priority += Math.min(defectCount * 5, 20);
      if (defectCount > 0) {
        reasons.push(`과거 ${defectCount}건 결함 발견`);
      }
 
      // 빠른 테스트 우선 (+15점)
      const duration = context.avgDuration.get(testId) ?? 10000;
      if (duration < 1000) {
        priority += 15;
        reasons.push("빠른 실행 (1초 미만)");
      } else if (duration < 5000) {
        priority += 10;
      }
 
      // 비즈니스 중요도 (+10점)
      if (context.criticalPaths.has(testId)) {
        priority += 10;
        reasons.push("핵심 비즈니스 경로");
      }
 
      return { testId, testFile: testId, priority, reasons };
    })
    .sort((a, b) => b.priority - a.priority);
}

name: AI QA Pipeline
 
on:
  pull_request:
    branches: [main]
 
jobs:
  classify-tests:
    runs-on: ubuntu-latest
    outputs:
      stable-tests: ${{ steps.classify.outputs.stable }}
      flaky-tests: ${{ steps.classify.outputs.flaky }}
    steps:
      - uses: actions/checkout@v4
      - name: Classify tests
        id: classify
        run: |
          node scripts/classify-tests.js \
            --history=test-history.json \
            --threshold=0.2
 
  run-stable:
    needs: classify-tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run stable tests
        run: |
          npx jest --testPathPattern="${{ needs.classify-tests.outputs.stable-tests }}"
 
  run-flaky:
    needs: classify-tests
    runs-on: ubuntu-latest
    continue-on-error: true
    steps:
      - uses: actions/checkout@v4
      - name: Run flaky tests with retries
        run: |
          npx jest \
            --testPathPattern="${{ needs.classify-tests.outputs.flaky-tests }}" \
            --retries=3
      - name: Report flaky results
        if: always()
        run: node scripts/report-flaky.js

interface ShardPlan {
  shards: Array<{
    id: number;
    tests: string[];
    estimatedDuration: number;
  }>;
  totalEstimatedDuration: number;
  parallelSpeedup: number;
}
 
function optimizeShards(
  tests: TestMetadata[],
  maxShards: number
): ShardPlan {
  // 실행 시간 기준으로 테스트를 내림차순 정렬
  const sorted = [...tests].sort(
    (a, b) => b.avgDuration - a.avgDuration
  );
 
  // 최소 힙(min-heap) 기반 로드 밸런싱
  const shards: Array<{ id: number; tests: string[]; totalDuration: number }> =
    Array.from({ length: maxShards }, (_, i) => ({
      id: i,
      tests: [],
      totalDuration: 0,
    }));
 
  for (const test of sorted) {
    // 가장 여유로운 샤드에 테스트 배정
    const lightest = shards.reduce((min, shard) =>
      shard.totalDuration < min.totalDuration ? shard : min
    );
    lightest.tests.push(test.id);
    lightest.totalDuration += test.avgDuration;
  }
 
  const maxDuration = Math.max(...shards.map((s) => s.totalDuration));
  const sequentialDuration = tests.reduce((sum, t) => sum + t.avgDuration, 0);
 
  return {
    shards: shards.map((s) => ({
      id: s.id,
      tests: s.tests,
      estimatedDuration: s.totalDuration,
    })),
    totalEstimatedDuration: maxDuration,
    parallelSpeedup: sequentialDuration / maxDuration,
  };
}

=== PR #1234 결함 예측 ===
 
[위험도 0.87] src/services/payment-processor.ts
  - 순환 복잡도: 28 (권장: 15 이하)
  - 최근 30일 변경: 12회
  - 과거 결함: 4건
  - 이번 변경: +45 / -12 라인
  권장: 집중 코드 리뷰 + 추가 테스트
 
[위험도 0.62] src/api/routes/orders.ts
  - 순환 복잡도: 15
  - 최근 30일 변경: 8회
  - 과거 결함: 2건
  - 이번 변경: +23 / -5 라인
  권장: 일반 코드 리뷰
 
[위험도 0.23] src/utils/format.ts
  - 순환 복잡도: 5
  - 최근 30일 변경: 1회
  - 과거 결함: 0건
  - 이번 변경: +8 / -2 라인
  권장: 표준 프로세스

name: AI QA Pipeline
 
on:
  pull_request:
    branches: [main]
  push:
    branches: [main]
 
env:
  NODE_VERSION: "22"
 
jobs:
  # 1단계: 변경 분석 및 테스트 계획
  analyze:
    runs-on: ubuntu-latest
    outputs:
      test-plan: ${{ steps.plan.outputs.plan }}
      risk-level: ${{ steps.plan.outputs.risk }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - name: Analyze changes and create test plan
        id: plan
        run: |
          node scripts/ai-test-planner.js \
            --base=${{ github.event.pull_request.base.sha }} \
            --head=${{ github.event.pull_request.head.sha }}
 
  # 2단계: 단위 + 통합 테스트 (병렬)
  unit-integration:
    needs: analyze
    runs-on: ubuntu-latest
    strategy:
      matrix:
        shard: [1, 2, 3, 4]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: "pnpm"
 
      - run: pnpm install --frozen-lockfile
      
      - name: Run tests (shard ${{ matrix.shard }})
        run: |
          pnpm test -- \
            --shard=${{ matrix.shard }}/4 \
            --forceExit \
            --ci
 
  # 3단계: E2E 테스트 (위험도 높을 때만)
  e2e:
    needs: [analyze, unit-integration]
    if: needs.analyze.outputs.risk-level == 'high'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: "pnpm"
 
      - run: pnpm install --frozen-lockfile
      - run: npx playwright install --with-deps
 
      - name: Run E2E tests
        run: pnpm test:e2e
 
      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: e2e-results
          path: test-results/
 
  # 4단계: 품질 게이트
  quality-gate:
    needs: [unit-integration, e2e]
    if: always()
    runs-on: ubuntu-latest
    steps:
      - name: Evaluate quality gate
        run: |
          echo "Checking quality gate..."
          node scripts/quality-gate.js \
            --coverage-threshold=80 \
            --mutation-threshold=70