fix(pci-kubernetes): calculate multiple node price

ref: #TAPC-3341

Signed-off-by: Pierre-Philippe <[email protected]>

Author: ppprevost

packages/manager/apps/pci-kubernetes/src/api/data/flavors.ts

@@ -71,6 +71,16 @@ export const getFlavors = async (
   return data;
 };
 
+export const getFlavorDetails = async (
+  projectId: string,
+  region: string,
+): Promise<TFlavor[]> => {
+  const { data } = await v6.get<TFlavor[]>(
+    `/cloud/project/${projectId}/flavor?region=${region}`,
+  );
+  return data;
+};
+
 export type TKubeFlavor = {
   category: string;
   gpus: number;

packages/manager/apps/pci-kubernetes/src/api/data/kubernetes.ts

@@ -19,22 +19,22 @@ export const getAllKube = async (projectId: string): Promise<TKube[]> => {
   return data;
 };
 
-export interface NodePool {
+export type NodePool = {
   name: string;
   antiAffinity: boolean;
   autoscale: boolean;
-  availabilityZones: string[];
+  availabilityZones?: string[];
   desiredNodes: number;
   minNodes: number;
-  localisation: string; // will change with 3AZ
+  localisation: string;
   flavorName: string;
   maxNodes: number;
   monthlyBilled: boolean;
-}
+};
 
 export type NodePoolPrice = NodePool & { monthlyPrice: number };
 
-export interface KubeClusterCreationParams {
+export type KubeClusterCreationParams = {
   name: string;
   region: string;
   version: string;
@@ -48,7 +48,7 @@ export interface KubeClusterCreationParams {
     defaultVrackGateway?: string;
     privateNetworkRoutingAsDefault?: boolean;
   };
-}
+};
 
 export const createKubernetesCluster = async (
   projectId: string,

packages/manager/apps/pci-kubernetes/src/components/flavor-selector/FlavorSelector.component.tsx

@@ -14,14 +14,14 @@ import {
 } from '@/hooks/useFlavors';
 import { FlavorTile } from './FlavorTile.component';
 
-export type KubeFlavor = ReturnType<
+export type TComputedKubeFlavor = ReturnType<
   typeof useMergedKubeFlavors
 >['mergedFlavors'][0];
 
 interface FlavorSelectorProps {
   projectId: string;
   region: string;
-  onSelect?: (flavor: KubeFlavor) => void;
+  onSelect?: (flavor: TComputedKubeFlavor) => void;
 }
 
 export function FlavorSelector({

packages/manager/apps/pci-kubernetes/src/helpers/index.spec.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { z } from 'zod';
+
 import {
   compareFunction,
   formatIP,
@@ -13,7 +14,7 @@ import {
   parseCommaSeparated,
   generateUniqueName,
 } from '@/helpers/index';
-import { NodePool } from '@/api/data/kubernetes';
+import { NodePoolPrice } from '@/api/data/kubernetes';
 
 describe('helper', () => {
   it('compares two objects based on a key', () => {
@@ -200,7 +201,7 @@ describe('generateUniqueName', () => {
     (baseName, existingNodePools, expectedResult) => {
       const result = generateUniqueName(
         baseName,
-        existingNodePools as NodePool[],
+        existingNodePools as NodePoolPrice[],
       );
       expect(result).toBe(expectedResult);
     },

packages/manager/apps/pci-kubernetes/src/helpers/index.ts

@@ -4,7 +4,7 @@ import { ZodObject, ZodRawShape } from 'zod';
 import { ClassValue, clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
 import { DeploymentMode, SigningAlgorithms, TOidcProvider } from '@/types';
-import { NodePool } from '@/api/data/kubernetes';
+import { NodePool, NodePoolPrice } from '@/api/data/kubernetes';
 
 export const REFETCH_INTERVAL_DURATION = 15_000;
 export const QUOTA_ERROR_URL =
@@ -164,7 +164,7 @@ export const transformKey = (key: string): string =>
   key.replace(/([A-Z])/g, '_$1').toLowerCase();
 
 const isNotEmptyString = (str: string): boolean => str.trim() !== '';
-const isNotEmptyArray = (arr: any[]): boolean => arr.length > 0;
+const isNotEmptyArray = (arr: unknown[]): boolean => arr.length > 0;
 
 export const isOptionalValue = (
   value: string | string[] | SigningAlgorithms[] | null | undefined,
@@ -175,7 +175,7 @@ export const isOptionalValue = (
   return true;
 };
 export const getValidOptionalKeys = (oidcProvider: TOidcProvider) =>
-  Object.entries(oidcProvider ?? {}).reduce((acc, [key, value]) => {
+  Object.entries(oidcProvider ?? {}).reduce<string[]>((acc, [key, value]) => {
     if (isOptionalValue(value) && key !== 'issuerUrl' && key !== 'clientId') {
       acc.push(key);
     }
@@ -191,7 +191,7 @@ export const getValidOptionalKeys = (oidcProvider: TOidcProvider) =>
  */
 export function generateUniqueName(
   baseName: string,
-  existingNodePools: NodePool[],
+  existingNodePools: NodePoolPrice[],
 ) {
   let newName = baseName;
   let copyNumber = 1;

packages/manager/apps/pci-kubernetes/src/hooks/useFlavorDetails.spec.ts

@@ -0,0 +1,113 @@
+import { renderHook } from '@testing-library/react';
+import { describe, it, vi, beforeEach, afterEach, expect, test } from 'vitest';
+
+import useFlavorDetails, { getPrice } from './useMergedFlavorById';
+
+import { TComputedKubeFlavor } from '@/components/flavor-selector/FlavorSelector.component';
+import { useMergedKubeFlavors } from './useFlavors';
+import { wrapper } from '@/wrapperRenders';
+
+vi.mock('./useFlavors', () => ({
+  ...vi.importActual('./useFlavors'),
+  useMergedKubeFlavors: vi.fn(),
+}));
+
+describe('getPrice', () => {
+  test.each([
+    [undefined, undefined, 0, undefined],
+    [0, 100, 2, undefined],
+    [1, undefined, 2, { hour: 2, month: undefined }],
+    [1, 10, 2, { hour: 2, month: 20 }],
+    [5, 50, 3, { hour: 15, month: 150 }],
+  ])(
+    'getPrice(%p, %p, %p) should return %p',
+    (hour, month, desiredScaling, expected) => {
+      expect(getPrice(hour, month, desiredScaling)).toEqual(expected);
+    },
+  );
+});
+
+describe('useFlavorDetails', () => {
+  const mockFlavors = [
+    {
+      id: 'flavor-1',
+      name: 'Flavor 1',
+      vcpus: 2,
+      ram: 4096,
+      pricingsHourly: { price: 0.05 },
+      pricingsMonthly: { price: 30 },
+    },
+    {
+      id: 'flavor-2',
+      name: 'Flavor 2',
+      vcpus: 4,
+      ram: 8192,
+      pricingsHourly: { price: 0.1 },
+      pricingsMonthly: { price: 60 },
+    },
+  ] as TComputedKubeFlavor[];
+
+  beforeEach(() => {
+    vi.mocked(useMergedKubeFlavors).mockReturnValue({
+      mergedFlavors: mockFlavors,
+      isPending: false,
+    } as { mergedFlavors: TComputedKubeFlavor[]; isPending: boolean });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return flavor details with computed price', async () => {
+    const { result } = renderHook(
+      () =>
+        useFlavorDetails('project-1', 'GRA', 'flavor-1', { desiredScaling: 3 }),
+      { wrapper },
+    );
+
+    expect(result.current).toEqual({
+      id: 'flavor-1',
+      name: 'Flavor 1',
+      vcpus: 2,
+      ram: 4096,
+      pricingsHourly: { price: 0.05 },
+      pricingsMonthly: { price: 30 },
+      price: {
+        hour: 0.05 * 3,
+        month: 30 * 3,
+      },
+    });
+  });
+
+  it('should return undefined price if desiredScaling is 0', () => {
+    const { result } = renderHook(
+      () =>
+        useFlavorDetails('project-1', 'GRA', 'flavor-2', { desiredScaling: 0 }),
+      { wrapper },
+    );
+
+    expect(result.current).toEqual({
+      id: 'flavor-2',
+      name: 'Flavor 2',
+      vcpus: 4,
+      ram: 8192,
+      pricingsHourly: { price: 0.1 },
+      pricingsMonthly: { price: 60 },
+      price: undefined,
+    });
+  });
+
+  it('should return undefined flavor if not found', () => {
+    const { result } = renderHook(
+      () =>
+        useFlavorDetails('project-1', 'GRA', 'unknown-flavor', {
+          desiredScaling: 2,
+        }),
+      { wrapper },
+    );
+
+    expect(result.current).toEqual({
+      price: undefined,
+    });
+  });
+});

packages/manager/apps/pci-kubernetes/src/hooks/useMergedFlavorById.ts

@@ -0,0 +1,34 @@
+import { useMemo } from 'react';
+import { useMergedKubeFlavors } from './useFlavors';
+import { TComputedKubeFlavor } from '@/components/flavor-selector/FlavorSelector.component';
+
+export const getPriceByDesiredScale = (
+  hour?: number,
+  month?: number,
+  desiredScaling = 0,
+) => {
+  if (!hour || !desiredScaling) return undefined;
+  return {
+    hour: hour * desiredScaling,
+    month: month ? month * desiredScaling : undefined,
+  };
+};
+
+const useMergedFlavorById = <T = TComputedKubeFlavor>(
+  projectId: string,
+  region: string,
+  flavorId: string,
+  opts?: { select?: (flavor: TComputedKubeFlavor) => T },
+): T | null => {
+  const { mergedFlavors } = useMergedKubeFlavors(projectId, region);
+
+  const flavor = useMemo(() => mergedFlavors?.find((f) => f.id === flavorId), [
+    mergedFlavors,
+    flavorId,
+  ]);
+  if (!flavor) return null;
+
+  return opts?.select ? opts?.select(flavor) : (flavor as T);
+};
+
+export default useMergedFlavorById;