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

package/mixins/__tests__/auth-config.test.ts

@@ -69,4 +69,94 @@ describe('mixin: authConfigMixin', () => {
       expect(instance.model.scope).toStrictEqual(scope);
     });
   });
+
+  describe('accessMode on enable', () => {
+    const FakeComponent = {
+      render() {},
+      mixins:  [authConfigMixin, childHook],
+      methods: { applyHooks: jest.fn() },
+    };
+
+    const createMock = (model: any, overrides: Record<string, any> = {}) => ({
+      data: () => ({
+        value: { configType: 'oidc' },
+        model,
+        ...overrides,
+      }),
+      computed: { principal: () => ({ me: {} }) },
+      global:   {
+        mocks: {
+          $store: { dispatch: () => model },
+          $route: {
+            params: { id: model.id || '123' },
+            query:  { mode: 'edit' },
+          },
+        }
+      }
+    });
+
+    it.each([
+      'github',
+      'githubapp',
+    ])('should default accessMode to restricted for %s on enable', async(id) => {
+      const model = {
+        id,
+        enabled:        false,
+        authConfigName: 'whatever',
+        doAction:       jest.fn(),
+        save:           jest.fn(),
+      };
+      const instance = mount(FakeComponent, createMock(model)).vm as any;
+
+      await instance.save(jest.fn());
+
+      expect(model.save).toHaveBeenCalled();
+      expect(instance.model.accessMode).toStrictEqual('required');
+    });
+
+    it('should default accessMode to unrestricted for non-github oauth on enable', async() => {
+      const model = {
+        id:             'googleoauth',
+        enabled:        false,
+        authConfigName: 'whatever',
+        doAction:       jest.fn(),
+        save:           jest.fn(),
+      };
+      const instance = mount(FakeComponent, createMock(model)).vm as any;
+
+      await instance.save(jest.fn());
+
+      expect(instance.model.accessMode).toStrictEqual('required');
+    });
+
+    it('should set accessMode to required after enabling a provider', async() => {
+      const model = {
+        enabled:        false,
+        accessMode:     'unrestricted',
+        authConfigName: 'whatever',
+        doAction:       jest.fn(),
+        save:           async() => {}
+      };
+      const instance = mount(FakeComponent, createMock(model)).vm as any;
+
+      await instance.save(jest.fn());
+
+      expect(instance.model.accessMode).toStrictEqual('required');
+    });
+
+    it('should not change accessMode when editing an already enabled provider', async() => {
+      const model = {
+        enabled:        true,
+        accessMode:     'unrestricted',
+        authConfigName: 'whatever',
+        doAction:       jest.fn(),
+        save:           async() => {}
+      };
+      const instance = mount(FakeComponent, createMock(model, { editConfig: true })).vm as any;
+
+      await instance.save(jest.fn());
+
+      expect(instance.model.accessMode).toStrictEqual('unrestricted');
+    });
+  });
 });

package/mixins/__tests__/chart.test.ts

@@ -214,6 +214,72 @@ describe('chartMixin', () => {
         id:   'custom-ns/custom-name'
       });
     });
+
+    it('should fall back to matchingInstalledApps when version namespace lookup fails', async() => {
+      const installedApp = {
+        id:   'other-ns/custom-name',
+        spec: { chart: { metadata: { version: '0.9.0' } } }
+      };
+
+      const mockStore = {
+        dispatch: jest.fn((action, payload) => {
+          if (action === 'cluster/find') {
+            return Promise.reject(new Error('not found'));
+          }
+
+          return Promise.resolve();
+        }),
+        getters: {
+          currentCluster: () => {},
+          isRancher:      () => true,
+          'catalog/repo': () => {
+            return () => 'repo';
+          },
+          'catalog/chart': () => {
+            return {
+              id:                    'chart-id',
+              versions:              [{ version: '1.0.0' }],
+              matchingInstalledApps: [installedApp]
+            };
+          },
+          'catalog/version': () => ({
+            version:     '1.0.0',
+            annotations: {
+              [CATALOG_ANNOTATIONS.NAMESPACE]:    'custom-ns',
+              [CATALOG_ANNOTATIONS.RELEASE_NAME]: 'custom-name',
+            }
+          }),
+          'prefs/get': () => {},
+          'i18n/t':    () => jest.fn()
+        }
+      };
+
+      const DummyComponent = {
+        mixins:   [ChartMixin],
+        template: '<div></div>',
+      };
+
+      const wrapper = mount(
+        DummyComponent,
+        {
+          global: {
+            mocks: {
+              $store: mockStore,
+              $route: {
+                query: {
+                  chart:       'chart_name',
+                  versionName: '1.0.0'
+                }
+              }
+            }
+          }
+        });
+
+      await wrapper.vm.fetchChart();
+
+      expect(wrapper.vm.existing).toStrictEqual(installedApp);
+      expect(wrapper.vm.mode).toStrictEqual('edit');
+    });
   });
 
   describe('action', () => {
@@ -366,6 +432,52 @@ describe('chartMixin', () => {
     });
   });
 
