@rancher/shell 3.0.12-rc.2 → 3.0.12-rc.4

package/utils/__tests__/parse-externalid.test.ts

@@ -0,0 +1,137 @@
+import { parseExternalId, parseHelmExternalId } from '@shell/utils/parse-externalid';
+
+describe('parseExternalId', () => {
+  describe('falsy / empty input', () => {
+    it.each([
+      { desc: 'null', input: null },
+      { desc: 'undefined', input: undefined },
+      { desc: 'empty string', input: '' },
+    ])('returns all-null output for $desc', ({ input }) => {
+      expect(parseExternalId(input as any)).toStrictEqual({
+        kind:    null,
+        group:   null,
+        base:    null,
+        id:      null,
+        name:    null,
+        version: null,
+      });
+    });
+  });
+
+  describe('new-style: kind://group:name:version', () => {
+    it('extracts kind, group, name and version from a full new-style id', () => {
+      const result = parseExternalId('catalog://library:mysql:1.2.3');
+
+      expect(result.kind).toStrictEqual('catalog');
+      expect(result.group).toStrictEqual('library');
+      expect(result.name).toStrictEqual('mysql');
+      expect(result.version).toStrictEqual('1.2.3');
+      expect(result.id).toStrictEqual('library:mysql:1.2.3');
+      expect(result.templateId).toStrictEqual('library:mysql');
+    });
+
+    it('handles name with base separator (*)', () => {
+      const result = parseExternalId('catalog://library:base*app:1.0.0');
+
+      expect(result.base).toStrictEqual('base');
+      expect(result.name).toStrictEqual('app');
+      expect(result.version).toStrictEqual('1.0.0');
+    });
+
+    it('uses part before colon as group', () => {
+      // For 'containers://someimage:latest', group='someimage', name='latest'
+      const result = parseExternalId('containers://someimage:latest');
+
+      expect(result.kind).toStrictEqual('containers');
+      expect(result.group).toStrictEqual('someimage');
+      expect(result.name).toStrictEqual('latest');
+      expect(result.version).toBeNull();
+    });
+
+    it('name with no version (no trailing colon) sets version to null', () => {
+      const result = parseExternalId('catalog://library:nameonly');
+
+      expect(result.name).toStrictEqual('nameonly');
+      expect(result.version).toBeNull();
+    });
+  });
+
+  describe('new-style: kind://name (no group, no colon in rest)', () => {
+    it('leaves group null when rest has no colon', () => {
+      // NOTE: EXTERNAL_ID.KIND_CATALOG is undefined, so the "set library group for
+      // catalog kind" branch is unreachable (kind === undefined condition never matches).
+      // group stays null for all kinds when rest contains no colon.
+      const result = parseExternalId('catalog://appname');
+
+      expect(result.kind).toStrictEqual('catalog');
+      expect(result.group).toBeNull();
+      expect(result.name).toStrictEqual('appname');
+    });
+  });
+
+  describe('old-style: name-version (no ://)', () => {
+    it('extracts group, name and version from a name-version string', () => {
+      // NOTE: EXTERNAL_ID.KIND_CATALOG is not defined, so result.kind is undefined (not 'catalog').
+      // All other fields (group, name, version, templateId) are populated correctly.
+      const result = parseExternalId('mysql-1.2.3');
+
+      expect(result.kind).toBeUndefined();
+      expect(result.group).toStrictEqual('library');
+      expect(result.name).toStrictEqual('mysql');
+      expect(result.version).toStrictEqual('1.2.3');
+      expect(result.templateId).toStrictEqual('library:mysql');
+    });
+
+    it('splits on last hyphen so names with hyphens are preserved', () => {
+      const result = parseExternalId('my-app-chart-0.1.0');
+
+      expect(result.kind).toBeUndefined();
+      expect(result.group).toStrictEqual('library');
+      expect(result.version).toStrictEqual('0.1.0');
+      expect(result.name).toStrictEqual('my-app-chart');
+    });
+  });
+});
+
+describe('parseHelmExternalId', () => {
+  describe('falsy / empty input', () => {
+    it.each([
+      { desc: 'null', input: null },
+      { desc: 'undefined', input: undefined },
+      { desc: 'empty string', input: '' },
+    ])('returns all-null output for $desc', ({ input }) => {
+      expect(parseHelmExternalId(input as any)).toStrictEqual({
+        kind:    null,
+        group:   null,
+        base:    null,
+        id:      null,
+        name:    null,
+        version: null,
+      });
+    });
+  });
+
+  describe('valid helm external id', () => {
+    it('parses a helm id with catalog containing a slash (catalog/chart format)', () => {
+      // Format: kind:///key=val&key=val — the key=val pairs are parsed directly
+      const id = 'catalog:///catalog=cattle-global-data/mycharts&template=nginx&version=1.0.0';
+      const result = parseHelmExternalId(id);
+
+      expect(result.kind).toStrictEqual('catalog');
+      expect(result.id).toStrictEqual(id);
+      expect(result.template).toStrictEqual('nginx');
+      expect(result.version).toStrictEqual('1.0.0');
+      // catalog contains slash → replaced with colon for templateId prefix
+      expect(result.templateId).toStrictEqual('cattle-global-data:mycharts-nginx');
+      expect(result.templateVersionId).toStrictEqual('cattle-global-data:mycharts-nginx-1.0.0');
+    });
+
+    it('prepends cattle-global-data: prefix when catalog value has no slash', () => {
+      const id = 'catalog:///catalog=mycharts&template=redis&version=2.0.0';
+      const result = parseHelmExternalId(id);
+
+      expect(result.templateId).toStrictEqual('cattle-global-data:mycharts-redis');
+      expect(result.templateVersionId).toStrictEqual('cattle-global-data:mycharts-redis-2.0.0');
+    });
+  });
+});

