AI API Mock Testing: Hướng Dẫn Toàn Diện Cho Development và QA

Là một senior backend engineer với hơn 8 năm kinh nghiệm triển khai hệ thống AI, tôi đã trải qua vô số lần "đau đầu" khi phải test API AI mà không có môi trường staging hoàn chỉnh. Chi phí API chính hãng quá cao, các dịch vụ relay thì không đáng tin cậy, và việc mock thủ công tốn quá nhiều thời gian. Hôm nay, tôi sẽ chia sẻ giải pháp tối ưu mà tôi đã áp dụng thành công trong 15+ dự án production.

Tại Sao Mock Testing Quan Trọng?

Trước khi đi vào chi tiết kỹ thuật, hãy xem tại sao mock testing lại là "chìa khóa vàng" cho development và QA:

• Tiết kiệm chi phí: Không phải trả $0.03-0.12/1K tokens mỗi lần chạy test suite
• Tốc độ phát triển: Response tức thì thay vì chờ 200-500ms mỗi request
• Reproducibility: Luôn nhận được response nhất quán để debug
• Offline development: Làm việc không cần internet
• Edge case testing: Dễ dàng test các scenario hiếm gặp

So Sánh: HolySheep vs API Chính Thức vs Dịch Vụ Relay

Tiêu chí	HolySheep AI	API Chính Thức	Dịch Vụ Relay
Giá GPT-4.1	$8/MTok (¥1=$1)	$60/MTok	$15-40/MTok
Giá Claude Sonnet 4.5	$15/MTok	$90/MTok	$25-60/MTok
Giá Gemini 2.5 Flash	$2.50/MTok	$15/MTok	$5-12/MTok
DeepSeek V3.2	$0.42/MTok	$1/MTok	$0.6-1.5/MTok
Độ trễ trung bình	<50ms	200-500ms	100-300ms
Mock/Testing mode	✅ Có	❌ Không	⚠️ Hạn chế
Thanh toán	WeChat/Alipay/Visa	Card quốc tế	Thẻ quốc tế
Tín dụng miễn phí	✅ Có	❌ Không	⚠️ Hiếm khi

Như bạn thấy, HolySheep AI không chỉ tiết kiệm 85%+ chi phí mà còn hỗ trợ mock testing - điều mà API chính thức hoàn toàn không có.

Mock Testing Strategy Từ Thực Chiến

Trong kinh nghiệm của tôi, có 3 cấp độ mock testing mà tôi luôn áp dụng theo thứ tự:

Cấp 1: Static Mock - Response Cố Định

Phù hợp cho unit test và integration test đơn giản. Response luôn giống nhau, không phụ thuộc input.

const axios = require('axios');

// Mock client cho HolySheep API
class HolySheepMockClient {
    constructor() {
        this.baseUrl = 'https://api.holysheep.ai/v1';
        this.mockMode = true;
        this.mockResponses = new Map();
    }

    // Đăng ký mock response cho một prompt cụ thể
    registerMock(promptPattern, response) {
        this.mockResponses.set(promptPattern, response);
    }

    // Gọi API - trong mock mode sẽ trả về response đã đăng ký
    async chat(prompt, options = {}) {
        if (this.mockMode) {
            // Tìm mock response phù hợp
            for (const [pattern, response] of this.mockResponses) {
                if (prompt.includes(pattern)) {
                    return {
                        success: true,
                        model: options.model || 'gpt-4.1',
                        response: response,
                        latency_ms: 0,
                        cached: true
                    };
                }
            }
            // Default mock response
            return {
                success: true,
                model: options.model || 'gpt-4.1',
                response: 'Mock response - no pattern matched',
                latency_ms: 0,
                cached: true
            };
        }

        // Real API call
        const response = await axios.post(
            ${this.baseUrl}/chat/completions,
            {
                model: options.model || 'gpt-4.1',
                messages: [{ role: 'user', content: prompt }],
                temperature: options.temperature || 0.7
            },
            {
                headers: {
                    'Authorization': Bearer ${process.env.HOLYSHEEP_API_KEY},
                    'Content-Type': 'application/json'
                }
            }
        );

        return {
            success: true,
            model: response.data.model,
            response: response.data.choices[0].message.content,
            latency_ms: response.headers['x-latency'] || 0,
            usage: response.data.usage
        };
    }
}

