# 💻 Developer — 설계된 테스트 시나리오를 기반으로, 초기 데이터 수집 및 결과 기록을 위한 API 연동 구조 또는 테스트 환경 구축에 필요한 최소한의 기술적 프레임워크(Mock-up)를 설계하세요.

💻 Developer: 작업 시작합니다.

## 🛠️ 테스트 환경 구축 Mock-up (TypeScript/Node.js)

설계된 AO/TTV 테스트 가설을 검증하기 위해, Bundle 결과와 표준(Baseline) 결과를 시뮬레이션하고 정량적 지표를 반환하는 최소한의 API 연동 프레임워크를 설계합니다. 이 Mock-up은 실제 데이터 파이프라인에 통합되어 AO/TTV 지표를 측정하는 기반 역할을 합니다.

### 1. 인터페이스 정의 (Type Definitions)

먼저, 측정하고자 하는 데이터의 구조와 결과를 명확히 정의합니다.

```typescript
// src/types.ts (가정)

/**
 * Bundle 결과의 구조 정의
 */
export interface BundleResult {
    taskId: string;
    stepsTaken: number; // AO 측정 지표: 수행된 단계 수
    accuracyScore: number; // AO 측정 지표: 결과 정확도 점수 (0.0 ~ 1.0)
    timeTakenMs: number; // TTV 측정 지표: 소요 시간 (밀리초)
    timestamp: Date;
}

/**
 * Standard/Competitor 결과의 구조 정의 (Baseline)
 */
export interface StandardResult {
    taskId: string;
    stepsTaken: number; // Baseline 단계 수
    accuracyScore: number; // Baseline 정확도 점수 (0.0 ~ 1.0)
    timeTakenMs: number; // Baseline 소요 시간 (밀리초)
    timestamp: Date;
}

/**
 * 최종 비교 결과 구조 정의
 */
export interface ComparisonReport {
    bundle: BundleResult;
    standard: StandardResult;
    efficiencyRatio: number; // bundle.stepsTaken / standard.stepsTaken (AO 비교용)
    accuracyDelta: number; // bundle.accuracyScore - standard.accuracyScore (정확도 차이)
    timeRatio: number; // bundle.timeTakenMs / standard.timeTakenMs (TTV 비교용)
    reportTimestamp: Date;
}
```

### 2. Mock API Service 구현 (Simulation Layer)

실제 외부 API 호출 대신, 시나리오에 맞춰 데이터를 인위적으로 생성하여 테스트 환경을 구성합니다.

