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

package/mixins/__tests__/resource-fetch-api-pagination.test.ts

@@ -0,0 +1,48 @@
+import { parseStateFilter } from '@shell/mixins/resource-fetch-api-pagination';
+import { PaginationFilterEquality } from '@shell/types/store/pagination.types';
+
+describe('parseStateFilter', () => {
+  it('should return null for null input', () => {
+    expect(parseStateFilter(null)).toBeNull();
+  });
+
+  it('should return null for undefined input', () => {
+    expect(parseStateFilter(undefined)).toBeNull();
+  });
+
+  it('should return null for empty string', () => {
+    expect(parseStateFilter('')).toBeNull();
+  });
+
+  it('should parse a single state', () => {
+    const result = parseStateFilter('running');
+
+    expect(result).toHaveLength(1);
+    expect(result?.[0].field).toStrictEqual('metadata.state.name');
+    expect(result?.[0].value).toStrictEqual('running');
+    expect(result?.[0].equality).toStrictEqual(PaginationFilterEquality.IN);
+  });
+
+  it('should parse multiple comma-separated states', () => {
+    const result = parseStateFilter('running,active');
+
+    expect(result).toHaveLength(1);
+    expect(result?.[0].field).toStrictEqual('metadata.state.name');
+    expect(result?.[0].value).toStrictEqual('running,active');
+    expect(result?.[0].equality).toStrictEqual(PaginationFilterEquality.IN);
+  });
+
+  it('should parse three comma-separated states', () => {
+    const result = parseStateFilter('running,active,waiting');
+
+    expect(result).toHaveLength(1);
+    expect(result?.[0].value).toStrictEqual('running,active,waiting');
+  });
+
+  it('should ignore empty segments from trailing commas', () => {
+    const result = parseStateFilter('running,,active,');
+
+    expect(result).toHaveLength(1);
+    expect(result?.[0].value).toStrictEqual('running,active');
+  });
+});

package/mixins/auth-config.js

@@ -201,6 +201,9 @@ export default {
             if (!this.model.accessMode) {
               this.model.accessMode = 'unrestricted';
             }
+            if (this.model.id === 'github' || this.model.id === 'githubapp') {
+              this.model.accessMode = 'restricted';
+            }
             await this.model.doAction('testAndApply', obj, { redirectUnauthorized: false });
           }
 
@@ -241,6 +244,10 @@ export default {
           } else {
             console.warn(`Unable to find principal marked as 'me'`); // eslint-disable-line no-console
           }
