A spy satellite simulator in your browser, except the data is real. Live open source spatial intelligence on a photorealistic 3D globe.
JavaScript 3d-globecesiumflight-trackinggeospatialgeospatial-intelligencegisosintphotogrammetrysatellite-trackingspatial-intelligencewebglworldview
import { readFileSync } from 'node:fs';
import test from 'node:test';
import assert from 'node:assert/strict';
import {
TRANSIT_ENABLED_FEEDS,
TRANSIT_FEED_REGISTRY,
TRANSIT_FEED_ID_PATTERN,
TRANSIT_MODES,
getRegisteredTransitFeed,
getTransitFeed,
haversineKm,
publicTransitCatalog,
transitFeedsInRange,
transitModeFor,
transitModeResolved,
transitRouteLabel,
} from './transitFeeds.js';
test('every registered feed is keyless, https, licensed, and uniquely identified', () => {
const ids = new Set();
for (const feed of TRANSIT_FEED_REGISTRY) {
assert.match(
feed.id,
TRANSIT_FEED_ID_PATTERN,
`${feed.id} is a valid path segment`,
);
assert.equal(ids.has(feed.id), false, `${feed.id} is unique`);
ids.add(feed.id);
const url = new URL(feed.url);
assert.equal(url.protocol, 'https:', `${feed.id} fetches over https`);
assert.equal(
url.search.includes('key='),
false,
`${feed.id} carries no key in its URL`,
);
assert.ok(
feed.license && feed.licenseUrl && feed.attribution,
`${feed.id} names its license`,
);
assert.ok(
feed.loadRadiusKm > 0 && feed.loadRadiusKm <= 1000,
`${feed.id} radius is sane`,
);
assert.ok(
Math.abs(feed.center.lat) <= 90 && Math.abs(feed.center.lon) <= 180,
);
assert.ok(
TRANSIT_MODES.includes(feed.defaultMode),
`${feed.id} default mode is known`,
);
assert.ok(Object.isFrozen(feed), `${feed.id} is immutable`);
}
});
test('getTransitFeed is the only door to an upstream URL and refuses anything unregistered', () => {
assert.equal(
getTransitFeed('mbta')?.url,
'https://cdn.mbta.com/realtime/VehiclePositions.pb',
);
assert.equal(getTransitFeed('MBTA'), null);
assert.equal(getTransitFeed('../etc/passwd'), null);
assert.equal(getTransitFeed('https://evil.example'), null);
assert.equal(getTransitFeed(''), null);
assert.equal(getTransitFeed(null), null);
assert.equal(getTransitFeed(42), null);
});
test('haversine matches known city distances', () => {
const bostonToNyc = haversineKm(42.3601, -71.0589, 40.7128, -74.006);
assert.ok(
Math.abs(bostonToNyc - 306) < 5,
`Boston–NYC ≈ 306 km, got ${bostonToNyc}`,
);
assert.equal(haversineKm(0, 0, 0, 0), 0);
});
test('feeds in range are nearest-first and honor slack as hysteresis', () => {
// Camera over Cambridge, MA → MBTA only.
const boston = transitFeedsInRange(42.37, -71.11);
assert.deepEqual(
boston.map((f) => f.id),
['mbta'],
);
// Mid-Atlantic: nothing.
assert.deepEqual(transitFeedsInRange(40, -40), []);
// Just outside MBTA's 70 km circle (≈ 80 km south) — out without slack, in with 20 km slack.
const farLat = 42.3601 - 80 / 111;
assert.deepEqual(transitFeedsInRange(farLat, -71.0589), []);
assert.deepEqual(
transitFeedsInRange(farLat, -71.0589, 20).map((f) => f.id),
['mbta'],
);
// Bad input never throws.
assert.deepEqual(transitFeedsInRange(NaN, 1), []);
// A national feed covers its own cities and not the neighbour's capital.
for (const [city, lat, lon] of [
['Oslo', 59.91, 10.75],
['Bergen', 60.39, 5.32],
['Tromsø', 69.65, 18.96],
]) {
assert.ok(
transitFeedsInRange(lat, lon).some((f) => f.id === 'entur-norway'),
`${city} is covered by Entur`,
);
}
assert.deepEqual(
transitFeedsInRange(60.17, 24.94).map((f) => f.id),
['hsl-helsinki'],
'Helsinki polls HSL only',
);
});
test('route hints refine a feed default and never escape the known modes', () => {
const mbta = getTransitFeed('mbta');
assert.equal(transitModeFor(mbta, 'Red'), 'subway');
assert.equal(transitModeFor(mbta, 'Green-B'), 'tram');
assert.equal(transitModeFor(mbta, 'CR-Fitchburg'), 'rail');
assert.equal(transitModeFor(mbta, 'Boat-F1'), 'ferry');
assert.equal(transitModeFor(mbta, '66'), 'bus');
assert.equal(transitModeFor(mbta, null), 'bus');
const hsl = getTransitFeed('hsl-helsinki');
assert.equal(transitModeFor(hsl, '31M1'), 'subway');
assert.equal(transitModeFor(hsl, '1006'), 'tram');
assert.equal(transitModeFor(hsl, '9982'), 'bus');
const msp = getTransitFeed('metrotransit-msp');
assert.equal(transitModeFor(msp, '901'), 'tram');
assert.equal(transitModeFor(msp, '17'), 'bus');
const entur = getTransitFeed('entur-norway');
assert.equal(transitModeFor(entur, 'VYG:Line:R10'), 'rail');
assert.equal(transitModeFor(entur, 'TRO:Line:1_310'), 'bus');
assert.equal(transitModeFor({ defaultMode: 'spaceship' }, 'x'), 'unknown');
assert.equal(transitModeFor(null, 'x'), 'unknown');
});
test('the public catalog exposes coverage and credit, never the upstream URL or headers', () => {
const catalog = publicTransitCatalog();
assert.equal(catalog.length, TRANSIT_ENABLED_FEEDS.length);
for (const entry of catalog) {
assert.equal('url' in entry, false);
assert.equal('headers' in entry, false);
assert.ok(entry.id && entry.name && entry.region && entry.attribution);
assert.ok(
Number.isFinite(entry.center.lat) && Number.isFinite(entry.loadRadiusKm),
);
}
});
test('the enabled set is a gate on the registry, not a copy of it', () => {
// Every registered feed is switched on today. The gate still has to be the
// thing that decides that, because the moment an operator's terms change the
// owner flips one flag and expects the feed to become unreachable — not to
// stay routable because the filter had quietly become a no-op.
assert.deepEqual(
TRANSIT_ENABLED_FEEDS.map((feed) => feed.id),
TRANSIT_FEED_REGISTRY.filter((feed) => feed.defaultEnabled === true).map(
(feed) => feed.id,
),
);
for (const feed of TRANSIT_FEED_REGISTRY) {
assert.equal(
typeof feed.defaultEnabled,
'boolean',
`${feed.id} states whether it ships on`,
);
assert.equal(
Boolean(getTransitFeed(feed.id)),
feed.defaultEnabled,
`${feed.id} is routable exactly when it is enabled`,
);
assert.ok(getRegisteredTransitFeed(feed.id), `${feed.id} stays documented`);
}
});
test('a mode the route id established is resolved; a feed default is only a guess', () => {
// TransLink publishes rail in a feed whose default is bus. A consumer that
// judges physical plausibility must know the difference, or a 140 km/h
// train is refused as an impossible bus.
const translink = getTransitFeed('translink-seq');
assert.equal(transitModeFor(translink, '600'), 'bus');
assert.equal(transitModeResolved(translink, '600'), false, 'defaulted');
const mbta = getTransitFeed('mbta');
assert.equal(transitModeResolved(mbta, 'Red'), true);
assert.equal(
transitModeResolved(mbta, '66'),
true,
'a numeric MBTA route is a bus by rule, not by default',
);
assert.equal(transitModeResolved(mbta, null), false);
assert.equal(transitModeResolved({ defaultMode: 'bus' }, 'x'), false);
assert.equal(
transitModeResolved({ routeMode: () => 'spaceship' }, 'x'),
false,
'an unknown hint resolves nothing',
);
});
test('only MBTA retains proxy history while every other registered feed stays live-enabled', () => {
assert.deepEqual(
publicTransitCatalog()
.filter((feed) => feed.historyRetention)
.map((feed) => feed.id),
['mbta'],
);
assert.equal(getTransitFeed('capmetro-austin').defaultEnabled, true);
assert.equal(getTransitFeed('mbta').attribution, 'MBTA / MassDOT');
});
test('published transit history scope agrees with the catalog capability', () => {
const retained = publicTransitCatalog().filter(
(feed) => feed.historyRetention,
);
assert.deepEqual(
retained.map((feed) => feed.id),
['mbta'],
);
const sources = readFileSync(
new URL('../../DATA_SOURCES.md', import.meta.url),
'utf8',
);
const row = sources
.split('\n')
.find((line) => line.startsWith('| **MBTA / MassDOT**'));
assert.match(
row,
/live vehicles and up to 15 minutes of recently observed positions/,
);
assert.match(row, /MBTA \/ MassDOT.*courtesy/);
assert.match(sources, /other feeds have no proxy retention/);
const state = readFileSync(
new URL('../../docs/CURRENT-STATE.md', import.meta.url),
'utf8',
);
const transit = state.slice(
state.indexOf('Transit is off by default'),
state.indexOf('`src/data/militaryAwareness.js` remains'),
);
assert.match(transit, /Restart clears it/);
assert.doesNotMatch(
transit,
/four fixes|0\.95x|guaranteed lower|one poll interval behind/,
);
});
test('the TTC feed is registered, routable, and covers Toronto', () => {
const ttc = getTransitFeed('ttc-toronto');
assert.equal(ttc?.url, 'https://bustime.ttc.ca/gtfsrt/vehicles');
assert.equal(ttc.defaultEnabled, true);
assert.match(ttc.attribution, /Toronto Transit Commission/);
assert.equal(ttc.historyRetention, undefined, 'no proxy retention');
assert.ok(
transitFeedsInRange(43.6532, -79.3832).some(
(feed) => feed.id === 'ttc-toronto',
),
'downtown Toronto is inside the load radius',
);
});
test('TTC route numbers tell a streetcar from a bus', () => {
// BusTime is the surface feed: 500-series are streetcar routes and the
// streetcar-operated Blue Night routes keep their own numbers. Everything
// else on this feed is a bus, so the mode is established, not defaulted.
const ttc = getTransitFeed('ttc-toronto');
assert.equal(transitModeFor(ttc, '501'), 'tram');
assert.equal(transitModeFor(ttc, '512'), 'tram');
assert.equal(transitModeFor(ttc, '304'), 'tram');
assert.equal(transitModeFor(ttc, '36'), 'bus');
// 52 Lawrence West is a bus. Only the three-digit 500-series is streetcar,
// so the rule must not match on a leading 5 alone.
assert.equal(transitModeFor(ttc, '52'), 'bus');
assert.equal(transitModeFor(ttc, '59'), 'bus');
assert.equal(transitModeFor(ttc, '900'), 'bus');
assert.equal(transitModeFor(ttc, '352'), 'bus');
assert.equal(transitModeResolved(ttc, '501'), true);
assert.equal(transitModeResolved(ttc, null), false);
assert.equal(
transitModeFor(ttc, null),
'bus',
'an unrouted vehicle falls back to the feed default, unresolved',
);
});
test('a TTC fleet number outranks the route', () => {
// Buses replace streetcars on 5xx routes during track work, and streetcars
// out of service report no route; the Flexity fleet is 4400–4699.
const ttc = getTransitFeed('ttc-toronto');
assert.equal(transitModeFor(ttc, '506', '8515'), 'bus');
assert.equal(transitModeFor(ttc, '512', '3101'), 'bus');
assert.equal(transitModeFor(ttc, null, '4507'), 'tram');
assert.equal(transitModeResolved(ttc, null, '4507'), true);
assert.equal(transitModeFor(ttc, '504', '4400'), 'tram');
assert.equal(transitModeFor(ttc, '29', '4699'), 'tram');
assert.equal(transitModeFor(ttc, '501', '4700'), 'bus');
// A vehicle id that is not a fleet number leaves the route to decide.
assert.equal(transitModeFor(ttc, '501', 'abc'), 'tram');
assert.equal(transitModeFor(ttc, '501'), 'tram');
});
test('the TTC row records that BusTime carries no subway', () => {
const sources = readFileSync(
new URL('../../DATA_SOURCES.md', import.meta.url),
'utf8',
);
const row = sources.split('\n').find((line) => line.startsWith('| **TTC**'));
assert.ok(row, 'TTC has a DATA_SOURCES row');
assert.match(row, /Toronto/);
assert.match(sources, /surface vehicles \(buses and streetcars\) only/);
assert.match(sources, /Open Government Licence – Toronto/);
});
test('the Golden Horseshoe neighbours are registered, keyless and routable', () => {
const expected = {
'miway-mississauga':
'https://www.miapp.ca/GTFS_RT/Vehicle/VehiclePositions.pb',
'hsr-hamilton':
'https://opendata.hamilton.ca/GTFS-RT/GTFS_VehiclePositions.pb',
'durham-region':
'https://drtonline.durhamregiontransit.com/gtfsrealtime/VehiclePositions',
};
for (const [id, url] of Object.entries(expected)) {
const feed = getTransitFeed(id);
assert.ok(feed, `${id} is routable`);
assert.equal(feed.url, url);
assert.equal(feed.defaultEnabled, true);
assert.equal(feed.defaultMode, 'bus');
assert.equal(feed.historyRetention, undefined, `${id} retains nothing`);
assert.ok(feed.terms?.quote, `${id} records the terms it ships on`);
}
});
test('each Golden Horseshoe feed covers its own city and not its neighbours', () => {
const near = (lat, lon) => transitFeedsInRange(lat, lon).map((f) => f.id);
// Mississauga City Centre, downtown Hamilton, Oshawa.
assert.ok(near(43.589, -79.6441).includes('miway-mississauga'));
assert.ok(near(43.2557, -79.8711).includes('hsr-hamilton'));
assert.ok(near(43.8971, -78.8658).includes('durham-region'));
// Hamilton is 60 km from Toronto: far enough that the TTC feed is not polled
// for it, which is the whole point of a per-feed radius.
assert.equal(near(43.2557, -79.8711).includes('ttc-toronto'), false);
});
test('a bus-only feed never claims a mode its route ids cannot establish', () => {
for (const id of ['miway-mississauga', 'hsr-hamilton', 'durham-region']) {
const feed = getTransitFeed(id);
assert.equal(transitModeFor(feed, '1'), 'bus');
assert.equal(
transitModeResolved(feed, '1'),
false,
`${id} defaults rather than resolves`,
);
}
});
test('every Golden Horseshoe feed is documented with its licence', () => {
const sources = readFileSync(
new URL('../../DATA_SOURCES.md', import.meta.url),
'utf8',
);
for (const name of ['MiWay', 'Hamilton HSR', 'Durham Region Transit']) {
assert.ok(
sources.split('\n').some((line) => line.startsWith(`| **${name}`)),
`${name} has a DATA_SOURCES row`,
);
}
assert.match(sources, /Durham Region Transit publishes no bearing/);
});
test('a feed whose route ids are internal database keys can name its routes', () => {
// Guelph's realtime feed emits `2991` where the rider sees route `1`. A feed
// that knows the difference translates it; every other feed is unaffected.
const guelph = getTransitFeed('guelph-transit');
assert.equal(transitRouteLabel(guelph, '2991'), '1');
assert.equal(transitRouteLabel(guelph, '3016'), '99');
assert.equal(transitRouteLabel(guelph, '3007'), '50 U');
assert.equal(transitRouteLabel(guelph, '3017'), '99Lite');
});
test('an unknown or absent route id survives translation unchanged', () => {
const guelph = getTransitFeed('guelph-transit');
// A route added after this table was built must still render its raw id
// rather than vanish or read as "undefined".
assert.equal(transitRouteLabel(guelph, '4242'), '4242');
assert.equal(transitRouteLabel(guelph, null), null);
assert.equal(transitRouteLabel(guelph, ''), '');
});
test('a feed with rider-facing route ids is left alone', () => {
// TTC and Kingston publish the route a rider would say, so translation is
// identity for them and no table is carried.
assert.equal(transitRouteLabel(getTransitFeed('ttc-toronto'), '501'), '501');
assert.equal(transitRouteLabel(getTransitFeed('mbta'), 'Red'), 'Red');
assert.equal(transitRouteLabel(null, '7'), '7');
});
test('the feeds whose licences are accepted by use are switched on', () => {
// Barrie and YRT each ask for acceptance through a form, and each licence
// also says that using the data is itself acceptance. That reading was
// taken deliberately, so both are routable and both record the reasoning
// in their terms note rather than leaving it to be re-derived later.
for (const id of ['barrie-transit', 'yrt-york']) {
assert.ok(getTransitFeed(id), `${id} is routable`);
assert.ok(
publicTransitCatalog().some((feed) => feed.id === id),
`${id} is offered to the browser`,
);
assert.match(
getRegisteredTransitFeed(id).terms.note,
/acceptance is by use|use itself acceptance|took that clause as sufficient/,
`${id} records why it ships on`,
);
}
});
test('every registered feed now ships on, and the gate still decides that', () => {
// The enabled set must stay a filter over the registry, not a copy of it:
// flipping one feed off has to make it unreachable.
assert.equal(getRegisteredTransitFeed('yrt-york')?.name, 'YRT/Viva');
assert.deepEqual(
TRANSIT_FEED_REGISTRY.filter((feed) => feed.defaultEnabled !== true),
[],
);
});
test('Viva bus rapid transit is named by its colour, not its route number', () => {
// YRT publishes `601` where every rider, map and station sign says
// "Viva Blue". The numeric local routes already read correctly and are
// left alone.
const yrt = getTransitFeed('yrt-york');
assert.equal(transitRouteLabel(yrt, '601'), 'Viva Blue');
assert.equal(transitRouteLabel(yrt, '60301'), 'Viva Purple A');
assert.equal(transitRouteLabel(yrt, '607'), 'Viva Yellow');
assert.equal(transitRouteLabel(yrt, '105'), '105', 'a local bus is a number');
assert.equal(transitRouteLabel(yrt, '9899'), '9899');
});
test('YRT local branches read as the branch letter, not the padded id', () => {
// YRT suffixes a two-digit branch onto the base route, the same scheme the
// Viva table already relies on for `60102`. Unsuffixed, that leaks to a rider
// as "8301". The letters are York Region's own published GTFS
// `routes.txt` short names, unpadded to match the local routes beside them.
const yrt = getTransitFeed('yrt-york');
assert.equal(transitRouteLabel(yrt, '10702'), '107B');
assert.equal(transitRouteLabel(yrt, '8301'), '83A');
assert.equal(transitRouteLabel(yrt, '9002'), '90B');
// `9101` runs in the realtime feed but is absent from routes.txt, so there is
// no published name to give it. Inventing "91A" from the pattern is exactly
// the guess the registry refuses to make; it stays opaque until it is
// published.
assert.equal(transitRouteLabel(yrt, '9101'), '9101');
});
test('Hamilton route ids are internal keys, read as the number on the bus', () => {
// Not one of HSR's 80 route ids equals its published short name, so every
// vehicle reads as "Route 5783" until the table translates it. Hamilton also
// carries two generations of id for the same route — `5688` and `5780` are
// both the 2 BARTON — so both must land on the same answer.
const hsr = getTransitFeed('hsr-hamilton');
assert.equal(transitRouteLabel(hsr, '5780'), '2');
assert.equal(transitRouteLabel(hsr, '5688'), '2', 'the older id agrees');
assert.equal(transitRouteLabel(hsr, '5687'), '1');
assert.equal(transitRouteLabel(hsr, '5829'), '10', 'the B-Line');
assert.equal(transitRouteLabel(hsr, '5793'), '20', 'the A-Line');
// Published names that are not numbers are already what a rider would say,
// so they survive as published rather than being forced into a number.
assert.equal(transitRouteLabel(hsr, '5820'), 'TC230');
assert.equal(transitRouteLabel(hsr, '9999'), '9999', 'unknown survives');
});
test('Burlington route ids are joined, never prefix-stripped', () => {
// `351` is route 1 and `3510` is route 10, so no amount of trimming a `35`
// prefix works — the table is the only correct answer.
const bur = getTransitFeed('burlington-transit');
assert.equal(transitRouteLabel(bur, '351'), '1');
assert.equal(transitRouteLabel(bur, '3510'), '10');
assert.equal(transitRouteLabel(bur, '3512'), '12');
assert.equal(transitRouteLabel(bur, '3587'), '87');
assert.equal(transitRouteLabel(bur, '9999'), '9999', 'unknown survives');
});
test('Burlington is live and carries its terms link, which its licence requires', () => {
const bur = getTransitFeed('burlington-transit');
assert.equal(bur.defaultEnabled, true);
assert.match(bur.licenseUrl, /Open%20Data%20Terms%20of%20Use\.pdf$/);
assert.match(bur.url, /^https:\/\//, 'port 80 has no listener at all');
});