@jmruthers/pace-core 0.5.186 → 0.5.187

package/src/utils/google-places/googlePlacesUtils.test.ts

@@ -0,0 +1,403 @@
+/**
+ * @file Google Places API Utilities Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/GooglePlaces/__tests__
+ * @since 0.1.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach, beforeAll } from 'vitest';
+import {
+  fetchPlaceAutocomplete,
+  fetchPlaceDetails,
+  parseAddressComponents,
+  createAddressFromPlaceResult,
+  getAddressByPlaceId,
+} from './googlePlacesUtils';
+import { clearInFlightRequests } from '../request-deduplication';
+import type { GoogleAddressComponent } from './types';
+
+// Mock loadGoogleMapsScript
+vi.mock('./loadGoogleMapsScript', () => {
+  // Setup window.google before returning the mock
+  const googleMapsMock = {
+    maps: {
+      places: {
+        AutocompleteService: vi.fn(),
+        PlacesService: vi.fn(),
+        PlacesServiceStatus: {
+          OK: 'OK',
+          ZERO_RESULTS: 'ZERO_RESULTS',
+          NOT_FOUND: 'NOT_FOUND',
+          REQUEST_DENIED: 'REQUEST_DENIED',
+          INVALID_REQUEST: 'INVALID_REQUEST',
+          OVER_QUERY_LIMIT: 'OVER_QUERY_LIMIT',
+        },
+      },
+      LatLng: vi.fn(),
+    },
+  };
+
+  if (typeof global !== 'undefined') {
+    (global as any).window = {
+      ...(global as any).window,
+      google: googleMapsMock,
+    };
+  }
+
+  return {
+    loadGoogleMapsScript: vi.fn().mockResolvedValue(undefined),
+    isGoogleMapsLoaded: vi.fn(() => {
+      const win = typeof window !== 'undefined' ? window : (global as any).window;
+      return !!(win?.google?.maps?.places);
+    }),
+  };
+});
+
+// Mock window.google.maps.places
+const mockAutocompleteService = {
+  getPlacePredictions: vi.fn(),
+};
+
+const mockPlacesService = {
+  getDetails: vi.fn(),
+};
+
+// Setup global window.google mock before any tests
+const setupGoogleMapsMock = () => {
+  const googleMapsMock = {
+    maps: {
+      places: {
+        AutocompleteService: vi.fn(() => mockAutocompleteService),
+        PlacesService: vi.fn(() => mockPlacesService),
+        PlacesServiceStatus: {
+          OK: 'OK',
+          ZERO_RESULTS: 'ZERO_RESULTS',
+          NOT_FOUND: 'NOT_FOUND',
+          REQUEST_DENIED: 'REQUEST_DENIED',
+          INVALID_REQUEST: 'INVALID_REQUEST',
+          OVER_QUERY_LIMIT: 'OVER_QUERY_LIMIT',
+        },
+      },
+      LatLng: vi.fn((lat: number, lng: number) => ({
+        lat: () => lat,
+        lng: () => lng,
+      })),
+    },
+  };
+
+  if (typeof window !== 'undefined') {
+    (window as any).google = googleMapsMock;
+  }
+  if (typeof global !== 'undefined') {
+    (global as any).window = {
+      ...(global as any).window,
+      google: googleMapsMock,
+    };
+  }
+};
+
+// Setup immediately
+setupGoogleMapsMock();
+
+describe('Google Places API Utilities', () => {
+  const mockApiKey = 'test-api-key';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    clearInFlightRequests();
+    // Reset mocks
+    mockAutocompleteService.getPlacePredictions.mockClear();
+    mockPlacesService.getDetails.mockClear();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('fetchPlaceAutocomplete', () => {
+    it('fetches autocomplete predictions successfully', async () => {
+      const mockPredictions = [
+        {
+          description: '123 Main St, Melbourne VIC, Australia',
+          place_id: 'ChIJ123',
+          structured_formatting: {
+            main_text: '123 Main St',
+            secondary_text: 'Melbourne VIC, Australia',
+          },
+        },
+      ];
+
+      mockAutocompleteService.getPlacePredictions.mockImplementation((request, callback) => {
+        callback(mockPredictions, 'OK');
+      });
+
+      const result = await fetchPlaceAutocomplete('123 Main', mockApiKey);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].place_id).toBe('ChIJ123');
+      expect(result[0].description).toBe('123 Main St, Melbourne VIC, Australia');
+      expect(mockAutocompleteService.getPlacePredictions).toHaveBeenCalled();
+    }, { timeout: 5000 });
+
+    it('returns empty array for empty query', async () => {
+      const result = await fetchPlaceAutocomplete('', mockApiKey);
+      expect(result).toEqual([]);
+    });
+
+    it('returns empty array for whitespace-only query', async () => {
+      const result = await fetchPlaceAutocomplete('   ', mockApiKey);
+      expect(result).toEqual([]);
+    });
+
+    it('throws error when API key is missing', async () => {
+      await expect(fetchPlaceAutocomplete('123 Main', '')).rejects.toThrow('API key is required');
+    });
+
+    it('handles ZERO_RESULTS status', async () => {
+      mockAutocompleteService.getPlacePredictions.mockImplementation((request, callback) => {
+        callback(null, 'ZERO_RESULTS');
+      });
+
+      const result = await fetchPlaceAutocomplete('nonexistent', mockApiKey);
+      expect(result).toEqual([]);
+    }, { timeout: 5000 });
+
+    it('handles REQUEST_DENIED status', async () => {
+      mockAutocompleteService.getPlacePredictions.mockImplementation((request, callback) => {
+        callback(null, 'REQUEST_DENIED');
+      });
+
+      await expect(fetchPlaceAutocomplete('123 Main', mockApiKey)).rejects.toThrow('REQUEST_DENIED');
+    }, { timeout: 5000 });
+
+    it('handles errors', async () => {
+      mockAutocompleteService.getPlacePredictions.mockImplementation((request, callback) => {
+        callback(null, 'INVALID_REQUEST');
+      });
+
+      await expect(fetchPlaceAutocomplete('123 Main', mockApiKey)).rejects.toThrow();
+    }, { timeout: 5000 });
+
+    it('includes optional parameters in request', async () => {
+      mockAutocompleteService.getPlacePredictions.mockImplementation((request, callback) => {
+        callback([], 'OK');
+      });
+
+      await fetchPlaceAutocomplete('123 Main', mockApiKey, {
+        components: 'country:au',
+        location: '-37.8136,144.9631',
+        radius: 5000,
+        types: 'address',
+        language: 'en',
+      });
+
+      expect(mockAutocompleteService.getPlacePredictions).toHaveBeenCalled();
+      const callArgs = mockAutocompleteService.getPlacePredictions.mock.calls[0][0];
+      expect(callArgs.input).toBe('123 Main');
+      // Country codes are converted to uppercase in the implementation
+      expect(callArgs.componentRestrictions).toEqual({ country: 'AU' });
+      expect(callArgs.radius).toBe(5000);
+      expect(callArgs.types).toEqual(['address']);
+      expect(callArgs.language).toBe('en');
+    }, { timeout: 5000 });
+  });
+
+  describe('fetchPlaceDetails', () => {
+    it('fetches place details successfully', async () => {
+      const mockPlace = {
+        place_id: 'ChIJ123',
+        formatted_address: '123 Main St, Melbourne VIC 3000, Australia',
+        address_components: [
+          { long_name: '123', short_name: '123', types: ['street_number'] },
+          { long_name: 'Main Street', short_name: 'Main St', types: ['route'] },
+          { long_name: 'Melbourne', short_name: 'Melbourne', types: ['locality'] },
+          { long_name: 'Victoria', short_name: 'VIC', types: ['administrative_area_level_1'] },
+          { long_name: '3000', short_name: '3000', types: ['postal_code'] },
+          { long_name: 'Australia', short_name: 'AU', types: ['country'] },
+        ],
+        geometry: {
+          location: {
+            lat: () => -37.8136,
+            lng: () => 144.9631,
+          },
+        },
+      };
+
+      mockPlacesService.getDetails.mockImplementation((request, callback) => {
+        callback(mockPlace, 'OK');
+      });
+
+      const result = await fetchPlaceDetails('ChIJ123', mockApiKey);
+
+      expect(result.place_id).toBe('ChIJ123');
+      expect(result.formatted_address).toBe('123 Main St, Melbourne VIC 3000, Australia');
+      expect(result.geometry?.location?.lat()).toBe(-37.8136);
+      expect(mockPlacesService.getDetails).toHaveBeenCalled();
+    }, { timeout: 5000 });
+
+    it('throws error when place_id is missing', async () => {
+      await expect(fetchPlaceDetails('', mockApiKey)).rejects.toThrow('Place ID is required');
+    });
+
+    it('throws error when API key is missing', async () => {
+      await expect(fetchPlaceDetails('ChIJ123', '')).rejects.toThrow('API key is required');
+    });
+
+    it('handles NOT_FOUND status', async () => {
+      mockPlacesService.getDetails.mockImplementation((request, callback) => {
+        callback(null, 'NOT_FOUND');
+      });
+
+      await expect(fetchPlaceDetails('invalid', mockApiKey)).rejects.toThrow('Place not found');
+    }, { timeout: 5000 });
+  });
+
+  describe('parseAddressComponents', () => {
+    it('parses address components correctly', () => {
+      const components: GoogleAddressComponent[] = [
+        { long_name: '123', short_name: '123', types: ['street_number'] },
+        { long_name: 'Main Street', short_name: 'Main St', types: ['route'] },
+        { long_name: 'Melbourne', short_name: 'Melbourne', types: ['locality'] },
+        { long_name: 'Victoria', short_name: 'VIC', types: ['administrative_area_level_1'] },
+        { long_name: '3000', short_name: '3000', types: ['postal_code'] },
+        { long_name: 'Australia', short_name: 'AU', types: ['country'] },
+      ];
+
+      const result = parseAddressComponents(components);
+
+      expect(result.street_number).toBe('123');
+      expect(result.route).toBe('Main Street');
+      expect(result.suburb).toBe('Melbourne');
+      expect(result.state).toBe('VIC');
+      expect(result.postcode).toBe('3000');
+      expect(result.country).toBe('AU');
+    });
+
+    it('handles missing components', () => {
+      const components: GoogleAddressComponent[] = [
+        { long_name: 'Melbourne', short_name: 'Melbourne', types: ['locality'] },
+      ];
+
+      const result = parseAddressComponents(components);
+
+      expect(result.street_number).toBeNull();
+      expect(result.route).toBeNull();
+      expect(result.suburb).toBe('Melbourne');
+      expect(result.state).toBeNull();
+      expect(result.postcode).toBeNull();
+      expect(result.country).toBeNull();
+    });
+
+    it('handles empty components array', () => {
+      const result = parseAddressComponents([]);
+
+      expect(result.street_number).toBeNull();
+      expect(result.route).toBeNull();
+      expect(result.suburb).toBeNull();
+      expect(result.state).toBeNull();
+      expect(result.postcode).toBeNull();
+      expect(result.country).toBeNull();
+    });
+
+    it('prefers locality over sublocality', () => {
+      const components: GoogleAddressComponent[] = [
+        { long_name: 'Sublocality', short_name: 'Sublocality', types: ['sublocality'] },
+        { long_name: 'Locality', short_name: 'Locality', types: ['locality'] },
+      ];
+
+      const result = parseAddressComponents(components);
+      expect(result.suburb).toBe('Locality');
+    });
+  });
+
+  describe('createAddressFromPlaceResult', () => {
+    it('creates parsed address from place result', () => {
+      const placeResult = {
+        place_id: 'ChIJ123',
+        formatted_address: '123 Main St, Melbourne VIC 3000, Australia',
+        address_components: [
+          { long_name: '123', short_name: '123', types: ['street_number'] },
+          { long_name: 'Main Street', short_name: 'Main St', types: ['route'] },
+          { long_name: 'Melbourne', short_name: 'Melbourne', types: ['locality'] },
+          { long_name: 'Victoria', short_name: 'VIC', types: ['administrative_area_level_1'] },
+          { long_name: '3000', short_name: '3000', types: ['postal_code'] },
+          { long_name: 'Australia', short_name: 'AU', types: ['country'] },
+        ],
+        geometry: {
+          location: {
+            lat: () => -37.8136,
+            lng: () => 144.9631,
+          },
+        },
+      };
+
+      const result = createAddressFromPlaceResult(placeResult);
+
+      expect(result.place_id).toBe('ChIJ123');
+      expect(result.full_address).toBe('123 Main St, Melbourne VIC 3000, Australia');
+      expect(result.street_number).toBe('123');
+      expect(result.route).toBe('Main Street');
+      expect(result.suburb).toBe('Melbourne');
+      expect(result.state).toBe('VIC');
+      expect(result.postcode).toBe('3000');
+      expect(result.country).toBe('AU');
+      expect(result.lat).toBe(-37.8136);
+      expect(result.lng).toBe(144.9631);
+    });
+
+    it('handles missing geometry', () => {
+      const placeResult = {
+        place_id: 'ChIJ123',
+        formatted_address: '123 Main St',
+        address_components: [],
+        geometry: {},
+      };
+
+      const result = createAddressFromPlaceResult(placeResult);
+
+      expect(result.place_id).toBe('ChIJ123');
+      expect(result.lat).toBeNull();
+      expect(result.lng).toBeNull();
+    });
+  });
+
+  describe('getAddressByPlaceId', () => {
+    it('retrieves address by place_id successfully', async () => {
+      const mockPlace = {
+        place_id: 'ChIJ123',
+        formatted_address: '123 Main St, Melbourne VIC 3000, Australia',
+        address_components: [
+          { long_name: '123', short_name: '123', types: ['street_number'] },
+          { long_name: 'Main Street', short_name: 'Main St', types: ['route'] },
+          { long_name: 'Melbourne', short_name: 'Melbourne', types: ['locality'] },
+        ],
+        geometry: {
+          location: {
+            lat: () => -37.8136,
+            lng: () => 144.9631,
+          },
+        },
+      };
+
+      mockPlacesService.getDetails.mockImplementation((request, callback) => {
+        callback(mockPlace, 'OK');
+      });
+
+      const result = await getAddressByPlaceId('ChIJ123', mockApiKey);
+
+      expect(result).not.toBeNull();
+      expect(result?.place_id).toBe('ChIJ123');
+      expect(result?.full_address).toBe('123 Main St, Melbourne VIC 3000, Australia');
+    }, { timeout: 5000 });
+
+    it('returns null on error', async () => {
+      mockPlacesService.getDetails.mockImplementation((request, callback) => {
+        callback(null, 'NOT_FOUND');
+      });
+
+      const result = await getAddressByPlaceId('ChIJ123', mockApiKey);
+      expect(result).toBeNull();
+    }, { timeout: 5000 });
+  });
+});
+