fix(locations): surface account locations backed only by newly created buckets

Author: hervedombya

src/react/next-architecture/domain/business/locations.test.tsx

@@ -1,11 +1,20 @@
 import { ShellHooksProvider } from '@scality/module-federation';
 import { act, renderHook } from '@testing-library/react-hooks';
+import { rest } from 'msw';
+import { setupServer } from 'msw/node';
 import type { PropsWithChildren } from 'react';
 import { QueryClient } from 'react-query';
 import { QueryClientProvider } from '../../../../QueryClientProvider';
 import type { LocationTypeKey } from '../../../../types/config';
 import * as DSRProvider from '../../../DataServiceRoleProvider';
-import { mockShellAlerts, mockShellHooks, WrapperAsStorageManager } from '../../../utils/testUtil';
+import { _ManagementContext } from '../../../ManagementProvider';
+import {
+  mockShellAlerts,
+  mockShellHooks,
+  TEST_API_BASE_URL,
+  TEST_MANAGEMENT_CLIENT,
+  WrapperAsStorageManager,
+} from '../../../utils/testUtil';
 import { MockedAccountsLocationsAdapter } from '../../adapters/accounts-locations/MockedAccountsLocationsAdapter';
 import {
   ACCOUNT_OWN_METRICS,
@@ -45,11 +54,23 @@ const queryClient = new QueryClient({
     },
   },
 });
+const server = setupServer(
+  rest.get(`${TEST_API_BASE_URL}/api/v1/instance/:instanceId/status`, (_req, res, ctx) => res(ctx.json({}))),
+);
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'bypass' }));
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
 const Wrapper = ({ children }: PropsWithChildren<Record<string, never>>) => {
   return (
     <WrapperAsStorageManager isStorageManager={true}>
       <ShellHooksProvider shellHooks={mockShellHooks} shellAlerts={mockShellAlerts}>
-        <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+        <QueryClientProvider client={queryClient}>
+          <_ManagementContext.Provider value={{ managementClient: TEST_MANAGEMENT_CLIENT }}>
+            {children}
+          </_ManagementContext.Provider>
+        </QueryClientProvider>
       </ShellHooksProvider>
     </WrapperAsStorageManager>
   );
@@ -431,4 +452,61 @@ describe('useListLocationsForCurrentAccount', () => {
     };
     expect(result.current).toStrictEqual(expectedRes);
   });
+
+  it('shows a location backed only by a freshly created bucket, resolving the bucket location name to its id', async () => {
+    // S
+    jest.spyOn(DSRProvider, 'useCurrentAccount').mockReturnValue({
+      account: {
+        id: 'account-id-bucket-only',
+        Name: 'BucketOnly',
+        Roles: [],
+        CreationDate: DEFAULT_METRICS_MESURED_ON,
+        CanonicalId: 'canonical-id-bucket-only',
+      },
+    });
+    // The account has no location metrics yet, but owns a bucket on `us-east-1`
+    // whose location id (95dbedf5-...) differs from its name.
+    server.use(
+      rest.get(`${TEST_API_BASE_URL}/api/v1/instance/:instanceId/status`, (_req, res, ctx) =>
+        res(
+          ctx.json({
+            metrics: {
+              'item-counts': {
+                bucketList: [
+                  {
+                    name: 'freshly-created-bucket',
+                    location: 'us-east-1',
+                    ownerCanonicalId: 'canonical-id-bucket-only',
+                  },
+                ],
+              },
+            },
+          }),
+        ),
+      ),
+    );
+
+    const { result, waitFor } = setupAndRenderHook();
+
+    // E
+    await waitFor(() => {
+      return result.current.locations.status === 'success';
+    });
+
+    // V
+    if (result.current.locations.status !== 'success') {
+      throw new Error('expected locations to be successfully loaded');
+    }
+    const value = result.current.locations.value;
+    // Keyed by the location id (objectId), not by the bucket location name.
+    expect(Object.keys(value)).toEqual(['95dbedf5-9888-11ec-8565-1ac2af7d1e53']);
+    const usEast1 = value['95dbedf5-9888-11ec-8565-1ac2af7d1e53'];
+    expect(usEast1.name).toBe('us-east-1');
+    expect(usEast1.usedCapacity.status).toBe('success');
+    // A bucket-only location gets synthesized zero-usage capacity.
+    expect(usEast1.usedCapacity).toMatchObject({
+      status: 'success',
+      value: { type: 'hasMetrics', usedCapacity: { current: 0, nonCurrent: 0 } },
+    });
+  });
 });

