AI 기반 애플리케이션 테스트하기: LLM 통합을 위한 전략

AI 애플리케이션을 테스트하는 것은 전통적인 소프트웨어를 테스트하는 것과 근본적으로 다릅니다. 결정론적(Deterministic)인 출력이 없으며, 프롬프트(Prompt)가 동작을 변화시키고, 예외 케이스(Edge cases)가 기하급수적으로 늘어납니다. 여기 AI 기반 애플리케이션을 위한 견고한 테스트 전략을 구축하는 방법을 소개합니다.

AI 테스트의 과제
전통적인 테스트: 입력(Input) → 함수(Function) → 예상 출력(Expected Output)
AI 테스트: 입력(Input) → 프롬프트(Prompt) + 컨텍스트(Context) → 확률적 출력(Probabilistic Output)

정확한 출력을 단언(Assert)할 수 없습니다. 대신, 속성(Properties)을 테스트해야 합니다.

AI를 위한 속성 기반 테스트 (Property-Based Testing for AI)

// 정확한 출력을 테스트하는 대신, 속성을 테스트합니다.
interface TestCase {
  input: string;
  constraints: Constraint[];
}

interface Constraint {
  type: 'contains' | 'excludes' | 'length' | 'format' | 'json';
  value: string | number | RegExp;
}

async function testAIOutput(testCase: TestCase, actualOutput: string): Promise<boolean> {
  for (const constraint of testCase.constraints) {
    switch (constraint.type) {
      case 'contains':
        if (!actualOutput.includes(constraint.value as string)) return false;
        break;
      case 'excludes':
        if (actualOutput.includes(constraint.value as string)) return false;
        break;
      case 'length':
        if (actualOutput.length > (constraint.value as number)) return false;
        break;
      case 'json':
        try {
          JSON.parse(actualOutput);
        } catch {
          return false;
        }
        break;
    }
  }
  return true;
}

// 테스트 예시
const testCase: TestCase = {
  input: 'Extract the name and email from: John Doe, john@example.com ',
  constraints: [
    { type: 'contains', value: 'John' },
    { type: 'contains', value: ' john@example.com ' },
    { type: 'excludes', value: 'undefined' },
    { type: 'length', value: 100 }
  ]
};

프롬프트 버전 관리 및 회귀 테스트 (Prompt Versioning and Regression Testing)

import hashlib
from datetime import datetime

class PromptRegistry:
    def __init__(self):
        self.prompts = {}

    def register(self, name: str, version: str, prompt: str, test_cases: list):
        key = f"{name}:{version}"
        self.prompts[key] = {
            'prompt': prompt,
            'testcases': test_cases,
            'hash': hashlib.md5(prompt.encode()).hexdigest(),
            'registered': datetime.now()
        }

    def get_prompt(self, name: str, version: 

str) -> str: return self.prompts[f"{name}:{version}"]['prompt'] 

    def regressiontest(self, name: str, newversion: str, llm_client, threshold: float = 0.8) -> bool: 
        """새 버전이 기존 테스트 케이스를 통과하는지 확인합니다.""" 
        old_prompt = self.prompts.get(f"{name}:{version}") 
        if not old_prompt: 
            return True 
        old_passes = 0 
        new_passes = 0 
        for tc in old_prompt['testcases']: 
            oldresult = await llm_client.complete(old_prompt['prompt'] + tc['input']) 
            newresult = await llm_client.complete( self.get_prompt(name, newversion) + tc['input'] ) 
            oldok = await testAIOutput(tc, oldresult) 
            newok = await testAIOutput(tc, newresult) 
            if oldok: old_passes += 1 
            if newok: new_passes += 1 
        # 새 버전은 최소한 기존만큼의 테스트를 통과해야 합니다. 
        return (new_passes / len(old_prompt['test_cases'])) >= threshold 

` 결정론적 출력 테스트 (Deterministic Output Testing) 

구조화된 출력 (Structured outputs)의 경우, 결정론적으로 테스트하십시오: 

`typescript 
import { z } from 'zod'; 

const CodeReviewSchema = z.object({ 
  score: z.number().min(0).max(10), 
  issues: z.array(z.object({ 
    severity: z.enum(['low', 'medium', 'high']), 
    line: z.number(), 
    description: z.string() 
  })), 
  summary: z.string() 
}); 

