fix: tests and typecheck

Author: astandrik

src/store/reducers/storage/__tests__/calculateMaximumDisksPerNode.test.ts

@@ -7,17 +7,17 @@ describe('calculateMaximumDisksPerNode', () => {
         const nodes: TNodeInfo[] = [];
         const providedMaximumDisksPerNode = '5';
 
-        expect(calculateMaximumDisksPerNode(nodes, providedMaximumDisksPerNode)).toBe('5');
+        expect(calculateMaximumDisksPerNode(nodes, providedMaximumDisksPerNode)).toBe(5);
     });
 
     test('should return "1" for empty nodes array', () => {
         const nodes: TNodeInfo[] = [];
 
-        expect(calculateMaximumDisksPerNode(nodes)).toBe('1');
+        expect(calculateMaximumDisksPerNode(nodes)).toBe(1);
     });
 
     test('should return "1" for undefined nodes', () => {
-        expect(calculateMaximumDisksPerNode(undefined)).toBe('1');
+        expect(calculateMaximumDisksPerNode(undefined)).toBe(1);
     });
 
     test('should return "1" for nodes without PDisks', () => {
@@ -28,7 +28,7 @@ describe('calculateMaximumDisksPerNode', () => {
             },
         ];
 
-        expect(calculateMaximumDisksPerNode(nodes)).toBe('1');
+        expect(calculateMaximumDisksPerNode(nodes)).toBe(1);
     });
 
     test('should calculate maximum disks correctly for single node with multiple PDisks', () => {
@@ -53,7 +53,7 @@ describe('calculateMaximumDisksPerNode', () => {
             },
         ];
 
-        expect(calculateMaximumDisksPerNode(nodes)).toBe('3');
+        expect(calculateMaximumDisksPerNode(nodes)).toBe(3);
     });
 
     test('should calculate maximum disks across multiple nodes', () => {
@@ -106,7 +106,7 @@ describe('calculateMaximumDisksPerNode', () => {
             },
         ];
 
-        expect(calculateMaximumDisksPerNode(nodes)).toBe('4');
+        expect(calculateMaximumDisksPerNode(nodes)).toBe(4);
     });
 
     test('should handle nodes with empty PDisks array', () => {
@@ -132,6 +132,6 @@ describe('calculateMaximumDisksPerNode', () => {
             },
         ];
 
-        expect(calculateMaximumDisksPerNode(nodes)).toBe('2');
+        expect(calculateMaximumDisksPerNode(nodes)).toBe(2);
     });
 });

src/store/reducers/storage/__tests__/calculateMaximumSlotsPerDisk.test.ts

