tests

Author: andrewazores

src/openshift/test/actions/DeploymentLabelAction/DeploymentLabelActionModal.test.tsx

@@ -220,4 +220,140 @@ describe('DeploymentLabelActionModal', () => {
       expect(screen.getByText('DEPLOYMENT_ACTION_QUICK_REGISTER')).toBeInTheDocument();
     });
   });
+
+  it('should include callback port label when set in wizard', async () => {
+    renderModal(mockDeploymentWithoutLabels);
+
+    const select = screen.getByLabelText('Cryostat Instance Selection');
+    await userEvent.selectOptions(select, '0');
+    await waitFor(() => {
+      expect(select).toHaveValue('0');
+    });
+
+    // Navigate through wizard steps to Agent Configuration
+    let nextButton = screen.queryByRole('button', { name: /next/i });
+    while (nextButton) {
+      await userEvent.click(nextButton);
+      // Wait a bit for the step to change
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      // Check if we're on the Agent Configuration step by looking for the callback port field
+      const callbackPortInput = screen.queryByRole('spinbutton', { name: '' });
+      if (callbackPortInput) {
+        // Found the callback port field, set its value
+        await userEvent.clear(callbackPortInput);
+        await userEvent.type(callbackPortInput, '8080');
+        break;
+      }
+
+      nextButton = screen.queryByRole('button', { name: /next/i });
+    }
+
+    // Continue to finish
+    nextButton = screen.queryByRole('button', { name: /next/i });
+    while (nextButton) {
+      await userEvent.click(nextButton);
+      nextButton = screen.queryByRole('button', { name: /next/i });
+    }
+
+    const finishButton = screen.queryByRole('button', { name: /finish|submit/i });
+    if (finishButton) {
+      await userEvent.click(finishButton);
+      expect(k8sPatchResource).toHaveBeenCalled();
+
+      const callArgs = (k8sPatchResource as jest.Mock).mock.calls[0][0];
+      const patches = callArgs.patches;
+
+      // Verify callback port patch is included
+      expect(patches).toEqual(
+        expect.arrayContaining([
+          {
+            op: 'replace',
+            path: '/spec/template/metadata/labels/cryostat.io~1callback-port',
+            value: '8080',
+          },
+        ]),
+      );
+    }
+  });
+
+  it('should NOT include callback port label in Quick Register', async () => {
+    renderModal(mockDeploymentWithoutLabels);
+
+    const select = screen.getByLabelText('Cryostat Instance Selection');
+    await userEvent.selectOptions(select, '0');
+    await waitFor(() => {
+      expect(select).toHaveValue('0');
+    });
+
+    // Click Quick Register button
+    const quickRegisterButton = screen.getByText('DEPLOYMENT_ACTION_QUICK_REGISTER');
+    await userEvent.click(quickRegisterButton);
+
+    await waitFor(() => {
+      expect(k8sPatchResource).toHaveBeenCalled();
+    });
+
+    const callArgs = (k8sPatchResource as jest.Mock).mock.calls[0][0];
+    const patches = callArgs.patches;
+
+    // Verify callback port patch is NOT included
+    const hasCallbackPortPatch = patches.some((p) => p.path?.includes('callback-port'));
+    expect(hasCallbackPortPatch).toBe(false);
+  });
+
+  it('should remove callback port label when deployment has it and user selects empty option', async () => {
+    const deploymentWithCallbackPort = {
+      ...mockDeploymentWithLabels,
+      spec: {
+        ...mockDeploymentWithLabels.spec,
+        template: {
+          ...mockDeploymentWithLabels.spec?.template,
+          metadata: {
+            ...mockDeploymentWithLabels.spec?.template?.metadata,
+            labels: {
+              ...mockDeploymentWithLabels.spec?.template?.metadata?.labels,
+              'cryostat.io/callback-port': '8080',
+            },
+          },
+        },
+      },
+    };
+
+    renderModal(deploymentWithCallbackPort);
+
+    const selectElement = screen.getByLabelText('Cryostat Instance Selection');
+    expect(selectElement).toHaveValue('0');
+
+    await userEvent.selectOptions(selectElement, '-1');
+    await waitFor(() => {
+      expect(selectElement).toHaveValue('-1');
+    });
+
+    const nextButtons = screen.queryAllByRole('button', { name: /next/i });
+    if (nextButtons.length > 0) {
+      for (const button of nextButtons) {
+        await userEvent.click(button);
+      }
+    }
+
+    const finishButton = screen.queryByRole('button', { name: /finish|submit/i });
+    if (finishButton) {
+      await userEvent.click(finishButton);
+      expect(k8sPatchResource).toHaveBeenCalled();
+
+      const callArgs = (k8sPatchResource as jest.Mock).mock.calls[0][0];
+      const patches = callArgs.patches;
+
+      // Verify callback port removal patch is included
+      expect(patches).toEqual(
+        expect.arrayContaining([
+          {
+            op: 'remove',
+            path: '/spec/template/metadata/labels/cryostat.io~1callback-port',
+          },
+        ]),
+      );
+    }
+  });
 });

