@rancher/shell 3.0.9-rc.5 → 3.0.9-rc.6

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

@@ -0,0 +1,281 @@
+import { shallowMount } from '@vue/test-utils';
+import NamespaceRow from '@shell/components/form/ResourceQuota/NamespaceRow.vue';
+
+describe('namespaceRow', () => {
+  const storeMock = { getters: { 'i18n/t': (key: string) => key } };
+
+  const standardType = {
+    value:         'limitsCpu',
+    inputExponent: -1,
+    baseUnit:      '',
+    placeholder:   'Enter CPU',
+    increment:     1,
+  };
+
+  const extendedType = {
+    value:         'extended',
+    inputExponent: 0,
+    baseUnit:      '',
+    placeholder:   'Enter value',
+    increment:     1,
+  };
+
+  const defaultProps = {
+    mode:                         'edit',
+    type:                         'limitsCpu',
+    types:                        [standardType, extendedType],
+    value:                        { limit: { limitsCpu: '1000m' } },
+    namespace:                    { id: 'test-ns' },
+    projectResourceQuotaLimits:   { limitsCpu: '2000m' },
+    namespaceResourceQuotaLimits: [],
+    defaultResourceQuotaLimits:   { limitsCpu: '500m' },
+  };
+
+  const createWrapper = (propsOverrides: Record<string, unknown> = {}) => {
+    return shallowMount(NamespaceRow, {
+      props:  { ...defaultProps, ...propsOverrides },
+      global: { mocks: { $store: storeMock } },
+    });
+  };
+
+  describe('computed: displayType', () => {
+    it('returns the type unchanged for standard quota types', () => {
+      const wrapper: any = createWrapper({ type: 'limitsCpu' });
+
+      expect(wrapper.vm.displayType).toBe('limitsCpu');
+    });
+
+    it('strips the "extended." prefix for extended quota types', () => {
+      const wrapper: any = createWrapper({
+        type:                         'extended.requests.nvidia.com/gpu',
+        value:                        { limit: { extended: { 'requests.nvidia.com/gpu': '4' } } },
+        projectResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '8' },
+        defaultResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '2' },
+        namespaceResourceQuotaLimits: [],
+      });
+
+      expect(wrapper.vm.displayType).toBe('requests.nvidia.com/gpu');
+    });
+
+    it('strips only the leading "extended." when the resource identifier itself starts with "extended."', () => {
+      const wrapper: any = createWrapper({
+        type:                         'extended.extended.nvidia.com/gpu',
+        value:                        { limit: { extended: { 'extended.nvidia.com/gpu': '4' } } },
+        projectResourceQuotaLimits:   { 'extended.extended.nvidia.com/gpu': '8' },
+        defaultResourceQuotaLimits:   { 'extended.extended.nvidia.com/gpu': '2' },
+        namespaceResourceQuotaLimits: [],
+      });
+
+      expect(wrapper.vm.displayType).toBe('extended.nvidia.com/gpu');
+    });
+  });
+
+  describe('computed: currentLimit', () => {
+    it('returns the limit value for a standard quota type', () => {
+      const wrapper: any = createWrapper({
+        type:  'limitsCpu',
+        value: { limit: { limitsCpu: '1000m' } },
+      });
+
+      expect(wrapper.vm.currentLimit).toBe('1000m');
+    });
+
+    it('returns undefined when the standard type key is absent from limit', () => {
+      const wrapper: any = createWrapper({
+        type:  'limitsCpu',
+        value: { limit: {} },
+      });
+
+      expect(wrapper.vm.currentLimit).toBeUndefined();
+    });
+
+    it('reads the value from limit.extended for an extended quota type', () => {
+      const wrapper: any = createWrapper({
+        type:                         'extended.requests.nvidia.com/gpu',
+        value:                        { limit: { extended: { 'requests.nvidia.com/gpu': '4' } } },
+        projectResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '8' },
+        defaultResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '2' },
+        namespaceResourceQuotaLimits: [],
+      });
+
+      expect(wrapper.vm.currentLimit).toBe('4');
+    });
+
+    it('returns undefined when limit.extended is absent for an extended quota type', () => {
+      const wrapper: any = createWrapper({
+        type:                         'extended.requests.nvidia.com/gpu',
+        value:                        { limit: {} },
+        projectResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '8' },
+        defaultResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '2' },
+        namespaceResourceQuotaLimits: [],
+      });
+
+      expect(wrapper.vm.currentLimit).toBeUndefined();
+    });
+
+    it('reads the correct value when the resource identifier itself starts with "extended."', () => {
+      const wrapper: any = createWrapper({
+        type:                         'extended.extended.nvidia.com/gpu',
+        value:                        { limit: { extended: { 'extended.nvidia.com/gpu': '4' } } },
+        projectResourceQuotaLimits:   { 'extended.extended.nvidia.com/gpu': '8' },
+        defaultResourceQuotaLimits:   { 'extended.extended.nvidia.com/gpu': '2' },
+        namespaceResourceQuotaLimits: [],
+      });
+
+      expect(wrapper.vm.currentLimit).toBe('4');
+    });
+
+    it('returns undefined when the extended resource identifier is not in limit.extended', () => {
+      const wrapper: any = createWrapper({
+        type:                         'extended.requests.nvidia.com/gpu',
+        value:                        { limit: { extended: { 'example.com/fpga': '1' } } },
+        projectResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '8' },
+        defaultResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '2' },
+        namespaceResourceQuotaLimits: [],
+      });
+
+      expect(wrapper.vm.currentLimit).toBeUndefined();
+    });
+
+    it.each([
+      ['limitsCpu', { limitsCpu: '500m' }, '500m'],
+      ['configMaps', { configMaps: '10' }, '10'],
+      ['pods', { pods: '20' }, '20'],
+    ])('returns the correct value for standard type "%s"', (type, limit, expected) => {
+      const wrapper: any = createWrapper({
+        type,
+        types: [
+          {
+            value: type, inputExponent: 0, baseUnit: '', placeholder: '', increment: 1
+          },
+          extendedType,
+        ],
+        value:                      { limit },
+        projectResourceQuotaLimits: { [type]: '100' },
+        defaultResourceQuotaLimits: { [type]: '0' },
+      });
+
+      expect(wrapper.vm.currentLimit).toBe(expected);
+    });
+  });
+
+  describe('mounted(): initial value emission', () => {
+    it('emits update:value on mount with the type as the first argument', () => {
+      const wrapper: any = createWrapper({
+        type:  'limitsCpu',
+        value: { limit: { limitsCpu: '1000m' } },
+      });
+
+      const emitted = wrapper.emitted('update:value');
+
+      expect(emitted).toBeTruthy();
+      expect(emitted![0][0]).toBe('limitsCpu');
+    });
+
+    it('emits update:value on mount when currentLimit is not set, using defaultResourceQuotaLimits', () => {
+      const wrapper: any = createWrapper({
+        type:                       'limitsCpu',
+        value:                      { limit: {} },
+        projectResourceQuotaLimits: { limitsCpu: '2000m' },
+        defaultResourceQuotaLimits: { limitsCpu: '500m' },
+      });
+
+      const emitted = wrapper.emitted('update:value');
+
+      expect(emitted).toBeTruthy();
+      expect(emitted![0][0]).toBe('limitsCpu');
+    });
+
+    it('emits update:value on mount for an extended quota type', () => {
+      const wrapper: any = createWrapper({
+        type:                         'extended.requests.nvidia.com/gpu',
+        value:                        { limit: { extended: { 'requests.nvidia.com/gpu': '4' } } },
+        projectResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '8' },
+        defaultResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '2' },
+        namespaceResourceQuotaLimits: [],
+      });
+
+      const emitted = wrapper.emitted('update:value');
+
+      expect(emitted).toBeTruthy();
+      expect(emitted![0][0]).toBe('extended.requests.nvidia.com/gpu');
+    });
+  });
+
+  describe('computed: totalContribution', () => {
+    it('equals zero when currentLimit is 0 and no other namespaces contribute', () => {
+      const wrapper: any = createWrapper({
+        type:                         'limitsCpu',
+        value:                        { limit: { limitsCpu: '0' } },
+        projectResourceQuotaLimits:   { limitsCpu: '2000m' },
+        namespaceResourceQuotaLimits: [],
+        defaultResourceQuotaLimits:   { limitsCpu: '0' },
+      });
+
+      expect(wrapper.vm.totalContribution).toBe(0);
+    });
+
+    it('includes contributions from other namespaces alongside the current limit', () => {
+      // ns2 contributes 500m, current namespace has 0
+      const wrapper: any = createWrapper({
+        type:                         'limitsCpu',
+        value:                        { limit: { limitsCpu: '0' } },
+        projectResourceQuotaLimits:   { limitsCpu: '2000m' },
+        namespaceResourceQuotaLimits: [
+          { id: 'ns2', limitsCpu: '500m' },
+        ],
+        defaultResourceQuotaLimits: { limitsCpu: '0' },
+        namespace:                  { id: 'test-ns' },
+      });
+
+      // ns2's 500m contribution should be included
+      expect(wrapper.vm.totalContribution).toBeGreaterThan(0);
+    });
+
+    it('uses currentLimit for the extended type in the total', () => {
+      const wrapper: any = createWrapper({
+        type:                         'extended.requests.nvidia.com/gpu',
+        value:                        { limit: { extended: { 'requests.nvidia.com/gpu': '0' } } },
+        projectResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '8' },
+        namespaceResourceQuotaLimits: [],
+        defaultResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '0' },
+      });
+
+      expect(wrapper.vm.totalContribution).toBe(0);
+    });
+  });
+
+  describe('computed: namespaceLimits', () => {
+    it('excludes the current namespace from the list', () => {
+      const wrapper: any = createWrapper({
+        type:                         'limitsCpu',
+        value:                        { limit: { limitsCpu: '500m' } },
+        projectResourceQuotaLimits:   { limitsCpu: '2000m' },
+        namespaceResourceQuotaLimits: [
+          { id: 'test-ns', limitsCpu: '500m' },
+          { id: 'other-ns', limitsCpu: '300m' },
+        ],
+        namespace:                  { id: 'test-ns' },
+        defaultResourceQuotaLimits: { limitsCpu: '0' },
+      });
+
+      // Only the other namespace should contribute
+      expect(wrapper.vm.namespaceLimits).toHaveLength(1);
+    });
+
+    it('handles flattened extended keys from namespaceResourceQuotaLimits', () => {
+      const wrapper: any = createWrapper({
+        type:                         'extended.requests.nvidia.com/gpu',
+        value:                        { limit: { extended: { 'requests.nvidia.com/gpu': '1' } } },
+        projectResourceQuotaLimits:   { 'extended.requests.nvidia.com/gpu': '8' },
+        namespaceResourceQuotaLimits: [
+          { id: 'other-ns', 'extended.requests.nvidia.com/gpu': '2' },
+        ],
+        namespace:                  { id: 'test-ns' },
+        defaultResourceQuotaLimits: { 'extended.requests.nvidia.com/gpu': '0' },
+      });
+
+      expect(wrapper.vm.namespaceLimits).toHaveLength(1);
+    });
+  });
+});

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]);
+    });
   });
 });