TomTom MCP Server

/* * Copyright (C) 2025 TomTom NV * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import { describe, it, expect } from "vitest"; import { searchPlaces, poiSearch, searchNearby, fuzzySearch, reverseGeocode, geocodeAddress, } from "./searchService"; import { beforeEach } from "vitest"; beforeEach(async () => { await new Promise((resolve) => setTimeout(resolve, 500)); }); // Real test using actual API calls describe("Search Service", () => { it("should search for a city name (Amsterdam)", async () => { // Call the service with real query const result = await searchPlaces("Amsterdam"); // Basic validation of the structure of the response expect(result).toBeDefined(); expect(result.results).toBeDefined(); expect(result.results?.length).toBeGreaterThan(0); expect(result.summary).toBeDefined(); expect(result.summary?.query).toBe("amsterdam"); // Check that at least one result has Amsterdam in the freeformAddress const amsterdamResult = result.results?.find( (r) => r.address && r.address.freeformAddress && r.address.freeformAddress.includes("Amsterdam") ); expect(amsterdamResult).toBeDefined(); // Check that the result has geographic coordinates expect(amsterdamResult?.position).toBeDefined(); expect(typeof amsterdamResult?.position?.lat).toBe("number"); expect(typeof amsterdamResult?.position?.lon).toBe("number"); }); it("should search for points of interest with a category", async () => { // Search for restaurants in Amsterdam const result = await poiSearch("restaurant", { limit: 5, lon: 4.89707, // Amsterdam lat: 52.377956, radius: 2000, }); // Validate response structure expect(result).toBeDefined(); expect(result.results).toBeDefined(); expect(Array.isArray(result.results)).toBe(true); expect(result.results?.length).toBeGreaterThan(0); }); it("should search for nearby points of interest", async () => { // Berlin coordinates const lat = 52.520008; const lon = 13.404954; const radius = 2000; // 2km radius const result = await searchNearby(lat, lon, { radius }); // Validate response structure expect(result).toBeDefined(); expect(result.results).toBeDefined(); expect(Array.isArray(result.results)).toBe(true); expect(result.results?.length).toBeGreaterThan(0); // Check that results are within the radius of Berlin const firstResult = result.results?.[0]; expect(firstResult).toBeDefined(); expect(firstResult?.position).toBeDefined(); expect(firstResult?.position.lat).toBeCloseTo(52.520008, 0); expect(firstResult?.position.lon).toBeCloseTo(13.404954, 0); // Check that each result has required properties result.results?.forEach((poi) => { expect(poi.type).toBeDefined(); expect(poi.id).toBeDefined(); expect(typeof poi.score).toBe("number"); expect(poi.position).toBeDefined(); expect(typeof poi.position.lat).toBe("number"); expect(typeof poi.position.lon).toBe("number"); }); }); it("should perform fuzzy search with location bias", async () => { const result = await fuzzySearch("cafe", { lat: 52.377956, // Amsterdam lon: 4.89707, radius: 5000, // 5km radius limit: 3, }); // Validate response structure expect(result).toBeDefined(); expect(result.results).toBeDefined(); expect(Array.isArray(result.results)).toBe(true); // Verify that we have results expect(result.results?.length).toBeGreaterThan(0); // Check that results have proper structure const firstResult = result.results?.[0]; expect(firstResult).toBeDefined(); expect(firstResult?.position).toBeDefined(); expect(firstResult?.address).toBeDefined(); }); it("should perform reverse geocoding", async () => { const lat = 52.377956; // Amsterdam const lon = 4.89707; const result = await reverseGeocode(lat, lon); // Validate response structure expect(result).toBeDefined(); // The response could be either SearchResult or ReverseGeocodingResult let firstItem: any; if ("results" in result && result.results && result.results.length > 0) { // It's a SearchResult expect(result.results).toBeDefined(); firstItem = result.results[0]; } else if ("addresses" in result && result.addresses && result.addresses.length > 0) { // It's a ReverseGeocodingResult expect(result.addresses).toBeDefined(); firstItem = result.addresses[0]; } expect(firstItem).toBeDefined(); const address = firstItem?.address; expect(address).toBeDefined(); // Check coordinates are close to what we requested - some API versions may use different property names const position = firstItem?.position; expect(position).toBeDefined(); if (position) { // In some API responses, position properties might have different names if (typeof position.lat === "number" && typeof position.lon === "number") { expect(position.lat).toBeCloseTo(lat, 1); // Within ~10km expect(position.lon).toBeCloseTo(lon, 1); } else if (typeof position.latitude === "number" && typeof position.longitude === "number") { expect(position.latitude).toBeCloseTo(lat, 1); expect(position.longitude).toBeCloseTo(lon, 1); } else { // Skip position checks if structure is different console.log("Position structure in reverse geocoding response differs from expected"); } } }); it("should geocode an address", async () => { const result = await geocodeAddress("Dam Square, Amsterdam"); // Validate response structure expect(result).toBeDefined(); expect(result.results).toBeDefined(); expect(Array.isArray(result.results)).toBe(true); // Check that we got results about Dam Square expect(result.results?.length).toBeGreaterThan(0); const damSquareResult = result.results?.find( (r) => r.address && r.address.freeformAddress && (r.address.freeformAddress.includes("Dam") || r.address.streetName?.includes("Dam")) ); expect(damSquareResult).toBeDefined(); // Check that we have coordinates expect(damSquareResult?.position).toBeDefined(); expect(typeof damSquareResult?.position.lat).toBe("number"); expect(typeof damSquareResult?.position.lon).toBe("number"); }); it("should handle fuzzy search with advanced options", async () => { const query = "restaurant"; const options = { limit: 3, typeahead: true, lat: 52.377956, lon: 4.89707, radius: 5000, countrySet: "NL", language: "nl-NL", categorySet: "7315", brandSet: "mcdonalds", maxFuzzyLevel: 2, minFuzzyLevel: 1, }; const result = await fuzzySearch(query, options); // Validate response structure expect(result).toBeDefined(); expect(result.summary).toBeDefined(); expect(result.results).toBeDefined(); }); it("should handle fuzzy search with bounding box", async () => { const query = "hotel"; const options = { topLeft: "52.4,4.8", btmRight: "52.3,4.95", limit: 3, }; const result = await fuzzySearch(query, options); // Validate response structure expect(result).toBeDefined(); expect(result.summary).toBeDefined(); expect(result.results).toBeDefined(); }); it("should handle POI search with EV options", async () => { try { const query = "charging station"; const options = { lat: 52.377956, lon: 4.89707, radius: 10000, connectorSet: "CCS", minPowerKW: 50, openingHours: "nextSevenDays", }; const result = await poiSearch(query, options); // Validate response structure expect(result).toBeDefined(); expect(result.summary).toBeDefined(); // Check if we got results - may not always find results depending on data if (result.results && result.results.length > 0) { expect(result.results[0].position).toBeDefined(); } } catch (error) { // Some TomTom API features might not be available in the test environment console.log( "POI search with EV options might not be fully supported, skipping detailed checks" ); } }); it("should handle POI search with fuel options", async () => { try { const query = "gas station"; const options = { lat: 52.377956, lon: 4.89707, radius: 10000, fuelSet: "diesel", openingHours: "nextSevenDays", }; const result = await poiSearch(query, options); // Validate response structure expect(result).toBeDefined(); expect(result.summary).toBeDefined(); } catch (error) { console.log( "POI search with fuel options might not be fully supported, skipping detailed checks" ); } }); it("should handle searchNearby with different parameters", async () => { // Test with only lat and lon (default radius) const lat = 52.377956; const lon = 4.89707; const result = await searchNearby(lat, lon); // Validate response structure expect(result).toBeDefined(); expect(result.summary).toBeDefined(); expect(Array.isArray(result.results)).toBe(true); }); it("should handle fuzzy search with no options", async () => { const query = "Amsterdam"; const result = await fuzzySearch(query); // Validate response structure expect(result).toBeDefined(); expect(result.summary).toBeDefined(); expect(Array.isArray(result.results)).toBe(true); }); it("should handle geocoding errors gracefully", async () => { try { // Using a very unusual address that should return no results or error const result = await geocodeAddress("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ"); // Even if it doesn't find an address, it should return a valid structure expect(result).toBeDefined(); expect(result.summary).toBeDefined(); expect(Array.isArray(result.results)).toBe(true); // Likely no results expect(result.results?.length).toBe(0); } catch (error) { // If the API returns an error, that's also an acceptable outcome console.log("Geocoding with invalid input might throw or return empty results"); } }); it("should handle reverse geocoding with invalid coordinates gracefully", async () => { try { // Using coordinates that are technically valid but unlikely to have data const result = await reverseGeocode(0, 0); // Null Island // Even for unusual coordinates, it should return a valid structure expect(result).toBeDefined(); // Check if it's a SearchResult or ReverseGeocodingResult expect("results" in result || "addresses" in result).toBe(true); } catch (error) { // If the API returns an error, that's also an acceptable outcome console.log("Reverse geocoding with unusual coordinates might throw or return empty results"); } }); it("should search nearby with all parameters", async () => { const lat = 52.377956; // Amsterdam const lon = 4.89707; const category = "7315"; // Restaurant category const radius = 1500; const result = await searchNearby(lat, lon, { categorySet: category, radius }); // Validate response structure expect(result).toBeDefined(); expect(result.summary).toBeDefined(); expect(Array.isArray(result.results)).toBe(true); // Check that results are properly structured and have position data if (result.results && result.results.length > 0) { const firstResult = result.results[0]; expect(firstResult.position).toBeDefined(); expect(firstResult.id).toBeDefined(); // For POI search, should include poi information if (firstResult.poi) { expect(firstResult.poi.name).toBeDefined(); } } }); it("should geocode an address with advanced options", async () => { const address = "Amsterdam Central Station"; const options = { countrySet: "NL", limit: 3, language: "nl-NL", // Remove the problematic parameters based on API errors view: "Unified", extendedPostalCodesFor: "PAD", }; const result = await geocodeAddress(address, options); expect(result).toBeTruthy(); expect(result.results).toBeTruthy(); expect(result.results?.length).toBeGreaterThan(0); if (result.results && result.results.length > 0) { expect(result.results[0].address).toBeTruthy(); expect(result.results[0].position).toBeTruthy(); } }); it("should reverse geocode coordinates with advanced options", async () => { const lat = 52.377956; const lon = 4.89707; const options = { radius: 200, limit: 3, language: "nl-NL", entityTypeSet: "Address", // Remove mapcodes since it's causing issues view: "Unified", geometries: true, addressRanges: true, }; const result = await reverseGeocode(lat, lon, options); expect(result).toBeTruthy(); // Check if it's a SearchResult or ReverseGeocodingResult if ("results" in result && result.results) { expect(result.results.length).toBeGreaterThan(0); expect(result.results[0].address).toBeTruthy(); expect(result.results[0].position).toBeTruthy(); } else if ("addresses" in result && result.addresses) { expect(result.addresses.length).toBeGreaterThan(0); expect(result.addresses[0].address).toBeTruthy(); expect(result.addresses[0].position).toBeTruthy(); } else { // Fail the test if neither structure is present throw new Error("Response does not contain expected structure"); } }); it("should perform reverse geocoding with enhanced parameters", async () => { // Coordinates for a known location (Amsterdam) const lat = 52.377956; const lon = 4.89707; const options = { radius: 150, returnMatchType: true, returnAddressNames: true, }; // Since we've been getting 503 errors, we'll make this test more robust try { const result = await reverseGeocode(lat, lon, options); // Check if the result includes the expected properties if ("addresses" in result) { // Using the ReverseGeocodingResult interface expect(result.summary).toBeDefined(); expect(result.summary.numResults).toBeGreaterThanOrEqual(1); expect(result.addresses).toBeDefined(); expect(result.addresses.length).toBeGreaterThanOrEqual(1); if (result.addresses.length > 0) { expect(result.addresses[0].address).toBeDefined(); expect(result.addresses[0].position).toBeDefined(); if (options.returnMatchType) { expect(result.addresses[0].matchType).toBeDefined(); } } } else if ("results" in result) { // Using the SearchResult interface (backward compatibility) expect(result.results).toBeDefined(); if (result.results) { expect(result.results.length).toBeGreaterThanOrEqual(1); if (result.results.length > 0) { expect(result.results[0].address).toBeDefined(); expect(result.results[0].position).toBeDefined(); } } } else { throw new Error("Response does not contain expected structure"); } } catch (error: any) { // Skip the test if the service is temporarily unavailable (503 error) if (error.message && error.message.includes("503")) { console.log("Skipping test due to TomTom service unavailable (503)"); // Don't fail the test when we get a 503 } else { // Re-throw other errors throw error; } } }); });