module.exports = HolySheepMockClient;

Cấp 2: Dynamic Mock - Response Theo Quy Tắc

Phù hợp cho integration test và QA. Response thay đổi theo input nhưng theo quy tắc có thể dự đoán.

const { v4: uuidv4 } = require('uuid');

class HolySheepDynamicMock {
    constructor() {
        this.baseUrl = 'https://api.holysheep.ai/v1';
        this.rules = [];
        this.callHistory = [];
    }

    // Thêm quy tắc mock
    addRule(pattern, generator) {
        this.rules.push({ pattern, generator });
    }

    // Tạo mock response động
    async chat(prompt, options = {}) {
        const startTime = Date.now();
        
        // Tìm rule phù hợp
        let response = 'Default mock response';
        for (const rule of this.rules) {
            if (prompt.includes(rule.pattern)) {
                response = await rule.generator(prompt, options);
                break;
            }
        }

        const result = {
            id: mock-${uuidv4()},
            model: options.model || 'gpt-4.1',
            choices: [{
                index: 0,
                message: {
                    role: 'assistant',
                    content: response
                },
                finish_reason: 'stop'
            }],
            usage: {
                prompt_tokens: prompt.split(' ').length,
                completion_tokens: response.split(' ').length,
                total_tokens: prompt.split(' ').length + response.split(' ').length
            },
            latency_ms: Date.now() - startTime,
            mock: true
        };

        this.callHistory.push({
            prompt,
            options,
            result,
            timestamp: new Date().toISOString()
        });

        return result;
    }

    // Lấy lịch sử call để verify
    getHistory() {
        return this.callHistory;
    }

    // Clear history
    clearHistory() {
        this.callHistory = [];
    }
}

// Ví dụ sử dụng
const mock = new HolySheepDynamicMock();

// Quy tắc 1: Sentiment analysis
mock.addRule('sentiment', (prompt) => {
    if (prompt.toLowerCase().includes('happy') || prompt.toLowerCase().includes('vui')) {
        return 'positive';
    }
    return 'neutral';
});

// Quy tắc 2: Translation
mock.addRule('translate', (prompt) => {
    return [TRANSLATED] ${prompt.replace(/translate/gi, '')};
});

// Test
mock.chat('Analyze sentiment: I am very happy today').then(result => {
    console.log('Result:', result.choices[0].message.content);
    console.log('Usage:', result.usage);
});

module.exports = HolySheepDynamicMock;

Cấp 3: Recording & Replay - Production-Like Mock

Đây là cấp độ cao nhất, sử dụng response thực từ production để replay. Tôi đã áp dụng kỹ thuật này trong dự án e-commerce với 50K+ daily requests.

const fs = require('fs').promises;
const crypto = require('crypto');
const path = require('path');

class HolySheepRecorder {
    constructor(cacheDir = './mock-cache') {
        this.baseUrl = 'https://api.holysheep.ai/v1';
        this.cacheDir = cacheDir;
        this.recordMode = process.env.RECORD_MODE === 'true';
        this.cacheHits = 0;
        this.cacheMisses = 0;
    }

    // Tạo hash key từ request
    hashRequest(prompt, model, temperature) {
        const data = ${prompt}|${model}|${temperature};
        return crypto.createHash('md5').update(data).digest('hex');
    }

    // Lấy cached response
    async getCached(hash) {
        const cachePath = path.join(this.cacheDir, ${hash}.json);
        try {
            const data = await fs.readFile(cachePath, 'utf-8');
            return JSON.parse(data);
        } catch {
            return null;
        }
    }

    // Lưu response vào cache
    async cacheResponse(hash, response) {
        await fs.mkdir(this.cacheDir, { recursive: true });
        const cachePath = path.join(this.cacheDir, ${hash}.json);
        await fs.writeFile(cachePath, JSON.stringify(response, null, 2));
    }