+  describe('isChartTargeted', () => {
+    const DummyComponent = {
+      mixins:   [ChartMixin],
+      template: '<div></div>',
+    };
+
+    const mockStore = {
+      dispatch: jest.fn(() => Promise.resolve()),
+      getters:  { 'i18n/t': (key: string) => key }
+    };
+
+    it('should return truthy when version annotations have both namespace and release-name', () => {
+      const wrapper = mount(DummyComponent, {
+        data: () => ({
+          version: {
+            annotations: {
+              [CATALOG_ANNOTATIONS.NAMESPACE]:    'custom-ns',
+              [CATALOG_ANNOTATIONS.RELEASE_NAME]: 'custom-name',
+            }
+          }
+        }),
+        global: { mocks: { $store: mockStore } }
+      });
+
+      expect(wrapper.vm.isChartTargeted).toBeTruthy();
+    });
+
+    it('should return falsy when version annotations are missing', () => {
+      const wrapper = mount(DummyComponent, {
+        data:   () => ({ version: { annotations: {} } }),
+        global: { mocks: { $store: mockStore } }
+      });
+
+      expect(wrapper.vm.isChartTargeted).toBeFalsy();
+    });
+
+    it('should return falsy when version is null', () => {
+      const wrapper = mount(DummyComponent, {
+        data:   () => ({ version: null }),
+        global: { mocks: { $store: mockStore } }
+      });
+
+      expect(wrapper.vm.isChartTargeted).toBeFalsy();
+    });
+  });
+
   describe('mappedVersions', () => {
     it('should return versions sorted by semver (descending)', () => {
       const versions = [
@@ -469,5 +581,99 @@ describe('chartMixin', () => {
         '0.0.1'
       ]);
     });
+
+    it('should correctly format current version when it is Linux-only', () => {
+      const versions = [
+        {
+          version:     '1.0.0',
+          created:     '2026-01-01',
+          annotations: { 'catalog.cattle.io/permits-os': 'linux' }
+        }
+      ];
+
+      const mockStore = {
+        dispatch: jest.fn(() => Promise.resolve()),
+        getters:  {
+          currentCluster:  () => ({ workerOSs: ['linux'] }),
+          isRancher:       () => true,
+          'catalog/repo':  () => () => 'repo',
+          'catalog/chart': () => ({ versions }),
+          'prefs/get':     () => () => true,
+          'i18n/t':        () => jest.fn()
+        }
+      };
+
+      const DummyComponent = {
+        mixins:   [ChartMixin],
+        template: '<div></div>',
+      };
+
+      const wrapper = mount(
+        DummyComponent,
+        {
+          data: () => ({
+            chart:    { versions },
+            existing: { spec: { chart: { metadata: { version: '1.0.0' } } } }
+          }),
+          global: {
+            mocks: {
+              $store: mockStore,
+              $route: { query: { version: '1.0.0' } },
+              t:      (key: string, args: any) => `${ args?.ver } (Current, Linux-only)`
+            }
+          }
+        });
+
+      const result = (wrapper.vm as any).mappedVersions;
+
+      expect(result[0].label).toBe('1.0.0 (Current, Linux-only)');
+    });
+
+    it('should correctly format current version when it is not OS-restricted', () => {
+      const versions = [
+        {
+          version:     '1.0.0',
+          created:     '2026-01-01',
+          annotations: {}
+        }
+      ];
+
+      const mockStore = {
+        dispatch: jest.fn(() => Promise.resolve()),
+        getters:  {
+          currentCluster:  () => ({ workerOSs: ['linux'] }),
+          isRancher:       () => true,
+          'catalog/repo':  () => () => 'repo',
+          'catalog/chart': () => ({ versions }),
+          'prefs/get':     () => () => true,
+          'i18n/t':        () => jest.fn()
+        }
+      };
+
+      const DummyComponent = {
+        mixins:   [ChartMixin],
+        template: '<div></div>',
+      };
+
+      const wrapper = mount(
+        DummyComponent,
+        {
+          data: () => ({
+            chart:    { versions },
+            existing: { spec: { chart: { metadata: { version: '1.0.0' } } } }
+          }),
+          global: {
+            mocks: {
+              $store: mockStore,
+              $route: { query: { version: '1.0.0' } },
+              t:      (key: string, args: any) => `${ args?.ver } (Current)`
+            }
+          }
+        });
+
+      const result = (wrapper.vm as any).mappedVersions;
+
+      expect(result[0].label).toBe('1.0.0 (Current)');
+    });
   });
 });

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/brand.js

