@rancher/shell 3.0.9-rc.5 → 3.0.9

package/types/store/pagination.types.ts

@@ -73,7 +73,7 @@ export const enum PaginationFilterEquality {
   /**
    * Field does not match a value
    */
-  NOT_EQUALS= '!=', // eslint-disable-line no-unused-vars
+  NOT_EQUALS = '!=', // eslint-disable-line no-unused-vars
   /**
    * Unknown
    */
@@ -81,19 +81,19 @@ export const enum PaginationFilterEquality {
   /**
    * Field must partially match a value
    */
-  CONTAINS= '~', // eslint-disable-line no-unused-vars
+  CONTAINS = '~', // eslint-disable-line no-unused-vars
   /**
    * Field must not partially match a value
    */
-  NOT_CONTAINS= '!~', // eslint-disable-line no-unused-vars
+  NOT_CONTAINS = '!~', // eslint-disable-line no-unused-vars
   /**
    * Field must be greater than a value
    */
-  GREATER_THAN= 'gt', // eslint-disable-line no-unused-vars
+  GREATER_THAN = 'gt', // eslint-disable-line no-unused-vars
   /**
    * Field must be less than a value
    */
-  LESS_THAN= 'lt', // eslint-disable-line no-unused-vars
+  LESS_THAN = 'lt', // eslint-disable-line no-unused-vars
 }
 
 /**

package/utils/__tests__/array.test.ts

@@ -1,5 +1,5 @@
 import {
-  addObject, addObjects, clear, filterBy, findBy, getUniqueLabelKeys, insertAt, isArray, joinStringList, removeAt, removeObject, removeObjects, replaceWith, sameContents, uniq
+  addObject, addObjects, clear, filterBy, findBy, insertAt, isArray, joinStringList, removeAt, removeObject, removeObjects, replaceWith, sameContents, uniq
 } from '@shell/utils/array';
 
 interface Obj {
@@ -473,34 +473,6 @@ describe('fx: replaceWith', () => {
   });
 });
 
-describe('fx: getUniqueLabelKeys', () => {
-  it('should get list of unique resource labels', () => {
-    const resources = [
-      {
-        metadata: {
-          labels: {
-            keyOne: 'value',
-            keyTwo: 'value',
-          }
-        }
-      },
-      {
-        metadata: {
-          labels: {
-            keyOne:   'value',
-            keyThree: 'value',
-          }
-        }
-      },
-    ] as unknown as { metadata: { labels: { [name: string]: string} } }[] ;
-
-    const expected = ['keyOne', 'keyThree', 'keyTwo'];
-    const result = getUniqueLabelKeys(resources);
-
-    expect(result).toStrictEqual(expected);
-  });
-});
-
 describe('fx: joinStringList', () => {
   it('should join two lists of strings', () => {
     const a = 'a b c';

package/utils/__tests__/cluster-agent-configuration.test.ts

@@ -0,0 +1,203 @@
+import { initSchedulingCustomization } from '@shell/utils/cluster';
+import { _CREATE, _EDIT } from '@shell/config/query-params';
+import { AGENT_CONFIGURATION_TYPES } from '@shell/config/settings';
+
+const mockStore = { dispatch: jest.fn() };
+
+const mockFeatures = jest.fn();
+
+interface MockValue {
+  clusterAgentDeploymentCustomization: any;
+  fleetAgentDeploymentCustomization: any;
+  [key: string]: any;
+}
+
+const createMockValue = (overrides = {}): MockValue => ({
+  clusterAgentDeploymentCustomization: {},
+  fleetAgentDeploymentCustomization:   {},
+  ...overrides
+});
+
+describe('utils: cluster - Agent Configuration Types and Scheduling Customization', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Mock successful store dispatch responses
+    mockStore.dispatch.mockImplementation((actionType, actionPayload) => {
+      if (actionType === 'management/find' && actionPayload?.id === 'cluster-agent-default-priority-class') {
+        return Promise.resolve({ value: JSON.stringify({ value: 100, preemptionPolicy: 'PreemptLowerPriority' }) });
+      }
+      if (actionType === 'management/find' && actionPayload?.id === 'cluster-agent-default-pod-disruption-budget') {
+        return Promise.resolve({ value: JSON.stringify({ maxUnavailable: 1 }) });
+      }
+      if (actionType === 'management/find' && actionPayload?.id === 'fleet-agent-default-priority-class') {
+        return Promise.resolve({ value: JSON.stringify({ value: 99, preemptionPolicy: 'PreemptLowerPriority' }) });
+      }
+      if (actionType === 'management/find' && actionPayload?.id === 'fleet-agent-default-pod-disruption-budget') {
+        return Promise.resolve({ value: JSON.stringify({ maxUnavailable: 2 }) });
+      }
+
+      return Promise.resolve({ value: '{}' });
+    });
+  });
+
+  describe('agent configuration types', () => {
+    it('should export correct agent configuration types', () => {
+      expect(AGENT_CONFIGURATION_TYPES).toBeDefined();
+      expect(AGENT_CONFIGURATION_TYPES.CLUSTER).toBe('cluster');
+      expect(AGENT_CONFIGURATION_TYPES.FLEET).toBe('fleet');
+    });
+
+    it('should have exactly two agent types', () => {
+      const keys = Object.keys(AGENT_CONFIGURATION_TYPES);
+
+      expect(keys).toHaveLength(2);
+      expect(keys).toContain('CLUSTER');
+      expect(keys).toContain('FLEET');
+    });
+  });
+
+  describe('initSchedulingCustomization', () => {
+    it('should initialize both cluster and fleet agent defaults in CREATE mode', async() => {
+      const value = createMockValue();
+
+      mockFeatures.mockReturnValue(true); // Enable scheduling customization feature
+
+      const result = await initSchedulingCustomization(value, mockFeatures, mockStore, _CREATE);
+
+      expect(result.clusterAgentDefaultPC).toStrictEqual({ value: 100, preemptionPolicy: 'PreemptLowerPriority' });
+      expect(result.clusterAgentDefaultPDB).toStrictEqual({ maxUnavailable: 1 });
+      expect(result.fleetAgentDefaultPC).toStrictEqual({ value: 99, preemptionPolicy: 'PreemptLowerPriority' });
+      expect(result.fleetAgentDefaultPDB).toStrictEqual({ maxUnavailable: 2 });
+      expect(result.schedulingCustomizationFeatureEnabled).toBe(true);
+    });
+
+    it('should set cluster agent scheduling customization in CREATE mode when feature enabled', async() => {
+      const value = createMockValue();
+
+      mockFeatures.mockReturnValue(true);
+
+      await initSchedulingCustomization(value, mockFeatures, mockStore, _CREATE);
+
+      expect(value.clusterAgentDeploymentCustomization.schedulingCustomization).toStrictEqual({
+        priorityClass:       { value: 100, preemptionPolicy: 'PreemptLowerPriority' },
+        podDisruptionBudget: { maxUnavailable: 1 }
+      });
+    });
+
+    it('should set fleet agent scheduling customization in CREATE mode when feature enabled', async() => {
+      const value = createMockValue();
+
+      mockFeatures.mockReturnValue(true);
+
+      await initSchedulingCustomization(value, mockFeatures, mockStore, _CREATE);
+
+      expect(value.fleetAgentDeploymentCustomization.schedulingCustomization).toStrictEqual({
+        priorityClass:       { value: 99, preemptionPolicy: 'PreemptLowerPriority' },
+        podDisruptionBudget: { maxUnavailable: 2 }
+      });
+    });
+
+    it('should not set scheduling customization when feature is disabled', async() => {
+      const value = createMockValue();
+
+      mockFeatures.mockReturnValue(false);
+
+      await initSchedulingCustomization(value, mockFeatures, mockStore, _CREATE);
+
+      expect(value.clusterAgentDeploymentCustomization.schedulingCustomization).toBeUndefined();
+      expect(value.fleetAgentDeploymentCustomization.schedulingCustomization).toBeUndefined();
+    });
+
+    it('should not overwrite existing cluster agent scheduling customization in CREATE mode', async() => {
+      const existingClusterConfig = { priorityClass: { value: 200 }, podDisruptionBudget: { maxUnavailable: 2 } };
+      const value = createMockValue({ clusterAgentDeploymentCustomization: { schedulingCustomization: existingClusterConfig } });
+
+      mockFeatures.mockReturnValue(true);
+
+      await initSchedulingCustomization(value, mockFeatures, mockStore, _CREATE);
+
+      expect(value.clusterAgentDeploymentCustomization.schedulingCustomization).toStrictEqual(existingClusterConfig);
+    });
+
+    it('should not overwrite existing fleet agent scheduling customization in CREATE mode', async() => {
+      const existingFleetConfig = { priorityClass: { value: 300 }, podDisruptionBudget: { maxUnavailable: 3 } };
+      const value = createMockValue({ fleetAgentDeploymentCustomization: { schedulingCustomization: existingFleetConfig } });
+
+      mockFeatures.mockReturnValue(true);
+
+      await initSchedulingCustomization(value, mockFeatures, mockStore, _CREATE);
+
+      expect(value.fleetAgentDeploymentCustomization.schedulingCustomization).toStrictEqual(existingFleetConfig);
+    });
+
+    it('should detect originally enabled scheduling customization in EDIT mode', async() => {
+      const value = createMockValue({ clusterAgentDeploymentCustomization: { schedulingCustomization: { priorityClass: { value: 100 } } } });
+
+      mockFeatures.mockReturnValue(true);
+
+      const result = await initSchedulingCustomization(value, mockFeatures, mockStore, _EDIT);
+
+      expect(result.schedulingCustomizationOriginallyEnabled).toBe(true);
+    });
+
+    it('should detect originally enabled scheduling customization for fleet agent in EDIT mode', async() => {
+      const value = createMockValue({ fleetAgentDeploymentCustomization: { schedulingCustomization: { priorityClass: { value: 99 } } } });
+
+      mockFeatures.mockReturnValue(true);
+
+      const result = await initSchedulingCustomization(value, mockFeatures, mockStore, _EDIT);
+
+      expect(result.schedulingCustomizationOriginallyEnabled).toBe(true);
+    });
+
+    it('should detect originally enabled when either cluster or fleet agent has customization', async() => {
+      const value = createMockValue({ fleetAgentDeploymentCustomization: { schedulingCustomization: { priorityClass: { value: 99 } } } });
+      // clusterAgentDeploymentCustomization has no schedulingCustomization
+
+      mockFeatures.mockReturnValue(true);
+
+      const result = await initSchedulingCustomization(value, mockFeatures, mockStore, _EDIT);
+
+      expect(result.schedulingCustomizationOriginallyEnabled).toBe(true);
+    });
+
+    it('should handle store dispatch errors gracefully', async() => {
+      const value = createMockValue();
+
+      mockFeatures.mockReturnValue(true);
+      mockStore.dispatch.mockRejectedValue(new Error('Store error'));
+
+      const result = await initSchedulingCustomization(value, mockFeatures, mockStore, _CREATE);
+
+      expect(result.errors).toHaveLength(4); // 4 dispatch calls, all failing
+      expect(result.clusterAgentDefaultPC).toBeNull();
+      expect(result.clusterAgentDefaultPDB).toBeNull();
+      expect(result.fleetAgentDefaultPC).toBeNull();
+      expect(result.fleetAgentDefaultPDB).toBeNull();
+    });
+
+    it('should handle JSON parsing errors gracefully', async() => {
+      const value = createMockValue();
+
+      mockFeatures.mockReturnValue(true);
+      mockStore.dispatch.mockResolvedValue({ value: 'invalid-json' });
+
+      const result = await initSchedulingCustomization(value, mockFeatures, mockStore, _CREATE);
+
+      expect(result.errors).toHaveLength(4); // JSON parsing errors
+      expect(result.clusterAgentDefaultPC).toBeNull();
+      expect(result.fleetAgentDefaultPC).toBeNull();
+    });
+
+    it('should return empty errors array when everything succeeds', async() => {
+      const value = createMockValue();
+
+      mockFeatures.mockReturnValue(true);
+
+      const result = await initSchedulingCustomization(value, mockFeatures, mockStore, _CREATE);
+
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+});

package/utils/array.ts

@@ -231,17 +231,6 @@ export function concatStrings(a: string[], b: string[]): string[] {
   return [...a.map((aa) => b.map((bb) => aa.concat(bb)))].reduce((acc, arr) => [...arr, ...acc], []);
 }
 
-interface KubeResource { metadata: { labels: { [name: string]: string} } } // Migrate to central kube types resource when those are brought in
-export function getUniqueLabelKeys<T extends KubeResource>(aryResources: T[]): string[] {
-  const uniqueObj = aryResources.reduce((res, r) => {
-    Object.keys(r.metadata.labels).forEach((l) => (res[l] = true));
-
-    return res;
-  }, {} as {[label: string]: boolean});
-
-  return Object.keys(uniqueObj).sort();
-}
-
 /**
  * Join list as string into a new string without duplicates
  * @param {string} a 'a b c'

package/utils/aws.ts

@@ -0,0 +1,21 @@
+import { Subnet, VPC } from '@shell/types/aws-sdk';
+
+export function isIpv4Network(network: Subnet | VPC): boolean {
+  return !!network.CidrBlock;
+}
+
+export function isIpv6Network(network: Subnet | VPC): boolean {
+  return !!network.Ipv6CidrBlockAssociationSet?.length;
+}
+
+export function getVpcDisplayName(vpc: VPC): string {
+  const nameTag = vpc.Tags?.find((t) => t.Key === 'Name');
+
+  return nameTag ? `${ nameTag.Value } (${ vpc.VpcId })` : vpc.VpcId;
+}
+
+export function getSubnetDisplayName(subnet: Subnet): string {
+  const nameTag = subnet.Tags?.find((t) => t.Key === 'Name');
+
+  return nameTag ? `${ nameTag.Value } (${ subnet.SubnetId })` : subnet.SubnetId;
+}

package/utils/cluster.js

@@ -312,9 +312,12 @@ export async function initSchedulingCustomization(value, features, store, mode)
   const schedulingCustomizationFeatureEnabled = features(SCHEDULING_CUSTOMIZATION);
   let clusterAgentDefaultPC = null;
   let clusterAgentDefaultPDB = null;
+  let fleetAgentDefaultPC = null;
+  let fleetAgentDefaultPDB = null;
   let schedulingCustomizationOriginallyEnabled = false;
   const errors = [];
 
+  // Cluster Agent Config
   try {
     clusterAgentDefaultPC = JSON.parse((await store.dispatch('management/find', { type: MANAGEMENT.SETTING, id: SETTING.CLUSTER_AGENT_DEFAULT_PRIORITY_CLASS })).value) || null;
   } catch (e) {
@@ -330,12 +333,29 @@ export async function initSchedulingCustomization(value, features, store, mode)
     set(value, 'clusterAgentDeploymentCustomization.schedulingCustomization', { priorityClass: clusterAgentDefaultPC, podDisruptionBudget: clusterAgentDefaultPDB });
   }
 
-  if (mode === _EDIT && !!value?.clusterAgentDeploymentCustomization?.schedulingCustomization) {
+  // Fleet Agent Config
+  try {
+    fleetAgentDefaultPC = JSON.parse((await store.dispatch('management/find', { type: MANAGEMENT.SETTING, id: SETTING.FLEET_AGENT_DEFAULT_PRIORITY_CLASS })).value) || null;
+  } catch (e) {
+    errors.push(e);
+  }
+  try {
+    fleetAgentDefaultPDB = JSON.parse((await store.dispatch('management/find', { type: MANAGEMENT.SETTING, id: SETTING.FLEET_AGENT_DEFAULT_POD_DISTRIBUTION_BUDGET })).value) || null;
+  } catch (e) {
+    errors.push(e);
+  }
+
+  if (schedulingCustomizationFeatureEnabled && mode === _CREATE && isEmptyLodash(value?.fleetAgentDeploymentCustomization?.schedulingCustomization)) {
+    set(value, 'fleetAgentDeploymentCustomization.schedulingCustomization', { priorityClass: fleetAgentDefaultPC, podDisruptionBudget: fleetAgentDefaultPDB });
+  }
+
+  // Validates if any, FleetAgent or ClusterAgent have been added before
+  if (mode === _EDIT && (!!value?.clusterAgentDeploymentCustomization?.schedulingCustomization || !!value?.fleetAgentDeploymentCustomization?.schedulingCustomization)) {
     schedulingCustomizationOriginallyEnabled = true;
   }
 
   return {
-    clusterAgentDefaultPC, clusterAgentDefaultPDB, schedulingCustomizationFeatureEnabled, schedulingCustomizationOriginallyEnabled, errors
+    fleetAgentDefaultPC, fleetAgentDefaultPDB, clusterAgentDefaultPC, clusterAgentDefaultPDB, schedulingCustomizationFeatureEnabled, schedulingCustomizationOriginallyEnabled, errors
   };
 }
 

package/utils/selector-typed.ts

@@ -110,7 +110,7 @@ export async function matching({
     return generateMatchingResponse([], inScopeCount || 0);
   }
 
-  if ($store.getters[`${ inStore }/paginationEnabled`]?.({ id: type })) {
+  if ($store.getters[`${ inStore }/paginationEnabled`]?.()) {
     if (isLabelSelectorEmpty(labelSelector) && (!!namespace && !safeNamespaces?.length)) {
       // no namespaces - ALL resources are candidates
       // no labels - return all candidates

package/utils/svg-filter.js

@@ -169,9 +169,10 @@ export class Solver {
     const result = this.solveNarrow(this.solveWide());
 
     return {
-      values: result.values,
-      loss:   result.loss,
-      filter: this.css(result.values),
+      values:    result.values,
+      loss:      result.loss,
+      filter:    this.css(result.values),
+      filterVal: this.css(result.values).replace('filter: ', '').replace(';', '')
     };
   }
 

package/components/__tests__/ProjectRow.test.ts

@@ -1,206 +0,0 @@
-import ProjectRow from '@shell/components/form/ResourceQuota/ProjectRow.vue';
-import { RANCHER_TYPES, TYPES } from '@shell/components/form/ResourceQuota/shared';
-import { shallowMount } from '@vue/test-utils';
-
-const CONFIGMAP_STRING = TYPES.CONFIG_MAPS;
-
-describe('component: ProjectRow.vue', () => {
-  const defaultMountOptions = {
-    props: {
-      mode:  'edit',
-      types: RANCHER_TYPES,
-      type:  CONFIGMAP_STRING,
-      index: 0,
-      value: {
-        spec: {
-          namespaceDefaultResourceQuota: { limit: {} },
-          resourceQuota:                 { limit: {} }
-        }
-      }
-    }
-  };
-
-  it('should render the correct input fields and set the correct computed values, based on the provided data', () => {
-    const wrapper = shallowMount(
-      ProjectRow,
-      { ...defaultMountOptions }
-    );
-
-    const typeInput = wrapper.find(`[data-testid="projectrow-type-input"]`);
-    const customTypeInput = wrapper.find(`[data-testid="projectrow-custom-type-input"]`);
-    const projectQuotaInput = wrapper.find(`[data-testid="projectrow-project-quota-input"]`);
-    const namespaceQuotaInput = wrapper.find(`[data-testid="projectrow-namespace-quota-input"]`);
-
-    expect(typeInput.exists()).toBe(true);
-    expect(customTypeInput.exists()).toBe(true);
-    expect(customTypeInput.attributes().disabled).toBe('true');
-    expect(projectQuotaInput.exists()).toBe(true);
-    expect(namespaceQuotaInput.exists()).toBe(true);
-    expect(wrapper.vm.resourceQuotaLimit).toStrictEqual({});
-    expect(wrapper.vm.namespaceDefaultResourceQuotaLimit).toStrictEqual({});
-  });
-
-  it('triggering "updateQuotaLimit" should trigger Vue.set with the correct data', () => {
-    const wrapper = shallowMount(
-      ProjectRow,
-      { ...defaultMountOptions }
-    );
-
-    wrapper.vm.updateQuotaLimit('resourceQuota', CONFIGMAP_STRING, 10);
-
-    expect(wrapper.vm.value).toStrictEqual({
-      spec: {
-        namespaceDefaultResourceQuota: { limit: {} },
-        resourceQuota:                 { limit: { [`${ CONFIGMAP_STRING }`]: 10 } }
-      }
-    });
-  });
-
-  it('triggering "updateType" with the same type that existed should clear limits and trigger emit', () => {
-    const wrapper = shallowMount(
-      ProjectRow,
-      { ...defaultMountOptions }
-    );
-
-    wrapper.vm.updateType(CONFIGMAP_STRING);
-
-    expect(wrapper.vm.value).toStrictEqual({
-      spec: {
-        namespaceDefaultResourceQuota: { limit: {} },
-        resourceQuota:                 { limit: {} }
-      }
-    });
-
-    expect(wrapper.emitted('type-change')).toBeTruthy();
-    expect(wrapper.emitted('type-change')[0]).toStrictEqual([{ index: 0, type: CONFIGMAP_STRING }]);
-  });
-
-  it('should update standard resource types', async() => {
-    const wrapper = shallowMount(
-      ProjectRow,
-      { ...defaultMountOptions }
-    );
-
-    expect(wrapper.vm.isCustom).toBe(false);
-
-    await wrapper.vm.updateQuotaLimit('resourceQuota', 'limitsCpu', '100m');
-    await wrapper.vm.updateQuotaLimit('namespaceDefaultResourceQuota', 'limitsCpu', '50m');
-
-    expect(wrapper.vm.value.spec.resourceQuota.limit.limitsCpu).toBe('100m');
-    expect(wrapper.vm.value.spec.namespaceDefaultResourceQuota.limit.limitsCpu).toBe('50m');
-    expect(wrapper.vm.value.spec.resourceQuota.limit.extended).toBeUndefined();
-  });
-
-  it('should switch to a custom resource type', async() => {
-    const wrapper = shallowMount(
-      ProjectRow,
-      { ...defaultMountOptions }
-    );
-
-    await wrapper.vm.updateType(TYPES.EXTENDED);
-
-    expect(wrapper.emitted('type-change')).toHaveLength(1);
-    expect(wrapper.emitted('type-change')[0][0]).toStrictEqual({ index: 0, type: TYPES.EXTENDED });
-  });
-
-  it('should update custom resource types', async() => {
-    const wrapper = shallowMount(
-      ProjectRow,
-      {
-        ...defaultMountOptions,
-        props: {
-          ...defaultMountOptions.props,
-          type: TYPES.EXTENDED
-        }
-      }
-    );
-
-    expect(wrapper.vm.isCustom).toBe(true);
-
-    const customTypeInput = wrapper.find(`[data-testid="projectrow-custom-type-input"]`);
-
-    expect(customTypeInput.attributes().disabled).toBe('false');
-    await wrapper.vm.updateCustomType('custom.resource/foo');
-
-    expect(wrapper.vm.customType).toBe('custom.resource/foo');
-
-    await wrapper.vm.updateQuotaLimit('resourceQuota', 'custom.resource/foo', 1);
-    await wrapper.vm.updateQuotaLimit('namespaceDefaultResourceQuota', 'custom.resource/foo', 2);
-
-    expect(wrapper.vm.value.spec.resourceQuota.limit.extended['custom.resource/foo']).toBe(1);
-    expect(wrapper.vm.value.spec.namespaceDefaultResourceQuota.limit.extended['custom.resource/foo']).toBe(2);
-  });
-
-  it('should handle custom resource types with periods', () => {
-    const wrapper = shallowMount(ProjectRow, {
-      ...defaultMountOptions,
-      props: {
-        ...defaultMountOptions.props,
-        type: 'extended.requests.nvidia.com/gpu'
-      }
-    });
-
-    expect(wrapper.vm.isCustom).toBe(true);
-    expect(wrapper.vm.customType).toBe('requests.nvidia.com/gpu');
-  });
-
-  it('should emit update:resource-identifier when updateCustomType is called', () => {
-    const wrapper: any = shallowMount(ProjectRow, {
-      props: {
-        ...defaultMountOptions.props,
-        type: TYPES.EXTENDED,
-      }
-    });
-
-    wrapper.vm.updateCustomType('my-custom-resource');
-
-    expect(wrapper.emitted('update:resource-identifier')).toBeTruthy();
-    expect(wrapper.emitted('update:resource-identifier')[0]).toStrictEqual([{
-      type:       TYPES.EXTENDED,
-      customType: 'my-custom-resource',
-      index:      0
-    }]);
-  });
-
-  it('should not delete resource limits if there are duplicate keys in localTypeValues', () => {
-    const value = {
-      spec: {
-        resourceQuota:                 { limit: { extended: { 'my-resource': '10' } } },
-        namespaceDefaultResourceQuota: { limit: { extended: { 'my-resource': '5' } } }
-      }
-    };
-    const wrapper: any = shallowMount(ProjectRow, {
-      props: {
-        ...defaultMountOptions.props,
-        value,
-        typeValues: ['extended.my-resource', 'extended.my-resource']
-      }
-    });
-
-    wrapper.vm.deleteResourceLimits('my-resource', true);
-
-    expect(value.spec.resourceQuota.limit.extended['my-resource']).toStrictEqual('10');
-    expect(value.spec.namespaceDefaultResourceQuota.limit.extended['my-resource']).toStrictEqual('5');
-  });
-
-  it('should delete resource limits if there is only one key in localTypeValues', () => {
-    const value = {
-      spec: {
-        resourceQuota:                 { limit: { extended: { 'my-resource': '10' } } },
-        namespaceDefaultResourceQuota: { limit: { extended: { 'my-resource': '5' } } }
-      }
-    };
-    const wrapper: any = shallowMount(ProjectRow, {
-      props: {
-        ...defaultMountOptions.props,
-        value,
-        typeValues: ['extended.my-resource']
-      }
-    });
-
-    wrapper.vm.deleteResourceLimits('my-resource', true);
-
-    expect(value.spec.resourceQuota.limit.extended['my-resource']).toBeUndefined();
-    expect(value.spec.namespaceDefaultResourceQuota.limit.extended['my-resource']).toBeUndefined();
-  });
-});