@@ -17,17 +17,17 @@ describe('calculateMaximumSlotsPerDisk', () => {
         const nodes: TNodeInfo[] = [];
         const providedMaximumSlotsPerDisk = '5';
 
-        expect(calculateMaximumSlotsPerDisk(nodes, providedMaximumSlotsPerDisk)).toBe('5');
+        expect(calculateMaximumSlotsPerDisk(nodes, providedMaximumSlotsPerDisk)).toBe(5);
     });
 
     test('should return "1" for empty nodes array', () => {
         const nodes: TNodeInfo[] = [];
 
-        expect(calculateMaximumSlotsPerDisk(nodes)).toBe('1');
+        expect(calculateMaximumSlotsPerDisk(nodes)).toBe(1);
     });
 
     test('should return "1" for undefined nodes', () => {
-        expect(calculateMaximumSlotsPerDisk(undefined)).toBe('1');
+        expect(calculateMaximumSlotsPerDisk(undefined)).toBe(1);
     });
 
     test('should return "1" for nodes without PDisks or VDisks', () => {
@@ -38,7 +38,7 @@ describe('calculateMaximumSlotsPerDisk', () => {
             },
         ];
 
-        expect(calculateMaximumSlotsPerDisk(nodes)).toBe('1');
+        expect(calculateMaximumSlotsPerDisk(nodes)).toBe(1);
     });
 
     test('should calculate maximum slots correctly for single node with one PDisk and multiple VDisks', () => {
@@ -67,7 +67,7 @@ describe('calculateMaximumSlotsPerDisk', () => {
             },
         ];
 
-        expect(calculateMaximumSlotsPerDisk(nodes)).toBe('2');
+        expect(calculateMaximumSlotsPerDisk(nodes)).toBe(2);
     });
 
     test('should calculate maximum slots across multiple nodes', () => {
@@ -118,7 +118,7 @@ describe('calculateMaximumSlotsPerDisk', () => {
             },
         ];
 
-        expect(calculateMaximumSlotsPerDisk(nodes)).toBe('3');
+        expect(calculateMaximumSlotsPerDisk(nodes)).toBe(3);
     });
 
     test('should handle nodes with multiple PDisks', () => {
@@ -156,7 +156,7 @@ describe('calculateMaximumSlotsPerDisk', () => {
             },
         ];
 
-        expect(calculateMaximumSlotsPerDisk(nodes)).toBe('2');
+        expect(calculateMaximumSlotsPerDisk(nodes)).toBe(2);
     });
 
     test('should ignore VDisks with non-matching PDiskId', () => {
@@ -185,6 +185,6 @@ describe('calculateMaximumSlotsPerDisk', () => {
             },
         ];
 
-        expect(calculateMaximumSlotsPerDisk(nodes)).toBe('1');
+        expect(calculateMaximumSlotsPerDisk(nodes)).toBe(1);
     });
 });

src/store/reducers/storage/utils.ts

@@ -235,7 +235,7 @@ export const calculateMaximumSlotsPerDisk = (
     nodes: TNodeInfo[] | undefined,
     providedMaximumSlotsPerDisk?: string,
 ): number => {
-    if (providedMaximumSlotsPerDisk) {
+    if (providedMaximumSlotsPerDisk && !isNaN(Number(providedMaximumSlotsPerDisk))) {
         return Number(providedMaximumSlotsPerDisk);
     }
 
@@ -261,7 +261,7 @@ export const calculateMaximumDisksPerNode = (
     nodes: TNodeInfo[] | undefined,
     providedMaximumDisksPerNode?: string,
 ): number => {
-    if (providedMaximumDisksPerNode) {
+    if (providedMaximumDisksPerNode && !isNaN(Number(providedMaximumDisksPerNode))) {
         return Number(providedMaximumDisksPerNode);
     }
 
@@ -287,21 +287,18 @@ export const prepareStorageNodesResponse = (data: TNodesInfo): PreparedStorageRe
         return undefined;
     }).filter((group): group is TableGroup => Boolean(group));
 
-    const maximumSlots = calculateMaximumSlotsPerDisk(Nodes, MaximumSlotsPerDisk);
-    const maximumDisks = calculateMaximumDisksPerNode(Nodes, MaximumDisksPerNode);
+    const maxSlotsPerDisk = calculateMaximumSlotsPerDisk(Nodes, MaximumSlotsPerDisk);
+    const maxDisksPerNode = calculateMaximumDisksPerNode(Nodes, MaximumDisksPerNode);
     const preparedNodes = Nodes?.map((node) =>
-        prepareStorageNodeData(node, maximumSlots, maximumDisks),
+        prepareStorageNodeData(node, maxSlotsPerDisk, maxDisksPerNode),
     );
 
     return {
         nodes: preparedNodes,
         total: Number(TotalNodes) || preparedNodes?.length,
         found: Number(FoundNodes),
         tableGroups,
-        columnSettings: {
-            maxSlotsPerDisk: Number(maximumSlots),
-            maxDisksPerNode: Number(maximumDisks),
-        },
+        columnSettings: {maxSlotsPerDisk, maxDisksPerNode},
     };
 };