@rancher/shell 3.0.12-rc.1 → 3.0.12-rc.3

package/utils/__tests__/units.test.ts

@@ -0,0 +1,417 @@
+import {
+  exponentNeeded,
+  formatSi,
+  parseSi,
+  createMemoryFormat,
+  createMemoryValues,
+  UNITS,
+  FRACTIONAL,
+  MEMORY_PARSE_RULES,
+} from '@shell/utils/units';
+
+describe('units', () => {
+  describe('exported constants', () => {
+    it('exports expected UNITS prefixes', () => {
+      expect(UNITS).toStrictEqual(['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y']);
+    });
+
+    it('exports expected FRACTIONAL prefixes', () => {
+      expect(FRACTIONAL).toStrictEqual(['', 'm', 'u', 'n', 'p', 'f', 'a', 'z', 'y']);
+    });
+  });
+
+  describe('exponentNeeded', () => {
+    it.each([
+      {
+        desc:     'returns 0 for value below increment',
+        value:    999,
+        expected: 0,
+      },
+      {
+        desc:     'returns 1 for value equal to increment',
+        value:    1000,
+        expected: 1,
+      },
+      {
+        desc:     'returns 2 for value 1_000_000',
+        value:    1_000_000,
+        expected: 2,
+      },
+      {
+        desc:     'returns 3 for value 1_000_000_000',
+        value:    1_000_000_000,
+        expected: 3,
+      },
+      {
+        desc:      'uses custom increment when provided',
+        value:     1024,
+        increment: 1024,
+        expected:  1,
+      },
+      {
+        desc:     'returns 0 for value 0',
+        value:    0,
+        expected: 0,
+      },
+      {
+        desc:     'returns 0 for value 1',
+        value:    1,
+        expected: 0,
+      },
+    ])('$desc', ({ value, increment, expected }) => {
+      expect(exponentNeeded(value, increment)).toStrictEqual(expected);
+    });
+  });
+
+  describe('formatSi', () => {
+    describe('default options (increment=1000)', () => {
+      it.each([
+        {
+          desc:     'formats 0',
+          input:    0,
+          expected: '0 ',
+        },
+        {
+          desc:     'formats 999',
+          input:    999,
+          expected: '999 ',
+        },
+        {
+          desc:     'formats 1000 as 1 K',
+          input:    1000,
+          expected: '1 K',
+        },
+        {
+          desc:     'formats 1500 as 1.5 K',
+          input:    1500,
+          expected: '1.5 K',
+        },
+        {
+          desc:     'formats 1_000_000 as 1 M',
+          input:    1_000_000,
+          expected: '1 M',
+        },
+        {
+          desc:     'formats 1_500_000 as 1.5 M',
+          input:    1_500_000,
+          expected: '1.5 M',
+        },
+        {
+          desc:     'formats 1_000_000_000 as 1 G',
+          input:    1_000_000_000,
+          expected: '1 G',
+        },
+        {
+          desc:     'formats 1_000_000_000_000 as 1 T',
+          input:    1_000_000_000_000,
+          expected: '1 T',
+        },
+        {
+          desc:     'formats with 2 decimal precision for values < 10',
+          input:    1234,
+          expected: '1.23 K',
+        },
+      ])('$desc', ({ input, expected }) => {
+        expect(formatSi(input)).toStrictEqual(expected);
+      });
+    });
+
+    describe('suffix options', () => {
+      it.each([
+        {
+          desc:     'appends suffix',
+          input:    1000,
+          options:  { suffix: 'B' },
+          expected: '1 KB',
+        },
+        {
+          desc:     'uses firstSuffix for exponent 0',
+          input:    500,
+          options:  { suffix: 'B', firstSuffix: 'B' },
+          expected: '500 B',
+        },
+        {
+          desc:     'does not use firstSuffix when exponent > 0',
+          input:    1000,
+          options:  { suffix: 'B', firstSuffix: 'B' },
+          expected: '1 KB',
+        },
+        {
+          desc:     'omits suffix space when addSuffixSpace=false',
+          input:    1000,
+          options:  { addSuffixSpace: false, suffix: 'B' },
+          expected: '1KB',
+        },
+        {
+          desc:     'omits suffix entirely when addSuffix=false',
+          input:    1000,
+          options:  { addSuffix: false },
+          expected: '1',
+        },
+      ])('$desc', ({ input, options, expected }) => {
+        expect(formatSi(input, options)).toStrictEqual(expected);
+      });
+    });
+
+    describe('increment=1024', () => {
+      it.each([
+        {
+          desc:    'formats 1024 as 1 KiB',
+          input:   1024,
+          options: {
+            increment:   1024,
+            suffix:      'iB',
+            firstSuffix: 'B',
+          },
+          expected: '1 KiB',
+        },
+        {
+          desc:     'formats 1048576 as 1 MiB',
+          input:    1048576,
+          options:  { increment: 1024, suffix: 'iB' },
+          expected: '1 MiB',
+        },
+      ])('$desc', ({ input, options, expected }) => {
+        expect(formatSi(input, options)).toStrictEqual(expected);
+      });
+    });
+
+    describe('minExponent / maxExponent', () => {
+      it.each([
+        {
+          desc:     'respects minExponent to force higher unit',
+          input:    500,
+          options:  { minExponent: 1, addSuffix: false },
+          expected: '0.5',
+        },
+        {
+          desc:     'respects maxExponent to cap scaling',
+          input:    1_000_000,
+          options:  { maxExponent: 1, addSuffix: false },
+          expected: '1000',
+        },
+      ])('$desc', ({ input, options, expected }) => {
+        expect(formatSi(input, options)).toStrictEqual(expected);
+      });
+    });
+
+    describe('maxPrecision', () => {
+      it.each([
+        {
+          desc:     'uses integer for maxPrecision=0',
+          input:    1500,
+          options:  { maxPrecision: 0 },
+          expected: '2 K',
+        },
+        {
+          desc:     'uses 1 decimal for maxPrecision=1',
+          input:    1500,
+          options:  { maxPrecision: 1 },
+          expected: '1.5 K',
+        },
+      ])('$desc', ({ input, options, expected }) => {
+        expect(formatSi(input, options)).toStrictEqual(expected);
+      });
+    });
+
+    describe('canRoundToZero=false', () => {
+      it('avoids returning "0" by adjusting exponent', () => {
+        // 1 byte formatted as KiB would be 0, but canRoundToZero=false forces min representation
+        const result = formatSi(1, {
+          increment:      1024,
+          canRoundToZero: false,
+          suffix:         'iB',
+          firstSuffix:    'B',
+        });
+
+        expect(result).not.toStrictEqual('0 ');
+        expect(result).toStrictEqual('1 B');
+      });
+    });
+
+    describe('startingExponent', () => {
+      it('starts from specified exponent', () => {
+        // startingExponent=1 means value is already in K
+        expect(formatSi(1, { startingExponent: 1 })).toStrictEqual('1 K');
+      });
+    });
+  });
+
+  describe('parseSi', () => {
+    it.each([
+      {
+        desc:     'parses 1K to 1000',
+        input:    '1K',
+        expected: 1000,
+      },
+      {
+        desc:     'parses 1M to 1_000_000',
+        input:    '1M',
+        expected: 1_000_000,
+      },
+      {
+        desc:     'parses 1G to 1_000_000_000',
+        input:    '1G',
+        expected: 1_000_000_000,
+      },
+      {
+        desc:     'parses 1T to 1_000_000_000_000',
+        input:    '1T',
+        expected: 1_000_000_000_000,
+      },
+      {
+        desc:     'parses plain number string',
+        input:    '500',
+        expected: 500,
+      },
+      {
+        desc:     'parses decimal number string',
+        input:    '1.5K',
+        expected: 1500,
+      },
+      {
+        desc:     'parses KiB with increment=1024',
+        input:    '1Ki',
+        expected: 1024,
+      },
+      {
+        desc:     'parses MiB with increment=1024',
+        input:    '1Mi',
+        expected: 1048576,
+      },
+      {
+        desc:     'strips commas from numeric strings',
+        input:    '1,000',
+        expected: 1000,
+      },
+      {
+        desc:     'ignores unrecognized unit suffix',
+        input:    '100X',
+        expected: 100,
+      },
+    ])('$desc', ({ input, expected }) => {
+      expect(parseSi(input)).toStrictEqual(expected);
+    });
+
+    it.each([
+      {
+        desc:  'empty string',
+        input: '',
+      },
+      {
+        desc:  'null',
+        input: null as any,
+      },
+      {
+        desc:  'undefined',
+        input: undefined as any,
+      },
+      {
+        desc:  'non-string input',
+        input: 123 as any,
+      },
+    ])('returns NaN for $desc', ({ input }) => {
+      expect(parseSi(input)).toStrictEqual(NaN);
+    });
+
+    it('parses fractional milli unit (m)', () => {
+      // 1m = 1 * 1/1000 = 0.001
+      expect(parseSi('1m')).toBeCloseTo(0.001);
+    });
+
+    it('falls back to multiply path when allowFractional=false and unit matches UNITS uppercase', () => {
+      // 'm'.toUpperCase() === 'M' is in UNITS (Mega), so parsed as 1 * 1000^2 = 1_000_000
+      expect(parseSi('1m', { allowFractional: false })).toStrictEqual(1_000_000);
+    });
+
+    it('uses custom increment option', () => {
+      expect(parseSi('1K', { increment: 1024 })).toStrictEqual(1024);
+    });
+
+    it('handles micro symbol (µ) as u', () => {
+      // charCode 181 is µ, should be treated as 'u' (micro)
+      const mu = String.fromCharCode(181);
+
+      expect(parseSi(`1${ mu }`)).toBeCloseTo(0.000001);
+    });
+  });
+
+  describe('createMemoryFormat', () => {
+    it.each([
+      {
+        desc:     'locks exponent for 1 KiB',
+        value:    1024,
+        expected: 1,
+      },
+      {
+        desc:     'sets GiB exponent for 1 GiB',
+        value:    1024 * 1024 * 1024,
+        expected: 3,
+      },
+      {
+        desc:     'sets byte exponent for 0',
+        value:    0,
+        expected: 0,
+      },
+    ])('$desc', ({ value, expected }) => {
+      const fmt = createMemoryFormat(value);
+
+      expect(fmt.maxExponent).toStrictEqual(expected);
+      expect(fmt.minExponent).toStrictEqual(expected);
+    });
+
+    it('includes all MEMORY_PARSE_RULES format properties', () => {
+      const base = MEMORY_PARSE_RULES.memory.format;
+      const fmt = createMemoryFormat(1024);
+
+      expect(fmt.increment).toStrictEqual(base.increment);
+      expect(fmt.addSuffix).toStrictEqual(base.addSuffix);
+      expect(fmt.firstSuffix).toStrictEqual(base.firstSuffix);
+      expect(fmt.suffix).toStrictEqual(base.suffix);
+      expect(fmt.maxPrecision).toStrictEqual(base.maxPrecision);
+    });
+  });
+
+  describe('createMemoryValues', () => {
+    it('converts bytes total and useful to same unit', () => {
+      const result = createMemoryValues('1073741824', '536870912'); // 1GiB total, 512MiB useful
+
+      expect(result.total).toStrictEqual(1);
+      expect(result.useful).toStrictEqual(0.5);
+      expect(result.units).toStrictEqual('GiB');
+    });
+
+    it('handles 0 total and useful', () => {
+      const result = createMemoryValues('0', '0');
+
+      expect(result.total).toStrictEqual(0);
+      expect(result.useful).toStrictEqual(0);
+      // UNITS[0] = '' + suffix 'iB' = 'iB'
+      expect(result.units).toStrictEqual('iB');
+    });
+
+    it('handles null/undefined by treating as 0', () => {
+      const result = createMemoryValues(null as any, undefined as any);
+
+      expect(result.total).toStrictEqual(0);
+      expect(result.useful).toStrictEqual(0);
+      expect(result.units).toStrictEqual('iB');
+    });
+
+    it('accepts numeric strings with Si notation', () => {
+      const result = createMemoryValues('1Ki', '512');
+
+      expect(result.units).toStrictEqual('KiB');
+      expect(result.total).toStrictEqual(1);
+      expect(result.useful).toStrictEqual(0.5);
+    });
+
+    it('rounds to 2 decimal places', () => {
+      // 1.005 * 1024 = 1029.12 bytes, expressed in KiB = ~1.005
+      const result = createMemoryValues('1049600', '524800'); // slightly over 1024*1024 and 512*1024
+
+      expect(result.total).toStrictEqual(Math.round((1049600 / 1048576) * 100) / 100);
+      expect(result.useful).toStrictEqual(Math.round((524800 / 1048576) * 100) / 100);
+    });
+  });
+});