src/react/next-architecture/domain/business/locations.ts

@@ -171,7 +171,7 @@ export const useListLocationsForCurrentAccount = ({
 
   const { bucketList, status: bucketListStatus } = useBucketList();
 
-  const bucketLocationIds = useMemo(() => {
+  const bucketLocationNames = useMemo(() => {
     if (bucketListStatus === 'error') {
       return [];
     }
@@ -230,33 +230,34 @@ export const useListLocationsForCurrentAccount = ({
     };
   }
 
-  const accountLocationsKey = Array.from(
-    new Set([...Object.keys(accountLocationData), ...bucketLocationIds]),
-  );
-
   if (allLocations.locations.status !== 'success') {
     return allLocations;
   }
 
+  const metricsByLocationId = accountLocationData ?? {};
+  const bucketLocationNameSet = new Set(bucketLocationNames);
   const allLocationsValue = Object.values(allLocations.locations.value);
   const locations: Record<string, Location> = {};
-  accountLocationsKey.forEach((locationId) => {
-    const locationDefinition = allLocationsValue.find(
-      (l) => l.id === locationId,
-    );
 
-    if (locationDefinition) {
-      const usedCapacityValue: LatestUsedCapacity =
-        locationId in accountLocationData ? accountLocationData[locationId] : ZERO_USED_CAPACITY;
+  allLocationsValue.forEach((locationDefinition) => {
+    const hasMetrics = locationDefinition.id in metricsByLocationId;
+    const isBackedByBucket = bucketLocationNameSet.has(locationDefinition.name);
 
-      locations[locationId] = {
-        ...locationDefinition,
-        usedCapacity: {
-          status: 'success',
-          value: usedCapacityValue,
-        },
-      };
+    if (!hasMetrics && !isBackedByBucket) {
+      return;
     }
+
+    const usedCapacityValue: LatestUsedCapacity = hasMetrics
+      ? metricsByLocationId[locationDefinition.id]
+      : ZERO_USED_CAPACITY;
+
+    locations[locationDefinition.id] = {
+      ...locationDefinition,
+      usedCapacity: {
+        status: 'success',
+        value: usedCapacityValue,
+      },
+    };
   });
 
   return {

src/react/queries/instanceStatusQuery.ts

@@ -3,7 +3,7 @@ import { useMemo } from 'react';
 import { useQuery } from 'react-query';
 import type { InlineResponse200 } from '../../js/managementClient/api';
 import type { ApiError } from '../../types/actions';
-import type { Capabilities } from '../../types/stats';
+import type { BucketList, Capabilities } from '../../types/stats';
 import { notFalsyTypeGuard } from '../../types/typeGuards';
 import { useErrorHandler } from '../ErrorProvider';
 import { useManagementClient } from '../ManagementProvider';
@@ -52,9 +52,9 @@ export const useInstanceStatusQuery = (options?: InstanceStatusQueryOptions) =>
  */
 export const useBucketList = () => {
   const { data, status, isFetching, error } = useInstanceStatusQuery();
-  const rawBucketList = data?.metrics?.['item-counts']?.bucketList;
+  const rawBucketList = data?.metrics?.['item-counts']?.bucketList as BucketList | undefined;
 
-  const bucketList = useMemo(() => {
+  const bucketList = useMemo((): BucketList => {
     return rawBucketList || [];
   }, [JSON.stringify(rawBucketList)]);