```typescript
// src/TestService.ts

import { BundleResult, StandardResult, ComparisonReport } from './types';

/**
 * 가상의 데이터 생성기 (실제로는 API 호출로 대체됨)
 */
class TestDataSimulator {
    private static generateRandomData(baseSteps: number, baseAccuracy: number, baseTime: number): Omit<BundleResult, 'taskId' | 'timestamp'> {
        // 노이즈를 추가하여 현실적인 변동성을 시뮬레이션합니다.
        const noise = (Math.random() - 0.5) * 0.2; // +/- 10% 변동
        return {
            stepsTaken: Math.round(baseSteps * (1 + noise)),
            accuracyScore: Math.min(1.0, Math.max(0.1, baseAccuracy + (Math.random() - 0.5) * 0.1)), // 정확도 범위 유지
            timeTakenMs: Math.round(baseTime * (1 + noise)),
        };
    }

    /**
     * Bundle 결과 시뮬레이션 (높은 효율성 가정)
     */
    public static generateBundleData(id: string): BundleResult {
        // Bundle은 표준보다 효율적이라고 가정 (Steps 30% 감소 목표)
        const baseSteps = 100; // 표준 대비 높게 설정하여 비교 가능하도록 함
        const baseAccuracy = 0.95; // 높은 정확도 가정
        const baseTime = 5000; // 5초 이내 완료 가정

        return {
            taskId: id,
            stepsTaken: Math.round(baseSteps * 0.7), // 효율성 입증 목표 (예: 70)
            accuracyScore: baseAccuracy + Math.random() * 0.1, // 약간의 변동성 허용
            timeTakenMs: baseTime * 0.5, // 빠른 TTV 입증 목표 (예: 2.5초)
            timestamp: new Date(),
        };
    }

    /**
     * Standard/Competitor 결과 시뮬레이션 (Baseline)
     */
    public static generateStandardData(id: string): StandardResult {
        // 표준은 비교 기준이 되므로 약간 더 비효율적이거나 느리게 설정
        return {
            taskId: id,
            stepsTaken: 100, // 기준 단계 수
            accuracyScore: 0.85 + Math.random() * 0.1, // 기준 정확도
            timeTakenMs: 8000, // 비교 기준 시간
            timestamp: new Date(),
        };
    }

    /**
     * 비교 리포트 생성 함수 (핵심 로직)
     */
    public static generateComparisonReport(bundleData: BundleResult, standardData: StandardResult): ComparisonReport {
        const efficiencyRatio = bundleData.stepsTaken / standardData.stepsTaken;
        const accuracyDelta = bundleData.accuracyScore - standardData.accuracyScore;
        const timeRatio = bundleData.timeTakenMs / standardData.timeTakenMs;

        return {
            bundle: bundleData,
            standard: standardData,
            efficiencyRatio: parseFloat(efficiencyRatio.toFixed(3)),
            accuracyDelta: parseFloat(accuracyDelta.toFixed(3)),
            timeRatio: parseFloat(timeRatio.toFixed(3)),
            reportTimestamp: new Date(),
        };
    }
}

export const TestService = {
    generateComparisonReport: (bundleId: string, standardId: string): ComparisonReport => {
        const bundleData = TestDataSimulator.generateBundleData(bundleId);
        const standardData = TestDataSimulator.generateStandardData(standardId);
        return TestDataSimulator.generateComparisonReport(bundleData, standardData);
    }
};
```

### 3. 사용 예시 (Usage Example)

이 함수를 사용하여 두 시나리오의 성능을 비교하고, 가설 검증에 필요한 핵심 지표를 산출합니다.

```typescript
// src/main.ts (실행 예시)

import { TestService } from './TestService';
import { ComparisonReport } from './types';

console.log("--- 🧪 AO/TTV 테스트 시나리오 실행 ---");

// 1. 테스트 데이터 생성
const bundleReport: ComparisonReport = TestService.generateComparisonReport("BUNDLE_V1", "STANDARD_V1");

console.log("\n✅ Bundle 성능 보고서:");
console.log(`   Bundle Steps: ${bundleReport.bundle.stepsTaken} (목표 대비 효율성 측정)`);
console.log(`   Bundle Accuracy: ${bundleReport.bundle.accuracyScore}`);
console.log(`   Bundle Time (ms): ${bundleReport.bundle.timeTakenMs}`);

console.log("\n🆚 Standard (Baseline) 성능 보고서:");
console.log(`   Standard Steps: ${bundleReport.standard.stepsTaken}`);
console.log(`   Standard Accuracy: ${bundleReport.standard.accuracyScore}`);
console.log(`   Standard Time (ms): ${bundleReport.standard.timeTakenMs}`);


console.log("\n📊 최종 비교 분석:");
console.log("=============================");
console.log(`🚀 효율성 비율 (Steps Ratio): ${bundleReport.efficiencyRatio}x`);
console.log(`✨ 정확도 차이 (Accuracy Delta): ${bundleReport.accuracyDelta}`);
console.log(`⏱️ 시간 비율 (TTV Ratio): ${bundleReport.timeRatio}x`);

// --- 사용법 가이드 ---
console.log("\n\n👉 사용 방법:");
console.log("1. TestService.generateComparisonReport(\"Bundle_ID\", \"Standard_ID\")를 호출하여 비교 리포트를 즉시 얻습니다.");
console.log("2. 이 리포트의 `efficiencyRatio`와 `timeRatio`를 통해 가설 Set A의 승리 기준을 충족했는지 검토합니다.");
```

### 📝 다음 단계: 테스트 환경에 실제 데이터 파이프라인 통합 및 자동화 스크립트 작성