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

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

package/utils/__tests__/git.test.ts

@@ -0,0 +1,270 @@
+import { GitUtils, Commit } from '@shell/utils/git';
+
+describe('git utils', () => {
+  describe('gitUtils.github.normalize.repo', () => {
+    it('maps owner fields from GitHub API response', () => {
+      const data = {
+        owner: {
+          login:      'octocat',
+          html_url:   'https://github.com/octocat',
+          avatar_url: 'https://avatars.githubusercontent.com/u/1?v=4'
+        },
+        description: 'Hello World',
+        created_at:  '2021-01-01T00:00:00Z',
+        updated_at:  '2021-06-01T00:00:00Z',
+        html_url:    'https://github.com/octocat/hello-world',
+        name:        'hello-world'
+      };
+
+      const result = GitUtils.github.normalize.repo(data);
+
+      expect(result.owner).toStrictEqual({
+        name:      'octocat',
+        htmlUrl:   'https://github.com/octocat',
+        avatarUrl: 'https://avatars.githubusercontent.com/u/1?v=4'
+      });
+    });
+
+    it('maps repo-level fields from GitHub API response', () => {
+      const data = {
+        owner: {
+          login: 'octocat', html_url: '', avatar_url: ''
+        },
+        description: 'A repository description',
+        created_at:  '2021-01-01T00:00:00Z',
+        updated_at:  '2022-03-15T12:00:00Z',
+        html_url:    'https://github.com/octocat/repo',
+        name:        'my-repo'
+      };
+
+      const result = GitUtils.github.normalize.repo(data);
+
+      expect(result.description).toStrictEqual('A repository description');
+      expect(result.created_at).toStrictEqual('2021-01-01T00:00:00Z');
+      expect(result.updated_at).toStrictEqual('2022-03-15T12:00:00Z');
+      expect(result.htmlUrl).toStrictEqual('https://github.com/octocat/repo');
+      expect(result.name).toStrictEqual('my-repo');
+    });
+
+    it('handles missing owner gracefully', () => {
+      const data = {
+        owner:       undefined,
+        description: 'No owner',
+        created_at:  '2021-01-01T00:00:00Z',
+        updated_at:  '2021-01-01T00:00:00Z',
+        html_url:    'https://github.com/no/owner',
+        name:        'no-owner'
+      };
+
+      const result = GitUtils.github.normalize.repo(data);
+
+      expect(result.owner).toStrictEqual({
+        name:      undefined,
+        htmlUrl:   undefined,
+        avatarUrl: undefined
+      });
+    });
+  });
+
+  describe('gitUtils.github.normalize.commit', () => {
+    it('maps commit fields from GitHub API response', () => {
+      const data = {
+        commit: {
+          message:   'fix: resolve issue',
+          committer: { date: '2022-01-15T10:30:00Z' }
+        },
+        html_url: 'https://github.com/octocat/repo/commit/abc1234567890',
+        sha:      'abc1234567890abcdef',
+        author:   {
+          login:      'octocat',
+          avatar_url: 'https://avatars.githubusercontent.com/u/1?v=4',
+          htmlUrl:    'https://github.com/octocat'
+        }
+      };
+
+      const result = GitUtils.github.normalize.commit(data);
+
+      expect(result.message).toStrictEqual('fix: resolve issue');
+      expect(result.htmlUrl).toStrictEqual('https://github.com/octocat/repo/commit/abc1234567890');
+      expect(result.sha).toStrictEqual('abc1234');
+      expect(result.commitId).toStrictEqual('abc1234567890abcdef');
+      expect(result.date).toStrictEqual('2022-01-15T10:30:00Z');
+      expect(result.isChecked).toStrictEqual(false);
+    });
+
+    it('truncates sha to 7 characters', () => {
+      const data = {
+        commit:   { message: 'chore: update deps', committer: { date: '2022-01-01T00:00:00Z' } },
+        html_url: 'https://github.com/octocat/repo/commit/1234567890',
+        sha:      '1234567890abcdef1234',
+        author:   {
+          login: 'user', avatar_url: '', htmlUrl: ''
+        }
+      };
+
+      const result = GitUtils.github.normalize.commit(data);
+
+      expect(result.sha).toStrictEqual('1234567');
+    });
+
+    it('returns undefined sha when sha is empty string', () => {
+      const data = {
+        commit:   { message: 'fix: bug', committer: { date: '2022-01-01T00:00:00Z' } },
+        html_url: 'https://github.com/octocat/repo/commit/x',
+        sha:      '',
+        author:   {
+          login: 'user', avatar_url: '', htmlUrl: ''
+        }
+      };
+
+      const result: Commit = GitUtils.github.normalize.commit(data);
+
+      expect(result.sha).toBeUndefined();
+    });
+
+    it('maps author fields from GitHub API response', () => {
+      const data = {
+        commit:   { message: 'feat: new feature', committer: { date: '2022-01-01T00:00:00Z' } },
+        html_url: 'https://github.com/octocat/repo/commit/abc',
+        sha:      'abcdef1234567890',
+        author:   {
+          login:      'contributor',
+          avatar_url: 'https://avatars.githubusercontent.com/u/2?v=4',
+          htmlUrl:    'https://github.com/contributor'
+        }
+      };
+
+      const result = GitUtils.github.normalize.commit(data);
+
+      expect(result.author).toStrictEqual({
+        name:      'contributor',
+        avatarUrl: 'https://avatars.githubusercontent.com/u/2?v=4',
+        htmlUrl:   'https://github.com/contributor'
+      });
+    });
+  });
+
+  describe('gitUtils.gitlab.normalize.repo', () => {
+    it('maps owner fields from GitLab API response', () => {
+      const data = {
+        namespace: {
+          name:       'my-group',
+          web_url:    'https://gitlab.com/my-group',
+          avatar_url: 'https://gitlab.com/uploads/group.png'
+        },
+        description:      'GitLab repo description',
+        created_at:       '2021-02-01T00:00:00Z',
+        last_activity_at: '2022-07-20T00:00:00Z',
+        web_url:          'https://gitlab.com/my-group/project',
+        name:             'project'
+      };
+
+      const result = GitUtils.gitlab.normalize.repo(data);
+
+      expect(result.owner).toStrictEqual({
+        name:      'my-group',
+        htmlUrl:   'https://gitlab.com/my-group',
+        avatarUrl: 'https://gitlab.com/uploads/group.png'
+      });
+    });
+
+    it('maps repo-level fields from GitLab API response', () => {
+      const data = {
+        namespace: {
+          name: 'ns', web_url: '', avatar_url: ''
+        },
+        description:      'My GitLab project',
+        created_at:       '2020-05-01T00:00:00Z',
+        last_activity_at: '2023-01-10T00:00:00Z',
+        web_url:          'https://gitlab.com/ns/myproject',
+        name:             'myproject'
+      };
+
+      const result = GitUtils.gitlab.normalize.repo(data);
+
+      expect(result.description).toStrictEqual('My GitLab project');
+      expect(result.created_at).toStrictEqual('2020-05-01T00:00:00Z');
+      expect(result.updated_at).toStrictEqual('2023-01-10T00:00:00Z');
+      expect(result.htmlUrl).toStrictEqual('https://gitlab.com/ns/myproject');
+      expect(result.name).toStrictEqual('myproject');
+    });
+
+    it('maps updated_at from last_activity_at (not updated_at)', () => {
+      const data = {
+        namespace: {
+          name: 'ns', web_url: '', avatar_url: ''
+        },
+        description:      '',
+        created_at:       '2020-01-01T00:00:00Z',
+        last_activity_at: '2023-06-15T08:00:00Z',
+        updated_at:       'should-be-ignored',
+        web_url:          'https://gitlab.com/ns/proj',
+        name:             'proj'
+      };
+
+      const result = GitUtils.gitlab.normalize.repo(data);
+
+      expect(result.updated_at).toStrictEqual('2023-06-15T08:00:00Z');
+    });
+  });
+
+  describe('gitUtils.gitlab.normalize.commit', () => {
+    it('maps commit fields from GitLab API response', () => {
+      const data = {
+        message:        'refactor: clean up code',
+        web_url:        'https://gitlab.com/ns/proj/-/commit/abc1234',
+        short_id:       'abc1234',
+        id:             'abc1234567890abcdef',
+        author_name:    'Jane Doe',
+        avatar_url:     'https://gitlab.com/uploads/jane.png',
+        committed_date: '2022-03-10T14:00:00Z'
+      };
+
+      const result = GitUtils.gitlab.normalize.commit(data);
+
+      expect(result.message).toStrictEqual('refactor: clean up code');
+      expect(result.htmlUrl).toStrictEqual('https://gitlab.com/ns/proj/-/commit/abc1234');
+      expect(result.sha).toStrictEqual('abc1234');
+      expect(result.commitId).toStrictEqual('abc1234567890abcdef');
+      expect(result.date).toStrictEqual('2022-03-10T14:00:00Z');
+      expect(result.isChecked).toStrictEqual(false);
+    });
+
+    it('maps author fields from GitLab API response', () => {
+      const data = {
+        message:        'feat: add feature',
+        web_url:        'https://gitlab.com/ns/proj/-/commit/xyz',
+        short_id:       'xyz',
+        id:             'xyzabcdef',
+        author_name:    'John Smith',
+        avatar_url:     'https://gitlab.com/uploads/john.png',
+        committed_date: '2022-04-01T00:00:00Z'
+      };
+
+      const result = GitUtils.gitlab.normalize.commit(data);
+
+      expect(result.author).toStrictEqual({
+        name:      'John Smith',
+        avatarUrl: 'https://gitlab.com/uploads/john.png',
+        htmlUrl:   'https://gitlab.com/ns/proj/-/commit/xyz'
+      });
+    });
+
+    it('uses web_url for both htmlUrl and author.htmlUrl', () => {
+      const data = {
+        message:        'fix: something',
+        web_url:        'https://gitlab.com/ns/proj/-/commit/def456',
+        short_id:       'def456',
+        id:             'def456abc',
+        author_name:    'Dev',
+        avatar_url:     '',
+        committed_date: '2022-01-01T00:00:00Z'
+      };
+
+      const result = GitUtils.gitlab.normalize.commit(data);
+
+      expect(result.htmlUrl).toStrictEqual('https://gitlab.com/ns/proj/-/commit/def456');
+      expect((result.author as any).htmlUrl).toStrictEqual('https://gitlab.com/ns/proj/-/commit/def456');
+    });
+  });
+});