@rancher/shell 0.3.26 → 0.3.27

package/promptRemove/management.cattle.io.project.vue

@@ -71,12 +71,9 @@ export default {
     names() {
       return this.filteredNamespaces.map((obj) => obj.nameDisplay).slice(0, 5);
     },
-
-    canManageNamespaces() {
-      // Only admins and cluster owners can see namespaces outside of projects
-      // BUT cluster members can also manage projects and namespaces and may want to not delete the namespaces associated with the project
-      // as per https://github.com/rancher/dashboard/issues/9517 despite the namespaces cannot be seen afterwards (projectless)
-      return this.currentCluster.canUpdate || (this.currentProject.canDelete && this.filteredNamespaces.length && this.filteredNamespaces[0]?.canDelete);
+    // Only admins and cluster owners can see namespaces outside of projects
+    canSeeProjectlessNamespaces() {
+      return this.currentCluster.canUpdate;
     }
   },
   methods: {
@@ -84,7 +81,7 @@ export default {
     remove() {
       // Delete all of thre namespaces and return false - this tells the prompt remove dialog to continue and delete the project
       // Delete all namespaces if the user wouldn't be able to see them after deleting the project
-      if (this.deleteProjectNamespaces || !this.canManageNamespaces) {
+      if (this.deleteProjectNamespaces || !this.canSeeProjectlessNamespaces) {
         return Promise.all(this.filteredNamespaces.map((n) => n.remove())).then(() => false);
       }
 
@@ -100,7 +97,7 @@ export default {
     <div>
       <div class="mb-10">
         {{ t('promptRemove.attemptingToRemove', { type }) }} <span class="display-name">{{ `${displayName}.` }}</span>
-        <template v-if="!canManageNamespaces">
+        <template v-if="!canSeeProjectlessNamespaces">
           <span class="delete-warning"> {{ t('promptRemove.willDeleteAssociatedNamespaces') }}</span> <br>
           <div
             v-clean-html="resourceNames(names, plusMore, t)"
@@ -109,7 +106,7 @@ export default {
         </template>
       </div>
       <div
-        v-if="filteredNamespaces.length > 0 && canManageNamespaces"
+        v-if="filteredNamespaces.length > 0 && canSeeProjectlessNamespaces"
         class="mt-20 remove-project-dialog"
       >
         <Checkbox

package/rancher-components/components/Form/Radio/RadioGroup.test.ts

@@ -0,0 +1,30 @@
+import { mount } from '@vue/test-utils';
+import { RadioGroup } from './index';
+
+describe('component: RadioGroup', () => {
+  describe('when disabled', () => {
+    it.each([true, false])('should expose disabled slot prop for indexed slots for %p', (disabled) => {
+      const wrapper = mount(RadioGroup, {
+        propsData: {
+          name:    'whatever',
+          options: [{ label: 'whatever', value: 'whatever' }],
+          disabled
+        },
+        scopedSlots: {
+          0(props: {isDisabled: boolean}) {
+            return this.$createElement('input', {
+              attrs: {
+                id:       'test',
+                disabled: props.isDisabled
+              }
+            });
+          }
+        }
+      });
+
+      const slot = wrapper.find('#test').element as HTMLInputElement;
+
+      expect(slot.disabled).toBe(disabled);
+    });
+  });
+});

package/rancher-components/components/Form/Radio/RadioGroup.vue

@@ -169,6 +169,7 @@ export default Vue.extend({
 
 <template>
   <div>
+    <!-- Label -->
     <div
       v-if="label || labelKey || tooltip || tooltipKey || $slots.label"
       class="radio-group label"
@@ -195,6 +196,8 @@ export default Vue.extend({
         </h3>
       </slot>
     </div>
+
+    <!-- Group -->
     <div
       class="radio-group"
       :class="{'row':row}"
@@ -212,6 +215,7 @@ export default Vue.extend({
           :is-disabled="isDisabled"
           :name="i"
         >
+          <!-- Default input -->
           <RadioButton
             :key="name+'-'+i"
             :name="name"

package/store/features.js

@@ -31,6 +31,7 @@ export const UNSUPPORTED_STORAGE_DRIVERS = create('unsupported-storage-drivers',
 export const FLEET = create('continuous-delivery', true);
 export const HARVESTER = create('harvester', true);
 export const HARVESTER_CONTAINER = create('harvester-baremetal-container-workload', false);
+export const FLEET_WORKSPACE_BACK = create('provisioningv2-fleet-workspace-back-population', false);
 
 // Not currently used.. no point defining ones we don't use
 // export const EMBEDDED_CLUSTER_API = create('embedded-cluster-api', true);

package/types/shell/index.d.ts

@@ -2807,6 +2807,7 @@ export const UNSUPPORTED_STORAGE_DRIVERS: any;
 export const FLEET: any;
 export const HARVESTER: any;
 export const HARVESTER_CONTAINER: any;
+export const FLEET_WORKSPACE_BACK: any;
 export namespace getters {
     function get(state: any, getters: any, rootState: any, rootGetters: any): (name: any) => any;
 }
@@ -3444,6 +3445,9 @@ export function monitoringStatus(): {
 export function haveV2Monitoring(getters: any): boolean;
 export function haveV1Monitoring(getters: any): boolean;
 export function haveV1MonitoringWorkloads(store: any): Promise<boolean>;
+export function canViewGrafanaLink(store: any): Promise<boolean>;
+export function canViewAlertManagerLink(store: any): Promise<boolean>;
+export function canViewPrometheusLink(store: any): Promise<boolean>;
 }
 
 // @shell/utils/namespace-filter
@@ -4188,7 +4192,6 @@ export function seenReleaseNotes(store: any): boolean;
 export function markSeenReleaseNotes(store: any): Promise<void>;
 export function readReleaseNotes(store: any): boolean;
 export function markReadReleaseNotes(store: any): Promise<void>;
-export function generateSupportLink(version: any): string;
 }
 
 // @shell/utils/width

package/utils/__tests__/object.test.ts

@@ -1,5 +1,5 @@
 import {
-  clone, get, getter, isEmpty, toDictionary, remove
+  clone, get, getter, isEmpty, toDictionary, remove, diff, definedKeys
 } from '@shell/utils/object';
 
 describe('fx: get', () => {
@@ -161,3 +161,69 @@ describe('fx: remove', () => {
     expect(result).toStrictEqual(expected);
   });
 });
+
+describe('fx: diff', () => {
+  it('should return an object including only the differences between two objects', () => {
+    const from = {
+      foo: 'bar',
+      baz: 'bang',
+    };
+    const to = {
+      foo:  'bar',
+      bang: 'baz'
+    };
+
+    const result = diff(from, to);
+    const expected = {
+      baz:  null,
+      bang: 'baz'
+    };
+
+    expect(result).toStrictEqual(expected);
+  });
+  it('should return an object and dot characters in object should still be respected', () => {
+    const from = {};
+    const to = { foo: { 'bar.baz': 'bang' } };
+
+    const result = diff(from, to);
+    const expected = { foo: { 'bar.baz': 'bang' } };
+
+    expect(result).toStrictEqual(expected);
+  });
+});
+
+describe('fx: definedKeys', () => {
+  it('should return an array of keys within an array', () => {
+    const obj = {
+      foo: 'bar',
+      baz: 'bang',
+    };
+
+    const result = definedKeys(obj);
+    const expected = ['"foo"', '"baz"'];
+
+    expect(result).toStrictEqual(expected);
+  });
+  it('should return an array of keys with primitive values and their full nested path', () => {
+    const obj = {
+      foo: 'bar',
+      baz: { bang: 'bop' },
+    };
+
+    const result = definedKeys(obj);
+    const expected = ['"foo"', '"baz"."bang"'];
+
+    expect(result).toStrictEqual(expected);
+  });
+  it('should return an array of keys with primitive values and their full nested path with quotation marks to escape keys with dots in them', () => {
+    const obj = {
+      foo: 'bar',
+      baz: { 'bang.bop': 'beep' },
+    };
+
+    const result = definedKeys(obj);
+    const expected = ['"foo"', '"baz"."bang.bop"'];
+
+    expect(result).toStrictEqual(expected);
+  });
+});

package/utils/__tests__/version.test.ts

@@ -1,28 +1,18 @@
-import { generateSupportLink } from '@shell/utils/version';
+import { isDevBuild } from '@shell/utils/version';
 
-describe('fx: generateSupportLink', () => {
-  it('should generate support link corresponding to the installed Rancher version', () => {
-    const version = 'v2.7.5';
-    const expectation = 'https://www.suse.com/suse-rancher/support-matrix/all-supported-versions/rancher-v2-7-5';
+describe('fx: isDevBuild', () => {
+  it.each([
+    'dev',
+    'master',
+    'head',
+    'whatever-head',
+    'whatever-rc1',
+    'whatever-alpha1',
+  ])(
+    'should exclude version type %p', (version: string) => {
+      const result = isDevBuild(version);
 
-    const result = generateSupportLink(version);
-
-    expect(result).toStrictEqual(expectation);
-  });
-
-  const latestVersionSupportURL = 'https://rancher.com/support-maintenance-terms';
-  const testCases = [
-    ['v2.7-0bcf068e1237acafd4aca01385c7c6b432e22fd7-head', latestVersionSupportURL],
-    ['v2.7.5-rc4', latestVersionSupportURL],
-    [undefined, latestVersionSupportURL],
-  ];
-
-  it.each(testCases)(
-    'should generate support link corresponding to the latest Rancher version when version is unknown or for dev build',
-    (version, expected) => {
-      const result = generateSupportLink(version);
-
-      expect(result).toBe(expected);
+      expect(result).toBe(true);
     }
   );
 });

package/utils/cluster.js

@@ -7,7 +7,7 @@ import { SETTING } from '@shell/config/settings';
 export function filterOnlyKubernetesClusters(mgmtClusters, store) {
   const openHarvesterContainerWorkload = store.getters['features/get']('harvester-baremetal-container-workload');
 
-  return mgmtClusters.filter((c) => {
+  return mgmtClusters?.filter((c) => {
     return openHarvesterContainerWorkload ? true : !isHarvesterCluster(c);
   });
 }

package/utils/grafana.js

@@ -63,14 +63,13 @@ export async function allDashboardsExist(store, clusterId, embeddedUrls, storeNa
 
   let monitoringVersion = '';
 
-  if (!projectId) {
+  if (!projectId && store.getters[`${ storeName }/canList`](CATALOG.APP)) {
     try {
       res = await store.dispatch(`${ storeName }/find`, {
         type: CATALOG.APP,
         id:   'cattle-monitoring-system/rancher-monitoring'
       });
     } catch (err) {
-      return false;
     }
 
     monitoringVersion = res?.currentVersion;

package/utils/monitoring.js

@@ -1,6 +1,6 @@
 // Helpers for determining if V2 or v1 Monitoring are installed
 
-import { SCHEMA, MONITORING, WORKLOAD_TYPES } from '@shell/config/types';
+import { SCHEMA, MONITORING, WORKLOAD_TYPES, ENDPOINTS } from '@shell/config/types';
 import { normalizeType } from '@shell/plugins/dashboard-store/normalize';
 import { findBy } from '@shell/utils/array';
 import { isEmpty } from '@shell/utils/object';
@@ -65,6 +65,30 @@ export async function haveV1MonitoringWorkloads(store) {
   }
 }
 
+async function hasEndpointSubsets(store, id) {
+  if (store.getters['cluster/schemaFor'](ENDPOINTS)) {
+    const endpoints = await store.dispatch('cluster/findAll', { type: ENDPOINTS }) || [];
+
+    const endpoint = endpoints.find((ep) => ep.id === id);
+
+    return endpoint && !isEmpty(endpoint) && !isEmpty(endpoint.subsets);
+  }
+
+  return false;
+}
+
+export async function canViewGrafanaLink(store) {
+  return await hasEndpointSubsets(store, `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-grafana`);
+}
+
+export async function canViewAlertManagerLink(store) {
+  return await hasEndpointSubsets(store, `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-alertmanager`);
+}
+
+export async function canViewPrometheusLink(store) {
+  return await hasEndpointSubsets(store, `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-prometheus`);
+}
+
 // Other ways we check for monitoring:
 
 // (1) Using counts (requires RBAC permissions)

package/utils/object.js

@@ -178,11 +178,12 @@ export function definedKeys(obj) {
     const val = obj[key];
 
     if ( Array.isArray(val) ) {
-      return key;
+      return `"${ key }"`;
     } else if ( isObject(val) ) {
-      return ( definedKeys(val) || [] ).map((subkey) => `${ key }.${ subkey }`);
+      // no need for quotes around the subkey since the recursive call will fill that in via one of the other two statements in the if block
+      return ( definedKeys(val) || [] ).map((subkey) => `"${ key }".${ subkey }`);
     } else {
-      return key;
+      return `"${ key }"`;
     }
   });
 

package/utils/sort.js

@@ -184,7 +184,7 @@ export function sortBy(ary, keys, desc) {
     keys = [keys];
   }
 
-  return ary.slice().sort((objA, objB) => {
+  return (ary || []).slice().sort((objA, objB) => {
     for ( let i = 0 ; i < keys.length ; i++ ) {
       const parsed = parseField(keys[i]);
       const a = get(objA, parsed.field);

package/utils/validators/formRules/index.ts

@@ -382,7 +382,7 @@ export default function(t: Translation, { key = 'Value' }: ValidationOptions): {
       if (val.some((rule: any) => isEmpty(rule.apiGroups))) {
         return t('validation.roleTemplate.roleTemplateRules.missingApiGroup');
       }
-    } else if (val.some((rule: any) => isEmpty(rule.resources) && isEmpty(rule.nonResourceURLs) && isEmpty(rule.apiGroups))) {
+    } else if (val.some((rule: any) => isEmpty(rule.resources) && isEmpty(rule.nonResourceURLs))) {
       return t('validation.roleTemplate.roleTemplateRules.missingOneResource');
     }
 

package/utils/validators/role-template.js

@@ -21,7 +21,7 @@ export function roleTemplateRules(rules = [], getters, errors, validatorArgs = [
     errors.push(getters['i18n/t']('validation.roleTemplate.roleTemplateRules.noResourceAndNonResource'));
   }
 
-  if (rules.some((rule) => isEmpty(rule.resources) && isEmpty(rule.nonResourceURLs) && isEmpty(rule.apiGroups))) {
+  if (rules.some((rule) => isEmpty(rule.resources) && isEmpty(rule.nonResourceURLs))) {
     errors.push(getters['i18n/t']('validation.roleTemplate.roleTemplateRules.missingOneResource'));
   }
 }

package/utils/version.js

@@ -125,16 +125,3 @@ export async function markReadReleaseNotes(store) {
     await store.dispatch('prefs/set', { key: READ_WHATS_NEW, value: getVersionInfo(store).fullVersion });
   }
 }
-
-export function generateSupportLink(version) {
-  const defaultSupportURL = 'https://rancher.com/support-maintenance-terms';
-
-  if (!version || isDevBuild(version)) {
-    return defaultSupportURL;
-  }
-
-  const baseUrl = 'https://www.suse.com/suse-rancher/support-matrix/all-supported-versions/rancher-';
-  const formattedVersion = version.split('.').join('-');
-
-  return baseUrl + formattedVersion;
-}