AI API Mock Testing: การจำลอง Response สำหรับ Development และ QA

การพัฒนาแอปพลิเคชันที่ใช้ AI API นั้น ความท้าทายหลักคือการทดสอบโดยไม่ต้องเรียก API จริงทุกครั้ง เพราะต้นทุน token มีราคาสูงและ latency ในการเรียกจริงอาจทำให้ CI/CD pipeline ช้าลง ในบทความนี้เราจะมาเรียนรู้วิธีสร้าง mock testing system ที่ช่วยให้ทีมพัฒนาทำงานได้เร็วขึ้นและประหยัดค่าใช้จ่ายอย่างมาก

ทำไมต้องทำ Mock Testing?

สมมติว่าทีมของคุณต้องการทดสอบ feature ใหม่ที่ใช้ GPT-4.1 จำนวน 10 ล้าน tokens/เดือน ลองมาดูการเปรียบเทียบต้นทุนจริง:

โมเดล	ราคา/MTok	10M tokens/เดือน
GPT-4.1	$8.00	$80.00
Claude Sonnet 4.5	$15.00	$150.00
Gemini 2.5 Flash	$2.50	$25.00
DeepSeek V3.2	$0.42	$4.20

เมื่อใช้ HolySheep AI ที่มีอัตรา ¥1=$1 คุณจะประหยัดได้มากกว่า 85% เมื่อเทียบกับราคามาตรฐาน และยังได้ latency ต่ำกว่า 50ms พร้อมระบบชำระเงินผ่าน WeChat/Alipay ที่สะดวก

สร้าง Mock Server ด้วย Python

เริ่มต้นด้วยการสร้าง mock server ที่จำลอง response จาก AI API ทุกตัวได้ โดยใช้ FastAPI

import json
import time
from typing import Generator, Optional
from fastapi import FastAPI, HTTPException, Header
from fastapi.responses import StreamingResponse

app = FastAPI(title="AI API Mock Server")

ฐานข้อมูล mock responses
MOCK_RESPONSES = {
    "gpt-4.1": {
        "model": "gpt-4.1",
        "content": "นี่คือ response จาก GPT-4.1 mock สำหรับการทดสอบ development",
        "latency_ms": 25,
        "tokens": 1500
    },
    "claude-sonnet-4.5": {
        "model": "claude-sonnet-4.5",
        "content": "Claude Sonnet 4.5 mock response พร้อมสำหรับ QA testing",
        "latency_ms": 30,
        "tokens": 1200
    },
    "gemini-2.5-flash": {
        "model": "gemini-2.5-flash",
        "content": "Gemini 2.5 Flash ทำงานเร็วมากใน mock mode",
        "latency_ms": 15,
        "tokens": 800
    },
    "deepseek-v3.2": {
        "model": "deepseek-v3.2",
        "content": "DeepSeek V3.2 mock - ประหยัดและเร็ว",
        "latency_ms": 20,
        "tokens": 1000
    }
}

def simulate_latency(ms: int) -> None:
    """จำลองความหน่วงของ API จริง"""
    time.sleep(ms / 1000.0)

@app.post("/v1/chat/completions")
async def chat_completions(
    request: dict,
    authorization: str = Header(None)
):
    # ตรวจสอบ API key
    if not authorization or not authorization.startswith("Bearer "):
        raise HTTPException(status_code=401, detail="Invalid API key")
    
    model = request.get("model", "gpt-4.1")
    
    # ค้นหา mock response
    mock_key = model.replace(".", "-").replace("_", "-").lower()
    if mock_key not in MOCK_RESPONSES:
        mock_key = "gpt-4.1"  # default
    
    mock_data = MOCK_RESPONSES[mock_key]
    simulate_latency(mock_data["latency_ms"])
    
    # สร้าง response ตาม OpenAI format
    return {
        "id": f"mock-{int(time.time())}",
        "model": model,
        "choices": [{
            "index": 0,
            "message": {
                "role": "assistant",
                "content": mock_data["content"]
            },
            "finish_reason": "stop"
        }],
        "usage": {
            "prompt_tokens": 100,
            "completion_tokens": mock_data["tokens"],
            "total_tokens": 100 + mock_data["tokens"]
        }
    }

