airport-utils 1.2.0 → 1.3.1

package/tests/built.test.ts

@@ -1,52 +1,69 @@
 import { execSync } from 'child_process';
+import fs from 'fs';
 import path from 'path';
+import type * as AirportUtils from '../src/index';
+
+function ensureBuild(): void {
+  const esmPath = path.resolve(__dirname, '../dist/esm/index.js');
+  const cjsPath = path.resolve(__dirname, '../dist/cjs/index.js');
+  if (fs.existsSync(esmPath) && fs.existsSync(cjsPath)) return;
+  execSync('npm run build', { stdio: 'inherit' });
+}
 
 // Test CommonJS build
 describe('CommonJS build (dist/cjs)', () => {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const cjs = require('../dist/cjs/index.js') as any;
-    const { convertToUTC, convertLocalToUTCByZone, getAirportInfo } = cjs;
-
-    it('convertToUTC works in CommonJS build', () => {
-        expect(convertToUTC('2025-05-02T14:30', 'JFK')).toBe('2025-05-02T18:30:00Z');
-    });
-
-    it('convertLocalToUTCByZone works in CommonJS build', () => {
-        expect(convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London'))
-            .toBe('2025-05-02T13:30:00Z');
-    });
-
-    it('getAirportInfo works in CommonJS build', () => {
-        const info = getAirportInfo('JFK');
-        expect(info).toHaveProperty('timezone');
-        expect(info).toHaveProperty('latitude');
-        expect(info).toHaveProperty('longitude');
-    });
+  beforeAll(() => {
+    ensureBuild();
+  });
+
+  const cjs = require('../dist/cjs/index.js') as typeof AirportUtils;
+  const { convertToUTC, convertLocalToUTCByZone, getAirportInfo } = cjs;
+
+  it('convertToUTC works in CommonJS build', () => {
+    expect(convertToUTC('2025-05-02T14:30', 'JFK')).toBe('2025-05-02T18:30:00Z');
+  });
+
+  it('convertLocalToUTCByZone works in CommonJS build', () => {
+    expect(convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London')).toBe(
+      '2025-05-02T13:30:00Z'
+    );
+  });
+
+  it('getAirportInfo works in CommonJS build', () => {
+    const info = getAirportInfo('JFK');
+    expect(info).toHaveProperty('timezone');
+    expect(info).toHaveProperty('latitude');
+    expect(info).toHaveProperty('longitude');
+  });
 });
 
 // Test ESM build using a subprocess to dynamically import the file
 describe('ESM build (dist/esm)', () => {
-    const esmPath = path.resolve(__dirname, '../dist/esm/index.js');
-    const fileUrl = 'file://' + esmPath;
-
-    it('convertToUTC works in ESM build', () => {
-        const cmd = `node -e "(async()=>{ const m = await import('${fileUrl}'); console.log(m.convertToUTC('2025-05-02T14:30','JFK')); })()"`;
-        const result = execSync(cmd, { encoding: 'utf-8' }).trim();
-        expect(result).toBe('2025-05-02T18:30:00Z');
-    });
-
-    it('convertLocalToUTCByZone works in ESM build', () => {
-        const cmd = `node -e "(async()=>{ const m = await import('${fileUrl}'); console.log(m.convertLocalToUTCByZone('2025-05-02T14:30:00','Europe/London')); })()"`;
-        const result = execSync(cmd, { encoding: 'utf-8' }).trim();
-        expect(result).toBe('2025-05-02T13:30:00Z');
-    });
-
-    it('getAirportInfo works in ESM build', () => {
-        const cmd = `node -e "(async()=>{ const m = await import('${fileUrl}'); console.log(JSON.stringify(m.getAirportInfo('JFK'))); })()"`;
-        const result = execSync(cmd, { encoding: 'utf-8' }).trim();
-        const info = JSON.parse(result);
-        expect(info).toHaveProperty('timezone');
-        expect(info).toHaveProperty('latitude');
-        expect(info).toHaveProperty('longitude');
-    });
+  beforeAll(() => {
+    ensureBuild();
+  });
+
+  const esmPath = path.resolve(__dirname, '../dist/esm/index.js');
+  const fileUrl = 'file://' + esmPath;
+
+  it('convertToUTC works in ESM build', () => {
+    const cmd = `node -e "(async()=>{ const m = await import('${fileUrl}'); console.log(m.convertToUTC('2025-05-02T14:30','JFK')); })()"`;
+    const result = execSync(cmd, { encoding: 'utf-8' }).trim();
+    expect(result).toBe('2025-05-02T18:30:00Z');
+  });
+
+  it('convertLocalToUTCByZone works in ESM build', () => {
+    const cmd = `node -e "(async()=>{ const m = await import('${fileUrl}'); console.log(m.convertLocalToUTCByZone('2025-05-02T14:30:00','Europe/London')); })()"`;
+    const result = execSync(cmd, { encoding: 'utf-8' }).trim();
+    expect(result).toBe('2025-05-02T13:30:00Z');
+  });
+
+  it('getAirportInfo works in ESM build', () => {
+    const cmd = `node -e "(async()=>{ const m = await import('${fileUrl}'); console.log(JSON.stringify(m.getAirportInfo('JFK'))); })()"`;
+    const result = execSync(cmd, { encoding: 'utf-8' }).trim();
+    const info = JSON.parse(result);
+    expect(info).toHaveProperty('timezone');
+    expect(info).toHaveProperty('latitude');
+    expect(info).toHaveProperty('longitude');
+  });
 });

package/tests/converter.test.ts

@@ -1,115 +1,130 @@
+import { TZDate } from '@date-fns/tz';
 import { convertToUTC, convertLocalToUTCByZone } from '../src/converter';
-import {
-  UnknownAirportError,
-  InvalidTimestampError,
-  UnknownTimezoneError
-} from '../src/errors';
-import { timezones } from '../src/mapping/timezones';
-
-const { TZDate } = require('@date-fns/tz');
-
-// Dynamically find an invalid 3-letter IATA
-function getInvalidIata(): string {
-  const existing = new Set(Object.keys(timezones));
-  for (let a = 65; a <= 90; a++) {
-    for (let b = 65; b <= 90; b++) {
-      for (let c = 65; c <= 90; c++) {
-        const code = String.fromCharCode(a, b, c);
-        if (!existing.has(code)) return code;
-      }
-    }
-  }
-  throw new Error('All codes taken?!');
-}
+import { UnknownAirportError, InvalidTimestampError, UnknownTimezoneError } from '../src/errors';
+import { getInvalidIata } from './helpers';
+
 const invalidIata = getInvalidIata();
 
 describe('convertToUTC', () => {
   it('converts JFK local time (UTC–4 in May) correctly', () => {
-    expect(convertToUTC('2025-05-02T14:30', 'JFK'))
-        .toBe('2025-05-02T18:30:00Z');
+    expect(convertToUTC('2025-05-02T14:30', 'JFK')).toBe('2025-05-02T18:30:00Z');
   });
 
   it('throws UnknownAirportError for bad IATA', () => {
-    expect(() => convertToUTC('2025-05-02T14:30', invalidIata))
-        .toThrow(UnknownAirportError);
+    expect(() => convertToUTC('2025-05-02T14:30', invalidIata)).toThrow(UnknownAirportError);
   });
 
   it('throws InvalidTimestampError for malformed timestamp', () => {
-    expect(() => convertToUTC('not-a-timestamp', 'JFK'))
-        .toThrow(InvalidTimestampError);
+    expect(() => convertToUTC('not-a-timestamp', 'JFK')).toThrow(InvalidTimestampError);
+  });
+
+  it('throws InvalidTimestampError for invalid date components', () => {
+    expect(() => convertToUTC('2025-13-02T14:30', 'JFK')).toThrow(InvalidTimestampError);
+    expect(() => convertToUTC('2025-02-30T14:30', 'JFK')).toThrow(InvalidTimestampError);
+    expect(() => convertToUTC('2025-04-31T14:30', 'JFK')).toThrow(InvalidTimestampError);
+    expect(() => convertToUTC('2025-05-02T25:30', 'JFK')).toThrow(InvalidTimestampError);
+    expect(() => convertToUTC('2025-05-02T23:60', 'JFK')).toThrow(InvalidTimestampError);
+    expect(() => convertToUTC('2025-05-02T23:59:60', 'JFK')).toThrow(InvalidTimestampError);
   });
 
   it('throws InvalidTimestampError for fractional seconds format', () => {
-    expect(() => convertToUTC('2025-05-02T14:30:00.123', 'JFK'))
-        .toThrow(InvalidTimestampError);
+    expect(() => convertToUTC('2025-05-02T14:30:00.123', 'JFK')).toThrow(InvalidTimestampError);
   });
 
   describe('error branches', () => {
-    const original = TZDate.tz;
-    afterEach(() => { TZDate.tz = original; });
-
     it('throws InvalidTimestampError if TZDate.tz throws', () => {
-      TZDate.tz = () => { throw new Error('forced'); };
-      expect(() => convertToUTC('2025-05-02T14:30', 'JFK'))
-          .toThrow(InvalidTimestampError);
+      const spy = jest.spyOn(TZDate, 'tz').mockImplementation(() => {
+        throw new Error('forced');
+      });
+      expect(() => convertToUTC('2025-05-02T14:30', 'JFK')).toThrow(InvalidTimestampError);
+      spy.mockRestore();
     });
 
     it('throws InvalidTimestampError if TZDate.tz returns invalid Date', () => {
-      TZDate.tz = () => {
-        const d = new Date(NaN);
+      const spy = jest.spyOn(TZDate, 'tz').mockImplementation(() => {
+        const d = new Date(NaN) as unknown as TZDate;
         Object.setPrototypeOf(d, TZDate.prototype);
         return d;
-      };
-      expect(() => convertToUTC('2025-05-02T14:30', 'JFK'))
-          .toThrow(InvalidTimestampError);
+      });
+      expect(() => convertToUTC('2025-05-02T14:30', 'JFK')).toThrow(InvalidTimestampError);
+      spy.mockRestore();
     });
   });
 });
 
 describe('convertLocalToUTCByZone', () => {
   it('converts London local time to UTC', () => {
-    expect(convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London'))
-        .toBe('2025-05-02T13:30:00Z');
+    expect(convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London')).toBe(
+      '2025-05-02T13:30:00Z'
+    );
+  });
+
+  it('accepts leap day dates', () => {
+    expect(convertLocalToUTCByZone('2024-02-29T12:00:00', 'Europe/London')).toBe(
+      '2024-02-29T12:00:00Z'
+    );
   });
 
   it('throws UnknownTimezoneError for invalid tz', () => {
-    expect(() =>
-        convertLocalToUTCByZone('2025-05-02T14:30:00', 'Not/A_Zone')
-    ).toThrow(UnknownTimezoneError);
+    expect(() => convertLocalToUTCByZone('2025-05-02T14:30:00', 'Not/A_Zone')).toThrow(
+      UnknownTimezoneError
+    );
+  });
+
+  it('caches invalid timezone results', () => {
+    expect(() => convertLocalToUTCByZone('2025-05-02T14:30:00', 'Not/A_Zone')).toThrow(
+      UnknownTimezoneError
+    );
+    expect(() => convertLocalToUTCByZone('2025-05-02T14:30:00', 'Not/A_Zone')).toThrow(
+      UnknownTimezoneError
+    );
   });
 
   it('throws InvalidTimestampError for malformed timestamp', () => {
-    expect(() =>
-        convertLocalToUTCByZone('bad-format', 'Europe/London')
-    ).toThrow(InvalidTimestampError);
+    expect(() => convertLocalToUTCByZone('bad-format', 'Europe/London')).toThrow(
+      InvalidTimestampError
+    );
+  });
+
+  it('throws InvalidTimestampError for invalid date components', () => {
+    expect(() => convertLocalToUTCByZone('2025-13-02T14:30:00', 'Europe/London')).toThrow(
+      InvalidTimestampError
+    );
+    expect(() => convertLocalToUTCByZone('2025-02-30T14:30:00', 'Europe/London')).toThrow(
+      InvalidTimestampError
+    );
+    expect(() => convertLocalToUTCByZone('2025-05-02T24:30:00', 'Europe/London')).toThrow(
+      InvalidTimestampError
+    );
   });
 
   it('throws InvalidTimestampError for fractional seconds format', () => {
-    expect(() =>
-        convertLocalToUTCByZone('2025-05-02T14:30:00.123', 'Europe/London')
-    ).toThrow(InvalidTimestampError);
+    expect(() => convertLocalToUTCByZone('2025-05-02T14:30:00.123', 'Europe/London')).toThrow(
+      InvalidTimestampError
+    );
   });
 
   describe('error branches', () => {
-    const original = TZDate.tz;
-    afterEach(() => { TZDate.tz = original; });
-
     it('throws UnknownTimezoneError if TZDate.tz throws for valid zone', () => {
-      TZDate.tz = () => { throw new RangeError('forced'); };
-      expect(() =>
-          convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London')
-      ).toThrow(UnknownTimezoneError);
+      const spy = jest.spyOn(TZDate, 'tz').mockImplementation(() => {
+        throw new RangeError('forced');
+      });
+      expect(() => convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London')).toThrow(
+        UnknownTimezoneError
+      );
+      spy.mockRestore();
     });
 
     it('throws InvalidTimestampError if TZDate.tz returns invalid Date', () => {
-      TZDate.tz = () => {
-        const d = new Date(NaN);
+      const spy = jest.spyOn(TZDate, 'tz').mockImplementation(() => {
+        const d = new Date(NaN) as unknown as TZDate;
         Object.setPrototypeOf(d, TZDate.prototype);
         return d;
-      };
-      expect(() =>
-          convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London')
-      ).toThrow(InvalidTimestampError);
+      });
+      expect(() => convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London')).toThrow(
+        InvalidTimestampError
+      );
+      spy.mockRestore();
     });
   });
 });

package/tests/generateMapping.test.ts

@@ -0,0 +1,233 @@
+const buildCsv = (rows: string[]) => {
+  const header = [
+    'iata_code',
+    'timezone',
+    'latitude',
+    'longitude',
+    'name',
+    'city_name_list',
+    'location_type',
+    'country_code',
+    'country_name',
+    'continent_name'
+  ].join('^');
+  return [header, ...rows].join('\n');
+};
+
+const globalAny = globalThis as unknown as { fetch?: typeof globalThis.fetch };
+
+jest.mock('fs', () => {
+  const realFs = jest.requireActual('fs');
+  return {
+    __esModule: true,
+    default: {
+      ...realFs,
+      mkdirSync: jest.fn(),
+      writeFileSync: jest.fn()
+    }
+  };
+});
+
+jest.mock('prettier', () => ({
+  __esModule: true,
+  default: {
+    resolveConfig: jest.fn(),
+    format: jest.fn(async (text: string) => text)
+  }
+}));
+
+describe('generateMapping', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  it('writes mappings and normalizes city names', async () => {
+    const csv = buildCsv([
+      // Airport row should win and city should be last token after "="
+      'ACE^Atlantic/Canary^28.95027^-13.60556^Lanzarote Airport^Lanzarote=Arrecife^A^ES^Spain^Europe',
+      // City rows should be ignored
+      'ACE^Europe/Paris^28.96302^-13.54769^Arrecife^Lanzarote=Arrecife^C^ES^Spain^Europe',
+      'AMS^Europe/Amsterdam^52.37403^4.88969^Amsterdam^Amsterdam=Schiphol^C^NL^Netherlands^Europe',
+      'AMS^Europe/Amsterdam^52.3103^4.76028^Amsterdam Airport Schiphol^Amsterdam=Schiphol^A^NL^Netherlands^Europe',
+      // Invalid code should be skipped
+      'ZZ^UTC^0^0^Bad^Bad City^A^ZZ^Nowhere^Antarctica',
+      // Missing timezone should not add to timezone map
+      'NOT^^10^20^No Tz Airport^Foo,Bar^A^XX^Nowhere^Asia',
+      // Invalid lat/lon should be skipped for geo
+      'INV^UTC^^20^Invalid^Foo^A^XX^Nowhere^Asia',
+      // Empty city list should fall back to empty city
+      'EMP^UTC^1^2^Empty City^^A^XX^Nowhere^Asia',
+      // Short row should yield undefined location_type
+      'MIS^UTC^1^2^Missing Fields^City'
+    ]);
+
+    const fetchMock = jest.fn(async () => ({
+      ok: true,
+      text: async () => csv
+    })) as unknown as typeof globalThis.fetch;
+    globalAny.fetch = fetchMock;
+
+    const fs = await import('fs');
+    const prettier = await import('prettier');
+    (prettier.default.resolveConfig as jest.Mock).mockResolvedValue({});
+
+    const { generateMapping } = await import('../scripts/generateMapping');
+    await generateMapping();
+
+    expect(fs.default.mkdirSync as jest.Mock).toHaveBeenCalled();
+    expect(fs.default.writeFileSync as jest.Mock).toHaveBeenCalledTimes(2);
+    expect(prettier.default.resolveConfig).toHaveBeenCalledWith(expect.any(String), {
+      editorconfig: true
+    });
+    expect(prettier.default.format).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ parser: 'typescript' })
+    );
+
+    const geoWrite = (fs.default.writeFileSync as jest.Mock).mock.calls.find(([file]) =>
+      String(file).endsWith('geo.ts')
+    );
+    expect(geoWrite).toBeTruthy();
+    const geoContents = String(geoWrite?.[1]);
+    expect(geoContents).toContain('"city": "Arrecife"');
+    expect(geoContents).toContain('"city": "Schiphol"');
+    expect(geoContents).not.toContain('Warszawa Centralna Railway Station');
+  });
+
+  it('throws when required columns are missing', async () => {
+    const badCsv = ['iata_code^timezone^latitude'].join('\n');
+
+    const fetchMock = jest.fn(async () => ({
+      ok: true,
+      text: async () => badCsv
+    })) as unknown as typeof globalThis.fetch;
+    globalAny.fetch = fetchMock;
+
+    const prettier = await import('prettier');
+    (prettier.default.resolveConfig as jest.Mock).mockResolvedValue({});
+
+    const { generateMapping } = await import('../scripts/generateMapping');
+    await expect(generateMapping()).rejects.toThrow('Missing required OPTD columns');
+  });
+
+  it('uses global fetch when fetchImpl is not provided', async () => {
+    const csv = buildCsv([
+      'ACE^Atlantic/Canary^28.95027^-13.60556^Lanzarote Airport^Lanzarote=Arrecife^A^ES^Spain^Europe'
+    ]);
+    const globalFetch = jest.fn(async () => ({
+      ok: true,
+      text: async () => csv
+    })) as unknown as typeof globalThis.fetch;
+    const previousFetch = globalAny.fetch;
+    globalAny.fetch = globalFetch;
+
+    const prettier = await import('prettier');
+    (prettier.default.resolveConfig as jest.Mock).mockResolvedValue({});
+
+    const { generateMapping } = await import('../scripts/generateMapping');
+    await generateMapping();
+
+    expect(globalFetch).toHaveBeenCalled();
+    globalAny.fetch = previousFetch;
+  });
+
+  it('throws when global fetch is missing', async () => {
+    const previousFetch = globalAny.fetch;
+    delete globalAny.fetch;
+
+    const { generateMapping } = await import('../scripts/generateMapping');
+    await expect(generateMapping()).rejects.toThrow('Global fetch is not available.');
+
+    globalAny.fetch = previousFetch;
+  });
+
+  it('throws when fetch response is not ok', async () => {
+    const fetchMock = jest.fn(async () => ({
+      ok: false,
+      statusText: 'Bad Gateway',
+      text: async () => ''
+    })) as unknown as typeof globalThis.fetch;
+    globalAny.fetch = fetchMock;
+
+    const prettier = await import('prettier');
+    (prettier.default.resolveConfig as jest.Mock).mockResolvedValue({});
+
+    const { generateMapping } = await import('../scripts/generateMapping');
+    await expect(generateMapping()).rejects.toThrow('Fetch failed: Bad Gateway');
+  });
+
+  it('uses fallback config and unknown error status text', async () => {
+    const fetchMock = jest.fn(async () => ({
+      ok: false,
+      text: async () => ''
+    })) as unknown as typeof globalThis.fetch;
+    globalAny.fetch = fetchMock;
+
+    const prettier = await import('prettier');
+    (prettier.default.resolveConfig as jest.Mock).mockResolvedValue(null);
+
+    const { generateMapping } = await import('../scripts/generateMapping');
+    await expect(generateMapping()).rejects.toThrow('Fetch failed: Unknown error');
+  });
+
+  it('skips rows that are not airports', async () => {
+    const csv = buildCsv([
+      'CIT^UTC^1^2^City^City^C^XX^Nowhere^Asia',
+      'BUS^UTC^3^4^Bus Station^City^B^XX^Nowhere^Asia',
+      'AIR^UTC^5^6^Airport^City^A^XX^Nowhere^Asia',
+      'NTZ^^7^8^No Tz Airport^City^A^XX^Nowhere^Asia',
+      'NTZ^UTC^7^8^No Tz Airport^City^A^XX^Nowhere^Asia'
+    ]);
+    const fetchMock = jest.fn(async () => ({
+      ok: true,
+      text: async () => csv
+    })) as unknown as typeof globalThis.fetch;
+    globalAny.fetch = fetchMock;
+
+    const fs = await import('fs');
+    const prettier = await import('prettier');
+    (prettier.default.resolveConfig as jest.Mock).mockResolvedValue({});
+
+    const { generateMapping } = await import('../scripts/generateMapping');
+    await generateMapping();
+
+    const geoWrite = (fs.default.writeFileSync as jest.Mock).mock.calls.find(([file]) =>
+      String(file).endsWith('geo.ts')
+    );
+    expect(geoWrite).toBeTruthy();
+    const geoContents = String(geoWrite?.[1]);
+    expect(geoContents).toContain('"AIR"');
+    expect(geoContents).toContain('"NTZ"');
+    expect(geoContents).not.toContain('"CIT"');
+    expect(geoContents).not.toContain('"BUS"');
+  });
+
+  it('uses default cwd/sourceUrl when omitted', async () => {
+    const csv = buildCsv(['DEF^UTC^1^2^Default Airport^Default City^A^XX^Nowhere^Asia']);
+    const fetchMock = jest.fn(async () => ({
+      ok: true,
+      text: async () => csv
+    })) as unknown as typeof globalThis.fetch;
+    globalAny.fetch = fetchMock;
+
+    const prettier = await import('prettier');
+    (prettier.default.resolveConfig as jest.Mock).mockResolvedValue({});
+
+    const fs = await import('fs');
+    const os = await import('os');
+    const path = await import('path');
+    const previousCwd = process.cwd();
+    const tempDir = fs.default.mkdtempSync(path.join(os.tmpdir(), 'airport-utils-'));
+    process.chdir(tempDir);
+
+    const { generateMapping } = await import('../scripts/generateMapping');
+    await generateMapping();
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://raw.githubusercontent.com/opentraveldata/opentraveldata/master/opentraveldata/optd_por_public.csv'
+    );
+
+    process.chdir(previousCwd);
+  });
+});