@@ -183,7 +183,8 @@ export default {
     },
     setBodyClass() {
       const body = document.getElementsByTagName('body')[0];
-      const cssClass = `overflow-hidden dashboard-body`;
+      const isStandalone = this.$route?.meta?.standalone;
+      const cssClass = isStandalone ? 'dashboard-body' : 'overflow-hidden dashboard-body';
       let bodyClass = `theme-${ this.theme } ${ cssClass }`;
 
       if ( this.brand ) {

package/mixins/chart.js

@@ -13,7 +13,7 @@ import { CAPI, CATALOG } from '@shell/config/types';
 import { isPrerelease } from '@shell/utils/version';
 import { compareChartVersions } from '@shell/utils/chart';
 import difference from 'lodash/difference';
-import { LINUX, APP_UPGRADE_STATUS } from '@shell/store/catalog';
+import { APP_UPGRADE_STATUS, isRancherRepo, getPermittedOSs } from '@shell/store/catalog';
 import { clone } from '@shell/utils/object';
 import { merge } from 'lodash';
 
@@ -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,7 +86,9 @@ export default {
           keywords:        version.keywords
         };
 
-        const permittedSystems = (version?.annotations?.[CATALOG_ANNOTATIONS.PERMITTED_OS] || LINUX).split(',');
+        const permittedSystems = getPermittedOSs(version?.annotations, isRancher);
+
+        permittedSystemsByVersion.set(version.version, permittedSystems);
 
         if (permittedSystems.length > 0 && difference(OSs, permittedSystems).length > 0) {
           nue.disabled = true;
@@ -117,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;
@@ -271,7 +281,7 @@ export default {
     },
 
     isChartTargeted() {
-      return this.chart?.targetNamespace && this.chart?.targetName;
+      return this.version?.annotations?.[CATALOG_ANNOTATIONS.NAMESPACE] && this.version?.annotations?.[CATALOG_ANNOTATIONS.RELEASE_NAME];
     },
 
     hasQuestions() {
@@ -386,8 +396,8 @@ export default {
         // Use those values to check for a catalog app resource.
         // If found, set the form to edit mode. If not, set the
         // form to create mode.
-        // This is a hard blocker - installing a new instance is NOT allowed.
 
+        // This is a hard blocker - installing a new instance is NOT allowed.
         this.canInstallNew = false;
 
         try {
@@ -410,11 +420,10 @@ export default {
         if ( targetNamespace && targetName ) {
           // If the app name and namespace values are not provided in the
           // query, fall back on target values defined in the Helm chart itself.
-
           // Ask to install a special chart with fixed namespace/name
           // or edit it if there's an existing install.
-          // This is a hard blocker - installing a new instance is NOT allowed.
 
+          // This is a hard blocker - installing a new instance is NOT allowed.
           this.canInstallNew = false;
 
           try {
@@ -424,8 +433,12 @@ export default {
             });
             this.mode = _EDIT;
           } catch (e) {
-            this.mode = _CREATE;
-            this.existing = null;
+            // Version targets a different namespace than where the app is installed.
+            // Fall back to matching installed apps (e.g. chart detail page).
+            const matching = this.chart?.matchingInstalledApps || [];
+
+            this.existing = matching[0] || null;
+            this.mode = this.existing ? _EDIT : _CREATE;
           }
         } else {
           // Regular chart (not targeted) - check if there are installed instances.

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

@@ -1,14 +1,32 @@
 import { NAMESPACE_FILTER_NAMESPACED_YES, NAMESPACE_FILTER_NAMESPACED_NO, NAMESPACE_FILTER_ALL } from '@shell/utils/namespace-filter';
-import { NAMESPACE } from '@shell/config/types';
+import { MANAGEMENT, NAMESPACE } from '@shell/config/types';
 import { ALL_NAMESPACES } from '@shell/store/prefs';
 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
         ]
       });
@@ -248,7 +268,7 @@ export default {
     namespaceFilters: {
       immediate: true,
       async handler(neu, old) {
-        if (!this.canPaginate || !this.isNamespaced) {
+        if (!this.canPaginate || !this.isNamespaced || !this.currentProduct?.showNamespaceFilter) {
           return;
         }
 
@@ -283,7 +303,7 @@ export default {
           allNamespaces:                 this.$store.getters[`${ this.currentProduct?.inStore }/all`](NAMESPACE),
           selection:                     neu,
           isAllNamespaces:               this.isAllNamespaces,
-          isLocalCluster:                this.$store.getters['currentCluster'].isLocal,
+          isLocalCluster:                this.$store.getters['currentCluster']?.isLocal,
           showReservedRancherNamespaces: this.showDynamicRancherNamespaces,
           productHidesSystemNamespaces:  this.productHidesSystemNamespaces,
         });
@@ -354,15 +374,51 @@ export default {
 
   async beforeUnmount() {
     if (this.havePaginated) {
+      const store = this.overrideInStore || this.inStore;
       // of type @STEVE_WATCH_PARAMS
       const watchArgs = {
         type: this.resource,
         mode: STEVE_WATCH_MODE.RESOURCE_CHANGES,
       };
 
-      await this.$store.dispatch(`${ this.overrideInStore || this.inStore }/forgetType`, this.resource, (watchParams) => {
-        return watchParams.type === watchArgs.type && watchParams.mode === watchArgs.type.mode;
+      // Ensure that a resource remains in the store... and it's the same reference as before
+      // We'll do this for the mgmt cluster if there's a currentCluster set, otherwise we become unstuck
+      // (on nav we ensure currentCluster exists, but beforeUnmount fires afterwards, removing the cluster from pages that are using it)
+      const retainResource = this.resource === MANAGEMENT.CLUSTER && this.currentCluster ? this.currentCluster : null;
+
+      // Forget (unwatch, clear from store) the list's resource
+      await this.$store.dispatch(`${ store }/forgetType`, {
+        type:           this.resource,
+        compareWatches: (watchParams) => {
+          return watchParams.type === watchArgs.type && watchParams.mode === watchArgs.mode;
+        },
+        unwatch: true,
+        forget:  !retainResource
       });
+
+      if (!!retainResource) {
+        // The end state should be just like we've dispatched `${store}/find`
+
+        try {
+          // Clone to ensure we can load each property of A into B without worrying about them being the same reference
+          const clone = await this.$store.dispatch(`${ store }/clone`, { resource: retainResource });
+
+          // Load the resource. It's already in the store but this makes sure any legacy state (like havePage) is reset
+          await this.$store.dispatch(`${ store }/load`, {
+            data:                clone,
+            existing:            retainResource,
+            invalidatePageCache: true,
+          });
+
+          // Watch the resource.
+          await this.$store.dispatch(`${ store }/watch`, {
+            type: this.resource,
+            id:   retainResource.id,
+          });
+        } catch (error) {
+          console.error('Error occurred whilst trying to retain the management cluster in cache and correctly watched', error); // eslint-disable-line no-console
+        }
+      }
     }
   }
 };