src/openshift/test/actions/DeploymentLabelAction/utils.test.ts

@@ -19,6 +19,9 @@ import {
   LOG_LEVELS,
   getAgentConfig,
   formatAgentConfig,
+  formatDurationForLabel,
+  formatByteSizeForLabel,
+  parseDuration,
 } from '@console-plugin/actions/DeploymentLabelAction/utils';
 
 describe('envVarUtils', () => {
@@ -239,4 +242,149 @@ describe('envVarUtils', () => {
       expect(result).toBe('None');
     });
   });
+
+  describe('parseDuration', () => {
+    it('should parse duration with hours unit', () => {
+      expect(parseDuration('2h', 0)).toBe(2 * 60 * 60 * 1000);
+    });
+
+    it('should parse duration with minutes unit', () => {
+      expect(parseDuration('15m', 0)).toBe(15 * 60 * 1000);
+    });
+
+    it('should parse duration with seconds unit', () => {
+      expect(parseDuration('30s', 0)).toBe(30 * 1000);
+    });
+
+    it('should parse duration with milliseconds unit', () => {
+      expect(parseDuration('500ms', 0)).toBe(500);
+    });
+
+    it('should parse duration without unit as milliseconds', () => {
+      expect(parseDuration('1000', 0)).toBe(1000);
+    });
+
+    it('should return default value for undefined duration', () => {
+      expect(parseDuration(undefined, 12345)).toBe(12345);
+    });
+
+    it('should return default value for invalid duration format', () => {
+      expect(parseDuration('invalid', 12345)).toBe(12345);
+    });
+
+    it('should return default value for empty string', () => {
+      expect(parseDuration('', 12345)).toBe(12345);
+    });
+  });
+
+  describe('formatDurationForLabel', () => {
+    it('should format duration in hours when value divides evenly', () => {
+      expect(formatDurationForLabel(3600000)).toBe('1h');
+      expect(formatDurationForLabel(7200000)).toBe('2h');
+      expect(formatDurationForLabel(10800000)).toBe('3h');
+    });
+
+    it('should format duration in minutes when value divides evenly', () => {
+      expect(formatDurationForLabel(60000)).toBe('1m');
+      expect(formatDurationForLabel(900000)).toBe('15m');
+      expect(formatDurationForLabel(1800000)).toBe('30m');
+    });
+
+    it('should format duration in seconds when value divides evenly', () => {
+      expect(formatDurationForLabel(1000)).toBe('1s');
+      expect(formatDurationForLabel(5000)).toBe('5s');
+      expect(formatDurationForLabel(30000)).toBe('30s');
+    });
+
+    it('should format duration in milliseconds when value does not divide evenly', () => {
+      expect(formatDurationForLabel(1500)).toBe('1500ms');
+      expect(formatDurationForLabel(999)).toBe('999ms');
+      expect(formatDurationForLabel(12345)).toBe('12345ms');
+    });
+
+    it('should prefer larger units over smaller units', () => {
+      // 1 hour should be formatted as 1h, not 60m
+      expect(formatDurationForLabel(3600000)).toBe('1h');
+      // 1 minute should be formatted as 1m, not 60s
+      expect(formatDurationForLabel(60000)).toBe('1m');
+    });
+
+    it('should handle zero duration', () => {
+      expect(formatDurationForLabel(0)).toBe('0ms');
+    });
+
+    it('should handle very large durations', () => {
+      expect(formatDurationForLabel(86400000)).toBe('24h'); // 24 hours
+    });
+
+    it('should format default harvester period correctly', () => {
+      expect(formatDurationForLabel(900000)).toBe('15m');
+    });
+
+    it('should format default harvester exit max age correctly', () => {
+      expect(formatDurationForLabel(300000)).toBe('5m');
+    });
+  });
+
+  describe('formatByteSizeForLabel', () => {
+    it('should format size in Gi when value divides evenly', () => {
+      expect(formatByteSizeForLabel(1073741824)).toBe('1Gi');
+      expect(formatByteSizeForLabel(2147483648)).toBe('2Gi');
+      expect(formatByteSizeForLabel(5368709120)).toBe('5Gi');
+    });
+
+    it('should format size in Mi when value divides evenly', () => {
+      expect(formatByteSizeForLabel(1048576)).toBe('1Mi');
+      expect(formatByteSizeForLabel(20971520)).toBe('20Mi');
+      expect(formatByteSizeForLabel(52428800)).toBe('50Mi');
+    });
+
+    it('should format size in Ki when value divides evenly', () => {
+      expect(formatByteSizeForLabel(1024)).toBe('1Ki');
+      expect(formatByteSizeForLabel(2048)).toBe('2Ki');
+      expect(formatByteSizeForLabel(10240)).toBe('10Ki');
+    });
+
+    it('should format size in bytes when value does not divide evenly', () => {
+      expect(formatByteSizeForLabel(500)).toBe('500');
+      expect(formatByteSizeForLabel(1023)).toBe('1023');
+      expect(formatByteSizeForLabel(1025)).toBe('1025');
+    });
+
+    it('should prefer larger units over smaller units', () => {
+      // 1 GiB should be formatted as 1Gi, not 1024Mi
+      expect(formatByteSizeForLabel(1073741824)).toBe('1Gi');
+      // 1 MiB should be formatted as 1Mi, not 1024Ki
+      expect(formatByteSizeForLabel(1048576)).toBe('1Mi');
+    });
+
+    it('should handle zero size', () => {
+      expect(formatByteSizeForLabel(0)).toBe('0');
+    });
+
+    it('should handle very large sizes', () => {
+      expect(formatByteSizeForLabel(10737418240)).toBe('10Gi'); // 10 GiB
+    });
+
+    it('should format default harvester exit max size correctly', () => {
+      expect(formatByteSizeForLabel(20971520)).toBe('20Mi');
+    });
+
+    it('should use Kubernetes resource format (no B suffix)', () => {
+      // Verify the format matches k8s resource quantities
+      expect(formatByteSizeForLabel(1073741824)).not.toContain('B');
+      expect(formatByteSizeForLabel(1048576)).not.toContain('B');
+      expect(formatByteSizeForLabel(1024)).not.toContain('B');
+    });
+
+    it('should handle fractional MiB that do not divide evenly', () => {
+      // 1.5 MiB in bytes (1572864) should not format as Mi
+      expect(formatByteSizeForLabel(1572864)).toBe('1536Ki');
+    });
+
+    it('should handle fractional GiB that do not divide evenly', () => {
+      // 1.5 GiB in bytes (1610612736) should not format as Gi
+      expect(formatByteSizeForLabel(1610612736)).toBe('1536Mi');
+    });
+  });
 });