Merge pull request #25 from TextureHQ/test/improve-coverage

test: expand coverage for weather providers

Author: victorquinn

src/providers/nws/client.test.ts

@@ -2,6 +2,9 @@ import axios from 'axios';
 import MockAdapter from 'axios-mock-adapter';
 import { NWSProvider } from './client';
 import { InvalidProviderLocationError } from '../../errors';
+import * as conditionModule from './condition';
+import * as cloudinessModule from './cloudiness';
+import { IObservationsLatest } from './interfaces';
 
 describe('NWSProvider', () => {
   const latInUS = 38.8977; // Latitude in the US (e.g., Washington D.C.)
@@ -120,6 +123,51 @@ describe('NWSProvider', () => {
     await expect(provider.getWeather(latInUS, lngInUS)).rejects.toThrow('Invalid observation data');
   });
 
+  it('should throw when observation station metadata is malformed', async () => {
+    mock
+      .onGet(`https://api.weather.gov/points/${latInUS},${lngInUS}`)
+      .reply(200, { properties: {} });
+
+    await expect(provider.getWeather(latInUS, lngInUS)).rejects.toThrow('Failed to fetch observation station URL');
+  });
+
+  it('should throw when nearby stations payload is invalid', async () => {
+    mockObservationStationUrl();
+
+    mock
+      .onGet('https://api.weather.gov/gridpoints/XYZ/123,456/stations')
+      .reply(200, { properties: {} });
+
+    await expect(provider.getWeather(latInUS, lngInUS)).rejects.toThrow('Failed to fetch nearby stations');
+  });
+
+  it('should normalize missing text description to Unknown', async () => {
+    mockObservationStationUrl();
+
+    mock
+      .onGet('https://api.weather.gov/gridpoints/XYZ/123,456/stations')
+      .reply(200, {
+        features: [{ id: 'station123' }],
+      });
+
+    const observation = {
+      properties: {
+        dewpoint: { value: 5, unitCode: 'wmoUnit:degC' },
+        relativeHumidity: { value: 50 },
+        temperature: { value: 10, unitCode: 'wmoUnit:degC' },
+        cloudLayers: undefined as unknown as IObservationsLatest['properties']['cloudLayers'],
+        textDescription: undefined as unknown as string,
+      },
+    };
+
+    mock.onGet('station123/observations/latest').reply(200, observation as unknown as IObservationsLatest);
+
+    const weatherData = await provider.getWeather(latInUS, lngInUS);
+
+    expect(weatherData.conditions).toEqual({ value: 'Unknown', unit: 'string', original: undefined });
+    expect(weatherData.cloudiness).toEqual({ value: 0, unit: 'percent' });
+  });
+
   // Add this test case
   it('should skip stations if fetching data from a station fails', async () => {
     mockObservationStationUrl();
@@ -153,4 +201,60 @@ describe('NWSProvider', () => {
       },
     });
   });
-});
+
+  it('should throw when a station response lacks an identifier', async () => {
+    mockObservationStationUrl();
+
+    mock
+      .onGet('https://api.weather.gov/gridpoints/XYZ/123,456/stations')
+      .reply(200, {
+        features: [{}],
+      });
+
+    await expect(provider.getWeather(latInUS, lngInUS)).rejects.toThrow('Invalid observation data');
+  });
+
+  it('should throw when latest observation response omits properties entirely', async () => {
+    mockObservationStationUrl();
+
+    mock
+      .onGet('https://api.weather.gov/gridpoints/XYZ/123,456/stations')
+      .reply(200, {
+        features: [{ id: 'station123' }],
+      });
+
+    mock.onGet('station123/observations/latest').reply(200, {});
+
+    await expect(provider.getWeather(latInUS, lngInUS)).rejects.toThrow('Invalid observation data');
+  });
+
+  it('should throw when converted data lacks usable metric values', async () => {
+    const conditionSpy = jest.spyOn(conditionModule, 'standardizeCondition').mockReturnValueOnce(undefined as unknown as string);
+    const cloudSpy = jest.spyOn(cloudinessModule, 'getCloudinessFromCloudLayers').mockReturnValueOnce(undefined as unknown as number);
+
+    mockObservationStationUrl();
+
+    mock
+      .onGet('https://api.weather.gov/gridpoints/XYZ/123,456/stations')
+      .reply(200, {
+        features: [{ id: 'station123' }],
+      });
+
+    const observation = {
+      properties: {
+        dewpoint: { value: null, unitCode: 'wmoUnit:degC' } as unknown as IObservationsLatest['properties']['dewpoint'],
+        relativeHumidity: { value: null } as unknown as IObservationsLatest['properties']['relativeHumidity'],
+        temperature: { value: null, unitCode: 'wmoUnit:degC' } as unknown as IObservationsLatest['properties']['temperature'],
+        textDescription: 'Clear',
+        cloudLayers: [],
+      },
+    };
+
+    mock.onGet('station123/observations/latest').reply(200, observation as unknown as IObservationsLatest);
+
+    await expect(provider.getWeather(latInUS, lngInUS)).rejects.toThrow('Invalid observation data');
+
+    conditionSpy.mockRestore();
+    cloudSpy.mockRestore();
+  });
+});

