@rancher/shell 3.0.9-rc.4 → 3.0.9-rc.6

package/models/__tests__/auditlog.cattle.io.auditpolicy.test.ts

@@ -0,0 +1,117 @@
+import AuditPolicy from '@shell/models/auditlog.cattle.io.auditpolicy';
+
+describe('auditPolicy Model', () => {
+  let mockDispatch: jest.Mock;
+  let mockT: jest.Mock;
+  let auditPolicy: any;
+
+  beforeEach(() => {
+    mockDispatch = jest.fn();
+    mockT = jest.fn();
+
+    const mockResource = {
+      id:       'test-policy',
+      spec:     { enabled: false },
+      metadata: { name: 'test-policy' }
+    };
+
+    auditPolicy = new AuditPolicy(mockResource, {
+      dispatch:    mockDispatch,
+      rootGetters: { 'i18n/t': mockT },
+      getters:     { schemaFor: () => ({ linkFor: jest.fn() }) }
+    });
+  });
+
+  describe('enable method', () => {
+    it('should call enableOrDisable with "enable"', () => {
+      const spy = jest.spyOn(auditPolicy, 'enableOrDisable').mockImplementation();
+
+      auditPolicy.enable();
+
+      expect(spy).toHaveBeenCalledWith('enable');
+    });
+  });
+
+  describe('disable method', () => {
+    it('should call enableOrDisable with "disable"', () => {
+      const spy = jest.spyOn(auditPolicy, 'enableOrDisable').mockImplementation();
+
+      auditPolicy.disable();
+
+      expect(spy).toHaveBeenCalledWith('disable');
+    });
+  });
+
+  describe('enableOrDisable method', () => {
+    let mockClone: any;
+
+    beforeEach(() => {
+      mockClone = {
+        spec: { enabled: false },
+        save: jest.fn()
+      };
+
+      mockDispatch.mockImplementation((action: string) => {
+        if (action === 'rancher/clone') {
+          return Promise.resolve(mockClone);
+        }
+
+        return Promise.resolve();
+      });
+    });
+
+    it('should enable policy when flag is "enable"', async() => {
+      mockClone.save.mockResolvedValue({});
+
+      await auditPolicy.enableOrDisable('enable');
+
+      expect(mockClone.spec.enabled).toBe(true);
+      expect(mockClone.save).toHaveBeenCalledWith();
+    });
+
+    it('should disable policy when flag is "disable"', async() => {
+      mockClone.save.mockResolvedValue({});
+
+      await auditPolicy.enableOrDisable('disable');
+
+      expect(mockClone.spec.enabled).toBe(false);
+      expect(mockClone.save).toHaveBeenCalledWith();
+    });
+
+    it('should handle save errors and show growl notification', async() => {
+      const saveError = new Error('Save failed');
+
+      mockClone.save.mockRejectedValue(saveError);
+      mockT.mockReturnValue('Error when enabling - test-policy');
+
+      await auditPolicy.enableOrDisable('enable');
+
+      expect(mockDispatch).toHaveBeenCalledWith('growl/fromError', {
+        title:   'Error when enabling - test-policy',
+        err:     saveError,
+        timeout: 5000
+      }, { root: true });
+    });
+
+    it('should call translation with correct parameters', async() => {
+      const saveError = new Error('Save failed');
+
+      mockClone.save.mockRejectedValue(saveError);
+
+      await auditPolicy.enableOrDisable('enable');
+
+      expect(mockT).toHaveBeenCalledWith('auditPolicy.error.enableOrDisable', {
+        flag: 'enable',
+        id:   'test-policy'
+      });
+    });
+
+    it('should dispatch rancher/clone with correct parameters', async() => {
+      mockClone.save.mockResolvedValue({});
+
+      await auditPolicy.enableOrDisable('enable');
+
+      expect(mockDispatch).toHaveBeenCalledWith('rancher/clone', { resource: auditPolicy }, { root: true });
+    });
+  });
+});

package/models/__tests__/namespace.test.ts

