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

package/utils/__tests__/queue.test.ts

@@ -0,0 +1,232 @@
+import Queue from '@shell/utils/queue';
+
+describe('queue', () => {
+  describe('new queue', () => {
+    it('starts with length 0', () => {
+      const q = new Queue();
+
+      expect(q.getLength()).toStrictEqual(0);
+    });
+
+    it('starts empty', () => {
+      const q = new Queue();
+
+      expect(q.isEmpty()).toStrictEqual(true);
+    });
+
+    it('peek returns undefined on empty queue', () => {
+      const q = new Queue();
+
+      expect(q.peek()).toBeUndefined();
+    });
+
+    it('dequeue returns undefined on empty queue', () => {
+      const q = new Queue();
+
+      expect(q.dequeue()).toBeUndefined();
+    });
+  });
+
+  describe('enqueue', () => {
+    it('increases length by 1', () => {
+      const q = new Queue();
+
+      q.enqueue('a');
+      expect(q.getLength()).toStrictEqual(1);
+    });
+
+    it('marks queue as non-empty after first item', () => {
+      const q = new Queue();
+
+      q.enqueue('x');
+      expect(q.isEmpty()).toStrictEqual(false);
+    });
+
+    it('accepts arbitrary values', () => {
+      const q = new Queue();
+
+      q.enqueue(42);
+      q.enqueue(null);
+      q.enqueue({ key: 'val' });
+      expect(q.getLength()).toStrictEqual(3);
+    });
+  });
+
+  describe('dequeue', () => {
+    it('returns the enqueued item', () => {
+      const q = new Queue();
+
+      q.enqueue('hello');
+      expect(q.dequeue()).toStrictEqual('hello');
+    });
+
+    it('decreases length by 1', () => {
+      const q = new Queue();
+
+      q.enqueue('a');
+      q.enqueue('b');
+      q.dequeue();
+      expect(q.getLength()).toStrictEqual(1);
+    });
+
+    it('empties the queue when last item is removed', () => {
+      const q = new Queue();
+
+      q.enqueue('only');
+      q.dequeue();
+      expect(q.isEmpty()).toStrictEqual(true);
+      expect(q.getLength()).toStrictEqual(0);
+    });
+
+    it('maintains FIFO order', () => {
+      const q = new Queue();
+
+      q.enqueue('first');
+      q.enqueue('second');
+      q.enqueue('third');
+
+      expect(q.dequeue()).toStrictEqual('first');
+      expect(q.dequeue()).toStrictEqual('second');
+      expect(q.dequeue()).toStrictEqual('third');
+    });
+
+    it('returns undefined after queue is drained', () => {
+      const q = new Queue();
+
+      q.enqueue('item');
+      q.dequeue();
+      expect(q.dequeue()).toBeUndefined();
+    });
+  });
+
+  describe('peek', () => {
+    it('returns the front item without removing it', () => {
+      const q = new Queue();
+
+      q.enqueue('front');
+      q.enqueue('back');
+      expect(q.peek()).toStrictEqual('front');
+    });
+
+    it('does not change the queue length', () => {
+      const q = new Queue();
+
+      q.enqueue('a');
+      q.peek();
+      expect(q.getLength()).toStrictEqual(1);
+    });
+
+    it('reflects the new front after a dequeue', () => {
+      const q = new Queue();
+
+      q.enqueue('first');
+      q.enqueue('second');
+      q.dequeue();
+      expect(q.peek()).toStrictEqual('second');
+    });
+  });
+
+  describe('clear', () => {
+    it('empties a populated queue', () => {
+      const q = new Queue();
+
+      q.enqueue('a');
+      q.enqueue('b');
+      q.clear();
+      expect(q.isEmpty()).toStrictEqual(true);
+    });
+
+    it('resets length to 0', () => {
+      const q = new Queue();
+
+      q.enqueue(1);
+      q.enqueue(2);
+      q.enqueue(3);
+      q.clear();
+      expect(q.getLength()).toStrictEqual(0);
+    });
+
+    it('allows enqueue after clear', () => {
+      const q = new Queue();
+
+      q.enqueue('before');
+      q.clear();
+      q.enqueue('after');
+      expect(q.dequeue()).toStrictEqual('after');
+    });
+
+    it('is safe to call on an already-empty queue', () => {
+      const q = new Queue();
+
+      q.clear();
+      expect(q.isEmpty()).toStrictEqual(true);
+      expect(q.getLength()).toStrictEqual(0);
+    });
+  });
+
+  describe('mixed operations', () => {
+    it('handles interleaved enqueue and dequeue correctly', () => {
+      const q = new Queue();
+
+      q.enqueue('a');
+      q.enqueue('b');
+      expect(q.dequeue()).toStrictEqual('a');
+      q.enqueue('c');
+      expect(q.dequeue()).toStrictEqual('b');
+      expect(q.dequeue()).toStrictEqual('c');
+      expect(q.isEmpty()).toStrictEqual(true);
+    });
+
+    it('tracks length correctly through mixed operations', () => {
+      const q = new Queue();
+
+      q.enqueue(1);
+      q.enqueue(2);
+      q.enqueue(3);
+      expect(q.getLength()).toStrictEqual(3);
+
+      q.dequeue();
+      expect(q.getLength()).toStrictEqual(2);
+
+      q.enqueue(4);
+      expect(q.getLength()).toStrictEqual(3);
+
+      q.dequeue();
+      q.dequeue();
+      expect(q.getLength()).toStrictEqual(1);
+    });
+
+    it('compacts the backing array when threshold is reached', () => {
+      // The implementation slices when ++offset * 2 >= queue.length.
+      // With 4 items: after the 2nd dequeue offset*2 (4) reaches length (4),
+      // triggering a compaction so the backing array is reset.
+      const q = new Queue();
+
+      q.enqueue('w');
+      q.enqueue('x');
+      q.enqueue('y');
+      q.enqueue('z');
+
+      expect(q.dequeue()).toStrictEqual('w'); // offset=1, 1*2=2 < 4 — no compaction yet
+      expect(q.dequeue()).toStrictEqual('x'); // offset=2, 2*2=4 >= 4 — compaction!
+      // After compaction: backing array = ['y','z'], offset=0
+      expect(q.getLength()).toStrictEqual(2);
+      expect(q.peek()).toStrictEqual('y');
+      expect(q.dequeue()).toStrictEqual('y');
+      expect(q.dequeue()).toStrictEqual('z');
+      expect(q.isEmpty()).toStrictEqual(true);
+    });
+
+    it('enqueues object values and preserves them through FIFO', () => {
+      const q = new Queue();
+      const obj1 = { id: 1, name: 'first' };
+      const obj2 = { id: 2, name: 'second' };
+
+      q.enqueue(obj1);
+      q.enqueue(obj2);
+
+      expect(q.dequeue()).toStrictEqual({ id: 1, name: 'first' });
+      expect(q.dequeue()).toStrictEqual({ id: 2, name: 'second' });
+    });
+  });
+});

