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

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');
+  });
+});