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

package/types/notifications/index.ts

@@ -29,7 +29,7 @@ export type NotificationAction = {
  * Defines the User Preference linked to a notification
  */
 export type NotificationPreference = {
-  key: string; // User preference key to use when setting the preference when the notification is marked as read
+  key: string; // User preference key to use when setting the preference when the notification is marked as read/unread
   value: string; // User preference value to use when setting the preference when the notification is marked as read
   unsetValue?: string; // User preference value to use when setting the preference when the notification is marked as unread - defaults to empty string
 };
@@ -47,6 +47,11 @@ export type EncryptedNotification = {
   primaryAction?: NotificationAction;
   // Secondary to be shown in the notification (optional)
   secondaryAction?: NotificationAction;
+  // User Preference tied to the notification (optional) (the preference will be updated when the notification is marked read)
+  preference?: NotificationPreference;
+  // Handler to be associated with this notification that can invoke additional behaviour when the notification changes
+  // This is the name of the handler (the handlers are added as extensions). Notifications are persisted in the store, so can't use functions.
+  handlerName?: string;
 };
 
 /**
@@ -57,8 +62,6 @@ export type Notification = {
   id: string;
   // Progress (0-100) for notifications of type `Task` (optional)
   progress?: number;
-  // User Preference tied to the notification (optional) (the preference will be updated when the notification is marked read)
-  preference?: NotificationPreference;
 } & EncryptedNotification;
 
 /**
@@ -72,3 +75,21 @@ export type StoredNotification = {
   created: Date;
   read: Boolean;
 } & Notification;
+
+/**
+ * Name to use when registering a custom notification handler
+ */
+export const NotificationHandlerExtensionName = 'notification-handler';
+
+/**
+ * Interface for notification handler
+ */
+export interface NotificationHandler {
+  /**
+   * Called when a notification with this handler has its read status is updated (read or unread)
+   *
+   * @param notification Notification that was marked read or unread
+   * @param read Indicates whether the notification was updated to be read or unread
+   */
+  onReadUpdated(notification: Notification, read: boolean): void;
+}

package/types/shell/index.d.ts

@@ -70,6 +70,9 @@ export namespace CAPI {
     let SECRET_AUTH: string;
     let SECRET_WILL_DELETE: string;
     let UI_CUSTOM_PROVIDER: string;
+    let AUTOSCALER_CLUSTER_PAUSE: string;
+    let AUTOSCALER_MACHINE_POOL_MIN_SIZE: string;
+    let AUTOSCALER_MACHINE_POOL_MAX_SIZE: string;
 }
 export namespace CATALOG {
     let CERTIFIED: string;
@@ -2000,6 +2003,18 @@ export namespace PROJECT {
     let labelKey_124: string;
     export { labelKey_124 as labelKey };
 }
+export namespace AUTOSCALER_ENABLED {
+    let name_128: string;
+    export { name_128 as name };
+    let labelKey_125: string;
+    export { labelKey_125 as labelKey };
+    let value_127: string;
+    export { value_127 as value };
+    let sort_116: string[];
+    export { sort_116 as sort };
+    let formatter_71: string;
+    export { formatter_71 as formatter };
+}
 }
 
 // @shell/config/types
@@ -2322,6 +2337,8 @@ export const ZERO_TIME: "0001-01-01T00:00:00Z";
 export const DEFAULT_GRAFANA_STORAGE_SIZE: "10Gi";
 export const DEPRECATED: "Deprecated";
 export const EXPERIMENTAL: "Experimental";
+export const AUTOSCALER_CONFIG_MAP_ID: "kube-system/cluster-autoscaler-status";
+export const HOSTED_PROVIDER: "hostedprovider";
 }
 
 // @shell/config/version
@@ -3676,6 +3693,7 @@ export const UIEXTENSION: any;
 export const PROVISIONING_PRE_BOOTSTRAP: any;
 export const SCHEDULING_CUSTOMIZATION: any;
 export const SCC: any;
+export const AUTOSCALER: any;
 export namespace getters {
     function get(state: any, getters: any, rootState: any, rootGetters: any): (name: any) => any;
 }
