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

package/models/__tests__/workload.test.ts

@@ -1,6 +1,6 @@
 import Workload from '@shell/models/workload.js';
 import { steveClassJunkObject } from '@shell/plugins/steve/__tests__/utils/steve-mocks';
-import { WORKLOAD_TYPES, SERVICE } from '@shell/config/types';
+import { WORKLOAD_TYPES, SERVICE, INGRESS } from '@shell/config/types';
 
 describe('class: Workload', () => {
   describe('given custom workload keys', () => {
@@ -160,12 +160,7 @@ describe('class: Workload', () => {
   });
 
   describe('getter: relatedServices', () => {
-    it('should return services that match workload pods', () => {
-      const mockPod = {
-        metadata: {
-          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
-        }
-      };
+    it('should return services that match workload pod template labels', () => {
       const mockService = {
         metadata: { name: 'my-service', namespace: 'default' },
         spec:     { selector: { app: 'my-app' } }
@@ -173,7 +168,7 @@ describe('class: Workload', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.DEPLOYMENT,
         metadata: { name: 'test', namespace: 'default' },
-        spec:     {}
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
       }, {
         getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
         dispatch:    jest.fn(),
@@ -183,20 +178,12 @@ describe('class: Workload', () => {
         },
       });
 
-      // Mock pods getter
-      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
-
       const related = workload.relatedServices;
 
       expect(related).toContain(mockService);
     });
 
     it('should not return services from different namespace', () => {
-      const mockPod = {
-        metadata: {
-          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
-        }
-      };
       const mockService = {
         metadata: { name: 'my-service', namespace: 'other-namespace' },
         spec:     { selector: { app: 'my-app' } }
@@ -204,7 +191,7 @@ describe('class: Workload', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.DEPLOYMENT,
         metadata: { name: 'test', namespace: 'default' },
-        spec:     {}
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
       }, {
         getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
         dispatch:    jest.fn(),
@@ -214,19 +201,12 @@ describe('class: Workload', () => {
         },
       });
 
-      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
-
       const related = workload.relatedServices;
 
       expect(related).toHaveLength(0);
     });
 
     it('should not return services with non-matching selectors', () => {
-      const mockPod = {
-        metadata: {
-          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
-        }
-      };
       const mockService = {
         metadata: { name: 'my-service', namespace: 'default' },
         spec:     { selector: { app: 'different-app' } }
@@ -234,7 +214,7 @@ describe('class: Workload', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.DEPLOYMENT,
         metadata: { name: 'test', namespace: 'default' },
-        spec:     {}
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
       }, {
         getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
         dispatch:    jest.fn(),
@@ -244,7 +224,28 @@ describe('class: Workload', () => {
         },
       });
 
-      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+      const related = workload.relatedServices;
+
+      expect(related).toHaveLength(0);
+    });
+
+    it('should return empty array when pod template has no labels', () => {
+      const mockService = {
+        metadata: { name: 'my-service', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: {} } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      jest.fn(),
+          'cluster/all': (type: string) => (type === SERVICE ? [mockService] : [])
+        },
+      });
 
       const related = workload.relatedServices;
 
@@ -506,4 +507,378 @@ describe('class: Workload', () => {
       expect(jobsCard).toBeDefined();
     });
   });
+
+  describe('getter: matchingIngresses', () => {
+    const makeWorkload = (services: any[], ingresses: any[], pods: any[] = []) => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      jest.fn(),
+          'cluster/all': (type: string) => {
+            if (type === SERVICE) {
+              return services;
+            }
+            if (type === INGRESS) {
+              return ingresses;
+            }
+
+            return [];
+          }
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => pods });
+
+      return workload;
+    };
+
+    it('should return empty array when no related services', () => {
+      const workload = makeWorkload([], [
+        {
+          metadata: { namespace: 'default' },
+          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] }
+        }
+      ]);
+
+      expect(workload.matchingIngresses).toStrictEqual([]);
+    });
+
+    it('should find matching ingresses', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'default' },
+        spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] }
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(1);
+      expect(workload.matchingIngresses[0]).toStrictEqual(mockIngress);
+    });
+
+    it('should not match ingresses from other namespaces', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'other' },
+        spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] }
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(0);
+    });
+
+    it('should not match ingresses pointing to other services', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'default' },
+        spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc2' } } }] } }] }
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(0);
+    });
+
+    it('should handle ingresses with no rules', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'default' },
+        spec:     {}
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(0);
+    });
+
+    it('should handle ingress rules with no paths', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'default' },
+        spec:     { rules: [{ http: {} }] }
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(0);
+    });
+
+    it('should handle ingress paths with no backend service', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'default' },
+        spec:     { rules: [{ http: { paths: [{ backend: {} }] } }] }
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(0);
+    });
+
+    it('should find one of many ingresses', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const ingresses = [
+        {
+          metadata: { namespace: 'other' },
+          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] }
+        },
+        {
+          metadata: { namespace: 'default' },
+          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] }
+        },
+        {
+          metadata: { namespace: 'default' },
+          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc2' } } }] } }] }
+        }
+      ];
+
+      const workload = makeWorkload([mockService], ingresses, [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(1);
+      expect(workload.matchingIngresses[0]).toStrictEqual(ingresses[1]);
+    });
+  });
+
+  describe('getter: resourcesCardRows', () => {
+    it('should include services row when related services exist', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata:         { name: 'svc1', namespace: 'default' },
+        spec:             { selector: { app: 'my-app' } },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': (type: string) => {
+            if (type === SERVICE) {
+              return [mockService];
+            }
+
+            return [];
+          }
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const rows = workload.resourcesCardRows;
+      const servicesRow = rows.find((r: any) => r.label === 'component.resource.detail.card.resourcesCard.rows.services');
+
+      expect(servicesRow).toBeDefined();
+    });
+
+    it('should include ingresses row when matching ingresses exist', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata:         { name: 'svc1', namespace: 'default' },
+        spec:             { selector: { app: 'my-app' } },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+      const mockIngress = {
+        metadata:         { namespace: 'default' },
+        spec:             { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': (type: string) => {
+            if (type === SERVICE) {
+              return [mockService];
+            }
+            if (type === INGRESS) {
+              return [mockIngress];
+            }
+
+            return [];
+          }
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const rows = workload.resourcesCardRows;
+      const ingressesRow = rows.find((r: any) => r.label === 'component.resource.detail.card.resourcesCard.rows.ingresses');
+
+      expect(ingressesRow).toBeDefined();
+      expect(ingressesRow.to).toBe('#ingresses');
+    });
+
+    it('should order services before ingresses', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata:         { name: 'svc1', namespace: 'default' },
+        spec:             { selector: { app: 'my-app' } },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+      const mockIngress = {
+        metadata:         { namespace: 'default' },
+        spec:             { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': (type: string) => {
+            if (type === SERVICE) {
+              return [mockService];
+            }
+            if (type === INGRESS) {
+              return [mockIngress];
+            }
+
+            return [];
+          }
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const rows = workload.resourcesCardRows;
+
+      expect(rows[0].label).toBe('component.resource.detail.card.resourcesCard.rows.services');
+      expect(rows[1].label).toBe('component.resource.detail.card.resourcesCard.rows.ingresses');
+    });
+
+    it('should not include ingresses row when no matching ingresses', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata:         { name: 'svc1', namespace: 'default' },
+        spec:             { selector: { app: 'my-app' } },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': (type: string) => {
+            if (type === SERVICE) {
+              return [mockService];
+            }
+
+            return [];
+          }
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const rows = workload.resourcesCardRows;
+      const ingressesRow = rows.find((r: any) => r.label === 'component.resource.detail.card.resourcesCard.rows.ingresses');
+
+      expect(ingressesRow).toBeUndefined();
+    });
+  });
 });

