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

MCP server for TV show recommendations

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tmdbClient_1 = require("../../services/tmdbClient");
// 模拟 axios 和 配置
jest.mock('axios');
jest.mock('../../utils/config', () => ({
    tmdbApiKey: 'mock-api-key'
}));
// 直接模拟 tmdbClient 的方法
jest.spyOn(tmdbClient_1.tmdbClient, 'testConnection');
jest.spyOn(tmdbClient_1.tmdbClient, 'getConfiguration');
jest.spyOn(tmdbClient_1.tmdbClient, 'searchTvShow');
jest.spyOn(tmdbClient_1.tmdbClient, 'getTvGenres');
jest.spyOn(tmdbClient_1.tmdbClient, 'getRecommendationsByGenre');
jest.spyOn(tmdbClient_1.tmdbClient, 'searchTvShowByTitle');
jest.spyOn(tmdbClient_1.tmdbClient, 'getSimilarTvShows');
jest.spyOn(tmdbClient_1.tmdbClient, 'getTvShowWatchProviders');
jest.spyOn(tmdbClient_1.tmdbClient, 'discoverTvShows');
jest.spyOn(tmdbClient_1.tmdbClient, 'searchPerson');
jest.spyOn(tmdbClient_1.tmdbClient, 'searchKeyword');
jest.spyOn(tmdbClient_1.tmdbClient, 'getPersonDetails');
jest.spyOn(tmdbClient_1.tmdbClient, 'getNetworks');
jest.spyOn(tmdbClient_1.tmdbClient, 'getPersonTvCredits');
jest.spyOn(tmdbClient_1.tmdbClient, 'getTvShowReviews');
jest.spyOn(tmdbClient_1.tmdbClient, 'getPopularTvShows');
jest.spyOn(tmdbClient_1.tmdbClient, 'getTrendingTvShows');
jest.spyOn(tmdbClient_1.tmdbClient, 'getTvShowVideos');
describe('TMDbClient', () => {
    beforeEach(() => {
        jest.clearAllMocks();
    });
    describe('testConnection', () => {
        it('当API调用成功时应该返回true', async () => {
            // 模拟方法返回成功结果
            tmdbClient_1.tmdbClient.testConnection.mockResolvedValueOnce(true);
            const result = await tmdbClient_1.tmdbClient.testConnection();
            expect(result).toBe(true);
            expect(tmdbClient_1.tmdbClient.testConnection).toHaveBeenCalled();
        });
        it('当API调用失败时应该返回false', async () => {
            // 模拟方法返回失败结果
            tmdbClient_1.tmdbClient.testConnection.mockResolvedValueOnce(false);
            const result = await tmdbClient_1.tmdbClient.testConnection();
            expect(result).toBe(false);
            expect(tmdbClient_1.tmdbClient.testConnection).toHaveBeenCalled();
        });
    });
    describe('getConfiguration', () => {
        it('应该返回配置数据', async () => {
            const mockData = { images: { base_url: 'http://example.com' } };
            // 模拟方法返回配置数据
            tmdbClient_1.tmdbClient.getConfiguration.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getConfiguration();
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getConfiguration).toHaveBeenCalled();
        });
        it('当API调用失败时应该抛出错误', async () => {
            // 模拟方法抛出错误
            tmdbClient_1.tmdbClient.getConfiguration.mockRejectedValueOnce(new Error('API Error'));
            await expect(tmdbClient_1.tmdbClient.getConfiguration()).rejects.toThrow('API Error');
        });
    });
    describe('searchTvShow', () => {
        it('应该返回搜索结果', async () => {
            const mockData = { results: [{ id: 1, name: '测试剧集' }] };
            // 模拟方法返回搜索结果
            tmdbClient_1.tmdbClient.searchTvShow.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.searchTvShow('测试查询');
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.searchTvShow).toHaveBeenCalledWith('测试查询');
        });
        it('当API调用失败时应该抛出错误', async () => {
            // 模拟方法抛出错误
            tmdbClient_1.tmdbClient.searchTvShow.mockRejectedValueOnce(new Error('API Error'));
            await expect(tmdbClient_1.tmdbClient.searchTvShow('测试查询')).rejects.toThrow('API Error');
        });
    });
    describe('getTvGenres', () => {
        it('应该返回电视剧类型列表', async () => {
            const mockData = { genres: [{ id: 1, name: '测试类型' }] };
            // 模拟方法返回类型列表
            tmdbClient_1.tmdbClient.getTvGenres.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getTvGenres();
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getTvGenres).toHaveBeenCalled();
        });
        it('当API调用失败时应该抛出错误', async () => {
            // 模拟方法抛出错误
            tmdbClient_1.tmdbClient.getTvGenres.mockRejectedValueOnce(new Error('API Error'));
            await expect(tmdbClient_1.tmdbClient.getTvGenres()).rejects.toThrow('API Error');
        });
    });
    describe('searchTvShowByTitle', () => {
        it('应该返回搜索结果', async () => {
            const mockData = { results: [{ id: 66732, name: '测试剧集' }] };
            // 模拟方法返回搜索结果
            tmdbClient_1.tmdbClient.searchTvShowByTitle.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.searchTvShowByTitle('测试剧集');
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.searchTvShowByTitle).toHaveBeenCalledWith('测试剧集');
        });
    });
    describe('getSimilarTvShows', () => {
        it('应该返回相似剧集列表', async () => {
            const mockData = { results: [{ id: 1, name: '相似剧集' }] };
            // 模拟方法返回相似剧集
            tmdbClient_1.tmdbClient.getSimilarTvShows.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getSimilarTvShows(66732);
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getSimilarTvShows).toHaveBeenCalledWith(66732);
        });
    });
    describe('getRecommendationsByGenre', () => {
        it('应该返回按类型推荐的剧集列表', async () => {
            const mockData = { results: [{ id: 1, name: '推荐剧集' }] };
            // 模拟方法返回推荐剧集
            tmdbClient_1.tmdbClient.getRecommendationsByGenre.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getRecommendationsByGenre(35);
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getRecommendationsByGenre).toHaveBeenCalledWith(35);
        });
    });
    describe('getTvShowWatchProviders', () => {
        it('应该返回观看渠道信息', async () => {
            const mockData = {
                id: 123,
                results: {
                    US: {
                        link: 'https://example.com',
                        flatrate: [{ provider_id: 8, provider_name: 'Netflix' }]
                    }
                }
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getTvShowWatchProviders.mockResolvedValueOnce({
                id: 123,
                results: {
                    link: 'https://example.com',
                    flatrate: [{ provider_id: 8, provider_name: 'Netflix' }]
                }
            });
            const result = await tmdbClient_1.tmdbClient.getTvShowWatchProviders(123);
            expect(result).toHaveProperty('id', 123);
            expect(result).toHaveProperty('results');
            expect(tmdbClient_1.tmdbClient.getTvShowWatchProviders).toHaveBeenCalledWith(123);
        });
        it('应该支持自定义国家/地区代码', async () => {
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getTvShowWatchProviders.mockResolvedValueOnce({
                id: 123,
                results: {
                    link: 'https://example.cn',
                    flatrate: [{ provider_id: 10, provider_name: 'iQiyi' }]
                }
            });
            const result = await tmdbClient_1.tmdbClient.getTvShowWatchProviders(123, 'CN');
            expect(tmdbClient_1.tmdbClient.getTvShowWatchProviders).toHaveBeenCalledWith(123, 'CN');
        });
    });
    describe('discoverTvShows', () => {
        it('应该返回高级发现结果', async () => {
            const mockData = {
                page: 1,
                results: [{ id: 1, name: '发现剧集' }],
                total_pages: 10,
                total_results: 100
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.discoverTvShows.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.discoverTvShows({ with_genres: 28, sort_by: 'popularity.desc' });
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.discoverTvShows).toHaveBeenCalledWith({ with_genres: 28, sort_by: 'popularity.desc' });
        });
        it('应该处理空参数调用', async () => {
            const mockData = {
                page: 1,
                results: [{ id: 2, name: '默认发现剧集' }]
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.discoverTvShows.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.discoverTvShows();
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.discoverTvShows).toHaveBeenCalledWith();
        });
    });
    describe('searchPerson', () => {
        it('应该返回人物搜索结果', async () => {
            const mockData = {
                results: [{ id: 123, name: '汤姆·汉克斯' }]
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.searchPerson.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.searchPerson('汤姆');
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.searchPerson).toHaveBeenCalledWith('汤姆');
        });
    });
    describe('searchKeyword', () => {
        it('应该返回关键词搜索结果', async () => {
            const mockData = {
                results: [{ id: 123, name: '超级英雄' }]
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.searchKeyword.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.searchKeyword('英雄');
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.searchKeyword).toHaveBeenCalledWith('英雄');
        });
    });
    describe('getPersonDetails', () => {
        it('应该返回人物详细信息', async () => {
            const mockData = {
                id: 123,
                name: '汤姆·汉克斯',
                biography: '著名演员...',
                birthday: '1956-07-09'
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getPersonDetails.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getPersonDetails(123);
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getPersonDetails).toHaveBeenCalledWith(123);
        });
    });
    describe('getNetworks', () => {
        it('应该返回电视网络列表', async () => {
            const mockData = {
                results: [
                    { provider_id: 8, provider_name: 'Netflix' },
                    { provider_id: 9, provider_name: 'HBO' }
                ]
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getNetworks.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getNetworks();
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getNetworks).toHaveBeenCalled();
        });
    });
    describe('getPersonTvCredits', () => {
        it('应该返回人物的电视剧作品', async () => {
            const mockData = {
                id: 123,
                cast: [
                    { id: 1, name: '剧集1', character: '角色1' },
                    { id: 2, name: '剧集2', character: '角色2' }
                ],
                crew: [
                    { id: 3, name: '剧集3', job: '导演' }
                ]
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getPersonTvCredits.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getPersonTvCredits(123);
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getPersonTvCredits).toHaveBeenCalledWith(123);
        });
    });
    describe('getTvShowReviews', () => {
        it('应该返回剧集评论', async () => {
            const mockData = {
                id: 123,
                page: 1,
                results: [
                    { id: 'abc123', author: '用户1', content: '很棒的剧集!' },
                    { id: 'def456', author: '用户2', content: '值得推荐.' }
                ],
                total_pages: 1,
                total_results: 2
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getTvShowReviews.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getTvShowReviews(123);
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getTvShowReviews).toHaveBeenCalledWith(123);
        });
        it('应该支持分页', async () => {
            const mockData = {
                id: 123,
                page: 2,
                results: [
                    { id: 'ghi789', author: '用户3', content: '很精彩!' }
                ],
                total_pages: 2,
                total_results: 3
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getTvShowReviews.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getTvShowReviews(123, 2);
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getTvShowReviews).toHaveBeenCalledWith(123, 2);
        });
    });
    describe('getPopularTvShows', () => {
        it('应该返回热门剧集', async () => {
            const mockData = {
                page: 1,
                results: [
                    { id: 1, name: '热门剧集1' },
                    { id: 2, name: '热门剧集2' }
                ],
                total_pages: 10,
                total_results: 200
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getPopularTvShows.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getPopularTvShows();
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getPopularTvShows).toHaveBeenCalled();
        });
        it('应该支持分页', async () => {
            const mockData = {
                page: 2,
                results: [
                    { id: 3, name: '热门剧集3' },
                    { id: 4, name: '热门剧集4' }
                ],
                total_pages: 10,
                total_results: 200
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getPopularTvShows.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getPopularTvShows(2);
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getPopularTvShows).toHaveBeenCalledWith(2);
        });
    });
    describe('getTrendingTvShows', () => {
        it('应该返回周趋势剧集（默认)', async () => {
            const mockData = {
                page: 1,
                results: [
                    { id: 1, name: '周趋势剧集1' },
                    { id: 2, name: '周趋势剧集2' }
                ],
                total_pages: 5,
                total_results: 100
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getTrendingTvShows.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getTrendingTvShows();
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getTrendingTvShows).toHaveBeenCalled();
        });
        it('应该返回日趋势剧集', async () => {
            const mockData = {
                page: 1,
                results: [
                    { id: 3, name: '日趋势剧集1' },
                    { id: 4, name: '日趋势剧集2' }
                ],
                total_pages: 3,
                total_results: 50
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getTrendingTvShows.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getTrendingTvShows('day');
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getTrendingTvShows).toHaveBeenCalledWith('day');
        });
        it('应该支持分页', async () => {
            const mockData = {
                page: 2,
                results: [
                    { id: 5, name: '周趋势剧集3' },
                    { id: 6, name: '周趋势剧集4' }
                ],
                total_pages: 5,
                total_results: 100
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getTrendingTvShows.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getTrendingTvShows('week', 2);
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getTrendingTvShows).toHaveBeenCalledWith('week', 2);
        });
    });
    describe('getTvShowVideos', () => {
        it('应该返回剧集视频列表', async () => {
            const mockData = {
                id: 123,
                results: [
                    {
                        id: 'v1',
                        key: 'abc123',
                        name: '预告片',
                        site: 'YouTube',
                        type: 'Trailer',
                        official: true
                    },
                    {
                        id: 'v2',
                        key: 'def456',
                        name: '花絮',
                        site: 'Vimeo',
                        type: 'Featurette',
                        official: false
                    }
                ]
            };
            // 模拟方法返回结果
            tmdbClient_1.tmdbClient.getTvShowVideos.mockResolvedValueOnce(mockData);
            const result = await tmdbClient_1.tmdbClient.getTvShowVideos(123);
            expect(result).toEqual(mockData);
            expect(tmdbClient_1.tmdbClient.getTvShowVideos).toHaveBeenCalledWith(123);
        });
    });
});