package/tests/helpers.ts

@@ -0,0 +1,16 @@
+import { timezones } from '../src/mapping/timezones';
+
+// Dynamically find an invalid 3-letter IATA code not in the mapping.
+export function getInvalidIata(): string {
+  const existing = new Set(Object.keys(timezones));
+  for (let a = 65; a <= 90; a++) {
+    for (let b = 65; b <= 90; b++) {
+      for (let c = 65; c <= 90; c++) {
+        const code = String.fromCharCode(a, b, c);
+        if (!existing.has(code)) return code;
+      }
+    }
+  }
+  /* istanbul ignore next */
+  throw new Error('All codes taken?!');
+}

package/tests/info.mocks.test.ts

@@ -0,0 +1,36 @@
+describe('getAllAirports with inconsistent mappings', () => {
+  it('excludes airports missing timezone entries', async () => {
+    jest.resetModules();
+    jest.doMock('../src/mapping/timezones', () => ({
+      timezones: { AAA: 'UTC' }
+    }));
+    jest.doMock('../src/mapping/geo', () => ({
+      geo: {
+        AAA: {
+          latitude: 1,
+          longitude: 2,
+          name: 'Airport A',
+          city: 'City A',
+          country: 'AA',
+          countryName: 'Aland',
+          continent: 'Europe'
+        },
+        BBB: {
+          latitude: 3,
+          longitude: 4,
+          name: 'Airport B',
+          city: 'City B',
+          country: 'BB',
+          countryName: 'Bland',
+          continent: 'Asia'
+        }
+      }
+    }));
+
+    const { getAllAirports } = await import('../src/info');
+    const all = getAllAirports();
+
+    expect(all).toHaveLength(1);
+    expect(all[0].iata).toBe('AAA');
+  });
+});