package/utils/__tests__/perf-setting.utils.test.ts

@@ -0,0 +1,98 @@
+import perfSettingUtils from '@shell/utils/perf-setting.utils';
+import { PerfSettings } from '@shell/config/settings';
+
+const makePerfSettings = (incrementalLoading: boolean, manualRefresh: boolean): PerfSettings => ({
+  inactivity:                   { enabled: false, threshold: 0 },
+  incrementalLoading:           { enabled: incrementalLoading, threshold: 0 },
+  manualRefresh:                { enabled: manualRefresh, threshold: 0 },
+  disableWebsocketNotification: false,
+  garbageCollection:            {} as any,
+  forceNsFilterV2:              null,
+  advancedWorker:               {},
+  kubeAPI:                      { warningHeader: { separator: '', notificationBlockList: [] } },
+  serverPagination:             {} as any,
+});
+
+describe('perf-setting.utils', () => {
+  describe('incrementalLoadingUtils.isEnabled', () => {
+    it.each([
+      {
+        desc:              'SSP disabled, performance setting enabled → enabled',
+        paginationEnabled: false,
+        perfEnabled:       true,
+        expected:          true,
+      },
+      {
+        desc:              'SSP disabled, performance setting disabled → disabled',
+        paginationEnabled: false,
+        perfEnabled:       false,
+        expected:          false,
+      },
+      {
+        desc:              'SSP enabled takes precedence even if performance setting enabled → disabled',
+        paginationEnabled: true,
+        perfEnabled:       true,
+        expected:          false,
+      },
+      {
+        desc:              'SSP enabled, performance setting disabled → disabled',
+        paginationEnabled: true,
+        perfEnabled:       false,
+        expected:          false,
+      },
+    ])('$desc', ({ paginationEnabled, perfEnabled, expected }) => {
+      const settings = makePerfSettings(perfEnabled, false);
+
+      expect(perfSettingUtils.incrementalLoadingUtils.isEnabled(paginationEnabled, settings)).toStrictEqual(expected);
+    });
+  });
+
+  describe('manualRefreshUtils.isEnabled', () => {
+    it.each([
+      {
+        desc:              'SSP disabled, performance setting enabled → enabled',
+        paginationEnabled: false,
+        perfEnabled:       true,
+        expected:          true,
+      },
+      {
+        desc:              'SSP disabled, performance setting disabled → disabled',
+        paginationEnabled: false,
+        perfEnabled:       false,
+        expected:          false,
+      },
+      {
+        desc:              'SSP enabled takes precedence even if performance setting enabled → disabled',
+        paginationEnabled: true,
+        perfEnabled:       true,
+        expected:          false,
+      },
+      {
+        desc:              'SSP enabled, performance setting disabled → disabled',
+        paginationEnabled: true,
+        perfEnabled:       false,
+        expected:          false,
+      },
+    ])('$desc', ({ paginationEnabled, perfEnabled, expected }) => {
+      const settings = makePerfSettings(false, perfEnabled);
+
+      expect(perfSettingUtils.manualRefreshUtils.isEnabled(paginationEnabled, settings)).toStrictEqual(expected);
+    });
+  });
+
+  describe('incrementalLoadingUtils and manualRefreshUtils are independent instances', () => {
+    it('incrementalLoading setting does not affect manualRefreshUtils', () => {
+      const settings = makePerfSettings(true, false);
+
+      expect(perfSettingUtils.incrementalLoadingUtils.isEnabled(false, settings)).toStrictEqual(true);
+      expect(perfSettingUtils.manualRefreshUtils.isEnabled(false, settings)).toStrictEqual(false);
+    });
+
+    it('manualRefresh setting does not affect incrementalLoadingUtils', () => {
+      const settings = makePerfSettings(false, true);
+
+      expect(perfSettingUtils.incrementalLoadingUtils.isEnabled(false, settings)).toStrictEqual(false);
+      expect(perfSettingUtils.manualRefreshUtils.isEnabled(false, settings)).toStrictEqual(true);
+    });
+  });
+});

