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

package/models/__tests__/rke-machine.cattle.io.vmwarevspheremachinetemplate.test.ts

@@ -0,0 +1,22 @@
+import VmwarevsphereMachineTemplate from '@shell/models/rke-machine.cattle.io.vmwarevspheremachinetemplate';
+
+describe('class VmwarevsphereMachineTemplate', () => {
+  describe('providerLocation', () => {
+    it.each([
+      ['/DC1/host/ClusterA/Resources', 'ClusterA'],
+      ['/DC1/host/ClusterA/Resources/PoolX', 'ClusterA'],
+      ['/DC1/host/ClusterA/Resources/', 'ClusterA'],
+      ['/DC1/host/esxi01/Resources', 'esxi01'],
+      ['/DC1/vm/FolderA', null],
+      ['/DC1/host/foo/ResourcesPool/bar', null],
+      ['/DC1/host//Resources/PoolX', null],
+      ['', null],
+      [null, null],
+      [undefined, null],
+    ])('returns %p for pool %p', (pool: string | null | undefined, expected: string | null) => {
+      const machineTemplate = new VmwarevsphereMachineTemplate({ spec: { template: { spec: { pool } } } });
+
+      expect(machineTemplate.providerLocation).toStrictEqual(expected);
+    });
+  });
+});

package/models/namespace.js

@@ -2,12 +2,15 @@ import SYSTEM_NAMESPACES from '@shell/config/system-namespaces';
 import {
   PROJECT, SYSTEM_NAMESPACE, ISTIO as ISTIO_LABELS, FLEET, RESOURCE_QUOTA
 } from '@shell/config/labels-annotations';
-import { ISTIO, MANAGEMENT } from '@shell/config/types';
+import { ISTIO, MANAGEMENT, LOCAL_CLUSTER } from '@shell/config/types';
 
 import { get, set } from '@shell/utils/object';
 import { insertAt, isArray } from '@shell/utils/array';
 import SteveModel from '@shell/plugins/steve/steve-class';
 import { HARVESTER_NAME as HARVESTER } from '@shell/config/features';
+import { NAME as MANAGER } from '@shell/config/product/manager';
+import { NAME as EXPLORER } from '@shell/config/product/explorer';
+import sideNavService from '@shell/components/nav/TopLevelMenu.helper';
 import { hasPSALabels, getPSATooltipsDescription, getPSALabels } from '@shell/utils/pod-security-admission';
 import { PSAIconsDisplay, PSALabelsNamespaceVersion } from '@shell/config/pod-security-admission';
 
