@phunky/scrape-channel-listings/dist/__tests__/index.test.js

A TypeScript library for scraping TV channel listings from various providers

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const index_1 = require("../index");
const scraper_1 = require("../utils/scraper");
// Mock the scraper utility
jest.mock('../utils/scraper', () => ({
    runScraper: jest.fn()
}));
describe('scrapeAllProviders', () => {
    beforeEach(() => {
        jest.clearAllMocks();
    });
    it('should scrape all providers and return provider channels', async () => {
        const mockChannels = [
            { number: '1', name: 'Channel 1' },
            { number: '2', name: 'Channel 2' }
        ];
        scraper_1.runScraper.mockResolvedValue(mockChannels);
        const result = await (0, index_1.scrapeAllProviders)();
        expect(result).toEqual([
            { provider: 'directv', channels: mockChannels },
            { provider: 'dish', channels: mockChannels },
            { provider: 'virgin', channels: mockChannels },
            { provider: 'sky', channels: mockChannels },
            { provider: 'skyireland', channels: mockChannels },
            { provider: 'skysatellite', channels: mockChannels },
            { provider: 'freesat', channels: mockChannels }
        ]);
        expect(scraper_1.runScraper).toHaveBeenCalledTimes(7);
    });
    it('should return summary when writeFiles is true', async () => {
        const mockChannels = [
            { number: '1', name: 'Channel 1' },
            { number: '2', name: 'Channel 2' }
        ];
        scraper_1.runScraper.mockResolvedValue(mockChannels);
        const result = await (0, index_1.scrapeAllProviders)({ writeFiles: true });
        expect(result).toMatchObject({
            results: expect.arrayContaining([
                expect.objectContaining({
                    name: expect.any(String),
                    success: true,
                    duration: expect.any(Number),
                    channelCount: 2,
                    channels: mockChannels
                })
            ]),
            totalDuration: expect.any(Number),
            successRate: expect.any(String),
            totalChannels: 14,
            failedScrapers: []
        });
    });
    it('should handle failed scrapers', async () => {
        scraper_1.runScraper
            .mockResolvedValueOnce([{ number: '1', name: 'Channel 1' }])
            .mockRejectedValueOnce(new Error('Failed'))
            .mockResolvedValueOnce([{ number: '2', name: 'Channel 2' }])
            .mockResolvedValueOnce([{ number: '3', name: 'Channel 3' }])
            .mockResolvedValueOnce([{ number: '4', name: 'Channel 4' }])
            .mockResolvedValueOnce([{ number: '5', name: 'Channel 5' }])
            .mockResolvedValueOnce([{ number: '6', name: 'Channel 6' }]);
        const result = await (0, index_1.scrapeAllProviders)({ writeFiles: true });
        expect(result).toMatchObject({
            results: expect.arrayContaining([
                expect.objectContaining({ success: true }),
                expect.objectContaining({
                    success: false,
                    error: expect.any(Error)
                }),
                expect.objectContaining({ success: true }),
                expect.objectContaining({ success: true }),
                expect.objectContaining({ success: true }),
                expect.objectContaining({ success: true }),
                expect.objectContaining({ success: true })
            ]),
            failedScrapers: expect.arrayContaining([
                expect.objectContaining({
                    name: 'dish',
                    success: false,
                    error: expect.any(Error)
                })
            ])
        });
    });
});
describe('scrapeProvider', () => {
    beforeEach(() => {
        jest.clearAllMocks();
    });
    it('should scrape a specific provider', async () => {
        const mockChannels = [
            { number: '1', name: 'Channel 1' },
            { number: '2', name: 'Channel 2' }
        ];
        scraper_1.runScraper.mockResolvedValue(mockChannels);
        const result = await (0, index_1.scrapeProvider)('directv');
        expect(result).toEqual({
            name: 'directv',
            success: true,
            duration: expect.any(Number),
            channelCount: 2,
            channels: mockChannels
        });
        expect(scraper_1.runScraper).toHaveBeenCalledTimes(1);
    });
    it('should handle scraping errors', async () => {
        scraper_1.runScraper.mockRejectedValue(new Error('Failed'));
        const result = await (0, index_1.scrapeProvider)('directv');
        expect(result).toEqual({
            name: 'directv',
            success: false,
            duration: expect.any(Number),
            error: expect.any(Error)
        });
    });
    it('should throw error for unknown provider', async () => {
        await expect((0, index_1.scrapeProvider)('UNKNOWN')).rejects.toThrow('Provider "UNKNOWN" not found');
        expect(scraper_1.runScraper).not.toHaveBeenCalled();
    });
});