    // Main method: ưu tiên cache, fallback real API
    async chat(prompt, options = {}) {
        const model = options.model || 'gpt-4.1';
        const temperature = options.temperature || 0.7;
        const hash = this.hashRequest(prompt, model, temperature);

        // Check cache first
        const cached = await this.getCached(hash);
        if (cached && !this.recordMode) {
            this.cacheHits++;
            return { ...cached, cached: true };
        }

        // Real API call (với HolySheep)
        const response = await this.callRealAPI(prompt, options);
        
        // Cache nếu không tồn tại
        if (!cached) {
            await this.cacheResponse(hash, response);
        }

        return response;
    }

    // Gọi real HolySheep API
    async callRealAPI(prompt, options = {}) {
        const axios = require('axios');
        
        try {
            const response = await axios.post(
                ${this.baseUrl}/chat/completions,
                {
                    model: options.model || 'gpt-4.1',
                    messages: [{ role: 'user', content: prompt }],
                    temperature: options.temperature || 0.7
                },
                {
                    headers: {
                        'Authorization': Bearer ${process.env.HOLYSHEEP_API_KEY},
                        'Content-Type': 'application/json'
                    },
                    timeout: 30000
                }
            );

            return {
                id: response.data.id,
                model: response.data.model,
                choices: response.data.choices,
                usage: response.data.usage,
                latency_ms: response.headers['x-latency'] || 0,
                cached: false
            };
        } catch (error) {
            console.error('HolySheep API Error:', error.message);
            throw error;
        }
    }

    // Stats
    getStats() {
        const total = this.cacheHits + this.cacheMisses;
        return {
            cacheHits: this.cacheHits,
            cacheMisses: this.cacheMisses,
            hitRate: total > 0 ? ${(this.cacheHits / total * 100).toFixed(1)}% : '0%'
        };
    }
}

module.exports = HolySheepRecorder;

Tích Hợp Vào Testing Framework

Đây là phần quan trọng - tích hợp mock testing vào CI/CD pipeline. Tôi sẽ show cách setup với Jest và pytest.

// jest.setup.js
const HolySheepMockClient = require('./mock-client');

beforeAll(() => {
    // Global mock instance cho tất cả tests
    global.holySheepMock = new HolySheepMockClient();
    
    // Đăng ký common mocks
    global.holySheepMock.registerMock('hello', 'Hello! How can I help you?');
    global.holySheepMock.registerMock('weather', 'The weather is sunny with 25°C.');
    global.holySheepMock.registerMock('help', 'I am here to help you with your questions.');
});

afterEach(() => {
    // Clear history sau mỗi test
    if (global.holySheepMock.clearHistory) {
        global.holySheepMock.clearHistory();
    }
});

// __tests__/ai-service.test.js
describe('AI Service Integration', () => {
    test('should return greeting response', async () => {
        const result = await global.holySheepMock.chat('Say hello to me');
        expect(result.success).toBe(true);
        expect(result.response).toContain('Hello');
    });

    test('should handle weather query', async () => {
        const result = await global.holySheepMock.chat('What is the weather?');
        expect(result.success).toBe(true);
        expect(result.latency_ms).toBe(0); // Mock mode = instant
    });

    test('should use correct model', async () => {
        const result = await global.holySheepMock.chat('Test', { model: 'claude-sonnet-4.5' });
        expect(result.model).toBe('claude-sonnet-4.5');
    });
});

Lỗi Thường Gặp và Cách Khắc Phục

Lỗi 1: "Connection timeout khi gọi mock API"

Nguyên nhân: Mock client cố gắi gọi real API thay vì return mock response ngay lập tức.

Giải pháp:

// Sai - không check mockMode
async chat(prompt, options) {
    const response = await axios.post(...); // Luôn gọi real API!
    return response;
}

// Đúng - check mockMode trước
async chat(prompt, options) {
    if (this.mockMode) {
        return this.getMockResponse(prompt, options);
    }
    return await this.callRealAPI(prompt, options);
}

// Setup mockMode bằng environment variable
const mockClient = new HolySheepMockClient();
mockClient.mockMode = process.env.NODE_ENV === 'test' || 
                      process.env.MOCK_MODE === 'true';

Lỗi 2: "Mock response không khớp với expected output"