async function testCodeReview(code: string, expectedScoreRange: [number, number]) { 
  const response = await llm.complete( 
    `Review this code and return JSON: ${code}` 
  ); 
  // 파싱 및 검증 (Parse and validate) 
  const parsed = JSON.parse(response); 
  const validated = CodeReviewSchema.parse(parsed); 
  
  // 결정론적 단언 (Deterministic assertions) 
  console.assert( 
    validated.score >= expectedScoreRange[0] && validated.score <= expectedScoreRange[1], 
    `Score ${validated.score} outside expected range` 
  ); 
  console.assert( validated.issues.length < 20, 'Too many issues reported' ); 
  return validated; 
} 
` 

` 외부 AI 호출 모킹 (Mocking External AI Calls) 

`typescript 
// 단위 테스트 (Unit tests)를 위해 LLM 클라이언트 클래스를 모킹합니다. 
class MockLLMClient { 
  constructor(private fixtures: Map<string, string>) {} 
  async complete(prompt: string): Promise<string> { 
    // 프롬프트 패턴과 일치하는 피스처 (fixture)를 반환합니다. 
    for (const [pattern, response] of this.fixtures) { 
      if (prompt.includes(pattern)) { 
        return response; 
      } 
    } 
    return 'Mock response'; 
  } 
}

async *stream(prompt: string): AsyncGenerator { const response = await this.complete(prompt); for (const char of response) { yield char; } } } // 테스트에서의 사용 const mockClient = new MockLLMClient(new Map([ ['extract email', '{"email": " test@example.com "}'], ['summarize', 'This is a summary of the text.'] ])); // 이제 비즈니스 로직 테스트가 빠르고 결정론적(deterministic)으로 실행됩니다. ` AI 애플리케이션을 위한 카오스 테스팅 (Chaos Testing) `python class AIChaosTests: def testratelimits(self, client): """애플리케이션이 속도 제한 (rate limits)을 유연하게 처리합니까?""" for _ in range(100): try: client.complete("test") except RateLimitError: assert client.retry_count > 0 break else: pytest.fail("100번의 요청 후에도 속도 제한이 발생하지 않았습니다") def testinvalidjson(self, client): """애플리케이션이 LLM으로부터 온 잘못된 형식의 JSON을 처리합니까?""" 잘못된 응답 주입 client.mock_response('{"broken": }') result = safeparsejson(client.complete("test")) assert result is not None # 유연하게 처리됨 def testemptycontext(self, client): """애플리케이션이 빈 컨텍스트 (empty context)를 처리합니까?""" result = client.complete("") assert result is not None def testmaxtokens_respected(self, client): """max_tokens가 실제로 출력을 제한합니까?""" result = client.complete("test", max_tokens=10) assert len(result) <= 50 # ~10 tokens ` 통합 테스트 프레임워크 (Integration Test Framework) `typescript describe('AI Integration Tests', () => { const client = new ClaudeClient(process.env.OFOXAPIKEY); describe('코드 리뷰 기능 (Code Review Feature)', () => { it('구문 오류 (syntax errors)를 식별합니다', async () => { const code = 'const x = ;'; const review = await reviewCode(client, code); expect(review.issues.some(i => i.severity === 'high')).toBe(true); }); it('유효한 코드를 유연하게 처리합니다', async () => { const code = 'const x = 42;'; const review = await reviewCode(client, code); expect(review.issues.filter(i => i.severity === 'high')).toHaveLength(0); }); it('최대 이슈 제한 (max issues limit)을 준수합니다', async () => { const code = '...'; // 대규모 코드 const review = await reviewCode(client, code, { maxIssues: 10 });

expect(review.issues.length).toBeLessThanOrEqual(10); }); }); }); `

테스트 가능한 AI 시스템 구축하기

관심사 분리 (Separate concerns) — 프롬프트 (Prompts)를 코드 내부에 묻어두지 말고 설정 (Config) 파일에 유지하세요.
구조화된 출력 (Structured outputs) — 응답을 제한하기 위해 Zod 또는 JSON Schema를 사용하세요.
폴백 처리 (Fallback handling) — 모든 호출 지점에서 API 실패에 대비한 계획을 세우세요.
스냅샷 테스트 (Snapshot testing) — 회귀 테스트 (Regression)를 위해 예상되는 응답을 저장하세요.

시작하기
ofox.ai를 사용하여 테스트 가능한 AI 애플리케이션을 구축해 보세요 — 이들의 API는 신뢰할 수 있고 일관되어 결정론적 (Deterministic) 테스트 스위트를 구축하기가 더 쉽습니다. 👉 ofox.ai에서 시작하기

이 기사에는 제휴 링크가 포함되어 있습니다.
태그: testing, ai, programming, developer, quality
Canonical URL: https://dev.to/zny10289