straeto 0.1.1 → 0.1.3

package/README.md

@@ -8,6 +8,13 @@
   A CLI for the Icelandic bus system <a href="https://www.straeto.is">Strætó</a>, built with <a href="https://bun.sh">Bun</a>.
 </p>
 
+<p align="center">
+  <a href="https://www.npmjs.com/package/straeto"><img src="https://img.shields.io/npm/v/straeto" alt="npm version" /></a>
+  <a href="https://github.com/magtastic/straeto-cli/actions/workflows/ci.yml"><img src="https://github.com/magtastic/straeto-cli/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
+  <a href="https://www.npmjs.com/package/straeto"><img src="https://img.shields.io/npm/dm/straeto" alt="npm downloads" /></a>
+  <a href="https://github.com/magtastic/straeto-cli/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/straeto" alt="license" /></a>
+</p>
+
 ---
 
 ## Install

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "straeto",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Strætó — Icelandic bus system CLI",
   "author": "magtastic",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "format": "biome format --write src",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
-    "release": "npm version patch && git push --tags"
+    "release": "bun test && npm version patch && git push --tags"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.6",

package/src/api.test.ts

@@ -1,183 +1,82 @@
 import { describe, expect, test } from "bun:test";
 import * as api from "./api";
 
-describe("getBusLocations", () => {
-	test("returns valid bus locations for a known route", async () => {
-		const data = await api.getBusLocations(["1"]);
+async function withRetry<T>(fn: () => Promise<T>, retries = 5): Promise<T> {
+	for (let i = 0; i < retries; i++) {
+		try {
+			return await fn();
+		} catch {
+			if (i === retries - 1) throw new Error(`Failed after ${retries} retries`);
+			await Bun.sleep(100 * 2 ** i); // 100ms, 200ms, 400ms, 800ms, 1600ms
+		}
+	}
+	throw new Error("unreachable");
+}
 
+describe("API schema validation", () => {
+	test("getBusLocations parses against schema", async () => {
+		const data = await withRetry(() => api.getBusLocations(["1"]));
 		expect(data.lastUpdate).toBeString();
 		expect(Array.isArray(data.results)).toBe(true);
-
-		for (const bus of data.results) {
-			expect(bus.busId).toBeString();
-			expect(bus.routeNr).toBe("1");
-			expect(bus.headsign).toBeString();
-			expect(bus.lat).toBeNumber();
-			expect(bus.lng).toBeNumber();
-			expect(bus.direction).toBeNumber();
-			expect(Array.isArray(bus.nextStops)).toBe(true);
-
-			for (const nextStop of bus.nextStops) {
-				expect(nextStop.arrival).toBeString();
-				expect(nextStop.waitingTime).toBeNumber();
-				if (nextStop.stop !== null) {
-					expect(nextStop.stop.name).toBeString();
-				}
-			}
-		}
 	});
 
-	test("returns empty results for nonexistent route", async () => {
-		const data = await api.getBusLocations(["99999"]);
-
+	test("getBusLocations returns empty for nonexistent route", async () => {
+		const data = await withRetry(() => api.getBusLocations(["99999"]));
 		expect(data.lastUpdate).toBeString();
 		expect(data.results).toEqual([]);
 	});
-});
-
-describe("getStops", () => {
-	test("returns a list of stops with required fields", async () => {
-		const stops = await api.getStops();
 
+	test("getStops parses against schema", async () => {
+		const stops = await withRetry(() => api.getStops());
 		expect(stops.length).toBeGreaterThan(100);
-
-		const stop = stops[0];
-		expect(stop).toBeDefined();
-		if (!stop) return;
-
-		expect(stop.id).toBeNumber();
-		expect(stop.name).toBeString();
-		expect(stop.lat).toBeNumber();
-		expect(stop.lon).toBeNumber();
-		expect(stop.type).toBeNumber();
-		expect(stop.code === null || typeof stop.code === "string").toBe(true);
-		expect(typeof stop.isTerminal).toBe("boolean");
-		expect(Array.isArray(stop.routes)).toBe(true);
 	});
 
-	test("contains known stops", async () => {
-		const stops = await api.getStops();
-		const names = stops.map((stop) => stop.name);
-
-		expect(names).toContain("Hamraborg");
-		expect(names).toContain("Mjódd A");
-	});
-});
-
-describe("getStop", () => {
-	test("returns details for a known stop", async () => {
-		const stops = await api.getStops();
-		const hamraborg = stops.find((stop) => stop.name === "Hamraborg");
+	test("getStop parses against schema", async () => {
+		const stops = await withRetry(() => api.getStops());
+		const hamraborg = stops.find((s) => s.name === "Hamraborg");
 		expect(hamraborg).toBeDefined();
-		if (!hamraborg) return;
 
-		const stop = await api.getStop(String(hamraborg.id));
+		const stop = await withRetry(() => api.getStop(String(hamraborg?.id)));
 		expect(stop).not.toBeNull();
-		if (!stop) return;
-
-		expect(stop.name).toBe("Hamraborg");
-		expect(stop.lat).toBeNumber();
-		expect(stop.lon).toBeNumber();
-		expect(Array.isArray(stop.routes)).toBe(true);
-		expect(Array.isArray(stop.routes)).toBe(true);
+		expect(stop?.name).toBe("Hamraborg");
 	});
 
-	test("returns null for nonexistent stop", async () => {
-		const stop = await api.getStop("0");
+	test("getStop returns null for nonexistent stop", async () => {
+		const stop = await withRetry(() => api.getStop("0"));
 		expect(stop).toBeNull();
 	});
-});
 
-describe("getAlerts", () => {
-	test("returns alerts in Icelandic", async () => {
-		const alerts = await api.getAlerts("IS");
+	test("getAlerts parses against schema", async () => {
+		const alertsIS = await withRetry(() => api.getAlerts("IS"));
+		expect(Array.isArray(alertsIS)).toBe(true);
 
-		expect(Array.isArray(alerts)).toBe(true);
-
-		for (const alert of alerts) {
-			expect(alert.id).toBeString();
-			expect(alert.cause).toBeString();
-			expect(alert.effect).toBeString();
-			expect(alert.title).toBeString();
-			expect(alert.text).toBeString();
-			expect(alert.dateStart).toBeString();
-			expect(Array.isArray(alert.routes)).toBe(true);
-		}
-	});
-
-	test("returns alerts in English", async () => {
-		const alerts = await api.getAlerts("EN");
-		expect(Array.isArray(alerts)).toBe(true);
+		const alertsEN = await withRetry(() => api.getAlerts("EN"));
+		expect(Array.isArray(alertsEN)).toBe(true);
 	});
-});
-
-describe("geocode", () => {
-	test("finds results for a known location", async () => {
-		const results = await api.geocode("Hlemmur");
 
+	test("geocode parses against schema", async () => {
+		const results = await withRetry(() => api.geocode("Hlemmur"));
 		expect(results.length).toBeGreaterThan(0);
-
-		const first = results[0];
-		expect(first).toBeDefined();
-		if (!first) return;
-
-		expect(first.id).toBeString();
-		expect(first.name).toBeString();
-		expect(first.lat).toBeNumber();
-		expect(first.lon).toBeNumber();
-		expect(first.address).toBeString();
-		expect(first.type).toBeString();
-		expect(first.subType).toBeString();
 	});
 
-	test("returns empty for gibberish query", async () => {
-		const results = await api.geocode("xyzxyzxyz123456");
+	test("geocode returns empty for gibberish", async () => {
+		const results = await withRetry(() => api.geocode("xyzxyzxyz123456"));
 		expect(results).toEqual([]);
 	});
-});
-
-describe("planTrip", () => {
-	test("plans a trip between two known locations", async () => {
-		// Hlemmur → Mjódd (common route)
-		const trips = await api.planTrip({
-			from: "64.1426,-21.9009",
-			to: "64.1117,-21.8437",
-			date: new Date().toISOString().slice(0, 10),
-			time: "08:00",
-			arrivalBy: false,
-		});
 
+	test("planTrip parses against schema", async () => {
+		const tomorrow = new Date(Date.now() + 86400000);
+		const date = tomorrow.toISOString().slice(0, 10);
+		const trips = await withRetry(() =>
+			api.planTrip({
+				from: "64.1426,-21.9009",
+				to: "64.1117,-21.8437",
+				date,
+				time: "08:00",
+				arrivalBy: false,
+			}),
+		);
 		expect(trips.length).toBeGreaterThan(0);
-
-		const trip = trips[0];
-		expect(trip).toBeDefined();
-		if (!trip) return;
-
-		expect(trip.id).toBeString();
-		expect(trip.duration.total).toBeNumber();
-		expect(trip.duration.walk).toBeNumber();
-		expect(trip.duration.bus).toBeNumber();
-		expect(trip.time.from).toBeString();
-		expect(trip.time.to).toBeString();
-		expect(trip.legs.length).toBeGreaterThan(0);
-
-		for (const leg of trip.legs) {
-			expect(["WALK", "BUS"]).toContain(leg.type);
-			expect(leg.duration).toBeNumber();
-			expect(leg.distance).toBeNumber();
-			expect(leg.time.from).toBeString();
-			expect(leg.time.to).toBeString();
-			expect(leg.from.lat).toBeNumber();
-			expect(leg.from.lon).toBeNumber();
-			expect(leg.to.lat).toBeNumber();
-			expect(leg.to.lon).toBeNumber();
-
-			if (leg.type === "BUS") {
-				expect(leg.trip).toBeDefined();
-				expect(leg.trip?.routeNr).toBeString();
-				expect(leg.trip?.headsign).toBeString();
-			}
-		}
 	});
 });
 

package/src/cli.test.ts

@@ -21,7 +21,6 @@ async function run(
 describe("cli --help", () => {
 	test("shows usage and all commands", async () => {
 		const { stdout, exitCode } = await run("--help");
-
 		expect(exitCode).toBe(0);
 		expect(stdout).toContain("Usage: straeto");
 		expect(stdout).toContain("route");
@@ -33,32 +32,31 @@ describe("cli --help", () => {
 });
 
 describe("cli --version", () => {
-	test("prints version number", async () => {
+	test("prints version matching package.json", async () => {
+		const pkg = await Bun.file("package.json").json();
 		const { stdout, exitCode } = await run("--version");
-
 		expect(exitCode).toBe(0);
-		expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+		expect(stdout.trim()).toBe(pkg.version);
 	});
 
 	test("works with -v shorthand", async () => {
 		const { stdout, exitCode } = await run("-v");
-
 		expect(exitCode).toBe(0);
 		expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
 	});
 });
 
-describe("cli route", () => {
-	test("shows bus overview for a route", async () => {
-		const { stdout, exitCode } = await run("route", "3");
-
-		expect(exitCode).toBe(0);
-		expect(stdout).toContain("Route 3");
+describe("cli unknown command", () => {
+	test("shows error for unknown command", async () => {
+		const { stderr, exitCode } = await run("foobar");
+		expect(exitCode).toBe(1);
+		expect(stderr).toContain("unknown command");
 	});
+});
 
+describe("cli route (help/args)", () => {
 	test("shows help for route command", async () => {
 		const { stdout, exitCode } = await run("route", "--help");
-
 		expect(exitCode).toBe(0);
 		expect(stdout).toContain("Route number");
 		expect(stdout).toContain("--watch");
@@ -67,109 +65,14 @@ describe("cli route", () => {
 
 	test("fails without route argument", async () => {
 		const { stderr, exitCode } = await run("route");
-
 		expect(exitCode).toBe(1);
 		expect(stderr).toContain("missing required argument");
 	});
 });
 
-describe("cli stops", () => {
-	test("lists stops with default limit", async () => {
-		const { stdout, exitCode } = await run("stops");
-
-		expect(exitCode).toBe(0);
-		expect(stdout).toContain("Bus stops");
-		expect(stdout).toContain("more");
-	});
-
-	test("filters stops by search", async () => {
-		const { stdout, exitCode } = await run("stops", "-s", "Hamraborg");
-
-		expect(exitCode).toBe(0);
-		expect(stdout).toContain("Hamraborg");
-	});
-
-	test("respects -n limit flag", async () => {
-		const { stdout, exitCode } = await run("stops", "-n", "3");
-
-		expect(exitCode).toBe(0);
-		expect(stdout).toContain("Bus stops");
-		// Should show "and N more" since 3 is less than total
-		expect(stdout).toContain("more");
-	});
-});
-
-describe("cli stop", () => {
-	test("looks up a stop by name", async () => {
-		const { stdout, exitCode } = await run("stop", "Hamraborg");
-
-		expect(exitCode).toBe(0);
-		expect(stdout).toContain("Hamraborg");
-	});
-
-	test("shows suggestions for partial match", async () => {
-		const { stdout, exitCode } = await run("stop", "Hamra");
-
-		expect(exitCode).toBe(0);
-		expect(stdout).toContain("Hamraborg");
-	});
-
-	test("fails for nonexistent stop", async () => {
-		const { stderr, exitCode } = await run("stop", "xyznonexistent123");
-
-		expect(exitCode).toBe(1);
-		expect(stderr).toContain("No stops matching");
-	});
-});
-
-describe("cli alerts", () => {
-	test("shows alerts in Icelandic by default", async () => {
-		const { stdout, exitCode } = await run("alerts");
-
-		expect(exitCode).toBe(0);
-		// May have 0 alerts, but should still show the header or "No active alerts"
-		expect(stdout.length).toBeGreaterThan(0);
-	});
-
-	test("shows alerts in English with -l EN", async () => {
-		const { stdout, exitCode } = await run("alerts", "-l", "EN");
-
-		expect(exitCode).toBe(0);
-		expect(stdout.length).toBeGreaterThan(0);
-	});
-});
-
-describe("cli plan", () => {
-	test("plans a trip with coordinates", async () => {
-		// Use tomorrow to avoid time-of-day edge cases
-		const tomorrow = new Date(Date.now() + 86400000);
-		const date = tomorrow.toISOString().slice(0, 10);
-		const { stdout, exitCode } = await run(
-			"plan",
-			"-f",
-			"64.1426,-21.9009",
-			"-t",
-			"64.1117,-21.8437",
-			"--at",
-			"10:00",
-			"-d",
-			date,
-		);
-
-		expect(exitCode).toBe(0);
-		expect(stdout).toContain("→");
-	});
-
-	test("fails without from/to in non-interactive mode", async () => {
-		const { stderr, exitCode } = await run("plan", "-f", "64.14,-21.90");
-
-		expect(exitCode).toBe(1);
-		expect(stderr).toContain("Missing --from and --to");
-	});
-
+describe("cli plan (help/args)", () => {
 	test("shows help for plan command", async () => {
 		const { stdout, exitCode } = await run("plan", "--help");
-
 		expect(exitCode).toBe(0);
 		expect(stdout).toContain("--from");
 		expect(stdout).toContain("--to");
@@ -177,13 +80,10 @@ describe("cli plan", () => {
 		expect(stdout).toContain("--by");
 		expect(stdout).toContain("--interactive");
 	});
-});
-
-describe("cli unknown command", () => {
-	test("shows error for unknown command", async () => {
-		const { stderr, exitCode } = await run("foobar");
 
+	test("fails without from/to in non-interactive mode", async () => {
+		const { stderr, exitCode } = await run("plan", "-f", "64.14,-21.90");
 		expect(exitCode).toBe(1);
-		expect(stderr).toContain("unknown command");
+		expect(stderr).toContain("Missing --from and --to");
 	});
 });

package/src/cli.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import chalk from "chalk";
 import { program } from "commander";
+import pkg from "../package.json";
 import { alertsCommand } from "./commands/alerts";
 import { planCommand } from "./commands/plan";
 import { routeCommand } from "./commands/route";
@@ -18,7 +19,7 @@ function handleError(error: unknown) {
 program
 	.name("straeto")
 	.description("Strætó — Icelandic bus system CLI")
-	.version("0.1.0", "-v, --version");
+	.version(pkg.version, "-v, --version");
 
 program
 	.command("route")

package/src/commands.test.ts

@@ -0,0 +1,319 @@
+import { describe, expect, test } from "bun:test";
+import type { Alert, BusLocation, Stop, StopDetail, TripItinerary } from "./api";
+import { findBus, findLastStop } from "./api";
+import * as fmt from "./format";
+
+// --- Mock data ---
+
+const mockBuses: BusLocation[] = [
+	{
+		busId: "1-A",
+		tripId: "t1",
+		routeNr: "3",
+		tag: null,
+		headsign: "Hlemmur",
+		lat: 64.14,
+		lng: -21.92,
+		direction: 90,
+		nextStops: [{ arrival: "2026-01-01T10:05:00", waitingTime: 3, stop: { name: "Hamraborg" } }],
+	},
+	{
+		busId: "2-B",
+		tripId: "t2",
+		routeNr: "3",
+		tag: null,
+		headsign: "Seltjarnarnes",
+		lat: 64.15,
+		lng: -21.95,
+		direction: 270,
+		nextStops: [{ arrival: "2026-01-01T10:10:00", waitingTime: 5, stop: { name: "Grandi" } }],
+	},
+];
+
+const mockStops: Stop[] = [
+	{
+		id: 10001,
+		name: "Hamraborg",
+		lat: 64.11,
+		lon: -21.88,
+		type: 1,
+		code: "HB",
+		isTerminal: true,
+		routes: ["1", "2", "3"],
+	},
+	{
+		id: 10002,
+		name: "Mjódd A",
+		lat: 64.1,
+		lon: -21.84,
+		type: 1,
+		code: null,
+		isTerminal: true,
+		routes: ["1", "3", "6"],
+	},
+	{
+		id: 10003,
+		name: "Hlemmur",
+		lat: 64.14,
+		lon: -21.9,
+		type: 1,
+		code: null,
+		isTerminal: false,
+		routes: ["1", "3", "6"],
+	},
+	{
+		id: 10004,
+		name: "Grandi",
+		lat: 64.15,
+		lon: -21.95,
+		type: 1,
+		code: null,
+		isTerminal: false,
+		routes: ["3"],
+	},
+];
+
+const mockStopDetail: StopDetail = {
+	id: 10001,
+	name: "Hamraborg",
+	lat: 64.11,
+	lon: -21.88,
+	type: 1,
+	code: "HB",
+	isTerminal: true,
+	routes: ["1", "2", "3"],
+	streetView: null,
+};
+
+const mockAlerts: Alert[] = [
+	{
+		id: "a1",
+		cause: "CONSTRUCTION",
+		effect: "DETOUR",
+		routes: ["3"],
+		title: "Route 3 detour",
+		text: "Due to construction near Hamraborg",
+		dateStart: "2026-01-01",
+		dateEnd: null,
+	},
+];
+
+const mockTrips: TripItinerary[] = [
+	{
+		id: "trip1",
+		duration: { walk: 300, bus: 600, total: 900 },
+		time: { from: "2026-01-01T10:00:00", to: "2026-01-01T10:15:00" },
+		legs: [
+			{
+				type: "WALK",
+				duration: 120,
+				distance: 150,
+				time: { from: "2026-01-01T10:00:00", to: "2026-01-01T10:02:00" },
+				from: { lat: 64.14, lon: -21.9, depature: null, stop: null },
+				to: {
+					lat: 64.14,
+					lon: -21.9,
+					arrival: null,
+					stop: { id: "10003", name: "Hlemmur", lat: 64.14, lon: -21.9 },
+				},
+			},
+			{
+				type: "BUS",
+				duration: 600,
+				distance: 3000,
+				time: { from: "2026-01-01T10:02:00", to: "2026-01-01T10:12:00" },
+				from: {
+					lat: 64.14,
+					lon: -21.9,
+					depature: "2026-01-01T10:02:00",
+					stop: { id: "10003", name: "Hlemmur", lat: 64.14, lon: -21.9 },
+				},
+				to: {
+					lat: 64.1,
+					lon: -21.84,
+					arrival: "2026-01-01T10:12:00",
+					stop: { id: "10002", name: "Mjódd A", lat: 64.1, lon: -21.84 },
+				},
+				trip: { routeNr: "3", headsign: "Mjódd" },
+				stops: [
+					{ id: "10003", name: "Hlemmur" },
+					{ id: "10001", name: "Hamraborg" },
+				],
+			},
+			{
+				type: "WALK",
+				duration: 180,
+				distance: 200,
+				time: { from: "2026-01-01T10:12:00", to: "2026-01-01T10:15:00" },
+				from: {
+					lat: 64.1,
+					lon: -21.84,
+					depature: null,
+					stop: { id: "10002", name: "Mjódd A", lat: 64.1, lon: -21.84 },
+				},
+				to: { lat: 64.1, lon: -21.84, arrival: null, stop: null },
+			},
+		],
+	},
+];
+
+// --- Format function tests ---
+
+describe("formatBusOverview", () => {
+	test("shows route and buses", () => {
+		const output = fmt.formatBusOverview("3", mockBuses, "2026-01-01T10:00:00");
+		expect(output).toContain("Route 3");
+		expect(output).toContain("Hlemmur");
+		expect(output).toContain("Seltjarnarnes");
+	});
+
+	test("shows no buses message for empty list", () => {
+		const output = fmt.formatBusOverview("999", [], "2026-01-01T10:00:00");
+		expect(output).toContain("No buses");
+	});
+});
+
+describe("formatBusDetail", () => {
+	test("shows bus detail with next stops", () => {
+		const bus = mockBuses[0];
+		expect(bus).toBeDefined();
+		if (!bus) return;
+		const output = fmt.formatBusDetail(bus, "2026-01-01T10:00:00");
+		expect(output).toContain("Bus 1-A");
+		expect(output).toContain("Hamraborg");
+	});
+
+	test("shows last stop when provided", () => {
+		const bus = mockBuses[0];
+		expect(bus).toBeDefined();
+		if (!bus) return;
+		const output = fmt.formatBusDetail(bus, "2026-01-01T10:00:00", "Grandi");
+		expect(output).toContain("Grandi");
+		expect(output).toContain("passed");
+	});
+});
+
+describe("formatStops", () => {
+	test("lists all stops", () => {
+		const output = fmt.formatStops(mockStops);
+		expect(output).toContain("Bus stops");
+		expect(output).toContain("Hamraborg");
+		expect(output).toContain("Mjódd A");
+		expect(output).toContain("Hlemmur");
+		expect(output).toContain("Grandi");
+	});
+
+	test("shows terminal indicator", () => {
+		const output = fmt.formatStops(mockStops);
+		// Hamraborg is a terminal
+		expect(output).toContain("◉");
+	});
+});
+
+describe("formatStop", () => {
+	test("shows stop detail", () => {
+		const output = fmt.formatStop(mockStopDetail);
+		expect(output).toContain("Hamraborg");
+		expect(output).toContain("10001");
+		expect(output).toContain("Terminal");
+	});
+});
+
+describe("formatAlerts", () => {
+	test("shows alerts", () => {
+		const output = fmt.formatAlerts(mockAlerts);
+		expect(output).toContain("Route 3 detour");
+		expect(output).toContain("construction");
+	});
+
+	test("shows no alerts message", () => {
+		const output = fmt.formatAlerts([]);
+		expect(output).toContain("No active alerts");
+	});
+});
+
+describe("formatTrips", () => {
+	test("shows trip plan", () => {
+		const output = fmt.formatTrips(mockTrips);
+		expect(output).toContain("→");
+		expect(output).toContain("Hlemmur");
+		expect(output).toContain("Mjódd");
+	});
+
+	test("shows no trips message", () => {
+		const output = fmt.formatTrips([]);
+		expect(output).toContain("No trips found");
+	});
+});
+
+// --- Helper function tests ---
+
+describe("findBus", () => {
+	test("finds a bus by route and letter", () => {
+		const found = findBus(mockBuses, "3", "b");
+		expect(found).toBeDefined();
+		expect(found?.busId).toBe("2-B");
+
+		expect(findBus(mockBuses, "3", "c")).toBeUndefined();
+		expect(findBus(mockBuses, "5", "a")).toBeUndefined();
+	});
+});
+
+describe("findLastStop", () => {
+	test("returns closest stop not in nextStops", () => {
+		const bus = mockBuses[0];
+		expect(bus).toBeDefined();
+		if (!bus) return;
+		// Hamraborg is in nextStops, so it should find the closest non-next stop
+		const result = findLastStop(bus, mockStops);
+		expect(result).toBeDefined();
+		expect(result).not.toBe("Hamraborg");
+	});
+
+	test("returns undefined when no route stops exist", () => {
+		const bus: BusLocation = {
+			busId: "1-A",
+			tripId: "t1",
+			routeNr: "99",
+			tag: null,
+			headsign: "Nowhere",
+			lat: 64.0,
+			lng: -21.0,
+			direction: 0,
+			nextStops: [],
+		};
+		expect(findLastStop(bus, [])).toBeUndefined();
+	});
+});
+
+// --- Stop filtering logic (mirrors stops/stop commands) ---
+
+describe("stop filtering", () => {
+	test("filters by route", () => {
+		const route6 = mockStops.filter((s) => s.routes.includes("6"));
+		expect(route6.map((s) => s.name)).toContain("Mjódd A");
+		expect(route6.map((s) => s.name)).toContain("Hlemmur");
+		expect(route6.map((s) => s.name)).not.toContain("Grandi");
+	});
+
+	test("filters by search", () => {
+		const query = "hamra";
+		const results = mockStops.filter((s) => s.name.toLowerCase().includes(query));
+		expect(results).toHaveLength(1);
+		expect(results[0]?.name).toBe("Hamraborg");
+	});
+
+	test("exact match lookup", () => {
+		const query = "hamraborg";
+		const matches = mockStops.filter((s) => s.name.toLowerCase() === query);
+		expect(matches).toHaveLength(1);
+	});
+
+	test("fuzzy suggestions for partial match", () => {
+		const query = "hamra";
+		const exact = mockStops.filter((s) => s.name.toLowerCase() === query);
+		expect(exact).toHaveLength(0);
+		const fuzzy = mockStops.filter((s) => s.name.toLowerCase().includes(query));
+		expect(fuzzy.length).toBeGreaterThan(0);
+	});
+});