src/providers/openweather/client.test.ts

@@ -1,6 +1,8 @@
 import axios from 'axios';
 import MockAdapter from 'axios-mock-adapter';
 import { OpenWeatherProvider } from './client';
+import { ProviderOutcomeReporter, defaultOutcomeReporter, setDefaultOutcomeReporter } from '../outcomeReporter';
+import { ProviderCallOutcome } from '../capabilities';
 
 describe('OpenWeatherProvider', () => {
   const lat = 51.5074; // Example latitude (London)
@@ -90,4 +92,48 @@ describe('OpenWeatherProvider', () => {
 
     await expect(provider.getWeather(lat, lng)).rejects.toThrow();
   });
-});
+
+  it('records retry metadata when OpenWeather responds with errors', async () => {
+    class TestReporter implements ProviderOutcomeReporter {
+      public events: Array<{ provider: string; outcome: ProviderCallOutcome }> = [];
+      record(provider: string, outcome: ProviderCallOutcome): void {
+        this.events.push({ provider, outcome });
+      }
+    }
+
+    const reporter = new TestReporter();
+    const originalReporter = defaultOutcomeReporter;
+    setDefaultOutcomeReporter(reporter);
+
+    mock
+      .onGet('https://api.openweathermap.org/data/3.0/onecall')
+      .reply(429, {}, { 'retry-after': '5' });
+
+    try {
+      await expect(provider.getWeather(lat, lng)).rejects.toThrow('Request failed with status code 429');
+
+      expect(reporter.events).toHaveLength(1);
+      expect(reporter.events[0]).toEqual({
+        provider: 'openweather',
+        outcome: expect.objectContaining({
+          ok: false,
+          code: 'UpstreamError',
+          status: 429,
+          retryAfterMs: 5000,
+        }),
+      });
+    } finally {
+      setDefaultOutcomeReporter(originalReporter);
+    }
+  });
+
+  it('wraps unexpected rejection values in a descriptive error', async () => {
+    mock.restore();
+    const axiosSpy = jest.spyOn(axios, 'get').mockRejectedValueOnce('boom');
+
+    await expect(provider.getWeather(lat, lng)).rejects.toThrow('Failed to fetch OpenWeather data');
+
+    axiosSpy.mockRestore();
+    mock = new MockAdapter(axios);
+  });
+});

src/providers/policy.more.test.ts

@@ -53,4 +53,59 @@ describe('policy engine more branches', () => {
     const res = selectProviders(reg, { current: true }, fallbackConfig);
     expect(res.candidates).toEqual(['nws', 'openweather']);
   });
+
+  it('priority-then-health skips providers without health snapshots', () => {
+    const registry = {
+      listProviders: () => ['ghost'],
+      getHealth: () => undefined,
+    } as unknown as ProviderRegistry;
+
+    const res = selectProviders(registry, { current: true }, { providerPolicy: 'priority-then-health' });
+
+    expect(res.candidates).toEqual([]);
+    expect(res.skipped).toEqual([]);
+  });
+
+  it('weighted policy skips providers below the minimum success threshold', () => {
+    const registry = {
+      listProviders: () => ['nws', 'openweather'],
+      getHealth: (id: string) =>
+        id === 'nws'
+          ? { circuit: 'closed', successRate: 0.1 }
+          : { circuit: 'closed', successRate: 0.9 },
+    } as unknown as ProviderRegistry;
+
+    const res = selectProviders(registry, { current: true }, {
+      providerPolicy: 'weighted',
+      providerWeights: { openweather: 5, nws: 1 },
+      healthThresholds: { minSuccessRate: 0.5 },
+    });
+
+    expect(res.candidates).toEqual(['openweather']);
+    expect(res.skipped).toEqual([{ id: 'nws', reason: 'below-success-threshold' }]);
+  });
+
+  it('weighted policy ignores providers without health snapshots', () => {
+    const registry = {
+      listProviders: () => ['ghost'],
+      getHealth: () => undefined,
+    } as unknown as ProviderRegistry;
+
+    const res = selectProviders(registry, { current: true }, { providerPolicy: 'weighted' });
+
+    expect(res.candidates).toEqual([]);
+    expect(res.skipped).toEqual([]);
+  });
+
+  it('weighted policy skips providers with open circuits', () => {
+    const registry = {
+      listProviders: () => ['nws'],
+      getHealth: () => ({ circuit: 'open', successRate: 0.9 }),
+    } as unknown as ProviderRegistry;
+
+    const res = selectProviders(registry, { current: true }, { providerPolicy: 'weighted' });
+
+    expect(res.candidates).toEqual([]);
+    expect(res.skipped).toEqual([{ id: 'nws', reason: 'circuit-open' }]);
+  });
 });

