ในฐานะนักพัฒนาที่เคยต้อง deploy ระบบ AI Customer Service สำหรับ e-commerce ที่มี SKU มากกว่า 50,000 รายการ ผมเจอปัญหาหลักอย่างนึงคือ การทดสอบ AI response กับหลาย scenario แบบ manual นั้นใช้เวลาเป็นวันๆ และ error-prone มาก วันนี้ผมจะมาแชร์วิธีที่ผมใช้ Pytest Parameterized Testing ร่วมกับ HolySheep AI เพื่อทดสอบ AI customer service responses อย่างมีประสิทธิภาพ

ทำไมต้อง Parameterized Testing สำหรับ AI API?

ลองนึกภาพ scenario นี้: ระบบ customer service ของ e-commerce ต้องตอบคำถามหลายรูปแบบ เช่น สถานะคำสั่งซื้อ, การคืนสินค้า, การสอบถามสินค้า, และการจัดการ complaint ถ้าเราเขียน test case แยกสำหรับแต่ละ scenario แบบ manual เราจะมีโค้ดซ้ำซ้อนเยอะมาก และเมื่อ business logic เปลี่ยน เราต้องแก้ test หลายจุด

Parameterized testing ช่วยให้เรา:

Setup Environment และ Dependencies

ก่อนอื่น install dependencies ที่ต้องใช้:

pip install pytest pytest-xdist httpx openai rich

โครงสร้างโปรเจกต์ที่ผมใช้:

ecommerce-ai-testing/
├── tests/
│   ├── __init__.py
│   ├── conftest.py
│   ├── test_customer_service.py
│   └── fixtures/
│       └── test_scenarios.json
├── src/
│   ├── __init__.py
│   └── ai_client.py
└── pytest.ini

สร้าง HolySheep AI Client Module

นี่คือ AI client ที่ใช้ HolySheep API โดยเฉพาะ ราคาถูกมากเพียง $0.42/MTok สำหรับ DeepSeek V3.2 และ latency ต่ำกว่า 50ms:

import os
from typing import Optional
from openai import OpenAI

class HolySheepAIClient:
    """AI Client สำหรับเชื่อมต่อกับ HolySheep AI API"""
    
    BASE_URL = "https://api.holysheep.ai/v1"
    
    def __init__(self, api_key: Optional[str] = None):
        self.api_key = api_key or os.environ.get("HOLYSHEEP_API_KEY")
        if not self.api_key:
            raise ValueError("API key is required. Get yours at https://www.holysheep.ai/register")
        
        self.client = OpenAI(
            api_key=self.api_key,
            base_url=self.BASE_URL
        )
    
    def chat(
        self,
        messages: list[dict],
        model: str = "deepseek-v3.2",
        temperature: float = 0.7,
        max_tokens: int = 500
    ) -> str:
        """ส่งข้อความไปยัง AI และรับ response"""
        response = self.client.chat.completions.create(
            model=model,
            messages=messages,
            temperature=temperature,
            max_tokens=max_tokens
        )
        return response.choices[0].message.content
    
    def customer_service_response(
        self,
        user_query: str,
        context: dict
    ) -> str:
        """สร้าง response สำหรับ customer service"""
        
        system_prompt = f"""คุณคือ AI customer service ของร้านค้าออนไลน์
        ข้อมูลลูกค้า: {context.get('customer_info', 'N/A')}
        ประวัติการสั่งซื้อ: {context.get('order_history', 'N/A')}
        สินค้าที่สนใจ: {context.get('product_catalog', 'N/A')}
        
        กรุณาตอบลูกค้าอย่างเป็นมิตร ให้ข้อมูลถูกต้อง และช่วยแก้ปัญหาได้"""
        
        messages = [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_query}
        ]
        
        return self.chat(messages, model="deepseek-v3.2", temperature=0.3)

เขียน Parameterized Test สำหรับ AI Customer Service

นี่คือหัวใจของบทความนี้ การใช้ @pytest.mark.parametrize ร่วมกับ fixture ที่มีหลาย test cases:

import pytest
import json
from src.ai_client import HolySheepAIClient


ข้อมูล test scenarios สำหรับ customer service