+
+          if (!wasEnabled) {
+            this.model.accessMode = 'required';
+          }
         }
         if (wasEnabled && configType === 'oauth') {
           await this.model.save({ ignoreFields: ['oauthCredential', 'serviceAccountCredential'] } );

package/mixins/chart.js

@@ -71,6 +71,8 @@ export default {
 
       const selectedVersion = this.targetVersion;
       const OSs = this.currentCluster?.workerOSs;
+      const isRancher = isRancherRepo(this.repo, this.chart);
+      const permittedSystemsByVersion = new Map();
       const out = [];
 
       versions.forEach((version) => {
@@ -84,9 +86,10 @@ export default {
           keywords:        version.keywords
         };
 
-        const isRancher = isRancherRepo(this.repo, this.chart);
         const permittedSystems = getPermittedOSs(version?.annotations, isRancher);
 
+        permittedSystemsByVersion.set(version.version, permittedSystems);
+
         if (permittedSystems.length > 0 && difference(OSs, permittedSystems).length > 0) {
           nue.disabled = true;
         }
@@ -118,7 +121,13 @@ export default {
       const currentVersion = out.find((v) => v.originalVersion === this.currentVersion);
 
       if (currentVersion) {
-        currentVersion.label = this.t('catalog.install.versions.current', { ver: this.currentVersion });
+        const permittedSystems = permittedSystemsByVersion.get(currentVersion.originalVersion) || [];
+
+        if (permittedSystems.length === 1) {
+          currentVersion.label = this.t(`catalog.install.versions.current_${ permittedSystems[0] }`, { ver: this.currentVersion });
+        } else {
+          currentVersion.label = this.t('catalog.install.versions.current', { ver: this.currentVersion });
+        }
       }
 
       return out;

package/mixins/child-hook.js

@@ -8,20 +8,26 @@ export const AFTER_SAVE_HOOKS = '_afterSaveHooks';
 
 export default {
   methods: {
+    registerHook(key, boundFn, name, priority = 99, boundFnContext) {
+      this._registerHook(key, boundFn, name, priority, boundFnContext);
+    },
+
     registerBeforeHook(boundFn, name, priority = 99, boundFnContext) {
-      this._registerHook(BEFORE_SAVE_HOOKS, boundFn, name, priority, boundFnContext);
+      this.registerHook(BEFORE_SAVE_HOOKS, boundFn, name, priority, boundFnContext);
     },
 
-    unregisterBeforeSaveHook(name) {
-      this[BEFORE_SAVE_HOOKS] = this[BEFORE_SAVE_HOOKS].filter((hook) => {
-        // BEFORE_SAVE_HOOKS is an array of objects with keys
-        // fn, name and priority.
+    unregisterHook(key, name) {
+      this[key] = (this[key] || []).filter((hook) => {
         return hook.name !== name;
       });
     },
 
+    unregisterBeforeSaveHook(name) {
+      this.unregisterHook(BEFORE_SAVE_HOOKS, name);
+    },
+
     registerAfterHook(boundFn, name, priority = 99, boundFnContext) {
-      this._registerHook(AFTER_SAVE_HOOKS, boundFn, name, priority, boundFnContext);
+      this.registerHook(AFTER_SAVE_HOOKS, boundFn, name, priority, boundFnContext);
     },
 
     async applyHooks(key, ...args) {

package/mixins/create-edit-view/impl.js

@@ -1,6 +1,6 @@
 import { _CREATE, _EDIT, _VIEW } from '@shell/config/query-params';
 import { LAST_NAMESPACE } from '@shell/store/prefs';
-import { exceptionToErrorsArray } from '@shell/utils/error';
+import { exceptionToErrorsArray, isDoNotLogError } from '@shell/utils/error';
 import ChildHook, { BEFORE_SAVE_HOOKS, AFTER_SAVE_HOOKS } from '@shell/mixins/child-hook';
 import { clear } from '@shell/utils/array';
 import { DEFAULT_WORKSPACE } from '@shell/config/types';
@@ -184,8 +184,10 @@ export default {
         } else {
           this.errors = exceptionToErrorsArray(err);
         }
-        // Provide a stack trace for easier debugging of save errors
-        console.error('CreateEditView mixin failed to save: ', err); // eslint-disable-line no-console
+        if (!isDoNotLogError(err)) {
+          // Provide a stack trace for easier debugging of save errors
+          console.error('CreateEditView mixin failed to save: ', err); // eslint-disable-line no-console
+        }
         buttonDone && buttonDone(false);
       }
     },

package/mixins/resource-fetch-api-pagination.js

@@ -5,10 +5,28 @@ import { mapGetters } from 'vuex';
 import { ResourceListComponentName } from '../components/ResourceList/resource-list.config';
 import paginationUtils from '@shell/utils/pagination-utils';
 import debounce from 'lodash/debounce';
-import { PaginationParamFilter, PaginationFilterField, PaginationArgs } from '@shell/types/store/pagination.types';
+import { PaginationParamFilter, PaginationFilterField, PaginationFilterEquality, PaginationArgs } from '@shell/types/store/pagination.types';
 import stevePaginationUtils from '@shell/plugins/steve/steve-pagination-utils';
 import { STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
 
+export function parseStateFilter(stateFilter) {
+  if (!stateFilter) {
+    return null;
+  }
+
+  const states = stateFilter.split(',').filter(Boolean);
+
+  if (!states.length) {
+    return null;
+  }
+
+  return [new PaginationFilterField({
+    field:    'metadata.state.name',
+    value:    states.join(','),
+    equality: PaginationFilterEquality.IN,
+  })];
+}
+
 /**
  * Companion mixin used with `resource-fetch` for `ResourceList` to determine if the user needs to filter the list by a single namespace
  */
@@ -75,6 +93,7 @@ export default {
       const {
         page, perPage, filter, sort, descending
       } = event;
+      const stateFilters = parseStateFilter(this.$route?.query?.stateFilter) || [];
       const searchFilters = filter.searchQuery ? filter.searchFields.map((field) => new PaginationFilterField({
         field,
         value: filter.searchQuery,
@@ -91,6 +110,7 @@ export default {
         projectsOrNamespaces: this.requestFilters.projectsOrNamespaces,
         filters:              [
           new PaginationParamFilter({ fields: searchFilters }),
+          new PaginationParamFilter({ fields: stateFilters }),
           ...this.requestFilters.filters, // Apply the additional filters. these aren't from the user but from ns filtering
         ]
       });

package/models/__tests__/catalog.cattle.io.clusterrepo.test.ts

@@ -17,6 +17,7 @@ describe('clusterRepo', () => {
     jest.spyOn(model, 'save').mockImplementation().mockResolvedValue(true);
     jest.spyOn(model, 'waitForState').mockImplementation().mockResolvedValue(true);
     jest.spyOn(model, '$dispatch', 'get').mockReturnValue(jest.fn());
+    jest.spyOn(model, 't', 'get').mockReturnValue((key: string) => key);
   });
 
   describe('refresh', () => {
@@ -59,6 +60,62 @@ describe('clusterRepo', () => {
     });
   });
 
+  describe('defaultRefreshIntervalHours', () => {
+    it('returns 24 for OCI repos', () => {
+      model.spec.url = 'oci://example.com/chart';
+      model.spec.insecurePlainHttp = false;
+      expect(model.defaultRefreshIntervalHours).toStrictEqual(24);
+    });
+
+    it('returns 1 for git repos', () => {
+      model.spec = { gitRepo: 'https://github.com/example/charts' };
+      expect(model.defaultRefreshIntervalHours).toStrictEqual(1);
+    });
+
+    it('returns 1 for helm repos', () => {
+      model.spec = { url: 'https://charts.example.com' };
+      expect(model.defaultRefreshIntervalHours).toStrictEqual(1);
+    });
+  });
+
+  describe('defaultRefreshInterval', () => {
+    it('returns seconds for OCI repos (24 hours)', () => {
+      model.spec.url = 'oci://example.com/chart';
+      model.spec.insecurePlainHttp = false;
+      expect(model.defaultRefreshInterval).toStrictEqual(86400);
+    });
+
+    it('returns seconds for non-OCI repos (1 hour)', () => {
+      model.spec = { gitRepo: 'https://github.com/example/charts' };
+      expect(model.defaultRefreshInterval).toStrictEqual(3600);
+    });
+  });
+
+  describe('refreshIntervalDisplay', () => {
+    it.each([
+      -1,
+      -100,
+    ])('returns "Disabled" when value is %p', (val) => {
+      model.spec.refreshInterval = val;
+      expect(model.refreshIntervalDisplay).toStrictEqual('generic.disabled');
+    });
+
+    it('returns formatted duration for positive values', () => {
+      model.spec.refreshInterval = 3661;
+      expect(model.refreshIntervalDisplay).toStrictEqual('1h 1m 1s');
+    });
+
+    it('returns default formatted duration when not set', () => {
+      model.spec = { url: 'https://charts.example.com' };
+      expect(model.refreshIntervalDisplay).toStrictEqual('1h');
+    });
+
+    it('returns default formatted duration for OCI when not set', () => {
+      model.spec = { url: 'oci://example.com/chart', insecurePlainHttp: false };
+      expect(model.refreshIntervalDisplay).toStrictEqual('1d');
+    });
+  });
+
   describe('refreshBulk', () => {
     it('calls refresh(false) on all items and then dispatches a single catalog/load with all repoKeys', async() => {
       const mockItem1 = {

package/models/__tests__/compliance.cattle.io.clusterscan.test.ts

@@ -0,0 +1,144 @@
+import ClusterScan from '@shell/models/compliance.cattle.io.clusterscan';
+
+/**
+ * Build a ClusterScan model wired to a mocked store `dispatch`.
+ * `$dispatch` resolves to `this.$ctx.dispatch`, so injecting it via the
+ * constructor context is enough to exercise `_resolveExportMetadata`.
+ */
+const makeScan = (dispatch: jest.Mock) => new ClusterScan({}, {
+  getters:     {},
+  rootGetters: {},
+  dispatch,
+} as any) as any;
+
+const benchmarkWithConfigMap = {
+  spec: {
+    customBenchmarkConfigMapName:      'metadata-cm',
+    customBenchmarkConfigMapNamespace: 'compliance',
+  },
+};
+
+describe('class: ClusterScan', () => {
+  describe('method: _resolveExportMetadata', () => {
+    it('returns empty metadata and decorations when the benchmark is undefined', async() => {
+      const dispatch = jest.fn();
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(undefined);
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+      expect(dispatch).not.toHaveBeenCalled();
+    });
+
+    it('returns empty when the ConfigMap name is missing', async() => {
+      const dispatch = jest.fn();
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata({ spec: { customBenchmarkConfigMapNamespace: 'compliance' } });
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+      expect(dispatch).not.toHaveBeenCalled();
+    });
+
+    it('returns empty when the ConfigMap namespace is missing', async() => {
+      const dispatch = jest.fn();
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata({ spec: { customBenchmarkConfigMapName: 'metadata-cm' } });
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+      expect(dispatch).not.toHaveBeenCalled();
+    });
+
+    it('fetches the ConfigMap by namespace/name from the configmap type', async() => {
+      const dispatch = jest.fn().mockResolvedValue({ data: {} });
+      const scan = makeScan(dispatch);
+
+      await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(dispatch).toHaveBeenCalledWith('find', { type: 'configmap', id: 'compliance/metadata-cm' });
+    });
+
+    it('returns empty when the ConfigMap has no metadata.yaml data key', async() => {
+      const dispatch = jest.fn().mockResolvedValue({ data: { 'other.yaml': 'title: x' } });
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+    });
+
+    it('returns empty when the ConfigMap itself is not found', async() => {
+      const dispatch = jest.fn().mockResolvedValue(undefined);
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+    });
+
+    it('splits top-level fields into metadata and the checks map into decorations', async() => {
+      const yaml = [
+        'title: CIS Kubernetes Benchmark',
+        'description: A CIS profile',
+        'referenceType: cis',
+        'checks:',
+        '  "5.1.1":',
+        '    ruleId: CIS-5.1.1-rule',
+        '    severity: high',
+        '    idents:',
+        '      - system: https://www.cisecurity.org/controls/',
+        '        value: CIS-CSC-3',
+        '  "5.1.2":',
+        '    ruleId: CIS-5.1.2-rule',
+      ].join('\n');
+      const dispatch = jest.fn().mockResolvedValue({ data: { 'metadata.yaml': yaml } });
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result.metadata).toStrictEqual({
+        title:         'CIS Kubernetes Benchmark',
+        description:   'A CIS profile',
+        referenceType: 'cis',
+      });
+      expect(result.decorations).toStrictEqual({
+        '5.1.1': {
+          ruleId:   'CIS-5.1.1-rule',
+          severity: 'high',
+          idents:   [{ system: 'https://www.cisecurity.org/controls/', value: 'CIS-CSC-3' }],
+        },
+        '5.1.2': { ruleId: 'CIS-5.1.2-rule' },
+      });
+    });
+
+    it('returns empty decorations when metadata.yaml has no checks map', async() => {
+      const yaml = ['title: STIG', 'source: disa'].join('\n');
+      const dispatch = jest.fn().mockResolvedValue({ data: { 'metadata.yaml': yaml } });
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result.metadata).toStrictEqual({ title: 'STIG', source: 'disa' });
+      expect(result.decorations).toStrictEqual({});
+    });
+
+    it('returns empty when the ConfigMap lookup rejects', async() => {
+      const dispatch = jest.fn().mockRejectedValue(new Error('not found'));
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+    });
+
+    it('returns empty when metadata.yaml is malformed YAML', async() => {
+      const dispatch = jest.fn().mockResolvedValue({ data: { 'metadata.yaml': 'title: "unterminated' } });
+      const scan = makeScan(dispatch);
+
+      const result = await scan._resolveExportMetadata(benchmarkWithConfigMap);
+
+      expect(result).toStrictEqual({ metadata: {}, decorations: {} });
+    });
+  });
+});

package/models/__tests__/fleet-application.test.ts

@@ -0,0 +1,175 @@
+import FleetApplication from '@shell/models/fleet-application.js';
+
+describe('class FleetApplication', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('applicationType', () => {
+    it('should return the kind property', () => {
+      const instance = new FleetApplication({ kind: 'GitRepo' });
+
+      expect(instance.applicationType).toStrictEqual('GitRepo');
+    });
+  });
+
+  describe('targetClusters', () => {
+    function createFleetApplication(targets: any[] | undefined, clusters: any[], workspaceId = 'fleet-default', groups: any[] = []) {
+      const workspace = {
+        id:            workspaceId,
+        clusters,
+        clusterGroups: groups,
+      };
+
+      jest.spyOn(FleetApplication.prototype, '$getters', 'get').mockReturnValue({ byId: () => workspace });
+
+      return new FleetApplication({
+        metadata: { namespace: workspaceId },
+        spec:     { targets },
+      });
+    }
+
+    it.each([
+      [
+        'metadata.name',
+        [{ clusterName: 'c-m-abc123' }],
+        [{
+          id: 'fleet-default/c-m-abc123', metadata: { name: 'c-m-abc123' }, nameDisplay: 'my-cluster'
+        }],
+        [{
+          id: 'fleet-default/c-m-abc123', metadata: { name: 'c-m-abc123' }, nameDisplay: 'my-cluster'
+        }],
+      ],
+      [
+        'nameDisplay when metadata.name does not match',
+        [{ clusterName: 'my-display-name' }],
+        [{
+          id: 'fleet-default/c-m-abc123', metadata: { name: 'c-m-abc123' }, nameDisplay: 'my-display-name'
+        }],
+        [{
+          id: 'fleet-default/c-m-abc123', metadata: { name: 'c-m-abc123' }, nameDisplay: 'my-display-name'
+        }],
+      ],
+    ])('should find cluster by %s', (_label, targets, clusters, expected) => {
+      const app = createFleetApplication(targets, clusters);
+
+      expect(app.targetClusters).toStrictEqual(expected);
+    });
+
+    it('should prefer metadata.name match over nameDisplay match', () => {
+      const clusters = [
+        {
+          id:          'fleet-default/exact-match',
+          metadata:    { name: 'exact-match' },
+          nameDisplay: 'display-a',
+        },
+        {
+          id:          'fleet-default/c-m-other',
+          metadata:    { name: 'c-m-other' },
+          nameDisplay: 'exact-match',
+        }
+      ];
+
+      const app = createFleetApplication([{ clusterName: 'exact-match' }], clusters);
+
+      expect(app.targetClusters).toStrictEqual([clusters[0]]);
+    });
+
+    it('should return empty array when no cluster matches by name or nameDisplay', () => {
+      const clusters = [
+        {
+          id:          'fleet-default/c-m-abc123',
+          metadata:    { name: 'c-m-abc123' },
+          nameDisplay: 'my-cluster',
+        }
+      ];
+
+      const app = createFleetApplication([{ clusterName: 'non-existent' }], clusters);
+
+      expect(app.targetClusters).toStrictEqual([]);
+    });
+
+    it('should handle multiple targets with mixed name and nameDisplay matches', () => {
+      const clusters = [
+        {
+          id:          'fleet-default/c-m-abc123',
+          metadata:    { name: 'c-m-abc123' },
+          nameDisplay: 'cluster-alpha',
+        },
+        {
+          id:          'fleet-default/c-m-def456',
+          metadata:    { name: 'c-m-def456' },
+          nameDisplay: 'cluster-beta',
+        }
+      ];
+
+      const targets = [
+        { clusterName: 'c-m-abc123' },
+        { clusterName: 'cluster-beta' },
+      ];
+
+      const app = createFleetApplication(targets, clusters);
+
+      expect(app.targetClusters).toStrictEqual([clusters[0], clusters[1]]);
+    });
+
+    it('should return empty array when targets is empty', () => {
+      const app = createFleetApplication([], []);
+
+      expect(app.targetClusters).toStrictEqual([]);
+    });
+
+    it('should return empty array when targets is undefined', () => {
+      const app = createFleetApplication(undefined, []);
+
+      expect(app.targetClusters).toStrictEqual([]);
+    });
+
+    it('should return empty array when workspace has no clusters', () => {
+      const app = createFleetApplication([{ clusterName: 'any-name' }], []);
+
+      expect(app.targetClusters).toStrictEqual([]);
+    });
+
+    it('should handle cluster with undefined nameDisplay gracefully', () => {
+      const clusters = [
+        {
+          id:          'fleet-default/c-m-abc123',
+          metadata:    { name: 'c-m-abc123' },
+          nameDisplay: undefined,
+        }
+      ];
+
+      const app = createFleetApplication([{ clusterName: 'c-m-abc123' }], clusters);
+
+      expect(app.targetClusters).toStrictEqual([clusters[0]]);
+    });
+
+    it('should return local cluster targets when workspace is fleet-local', () => {
+      const localTargetClusters = [
+        {
+          id:          'fleet-local/local',
+          metadata:    { name: 'local' },
+          nameDisplay: 'local',
+        }
+      ];
+
+      const groups = [
+        {
+          id:             'fleet-local/default',
+          targetClusters: localTargetClusters,
+        }
+      ];
+
+      const app = createFleetApplication([], [], 'fleet-local', groups);
+
+      expect(app.targetClusters).toStrictEqual(localTargetClusters);
+    });
+
+    it('should return empty array when workspace is fleet-local and default group is missing', () => {
+      const app = createFleetApplication([], [], 'fleet-local', []);
+
+      expect(app.targetClusters).toStrictEqual([]);
+    });
+  });
+});