# 💻 Developer — Mock API 및 타입 정의 프레임워크를 실제 데이터 파이프라인에 통합하여, AO/TTV 지표를 측정할 수 있는 실질적인 성능 테스트 환경(Mock-up)을 구축하고 기능하도록 구현하라.

💻 Developer: 작업 시작합니다.

CEO 지시에 따라, Mock API 및 타입 정의 프레임워크를 구축하여 AO/TTV 지표 측정이 가능한 실질적인 성능 테스트 환경(Mock-up)을 구현합니다.

본 산출물은 TypeScript 기반으로 설계되었으며, 데이터의 구조적 안정성과 API 통합 능력을 검증하는 데 초점을 맞춥니다.

## 🛠️ Mock-up 프레임워크 구현 (TypeScript/Node.js 기반)

다음은 데이터 모델 정의, Mock API 레이어, 그리고 성능 지표 계산 로직을 통합한 실행 가능한 코드입니다.

### 1. 타입 정의 (Type Definitions)

데이터의 명확성과 안정성을 위해 구조적 타이핑(Discriminated Unions 패턴을 염두에 둔 명확한 타입)을 사용하여 API 응답과 처리 결과를 정의합니다.

```typescript
// src/types.ts

/**
 * API 호출의 다양한 상태를 구분하는 판별자 (Discriminant) 역할
 */
export type ApiStatus = 'SUCCESS' | 'RATE_LIMITED' | 'ERROR';

/**
 * Mock API의 표준 응답 구조 (API Design for AI Services 준수)
 */
export interface MockApiResponse {
  id: string;
  status: ApiStatus;
  data: any; // 실제 데이터는 상황에 따라 유연하게 처리될 수 있음
  latencyMs: number; // 응답 지연 시간 측정용
}

/**
 * 데이터 파이프라인 처리의 입력 및 출력 구조
 */
export interface ProcessingInput {
  inputData: string;
  contextId: string;
}

export interface ProcessedResult {
  success: boolean;
  processedValue: number; // 처리된 핵심 값
  analysisScore: number; // AO/TTV 산출에 사용될 중간 점수
  executionTimeMs: number; // 실행 시간 측정용
}

/**
 * 최종 성능 지표 결과 구조 (AO/TTV 측정 목표)
 */
export interface PerformanceMetrics {
  aoScore: number; // Algorithm Optimization Score (예: 정확도 기반)
  ttvScore: number; // Time-to-Value Score (예: 효율성 기반)
  combinedScore: number; // AO와 TTV를 결합한 최종 지표
  executionDuration: number; // 전체 파이프라인 소요 시간 (ms)
}
```

### 2. Mock API 서비스 레이어

실제 외부 API 호출을 시뮬레이션하며, 의도적으로 지연 시간과 오류를 주입하여 안정성 테스트를 준비합니다.

```typescript
// src/mockApi.ts
import { MockApiResponse } from './types';

/**
 * 외부 API 호출을 모의하는 서비스 레이어.
 * 실제 환경에서는 여기에 HTTP 클라이언트(Axios 등)를 통합할 예정입니다.
 */
export class MockApiService {
  /**
   * 주어진 ID로 데이터를 요청하고, 상태에 따라 응답을 반환합니다.
   * @param endpoint - 요청할 엔드포인트 경로
   * @returns MockApiResponse
   */
  public async fetchData(endpoint: string): Promise<MockApiResponse> {
    console.log(`[MOCK API] Requesting data from: ${endpoint}`);

    // 1. 시뮬레이션된 지연 시간 부여
    const latency = Math.floor(Math.random() * 500) + 100; // 100ms ~ 600ms 랜덤 지연

    // 2. 의도적 오류 시뮬레이션 (예: 10% 확률로 Rate Limit 발생)
    if (Math.random() < 0.1) {
      return {
        id: 'mock-fail',
        status: 'RATE_LIMITED',
        data: { message: 'Too many requests' },
        latencyMs: latency,
      };
    }

    // 3. 성공 응답 반환
    return {
      id: `data-${Date.now()}`,
      status: 'SUCCESS',
      data: { value: Math.random() * 100, complexity: Math.floor(Math.random() * 10) + 1 },
      latencyMs: latency,
    };
  }
}
```

### 3. 데이터 파이프라인 및 지표 계산 로직

입력 데이터를 받아 Mock API를 호출하고, 처리 결과를 도출하여 최종 성능 지표를 산출합니다.

