homeio

1/* @vitest-environment jsdom */
2
3import { act, renderHook, waitFor } from "@testing-library/react";
4import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
5import {
6  resetUserLocationReverseGeocodeStateForTests,
7  useUserLocation,
8} from "@/modules/system/hooks/useUserLocation";
9
10const USER_LOCATION_STORAGE_KEY = "weather.user-location.v1";
11
12function mockGeolocation(
13  implementation: Geolocation["getCurrentPosition"],
14) {
15  const geolocation = {
16    getCurrentPosition: vi.fn(implementation),
17  } satisfies Pick<Geolocation, "getCurrentPosition">;
18
19  Object.defineProperty(navigator, "geolocation", {
20    configurable: true,
21    value: geolocation,
22  });
23
24  return geolocation.getCurrentPosition;
25}
26
27function mockPermissions(state: PermissionState = "prompt") {
28  const permission = {
29    state,
30    onchange: null,
31  } as unknown as PermissionStatus;
32
33  const permissions = {
34    query: vi.fn().mockResolvedValue(permission),
35  } satisfies Pick<Permissions, "query">;
36
37  Object.defineProperty(navigator, "permissions", {
38    configurable: true,
39    value: permissions,
40  });
41
42  return { permission, query: permissions.query };
43}
44
45describe("useUserLocation", () => {
46  beforeEach(() => {
47    localStorage.clear();
48    vi.clearAllMocks();
49    resetUserLocationReverseGeocodeStateForTests();
50  });
51
52  afterEach(() => {
53    vi.unstubAllGlobals();
54  });
55
56  it("loads saved coordinates from localStorage", async () => {
57    localStorage.setItem(
58      USER_LOCATION_STORAGE_KEY,
59      JSON.stringify({ latitude: 36.8, longitude: 10.1 }),
60    );
61    const getCurrentPosition = mockGeolocation(() => {});
62
63    const { result } = renderHook(() => useUserLocation());
64
65    await waitFor(() => {
66      expect(result.current.location).toEqual({
67        latitude: 36.8,
68        longitude: 10.1,
69        city: undefined,
70        country: undefined,
71      });
72    });
73
74    expect(result.current.loading).toBe(false);
75    expect(getCurrentPosition).toHaveBeenCalledTimes(1);
76  });
77
78  it("persists coordinates when geolocation succeeds", async () => {
79    vi.stubGlobal(
80      "fetch",
81      vi.fn().mockResolvedValue({
82        ok: true,
83        json: async () => ({
84          address: {
85            city: "Sousse",
86            country_code: "tn",
87          },
88        }),
89      }),
90    );
91
92    mockGeolocation((success) => {
93      success({
94        coords: {
95          latitude: 35.2,
96          longitude: 9.4,
97        },
98      } as GeolocationPosition);
99    });
100
101    const { result } = renderHook(() => useUserLocation());
102
103    await waitFor(() => {
104      expect(result.current.location).toEqual({
105        latitude: 35.2,
106        longitude: 9.4,
107        city: "Sousse",
108        country: "TN",
109      });
110    });
111
112    expect(fetch).toHaveBeenCalledWith(
113      "https://nominatim.openstreetmap.org/reverse?lat=35.2&lon=9.4&format=json",
114      { headers: { "User-Agent": "Homeio Dashboard" } },
115    );
116    expect(result.current.error).toBeNull();
117    expect(localStorage.getItem(USER_LOCATION_STORAGE_KEY)).toBe(
118      JSON.stringify({
119        latitude: 35.2,
120        longitude: 9.4,
121        city: "Sousse",
122        country: "TN",
123      }),
124    );
125  });
126
127  it("tracks geolocation permission status changes", async () => {
128    mockGeolocation(() => {});
129    const { permission } = mockPermissions("prompt");
130
131    const { result } = renderHook(() => useUserLocation());
132
133    await waitFor(() => {
134      expect(result.current.permissionStatus).toBe("prompt");
135    });
136
137    act(() => {
138      (permission as { state: PermissionState }).state = "granted";
139      permission.onchange?.(new Event("change"));
140    });
141
142    await waitFor(() => {
143      expect(result.current.permissionStatus).toBe("granted");
144    });
145  });
146
147  it("handles missing browser geolocation support", async () => {
148    Object.defineProperty(navigator, "geolocation", {
149      configurable: true,
150      value: undefined,
151    });
152
153    const { result } = renderHook(() => useUserLocation());
154
155    await waitFor(() => {
156      expect(result.current.loading).toBe(false);
157    });
158
159    expect(result.current.location).toBeNull();
160    expect(result.current.error).toBe("Geolocation not supported");
161  });
162
163  it("backs off reverse geocoding after a 429 rate-limit response", async () => {
164    vi.stubGlobal(
165      "fetch",
166      vi.fn().mockResolvedValue({
167        ok: false,
168        status: 429,
169      }),
170    );
171
172    mockGeolocation((success) => {
173      success({
174        coords: {
175          latitude: 35.2,
176          longitude: 9.4,
177        },
178      } as GeolocationPosition);
179    });
180
181    const { result } = renderHook(() => useUserLocation());
182
183    await waitFor(() => {
184      expect(result.current.location).toEqual({
185        latitude: 35.2,
186        longitude: 9.4,
187        city: undefined,
188        country: undefined,
189      });
190    });
191
192    expect(fetch).toHaveBeenCalledTimes(1);
193
194    act(() => {
195      result.current.requestLocation();
196    });
197
198    await waitFor(() => {
199      expect(result.current.loading).toBe(false);
200    });
201
202    expect(fetch).toHaveBeenCalledTimes(1);
203  });
204});
205