package/utils/__tests__/platform.test.ts

@@ -0,0 +1,91 @@
+import {
+  alternateKey,
+  isAlternate,
+  isMore,
+  isRange,
+  moreKey,
+  rangeKey,
+  suppressContextMenu,
+  version,
+} from '@shell/utils/platform';
+
+describe('platform utils', () => {
+  describe('isAlternate', () => {
+    it.each([
+      {
+        desc:     'returns true when the alternate key is pressed',
+        event:    { [alternateKey]: true },
+        expected: true,
+      },
+      {
+        desc:     'returns false when the alternate key is not pressed',
+        event:    { [alternateKey]: false },
+        expected: false,
+      },
+    ])('$desc', ({ event, expected }) => {
+      expect(isAlternate(event)).toStrictEqual(expected);
+    });
+  });
+
+  describe('isMore', () => {
+    it.each([
+      {
+        desc:     'returns true when the more key is pressed',
+        event:    { [moreKey]: true },
+        expected: true,
+      },
+      {
+        desc:     'returns false when the more key is not pressed',
+        event:    { [moreKey]: false },
+        expected: false,
+      },
+    ])('$desc', ({ event, expected }) => {
+      expect(isMore(event)).toStrictEqual(expected);
+    });
+  });
+
+  describe('isRange', () => {
+    it.each([
+      {
+        desc:     'returns true when the range key (shift) is pressed',
+        event:    { [rangeKey]: true },
+        expected: true,
+      },
+      {
+        desc:     'returns false when the range key is not pressed',
+        event:    { [rangeKey]: false },
+        expected: false,
+      },
+    ])('$desc', ({ event, expected }) => {
+      expect(isRange(event)).toStrictEqual(expected);
+    });
+  });
+
+  describe('suppressContextMenu', () => {
+    it.each([
+      {
+        desc:     'returns true when ctrlKey is pressed and mouse button is 2',
+        event:    { ctrlKey: true, button: 2 },
+        expected: true,
+      },
+      {
+        desc:     'returns false when ctrlKey is not pressed',
+        event:    { ctrlKey: false, button: 2 },
+        expected: false,
+      },
+      {
+        desc:     'returns false when mouse button is not 2',
+        event:    { ctrlKey: true, button: 0 },
+        expected: false,
+      },
+    ])('$desc', ({ event, expected }) => {
+      expect(suppressContextMenu(event)).toStrictEqual(expected);
+    });
+  });
+
+  describe('version', () => {
+    it('returns null when userAgent does not contain a Version/ segment', () => {
+      expect(version()).toBeNull();
+    });
+  });
+});

package/utils/__tests__/poller-sequential.test.ts

