iptv-org/epg
1
0
Fork 0
mirror of https://github.com/iptv-org/epg synced 2026-09-08 21:06:57 -04:00
Code Issues Packages Projects Releases Wiki Activity

feat: added sky.com for different europe countries

Browse Source
This commit is contained in:
knylbyte
2026-07-29 18:08:51 +02:00
parent e0e04036a7
commit ba706bb6c1
11 changed files with 2006 additions and 976 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sites/sky.com/__data__/regions.json
-98
View File
@@ -1,98 +0,0 @@
{
"regions": [
{ "text": "Atherstone HD", "bouquet": 4101, "subBouquet": 19, "value": "4101-19" },
{ "text": "Atherstone SD", "bouquet": 4097, "subBouquet": 19, "value": "4097-19" },
{ "text": "Border England HD", "bouquet": 4101, "subBouquet": 12, "value": "4101-12" },
{ "text": "Border England SD", "bouquet": 4097, "subBouquet": 12, "value": "4097-12" },
{ "text": "Border Scotland HD", "bouquet": 4102, "subBouquet": 36, "value": "4102-36" },
{ "text": "Border Scotland SD", "bouquet": 4098, "subBouquet": 36, "value": "4098-36" },
{ "text": "Brighton HD", "bouquet": 4103, "subBouquet": 65, "value": "4103-65" },
{ "text": "Brighton SD", "bouquet": 4099, "subBouquet": 65, "value": "4099-65" },
{ "text": "Central Midlands HD", "bouquet": 4101, "subBouquet": 3, "value": "4101-3" },
{ "text": "Central Midlands SD", "bouquet": 4097, "subBouquet": 3, "value": "4097-3" },
{ "text": "Channel Isles HD", "bouquet": 4104, "subBouquet": 34, "value": "4104-34" },
{ "text": "Channel Isles SD", "bouquet": 4100, "subBouquet": 34, "value": "4100-34" },
{ "text": "Dundee HD", "bouquet": 4102, "subBouquet": 39, "value": "4102-39" },
{ "text": "Dundee SD", "bouquet": 4098, "subBouquet": 39, "value": "4098-39" },
{ "text": "East Midlands HD", "bouquet": 4101, "subBouquet": 20, "value": "4101-20" },
{ "text": "East Midlands SD", "bouquet": 4097, "subBouquet": 20, "value": "4097-20" },
{ "text": "Essex HD", "bouquet": 4101, "subBouquet": 2, "value": "4101-2" },
{ "text": "Essex SD", "bouquet": 4097, "subBouquet": 2, "value": "4097-2" },
{ "text": "Gloucester HD", "bouquet": 4101, "subBouquet": 24, "value": "4101-24" },
{ "text": "Gloucester SD", "bouquet": 4097, "subBouquet": 24, "value": "4097-24" },
{ "text": "Grampian HD", "bouquet": 4102, "subBouquet": 35, "value": "4102-35" },
{ "text": "Grampian SD", "bouquet": 4098, "subBouquet": 35, "value": "4098-35" },
{ "text": "Granada HD", "bouquet": 4101, "subBouquet": 7, "value": "4101-7" },
{ "text": "Granada SD", "bouquet": 4097, "subBouquet": 7, "value": "4097-7" },
{ "text": "HTV West HD", "bouquet": 4101, "subBouquet": 4, "value": "4101-4" },
{ "text": "HTV West SD", "bouquet": 4097, "subBouquet": 4, "value": "4097-4" },
{ "text": "HTV West / Thames Valley HD", "bouquet": 4103, "subBouquet": 63, "value": "4103-63" },
{ "text": "HTV West / Thames Valley SD", "bouquet": 4099, "subBouquet": 63, "value": "4099-63" },
{ "text": "Henley On Thames HD", "bouquet": 4103, "subBouquet": 70, "value": "4103-70" },
{ "text": "Henley On Thames SD", "bouquet": 4099, "subBouquet": 70, "value": "4099-70" },
{ "text": "Humber HD", "bouquet": 4101, "subBouquet": 29, "value": "4101-29" },
{ "text": "Humber SD", "bouquet": 4097, "subBouquet": 29, "value": "4097-29" },
{ "text": "London HD", "bouquet": 4101, "subBouquet": 1, "value": "4101-1" },
{ "text": "London SD", "bouquet": 4097, "subBouquet": 1, "value": "4097-1" },
{ "text": "London / Essex HD", "bouquet": 4101, "subBouquet": 18, "value": "4101-18" },
{ "text": "London / Essex SD", "bouquet": 4097, "subBouquet": 18, "value": "4097-18" },
{ "text": "London / Thames Valley HD", "bouquet": 4103, "subBouquet": 66, "value": "4103-66" },
{ "text": "London / Thames Valley SD", "bouquet": 4099, "subBouquet": 66, "value": "4099-66" },
{ "text": "London Kent HD", "bouquet": 4103, "subBouquet": 64, "value": "4103-64" },
{ "text": "London Kent SD", "bouquet": 4099, "subBouquet": 64, "value": "4099-64" },
{ "text": "Meridian East HD", "bouquet": 4101, "subBouquet": 11, "value": "4101-11" },
{ "text": "Meridian East SD", "bouquet": 4097, "subBouquet": 11, "value": "4097-11" },
{ "text": "Meridian North HD", "bouquet": 4103, "subBouquet": 68, "value": "4103-68" },
{ "text": "Meridian North SD", "bouquet": 4099, "subBouquet": 68, "value": "4099-68" },
{ "text": "Meridian South HD", "bouquet": 4101, "subBouquet": 5, "value": "4101-5" },
{ "text": "Meridian South SD", "bouquet": 4097, "subBouquet": 5, "value": "4097-5" },
{ "text": "Meridian South East HD", "bouquet": 4101, "subBouquet": 10, "value": "4101-10" },
{ "text": "Meridian South East SD", "bouquet": 4097, "subBouquet": 10, "value": "4097-10" },
{ "text": "Merseyside HD", "bouquet": 4103, "subBouquet": 45, "value": "4103-45" },
{ "text": "Merseyside SD", "bouquet": 4099, "subBouquet": 45, "value": "4099-45" },
{ "text": "Norfolk HD", "bouquet": 4101, "subBouquet": 21, "value": "4101-21" },
{ "text": "Norfolk SD", "bouquet": 4097, "subBouquet": 21, "value": "4097-21" },
{ "text": "North East Midlands HD", "bouquet": 4103, "subBouquet": 62, "value": "4103-62" },
{ "text": "North East Midlands SD", "bouquet": 4099, "subBouquet": 62, "value": "4099-62" },
{ "text": "North West Yorkshire HD", "bouquet": 4101, "subBouquet": 8, "value": "4101-8" },
{ "text": "North West Yorkshire SD", "bouquet": 4097, "subBouquet": 8, "value": "4097-8" },
{ "text": "North Yorkshire HD", "bouquet": 4101, "subBouquet": 26, "value": "4101-26" },
{ "text": "North Yorkshire SD", "bouquet": 4097, "subBouquet": 26, "value": "4097-26" },
{ "text": "Northern Ireland HD", "bouquet": 4104, "subBouquet": 33, "value": "4104-33" },
{ "text": "Northern Ireland SD", "bouquet": 4100, "subBouquet": 33, "value": "4100-33" },
{ "text": "Oxford HD", "bouquet": 4103, "subBouquet": 71, "value": "4103-71" },
{ "text": "Oxford SD", "bouquet": 4099, "subBouquet": 71, "value": "4099-71" },
{ "text": "Republic of Ireland HD", "bouquet": 4104, "subBouquet": 50, "value": "4104-50" },
{ "text": "Republic of Ireland SD", "bouquet": 4100, "subBouquet": 50, "value": "4100-50" },
{ "text": "Ridge Hill HD", "bouquet": 4103, "subBouquet": 41, "value": "4103-41" },
{ "text": "Ridge Hill SD", "bouquet": 4099, "subBouquet": 41, "value": "4099-41" },
{ "text": "Scarborough HD", "bouquet": 4103, "subBouquet": 61, "value": "4103-61" },
{ "text": "Scarborough SD", "bouquet": 4099, "subBouquet": 61, "value": "4099-61" },
{ "text": "Scottish East HD", "bouquet": 4102, "subBouquet": 38, "value": "4102-38" },
{ "text": "Scottish East SD", "bouquet": 4098, "subBouquet": 38, "value": "4098-38" },
{ "text": "Scottish West HD", "bouquet": 4102, "subBouquet": 37, "value": "4102-37" },
{ "text": "Scottish West SD", "bouquet": 4098, "subBouquet": 37, "value": "4098-37" },
{ "text": "Sheffield HD", "bouquet": 4103, "subBouquet": 60, "value": "4103-60" },
{ "text": "Sheffield SD", "bouquet": 4099, "subBouquet": 60, "value": "4099-60" },
{ "text": "South Lakeland HD", "bouquet": 4101, "subBouquet": 28, "value": "4101-28" },
{ "text": "South Lakeland SD", "bouquet": 4097, "subBouquet": 28, "value": "4097-28" },
{ "text": "South Yorkshire HD", "bouquet": 4103, "subBouquet": 72, "value": "4103-72" },
{ "text": "South Yorkshire SD", "bouquet": 4099, "subBouquet": 72, "value": "4099-72" },
{ "text": "Tees HD", "bouquet": 4103, "subBouquet": 69, "value": "4103-69" },
{ "text": "Tees SD", "bouquet": 4099, "subBouquet": 69, "value": "4099-69" },
{ "text": "Thames Valley HD", "bouquet": 4101, "subBouquet": 9, "value": "4101-9" },
{ "text": "Thames Valley SD", "bouquet": 4097, "subBouquet": 9, "value": "4097-9" },
{ "text": "Tring HD", "bouquet": 4101, "subBouquet": 27, "value": "4101-27" },
{ "text": "Tring SD", "bouquet": 4097, "subBouquet": 27, "value": "4097-27" },
{ "text": "Tyne HD", "bouquet": 4101, "subBouquet": 13, "value": "4101-13" },
{ "text": "Tyne SD", "bouquet": 4097, "subBouquet": 13, "value": "4097-13" },
{ "text": "Wales HD", "bouquet": 4104, "subBouquet": 32, "value": "4104-32" },
{ "text": "Wales SD", "bouquet": 4100, "subBouquet": 32, "value": "4100-32" },
{ "text": "West Anglia HD", "bouquet": 4101, "subBouquet": 25, "value": "4101-25" },
{ "text": "West Anglia SD", "bouquet": 4097, "subBouquet": 25, "value": "4097-25" },
{ "text": "West Dorset HD", "bouquet": 4103, "subBouquet": 67, "value": "4103-67" },
{ "text": "West Dorset SD", "bouquet": 4099, "subBouquet": 67, "value": "4099-67" },
{ "text": "Westcountry HD", "bouquet": 4101, "subBouquet": 6, "value": "4101-6" },
{ "text": "Westcountry SD", "bouquet": 4097, "subBouquet": 6, "value": "4097-6" }
]
}
sites/sky.com/readme.md
+4
View File
@@ -2,6 +2,10 @@
https://www.sky.com/tv-guide
All Sky countries are covered: Germany, Austria and Switzerland (`DE`), the United Kingdom and Ireland (`GB`), and Italy (`IT`).
Channel IDs use the format `<territory>#<sid>` (`GB#...`, `IT#...` or `DE#...`).
### Download the guide
```sh
sites/sky.com/sky.com.channels.xml
+1487 -524
View File
File diff suppressed because it is too large Load Diff
sites/sky.com/sky.com.config.js
+275 -99
View File
@@ -1,137 +1,313 @@
const axios = require('axios')
const dayjs = require('dayjs')
const utc = require('dayjs/plugin/utc')
const doFetch = require('@ntlab/sfetch')
const debug = require('debug')('site:sky.com')
const fs = require('fs')
const path = require('path')
const fs = require('fs/promises')
const utc = require('dayjs/plugin/utc')
dayjs.extend(utc)
doFetch.setCheckResult(false).setDebugger(debug)
const eventIds = []
const API_ENDPOINT = 'https://awk.epgsky.com/hawk/linear'
const CHANNELS_FILE = path.join(__dirname, 'sky.com.channels.xml')
const LANG_BY_TERRITORY = {
DE: 'de',
GB: 'en',
IT: 'it'
}
const MAX_SIDS_PER_REQUEST = 20
const GRAB_START_DATE = dayjs
.utc(process.env.CURR_DATE || new Date().toISOString())
.startOf('d')
const eventIds = new Set()
const scheduleRequests = new Map()
let scheduleBatches
module.exports = {
site: 'sky.com',
days: 2,
request: {
headers({ channel }) {
return getHeaders(parseSiteId(channel.site_id).territory)
},
cache: {
ttl: 24 * 60 * 60 * 1000 // 1 day
ttl: 24 * 60 * 60 * 1000, // 1 day
vary: ['X-SkyOTT-Territory']
}
},
url({ date, channel }) {
return `https://awk.epgsky.com/hawk/linear/schedule/${date.format('YYYYMMDD')}/${
channel.site_id
}`
const { sid } = parseSiteId(channel.site_id)
const sids = getScheduleBatch(channel.site_id) || [sid]
return `${API_ENDPOINT}/schedule/${date.format('YYYYMMDD')}/${sids.join(',')}`
},
async parser({ content, channel, date }) {
async parser({ content, channel, date, config }) {
const programs = []
if (content) {
const events = {}
const ev = items => {
if (typeof items === 'string' || Buffer.isBuffer(items)) {
items = JSON.parse(items)
}
if (Array.isArray(items?.schedule)) {
items.schedule
.filter(schedule => schedule.sid === channel.site_id)
.forEach(schedule => {
if (Array.isArray(schedule.events)) {
schedule.events
.filter(event => !eventIds.includes(event.eid))
.forEach(event => {
// use event id (eid) as unique filter
if (events[event.eid] === undefined) {
events[event.eid] = event
}
})
}
})
}
const events = new Map()
const range = getGrabRange(config)
collectEvents(content, channel, events)
date = date.startOf('d')
if (date.isSame(range.lastDate, 'd')) {
try {
const response = await getSchedule(channel, date.add(1, 'd'))
collectEvents(response, channel, events)
} catch (error) {
debug('Unable to load the final Sky schedule batch: %s', error.message)
}
ev(content)
if (Object.keys(events).length) {
date = date.startOf('d')
// fetch next day schedule to get 24 hours schedule
await doFetch([module.exports.url({ channel, date: date.add(1, 'd') })], (url, res) => {
if (res) {
ev(res)
}
}
for (const event of events.values()) {
const start = dayjs.utc(event.st * 1000)
const stop = start.add(event.d, 's')
const eventId = getEventId(channel, event)
if (
start.isBefore(range.stop) &&
stop.isAfter(range.start) &&
!eventIds.has(eventId)
) {
eventIds.add(eventId)
const image = event.programmeuuid
? `https://images.metadata.sky.com/pd-image/${event.programmeuuid}/16-9/640`
: null
programs.push({
title: event.t,
description: event.sy,
season: event.seasonnumber,
episode: event.episodenumber,
start,
stop,
icon: image,
image
})
Object.values(events)
.forEach(event => {
const start = dayjs.utc(event.st * 1000)
const stop = start.add(event.d, 's')
if (date.isSame(start, 'd') || (date.isSame(stop, 'd') && stop > date)) {
eventIds.push(event.eid)
const image = `https://images.metadata.sky.com/pd-image/${event.programmeuuid}/16-9/640`
programs.push({
title: event.t,
description: event.sy,
season: event.seasonnumber,
episode: event.episodenumber,
start,
stop,
icon: image,
image
})
}
})
}
}
return programs
},
async channels() {
const dataPath = path.join(__dirname, '__data__', 'regions.json')
const regions = []
try {
const raw = await fs.readFile(dataPath, 'utf8')
const payload = JSON.parse(raw)
if (Array.isArray(payload.regions)) {
regions.push(...payload.regions)
const territories = Object.entries(LANG_BY_TERRITORY)
const queue = territories.map(([territory, lang]) => ({
type: 'regions',
lang,
territory,
url: `${API_ENDPOINT}/regions`,
params: {
headers: getHeaders(territory)
}
} catch (err) {
debug('Failed to read regions from %s: %o', dataPath, err)
throw err
}
if (regions.length === 0) {
debug('No regions defined in %s', dataPath)
return []
}
const uniqueRegions = new Map()
regions.forEach(region => {
if (!region || region.bouquet === undefined || region.subBouquet === undefined) return
const key = `${region.bouquet}-${region.subBouquet}`
if (!uniqueRegions.has(key)) uniqueRegions.set(key, region)
})
const channels = {}
const queues = Array.from(uniqueRegions.values()).map(region => ({
t: 'c',
url: `https://awk.epgsky.com/hawk/linear/services/${region.bouquet}/${region.subBouquet}`
}))
const channels = new Map()
const regions = new Set()
const failures = []
const states = new Map(
territories.map(([territory]) => [
territory,
{
channels: 0,
regionsLoaded: false,
serviceRequests: 0,
serviceResponses: 0
}
])
)
await doFetch(queues, (queue, res) => {
// process channels
if (queue.t === 'c') {
if (Array.isArray(res.services)) {
for (const ch of res.services) {
if (channels[ch.sid] === undefined) {
channels[ch.sid] = {
lang: 'en',
site_id: ch.sid,
name: ch.t
}
}
await doFetch(queue, (request, response) => {
const state = states.get(request.territory)
if (request.type === 'regions') {
if (!Array.isArray(response?.regions) || !response.regions.length) {
failures.push(`${request.territory}: ${request.url}`)
return
}
state.regionsLoaded = true
for (const region of response.regions) {
if (region?.bouquetId === undefined || region?.subBouquetId === undefined) {
failures.push(`${request.territory}: ${request.url} (invalid region)`)
continue
}
const regionId = `${region.bouquetId}/${region.subBouquetId}`
const key = `${request.territory}:${regionId}`
if (regions.has(key)) continue
regions.add(key)
state.serviceRequests++
queue.push({
type: 'services',
lang: request.lang,
territory: request.territory,
url: `${API_ENDPOINT}/services/${regionId}`,
params: {
headers: getHeaders(request.territory)
}
})
}
return
}
if (!Array.isArray(response?.services)) {
failures.push(`${request.territory}: ${request.url}`)
return
}
state.serviceResponses++
for (const service of response.services) {
if (service?.sid === undefined) {
failures.push(`${request.territory}: ${request.url} (invalid service)`)
continue
}
if (!service.t) continue
const siteId = `${request.territory}#${service.sid}`
if (!channels.has(siteId)) {
channels.set(siteId, {
lang: request.lang,
site_id: siteId,
name: service.t
})
state.channels++
}
}
})
return Object.values(channels)
const incomplete = [...states]
.filter(
([, state]) =>
!state.regionsLoaded ||
!state.serviceRequests ||
state.serviceResponses !== state.serviceRequests ||
!state.channels
)
.map(([territory]) => territory)
if (incomplete.length || failures.length) {
const reasons = [...new Set([...failures, ...incomplete])].join(', ')
throw new Error(
`Unable to load complete Sky channel list: ${reasons || 'no channels found'}`
)
}
return [...channels.values()]
}
}
function getHeaders(territory) {
return {
'X-SkyOTT-Territory': territory
}
}
function getEventId(channel, event) {
return `${channel.site_id}:${event.eid}`
}
function getGrabRange(config) {
const configuredDays = Number(config?.days)
const days = Number.isInteger(configuredDays) && configuredDays > 0
? configuredDays
: module.exports.days
const stop = GRAB_START_DATE.add(days, 'd')
return {
lastDate: stop.subtract(1, 'd'),
start: GRAB_START_DATE,
stop
}
}
function getSchedule(channel, date) {
const { territory } = parseSiteId(channel.site_id)
const url = module.exports.url({ channel, date })
const key = `${territory}:${url}`
if (!scheduleRequests.has(key)) {
const request = axios
.get(url, {
headers: getHeaders(territory)
})
.then(response => response.data)
.catch(error => {
scheduleRequests.delete(key)
throw error
})
scheduleRequests.set(key, request)
}
return scheduleRequests.get(key)
}
function getScheduleBatch(siteId) {
if (!scheduleBatches) scheduleBatches = loadScheduleBatches()
return scheduleBatches.get(siteId)
}
function loadScheduleBatches() {
const channelsXml = fs.readFileSync(CHANNELS_FILE, 'utf8')
const sidsByTerritory = new Map(
Object.keys(LANG_BY_TERRITORY).map(territory => [territory, new Set()])
)
for (const match of channelsXml.matchAll(/\bsite_id="([^"]+)"/g)) {
const { sid, territory } = parseSiteId(match[1])
sidsByTerritory.get(territory).add(sid)
}
const batches = new Map()
for (const [territory, sidSet] of sidsByTerritory) {
const sids = [...sidSet]
for (let index = 0; index < sids.length; index += MAX_SIDS_PER_REQUEST) {
const batch = sids.slice(index, index + MAX_SIDS_PER_REQUEST)
for (const sid of batch) {
batches.set(`${territory}#${sid}`, batch)
}
}
}
return batches
}
function collectEvents(content, channel, events) {
const data = parseContent(content)
if (!Array.isArray(data?.schedule)) return
const { sid } = parseSiteId(channel.site_id)
for (const schedule of data.schedule) {
if (String(schedule.sid) !== sid || !Array.isArray(schedule.events)) continue
for (const event of schedule.events) {
if (event?.eid !== undefined && !events.has(event.eid)) {
events.set(event.eid, event)
}
}
}
}
function parseSiteId(siteId) {
const [territory, sid, ...extra] = String(siteId || '').split('#')
if (!LANG_BY_TERRITORY[territory] || !sid || extra.length) {
throw new Error(
`Invalid Sky site_id "${siteId || ''}". Expected "<territory>#<sid>" with territory "DE", "GB" or "IT".`
)
}
return { sid, territory }
}
function parseContent(content) {
if (!content) return null
try {
if (Buffer.isBuffer(content)) content = content.toString()
return typeof content === 'string' ? JSON.parse(content) : content
} catch {
return null
}
}
sites/sky.com/sky.com.test.js
+239 -10
View File
@@ -1,4 +1,6 @@
const { parser, url } = require('./sky.com.config.js')
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')
@@ -13,29 +15,73 @@ jest.mock('axios')
const date = dayjs.utc('2026-06-08').startOf('d')
const channel = {
site_id: '4086',
lang: 'en',
site_id: 'GB#4086',
xmltv_id: 'SkyHistory.uk@HD'
}
axios.get.mockImplementation(url => {
function mockScheduleRequest(url) {
const urls = {
'https://awk.epgsky.com/hawk/linear/schedule/20260608/4086': 'content1.json',
'https://awk.epgsky.com/hawk/linear/schedule/20260609/4086': 'content2.json'
'20260608': 'content1.json',
'20260609': 'content2.json'
}
let data = ''
if (urls[url] !== undefined) {
data = fs.readFileSync(path.join(__dirname, '__data__', urls[url])).toString()
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 })
return Promise.resolve({ data, headers: {}, request: {} })
}
beforeEach(() => {
jest.clearAllMocks()
axios.get.mockImplementation(mockScheduleRequest)
})
it('can generate valid url', () => {
expect(url({ channel, date })).toBe('https://awk.epgsky.com/hawk/linear/schedule/20260608/4086')
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('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.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({ content, channel, date }))
const result = (await parser({ config: { days: 1 }, content, channel, date }))
.map(p => {
p.start = p.start.toJSON()
p.stop = p.stop.toJSON()
@@ -65,13 +111,196 @@ it('can parse response', async () => {
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('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: {}
})
}
return Promise.resolve({
data: {
services: [
{ sid: '123', t: titles[territory] },
{ sid: '123', t: titles[territory] },
...(territory === 'IT' ? [{ sid: '582' }] : [])
]
},
headers: {},
request: {}
})
})
await expect(channels()).resolves.toEqual([
{
lang: 'de',
site_id: 'DE#123',
name: 'Sky One Deutschland HD'
},
{
lang: 'en',
site_id: 'GB#123',
name: 'Sky One HD'
},
{
lang: 'it',
site_id: 'IT#123',
name: 'Sky Uno HD'
}
])
expect(axios.get).toHaveBeenCalledTimes(6)
expect(axios.get.mock.calls.map(([, options]) => options.headers)).toEqual(
expect.arrayContaining([
{ 'X-SkyOTT-Territory': 'GB' },
{ 'X-SkyOTT-Territory': 'DE' },
{ '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')
})