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

package/utils/gc/__tests__/gc-interval.test.ts

@@ -0,0 +1,119 @@
+describe('gc-interval', () => {
+  let gci: any;
+  let mockGc: any;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+
+    mockGc = {
+      gcEnabledSetting:  jest.fn(),
+      gcEnabledInterval: jest.fn(),
+    };
+
+    jest.resetModules();
+    jest.mock('../gc', () => ({ default: mockGc, __esModule: true }));
+
+    gci = require('../gc-interval').default;
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  describe('gcStartIntervals', () => {
+    it.each([
+      {
+        desc:            'gcEnabledSetting returns false',
+        enabledSetting:  false,
+        enabledInterval: { enabled: true, interval: 60 },
+      },
+      {
+        desc:            'gcEnabledInterval returns enabled=false',
+        enabledSetting:  true,
+        enabledInterval: { enabled: false, interval: 60 },
+      },
+    ])('does not start interval when $desc', ({ enabledSetting, enabledInterval }) => {
+      mockGc.gcEnabledSetting.mockReturnValue(enabledSetting);
+      mockGc.gcEnabledInterval.mockReturnValue(enabledInterval);
+
+      const ctx = { dispatch: jest.fn() };
+
+      gci.gcStartIntervals(ctx);
+
+      jest.advanceTimersByTime(120_000);
+      expect(ctx.dispatch).not.toHaveBeenCalled();
+    });
+
+    it('starts interval and dispatches garbageCollect when gc is enabled', () => {
+      mockGc.gcEnabledSetting.mockReturnValue(true);
+      mockGc.gcEnabledInterval.mockReturnValue({ enabled: true, interval: 60 });
+
+      const ctx = { dispatch: jest.fn() };
+
+      gci.gcStartIntervals(ctx);
+
+      jest.advanceTimersByTime(60_000);
+      expect(ctx.dispatch).toHaveBeenCalledWith('garbageCollect');
+    });
+
+    it('dispatches garbageCollect repeatedly according to interval', () => {
+      mockGc.gcEnabledSetting.mockReturnValue(true);
+      mockGc.gcEnabledInterval.mockReturnValue({ enabled: true, interval: 30 });
+
+      const ctx = { dispatch: jest.fn() };
+
+      gci.gcStartIntervals(ctx);
+
+      jest.advanceTimersByTime(90_000);
+      expect(ctx.dispatch).toHaveBeenCalledTimes(3);
+      expect(ctx.dispatch).toHaveBeenCalledWith('garbageCollect');
+    });
+
+    it('does not start a second interval if already running', () => {
+      mockGc.gcEnabledSetting.mockReturnValue(true);
+      mockGc.gcEnabledInterval.mockReturnValue({ enabled: true, interval: 60 });
+
+      const ctx = { dispatch: jest.fn() };
+
+      gci.gcStartIntervals(ctx);
+      gci.gcStartIntervals(ctx); // second call should be a no-op
+
+      jest.advanceTimersByTime(60_000);
+      expect(ctx.dispatch).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('gcStopIntervals', () => {
+    it('clears the running interval', () => {
+      mockGc.gcEnabledSetting.mockReturnValue(true);
+      mockGc.gcEnabledInterval.mockReturnValue({ enabled: true, interval: 60 });
+
+      const ctx = { dispatch: jest.fn() };
+
+      gci.gcStartIntervals(ctx);
+      gci.gcStopIntervals();
+
+      jest.advanceTimersByTime(120_000);
+      expect(ctx.dispatch).not.toHaveBeenCalled();
+    });
+
+    it('is safe to call when no interval is running', () => {
+      expect(() => gci.gcStopIntervals()).not.toThrow();
+    });
+
+    it('allows a new interval to be started after stopping', () => {
+      mockGc.gcEnabledSetting.mockReturnValue(true);
+      mockGc.gcEnabledInterval.mockReturnValue({ enabled: true, interval: 60 });
+
+      const ctx = { dispatch: jest.fn() };
+
+      gci.gcStartIntervals(ctx);
+      gci.gcStopIntervals();
+      gci.gcStartIntervals(ctx);
+
+      jest.advanceTimersByTime(60_000);
+      expect(ctx.dispatch).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/utils/gc/__tests__/gc-root-store.test.ts

@@ -0,0 +1,225 @@
+import type { gcGetters as GcGettersType, gcActions as GcActionsType } from '@shell/utils/gc/gc-root-store';
+
+let gcGetters: typeof GcGettersType;
+let gcActions: typeof GcActionsType;
+let mockGc: any;
+let mockGcInterval: any;
+let mockGcRoute: any;
+
+describe('gc-root-store', () => {
+  beforeEach(() => {
+    mockGc = {
+      gcEnabledForStore: jest.fn(),
+      gcEnabledSetting:  jest.fn(),
+    };
+
+    mockGcInterval = {
+      gcStartIntervals: jest.fn(),
+      gcStopIntervals:  jest.fn(),
+    };
+
+    mockGcRoute = { gcRouteChanged: jest.fn() };
+
+    jest.resetModules();
+    jest.mock('../gc', () => ({ default: mockGc, __esModule: true }));
+    jest.mock('../gc-interval', () => ({ default: mockGcInterval, __esModule: true }));
+    jest.mock('../gc-route-changed', () => ({ default: mockGcRoute, __esModule: true }));
+
+    const mod = require('../gc-root-store');
+
+    gcGetters = mod.gcGetters;
+    gcActions = mod.gcActions;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('gcGetters.gcStores', () => {
+    it('returns stores for which gcEnabledForStore returns truthy', () => {
+      const state = {
+        cluster:    { someKey: 'val' },
+        management: { someKey: 'val' },
+        other:      { someKey: 'val' },
+      };
+
+      mockGc.gcEnabledForStore.mockImplementation((storeState: any) => storeState === state.cluster || storeState === state.management);
+
+      expect(gcGetters.gcStores(state)).toStrictEqual([
+        ['cluster', state.cluster],
+        ['management', state.management],
+      ]);
+    });
+
+    it('returns empty array when no stores have gc enabled', () => {
+      const state = { cluster: { x: 1 }, management: { x: 2 } };
+
+      mockGc.gcEnabledForStore.mockReturnValue(false);
+
+      expect(gcGetters.gcStores(state)).toStrictEqual([]);
+    });
+
+    it('skips non-object state entries (primitives)', () => {
+      const state: any = {
+        counter: 42,
+        flag:    true,
+        cluster: { x: 1 },
+      };
+
+      mockGc.gcEnabledForStore.mockImplementation((s: any) => s === state.cluster);
+
+      expect(gcGetters.gcStores(state)).toStrictEqual([['cluster', state.cluster]]);
+      expect(mockGc.gcEnabledForStore).toHaveBeenCalledWith(state.cluster);
+      expect(mockGc.gcEnabledForStore).not.toHaveBeenCalledWith(42);
+    });
+
+    it('returns empty array for empty state', () => {
+      expect(gcGetters.gcStores({})).toStrictEqual([]);
+    });
+  });
+
+  describe('gcActions.gcRouteChanged', () => {
+    it('delegates to gcRoute.gcRouteChanged with ctx and to', () => {
+      const ctx = { dispatch: jest.fn() };
+      const to = { path: '/clusters' };
+
+      gcActions.gcRouteChanged(ctx, to);
+
+      expect(mockGcRoute.gcRouteChanged).toHaveBeenCalledWith(ctx, to);
+    });
+  });
+
+  describe('gcActions.gcStartIntervals', () => {
+    it('delegates to gcInterval.gcStartIntervals with ctx', () => {
+      const ctx = { dispatch: jest.fn() };
+
+      gcActions.gcStartIntervals(ctx);
+
+      expect(mockGcInterval.gcStartIntervals).toHaveBeenCalledWith(ctx);
+    });
+  });
+
+  describe('gcActions.gcStopIntervals', () => {
+    it('delegates to gcInterval.gcStopIntervals with no arguments', () => {
+      const ctx = { dispatch: jest.fn() };
+
+      gcActions.gcStopIntervals(ctx);
+
+      expect(mockGcInterval.gcStopIntervals).toHaveBeenCalledWith();
+    });
+  });
+
+  describe('gcActions.gcResetStores', () => {
+    it('dispatches gcResetStore for each gc-enabled store', () => {
+      const dispatch = jest.fn();
+      const getters = {
+        gcStores: [
+          ['cluster', {}],
+          ['management', {}],
+        ],
+      };
+
+      gcActions.gcResetStores({ dispatch, getters });
+
+      expect(dispatch).toHaveBeenCalledWith('cluster/gcResetStore');
+      expect(dispatch).toHaveBeenCalledWith('management/gcResetStore');
+      expect(dispatch).toHaveBeenCalledTimes(2);
+    });
+
+    it('dispatches nothing when gcStores is empty', () => {
+      const dispatch = jest.fn();
+
+      gcActions.gcResetStores({ dispatch, getters: { gcStores: [] } });
+
+      expect(dispatch).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('gcActions.garbageCollect', () => {
+    it('dispatches garbageCollect to each gc-enabled store when gc setting is enabled', () => {
+      mockGc.gcEnabledSetting.mockReturnValue(true);
+
+      const dispatch = jest.fn();
+      const getters = {
+        gcStores: [
+          ['cluster', {}],
+          ['management', {}],
+        ],
+      };
+      const ignoreTypes = ['some.type'];
+
+      gcActions.garbageCollect({
+        rootState: {}, dispatch, getters
+      }, ignoreTypes);
+
+      expect(dispatch).toHaveBeenCalledWith('cluster/garbageCollect', ignoreTypes);
+      expect(dispatch).toHaveBeenCalledWith('management/garbageCollect', ignoreTypes);
+      expect(dispatch).toHaveBeenCalledTimes(2);
+    });
+
+    it('does not dispatch when gc setting is disabled', () => {
+      mockGc.gcEnabledSetting.mockReturnValue(false);
+
+      const dispatch = jest.fn();
+
+      gcActions.garbageCollect({
+        rootState: {}, dispatch, getters: { gcStores: [['cluster', {}]] }
+      }, []);
+
+      expect(dispatch).not.toHaveBeenCalled();
+    });
+
+    it('dispatches nothing when gcStores is empty even if setting is enabled', () => {
+      mockGc.gcEnabledSetting.mockReturnValue(true);
+
+      const dispatch = jest.fn();
+
+      gcActions.garbageCollect({
+        rootState: {}, dispatch, getters: { gcStores: [] }
+      }, []);
+
+      expect(dispatch).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('gcActions.gcPreferencesUpdated', () => {
+    it('stops intervals and starts them when new preferences are enabled', () => {
+      const dispatch = jest.fn();
+
+      gcActions.gcPreferencesUpdated({ dispatch }, {
+        previouslyEnabled: false,
+        newPreferences:    { enabled: true },
+      });
+
+      expect(dispatch).toHaveBeenCalledWith('gcStopIntervals', { root: true });
+      expect(dispatch).toHaveBeenCalledWith('gcStartIntervals', { root: true });
+      expect(dispatch).not.toHaveBeenCalledWith('gcResetStores', { root: true });
+    });
+
+    it('stops intervals and resets stores when transitioning from enabled to disabled', () => {
+      const dispatch = jest.fn();
+
+      gcActions.gcPreferencesUpdated({ dispatch }, {
+        previouslyEnabled: true,
+        newPreferences:    { enabled: false },
+      });
+
+      expect(dispatch).toHaveBeenCalledWith('gcStopIntervals', { root: true });
+      expect(dispatch).toHaveBeenCalledWith('gcResetStores', { root: true });
+      expect(dispatch).not.toHaveBeenCalledWith('gcStartIntervals', { root: true });
+    });
+
+    it('stops intervals only when new preferences are disabled and was not previously enabled', () => {
+      const dispatch = jest.fn();
+
+      gcActions.gcPreferencesUpdated({ dispatch }, {
+        previouslyEnabled: false,
+        newPreferences:    { enabled: false },
+      });
+
+      expect(dispatch).toHaveBeenCalledWith('gcStopIntervals', { root: true });
+      expect(dispatch).not.toHaveBeenCalledWith('gcStartIntervals', { root: true });
+      expect(dispatch).not.toHaveBeenCalledWith('gcResetStores', { root: true });
+    });
+  });
+});

package/utils/gc/__tests__/gc-route-changed.test.ts

@@ -0,0 +1,96 @@
+describe('gc-route-changed', () => {
+  let gcrc: any;
+  let mockGc: any;
+
+  beforeEach(() => {
+    mockGc = {
+      gcUpdateRouteChanged: jest.fn(),
+      gcEnabledSetting:     jest.fn(),
+      gcEnabledRoute:       jest.fn(),
+    };
+
+    jest.resetModules();
+    jest.mock('../gc', () => ({ default: mockGc, __esModule: true }));
+
+    gcrc = require('../gc-route-changed').default;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('gcRouteChanged', () => {
+    it('always calls gcUpdateRouteChanged', () => {
+      mockGc.gcEnabledSetting.mockReturnValue(false);
+      mockGc.gcEnabledRoute.mockReturnValue(false);
+
+      const ctx = { dispatch: jest.fn() };
+
+      gcrc.gcRouteChanged(ctx, { name: 'some-route', params: {} });
+
+      expect(mockGc.gcUpdateRouteChanged).toHaveBeenCalledWith();
+    });
+
+    it.each([
+      {
+        desc:           'gcEnabledSetting is false',
+        enabledSetting: false,
+        enabledRoute:   true,
+        route:          { name: 'c-cluster-explorer', params: { resource: 'pods' } },
+      },
+      {
+        desc:           'gcEnabledRoute is false',
+        enabledSetting: true,
+        enabledRoute:   false,
+        route:          { name: 'c-cluster-explorer', params: { resource: 'pods' } },
+      },
+      {
+        desc:           'route is auth-logout',
+        enabledSetting: true,
+        enabledRoute:   true,
+        route:          { name: 'auth-logout', params: {} },
+      },
+    ])('returns early without dispatch when $desc', ({ enabledSetting, enabledRoute, route }) => {
+      mockGc.gcEnabledSetting.mockReturnValue(enabledSetting);
+      mockGc.gcEnabledRoute.mockReturnValue(enabledRoute);
+
+      const ctx = { dispatch: jest.fn() };
+
+      gcrc.gcRouteChanged(ctx, route);
+
+      expect(ctx.dispatch).not.toHaveBeenCalled();
+    });
+
+    it.each([
+      {
+        desc:     'resource from to.params.resource as ignoreTypes',
+        route:    { name: 'c-cluster-explorer', params: { resource: 'pods' } },
+        expected: { pods: true },
+      },
+      {
+        desc:     'empty ignoreTypes when no resource in params',
+        route:    { name: 'some-route', params: {} },
+        expected: {},
+      },
+      {
+        desc:     'empty ignoreTypes when params is undefined',
+        route:    { name: 'some-route' },
+        expected: {},
+      },
+      {
+        desc:     'empty ignoreTypes when route name matches c-cluster pattern (match[2] is undefined)',
+        route:    { name: 'c-cluster-explorer', params: {} },
+        expected: {},
+      },
+    ])('dispatches garbageCollect with $desc', ({ route, expected }) => {
+      mockGc.gcEnabledSetting.mockReturnValue(true);
+      mockGc.gcEnabledRoute.mockReturnValue(true);
+
+      const ctx = { dispatch: jest.fn() };
+
+      gcrc.gcRouteChanged(ctx, route);
+
+      expect(ctx.dispatch).toHaveBeenCalledWith('garbageCollect', expected);
+    });
+  });
+});