src/providers/policy.ts

@@ -62,7 +62,3 @@ export function selectProviders(
 
   return { candidates: base, skipped: [] };
 }
-
-function dedupe<T>(arr: T[]): T[] {
-  return Array.from(new Set(arr));
-}

src/providers/providerRegistry.extra.test.ts

@@ -3,6 +3,7 @@ import { ProviderCapability } from './capabilities';
 
 const CAP_BASIC: ProviderCapability = { supports: { current: true } };
 const CAP_FULL: ProviderCapability = { supports: { current: true, hourly: true, daily: true } };
+const CAP_NO_CURRENT: ProviderCapability = { supports: { current: false, hourly: true, daily: true, alerts: true } };
 
 describe('ProviderRegistry extra coverage', () => {
   it('getCapability returns registered metadata', () => {
@@ -11,6 +12,15 @@ describe('ProviderRegistry extra coverage', () => {
     expect(reg.getCapability('nws')).toEqual(CAP_BASIC);
   });
 
+  it('ignores duplicate registrations for the same provider', () => {
+    const reg = new ProviderRegistry();
+    reg.register('nws', CAP_BASIC);
+    reg.register('nws', CAP_FULL);
+
+    expect(reg.listProviders({ current: true })).toEqual(['nws']);
+    expect(reg.getCapability('nws')).toEqual(CAP_BASIC);
+  });
+
   it('listProviders filters for combined intents', () => {
     const reg = new ProviderRegistry();
     reg.register('nws', CAP_BASIC);
@@ -22,4 +32,16 @@ describe('ProviderRegistry extra coverage', () => {
     const reg = new ProviderRegistry();
     expect(() => reg.recordOutcome('unknown', { ok: true, latencyMs: 1 })).not.toThrow();
   });
+
+  it('omits providers that do not support the requested current intent', () => {
+    const reg = new ProviderRegistry();
+    reg.register('unsupported', CAP_NO_CURRENT);
+    expect(reg.listProviders({ current: true })).toEqual([]);
+  });
+
+  it('returns undefined capability and health for unknown providers', () => {
+    const reg = new ProviderRegistry();
+    expect(reg.getCapability('ghost')).toBeUndefined();
+    expect(reg.getHealth('ghost')).toBeUndefined();
+  });
 });

src/utils/locationUtils.test.ts

@@ -0,0 +1,33 @@
+import { isLocationInUS } from './locationUtils';
+
+describe('isLocationInUS', () => {
+  it('returns true for a US coordinate and false for an international coordinate', () => {
+    expect(isLocationInUS(38.8977, -77.0365)).toBe(true); // Washington, D.C.
+    expect(isLocationInUS(51.5074, -0.1278)).toBe(false); // London
+  });
+
+  it('falls back gracefully when topology lacks polygon features', async () => {
+    jest.resetModules();
+    jest.doMock('us-atlas/states-10m.json', () => ({
+      type: 'Topology',
+      objects: { states: { type: 'GeometryCollection', geometries: [{ type: 'LineString', arcs: [] }] } },
+      arcs: [],
+      transform: { scale: [1, 1], translate: [0, 0] },
+    }));
+    jest.doMock('topojson-client', () => ({
+      feature: () => ({
+        type: 'FeatureCollection',
+        features: undefined,
+      }),
+    }));
+
+    await jest.isolateModulesAsync(async () => {
+      const module = await import('./locationUtils');
+      expect(module.isLocationInUS(0, 0)).toBe(false);
+    });
+
+    jest.dontMock('topojson-client');
+    jest.dontMock('us-atlas/states-10m.json');
+    jest.resetModules();
+  });
+});

src/weatherService.test.ts

@@ -255,6 +255,18 @@ describe('WeatherService', () => {
     }).toThrow('OpenWeather provider requires an API key.');
   });
 
+  it('throws a descriptive error when no providers can supply data', async () => {
+    const service = new WeatherService({
+      providers: ['nws'],
+    });
+
+    Reflect.set(service as unknown as Record<string, unknown>, 'providers', []);
+
+    await expect(service.getWeather(38.8977, -77.0365)).rejects.toThrow(
+      'Unable to retrieve weather data from any provider.'
+    );
+  });
+
   it('should verify that the provider name is included in the weather data', async () => {
     const lat = 37.7749; // San Francisco
     const lng = -122.4194;