package/utils/__tests__/url.test.ts

@@ -0,0 +1,246 @@
+import {
+  addParam, addParams, removeParam, parseLinkHeader, isMaybeSecure, portMatch, parse, stringify
+} from '@shell/utils/url';
+
+describe('fx: addParam', () => {
+  it('should add a query parameter to a URL without existing params', () => {
+    expect(addParam('https://example.com/path', 'foo', 'bar')).toStrictEqual('https://example.com/path?foo=bar');
+  });
+
+  it('should append a query parameter to a URL with existing params', () => {
+    expect(addParam('https://example.com/path?a=1', 'b', '2')).toStrictEqual('https://example.com/path?a=1&b=2');
+  });
+
+  it('should encode special characters in key and value', () => {
+    expect(addParam('https://example.com', 'my key', 'hello world')).toStrictEqual('https://example.com?my%20key=hello%20world');
+  });
+
+  it('should add multiple values from an array', () => {
+    expect(addParam('https://example.com', 'tag', ['a', 'b'])).toStrictEqual('https://example.com?tag=a&tag=b');
+  });
+
+  it('should add a key-only param when value is null', () => {
+    expect(addParam('https://example.com', 'flag', null)).toStrictEqual('https://example.com?flag');
+  });
+
+  it('should handle an array with a null value', () => {
+    expect(addParam('https://example.com', 'flag', [null])).toStrictEqual('https://example.com?flag');
+  });
+
+  it('should add a param with an empty string value', () => {
+    expect(addParam('https://example.com', 'key', '')).toStrictEqual('https://example.com?key=');
+  });
+
+  it('should add a duplicate key as an additional param', () => {
+    expect(addParam('https://example.com?a=1', 'a', '2')).toStrictEqual('https://example.com?a=1&a=2');
+  });
+});
+
+describe('fx: addParams', () => {
+  it('should add multiple parameters to a URL', () => {
+    expect(addParams('https://example.com', { a: '1', b: '2' })).toStrictEqual('https://example.com?a=1&b=2');
+  });
+
+  it('should return the URL unchanged if params is empty', () => {
+    expect(addParams('https://example.com', {})).toStrictEqual('https://example.com');
+  });
+
+  it('should return the URL unchanged if params is null', () => {
+    expect(addParams('https://example.com', null)).toStrictEqual('https://example.com');
+  });
+
+  it('should return the URL unchanged if params is a non-object value', () => {
+    expect(addParams('https://example.com', 'not-an-object')).toStrictEqual('https://example.com');
+  });
+});
+
+describe('fx: removeParam', () => {
+  it('should remove a query parameter from a URL', () => {
+    expect(removeParam('https://example.com?foo=bar&baz=qux', 'foo')).toStrictEqual('https://example.com/?baz=qux');
+  });
+
+  it('should return a normalized URL if the param does not exist', () => {
+    expect(removeParam('https://example.com?a=1', 'nonexistent')).toStrictEqual('https://example.com/?a=1');
+  });
+
+  it('should remove the only query parameter', () => {
+    expect(removeParam('https://example.com?only=param', 'only')).toStrictEqual('https://example.com/');
+  });
+
+  it('should normalize a key-only query parameter to key= (parser treats it as empty value)', () => {
+    expect(removeParam('https://example.com?flag', 'flag')).toStrictEqual('https://example.com/?flag=');
+  });
+});
+
+describe('fx: parseLinkHeader', () => {
+  it('should parse a single link header entry', () => {
+    expect(parseLinkHeader('<https://example.com/page2>; rel="next"')).toStrictEqual({ next: 'https://example.com/page2' });
+  });
+
+  it('should parse multiple link header entries', () => {
+    const header = '<https://example.com/page2>; rel="next", <https://example.com/page1>; rel="prev"';
+
+    expect(parseLinkHeader(header)).toStrictEqual({
+      next: 'https://example.com/page2',
+      prev: 'https://example.com/page1',
+    });
+  });
+
+  it('should return an empty object for an empty string', () => {
+    expect(parseLinkHeader('')).toStrictEqual({});
+  });
+
+  it('should return an empty object for a malformed header', () => {
+    expect(parseLinkHeader('not a valid link header')).toStrictEqual({});
+  });
+
+  it('should lowercase the rel value', () => {
+    expect(parseLinkHeader('<https://example.com>; rel="Next"')).toStrictEqual({ next: 'https://example.com' });
+  });
+});
+
+describe('fx: portMatch', () => {
+  it.each([
+    {
+      ports: [443], equals: [443, 8443], endsWith: [], expected: true, desc: 'port is in the equals list'
+    },
+    {
+      ports: [8080], equals: [443, 8443], endsWith: ['443'], expected: false, desc: 'port is not in equals or endsWith lists'
+    },
+    {
+      ports: [8443], equals: [], endsWith: ['443'], expected: true, desc: 'port string ends with the given suffix'
+    },
+    {
+      ports: [443], equals: [], endsWith: ['443'], expected: false, desc: 'port equals the suffix exactly (endsWith excludes exact match)'
+    },
+    {
+      ports: [], equals: [443], endsWith: ['443'], expected: false, desc: 'ports array is empty'
+    },
+    {
+      ports: [80, 443], equals: [443], endsWith: [], expected: true, desc: 'any port in the array matches equals'
+    },
+    {
+      ports: [18443], equals: [], endsWith: ['443'], expected: true, desc: 'multi-digit port ending with suffix'
+    },
+  ])('should return $expected when $desc', ({
+    ports, equals, endsWith, expected
+  }) => {
+    expect(portMatch(ports, equals, endsWith)).toBe(expected);
+  });
+});
+
+describe('fx: isMaybeSecure', () => {
+  it.each([
+    {
+      port: 80, proto: 'https', expected: true, desc: 'https protocol'
+    },
+    {
+      port: 80, proto: 'HTTPS', expected: true, desc: 'HTTPS protocol (case-insensitive)'
+    },
+    {
+      port: 443, proto: 'http', expected: true, desc: 'port 443'
+    },
+    {
+      port: 8443, proto: 'http', expected: true, desc: 'port 8443'
+    },
+    {
+      port: 18443, proto: 'http', expected: true, desc: 'port 18443 (endsWith 443)'
+    },
+    {
+      port: 80, proto: 'http', expected: false, desc: 'http on non-secure port'
+    },
+  ])('should return $expected for $desc', ({ port, proto, expected }) => {
+    expect(isMaybeSecure(port, proto)).toBe(expected);
+  });
+});
+
+describe('fx: parse', () => {
+  it('should parse a simple URL', () => {
+    const result = parse('https://example.com/path?foo=bar');
+
+    expect(result.protocol).toStrictEqual('https');
+    expect(result.host).toStrictEqual('example.com');
+    expect(result.path).toStrictEqual('/path');
+    expect(result.query).toStrictEqual({ foo: 'bar' });
+  });
+
+  it('should parse a URL with port', () => {
+    const result = parse('https://example.com:8080/');
+
+    expect(result.host).toStrictEqual('example.com');
+    expect(result.port).toStrictEqual('8080');
+  });
+
+  it('should parse a URL with user credentials', () => {
+    const result = parse('https://user:pass@example.com/');
+
+    expect(result.user).toStrictEqual('user');
+    expect(result.password).toStrictEqual('pass');
+  });
+
+  it('should parse a URL with anchor', () => {
+    const result = parse('https://example.com/page#section1');
+
+    expect(result.anchor).toStrictEqual('section1');
+  });
+
+  it('should parse a URL with multiple query params', () => {
+    expect(parse('https://example.com?a=1&b=2').query).toStrictEqual({ a: '1', b: '2' });
+  });
+
+  it('should parse a URL with user only (no password)', () => {
+    const result = parse('https://admin@example.com/');
+
+    expect(result.user).toStrictEqual('admin');
+    expect(result.password).toStrictEqual('');
+  });
+
+  it('should set empty strings for missing optional fields', () => {
+    const result = parse('https://example.com/path');
+
+    expect(result.port).toStrictEqual('');
+    expect(result.anchor).toStrictEqual('');
+    expect(result.user).toStrictEqual('');
+    expect(result.password).toStrictEqual('');
+  });
+});
+
+describe('fx: stringify', () => {
+  it('should reconstruct a simple URL', () => {
+    expect(stringify(parse('https://example.com/path'))).toStrictEqual('https://example.com/path');
+  });
+
+  it('should include user and password when both present', () => {
+    expect(stringify(parse('https://user:pass@example.com/'))).toStrictEqual('https://user:pass@example.com/');
+  });
+
+  it('should include user only when password is absent', () => {
+    expect(stringify(parse('https://admin@example.com/'))).toStrictEqual('https://admin@example.com/');
+  });
+
+  it('should include port when present', () => {
+    expect(stringify(parse('https://example.com:9090/'))).toStrictEqual('https://example.com:9090/');
+  });
+
+  it('should include anchor when present', () => {
+    expect(stringify(parse('https://example.com/page#section'))).toStrictEqual('https://example.com/page#section');
+  });
+
+  it('should default path to / when path is empty', () => {
+    const parsed = parse('https://example.com');
+
+    parsed.path = '';
+
+    expect(stringify(parsed)).toStrictEqual('https://example.com/');
+  });
+
+  it('should include query parameters', () => {
+    expect(stringify(parse('https://example.com/path?a=1&b=2'))).toStrictEqual('https://example.com/path?a=1&b=2');
+  });
+
+  it('should round-trip a complex URL', () => {
+    const url = 'https://user:pass@example.com:8080/some/path?key=value&other=test#anchor';
+
+    expect(stringify(parse(url))).toStrictEqual(url);
+  });
+});