tv-recommender-mcp-server/dist/__tests__/tmdbClient.test.js

MCP server for TV show recommendations

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const axios_1 = __importDefault(require("axios"));
const tmdbClient_1 = require("../services/tmdbClient");
// 模拟validateApiKey函数
jest.mock('../utils/config', () => ({
    validateApiKey: jest.fn().mockReturnValue('test-api-key')
}));
// 模拟 axios
jest.mock('axios', () => {
    return {
        create: jest.fn().mockReturnValue({
            get: jest.fn()
        })
    };
});
describe('TMDbClient', () => {
    let mockAxiosGet;
    let mockAxiosClient;
    beforeEach(() => {
        // 重置所有模拟
        jest.clearAllMocks();
        // 创建模拟的axios客户端实例
        mockAxiosClient = {
            get: jest.fn()
        };
        // 模拟axios.create返回我们控制的客户端
        axios_1.default.create.mockReturnValue(mockAxiosClient);
        // 确保client属性是null，这样会触发懒加载
        Object.defineProperty(tmdbClient_1.tmdbClient, 'client', {
            value: null,
            writable: true
        });
        // 通过调用一个方法触发懒加载
        tmdbClient_1.tmdbClient.testConnection();
        // 现在可以获取get方法
        mockAxiosGet = mockAxiosClient.get;
    });
    it('测试连接应该返回正确结果', async () => {
        // 成功情况
        mockAxiosGet.mockResolvedValueOnce({ status: 200 });
        expect(await tmdbClient_1.tmdbClient.testConnection()).toBe(true);
        // 失败情况
        mockAxiosGet.mockRejectedValueOnce(new Error('连接失败'));
        expect(await tmdbClient_1.tmdbClient.testConnection()).toBe(false);
    });
    it('getConfiguration应该正确调用API', async () => {
        const mockResponse = { data: { images: { base_url: 'http://image.tmdb.org/' } } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result = await tmdbClient_1.tmdbClient.getConfiguration();
        expect(mockAxiosGet).toHaveBeenCalledWith('/configuration');
        expect(result).toEqual(mockResponse.data);
    });
    it('getConfiguration应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.getConfiguration()).rejects.toThrow('获取TMDb配置失败');
    });
    it('searchTvShow应该正确调用API', async () => {
        const mockResponse = { data: { results: [] } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result = await tmdbClient_1.tmdbClient.searchTvShow('测试剧集');
        expect(mockAxiosGet).toHaveBeenCalledWith('/search/tv', {
            params: { query: '测试剧集' }
        });
        expect(result).toEqual(mockResponse.data);
    });
    it('searchTvShow应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.searchTvShow('测试剧集')).rejects.toThrow('查询TV节目');
    });
    it('getRecommendationsByGenre应该正确调用API', async () => {
        const mockResponse = { data: { results: [{}, {}, {}] } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result = await tmdbClient_1.tmdbClient.getRecommendationsByGenre(35, 2);
        expect(mockAxiosGet).toHaveBeenCalledWith('/discover/tv', {
            params: {
                with_genres: 35,
                sort_by: 'vote_average.desc',
                'vote_count.gte': 100,
                page: 1
            }
        });
        // 验证结果被限制为2个
        expect(result.results.length).toBe(2);
    });
    it('getRecommendationsByGenre应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.getRecommendationsByGenre(35)).rejects.toThrow('获取类型ID 35 的推荐失败');
    });
    it('getTvGenres应该正确调用API', async () => {
        const mockResponse = { data: { genres: [] } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result = await tmdbClient_1.tmdbClient.getTvGenres();
        expect(mockAxiosGet).toHaveBeenCalledWith('/genre/tv/list');
        expect(result).toEqual(mockResponse.data);
    });
    it('getTvGenres应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.getTvGenres()).rejects.toThrow('获取TV类型列表失败');
    });
    it('searchTvShowByTitle应该正确调用API', async () => {
        const mockResponse = { data: { results: [] } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result = await tmdbClient_1.tmdbClient.searchTvShowByTitle('测试剧集');
        expect(mockAxiosGet).toHaveBeenCalledWith('/search/tv', {
            params: {
                query: '测试剧集',
                page: 1
            }
        });
        expect(result).toEqual(mockResponse.data);
    });
    it('searchTvShowByTitle应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.searchTvShowByTitle('测试剧集')).rejects.toThrow('搜索剧集');
    });
    it('getSimilarTvShows应该正确调用API', async () => {
        const mockResponse = { data: { results: [{}, {}, {}] } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result = await tmdbClient_1.tmdbClient.getSimilarTvShows(123, 2);
        expect(mockAxiosGet).toHaveBeenCalledWith('/tv/123/similar');
        // 验证结果被限制为2个
        expect(result.results.length).toBe(2);
    });
    it('getSimilarTvShows应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.getSimilarTvShows(123)).rejects.toThrow('获取剧集ID 123 的相似剧集失败');
    });
    it('getTvShowWatchProviders应该正确调用API', async () => {
        const mockResponse = {
            data: {
                results: {
                    US: { flatrate: [{ provider_name: 'Netflix' }] },
                    CN: { buy: [{ provider_name: 'iTunes' }] }
                }
            }
        };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        // 测试默认国家/地区代码
        const result1 = await tmdbClient_1.tmdbClient.getTvShowWatchProviders(123);
        expect(mockAxiosGet).toHaveBeenCalledWith('/tv/123/watch/providers');
        expect(result1.results).toEqual(mockResponse.data.results.US);
        // 测试指定国家/地区代码
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result2 = await tmdbClient_1.tmdbClient.getTvShowWatchProviders(123, 'CN');
        expect(result2.results).toEqual(mockResponse.data.results.CN);
    });
    it('getTvShowWatchProviders应该处理国家/地区不存在的情况', async () => {
        const mockResponse = { data: { results: { US: {} } } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result = await tmdbClient_1.tmdbClient.getTvShowWatchProviders(123, 'XYZ');
        expect(result.results).toEqual({});
    });
    it('getTvShowWatchProviders应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.getTvShowWatchProviders(123)).rejects.toThrow('获取剧集ID 123 的观看渠道失败');
    });
    it('discoverTvShows应该正确调用API', async () => {
        const mockResponse = { data: { results: [] } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        // 使用默认参数
        const result1 = await tmdbClient_1.tmdbClient.discoverTvShows();
        expect(mockAxiosGet).toHaveBeenCalledWith('/discover/tv', {
            params: { page: 1 }
        });
        // 使用自定义参数
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result2 = await tmdbClient_1.tmdbClient.discoverTvShows({
            with_genres: '35,18',
            sort_by: 'popularity.desc',
            page: 2
        });
        expect(mockAxiosGet).toHaveBeenCalledWith('/discover/tv', {
            params: {
                with_genres: '35,18',
                sort_by: 'popularity.desc',
                page: 2
            }
        });
    });
    it('discoverTvShows应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.discoverTvShows()).rejects.toThrow('高级剧集发现失败');
    });
    it('searchPerson应该正确调用API', async () => {
        const mockResponse = { data: { results: [] } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result = await tmdbClient_1.tmdbClient.searchPerson('演员名');
        expect(mockAxiosGet).toHaveBeenCalledWith('/search/person', {
            params: { query: '演员名' }
        });
        expect(result).toEqual(mockResponse.data);
    });
    it('searchPerson应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.searchPerson('演员名')).rejects.toThrow('搜索人物');
    });
    it('searchKeyword应该正确调用API', async () => {
        const mockResponse = { data: { results: [] } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result = await tmdbClient_1.tmdbClient.searchKeyword('关键词');
        expect(mockAxiosGet).toHaveBeenCalledWith('/search/keyword', {
            params: { query: '关键词' }
        });
        expect(result).toEqual(mockResponse.data);
    });
    it('searchKeyword应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.searchKeyword('关键词')).rejects.toThrow('搜索关键词');
    });
    it('getNetworks应该正确调用API', async () => {
        const mockResponse = { data: { results: [] } };
        mockAxiosGet.mockResolvedValueOnce(mockResponse);
        const result = await tmdbClient_1.tmdbClient.getNetworks();
        expect(mockAxiosGet).toHaveBeenCalledWith('/watch/providers/tv');
        expect(result).toEqual(mockResponse.data);
    });
    it('getNetworks应该处理错误', async () => {
        mockAxiosGet.mockRejectedValueOnce(new Error('API错误'));
        await expect(tmdbClient_1.tmdbClient.getNetworks()).rejects.toThrow('获取电视网络列表失败');
    });
});