@app.get("/health")
async def health():
    return {"status": "healthy", "service": "mock-ai-server"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Client Wrapper สำหรับ HolySheep API

ต่อไปจะสร้าง client wrapper ที่รองรับทั้งโหมด mock และ production โดยใช้ base_url ของ HolySheep

import os
import json
from typing import Optional, Generator, Any

class HolySheepAIClient:
    """
    AI API Client รองรับ mock mode และ production mode
    base_url: https://api.holysheep.ai/v1 (production)
    """
    
    def __init__(
        self,
        api_key: str = None,
        base_url: str = "https://api.holysheep.ai/v1",
        mock_mode: bool = False,
        mock_server_url: str = "http://localhost:8000"
    ):
        self.api_key = api_key or os.getenv("YOUR_HOLYSHEEP_API_KEY", "sk-mock-key")
        self.base_url = base_url if not mock_mode else mock_server_url
        self.mock_mode = mock_mode
        self.usage_log = []
        
    def chat_completions(
        self,
        model: str,
        messages: list,
        temperature: float = 0.7,
        max_tokens: int = 2000,
        **kwargs
    ) -> dict:
        """
        ส่ง request ไปยัง chat completions API
        รองรับทุกโมเดล: gpt-4.1, claude-sonnet-4.5, gemini-2.5-flash, deepseek-v3.2
        """
        import requests
        
        endpoint = f"{self.base_url}/chat/completions"
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        payload = {
            "model": model,
            "messages": messages,
            "temperature": temperature,
            "max_tokens": max_tokens,
            **kwargs
        }
        
        # Log การใช้งาน
        self.usage_log.append({
            "model": model,
            "mock": self.mock_mode,
            "timestamp": self._get_timestamp()
        })
        
        if self.mock_mode:
            print(f"[MOCK MODE] Skipping real API call for {model}")
            return self._get_mock_response(model)
        
        response = requests.post(endpoint, headers=headers, json=payload, timeout=30)
        response.raise_for_status()
        return response.json()
    
    def chat_completions_stream(
        self,
        model: str,
        messages: list,
        **kwargs
    ) -> Generator[str, None, None]:
        """Streaming response สำหรับ real-time applications"""
        import requests
        
        endpoint = f"{self.base_url}/chat/completions"
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        payload = {
            "model": model,
            "messages": messages,
            "stream": True,
            **kwargs
        }
        
        if self.mock_mode:
            mock_response = self._get_mock_response(model)
            content = mock_response["choices"][0]["message"]["content"]
            for char in content:
                yield f'data: {{"choices":[{{"delta":{{"content":"{char}"}}}}]}}\n\n'
            yield "data: [DONE]\n\n"
            return
        
        response = requests.post(endpoint, headers=headers, json=payload, stream=True, timeout=60)
        response.raise_for_status()
        
        for line in response.iter_lines():
            if line:
                yield line.decode('utf-8')
    
    def _get_mock_response(self, model: str) -> dict:
        """สร้าง mock response ตาม model"""
        mock_contents = {
            "gpt-4.1": "นี่คือ response จาก GPT-4.1 ใน mock mode",
            "claude-sonnet-4.5": "Claude Sonnet 4.5 mock response พร้อมใช้งาน",
            "gemini-2.5-flash": "Gemini 2.5 Flash ทำงานเร็วมาก",
            "deepseek-v3.2": "DeepSeek V3.2 mock response สำหรับทดสอบ"
        }
        
        return {
            "id": f"mock-{self._get_timestamp()}",
            "model": model,
            "choices": [{
                "index": 0,
                "message": {
                    "role": "assistant",
                    "content": mock_contents.get(model, mock_contents["gpt-4.1"])
                },
                "finish_reason": "stop"
            }],
            "usage": {
                "prompt_tokens": 100,
                "completion_tokens": 500,
                "total_tokens": 600
            }
        }
    
    @staticmethod
    def _get_timestamp() -> str:
        from datetime import datetime
        return datetime.now().isoformat()
    
    def get_usage_stats(self) -> dict:
        """ดูสถิติการใช้งาน"""
        return {
            "total_requests": len(self.usage_log),
            "mock_requests": sum(1 for log in self.usage_log if log["mock"]),
            "production_requests": sum(1 for log in self.usage_log if not log["mock"]),
            "logs": self.usage_log
        }


ตัวอย่างการใช้งาน
if __name__ == "__main__":
    # Mock mode - สำหรับ development
    client = HolySheepAIClient(mock_mode=True)
    response = client.chat_completions(
        model="gpt-4.1",
        messages=[{"role": "user", "content": "ทดสอบ mock"}]
    )
    print("Mock Response:", response)
    
    # Production mode - ใช้ HolySheep API จริง
    client_prod = HolySheepAIClient(
        api_key="YOUR_HOLYSHEEP_API_KEY",
        mock_mode=False
    )
    print("Usage Stats:", client_prod.get_usage_stats())

Integration กับ pytest สำหรับ QA

ต่อไปจะสร้าง test suite สำหรับ QA team ที่ใช้งานได้ทั้ง mock และ integration testing

import pytest
from unittest.mock import patch, MagicMock
from your_module import HolySheepAIClient

Test fixtures
@pytest.fixture
def mock_client():
    return HolySheepAIClient(mock_mode=True)

@pytest.fixture
def production_client():
    return HolySheepAIClient(
        api_key="YOUR_HOLYSHEEP_API_KEY",
        mock_mode=False
    )

Unit Tests
class TestMockClient:
    """Test cases สำหรับ mock mode"""
    
    def test_chat_completions_returns_valid_response(self, mock_client):
        response = mock_client.chat_completions(
            model="gpt-4.1",
            messages=[{"role": "user", "content": "ทดสอบ"}]
        )
        
        assert "choices" in response
        assert "usage" in response
        assert response["choices"][0]["message"]["role"] == "assistant"
    
    def test_all_models_supported(self, mock_client):
        models = ["gpt-4.1", "claude-sonnet-4.5", "gemini-2.5-flash", "deepseek-v3.2"]
        
        for model in models:
            response = mock_client.chat_completions(
                model=model,
                messages=[{"role": "user", "content": f"ทดสอบ {model}"}]
            )
            assert response["model"] == model
    
    def test_usage_logging(self, mock_client):
        mock_client.chat_completions(
            model="gpt-4.1",
            messages=[{"role": "user", "content": "ทดสอบ"}]
        )
        
        stats = mock_client.get_usage_stats()
        assert stats["total_requests"] == 1
        assert stats["mock_requests"] == 1

Integration Tests (ต้องมี API key จริง)
class TestProductionIntegration:
    """Integration tests ที่ต้องเรียก API จริง"""
    
    @pytest.mark.integration
    def test_real_api_call(self, production_client):
        """ทดสอบ API จริง - รันเมื่อต้องการ"""
        response = production_client.chat_completions(
            model="deepseek-v3.2",
            messages=[{"role": "user", "content": "Hello"}]
        )
        
        assert "choices" in response
        assert "id" in response
        # ใช้ DeepSeek เพราะราคาถูกที่สุด - $0.42/MTok
    
    @pytest.mark.integration
    def test_latency_benchmark(self, production_client):
        """วัดความเร็ว API จริง"""
        import time
        
        start = time.time()
        response = production_client.chat_completions(
            model="gemini-2.5-flash",
            messages=[{"role": "user", "content": "Benchmark test"}]
        )
        elapsed = (time.time() - start) * 1000  # ms
        
        assert elapsed < 5000  # ควรเร็วกว่า 5 วินาที
        print(f"Latency: {elapsed:.2f}ms")

Parametrized tests
@pytest.mark.parametrize("model", [
    "gpt-4.1",
    "claude-sonnet-4.5",
    "gemini-2.5-flash",
    "deepseek-v3.2"
])
def test_model_compatibility(mock_client, model):
    """ทดสอบทุกโมเดลด้วย parameters เดียว"""
    response = mock_client.chat_completions(
        model=model,
        messages=[{"role": "user", "content": "Compatibility test"}]
    )
    
    assert response["model"] == model
    assert len(response["choices"]) > 0

Cost estimation test
def test_cost_estimation():
    """ทดสอบการคำนวณค่าใช้จ่าย"""
    tokens_per_month = 10_000_000  # 10M tokens
    
    prices = {
        "gpt-4.1": 8.00,
        "claude-sonnet-4.5": 15.00,
        "gemini-2.5-flash": 2.50,
        "deepseek-v3.2": 0.42
    }
    
    costs = {model: (tokens_per_month / 1_000_000) * price 
             for model, price in prices.items()}
    
    assert costs["deepseek-v3.2"] == 4.20  # ประหยัดที่สุด
    assert costs["claude-sonnet-4.5"] == 150.00  # แพงที่สุด
    
    # HolySheep ประหยัด 85%+ หมายความว่า DeepSeek จะถูกลงเหลือ ~$0.06/MTok
    holysheep_deepseek_cost = tokens_per_month / 1_000_000 * 0.42 * 0.15
    print(f"HolySheep DeepSeek cost: ${holysheep_deepseek_cost:.2f}")

การใช้งานใน CI/CD Pipeline

สำหรับการตั้งค่าใน GitHub Actions หรือ Jenkins ที่ใช้ HolySheep API จริงเมื่อ deploy

# .github/workflows/ci.yml
name: AI Integration Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      
      - name: Install dependencies
        run: |
          pip install pytest fastapi uvicorn requests
          pip install -e .
      
      - name: Run Mock Tests (สำหรับทุก PR)
        run: |
          pytest tests/ -v -m "not integration" --mock-mode=true
        env:
          HOLYSHEEP_API_KEY: ${{ secrets.HOLYSHEEP_API_KEY }}
      
      - name: Run Integration Tests (merge เท่านั้น)
        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
        run: |
          pytest tests/ -v -m integration --production-mode=true
        env:
          HOLYSHEEP_API_KEY: ${{ secrets.HOLYSHEEP_API_KEY }}
          # ใช้ DeepSeek V3.2 สำหรับ cost-effective integration tests
          TEST_MODEL: 'deepseek-v3.2'
      
      - name: Cost Report
        run: |
          python scripts/calculate_monthly_cost.py --model deepseek-v3.2 --tokens 10000000
        env:
          HOLYSHEEP_API_KEY: ${{ secrets.HOLYSHEEP_API_KEY }}

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

1. Error 401: Invalid API Key

อาการ: ได้รับ error {"error": {"message": "Invalid API key", "type": "invalid_request_error"}}

สาเหตุ: API key ไม่ถูกต้องหรือไม่ได้ส่ง Bearer token อย่างถูกต้อง

วิธีแก้ไข:

# ผิด - ลืม Bearer prefix
headers = {"Authorization": api_key}  # ❌

ถูก - ใส่ Bearer prefix
headers = {"Authorization": f"Bearer {api_key}"}  # ✅

ตรวจสอบว่า base_url ถูกต้อง
client = HolySheepAIClient(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"  # ต้องมี /v1
)

2. Error 429: Rate Limit Exceeded

อาการ: ได้รับ error {"error": {"message": "Rate limit exceeded", "type": "rate_limit_error"}}

สาเหตุ: เรียก API บ่อยเกินไปหรือ quota หมด

วิธีแก้ไข:

import time
from functools import wraps

def retry_with_backoff(max_retries=3, initial_delay=1):
    """decorator สำหรับ retry เมื่อเจอ rate limit"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            delay = initial_delay
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if "rate_limit" in str(e) and attempt < max_retries - 1:
                        print(f"Rate limited. Retrying in {delay}s...")
                        time.sleep(delay)
                        delay *= 2  # exponential backoff
                    else:
                        raise
            return func(*args, **kwargs)
        return wrapper
    return decorator

ใช้งาน
@retry_with_backoff(max_retries=3, initial_delay=2)
def call_ai_api(model: str, messages: list):
    client = HolySheepAIClient(api_key="YOUR_HOLYSHEEP_API_KEY")
    return client.chat_completions(model=model, messages=messages)

3. Mock Response ไม่ตรงกับ Format จริง

อาการ: โค้ดทำงานผ่าน mock แต่พังเมื่อใช้ production

สาเหตุ: Mock response structure ไม่ตรงกับ API จริง

วิธีแก้ไข:

# สร้าง mock ที่ใกล้เคียงจริงมากขึ้น
MOCK_RESPONSE_TEMPLATE = {
    "id": "chatcmpl-mock-123",
    "object": "chat.completion",
    "created": 1234567890,
    "model": "",  # จะถูกแทนที่
    "choices": [{
        "index": 0,
        "message": {
            "role": "assistant",
            "content": ""
        },
        "finish_reason": "stop",
        "logprobs": None  # อย่าลืม field ที่อาจจะมี
    }],
    "usage": {
        "prompt_tokens": 0,
        "completion_tokens": 0,
        "total_tokens": 0
    },
    "service_tier": "standard"
}

def get_realistic_mock(model: str, content: str) -> dict:
    """สร้าง mock ที่ match กับ response format จริง 100%"""
    import time
    return {
        **MOCK_RESPONSE_TEMPLATE,
        "id": f"chatcmpl-mock-{int(time.time() * 1000)}",
        "model": model,
        "created": int(time.time()),
        "choices": [{
            **MOCK_RESPONSE_TEMPLATE["choices"][0],
            "message": {
                "role": "assistant",
                "content": content
            }
        }],
        "usage": {
            "prompt_tokens": len(content) // 4,  # estimate
            "completion_tokens": len(content) // 4,
            "total_tokens": len(content) // 2
        }
    }

4. Streaming Response Parsing Error

อาการ: ได้รับ data ที่ parse ไม่ได้เมื่อใช้ streaming mode

สาเหตุ: การ parse streaming response ผิด format

วิธีแก้ไข:

def parse_streaming_response(stream_generator):
    """parse streaming response อย่างถูกต้อง"""
    buffer = ""
    for line in stream_generator:
        if not line.strip():
            continue
        
        # ข้อมูลจริงจาก API จะเป็น: data: {"choices":[...]}
        if line.startswith("data: "):
            data_str = line[6:]  # ตัด "data: " ออก
            
            if data_str == "[DONE]":
                break
            
            try:
                data = json.loads(data_str)
                # ดึง content จาก delta
                if "choices" in data and len(data["choices"]) > 0:
                    delta = data["choices"][0].get("delta", {})
                    content = delta.get("content", "")
                    if content:
                        yield content
            except json.JSONDecodeError:
                # อาจเป็น incomplete JSON - buffer ไว้
                buffer += data_str
    
    # process remaining buffer
    if buffer:
        try:
            data = json.loads(buffer)
            yield data["choices"][0]["delta"].get("content", "")
        except (json.JSONDecodeError, KeyError):
            pass

การใช้งาน
client = HolySheepAIClient(mock_mode=True)
stream = client.chat_completions_stream(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "ทดสอบ streaming"}]
)
full_response = "".join(parse_streaming_response(stream))
print(f"Full response: {full_response}")

สรุป

การทำ AI API mock testing เป็นสิ่งจำเป็นสำหรับทุกทีมที่พัฒนา application ที่ใช้ AI โดยประโยชน์หลักคือ:

• ประหยัดค่าใช้จ่าย: ใช้ mock สำหรับ development ส่วน production ใช้ HolySheep ที่ราคาถูกกว่า 85%+ เช่น DeepSeek V3.2 ที่เพียง $0.42/MTok
• เร็วขึ้น: ไม่ต้องรอ API response จริงในขั้นตอน development
• เสถียร: CI/CD pipeline ไม่พังเพราะ API ล่ม
• ครอบคลุม: ทดสอบ edge cases ที่ API จริงอาจไม่มี

การตั้งค่าที่แนะนำคือใช้ mock mode เป็น default สำหรับ unit tests และ CI แล้วรัน integration tests กับ HolySheep API จริงเฉพาะตอน merge เท่านั้น แบบนี้จะได้ทั้งความเร็วในการพัฒนาและความมั่นใจว่าโค้ดจะทำงานได้จริง

👉 สมัคร HolySheep AI — รับเครดิตฟรีเมื่อลงทะเบียน