package/models/catalog.cattle.io.clusterrepo.js

@@ -4,8 +4,10 @@ import { insertAt } from '@shell/utils/array';
 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 { _CREATE } from '@shell/config/query-params';
+import { formatDuration } from '@shell/utils/duration';
 
 import SteveModel from '@shell/plugins/steve/steve-class';
+import { SUSE_APPCO_DISPLAY_NAME } from '@shell/utils/fleet-appco';
 
 export default class ClusterRepo extends SteveModel {
   applyDefaults() {
@@ -183,7 +185,7 @@ export default class ClusterRepo extends SteveModel {
 
   get typeDisplay() {
     if (this.isSuseAppCollectionFromUI) {
-      return 'SUSE AppCo';
+      return SUSE_APPCO_DISPLAY_NAME;
     }
     if ( this.spec.gitRepo ) {
       return 'git';
@@ -218,15 +220,37 @@ export default class ClusterRepo extends SteveModel {
     return this.spec?.gitBranch || '(default)';
   }
 
+  get defaultRefreshIntervalHours() {
+    return this.isOciType ? 24 : 1;
+  }
+
+  get defaultRefreshInterval() {
+    return 60 * 60 * this.defaultRefreshIntervalHours;
+  }
+
+  get refreshIntervalDisplay() {
+    const val = this.spec?.refreshInterval;
+
+    if (val < 0) {
+      return this.t('generic.disabled');
+    }
+
+    return formatDuration(val ?? this.defaultRefreshInterval);
+  }
+
   get details() {
     return [
       {
-        label:   'Type',
+        label:   this.t('generic.type'),
         content: this.typeDisplay,
       },
       {
-        label:         'Downloaded',
-        content:       this.status.downloadTime,
+        label:   this.t('catalog.repo.refreshInterval.label'),
+        content: this.refreshIntervalDisplay,
+      },
+      {
+        label:         this.t('catalog.repo.downloaded.label'),
+        content:       this.status?.downloadTime,
         formatter:     'LiveDate',
         formatterOpts: { addSuffix: true },
       },

package/models/compliance.cattle.io.clusterscan.js

@@ -190,20 +190,54 @@ export default class ClusterScan extends SteveModel {
     return this.$dispatch('find', { type: COMPLIANCE.BENCHMARK, id: benchmarkId });
   }
 
+  // Fetches the kube-bench profile ConfigMap referenced by the benchmark and
+  // parses its metadata.yaml data key. Top-level fields become the XCCDF
+  // benchmark metadata; the checks: map becomes per-check decorations
+  // (framework-agnostic; STIG, CIS, BSI, etc. all populate the same shape).
+  async _resolveExportMetadata(benchmark) {
+    const name = benchmark?.spec?.customBenchmarkConfigMapName;
+    const namespace = benchmark?.spec?.customBenchmarkConfigMapNamespace;
+    const empty = { metadata: {}, decorations: {} };
+
+    if (!name || !namespace) {
+      return empty;
+    }
+
+    try {
+      const cm = await this.$dispatch('find', { type: 'configmap', id: `${ namespace }/${ name }` });
+      const raw = cm?.data?.['metadata.yaml'];
+
+      if (!raw) {
+        return empty;
+      }
+
+      const jsyaml = await import(/* webpackChunkName: "js-yaml" */'js-yaml');
+      const parsed = jsyaml.load(raw) || {};
+      const { checks = {}, ...rest } = parsed;
+
+      return { metadata: rest, decorations: checks };
+    } catch (e) {
+      console.error('[_resolveExportMetadata] failed to fetch or parse benchmark ConfigMap:', e); // eslint-disable-line no-console
+
+      return empty;
+    }
+  }
+
   async downloadLatestReportXCCDF() {
     const reports = await this.getReports() || [];
     const report = sortBy(reports, 'metadata.creationTimestamp', true)[0];
 
     try {
       const benchmark = await this._resolveBenchmark();
+      const { metadata, decorations } = await this._resolveExportMetadata(benchmark);
       const { generateXCCDFPerNode } = await import(/* webpackChunkName: "xccdf" */'@shell/utils/xccdf');
 
       const parsed = report.parsedReport || {};
       const common = {
         report:           parsed,
         benchmarkVersion: parsed.version || benchmark?.spec?.benchmarkVersion || '',
-        metadata:         benchmark?.spec?.benchmarkMetadata || {},
-        stigChecks:       benchmark?.spec?.stigChecks || {},
+        metadata,
+        decorations,
       };
 
       const toZip = {};
@@ -238,6 +272,7 @@ export default class ClusterScan extends SteveModel {
 
     try {
       const benchmark = await this._resolveBenchmark();
+      const { metadata, decorations } = await this._resolveExportMetadata(benchmark);
       const { generateXCCDFPerNode } = await import(/* webpackChunkName: "xccdf" */'@shell/utils/xccdf');
 
       const hasParsedNodes = reports.some((report) => Object.entries(report.parsedReport?.nodes || {}).length);
@@ -251,8 +286,8 @@ export default class ClusterScan extends SteveModel {
             const common = {
               report:           parsed,
               benchmarkVersion: parsed.version || benchmark?.spec?.benchmarkVersion || '',
-              metadata:         benchmark?.spec?.benchmarkMetadata || {},
-              stigChecks:       benchmark?.spec?.stigChecks || {},
+              metadata,
+              decorations,
             };
             const folder = labelFor(report);
 

package/models/fleet-application.js

@@ -30,6 +30,10 @@ function normalizeStateCounts(data) {
 }
 
 export default class FleetApplication extends SteveModel {
+  get applicationType() {
+    return this.kind;
+  }
+
   async getCurrentUser() {
     const user = this.$rootGetters['auth/user'];
 

package/models/fleet.cattle.io.helmop.js

@@ -4,10 +4,29 @@ import { set } from '@shell/utils/object';
 import { SOURCE_TYPE } from '@shell/config/product/fleet';
 import FleetUtils from '@shell/utils/fleet';
 import { FLEET } from '@shell/config/types';
-import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
+import { CATALOG, FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
 import FleetApplication from '@shell/models/fleet-application';
+import { SUSE_APP_COLLECTION_REPO_URL, SUSE_APPCO_DISPLAY_NAME } from '@shell/utils/fleet-appco';
 
 export default class HelmOp extends FleetApplication {
+  get isSuseAppCollectionFromUI() {
+    return !!this.metadata?.annotations?.[CATALOG.SUSE_APP_COLLECTION];
+  }
+
+  get isSuseAppCollection() {
+    // Annotation set by the UI on create, or fallback to URL check for older resources
+    return this.isSuseAppCollectionFromUI ||
+      (this.spec?.helm?.repo || '').startsWith(SUSE_APP_COLLECTION_REPO_URL);
+  }
+
+  get applicationType() {
+    if (this.isSuseAppCollectionFromUI) {
+      return SUSE_APPCO_DISPLAY_NAME;
+    }
+
+    return this.kind;
+  }
+
   applyDefaults() {
     const spec = this.spec || {};
     const meta = this.metadata || {};