TEST_SCENARIOS = [
    {
        "id": "order_status_inquiry",
        "category": "สอบถามสถานะคำสั่งซื้อ",
        "user_query": "ติดตามสถานะคำสั่งซื้อ #ORD-2024-12345",
        "expected_keywords": ["สถานะ", "จัดส่ง", "OR-D"],
        "context": {
            "customer_info": "ลูกค้าสมาชิกระดับ Gold",
            "order_history": "ORD-2024-12345: กำลังจัดส่ง",
            "product_catalog": "Electronics"
        }
    },
    {
        "id": "return_request",
        "category": "ขอคืนสินค้า",
        "user_query": "ต้องการคืนสินค้าที่สั่งซื้อเมื่อ 5 วันก่อน",
        "expected_keywords": ["คืน", "ระยะเวลา", "7 วัน", "นโยบาย"],
        "context": {
            "customer_info": "ลูกค้าใหม่",
            "order_history": "ORD-2024-12340: จัดส่งสำเร็จ 5 วันก่อน",
            "product_catalog": "เสื้อผ้า"
        }
    },
    {
        "id": "product_inquiry",
        "category": "สอบถามสินค้า",
        "user_query": "iPhone 15 Pro มีสีอะไรบ้าง และราคาเท่าไหร่?",
        "expected_keywords": ["iPhone", "สี", "ราคา"],
        "context": {
            "customer_info": "ลูกค้าทั่วไป",
            "order_history": "ไม่มี",
            "product_catalog": "iPhone 15 Pro: สีดำ, ขาว, ฟ้า, ไทเทเนียม - ราคา 45,900 บาท"
        }
    },
    {
        "id": "complaint_handling",
        "category": "ร้องเรียน",
        "user_query": "สินค้าที่ได้รับเป็นรอย ไม่ตรงกับรูปที่สั่ง",
        "expected_keywords": ["ขออภัย", "เยียวยา", "แก้ไข"],
        "context": {
            "customer_info": "ลูกค้าสมาชิกระดับ Silver",
            "order_history": "ORD-2024-12350: จัดส่งวันนี้",
            "product_catalog": "กระเป๋าแบรนด์เนม"
        }
    },
    {
        "id": "promotion_inquiry",
        "category": "สอบถามโปรโมชั่น",
        "user_query": "มีโปรโมชั่นลดราคาช่วงสิ้นปีไหม?",
        "expected_keywords": ["โปรโมชั่น", "ลดราคา", "สิ้นปี"],
        "context": {
            "customer_info": "ลูกค้าทั่วไป",
            "order_history": "ORD-2024-12320: สั่งซื้อ 2 เดือนก่อน",
            "product_catalog": "สินค้าทุกประเภท"
        }
    }
]

@pytest.fixture
def ai_client():
    """Fixture สำหรับ AI client - ใช้ HolySheep AI"""
    return HolySheepAIClient()

@pytest.fixture
def test_scenarios():
    """Fixture สำหรับ test scenarios"""
    return TEST_SCENARIOS

@pytest.mark.parametrize("scenario", TEST_SCENARIOS, ids=lambda s: f"{s['id']}")
def test_ai_customer_service_response(ai_client, scenario):
    """
    Parameterized test สำหรับ AI customer service responses
    
    Test นี้จะ run 5 ครั้ง (หรือมากกว่าถ้าเพิ่ม scenario)
    โดยแต่ละครั้งจะใช้ input ต่างกัน
    """
    # Arrange
    user_query = scenario["user_query"]
    context = scenario["context"]
    expected_keywords = scenario["expected_keywords"]
    
    # Act
    response = ai_client.customer_service_response(user_query, context)
    
    # Assert - ตรวจสอบว่า response มี keywords ที่คาดหวัง
    response_lower = response.lower()
    
    for keyword in expected_keywords:
        assert keyword.lower() in response_lower, \
            f"Response ของ scenario '{scenario['id']}' ไม่มี keyword '{keyword}'\n" \
            f"Response: {response[:200]}..."

@pytest.mark.parametrize("scenario", TEST_SCENARIOS, ids=lambda s: f"{s['id']}")
def test_ai_response_not_empty(ai_client, scenario):
    """Test ว่า AI response ไม่ว่างเปล่า"""
    response = ai_client.customer_service_response(
        scenario["user_query"],
        scenario["context"]
    )
    assert response, f"Response ว่างเปล่าสำหรับ scenario: {scenario['id']}"
    assert len(response) > 10, f"Response สั้นเกินไป: {response}"

Advanced: Dynamic Parameterized Testing จาก JSON

สำหรับโปรเจกต์ขนาดใหญ่ ผมแนะนำให้เก็บ test scenarios ไว้ในไฟล์ JSON แยก เพื่อให้ PM หรือ QA สามารถเพิ่ม test case ได้โดยไม่ต้องแก้โค้ด:

# tests/fixtures/test_scenarios.json
{
    "customer_service": [
        {
            "id": "cs_001",
            "category": "สอบถามสถานะ",
            "user_query": "คำสั่งซื้อของฉันถึงไหนแล้ว?",
            "expected_keywords": ["สถานะ", "ติดตาม"],
            "response_should_not_contain": ["ขอโทษ", "ไม่พบ"],
            "context": {
                "customer_info": "ลูกค้าสมาชิก",
                "order_history": "ORD-2024-001",
                "product_catalog": "ทั่วไป"
            }
        },
        {
            "id": "cs_002", 
            "category": "เปลี่ยนที่อยู่",
            "user_query": "เปลี่ยนที่อยู่จัดส่งเป็น 123 ถนนสุขุม ซอย 5",
            "expected_keywords": ["ที่อยู่", "ยืนยัน"],
            "response_should_not_contain": [],
            "context": {
                "customer_info": "ลูกค้าสมาชิก VIP",
                "order_history": "ORD-2024-002: รอจัดส่ง",
                "product_catalog": "เครื่องใช้ไฟฟ้า"
            }
        }
    ],
    "product_recommendation": [
        {
            "id": "rec_001",
            "category": "แนะนำสินค้า",
            "user_query": "แนะนำของขวัญวันเกิดให้หน่อย งบ 1000 บาท",
            "expected_keywords": ["ของขวัญ", "แนะนำ"],
            "context": {
                "customer_info": "ลูกค้าอายุ 30 ปี",
                "order_history": "ชอบเครื่องสำอาง",
                "product_catalog": "ของขวัญ ราคา 500-1500 บาท"
            }
        }
    ]
}


conftest.py - โหลด JSON fixtures

import json
import pytest
from pathlib import Path

def load_test_scenarios():
    """โหลด test scenarios จาก JSON file"""
    fixtures_path = Path(__file__).parent / "fixtures" / "test_scenarios.json"
    with open(fixtures_path, "r", encoding="utf-8") as f:
        return json.load(f)

@pytest.fixture(scope="session")
def test_scenarios():
    return load_test_scenarios()


test_dynamic_scenarios.py

import pytest
from src.ai_client import HolySheepAIClient

def pytest_generate_tests(metafunc):
    """Dynamic test generation จาก JSON"""
    if "scenario" in metafunc.fixturenames:
        scenarios = load_test_scenarios()
        
        # Flatten all scenarios from different categories
        all_scenarios = []
        for category, cases in scenarios.items():
            for case in cases:
                case["_category"] = category
                all_scenarios.append(case)
        
        metafunc.parametrize("scenario", all_scenarios, 
                           ids=lambda s: f"{s.get('_category', 'unknown')}/{s['id']}")

รัน Tests และดู Coverage

รัน tests ด้วย pytest พร้อม verbose output และ coverage report:

# รันเฉพาะ customer service tests
pytest tests/test_customer_service.py -v --tb=short


รันพร้อม coverage

pytest tests/ -v --cov=src --cov-report=html --cov-report=term


รัน parallel (เร็วขึ้น)

pytest tests/ -v -n auto


รันเฉพาะ scenario ที่ fail

pytest tests/ --lf -v

Output ที่ได้จะหน้าตาประมาณนี้:

tests/test_customer_service.py::test_ai_customer_service_response[order_status_inquiry] PASSED
tests/test_customer_service.py::test_ai_customer_service_response[return_request] PASSED
tests/test_customer_service.py::test_ai_customer_service_response[product_inquiry] PASSED
tests/test_customer_service.py::test_ai_customer_service_response[complaint_handling] PASSED
tests/test_customer_service.py::test_ai_customer_service_response[promotion_inquiry] PASSED
tests/test_customer_service.py::test_ai_response_not_empty[order_status_inquiry] PASSED
...
======================== 15 passed in 12.34s ========================

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

1. API Key Not Found Error

ปัญหา: เมื่อรัน test แล้วเจอ error ValueError: API key is required

สาเหตุ: Environment variable HOLYSHEEP_API_KEY ไม่ได้ถูก set

วิธีแก้: สร้างไฟล์ .env ในโปรเจกต์แล้วใส่ API key:

# .env file
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY

จากนั้นติดตั้ง python-dotenv และโหลดใน conftest.py:

# conftest.py
import os
from dotenv import load_dotenv

load_dotenv()  # โหลด .env file

@pytest.fixture(scope="session")
def ai_client():
    return HolySheepAIClient()

2. Rate Limit Error (429)

ปัญหา: เมื่อรัน parameterized tests หลายตัวพร้อมกัน เจอ error RateLimitError: 429

สาเหตุ: HolySheep API มี rate limit ต่อ second ถ้ารัน parallel tests เกิน

วิธีแก้: เพิ่ม delay ระหว่าง requests หรือใช้ semaphore เพื่อจำกัด concurrent requests:

import asyncio
import pytest


