import { renderHook, act } from '@testing-library/react' import { describe, it, expect, beforeEach, vi } from 'vitest' import { useSettingsStore } from '../../store/settingsStore' import type { Settings } from '../../types' import { useVehicleRange } from './useVehicleRange' /** * Seven settings assembled into one answer. * * The arithmetic is pinned next door in vehicleRange.test.ts; what is worth guarding * here is the assembly: that an unrecognised word is no vehicle rather than a vehicle * nobody can refuel, that every one of the parts really reaches the division, and that * a range which rounds away arrives as no limit rather than as a zero one. * * The identity cases are worth less than they look, and are kept small for that reason. * Every reader today destructures the object on the spot, so its reference reaches * nothing; what they guard is the day a reader stops doing that. */ // setState replaces the settings object wholesale, which is what the hook has to cope // with anyway: the settings load hands it a new one on every fetch. function setSettings(over: Partial): void { act(() => { useSettingsStore.setState({ settings: over as never }) }) } /** Changes one field and leaves the rest, the way the settings dialog does. */ function changeSetting(over: Partial): void { act(() => { useSettingsStore.setState(s => ({ settings: { ...s.settings, ...over } as never })) }) } beforeEach(() => { // Wholesale, so nothing a previous case stored can answer for this one. useSettingsStore.setState({ settings: {} as never }) }) describe('useVehicleRange', () => { it('FE-VEHRANGEHOOK-001: a word the picker never wrote is no vehicle at all', () => { // The setting is a free string on the wire and nothing on the server checks it, so a // hand-edited value or a leftover from an older picker arrives here as-is. Anything // but the two known words has to fall back to "not said", which is the state where a // stop of either kind still counts as a fill-up. setSettings({ roadtrip_vehicle: 'lorry' }) expect(renderHook(() => useVehicleRange()).result.current.vehicleKind).toBeNull() setSettings({ roadtrip_vehicle: 'Electric' }) expect(renderHook(() => useVehicleRange()).result.current.vehicleKind).toBeNull() setSettings({}) expect(renderHook(() => useVehicleRange()).result.current.vehicleKind).toBeNull() }) it('FE-VEHRANGEHOOK-002: the two words it does know come back untouched', () => { setSettings({ roadtrip_vehicle: 'combustion' }) expect(renderHook(() => useVehicleRange()).result.current.vehicleKind).toBe('combustion') setSettings({ roadtrip_vehicle: 'electric' }) expect(renderHook(() => useVehicleRange()).result.current.vehicleKind).toBe('electric') }) it('FE-VEHRANGEHOOK-003: a complete pair of parts beats the round number that was typed', () => { // 55 litres at 7 per hundred is 786 km, and the traveller who filled both fields said // something more exact than "about 500". setSettings({ roadtrip_vehicle: 'combustion', roadtrip_tank_litres: 55, roadtrip_litres_per_100: 7, roadtrip_range_km: 500, }) expect(renderHook(() => useVehicleRange()).result.current.rangeKm).toBe(786) }) it('FE-VEHRANGEHOOK-004: half a specification leaves the typed number standing', () => { // Half a pair is not a range, and the typed figure is still a real answer — dropping // it here would take the range budget away from somebody who had set one. setSettings({ roadtrip_vehicle: 'combustion', roadtrip_tank_litres: 55, roadtrip_range_km: 500, }) expect(renderHook(() => useVehicleRange()).result.current.rangeKm).toBe(500) }) it('FE-VEHRANGEHOOK-005: figures left over from the other kind of car are not used', () => { // Someone who filled in a tank and then switched the picker to electric still has // both petrol fields in their settings. Feeding them to an electric car would hand // back a range that has nothing to do with the battery. setSettings({ roadtrip_vehicle: 'electric', roadtrip_tank_litres: 55, roadtrip_litres_per_100: 7, roadtrip_range_km: 500, }) expect(renderHook(() => useVehicleRange()).result.current.rangeKm).toBe(500) }) it('FE-VEHRANGEHOOK-006: the battery figures arrive complete, age included', () => { // 58 kWh less a tenth is 52.2, and 52.2 at 16 per hundred is 326 km. Forgetting to // forward the degradation would give 363 here, which is a warning that fires 37 km // after the car has stopped. setSettings({ roadtrip_vehicle: 'electric', roadtrip_battery_kwh: 58, roadtrip_kwh_per_100: 16, roadtrip_battery_degradation: 10, }) expect(renderHook(() => useVehicleRange()).result.current.rangeKm).toBe(326) }) it('FE-VEHRANGEHOOK-007: an unset or zeroed range is no limit, never a range of nothing', () => { // Zero is a legal thing to type into the field and means the same as leaving it // empty. Handing a 0 downstream would put the dry point at the first metre and light // up every stop on the trip. setSettings({ roadtrip_range_km: 0 }) expect(renderHook(() => useVehicleRange()).result.current.rangeKm).toBeNull() setSettings({}) expect(renderHook(() => useVehicleRange()).result.current.rangeKm).toBeNull() }) it('FE-VEHRANGEHOOK-008: a re-render with nothing changed hands back the same object', () => { setSettings({ roadtrip_vehicle: 'combustion', roadtrip_range_km: 500 }) const { result, rerender } = renderHook(() => useVehicleRange()) const first = result.current rerender() // Identity, not equality: the readers put this straight into an effect dependency // list, so a new object per render means the whole trip is re-routed per render. expect(result.current).toBe(first) }) it('FE-VEHRANGEHOOK-009: a setting this hook does not read causes no churn', () => { setSettings({ roadtrip_vehicle: 'combustion', roadtrip_range_km: 500, dark_mode: false }) const { result } = renderHook(() => useVehicleRange()) const first = result.current // A fresh settings object arrives on every settings load and after every unrelated // toggle, and the seven fields are read as primitives so none of that reaches here. setSettings({ roadtrip_vehicle: 'combustion', roadtrip_range_km: 500, dark_mode: true }) expect(result.current).toBe(first) }) it('FE-VEHRANGEHOOK-011: every part of the car reaches the arithmetic while mounted', () => { // Each field changed on a hook that is already mounted, which is the only way a // missing memo dependency shows itself: mounting afresh recomputes regardless, so a // suite built out of fresh mounts passes with half the dependency list deleted. setSettings({ roadtrip_vehicle: 'electric', roadtrip_battery_kwh: 58, roadtrip_kwh_per_100: 16 }) const { result } = renderHook(() => useVehicleRange()) expect(result.current.rangeKm).toBe(363) changeSetting({ roadtrip_battery_kwh: 77 }) expect(result.current.rangeKm).toBe(481) changeSetting({ roadtrip_kwh_per_100: 22 }) expect(result.current.rangeKm).toBe(350) changeSetting({ roadtrip_battery_degradation: 10 }) expect(result.current.rangeKm).toBe(315) // And the kind itself: the same figures mean nothing to a petrol car, which has no // tank size stored here at all. changeSetting({ roadtrip_vehicle: 'combustion' }) expect(result.current.vehicleKind).toBe('combustion') expect(result.current.rangeKm).toBeNull() changeSetting({ roadtrip_tank_litres: 55, roadtrip_litres_per_100: 7 }) expect(result.current.rangeKm).toBe(786) }) it('FE-VEHRANGEHOOK-012: a range that rounds away leaves no limit rather than a zero one', () => { // The branch this hook owns, as opposed to the one its neighbour owns: parts that // round to nothing must not arrive as the number 0, which every reader downstream // would take for a car that cannot leave the drive. setSettings({ roadtrip_vehicle: 'combustion', roadtrip_tank_litres: 1, roadtrip_litres_per_100: 500 }) const { result } = renderHook(() => useVehicleRange()) expect(result.current.rangeKm).toBeNull() }) it('FE-VEHRANGEHOOK-010: a range the traveller actually changed does come through', () => { setSettings({ roadtrip_vehicle: 'combustion', roadtrip_range_km: 500 }) const { result } = renderHook(() => useVehicleRange()) const first = result.current setSettings({ roadtrip_vehicle: 'combustion', roadtrip_range_km: 640 }) // The other half of case 009: memoised is not frozen. A stale object here would keep // the old budget on screen until something else happened to re-render. expect(result.current.rangeKm).toBe(640) expect(result.current).not.toBe(first) }) }) vi.mock('../../hooks/useRoadtripSettings', () => ({ useRoadtripSettings: (select: (preferences: import('@trek/shared').RoadtripPreferences) => unknown) => useSettingsStore(state => select(state.settings as import('@trek/shared').RoadtripPreferences)), }))