@rancher/shell 3.0.12-rc.2 → 3.0.12-rc.3

package/utils/__tests__/duration.test.ts

@@ -0,0 +1,140 @@
+import { toMilliseconds, toSeconds } from '@shell/utils/duration';
+
+describe('toMilliseconds', () => {
+  describe('falsy input', () => {
+    it.each([
+      { desc: 'null', input: null },
+      { desc: 'undefined', input: undefined },
+      { desc: 'empty string', input: '' },
+      { desc: 'zero', input: 0 },
+    ])('returns 0 for $desc', ({ input }) => {
+      expect(toMilliseconds(input as any)).toStrictEqual(0);
+    });
+  });
+
+  describe('non-matching input', () => {
+    it.each([
+      { desc: 'a plain word', input: 'invalid' },
+      { desc: 'a number with no unit', input: '42' },
+    ])('returns 0 for $desc', ({ input }) => {
+      expect(toMilliseconds(input)).toStrictEqual(0);
+    });
+  });
+
+  describe('single-unit inputs', () => {
+    it.each([
+      {
+        desc:     '1ms → 1',
+        input:    '1ms',
+        expected: 1,
+      },
+      {
+        desc:     '1s → 1000',
+        input:    '1s',
+        expected: 1_000,
+      },
+      {
+        desc:     '1m → 60000',
+        input:    '1m',
+        expected: 60_000,
+      },
+      {
+        desc:     '1h → 3600000',
+        input:    '1h',
+        expected: 3_600_000,
+      },
+      {
+        desc:     '1d → 86400000',
+        input:    '1d',
+        expected: 86_400_000,
+      },
+      {
+        desc:     '1w → 604800000',
+        input:    '1w',
+        expected: 604_800_000,
+      },
+      {
+        desc:     '1y → 31536000000',
+        input:    '1y',
+        expected: 31_536_000_000,
+      },
+    ])('$desc', ({ input, expected }) => {
+      expect(toMilliseconds(input)).toStrictEqual(expected);
+    });
+  });
+
+  describe('multiple-unit inputs', () => {
+    it.each([
+      {
+        desc:     'combines years and days (1y2d)',
+        input:    '1y2d',
+        expected: 31_536_000_000 + 2 * 86_400_000,
+      },
+      {
+        desc:     'combines hours, minutes and seconds (1h30m15s)',
+        input:    '1h30m15s',
+        expected: 3_600_000 + 30 * 60_000 + 15_000,
+      },
+      {
+        desc:     'combines all units (1y1w1d1h1m1s1ms)',
+        input:    '1y1w1d1h1m1s1ms',
+        expected: 31_536_000_000 + 604_800_000 + 86_400_000 + 3_600_000 + 60_000 + 1_000 + 1,
+      },
+    ])('$desc', ({ input, expected }) => {
+      expect(toMilliseconds(input)).toStrictEqual(expected);
+    });
+  });
+
+  describe('multi-digit numbers', () => {
+    it.each([
+      {
+        desc:     'handles 52 weeks',
+        input:    '52w',
+        expected: 52 * 604_800_000,
+      },
+      {
+        desc:     'handles 500 milliseconds',
+        input:    '500ms',
+        expected: 500,
+      },
+    ])('$desc', ({ input, expected }) => {
+      expect(toMilliseconds(input)).toStrictEqual(expected);
+    });
+  });
+
+  it('returns 0 for numeric string "0"', () => {
+    expect(toMilliseconds('0')).toStrictEqual(0);
+  });
+});
+
+describe('toSeconds', () => {
+  it.each([
+    {
+      desc:     'returns 0 for empty string',
+      input:    '',
+      expected: 0,
+    },
+    {
+      desc:     'converts 30s to 30',
+      input:    '30s',
+      expected: 30,
+    },
+    {
+      desc:     'floors sub-second inputs (500ms → 0)',
+      input:    '500ms',
+      expected: 0,
+    },
+    {
+      desc:     'floors mixed sub-second remainder (1m30s500ms → 90)',
+      input:    '1m30s500ms',
+      expected: 90,
+    },
+    {
+      desc:     'converts 2h to 7200',
+      input:    '2h',
+      expected: 7_200,
+    },
+  ])('$desc', ({ input, expected }) => {
+    expect(toSeconds(input)).toStrictEqual(expected);
+  });
+});

package/utils/__tests__/fleet.test.ts