ใน conftest.py

@pytest.fixture(scope="session")
def rate_limiter():
    """Rate limiter สำหรับ API calls"""
    import threading
    semaphore = threading.Semaphore(3)  # อนุญาต max 3 concurrent calls
    
    def wait_and_acquire():
        semaphore.acquire()
        import time
        time.sleep(0.5)  # delay 500ms ระหว่าง requests
        return semaphore.release
    
    return wait_and_acquire

@pytest.fixture
def ai_client_with_rate_limit(rate_limiter):
    """AI client ที่มี rate limiting"""
    def get_response(*args, **kwargs):
        rate_limiter()
        client = HolySheepAIClient()
        return client.chat(*args, **kwargs)
    return get_response

3. Test Fails เพราะ Model Response ไม่ Consistent

ปัญหา: Test บางตัว fail เพราะ AI response มีความไม่ consistent กันในแต่ละ run

สาเหตุ: Temperature สูงเกินไป ทำให้ output ไม่ deterministic

วิธีแก้: ลด temperature ลงและใช้ response structure ที่ consistent มากขึ้น:

# แก้ไขใน ai_client.py
def chat(self, messages: list[dict], model: str = "deepseek-v3.2", 
         temperature: float = 0.1,  # ลดจาก 0.7 เป็น 0.1
         max_tokens: int = 500) -> str:
    """ส่งข้อความไปยัง AI ด้วย temperature ต่ำสำหรับ consistent output"""
    response = self.client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=temperature,  # 0.0-0.2 สำหรับ deterministic output
        max_tokens=max_tokens
    )
    return response.choices[0].message.content


หรือใช้ structured output ผ่าน response_format

def chat_structured(self, messages: list[dict], 
                   expected_format: dict) -> dict:
    """รับ structured JSON response ที่ consistent"""
    response = self.client.chat.completions.create(
        model="deepseek-v3.2",
        messages=messages,
        response_format={"type": "json_object"},
        temperature=0.1
    )
    return json.loads(response.choices[0].message.content)

4. Context Overflow Error

ปัญหา: เมื่อ context มีข้อมูลมากเกินไป เจอ error ContextLengthExceeded

สาเหตุ: Context ที่ส่งให้ AI ใหญ่เกินกว่า token limit ของ model

วิธีแก้: Truncate context ให้มีขนาดเหมาะสม:

import tiktoken

def truncate_context(context: dict, max_tokens: int = 2000) -> dict:
    """Truncate context ให้ไม่เกิน token limit"""
    # ใช้ cl100k_base tokenizer สำหรับ models ที่ใช้ GPT-4 tokenizer
    encoder = tiktoken.get_encoding("cl100k_base")
    
    context_str = json.dumps(context, ensure_ascii=False)
    tokens = encoder.encode(context_str)
    
    if len(tokens) > max_tokens:
        # Truncate และเพิ่ม indicator
        truncated_tokens = tokens[:max_tokens-50]  # เผื่อ 50 tokens สำหรับ indicator
        truncated_str = encoder.decode(truncated_tokens)
        context_str = truncated_str + '\n[...truncated...]'
        return json.loads(context_str)
    
    return context

@pytest.fixture
def ai_client():
    return HolySheepAIClient()

@pytest.mark.parametrize("scenario", TEST_SCENARIOS)
def test_ai_with_safe_context(ai_client, scenario):
    """Test ที่ใช้ truncated context เพื่อป้องกัน overflow"""
    safe_context = truncate_context(scenario["context"], max_tokens=1500)
    
    response = ai_client.customer_service_response(
        scenario["user_query"],
        safe_context
    )
    
    assert response, "Response should not be empty"

สรุป

Parameterized testing กับ pytest เป็นเครื่องมือที่ทรงพลังมากสำหรับการทดสอบ AI API อย่างเป็นระบบ โดยเฉพาะเมื่อใช้ร่วมกับ HolySheep AI ที่มีราคาประหยัดมากเพียง $0.42/MTok สำหรับ DeepSeek V3.2 รวมถึง GPT-4.1 ที่ $8/MTok และ Claude Sonnet 4.5 ที่ $15/MTok เมื่อเทียบกับราคาต้นทางแล้ว ประหยัดได้ถึง 85%+

Key takeaways จากบทความนี้:

ด้วย approach นี้ ทีมของผมสามารถทดสอบ AI customer service responses ได้ครอบคลุมมากขึ้น รัน test อัตโนมัติใน CI/CD pipeline และมั่นใจได้ว่า AI responses ตรงตาม requirements ทุก scenario

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

แหล่งข้อมูลที่เกี่ยวข้อง

บทความที่เกี่ยวข้อง