Update PU-API repository tests for private geodata helper.

Assert map and search behavior through public repository methods and expected endpoint URLs.

Author: jochbru

server/src/repositories/map.repository.spec.ts

@@ -16,17 +16,13 @@ describe(MapRepository.name, () => {
       getEnv: vitest.fn().mockReturnValue({ puApiHost: 'http://pu-api' }),
     } as unknown as ConfigRepository;
     const puApiRepository = {
-      requestGeodata: vitest.fn().mockResolvedValue({ country: 'NL', state: 'NH', city: 'Amsterdam' }),
+      reverseGeocode: vitest.fn().mockResolvedValue({ country: 'NL', state: 'NH', city: 'Amsterdam' }),
     } as unknown as PuApiRepository;
     const sut = new MapRepository(configRepository, metadataRepository, puApiRepository, logger as never, db as never);
 
     const result = await sut.reverseGeocode({ latitude: 1, longitude: 2 });
 
-    expect(puApiRepository.requestGeodata).toHaveBeenCalledWith({
-      path: '/reverse-geocode',
-      query: { lat: 1, lon: 2 },
-      context: 'reverse geocode',
-    });
+    expect(puApiRepository.reverseGeocode).toHaveBeenCalledWith({ latitude: 1, longitude: 2 });
     expect(result).toEqual({ country: 'NL', state: 'NH', city: 'Amsterdam' });
   });
 
@@ -35,7 +31,7 @@ describe(MapRepository.name, () => {
       getEnv: vitest.fn().mockReturnValue({ puApiHost: null }),
     } as unknown as ConfigRepository;
     const puApiRepository = {
-      requestGeodata: vitest.fn(),
+      reverseGeocode: vitest.fn(),
     } as unknown as PuApiRepository;
     const sut = new MapRepository(configRepository, metadataRepository, puApiRepository, logger as never, db as never);
     const fallbackSpy = vitest
@@ -45,7 +41,7 @@ describe(MapRepository.name, () => {
     const result = await sut.reverseGeocode({ latitude: 3, longitude: 4 });
 
     expect(fallbackSpy).toHaveBeenCalledWith({ latitude: 3, longitude: 4 });
-    expect(puApiRepository.requestGeodata).not.toHaveBeenCalled();
+    expect(puApiRepository.reverseGeocode).not.toHaveBeenCalled();
     expect(result).toEqual({ country: null, state: null, city: null });
   });
 });

server/src/repositories/pu-api.repository.spec.ts

@@ -72,21 +72,20 @@ describe(PuApiRepository.name, () => {
     expect(logger.debug).toHaveBeenCalledWith('Skipping PU API tenant sync, PU_API_HOST or PU_TENANT_NAME is not configured');
   });
 
-  it('should return null request when token cannot be read', async () => {
+  it('should return null reverse geocode when token cannot be read', async () => {
     vitest.mocked(readFile).mockRejectedValue(new Error('not found'));
 
-    const result = await sut.requestGeodata({
-      path: '/reverse-geocode',
-      query: { lat: 1.23, lon: 4.56 },
-      context: 'reverse geocode',
+    const result = await sut.reverseGeocode<{ country: string; state: string; city: string }>({
+      latitude: 1.23,
+      longitude: 4.56,
     });
 
     expect(result).toBeNull();
     expect(global.fetch).not.toHaveBeenCalled();
     expect(logger.error).toHaveBeenCalled();
   });
 
-  it('should return geodata response payload', async () => {
+  it('should return reverse geocode payload', async () => {
     vitest.spyOn(global, 'fetch').mockResolvedValue({
       ok: true,
       headers: new Headers(),
@@ -99,36 +98,49 @@ describe(PuApiRepository.name, () => {
       statusText: 'OK',
     } as Response);
 
-    const result = await sut.requestGeodata<{ country: string; state: string; city: string }>({
-      path: '/reverse-geocode',
-      query: { lat: 52.37, lon: 4.89 },
-      context: 'reverse geocode',
+    const result = await sut.reverseGeocode<{ country: string; state: string; city: string }>({
+      latitude: 52.37,
+      longitude: 4.89,
     });
 
     expect(result).toEqual({ country: 'NL', state: 'North Holland', city: 'Amsterdam' });
+    expect(global.fetch).toHaveBeenCalledWith(
+      new URL('/internal/api/map/reverse-geocode?lat=52.37&lon=4.89', 'http://pu-api'),
+      expect.anything(),
+    );
   });
 
-  it('should call reverse geocode endpoint via helper method', async () => {
-    const requestSpy = vitest.spyOn(sut, 'requestGeodata').mockResolvedValue({ country: null, state: null, city: null });
+  it('should call reverse geocode endpoint', async () => {
+    vitest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: true,
+      headers: new Headers(),
+      json: async () => ({ country: null, state: null, city: null }),
+      status: 200,
+      statusText: 'OK',
+    } as Response);
 
     await sut.reverseGeocode({ latitude: 52.37, longitude: 4.89 });
 
-    expect(requestSpy).toHaveBeenCalledWith({
-      path: '/reverse-geocode',
-      query: { lat: 52.37, lon: 4.89 },
-      context: 'reverse geocode',
-    });
+    expect(global.fetch).toHaveBeenCalledWith(
+      new URL('/internal/api/map/reverse-geocode?lat=52.37&lon=4.89', 'http://pu-api'),
+      expect.anything(),
+    );
   });
 
-  it('should call search places endpoint via helper method', async () => {
-    const requestSpy = vitest.spyOn(sut, 'requestGeodata').mockResolvedValue([]);
+  it('should call search places endpoint', async () => {
+    vitest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: true,
+      headers: new Headers(),
+      json: async () => [],
+      status: 200,
+      statusText: 'OK',
+    } as Response);
 
     await sut.searchPlaces('amst');
 
-    expect(requestSpy).toHaveBeenCalledWith({
-      path: '/search-places',
-      query: { q: 'amst' },
-      context: 'search places',
-    });
+    expect(global.fetch).toHaveBeenCalledWith(
+      new URL('/internal/api/map/search-places?q=amst', 'http://pu-api'),
+      expect.anything(),
+    );
   });
 });