@rancher/shell 3.0.9-rc.3 → 3.0.9-rc.5

package/models/__tests__/ext.cattle.io.kubeconfig.test.ts

@@ -0,0 +1,364 @@
+import Kubeconfig from '@shell/models/ext.cattle.io.kubeconfig';
+import { CAPI, MANAGEMENT } from '@shell/config/types';
+
+// SteveModel is JS, so we need to type the constructor
+const KubeconfigModel = Kubeconfig as unknown as new (data: object) => Kubeconfig;
+
+describe('class Kubeconfig', () => {
+  const mockT = jest.fn((key: string, opts?: { name: string }) => {
+    if (key === '"ext.cattle.io.kubeconfig".deleted') {
+      return `${ opts?.name } (deleted)`;
+    }
+
+    return key;
+  });
+
+  const createKubeconfig = (data: object, rootGetters: object = {}) => {
+    const kubeconfig = new KubeconfigModel(data);
+
+    // Mock $rootGetters before any getters are accessed
+    // Cast to any since $rootGetters is inherited from JS SteveModel
+    jest.spyOn(kubeconfig as any, '$rootGetters', 'get').mockReturnValue({
+      'i18n/t':         mockT,
+      'management/all': () => [],
+      ...rootGetters
+    });
+
+    return kubeconfig;
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('expiresAt', () => {
+    it('should return null when ttl is not set', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: { creationTimestamp: '2024-01-01T00:00:00Z' },
+        spec:     {}
+      });
+
+      expect(kubeconfig.expiresAt).toBeNull();
+    });
+
+    it('should return null when creationTimestamp is not set', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: {},
+        spec:     { ttl: 3600 }
+      });
+
+      expect(kubeconfig.expiresAt).toBeNull();
+    });
+
+    it('should calculate expiry correctly', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: { creationTimestamp: '2024-01-01T00:00:00Z' },
+        spec:     { ttl: 3600 } // 1 hour in seconds
+      });
+
+      expect(kubeconfig.expiresAt).toBe('2024-01-01T01:00:00.000Z');
+    });
+
+    it('should handle large ttl values', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: { creationTimestamp: '2024-01-01T00:00:00Z' },
+        spec:     { ttl: 86400 } // 24 hours in seconds
+      });
+
+      expect(kubeconfig.expiresAt).toBe('2024-01-02T00:00:00.000Z');
+    });
+  });
+
+  describe('referencedClusters', () => {
+    const mockProvCluster = {
+      mgmt:           { id: 'c-m-abc123' },
+      status:         { clusterName: 'c-m-abc123' },
+      nameDisplay:    'my-cluster',
+      detailLocation: { name: 'c-cluster-product-resource-id', params: { cluster: 'my-cluster' } }
+    };
+
+    const mockMgmtCluster = {
+      id:             'c-m-def456',
+      nameDisplay:    'mgmt-cluster',
+      detailLocation: { name: 'c-cluster-product-resource-id', params: { cluster: 'mgmt-cluster' } }
+    };
+
+    it('should return empty array when no clusters are specified', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: {},
+        spec:     {}
+      });
+
+      expect(kubeconfig.referencedClusters).toStrictEqual([]);
+    });
+
+    it('should map provisioning cluster by mgmt id', () => {
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-abc123'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return [mockProvCluster];
+            }
+
+            return [];
+          }
+        }
+      );
+
+      expect(kubeconfig.referencedClusters).toStrictEqual([
+        {
+          label:    'my-cluster',
+          location: mockProvCluster.detailLocation
+        }
+      ]);
+    });
+
+    it('should map management cluster when no provisioning cluster found', () => {
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-def456'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === MANAGEMENT.CLUSTER) {
+              return [mockMgmtCluster];
+            }
+
+            return [];
+          }
+        }
+      );
+
+      expect(kubeconfig.referencedClusters).toStrictEqual([
+        {
+          label:    'mgmt-cluster',
+          location: mockMgmtCluster.detailLocation
+        }
+      ]);
+    });
+
+    it('should return deleted label when cluster not found', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: {},
+        spec:     { clusters: ['c-m-deleted'] }
+      });
+
+      expect(kubeconfig.referencedClusters).toStrictEqual([
+        {
+          label:    'c-m-deleted (deleted)',
+          location: null
+        }
+      ]);
+      expect(mockT).toHaveBeenCalledWith('"ext.cattle.io.kubeconfig".deleted', { name: 'c-m-deleted' });
+    });
+
+    it('should prefer provisioning cluster over management cluster', () => {
+      const mgmtClusterSameId = {
+        id:             'c-m-abc123',
+        nameDisplay:    'mgmt-version',
+        detailLocation: { name: 'mgmt-location' }
+      };
+
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-abc123'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return [mockProvCluster];
+            }
+            if (type === MANAGEMENT.CLUSTER) {
+              return [mgmtClusterSameId];
+            }
+
+            return [];
+          }
+        }
+      );
+
+      expect(kubeconfig.referencedClusters).toStrictEqual([
+        {
+          label:    'my-cluster',
+          location: mockProvCluster.detailLocation
+        }
+      ]);
+    });
+  });
+
+  describe('sortedReferencedClusters', () => {
+    it('should sort existing clusters before deleted clusters', () => {
+      const existingCluster = {
+        mgmt:           { id: 'c-m-exists' },
+        nameDisplay:    'existing-cluster',
+        detailLocation: { name: 'location' }
+      };
+
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['deleted-1', 'c-m-exists', 'deleted-2'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return [existingCluster];
+            }
+
+            return [];
+          }
+        }
+      );
+
+      const sorted = kubeconfig.sortedReferencedClusters;
+
+      expect(sorted[0].label).toBe('existing-cluster');
+      expect(sorted[0].location).not.toBeNull();
+      expect(sorted[1].location).toBeNull();
+      expect(sorted[2].location).toBeNull();
+    });
+
+    it('should sort existing clusters alphabetically', () => {
+      const clusters = [
+        {
+          mgmt: { id: 'c-m-zebra' }, nameDisplay: 'zebra', detailLocation: { name: 'z' }
+        },
+        {
+          mgmt: { id: 'c-m-alpha' }, nameDisplay: 'alpha', detailLocation: { name: 'a' }
+        },
+        {
+          mgmt: { id: 'c-m-beta' }, nameDisplay: 'beta', detailLocation: { name: 'b' }
+        }
+      ];
+
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-zebra', 'c-m-alpha', 'c-m-beta'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return clusters;
+            }
+
+            return [];
+          }
+        }
+      );
+
+      const sorted = kubeconfig.sortedReferencedClusters;
+
+      expect(sorted.map((c) => c.label)).toStrictEqual(['alpha', 'beta', 'zebra']);
+    });
+
+    it('should sort numerically when names contain numbers', () => {
+      const clusters = [
+        {
+          mgmt: { id: 'c-m-2' }, nameDisplay: 'cluster2', detailLocation: { name: 'c2' }
+        },
+        {
+          mgmt: { id: 'c-m-10' }, nameDisplay: 'cluster10', detailLocation: { name: 'c10' }
+        },
+        {
+          mgmt: { id: 'c-m-1' }, nameDisplay: 'cluster1', detailLocation: { name: 'c1' }
+        }
+      ];
+
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-2', 'c-m-10', 'c-m-1'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return clusters;
+            }
+
+            return [];
+          }
+        }
+      );
+
+      const sorted = kubeconfig.sortedReferencedClusters;
+
+      expect(sorted.map((c) => c.label)).toStrictEqual(['cluster1', 'cluster2', 'cluster10']);
+    });
+  });
+
+  describe('referencedClustersSortable', () => {
+    it('should return comma-separated lowercase labels', () => {
+      const clusters = [
+        {
+          mgmt: { id: 'c-m-1' }, nameDisplay: 'Alpha', detailLocation: { name: 'a' }
+        },
+        {
+          mgmt: { id: 'c-m-2' }, nameDisplay: 'Beta', detailLocation: { name: 'b' }
+        }
+      ];
+
+      const kubeconfig = createKubeconfig(
+        {
+          metadata: {},
+          spec:     { clusters: ['c-m-1', 'c-m-2'] }
+        },
+        {
+          'management/all': (type: string) => {
+            if (type === CAPI.RANCHER_CLUSTER) {
+              return clusters;
+            }
+
+            return [];
+          }
+        }
+      );
+
+      expect(kubeconfig.referencedClustersSortable).toBe('alpha,beta');
+    });
+
+    it('should return empty string when no clusters', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: {},
+        spec:     {}
+      });
+
+      expect(kubeconfig.referencedClustersSortable).toBe('');
+    });
+  });
+
+  describe('_availableActions', () => {
+    it('should filter out goToEdit, goToEditYaml, cloneYaml, and download actions', () => {
+      const kubeconfig = createKubeconfig({
+        metadata: {},
+        spec:     {}
+      });
+
+      const mockActions = [
+        { action: 'goToClone' },
+        { action: 'divider' },
+        { action: 'goToEdit' },
+        { action: 'goToEditYaml' },
+        { action: 'cloneYaml' },
+        { action: 'download' },
+        { action: 'promptRemove' }
+      ];
+
+      jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(kubeconfig)), '_availableActions', 'get')
+        .mockReturnValue(mockActions);
+
+      const actions = kubeconfig._availableActions;
+
+      expect(actions).toStrictEqual([
+        { action: 'goToClone' },
+        { action: 'promptRemove' }
+      ]);
+    });
+  });
+});

