@rancher/shell 3.0.9-rc.5 → 3.0.9

package/components/form/ResourceQuota/__tests__/Project.test.ts

@@ -14,50 +14,297 @@ describe('project', () => {
     types: []
   };
 
-  it('should emit validationChanged with false when validateTypes(false) is called (e.g., when adding a row)', () => {
-    const wrapper: any = shallowMount(Project, { props: defaultProps });
+  describe('created() spec parser', () => {
+    it('should initialise resourceQuotas as an empty array when spec limits are empty', () => {
+      const wrapper: any = shallowMount(Project, { props: defaultProps });
 
-    wrapper.vm.validateTypes(false);
+      expect(wrapper.vm.resourceQuotas).toStrictEqual([]);
+    });
+
+    it('should parse a standard resource type from the spec into resourceQuotas', () => {
+      const wrapper: any = shallowMount(Project, {
+        props: {
+          ...defaultProps,
+          value: {
+            spec: {
+              resourceQuota:                 { limit: { configMaps: '20' } },
+              namespaceDefaultResourceQuota: { limit: { configMaps: '10' } }
+            }
+          }
+        }
+      });
+
+      expect(wrapper.vm.resourceQuotas).toHaveLength(1);
+      expect(wrapper.vm.resourceQuotas[0]).toMatchObject({
+        resourceType:          'configMaps',
+        resourceIdentifier:    'configMaps',
+        projectLimit:          '20',
+        namespaceDefaultLimit: '10',
+      });
+    });
+
+    it('should parse an extended resource type from the spec into resourceQuotas', () => {
+      const wrapper: any = shallowMount(Project, {
+        props: {
+          ...defaultProps,
+          value: {
+            spec: {
+              resourceQuota:                 { limit: { extended: { test1: '10' } } },
+              namespaceDefaultResourceQuota: { limit: { extended: { test1: '5' } } }
+            }
+          }
+        }
+      });
+
+      expect(wrapper.vm.resourceQuotas).toHaveLength(1);
+      expect(wrapper.vm.resourceQuotas[0]).toMatchObject({
+        resourceType:          TYPES.EXTENDED,
+        resourceIdentifier:    'test1',
+        projectLimit:          '10',
+        namespaceDefaultLimit: '5',
+      });
+    });
+
+    it('should initialise resourceQuotas as an empty array when resourceQuota exists but has no limit property', () => {
+      const wrapper: any = shallowMount(Project, {
+        props: {
+          ...defaultProps,
+          value: {
+            spec: {
+              resourceQuota:                 {},
+              namespaceDefaultResourceQuota: { limit: {} }
+            }
+          }
+        }
+      });
+
+      expect(wrapper.vm.resourceQuotas).toStrictEqual([]);
+    });
+
+    it('should parse project quotas and fall back to empty string for missing ns limits when namespaceDefaultResourceQuota has no limit property', () => {
+      const wrapper: any = shallowMount(Project, {
+        props: {
+          ...defaultProps,
+          value: {
+            spec: {
+              resourceQuota:                 { limit: { configMaps: '20' } },
+              namespaceDefaultResourceQuota: {}
+            }
+          }
+        }
+      });
 
-    expect(wrapper.emitted('validationChanged')).toBeTruthy();
-    expect(wrapper.emitted('validationChanged')[0]).toStrictEqual([false]);
+      expect(wrapper.vm.resourceQuotas).toHaveLength(1);
+      expect(wrapper.vm.resourceQuotas[0]).toMatchObject({
+        resourceType:          'configMaps',
+        projectLimit:          '20',
+        namespaceDefaultLimit: '',
+      });
+    });
+
+    it('should parse both standard and extended resource types into resourceQuotas', () => {
+      const wrapper: any = shallowMount(Project, {
+        props: {
+          ...defaultProps,
+          value: {
+            spec: {
+              resourceQuota:                 { limit: { configMaps: '20', extended: { test1: '10' } } },
+              namespaceDefaultResourceQuota: { limit: { configMaps: '15', extended: { test1: '8' } } }
+            }
+          }
+        }
+      });
+
+      expect(wrapper.vm.resourceQuotas).toHaveLength(2);
+    });
   });
 
-  it('should emit validationChanged with false if an extended type has no resource identifier', () => {
-    const wrapper: any = shallowMount(Project, { props: defaultProps });
+  describe('specFromQuotas()', () => {
+    it('should convert a standard resourceQuota entry to projectLimit and nsLimit', () => {
+      const wrapper: any = shallowMount(Project, { props: defaultProps });
+
+      wrapper.setData({
+        resourceQuotas: [{
+          id:                    '1',
+          resourceType:          'configMaps',
+          resourceIdentifier:    'configMaps',
+          projectLimit:          '20',
+          namespaceDefaultLimit: '10',
+        }]
+      });
+
+      expect(wrapper.vm.specFromQuotas()).toStrictEqual({
+        projectLimit: { configMaps: '20' },
+        nsLimit:      { configMaps: '10' },
+      });
+    });
+
+    it('should convert an extended resourceQuota entry to a nested extended object', () => {
+      const wrapper: any = shallowMount(Project, { props: defaultProps });
+
+      wrapper.setData({
+        resourceQuotas: [{
+          id:                    '1',
+          resourceType:          TYPES.EXTENDED,
+          resourceIdentifier:    'my-resource',
+          projectLimit:          '5',
+          namespaceDefaultLimit: '3',
+        }]
+      });
+
+      expect(wrapper.vm.specFromQuotas()).toStrictEqual({
+        projectLimit: { extended: { 'my-resource': '5' } },
+        nsLimit:      { extended: { 'my-resource': '3' } },
+      });
+    });
+
+    it('should omit an extended entry from the spec when resourceIdentifier is empty', () => {
+      const wrapper: any = shallowMount(Project, { props: defaultProps });
 
-    wrapper.setData({ typeValues: [TYPES.EXTENDED] });
+      wrapper.setData({
+        resourceQuotas: [{
+          id:                    '1',
+          resourceType:          TYPES.EXTENDED,
+          resourceIdentifier:    '',
+          projectLimit:          '5',
+          namespaceDefaultLimit: '3',
+        }]
+      });
 
-    wrapper.vm.validateTypes(true);
+      const { projectLimit } = wrapper.vm.specFromQuotas();
 
-    expect(wrapper.emitted('validationChanged')).toBeTruthy();
-    expect(wrapper.emitted('validationChanged')[0]).toStrictEqual([false]);
+      expect(projectLimit.extended).toBeUndefined();
+    });
   });
 
-  it('should emit validationChanged with true if an extended type has resource identifier', () => {
-    const wrapper: any = shallowMount(Project, { props: defaultProps });
+  describe('remainingTypes()', () => {
+    const typesProps = [
+      {
+        value:          TYPES.EXTENDED,
+        inputExponent:  0,
+        baseUnit:       '',
+        labelKey:       'resourceQuota.custom',
+        placeholderKey: 'resourceQuota.projectLimit.unitlessPlaceholder'
+      },
+      {
+        value:          'configMaps',
+        inputExponent:  0,
+        baseUnit:       '',
+        labelKey:       'resourceQuota.configMaps',
+        placeholderKey: 'resourceQuota.projectLimit.unitlessPlaceholder'
+      },
+      {
+        value:          'pods',
+        inputExponent:  0,
+        baseUnit:       '',
+        labelKey:       'resourceQuota.pods',
+        placeholderKey: 'resourceQuota.projectLimit.unitlessPlaceholder'
+      }
+    ];
+
+    it('should exclude already-used non-extended types', () => {
+      const wrapper: any = shallowMount(Project, { props: { ...defaultProps, types: typesProps } });
+
+      wrapper.setData({
+        resourceQuotas: [{
+          id:                    '1',
+          resourceType:          'configMaps',
+          resourceIdentifier:    'configMaps',
+          projectLimit:          '20',
+          namespaceDefaultLimit: '10',
+        }]
+      });
+
+      const values = wrapper.vm.remainingTypes('pods').map((t: any) => t.value);
+
+      expect(values).not.toContain('configMaps');
+      expect(values).toContain('pods');
+      expect(values).toContain(TYPES.EXTENDED);
+    });
+
+    it('should include the currentType even if it is already used', () => {
+      const wrapper: any = shallowMount(Project, { props: { ...defaultProps, types: typesProps } });
+
+      wrapper.setData({
+        resourceQuotas: [{
+          id:                    '1',
+          resourceType:          'configMaps',
+          resourceIdentifier:    'configMaps',
+          projectLimit:          '20',
+          namespaceDefaultLimit: '10',
+        }]
+      });
+
+      const values = wrapper.vm.remainingTypes('configMaps').map((t: any) => t.value);
+
+      expect(values).toContain('configMaps');
+    });
 
-    wrapper.setData({ typeValues: ['extended.my-resource'] });
+    it('should always include extended type', () => {
+      const wrapper: any = shallowMount(Project, { props: { ...defaultProps, types: typesProps } });
 
-    wrapper.vm.validateTypes(true);
+      const values = wrapper.vm.remainingTypes('pods').map((t: any) => t.value);
 
-    expect(wrapper.emitted('validationChanged')).toBeTruthy();
-    expect(wrapper.emitted('validationChanged')[0]).toStrictEqual([true]);
+      expect(values).toContain(TYPES.EXTENDED);
+    });
   });
 
-  it('should update typeValues and validate when updateResourceIdentifier is called', () => {
-    const wrapper: any = shallowMount(Project, { props: defaultProps });
+  describe('validationChanged watcher', () => {
+    it('should emit validationChanged with false when an extended quota has no resource identifier', async() => {
+      const wrapper: any = shallowMount(Project, { props: defaultProps });
+
+      await wrapper.setData({
+        resourceQuotas: [{
+          id:                    '1',
+          resourceType:          TYPES.EXTENDED,
+          resourceIdentifier:    '',
+          projectLimit:          '5',
+          namespaceDefaultLimit: '3',
+        }]
+      });
 
-    wrapper.setData({ typeValues: [TYPES.EXTENDED] });
+      const emitted = wrapper.emitted('validationChanged');
 
-    wrapper.vm.updateResourceIdentifier({
-      type:       TYPES.EXTENDED,
-      customType: 'my-resource',
-      index:      0
+      expect(emitted).toBeTruthy();
+      expect(emitted[emitted.length - 1]).toStrictEqual([false]);
     });
 
-    expect(wrapper.vm.typeValues[0]).toStrictEqual('extended.my-resource');
-    expect(wrapper.emitted('validationChanged')).toBeTruthy();
-    expect(wrapper.emitted('validationChanged')[0]).toStrictEqual([true]);
+    it('should emit validationChanged with true when all extended quotas have resource identifiers', async() => {
+      const wrapper: any = shallowMount(Project, { props: defaultProps });
+
+      await wrapper.setData({
+        resourceQuotas: [{
+          id:                    '1',
+          resourceType:          TYPES.EXTENDED,
+          resourceIdentifier:    'my-resource',
+          projectLimit:          '5',
+          namespaceDefaultLimit: '3',
+        }]
+      });
+
+      const emitted = wrapper.emitted('validationChanged');
+
+      expect(emitted).toBeTruthy();
+      expect(emitted[emitted.length - 1]).toStrictEqual([true]);
+    });
+
+    it('should emit validationChanged with true when resourceQuotas has no extended entries', async() => {
+      const wrapper: any = shallowMount(Project, { props: defaultProps });
+
+      await wrapper.setData({
+        resourceQuotas: [{
+          id:                    '1',
+          resourceType:          'configMaps',
+          resourceIdentifier:    'configMaps',
+          projectLimit:          '20',
+          namespaceDefaultLimit: '10',
+        }]
+      });
+
+      const emitted = wrapper.emitted('validationChanged');
+
+      expect(emitted).toBeTruthy();
+      expect(emitted[emitted.length - 1]).toStrictEqual([true]);
+    });
   });
 });

package/components/form/ResourceQuota/__tests__/ResourceQuotaEntry.test.ts

@@ -0,0 +1,215 @@
+import { shallowMount } from '@vue/test-utils';
+import { createStore } from 'vuex';
+import ResourceQuotaEntry from '@shell/components/form/ResourceQuota/ResourceQuotaEntry.vue';
+import { LabeledInput } from '@components/Form/LabeledInput';
+import { RcButton } from '@components/RcButton';
+import { TYPES } from '@shell/components/form/ResourceQuota/shared';
+
+describe('component: ResourceQuotaEntry', () => {
+  const store = createStore({});
+
+  const mockType = {
+    value:         'configMaps',
+    inputExponent: 0,
+    baseUnit:      '',
+    placeholder:   'Enter count',
+    increment:     1,
+  };
+
+  const podsType = {
+    value:         'pods',
+    inputExponent: 0,
+    baseUnit:      '',
+    placeholder:   'Enter count',
+    increment:     1,
+  };
+
+  const limitsCpuType = {
+    value:         'limitsCpu',
+    inputExponent: -1,
+    baseUnit:      '',
+    placeholder:   'Enter CPU',
+    increment:     1,
+  };
+
+  const extendedType = {
+    value:         TYPES.EXTENDED,
+    inputExponent: 0,
+    baseUnit:      '',
+    placeholder:   'Enter value',
+    increment:     1,
+  };
+
+  const allTypes = [mockType, podsType, limitsCpuType, extendedType];
+
+  const defaultProps = {
+    id:                    '1',
+    mode:                  'edit',
+    types:                 allTypes,
+    resourceType:          'configMaps',
+    resourceIdentifier:    'configMaps',
+    projectLimit:          '20',
+    namespaceDefaultLimit: '10',
+  };
+
+  const createWrapper = (propsOverrides: Record<string, unknown> = {}) => {
+    return shallowMount(ResourceQuotaEntry, {
+      props:  { ...defaultProps, ...propsOverrides },
+      global: { provide: { store } },
+    });
+  };
+
+  describe('rendering', () => {
+    it('should render all input fields with their data-testid attributes', () => {
+      const wrapper = createWrapper();
+
+      expect(wrapper.find('[data-testid="projectrow-type-input"]').exists()).toBe(true);
+      expect(wrapper.find('[data-testid="projectrow-custom-type-input"]').exists()).toBe(true);
+      expect(wrapper.find('[data-testid="projectrow-project-quota-input"]').exists()).toBe(true);
+      expect(wrapper.find('[data-testid="projectrow-namespace-quota-input"]').exists()).toBe(true);
+    });
+  });
+
+  describe('computed: typeOption', () => {
+    it('should return the matching type option for a given resourceType', () => {
+      const wrapper = createWrapper({ resourceType: 'configMaps' });
+
+      expect((wrapper.vm as any).typeOption).toStrictEqual(mockType);
+    });
+
+    it('should return the extended type option when resourceType is TYPES.EXTENDED', () => {
+      const wrapper = createWrapper({ resourceType: TYPES.EXTENDED });
+
+      expect((wrapper.vm as any).typeOption).toStrictEqual(extendedType);
+    });
+  });
+
+  describe('computed: isCustom', () => {
+    it('should return true when resourceType equals TYPES.EXTENDED', () => {
+      const wrapper = createWrapper({ resourceType: TYPES.EXTENDED });
+
+      expect((wrapper.vm as any).isCustom).toBe(true);
+    });
+
+    it.each([
+      ['configMaps'],
+      ['pods'],
+      ['limitsCpu'],
+    ])('should return false when resourceType is "%s"', (resourceType) => {
+      const wrapper = createWrapper({ resourceType });
+
+      expect((wrapper.vm as any).isCustom).toBe(false);
+    });
+  });
+
+  describe('computed: customTypeRules', () => {
+    it('should return an empty array when resourceType is a standard type', () => {
+      const wrapper = createWrapper({ resourceType: 'configMaps' });
+
+      expect((wrapper.vm as any).customTypeRules).toStrictEqual([]);
+    });
+
+    it('should return one validation rule when resourceType is TYPES.EXTENDED', () => {
+      const wrapper = createWrapper({ resourceType: TYPES.EXTENDED });
+
+      expect((wrapper.vm as any).customTypeRules).toHaveLength(1);
+    });
+
+    describe('validation rule behavior for custom type', () => {
+      it.each([
+        ['', 'resourceQuota.errors.customTypeRequired'],
+        [null, 'resourceQuota.errors.customTypeRequired'],
+        [undefined, 'resourceQuota.errors.customTypeRequired'],
+      ])('should return an error message for falsy value "%s"', (value, expectedError) => {
+        const wrapper = createWrapper({ resourceType: TYPES.EXTENDED });
+        const [rule] = (wrapper.vm as any).customTypeRules;
+
+        expect(rule(value)).toBe(expectedError);
+      });
+
+      it.each([
+        ['my-resource'],
+        ['cpu'],
+        ['custom.resource/name'],
+      ])('should return undefined for non-empty value "%s"', (value) => {
+        const wrapper = createWrapper({ resourceType: TYPES.EXTENDED });
+        const [rule] = (wrapper.vm as any).customTypeRules;
+
+        expect(rule(value)).toBeUndefined();
+      });
+    });
+  });
+
+  describe('method: remove', () => {
+    it('should emit remove event with the resource quota id', () => {
+      const id = 'test-remove-id';
+      const wrapper = createWrapper({ id });
+
+      (wrapper.vm as any).remove(id);
+
+      expect(wrapper.emitted('remove')).toBeTruthy();
+      expect(wrapper.emitted('remove')![0]).toStrictEqual([id]);
+    });
+
+    it('should emit remove when the Remove button is clicked', async() => {
+      const id = 'click-test-id';
+      const wrapper = createWrapper({ id });
+
+      await wrapper.findComponent(RcButton as any).trigger('click');
+
+      expect(wrapper.emitted('remove')).toBeTruthy();
+      expect(wrapper.emitted('remove')![0]).toStrictEqual([id]);
+    });
+  });
+
+  describe('method: updateResourceIdentifier', () => {
+    it('should emit update:resourceIdentifier with the new type for standard types', () => {
+      const wrapper = createWrapper({ resourceType: 'configMaps' });
+
+      (wrapper.vm as any).updateResourceIdentifier('pods');
+
+      expect(wrapper.emitted('update:resourceIdentifier')).toBeTruthy();
+      expect(wrapper.emitted('update:resourceIdentifier')![0]).toStrictEqual(['pods']);
+    });
+
+    it('should not emit update:resourceIdentifier when called with TYPES.EXTENDED', () => {
+      const wrapper = createWrapper({ resourceType: TYPES.EXTENDED });
+
+      (wrapper.vm as any).updateResourceIdentifier(TYPES.EXTENDED);
+
+      expect(wrapper.emitted('update:resourceIdentifier')).toBeFalsy();
+    });
+  });
+
+  describe('template: LabeledInput disabled state', () => {
+    it('should have the identifier input disabled when resourceType is a standard type', () => {
+      const wrapper = createWrapper({ resourceType: 'configMaps' });
+      const input = wrapper.findComponent(LabeledInput as any);
+
+      expect(input.props('disabled')).toBe(true);
+    });
+
+    it('should not have the identifier input disabled when resourceType is TYPES.EXTENDED', () => {
+      const wrapper = createWrapper({ resourceType: TYPES.EXTENDED });
+      const input = wrapper.findComponent(LabeledInput as any);
+
+      expect(input.props('disabled')).toBe(false);
+    });
+  });
+
+  describe('template: LabeledInput required state', () => {
+    it('should have the identifier input required when resourceType is TYPES.EXTENDED', () => {
+      const wrapper = createWrapper({ resourceType: TYPES.EXTENDED });
+      const input = wrapper.findComponent(LabeledInput as any);
+
+      expect(input.props('required')).toBe(true);
+    });
+
+    it('should not have the identifier input required when resourceType is a standard type', () => {
+      const wrapper = createWrapper({ resourceType: 'configMaps' });
+      const input = wrapper.findComponent(LabeledInput as any);
+
+      expect(input.props('required')).toBe(false);
+    });
+  });
+});

package/components/form/SchedulingCustomization.vue

@@ -7,6 +7,10 @@ export default {
   components: { Checkbox, Banner },
   emits:      ['scheduling-customization-changed'],
   props:      {
+    type: {
+      type:     String,
+      required: true,
+    },
     value: {
       type:    Object,
       default: () => {},
@@ -26,6 +30,10 @@ export default {
     defaultPDB: {
       type:    Object,
       default: () => {},
+    },
+    checkboxWithOnlyAgentName: {
+      type:    Boolean,
+      default: false
     }
   },
   data() {
@@ -59,10 +67,10 @@ export default {
     <Checkbox
       :value="enabled"
       :mode="mode"
-      label-key="cluster.agentConfig.subGroups.schedulingCustomization.label"
-      descriptionKey="cluster.agentConfig.subGroups.schedulingCustomization.description"
+      :label="checkboxWithOnlyAgentName ? t(`cluster.agentConfig.subGroups.agentsScheduling.${type}`) : t('cluster.agentConfig.subGroups.agentsScheduling.label', { agent: t(`cluster.agentConfig.subGroups.agentsScheduling.${type}`)})"
+      :description="checkboxWithOnlyAgentName ? '' :t('cluster.agentConfig.subGroups.agentsScheduling.description', { agent: t(`cluster.agentConfig.subGroups.agentsScheduling.${type}`)})"
       data-testid="scheduling-customization-checkbox"
-      @update:value="$emit('scheduling-customization-changed', $event)"
+      @update:value="$emit('scheduling-customization-changed', { event: $event, agentType: type })"
     >
       <template
         v-if="feature && isEdit && settingMissmatch"
@@ -71,13 +79,13 @@ export default {
         <Banner
           class="mt-10 mb-10"
           color="info"
-          label-key="cluster.agentConfig.subGroups.schedulingCustomization.banner"
+          :label="t('cluster.agentConfig.subGroups.agentsScheduling.banner', { agent: t(`cluster.agentConfig.subGroups.agentsScheduling.${type}`)})"
         />
         <Checkbox
           :value="applyGlobal"
           :mode="mode"
-          label-key="cluster.agentConfig.subGroups.schedulingCustomization.innerCheckbox"
-          @update:value="$emit('scheduling-customization-changed', feature)"
+          :label="t('cluster.agentConfig.subGroups.agentsScheduling.innerCheckbox', { agent: t(`cluster.agentConfig.subGroups.agentsScheduling.${type}`)})"
+          @update:value="$emit('scheduling-customization-changed', { event: $event, agentType: type })"
         />
       </template>
     </Checkbox>