@@ -187,6 +187,17 @@ describe('class Namespace', () => {
   it.todo('should set the resourceQuota as reactive Vue property');
   it.todo('should reset project with cleanForNew');
 
+  describe('hideDetailLocation', () => {
+    it('should not throw when currentProduct is undefined', () => {
+      const namespace = new Namespace({});
+
+      jest.spyOn(namespace, '$rootGetters', 'get').mockReturnValue({ currentProduct: undefined });
+
+      expect(() => namespace.hideDetailLocation).not.toThrow();
+      expect(namespace.hideDetailLocation).toBe(true);
+    });
+  });
+
   describe('glance', () => {
     it('should return projectGlance instead of namespace when namespace is in a project', () => {
       const t = jest.fn((key) => key);

package/models/__tests__/provisioning.cattle.io.cluster.test.ts

@@ -275,4 +275,100 @@ describe('class ProvCluster', () => {
     }
     );
   });
+
+  describe('supportsWindows', () => {
+    const testCases = [
+      {
+        description: 'should return false for k3s',
+        clusterData: { isK3s: true },
+        expected:    false
+      },
+      {
+        description: 'should return false for imported k3s',
+        clusterData: { isImportedK3s: true },
+        expected:    false
+      },
+      {
+        description: 'should return windowsPreferedCluster for rke1',
+        clusterData: { isRke1: true, mgmt: { spec: { windowsPreferedCluster: true } } },
+        expected:    true
+      },
+      {
+        description: 'should return false for rke1 if windowsPreferedCluster is false/missing',
+        clusterData: { isRke1: true, mgmt: { spec: { windowsPreferedCluster: false } } },
+        expected:    false
+      },
+      {
+        description: 'should return false if not rke2 (and not rke1 or k3s)',
+        clusterData: { isRke2: false },
+        expected:    false
+      },
+      {
+        description: 'should return false if kubernetesVersion is missing',
+        clusterData: { isRke2: true, kubernetesVersion: undefined },
+        expected:    false
+      },
+      {
+        description: 'should return false if kubernetesVersion is less than v1.21.0',
+        clusterData: { isRke2: true, kubernetesVersion: 'v1.20.9' },
+        expected:    false
+      },
+      {
+        description: 'should return false if cni is not calico or flannel',
+        clusterData: {
+          isRke2: true, kubernetesVersion: 'v1.34.0', spec: { rkeConfig: { machineGlobalConfig: { cni: 'cilium' } } }
+        },
+        expected: false
+      },
+      {
+        description: 'should return true if cni is calico',
+        clusterData: {
+          isRke2: true, kubernetesVersion: 'v1.34.0', spec: { rkeConfig: { machineGlobalConfig: { cni: 'calico' } } }
+        },
+        expected: true
+      },
+      {
+        description: 'should return false if cni is flannel and kubernetesVersion is less than v1.29.2 (e.g. v1.29.1)',
+        clusterData: {
+          isRke2: true, kubernetesVersion: 'v1.29.1', spec: { rkeConfig: { machineGlobalConfig: { cni: 'flannel' } } }
+        },
+        expected: false
+      },
+      {
+        description: 'should return true if cni is flannel and kubernetesVersion is exactly v1.29.2',
+        clusterData: {
+          isRke2: true, kubernetesVersion: 'v1.29.2', spec: { rkeConfig: { machineGlobalConfig: { cni: 'flannel' } } }
+        },
+        expected: true
+      },
+      {
+        description: 'should return true if cni is flannel and kubernetesVersion is >= v1.29.2 (e.g. v1.35.0)',
+        clusterData: {
+          isRke2: true, kubernetesVersion: 'v1.35.0', spec: { rkeConfig: { machineGlobalConfig: { cni: 'flannel' } } }
+        },
+        expected: true
+      },
+      {
+        description: 'should return true if cni is empty/undefined',
+        clusterData: {
+          isRke2: true, kubernetesVersion: 'v1.34.0', spec: { rkeConfig: { machineGlobalConfig: {} } }
+        },
+        expected: true
+      },
+    ];
+
+    it.each(testCases)('$description', ({ clusterData, expected }) => {
+      const cluster = new ProvCluster({ spec: clusterData.spec });
+
+      jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue(clusterData.mgmt);
+      jest.spyOn(cluster, 'isK3s', 'get').mockReturnValue(clusterData.isK3s || false);
+      jest.spyOn(cluster, 'isImportedK3s', 'get').mockReturnValue(clusterData.isImportedK3s || false);
+      jest.spyOn(cluster, 'isRke1', 'get').mockReturnValue(clusterData.isRke1 || false);
+      jest.spyOn(cluster, 'isRke2', 'get').mockReturnValue(clusterData.isRke2 || false);
+      jest.spyOn(cluster, 'kubernetesVersion', 'get').mockReturnValue(clusterData.kubernetesVersion);
+
+      expect(cluster.supportsWindows).toBe(expected);
+      jest.clearAllMocks();
+    });
+  });
 });

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;
@@ -272,6 +274,7 @@ describe('class: Workload', () => {
       expect(card).not.toBeNull();
       expect(card.props.title).toBe('component.resource.detail.card.podsCard.title');
       expect(card.props.showScaling).toBe(true);
+      expect(card.props.noResourcesMessage).toBe('component.resource.detail.card.podsCard.noPods');
     });
 
     it('should return card for DaemonSet type without scaling', () => {
@@ -285,7 +288,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 +313,7 @@ describe('class: Workload', () => {
       expect(card).toBeNull();
     });
 
-    it('should hide scaling when canUpdate is false', () => {
+    it('should return card when pods array is empty (scaled to 0)', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.DEPLOYMENT,
         metadata: { name: 'test', namespace: 'default' },
@@ -322,6 +325,64 @@ describe('class: Workload', () => {
       });
 
       Object.defineProperty(workload, 'pods', { get: () => [] });
+      Object.defineProperty(workload, 'canUpdate', { get: () => true });
+
+      const card = workload.podsCard;
+
+      expect(card).not.toBeNull();
+      expect(card.props.resources).toStrictEqual([]);
+      expect(card.props.noResourcesMessage).toBe('component.resource.detail.card.podsCard.noPods');
+    });
+
+    it('should return null for non-scalable type with empty pods', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DAEMON_SET,
+        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: () => [] });
+      Object.defineProperty(workload, 'canUpdate', { get: () => true });
+
+      const card = workload.podsCard;
+
+      expect(card).toBeNull();
+    });
+
+    it('should return null when pods is undefined', () => {
+      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: () => undefined });
+
+      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 +392,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 +405,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 +429,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 +468,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 +495,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/catalog.cattle.io.clusterrepo.js

@@ -1,7 +1,7 @@
 import { parse } from '@shell/utils/url';
 import { CATALOG } from '@shell/config/labels-annotations';
 import { insertAt } from '@shell/utils/array';
-import { CATALOG as CATALOG_TYPE } from '@shell/config/types';
+import { CLUSTER_REPO_APPCO_AUTH_GENERATE_NAME, CATALOG as CATALOG_TYPE } from '@shell/config/types';
 import { colorForState, stateDisplay } from '@shell/plugins/dashboard-store/resource-class';
 
 import SteveModel from '@shell/plugins/steve/steve-class';
@@ -143,14 +143,27 @@ export default class ClusterRepo extends SteveModel {
     return this.metadata?.state?.name === 'active';
   }
 
+  get isSuseAppCollectionFromUI() {
+    return this.metadata?.annotations?.[CATALOG.SUSE_APP_COLLECTION];
+  }
+
+  get isSuseAppCollection() {
+    // Check annotation set by the UI or if the URL points to the SUSE App Collection registry
+    return this.isSuseAppCollectionFromUI || this.spec?.url?.startsWith('oci://dp.apps.rancher.io/charts');
+  }
+
   get typeDisplay() {
+    if (this.isSuseAppCollectionFromUI) {
+      return 'SUSE AppCo';
+    }
     if ( this.spec.gitRepo ) {
       return 'git';
-    } else if ( this.spec.url ) {
+    }
+    if ( this.spec.url ) {
       return this.isOciType ? 'oci' : 'http';
-    } else {
-      return '?';
     }
+
+    return '?';
   }
 
   get nameDisplay() {
@@ -220,4 +233,17 @@ export default class ClusterRepo extends SteveModel {
       });
     }, `catalog operation fetch`, timeout, interval);
   }
