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

package/utils/gatekeeper/__tests__/util.test.ts

@@ -0,0 +1,174 @@
+import { findTemplateType, findAllConstraintTypes, findAllTemplates, findAllConstraints } from '../util';
+import { GATEKEEPER, SCHEMA } from '@shell/config/types';
+
+describe('gatekeeper/util.js', () => {
+  describe('findTemplateType', () => {
+    it('returns the schema id when a matching schema exists', () => {
+      const schemas = [
+        {
+          id:         'templates.gatekeeper.sh.constrainttemplate',
+          attributes: { group: 'templates.gatekeeper.sh', kind: 'ConstraintTemplate' },
+        },
+      ];
+
+      expect(findTemplateType(schemas)).toStrictEqual('templates.gatekeeper.sh.constrainttemplate');
+    });
+
+    it('returns undefined when no schemas match', () => {
+      const schemas = [
+        {
+          id:         'other.group.somekind',
+          attributes: { group: 'other.group', kind: 'SomeKind' },
+        },
+      ];
+
+      expect(findTemplateType(schemas)).toBeUndefined();
+    });
+
+    it('returns undefined for an empty schemas array', () => {
+      expect(findTemplateType([])).toBeUndefined();
+    });
+
+    it('matches only on the correct group and kind together', () => {
+      const schemas = [
+        {
+          id:         'templates.gatekeeper.sh.other',
+          attributes: { group: 'templates.gatekeeper.sh', kind: 'Other' },
+        },
+        {
+          id:         'other.group.constrainttemplate',
+          attributes: { group: 'other.group', kind: 'ConstraintTemplate' },
+        },
+      ];
+
+      expect(findTemplateType(schemas)).toBeUndefined();
+    });
+
+    it('returns undefined when schema has no attributes', () => {
+      const schemas = [{ id: 'some.id' }];
+
+      expect(findTemplateType(schemas)).toBeUndefined();
+    });
+
+    it('returns the first matching schema id when multiple matches exist', () => {
+      const schemas = [
+        {
+          id:         'first-match',
+          attributes: { group: 'templates.gatekeeper.sh', kind: 'ConstraintTemplate' },
+        },
+        {
+          id:         'second-match',
+          attributes: { group: 'templates.gatekeeper.sh', kind: 'ConstraintTemplate' },
+        },
+      ];
+
+      expect(findTemplateType(schemas)).toStrictEqual('first-match');
+    });
+
+    it('handles schemas with null attributes gracefully', () => {
+      const schemas = [
+        { id: 'null-attrs', attributes: null },
+        {
+          id:         'templates.gatekeeper.sh.constrainttemplate',
+          attributes: { group: 'templates.gatekeeper.sh', kind: 'ConstraintTemplate' },
+        },
+      ];
+
+      expect(findTemplateType(schemas)).toStrictEqual('templates.gatekeeper.sh.constrainttemplate');
+    });
+  });
+
+  describe('findAllConstraintTypes', () => {
+    it('returns constraint type schema ids filtered by constraints.gatekeeper.sh group', () => {
+      const schemas = [
+        { id: 'constraints.gatekeeper.sh.k8srequiredlabels', attributes: { group: 'constraints.gatekeeper.sh' } },
+        { id: 'constraints.gatekeeper.sh.k8sallowedrepos', attributes: { group: 'constraints.gatekeeper.sh' } },
+        { id: 'other.group.something', attributes: { group: 'other.group' } },
+      ];
+      const store = { getters: { [`cluster/all`]: () => schemas } };
+
+      const result = findAllConstraintTypes(store);
+
+      expect(result).toStrictEqual([
+        'constraints.gatekeeper.sh.k8srequiredlabels',
+        'constraints.gatekeeper.sh.k8sallowedrepos',
+      ]);
+    });
+
+    it('returns an empty array when no constraint schemas exist', () => {
+      const store = { getters: { [`cluster/all`]: () => [] } };
+
+      expect(findAllConstraintTypes(store)).toStrictEqual([]);
+    });
+
+    it('calls store.getters["cluster/all"] with SCHEMA constant', () => {
+      const mockAll = jest.fn().mockReturnValue([]);
+      const store = { getters: { [`cluster/all`]: mockAll } };
+
+      findAllConstraintTypes(store);
+
+      expect(mockAll).toHaveBeenCalledWith(SCHEMA);
+    });
+
+    it('filters out schemas with missing or non-matching group', () => {
+      const schemas = [
+        { id: 'no-attrs' },
+        { id: 'null-group', attributes: { group: null } },
+        { id: 'constraints.gatekeeper.sh.valid', attributes: { group: 'constraints.gatekeeper.sh' } },
+      ];
+      const store = { getters: { [`cluster/all`]: () => schemas } };
+
+      const result = findAllConstraintTypes(store);
+
+      expect(result).toStrictEqual(['constraints.gatekeeper.sh.valid']);
+    });
+  });
+
+  describe('findAllTemplates', () => {
+    it('dispatches cluster/findAll with the constraint template type', async() => {
+      const expectedResult = [{ id: GATEKEEPER.CONSTRAINT_TEMPLATE }];
+      const mockDispatch = jest.fn().mockResolvedValue(expectedResult);
+      const store = { dispatch: mockDispatch };
+
+      const result = await findAllTemplates(store);
+
+      expect(mockDispatch).toHaveBeenCalledWith('cluster/findAll', { type: GATEKEEPER.CONSTRAINT_TEMPLATE });
+      expect(result).toStrictEqual(expectedResult);
+    });
+  });
+
+  describe('findAllConstraints', () => {
+    it('returns all constraint resources flattened across all constraint types', async() => {
+      const schemas = [
+        { id: 'constraints.gatekeeper.sh.type1', attributes: { group: 'constraints.gatekeeper.sh' } },
+        { id: 'constraints.gatekeeper.sh.type2', attributes: { group: 'constraints.gatekeeper.sh' } },
+      ];
+      const type1Resources = [{ id: 'r1' }, { id: 'r2' }];
+      const type2Resources = [{ id: 'r3' }];
+      const mockDispatch = jest.fn()
+        .mockResolvedValueOnce(type1Resources)
+        .mockResolvedValueOnce(type2Resources);
+      const store = {
+        getters:  { [`cluster/all`]: () => schemas },
+        dispatch: mockDispatch,
+      };
+
+      const result = await findAllConstraints(store);
+
+      expect(mockDispatch).toHaveBeenCalledWith('cluster/findAll', { type: 'constraints.gatekeeper.sh.type1', opt: { force: true } });
+      expect(mockDispatch).toHaveBeenCalledWith('cluster/findAll', { type: 'constraints.gatekeeper.sh.type2', opt: { force: true } });
+      expect(result).toStrictEqual([{ id: 'r1' }, { id: 'r2' }, { id: 'r3' }]);
+    });
+
+    it('returns an empty array when there are no constraint types', async() => {
+      const store = {
+        getters:  { [`cluster/all`]: () => [] },
+        dispatch: jest.fn(),
+      };
+
+      const result = await findAllConstraints(store);
+
+      expect(result).toStrictEqual([]);
+    });
+  });
+});

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