package/utils/__tests__/release-notes.test.ts

@@ -0,0 +1,221 @@
+import { NotificationLevel } from '@shell/types/notifications';
+
+const MOCK_VERSION = '2.9.0';
+const MOCK_VERSION_WITH_SUFFIX = `${ MOCK_VERSION }-rc1`;
+const READ_WHATS_NEW_KEY = 'read-whatsnew';
+const PREFIX = 'release-notes-';
+const CURRENT_ID = `${ PREFIX }${ MOCK_VERSION }`;
+const RELEASE_NOTES_URL = 'https://example.com/release-notes';
+
+function makeGetters(overrides: {
+  all?: any[];
+  lastReadVersion?: string;
+  t?: (key: string, args?: any) => string;
+  releaseNotesUrl?: string;
+} = {}) {
+  const {
+    all = [],
+    lastReadVersion = '',
+    t = (key: string) => key,
+    releaseNotesUrl = RELEASE_NOTES_URL,
+  } = overrides;
+
+  return {
+    'notifications/all': all,
+    'prefs/get':         (key: string) => (key === READ_WHATS_NEW_KEY ? lastReadVersion : ''),
+    'i18n/t':            t,
+    releaseNotesUrl,
+  };
+}
+
+describe('addReleaseNotesNotification', () => {
+  let addReleaseNotesNotification: any;
+  let mockGetVersionData: jest.Mock;
+
+  beforeEach(() => {
+    jest.resetModules();
+    mockGetVersionData = jest.fn(() => ({ Version: MOCK_VERSION_WITH_SUFFIX }));
+    jest.mock('@shell/config/version', () => ({ getVersionData: mockGetVersionData }));
+    addReleaseNotesNotification = require('@shell/utils/release-notes').addReleaseNotesNotification;
+  });
+
+  describe('version parsing', () => {
+    it('strips the pre-release suffix from the version', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters();
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({ id: CURRENT_ID }));
+    });
+
+    it('uses the version as-is when there is no suffix', async() => {
+      mockGetVersionData.mockReturnValue({ Version: MOCK_VERSION });
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters();
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({ id: CURRENT_ID }));
+    });
+  });
+
+  describe('existing notification for the current version', () => {
+    it('does not add a notification when the current version notification already exists', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ all: [{ id: CURRENT_ID }] });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).not.toHaveBeenCalledWith('notifications/add', expect.anything());
+    });
+
+    it('does not remove the current version notification when it already exists', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ all: [{ id: CURRENT_ID }] });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).not.toHaveBeenCalledWith('notifications/remove', CURRENT_ID);
+    });
+  });
+
+  describe('old release-notes notifications', () => {
+    it('removes a notification for an older version', async() => {
+      const oldId = `${ PREFIX }2.8.0`;
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ all: [{ id: oldId }] });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledWith('notifications/remove', oldId);
+    });
+
+    it('removes multiple notifications for older versions', async() => {
+      const oldId1 = `${ PREFIX }2.7.0`;
+      const oldId2 = `${ PREFIX }2.8.0`;
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ all: [{ id: oldId1 }, { id: oldId2 }] });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledWith('notifications/remove', oldId1);
+      expect(dispatch).toHaveBeenCalledWith('notifications/remove', oldId2);
+    });
+
+    it('still adds a new notification after removing old ones', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ all: [{ id: `${ PREFIX }2.8.0` }] });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({ id: CURRENT_ID }));
+    });
+  });
+
+  describe('non-release-notes notifications', () => {
+    it('ignores notifications with a different id prefix', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ all: [{ id: 'cluster-upgrade-1.0.0' }, { id: 'some-other-notification' }] });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).not.toHaveBeenCalledWith('notifications/remove', expect.anything());
+    });
+  });
+
+  describe('version preference guard', () => {
+    it('does not add notification when the version has already been read', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ lastReadVersion: MOCK_VERSION });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).not.toHaveBeenCalledWith('notifications/add', expect.anything());
+    });
+
+    it('adds notification when the read version pref is for an older version', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ lastReadVersion: '2.8.0' });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({ id: CURRENT_ID }));
+    });
+
+    it('adds notification when the read version pref is empty', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ lastReadVersion: '' });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({ id: CURRENT_ID }));
+    });
+  });
+
+  describe('notification shape', () => {
+    it('adds a notification with the correct id, level and preference', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const t = jest.fn((key: string) => key);
+      const getters = makeGetters({ t });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledWith('notifications/add', {
+        id:         CURRENT_ID,
+        level:      NotificationLevel.Info,
+        title:      'landing.whatsNew.title',
+        message:    'landing.whatsNew.message',
+        preference: {
+          key:   READ_WHATS_NEW_KEY,
+          value: MOCK_VERSION,
+        },
+        primaryAction: {
+          label:  'landing.whatsNew.link',
+          target: RELEASE_NOTES_URL,
+        },
+      });
+    });
+
+    it('passes version to the title translation function', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const t = jest.fn((key: string) => key);
+      const getters = makeGetters({ t });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(t).toHaveBeenCalledWith('landing.whatsNew.title', { version: MOCK_VERSION });
+    });
+
+    it('uses the releaseNotesUrl getter for the primaryAction target', async() => {
+      const customUrl = 'https://custom.example.com/notes';
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ releaseNotesUrl: customUrl });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({ primaryAction: expect.objectContaining({ target: customUrl }) }));
+    });
+  });
+
+  describe('empty state', () => {
+    it('adds a notification when there are no existing notifications', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ all: [] });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({ id: CURRENT_ID }));
+    });
+
+    it('dispatches nothing beyond add when there are no existing notifications', async() => {
+      const dispatch = jest.fn(() => Promise.resolve());
+      const getters = makeGetters({ all: [] });
+
+      await addReleaseNotesNotification(dispatch, getters);
+
+      expect(dispatch).toHaveBeenCalledTimes(1);
+      expect(dispatch).toHaveBeenCalledWith('notifications/add', expect.anything());
+    });
+  });
+});