+
+  async save() {
+    // Add annotation only if the type is SUSE_APP_COLLECTION
+    if (this.spec.clientSecret?.name?.search(CLUSTER_REPO_APPCO_AUTH_GENERATE_NAME) === 0) {
+      if (!this.metadata.annotations) {
+        this.metadata.annotations = {};
+      }
+      this.metadata.annotations[CATALOG.SUSE_APP_COLLECTION] = 'true';
+    }
+
+    // Call the parent save method
+    return super.save();
+  }
 }

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

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

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

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

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

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

@@ -0,0 +1,48 @@
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class SteveToken extends SteveModel {
+  // for now, we are only showing the new tokens in the UI. Later we will be able to edit a few of it's fields
+  get _availableActions() {
+    return super._availableActions.filter((a) => ['viewInApi', 'promptRemove'].includes(a.action));
+  }
+
+  cleanForSave(data) {
+    const val = super.cleanForSave(data);
+
+    delete val.type;
+
+    return val;
+  }
+
+  get isDeprecated() {
+    return undefined;
+  }
+
+  get state() {
+    return this.isExpired ? 'expired' : !this.spec?.enabled ? 'inactive' : 'active';
+  }
+
+  get isExpired() {
+    return this.status?.expired;
+  }
+
+  get expiresAt() {
+    return this.status?.expiresAt || '';
+  }
+
+  get lastUsedAt() {
+    return this.status?.lastUsedAt || '';
+  }
+
+  get description() {
+    return this.spec?.description || '';
+  }
+
+  get clusterId() {
+    return this.spec?.clusterName || '';
+  }
+
+  get created() {
+    return this.metadata?.creationTimestamp;
+  }
+}