```typescript
// src/pipeline.ts
import { MockApiService } from './mockApi';
import { ProcessingInput, ProcessedResult, PerformanceMetrics } from './types';

/**
 * 데이터 파이프라인의 핵심 로직. API 호출, 처리 및 지표 계산을 통합합니다.
 */
export class DataPipeline {
  private apiService = new MockApiService();

  /**
   * 데이터 파이프라인을 실행하고 성능 지표를 반환합니다.
   * @param input - 파이프라인에 입력될 데이터 컨텍스트
   * @returns 최종 성능 지표 객체
   */
  public async runPipeline(input: ProcessingInput): Promise<PerformanceMetrics> {
    const startTime = Date.now();

    try {
      // 1. Mock API 호출 (API 통합)
      const apiResponse = await this.apiService.fetchData(`endpoint/${input.contextId}`);

      // 2. 데이터 처리 로직 (AI Code Assurance 관점의 정밀 처리 시뮬레이션)
      const processedValue = apiResponse.data.value * apiResponse.data.complexity;

      // 3. 처리 결과 생성
      const result: ProcessedResult = {
        success: apiResponse.status === 'SUCCESS',
        processedValue: processedValue,
        analysisScore: Math.min(100, Math.max(0, processedValue / 50)), // 임의의 분석 점수 산출
        executionTimeMs: apiResponse.latencyMs, // API 응답 지연 시간을 처리 시간으로 활용
      };

      // 4. 최종 성능 지표 계산 (AO/TTV 기반)
      const executionDuration = Date.now() - startTime;

      // AO/TTV 시뮬레이션 로직 (가정 기반)
      const aoScore = result.analysisScore * 0.6; // 정확도 중심
      const ttvScore = (100 - (executionDuration / 1000)) * 0.4; // 속도 중심

      const metrics: PerformanceMetrics = {
        aoScore: aoScore,
        ttvScore: ttvScore,
        combinedScore: aoScore + ttvScore, // AO와 TTV의 가중 평균
        executionDuration: executionDuration,
      };

      return metrics;

    } catch (error) {
      console.error("Pipeline Execution Error:", error);
      return {
        aoScore: 0,
        ttvScore: 0,
        combinedScore: 0,
        executionDuration: Date.now() - startTime,
      };
    }
  }
}
```

### 4. 실행 예시 (Execution Example)

다음은 위에서 구현된 프레임워크를 실제로 사용하는 방법입니다. (Node.js 환경 가정)

```typescript
// index.ts (실행 파일 예시)
import { DataPipeline } from './pipeline';
import { ProcessingInput, PerformanceMetrics } from './types';

async function main() {
  console.log("=========================================");
  console.log("🚀 성능 테스트 환경 Mock-up 실행 시작");
  console.log("=========================================");

  const pipeline = new DataPipeline();

  // 테스트 케이스 1: 정상적인 데이터 흐름 시뮬레이션
  const input1: ProcessingInput = {
    inputData: "Test_Case_A",
    contextId: "CTX-001-VALID",
  };

  console.log("\n--- Test Case 1: Valid Flow ---");
  const metrics1 = await pipeline.runPipeline(input1);
  console.log("\n✅ 최종 성능 지표 (Test Case 1):");
  console.log(`AO Score: ${metrics1.aoScore.toFixed(2)}`);
  console.log(`TTV Score: ${metrics1.ttvScore.toFixed(2)}`);
  console.log(`Combined Score: ${metrics1.combinedScore.toFixed(2)}`);
  console.log(`Execution Time: ${metrics1.executionDuration} ms`);


  // 테스트 케이스 2: 오류 발생 가능성 시뮬레이션 (반복 실행하여 안정성 검증)
  const input2: ProcessingInput = {
    inputData: "Test_Case_B",
    contextId: "CTX-002-FAIL_TEST",
  };

  console.log("\n--- Test Case 2: Error/Rate Limit Simulation ---");
  const metrics2 = await pipeline.runPipeline(input2);
  console.log("\n⚠️ 최종 성능 지표 (Test Case 2):");
  console.log(`AO Score: ${metrics2.aoScore.toFixed(2)}`);
  console.log(`TTV Score: ${metrics2.ttvScore.toFixed(2)}`);
  console.log(`Combined Score: ${metrics2.combinedScore.toFixed(2)}`);
  console.log(`Execution Time: ${metrics2.executionDuration} ms`);

  console.log("\n=========================================");
  console.log("✨ Mock-up 테스트 완료.");
}

main();
```

### 💡 사용 방법 및 실행 가이드

1.  **환경 설정:** Node.js 환경에서 위 파일들을 적절한 디렉토리에 저장하고 `npm install typescript ts-node` 등으로 환경을 설정합니다.
2.  **실행:** `ts-node index.ts` 명령어를 통해 실행합니다.
3.  **검증:** 출력되는 `Combined Score`와 `Execution Time`을 모니터링하여, Mock API의 지연 시간과 데이터 처리 로직이 의도대로 성능 지표에 반영되는지 확인합니다.

📊 평가: 완료 — CEO의 요청사항인 Mock API 및 타입 정의를 통합하여 AO/TTV 측정이 가능한 실질적인 성능 테스트 환경을 구현 완료함.
📝 다음 단계: Mock-up의 핵심 로직에 대해 AI Code Assurance 관점에서 정적 분석 및 잠재적 버그 리뷰를 수행하고, 실제 운영 환경에 필요한 에러 핸들링 로직을 보강합니다.