@@ -0,0 +1,177 @@
+import PollerSequential from '@shell/utils/poller-sequential';
+
+describe('pollerSequential', () => {
+  let fn: jest.Mock;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    fn = jest.fn().mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should store fn, pollRateMs and maxRetries', () => {
+      const poller = new PollerSequential(fn, 1000, 5);
+
+      expect(poller.fn).toBe(fn);
+      expect(poller.pollRateMs).toBe(1000);
+      expect(poller.maxRetries).toBe(5);
+    });
+
+    it('should default maxRetries to POSITIVE_INFINITY', () => {
+      const poller = new PollerSequential(fn, 500);
+
+      expect(poller.maxRetries).toBe(Number.POSITIVE_INFINITY);
+    });
+
+    it('should substitute a no-op when fn is falsy', () => {
+      const poller = new PollerSequential(null as any, 500);
+
+      expect(typeof poller.fn).toBe('function');
+    });
+
+    it('should initialise tryCount to 0', () => {
+      const poller = new PollerSequential(fn, 1000);
+
+      expect(poller.tryCount).toBe(0);
+    });
+
+    it('should initialise timeoutId to undefined', () => {
+      const poller = new PollerSequential(fn, 1000);
+
+      expect(poller.timeoutId).toBeUndefined();
+    });
+  });
+
+  describe('start', () => {
+    it('should set timeoutId after start', () => {
+      const poller = new PollerSequential(fn, 1000);
+
+      poller.start();
+
+      expect(poller.timeoutId).toBeDefined();
+
+      poller.stop();
+    });
+
+    it('should not call fn immediately (delayed unlike Poller)', () => {
+      const poller = new PollerSequential(fn, 1000);
+
+      poller.start();
+
+      expect(fn).not.toHaveBeenCalled();
+
+      poller.stop();
+    });
+
+    it('should stop and restart when start is called while already running', () => {
+      const poller = new PollerSequential(fn, 1000);
+      const stopSpy = jest.spyOn(poller, 'stop');
+
+      poller.start();
+      poller.start();
+
+      expect(stopSpy).toHaveBeenCalledWith();
+
+      poller.stop();
+    });
+  });
+
+  describe('stop', () => {
+    it('should clear timeoutId after stop', () => {
+      const poller = new PollerSequential(fn, 1000);
+
+      poller.start();
+      poller.stop();
+
+      expect(poller.timeoutId).toBeUndefined();
+    });
+
+    it('should not call fn after stop', async() => {
+      const poller = new PollerSequential(fn, 1000);
+
+      poller.start();
+      poller.stop();
+      jest.advanceTimersByTime(10000);
+
+      expect(fn).not.toHaveBeenCalled();
+    });
+
+    it('should be safe to call stop when not running', () => {
+      const poller = new PollerSequential(fn, 1000);
+
+      expect(() => poller.stop()).not.toThrow();
+    });
+  });
+
+  describe('_poll', () => {
+    it('should not continue polling if timeoutId has been cleared', async() => {
+      const poller = new PollerSequential(fn, 1000);
+
+      poller.timeoutId = undefined;
+      poller._poll();
+
+      jest.advanceTimersByTime(5000);
+
+      expect(fn).not.toHaveBeenCalled();
+    });
+
+    it('should clear timeoutId and schedule next poll', () => {
+      const poller = new PollerSequential(fn, 1000);
+
+      poller.start();
+      expect(poller.timeoutId).toBeDefined();
+
+      const firstId = poller.timeoutId;
+
+      // Advance past the initial delay to trigger _poll
+      jest.advanceTimersByTime(1000);
+
+      // _poll should have set a new timeout (different from the first)
+      expect(poller.timeoutId).toBeDefined();
+      // timeoutId should have changed since _poll calls stop then sets a new one
+      expect(poller.timeoutId).not.toBe(firstId);
+
+      poller.stop();
+    });
+  });
+
+  describe('_intervalMethod', () => {
+    it('should reset tryCount to 0 after a successful call', async() => {
+      const poller = new PollerSequential(fn, 1000);
+
+      poller.tryCount = 3;
+      await poller._intervalMethod();
+
+      expect(poller.tryCount).toBe(0);
+    });
+
+    it('should increment tryCount on each error', async() => {
+      fn.mockRejectedValue(new Error('fail'));
+      const poller = new PollerSequential(fn, 1000, 5);
+
+      await poller._intervalMethod();
+      expect(poller.tryCount).toBe(1);
+
+      await poller._intervalMethod();
+      expect(poller.tryCount).toBe(2);
+    });
+
+    it('should stop when tryCount reaches maxRetries', async() => {
+      fn.mockRejectedValue(new Error('fail'));
+      const poller = new PollerSequential(fn, 1000, 3);
+      const stopSpy = jest.spyOn(poller, 'stop');
+
+      await poller._intervalMethod();
+      await poller._intervalMethod();
+      expect(stopSpy).not.toHaveBeenCalled();
+
+      await poller._intervalMethod();
+      expect(stopSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/utils/__tests__/poller.test.ts

@@ -0,0 +1,170 @@
+import Poller from '@shell/utils/poller';
+
+describe('poller', () => {
+  let fn: jest.Mock;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    fn = jest.fn().mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should store fn, pollRateMs and maxRetries', () => {
+      const poller = new Poller(fn, 1000, 5);
+
+      expect(poller.fn).toBe(fn);
+      expect(poller.pollRateMs).toBe(1000);
+      expect(poller.maxRetries).toBe(5);
+    });
+
+    it('should default maxRetries to POSITIVE_INFINITY', () => {
+      const poller = new Poller(fn, 500);
+
+      expect(poller.maxRetries).toBe(Number.POSITIVE_INFINITY);
+    });
+
+    it('should substitute a no-op when fn is falsy', () => {
+      const poller = new Poller(null as any, 500);
+
+      expect(typeof poller.fn).toBe('function');
+    });
+
+    it('should initialise tryCount to 0', () => {
+      const poller = new Poller(fn, 1000);
+
+      expect(poller.tryCount).toBe(0);
+    });
+
+    it('should initialise intervalId to undefined', () => {
+      const poller = new Poller(fn, 1000);
+
+      expect(poller.intervalId).toBeUndefined();
+    });
+  });
+
+  describe('start', () => {
+    it('should call fn immediately when started', () => {
+      const poller = new Poller(fn, 1000);
+
+      poller.start();
+
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should set intervalId after start', () => {
+      const poller = new Poller(fn, 1000);
+
+      poller.start();
+
+      expect(poller.intervalId).toBeDefined();
+    });
+
+    it('should call fn again after each poll interval', async() => {
+      const poller = new Poller(fn, 1000);
+
+      poller.start();
+      expect(fn).toHaveBeenCalledTimes(1);
+
+      jest.advanceTimersByTime(1000);
+      expect(fn).toHaveBeenCalledTimes(2);
+
+      jest.advanceTimersByTime(1000);
+      expect(fn).toHaveBeenCalledTimes(3);
+
+      poller.stop();
+    });
+
+    it('should stop and restart when start is called while already running', () => {
+      const poller = new Poller(fn, 1000);
+      const stopSpy = jest.spyOn(poller, 'stop');
+
+      poller.start();
+      poller.start();
+
+      expect(stopSpy).toHaveBeenCalledWith();
+
+      poller.stop();
+    });
+  });
+
+  describe('stop', () => {
+    it('should clear intervalId after stop', () => {
+      const poller = new Poller(fn, 1000);
+
+      poller.start();
+      poller.stop();
+
+      expect(poller.intervalId).toBeUndefined();
+    });
+
+    it('should not call fn after stop', () => {
+      const poller = new Poller(fn, 1000);
+
+      poller.start();
+      expect(fn).toHaveBeenCalledTimes(1);
+
+      poller.stop();
+      jest.advanceTimersByTime(5000);
+
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should be safe to call stop when not running', () => {
+      const poller = new Poller(fn, 1000);
+
+      expect(() => poller.stop()).not.toThrow();
+    });
+  });
+
+  describe('_intervalMethod', () => {
+    it('should reset tryCount to 0 after a successful call', async() => {
+      const poller = new Poller(fn, 1000);
+
+      poller.tryCount = 3;
+      await poller._intervalMethod();
+
+      expect(poller.tryCount).toBe(0);
+    });
+
+    it('should increment tryCount on each error', async() => {
+      fn.mockRejectedValue(new Error('fail'));
+      const poller = new Poller(fn, 1000, 5);
+
+      await poller._intervalMethod();
+      expect(poller.tryCount).toBe(1);
+
+      await poller._intervalMethod();
+      expect(poller.tryCount).toBe(2);
+    });
+
+    it('should stop when tryCount reaches maxRetries', async() => {
+      fn.mockRejectedValue(new Error('fail'));
+      const poller = new Poller(fn, 1000, 3);
+      const stopSpy = jest.spyOn(poller, 'stop');
+
+      await poller._intervalMethod();
+      await poller._intervalMethod();
+      expect(stopSpy).not.toHaveBeenCalled();
+
+      await poller._intervalMethod();
+      expect(stopSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not stop before maxRetries is reached', async() => {
+      fn.mockRejectedValue(new Error('fail'));
+      const poller = new Poller(fn, 1000, 5);
+      const stopSpy = jest.spyOn(poller, 'stop');
+
+      for (let i = 0; i < 4; i++) {
+        await poller._intervalMethod();
+      }
+
+      expect(stopSpy).not.toHaveBeenCalled();
+    });
+  });
+});