@@ -188,7 +191,14 @@ export default class Namespace extends SteveModel {
   }
 
   get listLocation() {
-    const listLocation = { name: this.$rootGetters['isRancher'] ? 'c-cluster-product-projectsnamespaces' : 'c-cluster-product-resource' };
+    const productId = this.$rootGetters['productId'];
+    const isManagerProduct = productId === MANAGER;
+    const cluster = isManagerProduct ? LOCAL_CLUSTER : this.$rootGetters['clusterId'];
+
+    const listLocation = {
+      name:   this.$rootGetters['isRancher'] ? 'c-cluster-product-projectsnamespaces' : 'c-cluster-product-resource',
+      params: { cluster, product: EXPLORER },
+    };
 
     // Harvester uses these resource directly... but has different routes. listLocation covers routes leading back to route
     if (this.$rootGetters['currentProduct'].inStore === HARVESTER) {
@@ -202,6 +212,12 @@ export default class Namespace extends SteveModel {
   get _detailLocation() {
     const _detailLocation = super._detailLocation;
 
+    // Namespace detail pages belong to the local cluster's explorer, not Cluster Management
+    if (this.$rootGetters['productId'] === MANAGER) {
+      _detailLocation.params.cluster = LOCAL_CLUSTER;
+      _detailLocation.params.product = EXPLORER;
+    }
+
     return _detailLocation;
   }
 
@@ -285,6 +301,22 @@ export default class Namespace extends SteveModel {
       glance.splice(namespaceIndex, 1, this.projectGlance);
     }
 
+    // In Cluster Management, the type link points to the local cluster's explorer.
+    // If the user cannot access the local cluster, show type as plain text.
+    const productId = this.$rootGetters['productId'];
+
+    if (productId === MANAGER) {
+      const hasLocalCluster = sideNavService.helper.clustersPinned.some((c) => c.id === LOCAL_CLUSTER) ||
+        sideNavService.helper.clustersOthers.some((c) => c.id === LOCAL_CLUSTER);
+      const typeIndex = glance.findIndex((item) => item.name === 'type');
+
+      if (!hasLocalCluster && typeIndex > -1) {
+        glance[typeIndex] = {
+          ...glance[typeIndex], formatter: undefined, formatterOpts: undefined
+        };
+      }
+    }
+
     // projectGlance could be undefined
     return glance.filter(Boolean);
   }

package/models/pod.js

@@ -309,19 +309,21 @@ export default class Pod extends WorkloadService {
   save() {
     const prev = { ...this };
 
-    const { metadata, spec } = this.spec.template;
+    if (this.spec?.template) {
+      const { metadata, spec } = this.spec.template;
 
-    this.spec = {
-      ...this.spec,
-      ...spec
-    };
+      this.spec = {
+        ...this.spec,
+        ...spec
+      };
 
-    this.metadata = {
-      ...this.metadata,
-      ...metadata
-    };
+      this.metadata = {
+        ...this.metadata,
+        ...metadata
+      };
 
-    delete this.spec.template;
+      delete this.spec.template;
+    }
 
     // IF there is an error POD world model get overwritten
     // For the workloads this need be reset back

package/models/provisioning.cattle.io.cluster.js

@@ -3,6 +3,8 @@ import {
   CONFIG_MAP, AUTOSCALER_CONFIG_MAP_ID,
   EVENT, OPERATION
 } from '@shell/config/types';
+import { NAME as EXPLORER } from '@shell/config/product/explorer';
+import sideNavService from '@shell/components/nav/TopLevelMenu.helper';
 import SteveModel from '@shell/plugins/steve/steve-class';
 import { findBy } from '@shell/utils/array';
 import { get, set } from '@shell/utils/object';
@@ -788,21 +790,26 @@ export default class ProvCluster extends SteveModel {
   }
 
   get namespaceLocation() {
-    const localCluster = this.$rootGetters['management/byId'](MANAGEMENT.CLUSTER, LOCAL_CLUSTER);
-
-    if (localCluster) {
-      return {
-        name:   'c-cluster-product-resource-id',
-        params: {
-          cluster:  localCluster.id,
-          product:  this.$rootGetters['productId'],
-          resource: NAMESPACE,
-          id:       this.namespace
-        }
-      };
+    // Check side nav for local cluster access — `management/byId` only reflects what's
+    // currently cached, which on a downstream detail page is just the downstream cluster
+    // (so admins would falsely look like they have no local access). The side nav reflects
+    // permission, not cache state, so it's accurate for both admins and downstream-only users.
+    const hasLocalCluster = sideNavService.helper.clustersPinned.some((c) => c.id === LOCAL_CLUSTER) ||
+      sideNavService.helper.clustersOthers.some((c) => c.id === LOCAL_CLUSTER);
+
+    if (!hasLocalCluster) {
+      return null;
     }
 
-    return null;
+    return {
+      name:   'c-cluster-product-resource-id',
+      params: {
+        cluster:  LOCAL_CLUSTER,
+        product:  EXPLORER,
+        resource: NAMESPACE,
+        id:       this.namespace
+      }
+    };
   }
 
   /**

package/models/rke-machine.cattle.io.vmwarevspheremachinetemplate.js

@@ -1,11 +1,20 @@
 import { formatSi } from '@shell/utils/units';
 import MachineTemplate from './rke-machine.cattle.io.machinetemplate';
 
+const POOL_LOCATION_MATCHER = /\/host\/([^/]+)\/Resources(?:\/|$)/;
+
 export default class VmwarevsphereMachineTemplate extends MachineTemplate {
   get provider() {
     return 'vmwarevsphere';
   }
 
+  get providerLocation() {
+    const pool = this.spec?.template?.spec?.pool;
+    const match = pool?.match(POOL_LOCATION_MATCHER);
+
+    return match?.[1] || null;
+  }
+
   get providerSize() {
     const size = formatSi(this.spec.template.spec.memorySize * 1048576, 1024, 'iB');
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rancher/shell",
-  "version": "3.0.12-rc.5",
+  "version": "3.0.12-rc.7",
   "description": "Rancher Dashboard Shell",
   "repository": "https://github.com/rancher/dashboard",
   "license": "Apache-2.0",

package/pages/auth/login.vue

@@ -177,7 +177,7 @@ export default {
     this.vendor = getVendor();
     this.providers = providers;
     this.hasLocal = hasLocal;
-    this.showLocal = !hasOthers || (this.$route.query[LOCAL] === _FLAGGED);
+    this.showLocal = hasLocal && (!hasOthers || (this.$route.query[LOCAL] === _FLAGGED));
     this.customLoginError = JSON.parse(value).loginError;
     this.firstLogin = firstLoginSetting?.value === 'true';
     this.username = this.firstLogin ? 'admin' : this.username;

package/pages/c/_cluster/apps/charts/__tests__/install.test.ts

@@ -522,4 +522,114 @@ describe('page: Install', () => {
       expect(wrapper.vm.registryPullSecret).toBeNull();
     });
   });
+
+  describe('computed properties: monitoring banners', () => {
+    const setupComponent = (existing: any, releaseName: string, componentName: string, chartName: string, installedApps: any[] = [], certified = 'rancher') => {
+      const mockStore = {
+        getters: {
+          'i18n/withFallback':       () => '',
+          'catalog/inStore':         'cluster',
+          'features/get':            () => false,
+          'type-map/hasCustomChart': () => false,
+          'wm/byId':                 () => null,
+          'i18n/t':                  (k: string) => k,
+          'prefs/get':               () => {},
+          'management/all':          () => [],
+          'cluster/all':             () => [],
+          'cluster/byId':            (type: string, id: string) => {
+            if (type === 'catalog.cattle.io.app') {
+              return installedApps.find((app) => app.id === id);
+            }
+
+            return null;
+          },
+          'catalog/charts': [],
+        }
+      };
+
+      return mount(Install as any, {
+        global: {
+          mocks: {
+            $store:      mockStore,
+            $route:      { query: {} },
+            $fetchState: { pending: false },
+            t:           (k: string) => k,
+          },
+          stubs: {
+            Loading:             true,
+            Wizard:              true,
+            Banner:              true,
+            Checkbox:            true,
+            LabeledInput:        true,
+            LabeledSelect:       true,
+            NameNsDescription:   true,
+            Tabbed:              true,
+            Questions:           true,
+            YamlEditor:          true,
+            ResourceCancelModal: true,
+            UnitInput:           true,
+            TypeDescription:     true,
+            LazyImage:           true,
+            ChartReadme:         true,
+            ButtonGroup:         true,
+          }
+        },
+        data() {
+          return {
+            existing,
+            version: {
+              annotations: {
+                [CATALOG_ANNOTATIONS.RELEASE_NAME]: releaseName,
+                [CATALOG_ANNOTATIONS.COMPONENT]:    componentName,
+                [CATALOG_ANNOTATIONS.CERTIFIED]:    certified,
+              }
+            },
+            chart: {
+              chartName,
+              versions: []
+            },
+            query: { versionName: '1.0.0' }
+          };
+        }
+      });
+    };
+
+    it('showMonitoringBanner should return translation key if releaseName matches rancher-monitoring (install or edit)', () => {
+      const wrapper1 = setupComponent(true, 'rancher-monitoring', '', '');
+
+      expect((wrapper1.vm as any).showMonitoringBanner).toBe('catalog.install.steps.basics.oldMonitoringChartWarning');
+
+      const wrapper2 = setupComponent(true, '', 'rancher-monitoring', 'rancher-monitoring');
+
+      expect((wrapper2.vm as any).showMonitoringBanner).toBeNull();
+
+      const wrapper3 = setupComponent(false, 'rancher-monitoring', '', '');
+
+      expect((wrapper3.vm as any).showMonitoringBanner).toBe('catalog.install.steps.basics.oldMonitoringChartWarning');
+    });
+
+    it('showMonitoringBanner should return translation key if existing is false and releaseName matches rancher-monitoring-dashboards', () => {
+      const wrapper1 = setupComponent(false, 'rancher-monitoring-dashboards', '', '');
+
+      expect((wrapper1.vm as any).showMonitoringBanner).toBe('catalog.install.steps.basics.newMonitoringChartWarning');
+
+      const wrapper2 = setupComponent(false, '', 'rancher-monitoring-dashboards', 'rancher-monitoring-dashboards');
+
+      expect((wrapper2.vm as any).showMonitoringBanner).toBeNull();
+
+      const wrapper3 = setupComponent(true, 'rancher-monitoring-dashboards', '', '');
+
+      expect((wrapper3.vm as any).showMonitoringBanner).toBeNull();
+    });
+
+    it('showMonitoringBanner should return null when the chart is not Rancher-certified, even if the release name matches', () => {
+      const oldChartThirdParty = setupComponent(false, 'rancher-monitoring', '', '', [], 'partner');
+
+      expect((oldChartThirdParty.vm as any).showMonitoringBanner).toBeNull();
+
+      const newChartThirdParty = setupComponent(false, 'rancher-monitoring-dashboards', '', '', [], '');
+
+      expect((newChartThirdParty.vm as any).showMonitoringBanner).toBeNull();
+    });
+  });
 });

package/pages/c/_cluster/apps/charts/install.vue

@@ -515,6 +515,29 @@ export default {
     ...mapGetters({ inStore: 'catalog/inStore', features: 'features/get' }),
     mcm: mapFeature(MULTI_CLUSTER),
 
+    showMonitoringBanner() {
+      const annotations = this.version?.annotations || {};
+      const releaseName = annotations[CATALOG_ANNOTATIONS.RELEASE_NAME];
+      const certified = annotations[CATALOG_ANNOTATIONS.CERTIFIED];
+
+      // Only show monitoring banners for the Rancher-certified charts —
+      // a third-party chart that happens to reuse the release name should not
+      // trigger our migration prompts.
+      if (certified !== 'rancher') {
+        return null;
+      }
+
+      if (releaseName === 'rancher-monitoring') {
+        return this.t('catalog.install.steps.basics.oldMonitoringChartWarning');
+      }
+
+      if (!this.existing && releaseName === 'rancher-monitoring-dashboards') {
+        return this.t('catalog.install.steps.basics.newMonitoringChartWarning');
+      }
+
+      return null;
+    },
+
     /**
      * Return list of variables to filter chart questions
      */
@@ -1678,6 +1701,12 @@ export default {
       </template>
       <template #basics>
         <div class="step__basic">
+          <Banner
+            v-if="showMonitoringBanner"
+            color="warning"
+          >
+            {{ showMonitoringBanner }}
+          </Banner>
           <Banner
             v-if="step1Description"
             color="info"

package/pages/c/_cluster/auth/config/index.vue

@@ -6,6 +6,7 @@ import { MODE, _EDIT } from '@shell/config/query-params';
 import { authProvidersInfo } from '@shell/utils/auth';
 import { Banner } from '@components/Banner';
 import Loading from '@shell/components/Loading';
+import { HIDE_LOCAL_AUTH_PROVIDER } from '@shell/store/features';
 
 const resource = MANAGEMENT.AUTH_CONFIG;
 
@@ -28,8 +29,9 @@ export default {
   data() {
     return {
       // Provided by fetch later
-      enabled:  false,
-      nonLocal: null,
+      enabled:          false,
+      nonLocal:         null,
+      disableLocalAuth: this.$store.getters['features/get'](HIDE_LOCAL_AUTH_PROVIDER)
     };
   },
 
@@ -100,8 +102,13 @@ export default {
         <router-link :to="localUsersRoute">
           {{ t('authConfig.manageLocal') }}
         </router-link>
-        <br>
-        {{ t('authConfig.noneEnabled') }}
+        <br><br>
+        <template v-if="disableLocalAuth">
+          {{ t('authConfig.bannerEnableAuthProvider', null, true) }}
+        </template>
+        <template v-else>
+          {{ t('authConfig.noneEnabled') }}
+        </template>
       </div>
     </Banner>
     <SelectIconGrid

package/pages/c/_cluster/explorer/workload-dashboard/__tests__/composable.test.ts

@@ -1,11 +1,15 @@
 import { useWorkloadDashboard } from '@shell/pages/c/_cluster/explorer/workload-dashboard/composable';
 import { WORKLOAD_RESOURCE_TYPES } from '@shell/pages/c/_cluster/explorer/workload-dashboard/types';
+import { WORKLOAD_TYPES } from '@shell/config/types';
 import { defineComponent, h } from 'vue';
 import { shallowMount, flushPromises } from '@vue/test-utils';
 
+const WORKLOAD_DASHBOARD_ROUTE = 'c-cluster-explorer-workload-dashboard';
+
 const mockGetters: Record<string, any> = {};
 const mockDispatch = jest.fn();
 const mockRouterPush = jest.fn();
+const mockCurrentRoute = { value: { name: WORKLOAD_DASHBOARD_ROUTE } };
 
 jest.mock('vuex', () => ({
   useStore: () => ({
@@ -18,7 +22,7 @@ jest.mock('vuex', () => ({
   }),
 }));
 
-jest.mock('vue-router', () => ({ useRouter: () => ({ push: mockRouterPush }) }));
+jest.mock('vue-router', () => ({ useRouter: () => ({ push: mockRouterPush, currentRoute: mockCurrentRoute }) }));
 
 jest.mock('@shell/composables/useI18n', () => ({ useI18n: () => ({ t: (key: string, args?: Record<string, any>) => `%${ key }%${ args ? JSON.stringify(args) : '' }` }) }));
 
@@ -105,6 +109,7 @@ describe('composable: useWorkloadDashboard', () => {
   beforeEach(() => {
     jest.clearAllMocks();
     setupGetters();
+    mockCurrentRoute.value.name = WORKLOAD_DASHBOARD_ROUTE;
   });
 
   describe('namespaceSubtitle', () => {
@@ -558,4 +563,134 @@ describe('composable: useWorkloadDashboard', () => {
       wrapper.unmount();
     });
   });
+
+  describe('response validation', () => {
+    // The composable caches malformed clusters in a module-level singleton, so each
+    // invalid-data test uses a unique cluster id to stay independent of the others.
+    function deploymentRouteFor(cluster: string) {
+      return {
+        name:   'c-cluster-product-resource',
+        params: {
+          cluster,
+          product:  'explorer',
+          resource: WORKLOAD_TYPES.DEPLOYMENT,
+        },
+      };
+    }
+
+    const malformedSummaryResponse = {
+      summary: [{
+        property: 'metadata.state.name',
+        counts:   { running: { namespace: { default: 5 } } },
+      }],
+      data: [],
+    };
+
+    it('should redirect to the deployment page when a count entry is missing total', async() => {
+      const { wrapper } = mountComposable({ clusterId: 'c-missing-total' }, malformedSummaryResponse);
+
+      await flushPromises();
+
+      expect(mockRouterPush).toHaveBeenCalledWith(deploymentRouteFor('c-missing-total'));
+      wrapper.unmount();
+    });
+
+    it('should redirect when the summary is empty but data is present', async() => {
+      const dataWithoutSummaryResponse = { summary: [], data: [{ id: 'pod-1' }] };
+
+      const { wrapper } = mountComposable({ clusterId: 'c-empty-summary-with-data' }, dataWithoutSummaryResponse);
+
+      await flushPromises();
+
+      expect(mockRouterPush).toHaveBeenCalledWith(deploymentRouteFor('c-empty-summary-with-data'));
+      wrapper.unmount();
+    });
+
+    it('should redirect when there is no summary but data is present', async() => {
+      const dataWithoutSummaryResponse = { data: [{ id: 'pod-1' }] };
+
+      const { wrapper } = mountComposable({ clusterId: 'c-no-summary-with-data' }, dataWithoutSummaryResponse);
+
+      await flushPromises();
+
+      expect(mockRouterPush).toHaveBeenCalledWith(deploymentRouteFor('c-no-summary-with-data'));
+      wrapper.unmount();
+    });
+
+    it('should not redirect when every count entry has a total', async() => {
+      const { wrapper } = mountComposable();
+
+      await flushPromises();
+
+      expect(mockRouterPush).not.toHaveBeenCalled();
+      wrapper.unmount();
+    });
+
+    it('should not redirect when the summary is empty and there is no data', async() => {
+      const emptyResponse = { summary: [], data: [] };
+
+      const { wrapper } = mountComposable({}, emptyResponse);
+
+      await flushPromises();
+
+      expect(mockRouterPush).not.toHaveBeenCalled();
+      wrapper.unmount();
+    });
+
+    it('should not redirect when there is no summary and no data', async() => {
+      const noSummaryResponse = { data: [] };
+
+      const { wrapper } = mountComposable({}, noSummaryResponse);
+
+      await flushPromises();
+
+      expect(mockRouterPush).not.toHaveBeenCalled();
+      wrapper.unmount();
+    });
+
+    it('should not redirect for entries returned with an error', async() => {
+      const errorResponse = { summary: null, error: 'No access' };
+
+      const { wrapper } = mountComposable({}, errorResponse);
+
+      await flushPromises();
+
+      expect(mockRouterPush).not.toHaveBeenCalled();
+      wrapper.unmount();
+    });
+
+    it('should not redirect when the user has already navigated away from the dashboard', async() => {
+      // The fetch resolves after the user left the workload dashboard.
+      mockCurrentRoute.value.name = 'c-cluster-product-resource';
+
+      const { wrapper } = mountComposable({ clusterId: 'c-navigated-away' }, malformedSummaryResponse);
+
+      await flushPromises();
+
+      expect(mockRouterPush).not.toHaveBeenCalled();
+      wrapper.unmount();
+    });
+
+    it('should skip fetching and redirect immediately for a cluster already known to be invalid', async() => {
+      const cluster = 'c-cached-invalid';
+
+      // First mount detects the malformed response and caches the cluster.
+      const first = mountComposable({ clusterId: cluster }, malformedSummaryResponse);
+
+      await flushPromises();
+      first.wrapper.unmount();
+
+      jest.clearAllMocks();
+
+      // Second mount returns a valid response, but the cache should short-circuit the
+      // fetch entirely and redirect without ever requesting the summaries again.
+      const second = mountComposable({ clusterId: cluster }, summaryResponse);
+
+      await flushPromises();
+
+      expect(mockDispatch).not.toHaveBeenCalledWith('cluster/request', expect.anything());
+      expect(mockRouterPush).toHaveBeenCalledWith(deploymentRouteFor(cluster));
+      second.wrapper.unmount();
+    });
+  });
 });