Fix coverage regression in Locator and Map tests (#548)

* Fix coverage regression in Locator and Map tests

* Refactor Locator submit flow to try/catch/finally

* Increase coverage with deterministic Locator and Map tests

Author: sixcolors

src/Locator.svelte

@@ -57,36 +57,36 @@
         submitValue();
     };
 
-    const submitValue = (): void => {
+
+    const submitValue = async (): Promise<void> => {
         if (inputValue) {
             isFetching = true;
-            fetch(
-                `https://nominatim.openstreetmap.org/search?q=${encodeURIComponent(
-                    inputValue
-                )}&format=json&countrycodes=ca&limit=1`
-            )
-                .then((response) => {
-                    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-                    return response.json();
-                })
-                .then((data) => {
-                    if (Array.isArray(data) && data.length > 0) {
-                        const lat = parseFloat(data[0].lat);
-                        const lon = parseFloat(data[0].lon);
-                        if (!isFinite(lat) || !isFinite(lon)) {
-                            alert("No such location found.");
-                            return;
-                        }
-                        const placeName = data[0].display_name;
-                        onLocationFound(lat, lon, placeName);
-                    } else {
+            try {
+                const response = await fetch(
+                    `https://nominatim.openstreetmap.org/search?q=${encodeURIComponent(
+                        inputValue
+                    )}&format=json&countrycodes=ca&limit=1`
+                );
+                if (!response.ok) throw new Error(`HTTP ${response.status}`);
+
+                const data = await response.json();
+                if (Array.isArray(data) && data.length > 0) {
+                    const lat = parseFloat(data[0].lat);
+                    const lon = parseFloat(data[0].lon);
+                    if (!isFinite(lat) || !isFinite(lon)) {
                         alert("No such location found.");
+                        return;
                     }
-                })
-                .catch((error) => console.log(error))
-                .finally(() => {
-                    isFetching = false;
-                });
+                    const placeName = data[0].display_name;
+                    onLocationFound(lat, lon, placeName);
+                } else {
+                    alert("No such location found.");
+                }
+            } catch (error) {
+                console.log(error);
+            } finally {
+                isFetching = false;
+            }
             setTimeout(clearInput, 1000);
         } else {
             alert("You didn't type anything.");

tests/__snapshots__/map.test.ts.snap

@@ -102,4 +102,80 @@ describe('Locator.svelte', () => {
 
     expect(input.value).toBe('');
   });
+
+  it('handles failed autocomplete fetch without rendering suggestions', async () => {
+    const logMock = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    vi.stubGlobal('fetch', vi.fn((input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input.toString();
+
+      if (url.includes('limit=5')) {
+        return Promise.resolve({
+          ok: false,
+          status: 500,
+          json: () => Promise.resolve([]),
+        });
+      }
+
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve([]),
+      });
+    }));
+
+    render(App as unknown as new () => SvelteComponent, { target: document.body });
+    const input = screen.getByPlaceholderText('Search Location') as HTMLInputElement;
+
+    await fireEvent.input(input, { target: { value: 'Toronto' } });
+    await Promise.resolve();
+
+    expect(logMock).toHaveBeenCalled();
+    expect(screen.queryByRole('listitem')).toBeNull();
+    logMock.mockRestore();
+  });
+
+  it('alerts when geocoding returns no results', async () => {
+    const alertMock = vi.fn();
+    vi.stubGlobal('alert', alertMock);
+
+    vi.stubGlobal('fetch', vi.fn(() => {
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve([]),
+      });
+    }));
+
+    render(App as unknown as new () => SvelteComponent, { target: document.body });
+    const input = screen.getByPlaceholderText('Search Location') as HTMLInputElement;
+    const button = screen.getByDisplayValue('Submit');
+
+    await fireEvent.input(input, { target: { value: 'Nowhere' } });
+    vi.useFakeTimers();
+    await fireEvent.click(button);
+    await vi.runAllTimersAsync();
+
+    expect(alertMock).toHaveBeenCalledWith('No such location found.');
+  });
+
+  it('ignores unrelated key presses during navigation', async () => {
+    render(App as unknown as new () => SvelteComponent, { target: document.body });
+
+    const input = screen.getByPlaceholderText('Search Location') as HTMLInputElement;
+    await fireEvent.input(input, { target: { value: '' } });
+    await fireEvent.keyDown(window, { key: 'Escape' });
+
+    expect(input.value).toBe('');
+  });
+
+  it('returns early on ArrowDown with no suggestions', async () => {
+    render(App as unknown as new () => SvelteComponent, { target: document.body });
+    const input = screen.getByPlaceholderText('Search Location') as HTMLInputElement;
+
+    await fireEvent.input(input, { target: { value: '' } });
+    await fireEvent.keyDown(window, { key: 'ArrowDown' });
+
+    expect(input.value).toBe('');
+  });
 });