feat(pci-block-storage): block retyping for classic 3az volumes

ref: #TAPC-4567

Signed-off-by: Adrien Turmo <[email protected]>

Author: aTurmo

packages/manager/apps/pci-block-storage/public/translations/retype/Messages_fr_FR.json

@@ -1,5 +1,5 @@
 {
-  "pci_projects_project_storages_blocks_retype_cant_retype": "Nous sommes désolé mais vous ne pouvez pas changer votre type d'offre pour le moment",
+  "pci_projects_project_storages_blocks_retype_cant_retype": "Les fonctionnalités de modification du type et de chiffrement ne sont pas disponibiles pour les volumes Classic 3AZ",
   "pci_projects_project_storages_blocks_retype_title": "Modifier votre type d'offre",
   "pci_projects_project_storages_blocks_retype_change_type_title": "Sélectionner le type",
   "pci_projects_project_storages_blocks_retype_change_encryption_title": "Sélectionner le chiffrement",

packages/manager/apps/pci-block-storage/src/api/hooks/useCatalogWithPreselection.spec.tsx

@@ -7,8 +7,12 @@ import {
   TVolumeRetypeModel,
   useCatalogWithPreselection,
 } from '@/api/hooks/useCatalogWithPreselection';
-import { mapRetypingVolumeCatalog } from '@/api/select/catalog';
-import { EncryptionType, getEncryption } from '@/api/select/volume';
+import { is3az, mapRetypingVolumeCatalog } from '@/api/select/catalog';
+import {
+  EncryptionType,
+  getEncryption,
+  isClassicMultiAttach,
+} from '@/api/select/volume';
 import { TRegion } from '@/api/data/regions';
 
 vi.mock('@tanstack/react-query', () => ({
@@ -21,11 +25,13 @@ vi.mock('@/api/select/volume', async (importActual) => {
   return {
     ...actual,
     getEncryption: vi.fn(),
+    isClassicMultiAttach: vi.fn(),
   };
 });
 
 vi.mock('@/api/select/catalog', () => ({
   mapRetypingVolumeCatalog: vi.fn(),
+  is3az: vi.fn(),
 }));
 
 vi.mock('@/api/hooks/useVolume', () => ({
@@ -134,6 +140,8 @@ describe('useCatalogWithPreselection', () => {
       { data: volumeMock, isPending: false },
       { data: mockCatalog, isPending: false },
     ]);
+    vi.mocked(is3az).mockReturnValue(true);
+    vi.mocked(isClassicMultiAttach).mockReturnValue(true);
 
     const { result } = renderHook(() =>
       useCatalogWithPreselection(PROJECT_ID, VOLUME_ID),

packages/manager/apps/pci-block-storage/src/api/hooks/useCatalogWithPreselection.tsx

@@ -6,14 +6,15 @@ import { NAMESPACES } from '@ovh-ux/manager-common-translations';
 import { getVolumeCatalogQuery } from '@/api/hooks/useCatalog';
 import { getVolumeQuery } from '@/api/hooks/useVolume';
 import {
+  is3az,
   mapRetypingVolumeCatalog,
   TModelAttach,
   TModelAvailabilityZones,
   TModelName,
   TModelPreselection,
   TModelPrice,
 } from '@/api/select/catalog';
-import { getEncryption } from '@/api/select/volume';
+import { getEncryption, isClassicMultiAttach } from '@/api/select/volume';
 
 export type TVolumeRetypeModel = TModelPrice &
   TModelAvailabilityZones &
@@ -42,13 +43,9 @@ export const useCatalogWithPreselection = (
   const [data, preselectedEncryptionType] = useMemo(() => {
     if (!catalogData || !volumeData) return [null, null];
 
-    const regionType = catalogData?.regions.find(
-      (region) => region.name === volumeData?.region,
-    )?.type;
-
     if (
-      regionType === 'region-3-az' &&
-      volumeData.type === 'classic-multiattach'
+      is3az(catalogData.regions, volumeData.region) &&
+      isClassicMultiAttach(volumeData)
     ) {
       return [[], null];
     }

packages/manager/apps/pci-block-storage/src/api/hooks/useVolume.spec.tsx

@@ -2,20 +2,31 @@ import { act, renderHook, waitFor } from '@testing-library/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { describe, it, vi } from 'vitest';
 import {
+  useAllVolumes,
   useAttachVolume,
   useDeleteVolume,
   useDetachVolume,
   useVolume,
   useVolumes,
 } from '@/api/hooks/useVolume';
 import {
-  getVolume,
-  getAllVolumes,
-  deleteVolume,
   attachVolume,
+  deleteVolume,
   detachVolume,
+  getAllVolumes,
+  getVolume,
   TAPIVolume,
 } from '@/api/data/volume';
+import {
+  mapVolumeAttach,
+  mapVolumeEncryption,
+  mapVolumePricing,
+  mapVolumeRegion,
+  mapVolumeStatus,
+  mapVolumeType,
+  paginateResults,
+  sortResults,
+} from '@/api/select/volume';
 
 vi.mock('@/api/data/volume', async (importOriginal) => {
   const actual: any = await importOriginal();
@@ -29,6 +40,23 @@ vi.mock('@/api/data/volume', async (importOriginal) => {
   };
 });
 
+vi.mock('@/api/select/volume', async (importOriginal) => {
+  const actual: any = await importOriginal();
+  return {
+    ...actual,
+    mapVolumeAttach: vi.fn().mockReturnValue(vi.fn()),
+    mapVolumeEncryption: vi.fn().mockReturnValue(vi.fn()),
+    mapVolumePricing: vi.fn().mockReturnValue(vi.fn()),
+    mapVolumeRegion: vi.fn().mockReturnValue(vi.fn()),
+    mapVolumeStatus: vi.fn().mockReturnValue(vi.fn()),
+    mapVolumeToAdd: vi.fn().mockReturnValue(vi.fn()),
+    mapVolumeToEdit: vi.fn().mockReturnValue(vi.fn()),
+    mapVolumeType: vi.fn().mockReturnValue(vi.fn()),
+    paginateResults: vi.fn(),
+    sortResults: vi.fn(),
+  };
+});
+
 vi.mock('@/api/data/catalog');
 
 const queryClient = new QueryClient();
@@ -49,21 +77,8 @@ const onSuccess = vi.fn();
 const onError = vi.fn();
 
 describe('useVolume', () => {
-  it('returns volume data when volumeId is provided', async () => {
-    const volumeMock = {
-      id: '1',
-      name: 'Volume 1',
-      attachedTo: [],
-      creationDate: '',
-      description: '',
-      size: 0,
-      status: '',
-      region: 'region1',
-      bootable: false,
-      planCode: '',
-      type: 'model1',
-      availabilityZone: 'any',
-    } as TAPIVolume;
+  it('returns mapped volume data when volumeId is provided', async () => {
+    const volumeMock = { id: '1' } as TAPIVolume;
 
     vi.mocked(getVolume).mockResolvedValue(volumeMock);
 
@@ -73,7 +88,12 @@ describe('useVolume', () => {
 
     await waitFor(() => {
       expect(getVolume).toHaveBeenCalledWith('123', '1');
-      expect(result.current.data).toEqual(expect.objectContaining(volumeMock));
+      expect(mapVolumeAttach).toHaveBeenCalled();
+      expect(mapVolumeEncryption).toHaveBeenCalled();
+      expect(mapVolumeStatus).toHaveBeenCalled();
+      expect(mapVolumeRegion).toHaveBeenCalled();
+      expect(mapVolumePricing).toHaveBeenCalled();
+      expect(result.current.isPending).toBe(false);
     });
   });
 
@@ -86,36 +106,10 @@ describe('useVolume', () => {
 });
 
 describe('useVolumes', () => {
-  it('returns volumes data when projectId is provided', async () => {
+  it('returns volumes data mapped, paginated and sorted when projectId is provided', async () => {
     const volumesMock: TAPIVolume[] = [
-      {
-        id: '1',
-        name: 'Volume 1',
-        attachedTo: ['inst1'],
-        creationDate: '',
-        description: '',
-        size: 0,
-        status: 'available',
-        region: 'region1',
-        bootable: false,
-        planCode: '',
-        type: 'model1',
-        availabilityZone: 'any',
-      },
-      {
-        id: '2',
-        name: 'Volume 2',
-        attachedTo: [],
-        creationDate: '',
-        description: '',
-        size: 0,
-        status: 'available',
-        region: 'region2',
-        bootable: false,
-        planCode: '',
-        type: 'model1',
-        availabilityZone: 'any',
-      },
+      { id: '1' },
+      { id: '2' },
     ] as TAPIVolume[];
 
     vi.mocked(getAllVolumes).mockResolvedValue(volumesMock);
@@ -133,48 +127,14 @@ describe('useVolumes', () => {
 
     await waitFor(() => {
       expect(getAllVolumes).toHaveBeenCalledWith('123');
-      expect(result.current.data).toEqual({
-        pageCount: 1,
-        rows: [
-          expect.objectContaining({
-            attachedTo: ['inst1'],
-            bootable: false,
-            creationDate: '',
-            description: '',
-            id: '1',
-            name: 'Volume 1',
-            planCode: '',
-            region: 'region1',
-            regionName: 'region:manager_components_region_region_micro',
-            size: 0,
-            status: 'available',
-            statusGroup: 'ACTIVE',
-            type: 'model1',
-            availabilityZone: 'any',
-            canAttachInstance: false,
-            canDetachInstance: true,
-          }),
-          expect.objectContaining({
-            attachedTo: [],
-            bootable: false,
-            creationDate: '',
-            description: '',
-            id: '2',
-            name: 'Volume 2',
-            planCode: '',
-            region: 'region2',
-            regionName: 'region:manager_components_region_region_micro',
-            size: 0,
-            status: 'available',
-            statusGroup: 'ACTIVE',
-            type: 'model1',
-            availabilityZone: 'any',
-            canAttachInstance: true,
-            canDetachInstance: false,
-          }),
-        ],
-        totalRows: 2,
-      });
+      expect(mapVolumeStatus).toHaveBeenCalled();
+      expect(mapVolumeRegion).toHaveBeenCalled();
+      expect(mapVolumeAttach).toHaveBeenCalled();
+      expect(mapVolumeEncryption).toHaveBeenCalled();
+      expect(mapVolumeType).toHaveBeenCalled();
+      expect(paginateResults).toHaveBeenCalled();
+      expect(sortResults).toHaveBeenCalled();
+      expect(result.current.isPending).toBe(false);
     });
   });
 
@@ -193,6 +153,39 @@ describe('useVolumes', () => {
   });
 });
 
+describe('useAllVolumes', () => {
+  it('returns volumes data when projectId is provided', async () => {
+    const volumesMock: TAPIVolume[] = [
+      { id: '1' },
+      { id: '2' },
+    ] as TAPIVolume[];
+
+    vi.mocked(getAllVolumes).mockResolvedValue(volumesMock);
+
+    const { result } = renderHook(() => useAllVolumes('123'), {
+      wrapper,
+    });
+
+    await waitFor(() => {
+      expect(getAllVolumes).toHaveBeenCalledWith('123');
+      expect(getAllVolumes).toHaveBeenCalledWith('123');
+      expect(mapVolumeStatus).toHaveBeenCalled();
+      expect(mapVolumeRegion).toHaveBeenCalled();
+      expect(mapVolumeAttach).toHaveBeenCalled();
+      expect(mapVolumeEncryption).toHaveBeenCalled();
+      expect(mapVolumeType).toHaveBeenCalled();
+      expect(result.current.isPending).toBe(false);
+    });
+  });
+
+  it('does not fetch data when projectId is not provided', () => {
+    const { result } = renderHook(() => useAllVolumes(null), { wrapper });
+
+    expect(getAllVolumes).not.toHaveBeenCalled();
+    expect(result.current.isPending).toBe(true);
+  });
+});
+
 describe('useDeleteVolume', () => {
   it('deletes volume when volumeId is provided', async () => {
     vi.mocked(deleteVolume).mockResolvedValue(null);

packages/manager/apps/pci-block-storage/src/api/hooks/useVolume.tsx

@@ -35,6 +35,7 @@ import {
   mapVolumeStatus,
   mapVolumeToAdd,
   mapVolumeToEdit,
+  mapVolumeType,
   paginateResults,
   sortResults,
   TVolumeAttach,
@@ -43,12 +44,14 @@ import {
   TVolumeRegion,
   TVolumeStatus,
   TVolumeToAdd,
+  TVolumeType,
 } from '@/api/select/volume';
 
 export type TVolume = TAPIVolume &
   TVolumeAttach &
   TVolumeEncryption &
-  TVolumeStatus & {
+  TVolumeStatus &
+  TVolumeType & {
     regionName: string;
   };
 
@@ -79,6 +82,7 @@ export const useAllVolumes = (projectId: string | null) => {
         mapVolumeRegion(t),
         mapVolumeAttach(catalogData),
         mapVolumeEncryption(t, catalogData),
+        mapVolumeType(catalogData),
       ),
     [t, catalogData],
   );
@@ -305,7 +309,7 @@ export const convertUcentsToCurrency = (value: number, interval = 1) =>
 interface UpdateVolumeProps {
   projectId: string;
   volumeToEdit: Pick<TVolume, 'name' | 'size' | 'bootable'>;
-  originalVolume: TVolume;
+  originalVolume: UseVolumeResult;
   onError: (cause: Error) => void;
   onSuccess: () => void;
 }

packages/manager/apps/pci-block-storage/src/api/select/catalog.spec.ts

@@ -3,6 +3,7 @@ import { TFunction } from 'i18next';
 import { TVolumeAddon, TVolumeCatalog } from '@/api/data/catalog';
 import { TRegion } from '@/api/data/regions';
 import {
+  is3az,
   mapRetypingVolumeCatalog,
   mapVolumeCatalog,
 } from '@/api/select/catalog';
@@ -321,3 +322,29 @@ describe('mapRetypingVolumeCatalog', () => {
     expect(result[1].isPreselected).toBe(false);
   });
 });
+
+describe('is3az', () => {
+  it('should return false if the catalog region mathing the input region have a type different that "region-3-az"', () => {
+    const matchingRegionName = 'matching region';
+    const mockRegions = [
+      { name: matchingRegionName, type: 'region' },
+      { name: 'otherRegion', type: 'region-3-az' },
+    ] as TRegion[];
+
+    const result = is3az(mockRegions, matchingRegionName);
+
+    expect(result).toBe(false);
+  });
+
+  it('should return true if the catalog region mathing the input region have a type equal to "region-3-az"', () => {
+    const matchingRegionName = 'matching region';
+    const mockRegions = [
+      { name: matchingRegionName, type: 'region-3-az' },
+      { name: 'otherRegion', type: 'region' },
+    ] as TRegion[];
+
+    const result = is3az(mockRegions, matchingRegionName);
+
+    expect(result).toBe(true);
+  });
+});