package/models/__tests__/secret.test.ts

@@ -1,7 +1,62 @@
 import Secret from '@shell/models/secret';
 import { SECRET_TYPES as TYPES } from '@shell/config/secret';
+import { VIRTUAL_TYPES } from '@shell/config/types';
+import { UI_PROJECT_SECRET } from '@shell/config/labels-annotations';
 
 describe('class Secret', () => {
+  describe('detailLocation', () => {
+    it('should return correct route for project scoped secret', () => {
+      const secret = new Secret({
+        metadata: {
+          namespace: 'c-cluster-p-project',
+          labels:    { [UI_PROJECT_SECRET]: 'p-project' }
+        },
+        id: 'c-cluster-p-project/my-secret'
+      });
+
+      // Mock $rootGetters
+      Object.defineProperty(secret, '$rootGetters', {
+        value: {
+          productId: 'explorer',
+          clusterId: 'c-cluster',
+          isRancher: true
+        }
+      });
+
+      const location = secret.detailLocation;
+
+      expect(location.name).toBe(`c-cluster-product-${ VIRTUAL_TYPES.PROJECT_SECRETS }-namespace-id`);
+      expect(location.params.resource).toBe(VIRTUAL_TYPES.PROJECT_SECRETS);
+      expect(location.params.product).toBe('explorer');
+      expect(location.params.cluster).toBe('c-cluster');
+      expect(location.params.namespace).toBe('c-cluster-p-project');
+      expect(location.params.id).toBe('my-secret');
+    });
+
+    it('should return default detailLocation for non-project scoped secret', () => {
+      const secret = new Secret({
+        metadata: { namespace: 'default' },
+        id:       'default/my-secret'
+      });
+
+      // Mock $rootGetters
+      Object.defineProperty(secret, '$rootGetters', {
+        value: {
+          productId: 'explorer',
+          clusterId: 'c-cluster',
+          isRancher: true
+        }
+      });
+
+      const expectedLocation = { name: 'some-route' };
+
+      // Mock _detailLocation (the parent class implementation or default behavior)
+      Object.defineProperty(secret, '_detailLocation', { value: expectedLocation });
+
+      expect(secret.detailLocation).toBe(expectedLocation);
+    });
+  });
+
   describe('cleanForDownload', () => {
     it('should contains the type attribute if cleanForDownload', async() => {
       const secret = new Secret({});

package/models/__tests__/workload.test.ts

@@ -253,6 +253,8 @@ describe('class: Workload', () => {
   });
 
   describe('getter: podsCard', () => {
+    const mockPod = { metadata: { name: 'pod-1', namespace: 'default' } };
+
     it('should return card for Deployment type', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.DEPLOYMENT,
@@ -264,7 +266,7 @@ describe('class: Workload', () => {
         rootGetters: { 'i18n/t': (key: string) => key },
       });
 
-      Object.defineProperty(workload, 'pods', { get: () => [] });
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
       Object.defineProperty(workload, 'canUpdate', { get: () => true });
 
       const card = workload.podsCard;
@@ -285,7 +287,7 @@ describe('class: Workload', () => {
         rootGetters: { 'i18n/t': (key: string) => key },
       });
 
-      Object.defineProperty(workload, 'pods', { get: () => [] });
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
       Object.defineProperty(workload, 'canUpdate', { get: () => true });
 
       const card = workload.podsCard;
@@ -310,7 +312,7 @@ describe('class: Workload', () => {
       expect(card).toBeNull();
     });
 
-    it('should hide scaling when canUpdate is false', () => {
+    it('should return null when pods array is empty', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.DEPLOYMENT,
         metadata: { name: 'test', namespace: 'default' },
@@ -322,6 +324,24 @@ describe('class: Workload', () => {
       });
 
       Object.defineProperty(workload, 'pods', { get: () => [] });
+
+      const card = workload.podsCard;
+
+      expect(card).toBeNull();
+    });
+
+    it('should hide scaling when canUpdate is false', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
       Object.defineProperty(workload, 'canUpdate', { get: () => false });
 
       const card = workload.podsCard;
@@ -331,6 +351,8 @@ describe('class: Workload', () => {
   });
 
   describe('getter: jobsCard', () => {
+    const mockJob = { metadata: { name: 'job-1', namespace: 'default' } };
+
     it('should return card for CronJob type', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.CRON_JOB,
@@ -342,7 +364,7 @@ describe('class: Workload', () => {
         rootGetters: { 'i18n/t': (key: string) => key },
       });
 
-      Object.defineProperty(workload, 'jobs', { get: () => [] });
+      Object.defineProperty(workload, 'jobs', { get: () => [mockJob] });
 
       const card = workload.jobsCard;
 
@@ -366,9 +388,30 @@ describe('class: Workload', () => {
 
       expect(card).toBeNull();
     });
+
+    it('should return null when jobs array is empty', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.CRON_JOB,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      Object.defineProperty(workload, 'jobs', { get: () => [] });
+
+      const card = workload.jobsCard;
+
+      expect(card).toBeNull();
+    });
   });
 
   describe('getter: cards', () => {
+    const mockPod = { metadata: { name: 'pod-1', namespace: 'default' } };
+    const mockJob = { metadata: { name: 'job-1', namespace: 'default' } };
+
     it('should include podsCard for Deployment', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.DEPLOYMENT,
@@ -384,7 +427,7 @@ describe('class: Workload', () => {
         },
       });
 
-      Object.defineProperty(workload, 'pods', { get: () => [] });
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
       Object.defineProperty(workload, 'canUpdate', { get: () => true });
 
       const cards = workload.cards;
@@ -411,7 +454,7 @@ describe('class: Workload', () => {
         },
       });
 
-      Object.defineProperty(workload, 'jobs', { get: () => [] });
+      Object.defineProperty(workload, 'jobs', { get: () => [mockJob] });
 
       const cards = workload.cards;
       const nonNullCards = cards.filter((c: any) => c !== null);

package/models/auditlog.cattle.io.auditpolicy.js

@@ -0,0 +1,46 @@
+import { insertAt } from '@shell/utils/array';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class AuditPolicy extends SteveModel {
+  get _availableActions() {
+    const out = super._availableActions;
+
+    insertAt(out, 0, {
+      action:   'enable',
+      label:    this.t('action.enable'),
+      icon:     'icon icon-play',
+      enabled:  (this.canEdit || this.canEditYaml) && !this.spec.enabled,
+      bulkable: true,
+      weight:   2,
+    });
+    insertAt(out, 0, {
+      action:   'disable',
+      label:    this.t('action.disable'),
+      icon:     'icon icon-pause',
+      enabled:  (this.canEdit || this.canEditYaml) && this.spec.enabled,
+      bulkable: true,
+      weight:   1,
+    });
+
+    return out;
+  }
+
+  enable() {
+    this.enableOrDisable('enable');
+  }
+
+  disable() {
+    this.enableOrDisable('disable');
+  }
+
+  async enableOrDisable(flag) {
+    const clone = await this.$dispatch('rancher/clone', { resource: this }, { root: true });
+
+    clone.spec.enabled = flag === 'enable';
+    await clone.save().catch((err) => {
+      this.$dispatch('growl/fromError', {
+        title: this.t('auditPolicy.error.enableOrDisable', { flag, id: this.id }), err, timeout: 5000
+      }, { root: true });
+    });
+  }
+}

package/models/cluster.x-k8s.io.machine.js

@@ -138,7 +138,7 @@ export default class CapiMachine extends SteveModel {
 
   async machineRef() {
     const ref = this.spec.infrastructureRef;
-    const id = `${ ref.namespace }/${ ref.name }`;
+    const id = `${ this.metadata.namespace }/${ ref.name }`;
     const kind = `rke-machine.cattle.io.${ ref.kind.toLowerCase() }`;
 
     return await this.$dispatch('find', { type: kind, id });

package/models/cluster.x-k8s.io.machinedeployment.js

@@ -41,12 +41,12 @@ export default class CapiMachineDeployment extends SteveModel {
   }
 
   get templateType() {
-    return this.spec.template.spec.infrastructureRef.kind ? `rke-machine.cattle.io.${ this.spec.template.spec.infrastructureRef.kind.toLowerCase() }` : null;
+    return this.infrastructureRefKind ? `rke-machine.cattle.io.${ this.infrastructureRefKind.toLowerCase() }` : null;
   }
 
   get template() {
     const ref = this.spec.template.spec.infrastructureRef;
-    const id = `${ ref.namespace }/${ ref.name }`;
+    const id = `${ this.metadata.namespace }/${ ref.name }`;
     const template = this.$rootGetters['management/byId'](this.templateType, id);
 
     return template;
@@ -92,15 +92,15 @@ export default class CapiMachineDeployment extends SteveModel {
   }
 
   get outdated() {
-    return Math.max(0, (this.status?.replicas || 0) - (this.status?.updatedReplicas || 0));
+    return Math.max(0, (this.status?.replicas || 0) - (this.status?.upToDateReplicas || 0));
   }
 
   get ready() {
-    return Math.max(0, (this.status?.replicas || 0) - (this.status?.unavailableReplicas || 0));
+    return this.status?.availableReplicas || 0;
   }
 
   get unavailable() {
-    return this.status?.unavailableReplicas || 0;
+    return Math.max(0, (this.status?.replicas || 0) - (this.status?.availableReplicas || 0));
   }
 
   get isControlPlane() {

package/models/event.js

@@ -38,4 +38,9 @@ export default class K8sEvent extends SteveModel {
 
     return schema && rowValueGetter ? rowValueGetter(schema, 'Last Seen')(this) : null;
   }
+
+  // Because we're using eventType which is a non-standard state we don't have a reliable way to provide a state color anymore and have therefore disabled the color.
+  get insightsColor() {
+    return 'disabled';
+  }
 }

package/models/ext.cattle.io.groupmembershiprefreshrequest.js

@@ -0,0 +1,15 @@
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class GroupMembershipRefreshRequest extends SteveModel {
+  get canRefreshMemberships() {
+    return this.schema?.collectionMethods.find((x) => x.toLowerCase() === 'post');
+  }
+
+  cleanForSave(data) {
+    const val = super.cleanForSave(data);
+
+    delete val.type;
+
+    return val;
+  }
+}