Nguyên nhân: Pattern matching quá strict hoặc mock chưa được đăng ký.

Giải pháp:

// Thêm logging để debug
async chat(prompt, options) {
    console.log('[Mock] Received prompt:', prompt);
    
    for (const [pattern, response] of this.mockResponses) {
        console.log([Mock] Checking pattern: "${pattern}");
        if (prompt.includes(pattern)) {
            console.log('[Mock] Pattern matched!');
            return response;
        }
    }
    
    console.warn('[Mock] No pattern matched! Using default.');
    return this.defaultResponse;
}

// Hoặc dùng regex thay vì includes
if (new RegExp(pattern, 'i').test(prompt)) {
    return response;
}

Lỗi 3: "Cache không hoạt động - mỗi lần gọi đều tạo request mới"

Nguyên nhân: Cache directory chưa được tạo hoặc permissions không đúng.

Giải pháp:

// Đảm bảo tạo directory trước khi cache
async cacheResponse(hash, response) {
    try {
        await fs.mkdir(this.cacheDir, { recursive: true });
        const cachePath = path.join(this.cacheDir, ${hash}.json);
        await fs.writeFile(cachePath, JSON.stringify(response, null, 2));
        console.log([Cache] Stored: ${cachePath});
    } catch (error) {
        console.error('[Cache] Write error:', error.message);
        // Fallback: không throw, tiếp tục với real API
    }
}

// Verify cache exists
async verifyCache(hash) {
    const cachePath = path.join(this.cacheDir, ${hash}.json);
    const exists = await fs.access(cachePath).then(() => true).catch(() => false);
    console.log([Cache] ${hash} exists: ${exists});
    return exists;
}

Lỗi 4: "Lỗi CORS khi test trên browser"

Nguyên nhân: Browser block cross-origin request đến API.

Giải pháp:

// Server-side mock proxy
const express = require('express');
const app = express();

// Mock endpoint
app.post('/api/mock/chat', (req, res) => {
    res.setHeader('Access-Control-Allow-Origin', '*');
    res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
    
    const { prompt, model } = req.body;
    
    // Return mock response
    res.json({
        success: true,
        model: model || 'gpt-4.1',
        response: Mock response for: ${prompt},
        latency_ms: 0
    });
});

// Frontend gọi đến proxy thay vì direct API
async function callMockAPI(prompt) {
    const response = await fetch('/api/mock/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ prompt, model: 'gpt-4.1' })
    });
    return response.json();
}

Best Practices Từ Kinh Nghiệm Thực Chiến

1. Luôn dùng environment variable để switch giữa mock và real API
2. Version control cache - commit mock cache vào repo để đảm bảo consistency
3. Implement timeout mock - đôi khi bạn cần test xử lý timeout
4. Randomize response - tránh test quá "perfect" không thực tế
5. Log tất cả mock calls - giúp debug và coverage analysis

# .env.example
NODE_ENV=test
MOCK_MODE=true
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
RECORD_MODE=false
CACHE_DIR=./mock-cache

production.env
NODE_ENV=production
MOCK_MODE=false
HOLYSHEEP_API_KEY=sk_live_xxxxx
RECORD_MODE=false
CACHE_DIR=/var/cache/holysheep-mock

Kết Luận

Mock testing là không thể thiếu trong development workflow hiện đại. Với HolySheep AI, bạn không chỉ tiết kiệm 85%+ chi phí (tỷ giá ¥1=$1) mà còn có độ trễ dưới 50ms, hỗ trợ WeChat/Alipay thanh toán, và tín dụng miễn phí khi đăng ký. Đặc biệt, mock testing mode giúp team QA và dev làm việc hiệu quả hơn bao giờ hết.

Từ dự án e-commerce 50K+ requests/ngày đến chatbot startup, tôi đã áp dụng 3 cấp độ mock testing này và đều thành công. Bắt đầu với static mock đơn giản, sau đó nâng cấp dần khi team familiar hơn với workflow.

💡 Mẹo cuối cùng: Commit file mock-cache vào git, team member mới có thể bắt đầu development ngay lập tức mà không cần chờ API access.

👉 Đăng ký HolySheep AI — nhận tín dụng miễn phí khi đăng ký