@@ -1,5 +1,8 @@
+import { BundleDeployment, BundleDeploymentStatus } from '@shell/types/resources/fleet';
 import { Target } from '@shell/types/fleet';
 import FleetUtils from '@shell/utils/fleet';
+import { FLEET as FLEET_LABELS } from '@shell/config/labels-annotations';
+import { STATES_ENUM } from '@shell/plugins/dashboard-store/resource-class';
 
 describe('fx: util.getTargetMode', () => {
   const util = FleetUtils.Application;
@@ -153,3 +156,340 @@ describe('fx: util.getTargetMode', () => {
     expect(util.getTargetMode(targets, namespace)).toBe('all');
   });
 });
+
+describe('fleet: quacksLikeAHash', () => {
+  it.each([
+    {
+      desc: '40-char lowercase hex string', input: 'a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2', expected: true
+    },
+    {
+      desc: '40-char uppercase hex string', input: 'A1B2C3D4E5F6A1B2C3D4E5F6A1B2C3D4E5F6A1B2', expected: true
+    },
+    {
+      desc: '64-char sha256 hex string', input: 'a'.repeat(64), expected: true
+    },
+    {
+      desc: '39-char hex string (too short)', input: 'a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1', expected: false
+    },
+    {
+      desc: 'non-hex characters', input: 'z1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2', expected: false
+    },
+    {
+      desc: 'empty string', input: '', expected: false
+    },
+    {
+      desc: 'semantic version string', input: 'v1.2.3', expected: false
+    },
+    {
+      desc: 'branch name', input: 'main', expected: false
+    },
+  ])('$desc', ({ input, expected }) => {
+    expect(FleetUtils.quacksLikeAHash(input as string)).toBe(expected);
+  });
+});
+
+describe('fleet: parseSSHUrl', () => {
+  it('parses a standard git ssh url', () => {
+    const result = FleetUtils.parseSSHUrl('git@github.com:rancher/dashboard.git');
+
+    expect(result).toStrictEqual({ sshUserAndHost: 'git@github.com', repoPath: 'rancher/dashboard' });
+  });
+
+  it('handles url with no colon', () => {
+    const result = FleetUtils.parseSSHUrl('git@github.com');
+
+    expect(result).toStrictEqual({ sshUserAndHost: 'git@github.com', repoPath: undefined });
+  });
+
+  it('handles empty string', () => {
+    const result = FleetUtils.parseSSHUrl('');
+
+    expect(result).toStrictEqual({ sshUserAndHost: '', repoPath: undefined });
+  });
+});
+
+describe('fleet: resourceId', () => {
+  it.each([
+    {
+      desc:     'namespace/name when namespace is present',
+      resource: {
+        kind: 'Pod', apiVersion: 'v1', namespace: 'default', name: 'my-pod'
+      },
+      expected: 'default/my-pod'
+    },
+    {
+      desc:     'only name when namespace is absent',
+      resource: {
+        kind: 'ClusterRole', apiVersion: 'rbac.authorization.k8s.io/v1', name: 'my-role'
+      },
+      expected: 'my-role'
+    },
+    {
+      desc:     'only name when namespace is empty string',
+      resource: {
+        kind: 'Pod', apiVersion: 'v1', namespace: '', name: 'my-pod'
+      },
+      expected: 'my-pod'
+    },
+  ])('returns $desc', ({ resource, expected }) => {
+    expect(FleetUtils.resourceId(resource)).toBe(expected);
+  });
+});
+
+describe('fleet: resourceType', () => {
+  it.each([
+    {
+      desc:     'lowercase kind when apiVersion is v1',
+      resource: {
+        kind: 'Pod', apiVersion: 'v1', name: 'p', state: 'ready'
+      },
+      expected: 'pod'
+    },
+    {
+      desc:     'lowercase kind when apiVersion is absent',
+      resource: {
+        kind: 'Pod', apiVersion: '', name: 'p', state: 'ready'
+      },
+      expected: 'pod'
+    },
+    {
+      desc:     'group prefix for non-core resources',
+      resource: {
+        kind: 'Deployment', apiVersion: 'apps/v1', name: 'd', state: 'ready'
+      },
+      expected: 'apps.deployment'
+    },
+    {
+      desc:     'first segment of apiVersion as group',
+      resource: {
+        kind: 'Certificate', apiVersion: 'cert-manager.io/v1', name: 'c', state: 'ready'
+      },
+      expected: 'cert-manager.io.certificate'
+    },
+  ])('returns $desc', ({ resource, expected }) => {
+    expect(FleetUtils.resourceType(resource)).toBe(expected);
+  });
+});
+
+describe('fleet: bundleDeploymentState', () => {
+  const makeDeployment = (overrides: Partial<BundleDeployment> = {}): BundleDeployment => ({
+    spec:   { deploymentId: 'dep-1', stagedDeploymentId: 'dep-1' },
+    status: {
+      appliedDeploymentId: 'dep-1',
+      ready:               true,
+      nonModified:         true,
+      conditions:          [],
+    },
+    ...overrides,
+  });
+
+  it('returns ready when all conditions are nominal', () => {
+    expect(FleetUtils.bundleDeploymentState(makeDeployment())).toBe(STATES_ENUM.READY);
+  });
+
+  it('returns errapplied when appliedDeploymentId differs and Deployed condition is false', () => {
+    const bd = makeDeployment({
+      status: {
+        appliedDeploymentId: 'dep-0', ready: true, nonModified: true, conditions: []
+      }
+    });
+
+    expect(FleetUtils.bundleDeploymentState(bd)).toBe(STATES_ENUM.ERR_APPLIED);
+  });
+
+  it('returns waitapplied when appliedDeploymentId differs and Deployed condition is true', () => {
+    const bd = makeDeployment({
+      status: {
+        appliedDeploymentId: 'dep-0',
+        ready:               true,
+        nonModified:         true,
+        conditions:          [{ type: 'Deployed', status: 'True' }],
+      },
+    });
+
+    expect(FleetUtils.bundleDeploymentState(bd)).toBe(STATES_ENUM.WAIT_APPLIED);
+  });
+
+  it('returns notready when applied matches but not ready', () => {
+    const bd = makeDeployment({
+      status: {
+        appliedDeploymentId: 'dep-1', ready: false, nonModified: true, conditions: []
+      }
+    });
+
+    expect(FleetUtils.bundleDeploymentState(bd)).toBe(STATES_ENUM.NOT_READY);
+  });
+
+  it('returns outofsync when deploymentId differs from stagedDeploymentId', () => {
+    const bd: BundleDeployment = {
+      spec:   { deploymentId: 'dep-1', stagedDeploymentId: 'dep-2' },
+      status: {
+        appliedDeploymentId: 'dep-1',
+        ready:               true,
+        nonModified:         true,
+        conditions:          [],
+      },
+    };
+
+    expect(FleetUtils.bundleDeploymentState(bd)).toBe(STATES_ENUM.OUT_OF_SYNC);
+  });
+
+  it('returns modified when nonModified is false', () => {
+    const bd = makeDeployment({
+      status: {
+        appliedDeploymentId: 'dep-1', ready: true, nonModified: false, conditions: []
+      }
+    });
+
+    expect(FleetUtils.bundleDeploymentState(bd)).toBe(STATES_ENUM.MODIFIED);
+  });
+});
+
+describe('fleet: resourcesFromBundleDeploymentStatus', () => {
+  it('returns empty array for empty status', () => {
+    const result = FleetUtils.resourcesFromBundleDeploymentStatus({} as BundleDeploymentStatus);
+
+    expect(result).toStrictEqual([]);
+  });
+
+  it('marks resources as ready when only in status.resources', () => {
+    const status: BundleDeploymentStatus = {
+      resources: [{
+        kind: 'Pod', apiVersion: 'v1', namespace: 'ns', name: 'pod-1'
+      }],
+      ready:       true,
+      nonModified: true,
+      conditions:  [],
+    };
+    const result = FleetUtils.resourcesFromBundleDeploymentStatus(status);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].state).toBe(STATES_ENUM.READY);
+    expect(result[0].name).toBe('pod-1');
+  });
+
+  it('marks resource as missing when in modifiedStatus with missing=true', () => {
+    const status: BundleDeploymentStatus = {
+      modifiedStatus: [{
+        kind: 'Pod', apiVersion: 'v1', namespace: 'ns', name: 'pod-1', missing: true, patch: ''
+      }],
+      ready:       true,
+      nonModified: true,
+      conditions:  [],
+    };
+    const result = FleetUtils.resourcesFromBundleDeploymentStatus(status);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].state).toBe(STATES_ENUM.MISSING);
+  });
+
+  it('marks resource as orphaned when in modifiedStatus with delete=true', () => {
+    const status: BundleDeploymentStatus = {
+      modifiedStatus: [{
+        kind: 'Pod', apiVersion: 'v1', namespace: 'ns', name: 'pod-1', delete: true, patch: ''
+      }],
+      ready:       true,
+      nonModified: true,
+      conditions:  [],
+    };
+    const result = FleetUtils.resourcesFromBundleDeploymentStatus(status);
+
+    expect(result[0].state).toBe(STATES_ENUM.ORPHANED);
+  });
+
+  it('marks resource as modified when in modifiedStatus without missing/delete', () => {
+    const status: BundleDeploymentStatus = {
+      modifiedStatus: [{
+        kind: 'Pod', apiVersion: 'v1', namespace: 'ns', name: 'pod-1', patch: 'diff'
+      }],
+      ready:       true,
+      nonModified: true,
+      conditions:  [],
+    };
+    const result = FleetUtils.resourcesFromBundleDeploymentStatus(status);
+
+    expect(result[0].state).toBe(STATES_ENUM.MODIFIED);
+  });
+
+  it('updates state of a resource that appears in both resources and modifiedStatus', () => {
+    const status: BundleDeploymentStatus = {
+      resources: [{
+        kind: 'Pod', apiVersion: 'v1', namespace: 'ns', name: 'pod-1'
+      }],
+      modifiedStatus: [{
+        kind: 'Pod', apiVersion: 'v1', namespace: 'ns', name: 'pod-1', missing: true, patch: ''
+      }],
+      ready:       true,
+      nonModified: true,
+      conditions:  [],
+    };
+    const result = FleetUtils.resourcesFromBundleDeploymentStatus(status);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].state).toBe(STATES_ENUM.MISSING);
+  });
+});
+
+describe('fleet: clusterIdFromBundleDeploymentLabels', () => {
+  it('returns namespace/name from labels', () => {
+    const labels = {
+      [FLEET_LABELS.CLUSTER_NAMESPACE]: 'fleet-default',
+      [FLEET_LABELS.CLUSTER]:           'cluster-1',
+    };
+
+    expect(FleetUtils.clusterIdFromBundleDeploymentLabels(labels)).toBe('fleet-default/cluster-1');
+  });
+
+  it('returns undefined/undefined when labels are absent', () => {
+    expect(FleetUtils.clusterIdFromBundleDeploymentLabels(undefined)).toBe('undefined/undefined');
+  });
+});
+
+describe('fleet: bundleIdFromBundleDeploymentLabels', () => {
+  it('returns namespace/name from labels', () => {
+    const labels = {
+      [FLEET_LABELS.BUNDLE_NAMESPACE]: 'fleet-default',
+      [FLEET_LABELS.BUNDLE_NAME]:      'my-bundle',
+    };
+
+    expect(FleetUtils.bundleIdFromBundleDeploymentLabels(labels)).toBe('fleet-default/my-bundle');
+  });
+
+  it('returns undefined/undefined when labels are absent', () => {
+    expect(FleetUtils.bundleIdFromBundleDeploymentLabels(undefined)).toBe('undefined/undefined');
+  });
+});
+
+describe('fleet: getDashboardStateId', () => {
+  it.each([
+    {
+      desc: 'strips "text-" prefix from stateColor', stateColor: 'text-error', expected: 'error'
+    },
+    {
+      desc: 'returns "warning" when stateColor is falsy', stateColor: '', expected: 'warning'
+    },
+    {
+      desc: 'returns stateColor unchanged when no "text-" prefix', stateColor: 'success', expected: 'success'
+    },
+  ])('$desc', ({ stateColor, expected }) => {
+    expect(FleetUtils.getDashboardStateId({ stateColor })).toBe(expected);
+  });
+});
+
+describe('fleet: getDashboardState', () => {
+  it('returns the matching dashboard state for a known stateColor', () => {
+    const state = FleetUtils.getDashboardState({ stateColor: 'text-error' }) as { id: string };
+
+    expect(state.id).toBe('error');
+  });
+
+  it('returns empty object for an unknown stateColor', () => {
+    expect(FleetUtils.getDashboardState({ stateColor: 'text-unknown-state' })).toStrictEqual({});
+  });
+
+  it('returns warning state when stateColor is empty', () => {
+    const state = FleetUtils.getDashboardState({ stateColor: '' }) as { id: string };
+
+    expect(state.id).toBe('warning');
+  });
+});