@@ -3762,6 +3780,7 @@ export const SCALE_POOL_PROMPT: any;
 export const READ_NEW_RELEASE: any;
 export const READ_SUPPORT_NOTICE: any;
 export const READ_UPCOMING_SUPPORT_NOTICE: any;
+export const READ_ANNOUNCEMENTS: any;
 export function state(): {
     cookiesLoaded: boolean;
     data: {};
@@ -4495,7 +4514,7 @@ export function isEmpty(obj: any): boolean;
 export function isSimpleKeyValue(obj: any): boolean;
 export function cleanUp(obj: any): any;
 export function definedKeys(obj: any): any;
-export function diff(from: any, to: any): any;
+export function diff(from: any, to: any, preventNull?: boolean): any;
 export function changeset(from: any, to: any, parentPath?: any[]): {};
 export function changesetConflicts(a: any, b: any): any[];
 export function applyChangeset(obj: any, changeset: any): any;
@@ -4735,6 +4754,12 @@ export function routeRequiresAuthentication(to: any): boolean;
 export function routeRequiresInstallRedirect(to: any): boolean;
 }
 
+// @shell/utils/scroll
+
+declare module '@shell/utils/scroll' {
+export function scrollToBottom(): void;
+}
+
 // @shell/utils/select
 
 declare module '@shell/utils/select' {

package/utils/__tests__/object.test.ts

@@ -182,6 +182,25 @@ describe('fx: diff', () => {
 
     expect(result).toStrictEqual(expected);
   });
+  it('should return an object with property "baz" different than "null" if using the flag "preventNull" as true', () => {
+    const from = {
+      foo: 'bar',
+      baz: 'bang',
+    };
+    const to = {
+      foo:  'bar',
+      bang: 'baz'
+    };
+
+    const result = diff(from, to, true);
+    const expected = {
+      // the property "baz" having value !== null covers test case for https://github.com/rancher/dashboard/issues/15710
+      baz:  'bang',
+      bang: 'baz'
+    };
+
+    expect(result).toStrictEqual(expected);
+  });
   it('should return an object and dot characters in object should still be respected', () => {
     const from = {};
     const to = { foo: { 'bar.baz': 'bang' } };

package/utils/autoscaler-utils.ts

@@ -0,0 +1,7 @@
+import { AUTOSCALER } from '@shell/store/features';
+
+export function isAutoscalerFeatureFlagEnabled(store: any): boolean {
+  const rootGetters = store.rootGetters || store.getters;
+
+  return rootGetters['features/get'](AUTOSCALER);
+}

package/utils/dynamic-content/__tests__/announcement.test.ts

@@ -0,0 +1,498 @@
+import { processAnnouncements, ANNOUNCEMENT_PREFIX } from '../announcement';
+import { NotificationLevel, Notification } from '@shell/types/notifications';
+import { READ_ANNOUNCEMENTS } from '@shell/store/prefs';
+import { DynamicContentAnnouncementHandlerName } from '../notification-handler';
+import { Context, VersionInfo, Announcement } from '../types';
+import semver from 'semver';
+
+jest.mock('semver', () => ({
+  ...jest.requireActual('semver'),
+  satisfies: jest.fn(),
+}));
+
+describe('processAnnouncements', () => {
+  let mockDispatch: jest.Mock;
+  let mockGetters: any;
+  let mockLogger: any;
+  let mockContext: Context;
+
+  const VERSION_270 = { version: semver.coerce('v2.7.0') as semver.SemVer, isPrime: false };
+
+  beforeEach(() => {
+    mockDispatch = jest.fn();
+    mockGetters = {
+      'notifications/item': jest.fn(),
+      'prefs/get':          jest.fn(),
+    };
+    mockLogger = {
+      error: jest.fn(),
+      info:  jest.fn(),
+    };
+    mockContext = {
+      dispatch: mockDispatch,
+      getters:  mockGetters,
+      logger:   mockLogger,
+      isAdmin:  false, // Default to non-admin
+    } as unknown as Context;
+
+    // Reset all mocks before each test
+    jest.clearAllMocks();
+
+    // Default mock for semver.satisfies to return true
+    (semver.satisfies as jest.Mock).mockReturnValue(true);
+  });
+
+  // --- Early Exit Conditions ---
+  it('should return early if no announcements are provided', async() => {
+    await processAnnouncements(mockContext, undefined, VERSION_270);
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+  });
+
+  it('should return early if announcements array is empty', async() => {
+    await processAnnouncements(mockContext, [], VERSION_270);
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+  });
+
+  it('should return early if versionInfo is undefined', async() => {
+    await processAnnouncements(mockContext, [{
+      id:      '1',
+      target:  'notification/announcement',
+      title:   'Test',
+      message: 'Msg'
+    }], undefined as any);
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+  });
+
+  it('should return early if versionInfo.version is undefined', async() => {
+    await processAnnouncements(mockContext, [{
+      id:      '1',
+      target:  'notification/announcement',
+      title:   'Test',
+      message: 'Msg'
+    }], { version: undefined as any, isPrime: false });
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+  });
+
+  // --- Version and Audience Filtering ---
+  it('should not process announcement if version does not satisfy requirement', async() => {
+    (semver.satisfies as jest.Mock).mockReturnValue(false);
+    const announcements: Announcement[] = [
+      {
+        id:      '1',
+        target:  'notification/announcement',
+        title:   'Test',
+        message: 'Msg',
+        version: 'v2.8.0'
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(semver.satisfies).toHaveBeenCalledWith(VERSION_270.version, announcements[0].version);
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+  });
+
+  it('should not process admin-only announcement if user is not admin', async() => {
+    mockContext.isAdmin = false;
+    const announcements: Announcement[] = [
+      {
+        id:       '1',
+        target:   'notification/announcement',
+        title:    'Test',
+        message:  'Msg',
+        audience: 'admin'
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+  });
+
+  it('should process admin-only announcement if user is admin', async() => {
+    mockContext.isAdmin = true;
+    const announcements: Announcement[] = [
+      {
+        id:       '1',
+        target:   'notification/announcement',
+        title:    'Test',
+        message:  'Msg',
+        audience: 'admin'
+      },
+    ];
+    const versionInfo: VersionInfo = { version: VERSION_270.version };
+
+    await processAnnouncements(mockContext, announcements, versionInfo);
+
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expect.any(Object));
+  });
+
+  it('should process all-audience announcement regardless of admin status', async() => {
+    mockContext.isAdmin = false; // Test with non-admin
+    const announcements: Announcement[] = [
+      {
+        id:       '1',
+        target:   'notification/announcement',
+        title:    'Test',
+        message:  'Msg',
+        audience: 'all'
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expect.any(Object));
+  });
+
+  // --- Target Type Handling ---
+  it('should log error for unsupported announcement target type', async() => {
+    const announcements: Announcement[] = [
+      {
+        id:      '1',
+        target:  'unsupported/type',
+        title:   'Test',
+        message: 'Msg'
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(mockLogger.error).toHaveBeenCalledWith('Announcement type unsupported/type is not supported');
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  it('should log error for unsupported notification sub-type', async() => {
+    const announcements: Announcement[] = [
+      {
+        id:      '1',
+        target:  'notification/unsupported',
+        title:   'Test',
+        message: 'Msg'
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(mockLogger.error).toHaveBeenCalledWith('Announcement notification type unsupported is not supported');
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  // --- Notification Creation Logic ---
+  it('should log error and not add notification if announcement has no ID', async() => {
+    const announcements: Announcement[] = [
+      {
+        target:  'notification/announcement',
+        title:   'Test',
+        message: 'Msg'
+      } as Announcement, // Missing ID
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(mockLogger.error).toHaveBeenCalledWith('No ID For announcement - not going to add a notification for the announcement');
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  it('should not add notification if one with the same ID already exists', async() => {
+    const announcementId = 'existing-announcement';
+
+    mockGetters['notifications/item'].mockReturnValue({ id: `${ ANNOUNCEMENT_PREFIX }${ announcementId }` });
+    const announcements: Announcement[] = [
+      {
+        id:      announcementId,
+        target:  'notification/announcement',
+        title:   'Test',
+        message: 'Msg'
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(mockGetters['notifications/item']).toHaveBeenCalledWith(`${ ANNOUNCEMENT_PREFIX }${ announcementId }`);
+    expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining('Not adding announcement with ID'));
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  it('should not add notification if announcement ID is in READ_ANNOUNCEMENTS preference', async() => {
+    const announcementId = 'read-announcement';
+
+    mockGetters['notifications/item'].mockReturnValue(undefined); // No existing notification
+    mockGetters['prefs/get'].mockImplementation((key: string) => {
+      if (key === READ_ANNOUNCEMENTS) {
+        return `some-other-id,${ announcementId },another-one`;
+      }
+
+      return '';
+    });
+    const announcements: Announcement[] = [
+      {
+        id:      announcementId,
+        target:  'notification/announcement',
+        title:   'Test',
+        message: 'Msg'
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(mockGetters['prefs/get']).toHaveBeenCalledWith(READ_ANNOUNCEMENTS);
+    expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining('Not adding announcement with ID'));
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  it('should add a new announcement notification with default level (announcement)', async() => {
+    const announcementId = 'new-announcement';
+
+    mockGetters['notifications/item'].mockReturnValue(undefined);
+    mockGetters['prefs/get'].mockReturnValue('');
+    const announcements: Announcement[] = [
+      {
+        id:      announcementId,
+        target:  'notification/announcement',
+        title:   'New Announcement',
+        message: 'This is a new message.'
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    const expectedNotification: Notification = {
+      id:          `${ ANNOUNCEMENT_PREFIX }${ announcementId }`,
+      level:       NotificationLevel.Announcement,
+      title:       'New Announcement',
+      message:     'This is a new message.',
+      handlerName: DynamicContentAnnouncementHandlerName,
+    };
+
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expectedNotification);
+    expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining(`Adding announcement with ID ${ ANNOUNCEMENT_PREFIX }${ announcementId }`));
+  });
+
+  it('should add a new info level notification', async() => {
+    const announcementId = 'new-info';
+
+    mockGetters['notifications/item'].mockReturnValue(undefined);
+    mockGetters['prefs/get'].mockReturnValue('');
+    const announcements: Announcement[] = [
+      {
+        id:      announcementId,
+        target:  'notification/info',
+        title:   'Info Title',
+        message: 'Info Message'
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    const expectedNotification: Notification = {
+      id:          `${ ANNOUNCEMENT_PREFIX }${ announcementId }`,
+      level:       NotificationLevel.Info,
+      title:       'Info Title',
+      message:     'Info Message',
+      handlerName: DynamicContentAnnouncementHandlerName,
+    };
+
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expectedNotification);
+  });
+
+  it('should add a new warning level notification', async() => {
+    const announcementId = 'new-warning';
+
+    mockGetters['notifications/item'].mockReturnValue(undefined);
+    mockGetters['prefs/get'].mockReturnValue('');
+    const announcements: Announcement[] = [
+      {
+        id:      announcementId,
+        target:  'notification/warning',
+        title:   'Warning Title',
+        message: 'Warning Message'
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    const expectedNotification: Notification = {
+      id:          `${ ANNOUNCEMENT_PREFIX }${ announcementId }`,
+      level:       NotificationLevel.Warning,
+      title:       'Warning Title',
+      message:     'Warning Message',
+      handlerName: DynamicContentAnnouncementHandlerName,
+    };
+
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expectedNotification);
+  });
+
+  // --- Call To Action (CTA) Handling ---
+  it('should add notification with primary CTA', async() => {
+    const announcementId = 'cta-primary';
+
+    mockGetters['notifications/item'].mockReturnValue(undefined);
+    mockGetters['prefs/get'].mockReturnValue('');
+
+    const announcements: Announcement[] = [
+      {
+        id:      announcementId,
+        target:  'notification/announcement',
+        title:   'CTA Primary',
+        message: 'Message',
+        cta:     { primary: { action: 'Click Me', link: '/some/path' } },
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    const notification = mockDispatch.mock.calls[0][1];
+
+    expect(notification.primaryAction).toStrictEqual({
+      label:  'Click Me',
+      target: '/some/path'
+    });
+    expect(notification.secondaryAction).toBeUndefined();
+  });
+
+  it('should add notification with secondary CTA', async() => {
+    const announcementId = 'cta-secondary';
+
+    mockGetters['notifications/item'].mockReturnValue(undefined);
+    mockGetters['prefs/get'].mockReturnValue('');
+    const announcements: Announcement[] = [
+      {
+        id:      announcementId,
+        target:  'notification/announcement',
+        title:   'CTA Secondary',
+        message: 'Message',
+        cta:     { secondary: { action: 'More Info', link: 'http://example.com' } },
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    const notification = mockDispatch.mock.calls[0][1];
+
+    expect(notification.secondaryAction).toStrictEqual({ label: 'More Info', target: 'http://example.com' });
+    expect(notification.primaryAction).toBeUndefined();
+  });
+
+  it('should add notification with both primary and secondary CTAs', async() => {
+    const announcementId = 'cta-both';
+
+    mockGetters['notifications/item'].mockReturnValue(undefined);
+    mockGetters['prefs/get'].mockReturnValue('');
+    const announcements: Announcement[] = [
+      {
+        id:      announcementId,
+        target:  'notification/announcement',
+        title:   'CTA Both',
+        message: 'Message',
+        cta:     {
+          primary: {
+            action: 'Primary',
+            link:   '/primary'
+          },
+          secondary: {
+            action: 'Secondary',
+            link:   '/secondary'
+          },
+        },
+      },
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    const notification = mockDispatch.mock.calls[0][1];
+
+    expect(notification.primaryAction).toStrictEqual({ label: 'Primary', target: '/primary' });
+    expect(notification.secondaryAction).toStrictEqual({ label: 'Secondary', target: '/secondary' });
+  });
+
+  // --- Multiple Announcements ---
+  it('should process multiple announcements correctly, skipping invalid ones', async() => {
+    mockContext.isAdmin = true; // Ensure admin-only can be processed
+    mockGetters['notifications/item'].mockImplementation((id: string) => {
+      if (id === `${ ANNOUNCEMENT_PREFIX }existing-id`) {
+        return { id };
+      }
+
+      return undefined;
+    });
+    mockGetters['prefs/get'].mockImplementation((key: string) => {
+      if (key === READ_ANNOUNCEMENTS) {
+        return 'read-id';
+      }
+
+      return '';
+    });
+
+    const announcements: Announcement[] = [
+      {
+        id:       'valid-1',
+        target:   'notification/info',
+        title:    'Valid 1',
+        message:  'Msg 1',
+        audience: 'all'
+      },
+      {
+        id:      'existing-id',
+        target:  'notification/announcement',
+        title:   'Existing',
+        message: 'Msg Existing'
+      }, // Should be skipped
+      {
+        id:      'read-id',
+        target:  'notification/warning',
+        title:   'Read',
+        message: 'Msg Read'
+      }, // Should be skipped
+      {
+        id:       'valid-2',
+        target:   'notification/announcement',
+        title:    'Valid 2',
+        message:  'Msg 2',
+        audience: 'admin'
+      },
+      {
+        id:      'invalid-target',
+        target:  'unsupported/type',
+        title:   'Invalid',
+        message: 'Msg Invalid'
+      }, // Should log error
+      {
+        id:      'valid-3',
+        target:  'notification/info',
+        title:   'Valid 3',
+        message: 'Msg 3',
+        version: 'v1.0.0'
+      }, // semver.satisfies is mocked to true by default
+    ];
+
+    await processAnnouncements(mockContext, announcements, VERSION_270);
+
+    // Expect 3 notifications to be added (valid-1, valid-2, valid-3)
+    expect(mockDispatch).toHaveBeenCalledTimes(3);
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({ id: `${ ANNOUNCEMENT_PREFIX }valid-1` }));
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({ id: `${ ANNOUNCEMENT_PREFIX }valid-2` }));
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({ id: `${ ANNOUNCEMENT_PREFIX }valid-3` }));
+
+    // Expect errors for invalid target
+    expect(mockLogger.error).toHaveBeenCalledWith('Announcement type unsupported/type is not supported');
+
+    // Expect info logs for skipped announcements
+    expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining('Not adding announcement with ID '));
+    expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining(`${ ANNOUNCEMENT_PREFIX }existing-id`));
+    expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining(`${ ANNOUNCEMENT_PREFIX }read-id`));
+  });
+});