package/tests/info.test.ts

@@ -1,26 +1,13 @@
-import { getAirportInfo } from '../src/info';
+import { getAirportInfo, getAllAirports } from '../src/info';
 import { UnknownAirportError } from '../src/errors';
 import { timezones } from '../src/mapping/timezones';
 import { geo } from '../src/mapping/geo';
-
-// Dynamically find the first 3-letter code not in our mapping
-function getInvalidIata(): string {
-  const existing = new Set(Object.keys(timezones));
-  for (let a = 65; a <= 90; a++) {
-    for (let b = 65; b <= 90; b++) {
-      for (let c = 65; c <= 90; c++) {
-        const code = String.fromCharCode(a, b, c);
-        if (!existing.has(code)) return code;
-      }
-    }
-  }
-  throw new Error('All 3-letter codes are taken?!');
-}
+import { getInvalidIata } from './helpers';
 
 const invalidIata = getInvalidIata();
 
 describe('getAirportInfo', () => {
-  const validCodes = Object.keys(timezones).filter(i => geo[i]);
+  const validCodes = Object.keys(timezones).filter((i) => geo[i]);
   const sample = validCodes.length > 0 ? validCodes[0] : 'JFK';
 
   it('returns full info for a valid IATA', () => {
@@ -30,10 +17,10 @@ describe('getAirportInfo', () => {
       ...geo[sample]
     });
     expect(info.continent).toBeDefined();
+    expect(info.countryName).toBeDefined();
   });
 
   it('returns all airports', () => {
-    const { getAllAirports } = require('../src/info');
     const all = getAllAirports();
     expect(all.length).toBeGreaterThan(0);
     expect(all[0]).toHaveProperty('iata');
@@ -41,7 +28,6 @@ describe('getAirportInfo', () => {
   });
 
   it('throws UnknownAirportError for missing IATA', () => {
-    expect(() => getAirportInfo(invalidIata))
-      .toThrow(UnknownAirportError);
+    expect(() => getAirportInfo(invalidIata)).toThrow(UnknownAirportError);
   });
 });