package/utils/__tests__/router.test.js

@@ -1,4 +1,15 @@
-import { findRouteDefinitionByName, filterLocationValidParams } from '@shell/utils/router';
+import {
+  findRouteDefinitionByName,
+  filterLocationValidParams,
+  queryParamsFor,
+  findMeta,
+  getClusterFromRoute,
+  getProductFromRoute,
+  getPackageFromRoute,
+  routeMatched,
+  routeRequiresAuthentication,
+  routeRequiresInstallRedirect,
+} from '@shell/utils/router';
 
 describe('findRouteDefinitionByName', () => {
   const createMockRouter = (routes) => ({ getRoutes: () => routes });
@@ -236,3 +247,245 @@ describe('filterLocationValidParams', () => {
     expect(result.params.extra).toBeUndefined();
   });
 });
+
+describe('queryParamsFor', () => {
+  it.each([
+    {
+      desc:     'includes key when no default is defined',
+      current:  {},
+      qp:       { page: 2 },
+      defaults: {},
+      expected: { page: 2 },
+    },
+    {
+      desc:     'sets key to null when default is false and val is truthy',
+      current:  {},
+      qp:       { verbose: true },
+      defaults: { verbose: false },
+      expected: { verbose: null },
+    },
+    {
+      desc:     'deletes key when default is false and val is falsy',
+      current:  { verbose: null },
+      qp:       { verbose: false },
+      defaults: { verbose: false },
+      expected: {},
+    },
+    {
+      desc:     'deletes key when value matches non-false default',
+      current:  {},
+      qp:       { sort: 'name' },
+      defaults: { sort: 'name' },
+      expected: {},
+    },
+    {
+      desc:     'sets key when value differs from non-false default',
+      current:  {},
+      qp:       { sort: 'age' },
+      defaults: { sort: 'name' },
+      expected: { sort: 'age' },
+    },
+    {
+      desc:     'preserves unrelated keys from current',
+      current:  { filter: 'active' },
+      qp:       { page: 2 },
+      defaults: {},
+      expected: { filter: 'active', page: 2 },
+    },
+    {
+      desc:     'treats null current as empty object',
+      current:  null,
+      qp:       { page: 1 },
+      defaults: {},
+      expected: { page: 1 },
+    },
+  ])('$desc', ({
+    current, qp, defaults, expected
+  }) => {
+    expect(queryParamsFor(current, qp, defaults)).toStrictEqual(expected);
+  });
+});
+
+describe('findMeta', () => {
+  it.each([
+    {
+      desc:     'returns undefined when route has no meta',
+      route:    { params: {} },
+      key:      'product',
+      expected: undefined,
+    },
+    {
+      desc:     'returns undefined when route is null',
+      route:    null,
+      key:      'product',
+      expected: undefined,
+    },
+    {
+      desc:     'returns value from a plain meta object',
+      route:    { meta: { product: 'explorer' } },
+      key:      'product',
+      expected: 'explorer',
+    },
+    {
+      desc:     'returns value from a matching item in array meta',
+      route:    { meta: [{ cluster: 'local' }, { product: 'explorer' }] },
+      key:      'product',
+      expected: 'explorer',
+    },
+    {
+      desc:     'returns undefined when key is absent from all meta items',
+      route:    { meta: [{ cluster: 'local' }] },
+      key:      'product',
+      expected: undefined,
+    },
+  ])('$desc', ({ route, key, expected }) => {
+    expect(findMeta(route, key)).toStrictEqual(expected);
+  });
+});
+
+describe('getClusterFromRoute', () => {
+  it.each([
+    {
+      desc:     'returns cluster from route params',
+      to:       { params: { cluster: 'local' } },
+      expected: 'local',
+    },
+    {
+      desc:     'returns cluster from route meta when not in params',
+      to:       { params: {}, meta: { cluster: 'remote' } },
+      expected: 'remote',
+    },
+    {
+      desc:     'returns undefined when cluster is not in params or meta',
+      to:       { params: {} },
+      expected: undefined,
+    },
+  ])('$desc', ({ to, expected }) => {
+    expect(getClusterFromRoute(to)).toStrictEqual(expected);
+  });
+});
+
+describe('getProductFromRoute', () => {
+  it.each([
+    {
+      desc:     'returns product from route params',
+      to:       { params: { product: 'explorer' } },
+      expected: 'explorer',
+    },
+    {
+      desc:     'infers product segment from c-cluster-<product>-* route name',
+      to:       { name: 'c-cluster-explorer-workloads', params: {} },
+      expected: 'explorer',
+    },
+    {
+      desc: 'returns product from route meta when params and name do not have it',
+      to:   {
+        name: 'some-route', params: {}, meta: { product: 'manager' }
+      },
+      expected: 'manager',
+    },
+    {
+      desc:     'returns undefined when product is not found anywhere',
+      to:       { params: {} },
+      expected: undefined,
+    },
+  ])('$desc', ({ to, expected }) => {
+    expect(getProductFromRoute(to)).toStrictEqual(expected);
+  });
+});
+
+describe('getPackageFromRoute', () => {
+  it.each([
+    {
+      desc:     'returns undefined when route has no meta',
+      route:    {},
+      expected: undefined,
+    },
+    {
+      desc:     'returns pkg from array meta',
+      route:    { meta: [{ pkg: 'my-package' }] },
+      expected: 'my-package',
+    },
+    {
+      desc:     'returns pkg from plain object meta',
+      route:    { meta: { pkg: 'my-package' } },
+      expected: 'my-package',
+    },
+    {
+      desc:     'returns undefined when no meta item defines pkg',
+      route:    { meta: [{ product: 'explorer' }] },
+      expected: undefined,
+    },
+  ])('$desc', ({ route, expected }) => {
+    expect(getPackageFromRoute(route)).toStrictEqual(expected);
+  });
+});
+
+describe('routeMatched', () => {
+  it.each([
+    {
+      desc:     'returns false when route has no matched array',
+      to:       {},
+      fn:       (m) => !!m.meta?.test,
+      expected: false,
+    },
+    {
+      desc:     'returns true when predicate matches a route entry',
+      to:       { matched: [{ meta: { test: true } }] },
+      fn:       (m) => !!m.meta?.test,
+      expected: true,
+    },
+    {
+      desc:     'returns false when predicate matches no route entry',
+      to:       { matched: [{ meta: { other: true } }] },
+      fn:       (m) => !!m.meta?.test,
+      expected: false,
+    },
+  ])('$desc', ({ to, fn, expected }) => {
+    expect(routeMatched(to, fn)).toStrictEqual(expected);
+  });
+});
+
+describe('routeRequiresAuthentication', () => {
+  it.each([
+    {
+      desc:     'returns true when a matched route requires authentication',
+      to:       { matched: [{ meta: { requiresAuthentication: true } }] },
+      expected: true,
+    },
+    {
+      desc:     'returns false when no matched route requires authentication',
+      to:       { matched: [{ meta: {} }] },
+      expected: false,
+    },
+    {
+      desc:     'returns false when route has no matched array',
+      to:       {},
+      expected: false,
+    },
+  ])('$desc', ({ to, expected }) => {
+    expect(routeRequiresAuthentication(to)).toStrictEqual(expected);
+  });
+});
+
+describe('routeRequiresInstallRedirect', () => {
+  it.each([
+    {
+      desc:     'returns true when a matched route meta contains installRedirect',
+      to:       { matched: [{ meta: { installRedirect: 'some-product' } }] },
+      expected: true,
+    },
+    {
+      desc:     'returns false when no matched route has installRedirect',
+      to:       { matched: [{ meta: {} }] },
+      expected: false,
+    },
+    {
+      desc:     'returns false when route has no matched array',
+      to:       {},
+      expected: false,
+    },
+  ])('$desc', ({ to, expected }) => {
+    expect(routeRequiresInstallRedirect(to)).toStrictEqual(expected);
+  });
+});