mirror of
https://github.com/iptv-org/epg
synced 2026-09-06 12:00:09 -04:00
406 lines
11 KiB
JavaScript
406 lines
11 KiB
JavaScript
process.env.CURR_DATE = '2026-06-08'
|
|
|
|
const { channels, parser, request, url } = require('./sky.com.config.js')
|
|
const fs = require('fs')
|
|
const path = require('path')
|
|
const axios = require('axios')
|
|
const dayjs = require('dayjs')
|
|
const utc = require('dayjs/plugin/utc')
|
|
const customParseFormat = require('dayjs/plugin/customParseFormat')
|
|
|
|
dayjs.extend(customParseFormat)
|
|
dayjs.extend(utc)
|
|
|
|
jest.mock('axios')
|
|
|
|
const date = dayjs.utc('2026-06-08').startOf('d')
|
|
const channel = {
|
|
lang: 'en',
|
|
name: 'Sky History HD',
|
|
site_id: 'GB#4086',
|
|
xmltv_id: 'SkyHistory.uk@HD'
|
|
}
|
|
const uhdChannel = {
|
|
lang: 'en',
|
|
name: 'TNTUltimateUHD',
|
|
site_id: 'GB#1336',
|
|
xmltv_id: 'TNTSportsUltimate.uk@SD'
|
|
}
|
|
|
|
function mockScheduleRequest(url) {
|
|
const urls = {
|
|
20260608: 'content1.json',
|
|
20260609: 'content2.json'
|
|
}
|
|
let data = ''
|
|
const match = url.match(/\/schedule\/(\d{8})\/([^/]+)$/)
|
|
if (match && match[2].split(',').includes('4086') && urls[match[1]] !== undefined) {
|
|
data = fs.readFileSync(path.join(__dirname, '__data__', urls[match[1]])).toString()
|
|
}
|
|
return Promise.resolve({ data, headers: {}, request: {} })
|
|
}
|
|
|
|
beforeEach(() => {
|
|
jest.clearAllMocks()
|
|
axios.get.mockImplementation(mockScheduleRequest)
|
|
})
|
|
|
|
it('can generate valid url', () => {
|
|
const result = url({ channel, date })
|
|
const sids = result.split('/').pop().split(',')
|
|
|
|
expect(result).toContain('https://awk.epgsky.com/hawk/linear/schedule/20260608/')
|
|
expect(sids).toHaveLength(20)
|
|
expect(sids).toContain('4086')
|
|
expect(new Set(sids)).toHaveProperty('size', 20)
|
|
|
|
const companion = {
|
|
...channel,
|
|
site_id: `GB#${sids.find(sid => sid !== '4086')}`
|
|
}
|
|
expect(url({ channel: companion, date })).toBe(result)
|
|
})
|
|
|
|
it('falls back to a single SID for a channel outside the repository XML', () => {
|
|
expect(url({ channel: { ...channel, site_id: 'GB#999999' }, date })).toBe(
|
|
'https://awk.epgsky.com/hawk/linear/schedule/20260608/999999'
|
|
)
|
|
})
|
|
|
|
it.each([
|
|
['TNTUltimateUHD', 'GB#1336', '1336'],
|
|
['Ultra HD', 'GB#7233', '7233'],
|
|
['Sky Sport 4k', 'IT#628', '628']
|
|
])('uses Atlantis for %s', (name, siteId, sid) => {
|
|
const currentChannel = {
|
|
...channel,
|
|
name,
|
|
site_id: siteId
|
|
}
|
|
|
|
expect(url({ channel: currentChannel, date })).toBe(
|
|
`https://atlantis.epgsky.com/as/schedule/20260608/${sid}`
|
|
)
|
|
expect(request.headers({ channel: currentChannel })).toEqual({
|
|
'X-SkyOTT-Proposition': 'SKYQ',
|
|
'X-SkyOTT-Provider': 'SKY',
|
|
'X-SkyOTT-Territory': siteId.slice(0, 2)
|
|
})
|
|
})
|
|
|
|
it('rejects an unsupported territory in the site ID', () => {
|
|
expect(() => url({ channel: { ...channel, site_id: 'XX#4086' }, date })).toThrow(
|
|
'Expected "<territory>#<sid>"'
|
|
)
|
|
})
|
|
|
|
it('can generate territory headers from the site ID', () => {
|
|
expect(request.headers({ channel })).toEqual({
|
|
'X-SkyOTT-Territory': 'GB'
|
|
})
|
|
expect(request.headers({ channel: { ...channel, lang: 'en', site_id: 'DE#4086' } })).toEqual({
|
|
'X-SkyOTT-Territory': 'DE'
|
|
})
|
|
expect(request.headers({ channel: { ...channel, lang: 'it', site_id: 'IT#4086' } })).toEqual({
|
|
'X-SkyOTT-Territory': 'IT'
|
|
})
|
|
expect(request.headers({ channel: uhdChannel })).toEqual({
|
|
'X-SkyOTT-Proposition': 'SKYQ',
|
|
'X-SkyOTT-Provider': 'SKY',
|
|
'X-SkyOTT-Territory': 'GB'
|
|
})
|
|
expect(request.cache.vary).toEqual(['X-SkyOTT-Territory'])
|
|
})
|
|
|
|
it('can parse response', async () => {
|
|
const content = fs.readFileSync(path.join(__dirname, '__data__', 'content1.json'))
|
|
const result = (await parser({ config: { days: 1 }, content, channel, date })).map(p => {
|
|
p.start = p.start.toJSON()
|
|
p.stop = p.stop.toJSON()
|
|
return p
|
|
})
|
|
|
|
expect(result.length).toBe(30)
|
|
expect(result[0]).toMatchObject({
|
|
start: '2026-06-07T23:45:00.000Z',
|
|
stop: '2026-06-08T00:45:00.000Z',
|
|
title: 'The UnBelievable With Dan Aykroyd',
|
|
description:
|
|
"Bizarre Innovations: Discover bizarre innovations like a fully functioning car that hovers in midair. Or clothing made out of everyone's favorite source of calcium. (S2, ep 6)",
|
|
season: 2,
|
|
episode: 6,
|
|
icon: 'https://images.metadata.sky.com/pd-image/007ade72-3239-47d7-a452-3070eb8e591d/16-9/640',
|
|
image: 'https://images.metadata.sky.com/pd-image/007ade72-3239-47d7-a452-3070eb8e591d/16-9/640'
|
|
})
|
|
expect(result[29]).toMatchObject({
|
|
start: '2026-06-08T23:00:00.000Z',
|
|
stop: '2026-06-09T00:00:00.000Z',
|
|
title: 'Digging For Britain',
|
|
description:
|
|
"The Tudors: Dr Alice Roberts pays tribute to the Bard, visiting Shakespeare's first theatre in London's Shoreditch and sifting through the poet's rubbish! (S1, ep 4)",
|
|
season: 1,
|
|
episode: 4,
|
|
icon: 'https://images.metadata.sky.com/pd-image/68152ae7-97d6-44c8-8a54-e78710b94a76/16-9/640',
|
|
image: 'https://images.metadata.sky.com/pd-image/68152ae7-97d6-44c8-8a54-e78710b94a76/16-9/640'
|
|
})
|
|
expect(axios.get).toHaveBeenCalledWith(url({ channel, date: date.add(1, 'd') }), {
|
|
headers: {
|
|
'X-SkyOTT-Territory': 'GB'
|
|
}
|
|
})
|
|
})
|
|
|
|
it('only loads a follow-up batch for the final requested date', async () => {
|
|
await parser({
|
|
config: { days: 2 },
|
|
content: '',
|
|
channel,
|
|
date
|
|
})
|
|
expect(axios.get).not.toHaveBeenCalled()
|
|
|
|
await parser({
|
|
config: { days: 2 },
|
|
content: '',
|
|
channel,
|
|
date: date.add(1, 'd')
|
|
})
|
|
expect(axios.get).toHaveBeenCalledTimes(1)
|
|
expect(axios.get).toHaveBeenCalledWith(url({ channel, date: date.add(2, 'd') }), {
|
|
headers: {
|
|
'X-SkyOTT-Territory': 'GB'
|
|
}
|
|
})
|
|
})
|
|
|
|
it('loads a shared follow-up batch only once', async () => {
|
|
const sids = url({ channel, date }).split('/').pop().split(',')
|
|
const companion = {
|
|
...channel,
|
|
site_id: `GB#${sids.find(sid => sid !== '4086')}`
|
|
}
|
|
const finalDate = date.add(2, 'd')
|
|
|
|
await Promise.all([
|
|
parser({ config: { days: 3 }, content: '', channel, date: finalDate }),
|
|
parser({ config: { days: 3 }, content: '', channel: companion, date: finalDate })
|
|
])
|
|
|
|
expect(axios.get).toHaveBeenCalledTimes(1)
|
|
expect(axios.get).toHaveBeenCalledWith(url({ channel, date: finalDate.add(1, 'd') }), {
|
|
headers: {
|
|
'X-SkyOTT-Territory': 'GB'
|
|
}
|
|
})
|
|
})
|
|
|
|
it('loads an UHD follow-up schedule from Atlantis', async () => {
|
|
const finalDate = date.add(1, 'd')
|
|
|
|
await parser({
|
|
config: { days: 2 },
|
|
content: '',
|
|
channel: uhdChannel,
|
|
date: finalDate
|
|
})
|
|
|
|
expect(axios.get).toHaveBeenCalledTimes(1)
|
|
expect(axios.get).toHaveBeenCalledWith('https://atlantis.epgsky.com/as/schedule/20260610/1336', {
|
|
headers: {
|
|
'X-SkyOTT-Proposition': 'SKYQ',
|
|
'X-SkyOTT-Provider': 'SKY',
|
|
'X-SkyOTT-Territory': 'GB'
|
|
}
|
|
})
|
|
})
|
|
|
|
it('can handle empty guide', async () => {
|
|
const result = await parser({
|
|
config: { days: 2 },
|
|
date,
|
|
channel,
|
|
content: ''
|
|
})
|
|
expect(result).toMatchObject([])
|
|
})
|
|
|
|
it('keeps identical event IDs isolated by territory', async () => {
|
|
const content = JSON.stringify({
|
|
schedule: [
|
|
{
|
|
sid: '123',
|
|
events: [
|
|
{
|
|
eid: 'shared-event',
|
|
st: date.unix(),
|
|
d: 3600,
|
|
t: 'Shared event'
|
|
}
|
|
]
|
|
}
|
|
]
|
|
})
|
|
const englishChannel = { lang: 'en', site_id: 'GB#123' }
|
|
const germanChannel = { lang: 'de', site_id: 'DE#123' }
|
|
|
|
expect(await parser({ content, channel: englishChannel, date })).toHaveLength(1)
|
|
expect(await parser({ content, channel: germanChannel, date })).toHaveLength(1)
|
|
expect(await parser({ content, channel: englishChannel, date })).toHaveLength(0)
|
|
})
|
|
|
|
it('can load and deduplicate all territories by language and site ID', async () => {
|
|
axios.get.mockImplementation((url, options) => {
|
|
const territory = options.headers['X-SkyOTT-Territory']
|
|
const titles = {
|
|
DE: 'Sky One Deutschland HD',
|
|
GB: 'Sky One HD',
|
|
IT: 'Sky Uno HD'
|
|
}
|
|
|
|
if (url.endsWith('/regions')) {
|
|
return Promise.resolve({
|
|
data: {
|
|
regions: [
|
|
{ bouquetId: 1, subBouquetId: 2 },
|
|
{ bouquetId: 1, subBouquetId: 2 }
|
|
]
|
|
},
|
|
headers: {},
|
|
request: {}
|
|
})
|
|
}
|
|
|
|
if (url.includes('atlantis.epgsky.com')) {
|
|
return Promise.resolve({
|
|
data: {
|
|
services: [
|
|
{ schedule: true, sid: '123', t: `${titles[territory]} Atlantis` },
|
|
{ schedule: true, sid: '456', t: `${territory} UHD` },
|
|
{ schedule: false, sid: '789', t: `${territory} Internal` }
|
|
]
|
|
},
|
|
headers: {},
|
|
request: {}
|
|
})
|
|
}
|
|
|
|
return Promise.resolve({
|
|
data: {
|
|
services: [
|
|
{ sid: '123', t: titles[territory] },
|
|
{ sid: '123', t: titles[territory] },
|
|
...(territory === 'IT' ? [{ sid: '582' }] : [])
|
|
]
|
|
},
|
|
headers: {},
|
|
request: {}
|
|
})
|
|
})
|
|
|
|
const result = await channels()
|
|
|
|
expect(result).toHaveLength(6)
|
|
expect(result).toEqual(
|
|
expect.arrayContaining([
|
|
{
|
|
lang: 'de',
|
|
site_id: 'DE#123',
|
|
name: 'Sky One Deutschland HD'
|
|
},
|
|
{
|
|
lang: 'de',
|
|
site_id: 'DE#456',
|
|
name: 'DE UHD'
|
|
},
|
|
{
|
|
lang: 'en',
|
|
site_id: 'GB#123',
|
|
name: 'Sky One HD'
|
|
},
|
|
{
|
|
lang: 'en',
|
|
site_id: 'GB#456',
|
|
name: 'GB UHD'
|
|
},
|
|
{
|
|
lang: 'it',
|
|
site_id: 'IT#123',
|
|
name: 'Sky Uno HD'
|
|
},
|
|
{
|
|
lang: 'it',
|
|
site_id: 'IT#456',
|
|
name: 'IT UHD'
|
|
}
|
|
])
|
|
)
|
|
expect(result).not.toEqual(
|
|
expect.arrayContaining([
|
|
expect.objectContaining({
|
|
site_id: expect.stringMatching(/#789$/)
|
|
})
|
|
])
|
|
)
|
|
expect(axios.get).toHaveBeenCalledTimes(9)
|
|
expect(axios.get.mock.calls.map(([, options]) => options.headers)).toEqual(
|
|
expect.arrayContaining([
|
|
{ 'X-SkyOTT-Territory': 'GB' },
|
|
{ 'X-SkyOTT-Territory': 'DE' },
|
|
{ 'X-SkyOTT-Territory': 'IT' },
|
|
{
|
|
'X-SkyOTT-Proposition': 'SKYQ',
|
|
'X-SkyOTT-Provider': 'SKY',
|
|
'X-SkyOTT-Territory': 'GB'
|
|
},
|
|
{
|
|
'X-SkyOTT-Proposition': 'SKYQ',
|
|
'X-SkyOTT-Provider': 'SKY',
|
|
'X-SkyOTT-Territory': 'DE'
|
|
},
|
|
{
|
|
'X-SkyOTT-Proposition': 'SKYQ',
|
|
'X-SkyOTT-Provider': 'SKY',
|
|
'X-SkyOTT-Territory': 'IT'
|
|
}
|
|
])
|
|
)
|
|
})
|
|
|
|
it('rejects unsupported channel territories', () => {
|
|
expect(() => request.headers({ channel: { ...channel, site_id: 'FR#4086' } })).toThrow(
|
|
'territory "DE", "GB" or "IT"'
|
|
)
|
|
})
|
|
|
|
it('rejects an incomplete channel list', async () => {
|
|
axios.get.mockImplementation((url, options) => {
|
|
if (url.endsWith('/regions')) {
|
|
return Promise.resolve({
|
|
data: {
|
|
regions: [{ bouquetId: 1, subBouquetId: 2 }]
|
|
},
|
|
headers: {},
|
|
request: {}
|
|
})
|
|
}
|
|
|
|
if (options.headers['X-SkyOTT-Territory'] === 'DE') {
|
|
return Promise.resolve({
|
|
data: {
|
|
services: [{ sid: '123', t: 'Sky One Deutschland HD' }]
|
|
},
|
|
headers: {},
|
|
request: {}
|
|
})
|
|
}
|
|
|
|
return Promise.resolve({
|
|
data: {},
|
|
headers: {},
|
|
request: {}
|
|
})
|
|
})
|
|
|
|
await expect(channels()).rejects.toThrow('Unable to load complete Sky channel list')
|
|
})
|