@rancher/shell 3.0.6 → 3.0.8-rc.1

package/utils/dynamic-content/__tests__/support-notice.test.ts

@@ -0,0 +1,262 @@
+import { processSupportNotices } from '../support-notice';
+import { NotificationLevel } from '@shell/types/notifications';
+import { READ_SUPPORT_NOTICE, READ_UPCOMING_SUPPORT_NOTICE } from '@shell/store/prefs';
+import { Context, VersionInfo, SupportInfo } from '../types';
+import * as util from '../util'; // To mock removeMatchingNotifications
+import semver from 'semver';
+import day from 'dayjs';
+
+describe('processSupportNotices', () => {
+  let mockContext: Context;
+  let mockDispatch: jest.Mock;
+  let mockGetters: any;
+  let mockLogger: any;
+  let mockRemoveMatchingNotifications: jest.SpyInstance;
+
+  beforeEach(() => {
+    mockDispatch = jest.fn();
+    mockGetters = {
+      'prefs/get': jest.fn(),
+      'i18n/t':    jest.fn((key: string, params?: any) => {
+        const { version, days } = params || {};
+
+        if (key === 'dynamicContent.eol.title') return `EOL Title for ${ version }`;
+        if (key === 'dynamicContent.eol.message') return `EOL Message for ${ version }`;
+        if (key === 'dynamicContent.eom.title') return `EOM Title for ${ version }`;
+        if (key === 'dynamicContent.eom.message') return `EOM Message for ${ version }`;
+        if (key === 'dynamicContent.upcomingEol.title') return `Upcoming EOL Title for ${ version } in ${ days } days`;
+        if (key === 'dynamicContent.upcomingEol.message') return `Upcoming EOL Message for ${ version } in ${ days } days`;
+        if (key === 'dynamicContent.upcomingEom.title') return `Upcoming EOM Title for ${ version } in ${ days } days`;
+        if (key === 'dynamicContent.upcomingEom.message') return `Upcoming EOM Message for ${ version } in ${ days } days`;
+
+        return key;
+      }),
+    };
+    mockLogger = {
+      info:  jest.fn(),
+      debug: jest.fn(),
+      error: jest.fn(),
+    };
+
+    mockContext = {
+      dispatch: mockDispatch,
+      getters:  mockGetters,
+      axios:    {},
+      logger:   mockLogger,
+      isAdmin:  true,
+      config:   {
+        enabled:      true,
+        debug:        false,
+        log:          false,
+        endpoint:     '',
+        prime:        false,
+        distribution: 'community',
+      },
+      settings: {
+        releaseNotesUrl: '',
+        suseExtensions:  [],
+      },
+    };
+
+    // Mock the utility function. Default: notification does not exist, so add it.
+    mockRemoveMatchingNotifications = jest.spyOn(util, 'removeMatchingNotifications')
+      .mockResolvedValue(false);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should return early if statusInfo is null/undefined', async() => {
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+
+    await processSupportNotices(mockContext, null as any, versionInfo);
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  it('should return early if versionInfo is null/undefined or version is missing', async() => {
+    const statusInfo: SupportInfo = { status: { eol: '<= 2.11', eom: '<= 2.12' }, upcoming: {} as any };
+
+    await processSupportNotices(mockContext, statusInfo, null as any);
+    expect(mockDispatch).not.toHaveBeenCalled();
+    await processSupportNotices(mockContext, statusInfo, { version: null, isPrime: false });
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  it('should not add notification if no support status matches', async() => {
+    const versionInfo: VersionInfo = { version: semver.coerce('2.13.0')!, isPrime: false };
+    const statusInfo: SupportInfo = {
+      status:   { eol: '<= 2.11.x', eom: '<= 2.12.x' },
+      upcoming: {
+        eom: { version: '= 2.13.x', date: day().add(40, 'day').toDate() },
+        eol: { version: '= 2.13.x', date: day().add(40, 'day').toDate() },
+      }
+    };
+
+    await processSupportNotices(mockContext, statusInfo, versionInfo);
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+  });
+
+  it('should add EOL notification if version is EOL', async() => {
+    const versionInfo: VersionInfo = { version: semver.coerce('2.11.5')!, isPrime: false };
+    const statusInfo: SupportInfo = {
+      status:   { eol: '<= 2.11.x', eom: '<= 2.12.x' },
+      upcoming: {} as any
+    };
+
+    await processSupportNotices(mockContext, statusInfo, versionInfo);
+
+    expect(mockLogger.info).toHaveBeenCalledWith('This version (2.11.5) is End of Life');
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({
+      id:    'support-notice-eol-2.11',
+      level: NotificationLevel.Warning,
+      title: 'EOL Title for 2.11',
+    }));
+  });
+
+  it('should add EOM notification if version is EOM but not EOL', async() => {
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.3')!, isPrime: false };
+    const statusInfo: SupportInfo = {
+      status:   { eol: '<= 2.11.x', eom: '<= 2.12.x' },
+      upcoming: {} as any
+    };
+
+    await processSupportNotices(mockContext, statusInfo, versionInfo);
+
+    expect(mockLogger.info).toHaveBeenCalledWith('This version (2.12.3) is End of Maintenance');
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({
+      id:    'support-notice-eom-2.12',
+      level: NotificationLevel.Warning,
+      title: 'EOM Title for 2.12',
+    }));
+  });
+
+  it('should add upcoming EOL notification', async() => {
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+    const statusInfo: SupportInfo = {
+      status:   { eol: '<= 2.11.x', eom: '<= 2.11.x' },
+      upcoming: {
+        eol: { version: '= 2.12.x', date: day().add(15, 'day').toDate() },
+        eom: {} as any,
+      }
+    };
+
+    await processSupportNotices(mockContext, statusInfo, versionInfo);
+
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({
+      id:    'upcoming-support-notice-eol-2.12',
+      level: NotificationLevel.Warning,
+      title: 'Upcoming EOL Title for 2.12 in 15 days',
+    }));
+  });
+
+  it('should add upcoming EOM notification', async() => {
+    const versionInfo: VersionInfo = { version: semver.coerce('2.13.0')!, isPrime: false };
+    const statusInfo: SupportInfo = {
+      status:   { eol: '<= 2.12.x', eom: '<= 2.12.x' },
+      upcoming: {
+        eom: {
+          version: '= 2.13.x', date: day().add(20, 'day').toDate(), noticeDays: 25
+        },
+        eol: {} as any,
+      }
+    };
+
+    await processSupportNotices(mockContext, statusInfo, versionInfo);
+
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', expect.objectContaining({
+      id:    'upcoming-support-notice-eom-2.13',
+      level: NotificationLevel.Warning,
+      title: 'Upcoming EOM Title for 2.13 in 20 days',
+    }));
+  });
+
+  it('should not add notification if removeMatchingNotifications indicates it exists', async() => {
+    mockRemoveMatchingNotifications.mockResolvedValue(true); // Simulate notification already exists
+    const versionInfo: VersionInfo = { version: semver.coerce('2.11.5')!, isPrime: false };
+    const statusInfo: SupportInfo = {
+      status:   { eol: '<= 2.11.x', eom: '<= 2.12.x' },
+      upcoming: {} as any
+    };
+
+    await processSupportNotices(mockContext, statusInfo, versionInfo);
+
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  describe('user preferences', () => {
+    it('should not add EOL notification if it was already read', async() => {
+      mockGetters['prefs/get'].mockImplementation((key: string) => {
+        if (key === READ_SUPPORT_NOTICE) return 'eol-2.11';
+
+        return '';
+      });
+      const versionInfo: VersionInfo = { version: semver.coerce('2.11.5')!, isPrime: false };
+      const statusInfo: SupportInfo = {
+        status:   { eol: '<= 2.11.x', eom: '<= 2.12.x' },
+        upcoming: {} as any
+      };
+
+      await processSupportNotices(mockContext, statusInfo, versionInfo);
+
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it('should not add EOM notification if it was already read', async() => {
+      mockGetters['prefs/get'].mockImplementation((key: string) => {
+        if (key === READ_SUPPORT_NOTICE) return 'eom-2.12';
+
+        return '';
+      });
+      const versionInfo: VersionInfo = { version: semver.coerce('2.12.3')!, isPrime: false };
+      const statusInfo: SupportInfo = {
+        status:   { eol: '<= 2.11.x', eom: '<= 2.12.x' },
+        upcoming: {} as any
+      };
+
+      await processSupportNotices(mockContext, statusInfo, versionInfo);
+
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it('should not add upcoming EOL notification if it was already read', async() => {
+      mockGetters['prefs/get'].mockImplementation((key: string) => {
+        if (key === READ_UPCOMING_SUPPORT_NOTICE) return 'eol-2.12';
+
+        return '';
+      });
+      const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+      const statusInfo: SupportInfo = {
+        status:   { eol: '<= 2.11.x', eom: '<= 2.11.x' },
+        upcoming: { eol: { version: '= 2.12.x', date: day().add(145, 'day').toDate() }, eom: {} as any }
+      };
+
+      await processSupportNotices(mockContext, statusInfo, versionInfo);
+
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it('should not add upcoming EOM notification if it was already read', async() => {
+      mockGetters['prefs/get'].mockImplementation((key: string) => {
+        if (key === READ_UPCOMING_SUPPORT_NOTICE) return 'eom-2.13';
+
+        return '';
+      });
+      const versionInfo: VersionInfo = { version: semver.coerce('2.13.0')!, isPrime: false };
+      const statusInfo: SupportInfo = {
+        status:   { eol: '<= 2.12.x', eom: '<= 2.12.x' },
+        upcoming: {
+          eom: {
+            version: '= 2.13.x', date: day().add(20, 'day').toDate(), noticeDays: 25
+          },
+          eol: {} as any
+        }
+      };
+
+      await processSupportNotices(mockContext, statusInfo, versionInfo);
+
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -0,0 +1,235 @@
+import { removeMatchingNotifications, createLogger, LOCAL_STORAGE_CONTENT_DEBUG_LOG } from '../util';
+import { Context, Configuration } from '../types';
+
+describe('util.ts', () => {
+  describe('removeMatchingNotifications', () => {
+    let mockContext: Context;
+    let mockDispatch: jest.Mock;
+    let mockGetters: any;
+    let mockLogger: any;
+
+    beforeEach(() => {
+      mockDispatch = jest.fn();
+      mockGetters = { 'notifications/all': [] };
+      mockLogger = { debug: jest.fn() };
+      mockContext = {
+        dispatch: mockDispatch,
+        getters:  mockGetters,
+        logger:   mockLogger,
+        // The following properties are not used by this function but are required by the type
+        axios:    {},
+        isAdmin:  true,
+        config:   {} as any,
+        settings: {} as any,
+      };
+    });
+
+    it('should return false and not remove anything if no notifications exist', async() => {
+      const found = await removeMatchingNotifications(mockContext, 'prefix-', 'current');
+
+      expect(found).toBe(false);
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it('should return false and not remove anything if no notifications match the prefix', async() => {
+      mockGetters['notifications/all'] = [
+        { id: 'other-1' },
+        { id: 'other-2' },
+      ];
+      const found = await removeMatchingNotifications(mockContext, 'prefix-', 'current');
+
+      expect(found).toBe(false);
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it('should return true and not remove anything if the current notification is the only one matching', async() => {
+      mockGetters['notifications/all'] = [
+        { id: 'prefix-current' },
+        { id: 'other-1' },
+      ];
+      const found = await removeMatchingNotifications(mockContext, 'prefix-', 'current');
+
+      expect(found).toBe(true);
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it('should return false and remove a notification that matches the prefix but not the currentId', async() => {
+      mockGetters['notifications/all'] = [
+        { id: 'prefix-old' },
+        { id: 'other-1' },
+      ];
+      const found = await removeMatchingNotifications(mockContext, 'prefix-', 'current');
+
+      expect(found).toBe(false);
+      expect(mockDispatch).toHaveBeenCalledTimes(1);
+      expect(mockDispatch).toHaveBeenCalledWith('notifications/remove', 'prefix-old');
+    });
+
+    it('should return true and remove old notifications when the current one also exists', async() => {
+      mockGetters['notifications/all'] = [
+        { id: 'prefix-old-1' },
+        { id: 'prefix-current' },
+        { id: 'prefix-old-2' },
+        { id: 'other-1' },
+      ];
+      const found = await removeMatchingNotifications(mockContext, 'prefix-', 'current');
+
+      expect(found).toBe(true);
+      expect(mockDispatch).toHaveBeenCalledTimes(2);
+      expect(mockDispatch).toHaveBeenCalledWith('notifications/remove', 'prefix-old-1');
+      expect(mockDispatch).toHaveBeenCalledWith('notifications/remove', 'prefix-old-2');
+    });
+  });
+
+  describe('createLogger / log', () => {
+    let mockLocalStorage: { [key: string]: string };
+    let consoleErrorSpy: jest.SpyInstance;
+    let consoleInfoSpy: jest.SpyInstance;
+    let consoleDebugSpy: jest.SpyInstance;
+    let dispatchEventSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      // Mock localStorage
+      mockLocalStorage = {};
+      jest.spyOn(Storage.prototype, 'getItem').mockImplementation((key) => mockLocalStorage[key] || null);
+      jest.spyOn(Storage.prototype, 'setItem').mockImplementation((key, value) => {
+        mockLocalStorage[key] = value;
+      });
+
+      // Mock console
+      consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+      consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => {});
+      consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => {});
+
+      // Mock dispatchEvent
+      dispatchEventSpy = jest.spyOn(window, 'dispatchEvent').mockImplementation(() => true);
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should always log errors to console, but only to localStorage if config.log is true', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: false, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      logger.error('test error');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('test error');
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeUndefined();
+
+      // Test with arg
+      logger.error('test error', 'with arg');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('test error', 'with arg');
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeUndefined();
+
+      config.log = true;
+
+      logger.error('test error with log');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('test error with log');
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeDefined();
+      expect(JSON.parse(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG])[0].message).toBe('test error with log');
+    });
+
+    it('should log info to console and localStorage only if config.log is true', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: false, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      logger.info('test info');
+
+      expect(consoleInfoSpy).not.toHaveBeenCalled();
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeUndefined();
+
+      config.log = true;
+      logger.info('test info with log');
+
+      expect(consoleInfoSpy).toHaveBeenCalledWith('test info with log');
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeDefined();
+      expect(JSON.parse(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG])[0].message).toBe('test info with log');
+
+      // Test with arg
+      logger.info('test info', 'with arg');
+
+      expect(consoleInfoSpy).toHaveBeenCalledWith('test info', 'with arg');
+    });
+
+    it('should log debug to console only if config.debug is true, and localStorage if config.log is true', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: false, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      logger.debug('test debug');
+      expect(consoleDebugSpy).not.toHaveBeenCalled();
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeUndefined();
+
+      config.log = true;
+      logger.debug('test debug with log');
+      expect(consoleDebugSpy).not.toHaveBeenCalled();
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeDefined();
+      expect(JSON.parse(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG])[0].message).toBe('test debug with log');
+
+      config.debug = true;
+      logger.debug('test debug with debug and log');
+      expect(consoleDebugSpy).toHaveBeenCalledWith('test debug with debug and log');
+    });
+
+    it('should dispatch a custom event when logging to localStorage', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: true, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      logger.info('test event');
+
+      expect(dispatchEventSpy).toHaveBeenCalledTimes(1);
+      const event = dispatchEventSpy.mock.calls[0][0] as CustomEvent;
+
+      expect(event.type).toBe('dynamicContentLog');
+      expect(event.detail.message).toBe('test event');
+    });
+
+    it('should limit the number of log messages in localStorage', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: true, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      // MAX_LOG_MESSAGES is 50
+      for (let i = 0; i < 60; i++) {
+        logger.info(`message ${ i }`);
+      }
+
+      const logs = JSON.parse(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]);
+
+      expect(logs).toHaveLength(50);
+      expect(logs[0].message).toBe('message 59'); // Most recent
+      expect(logs[49].message).toBe('message 10'); // Oldest
+    });
+
+    it('should not throw if localStorage is corrupted', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: true, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG] = 'this is not valid json';
+
+      expect(() => {
+        logger.info('test message');
+      }).not.toThrow();
+
+      // It should have overwritten the bad data
+      const logs = JSON.parse(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]);
+
+      expect(logs).toHaveLength(1);
+      expect(logs[0].message).toBe('test message');
+    });
+  });
+});

package/utils/dynamic-content/config.ts

@@ -0,0 +1,55 @@
+import { SETTING } from '@shell/config/settings';
+import { isRancherPrime } from '@shell/config/version';
+import { Configuration, Distribution } from './types';
+import { MANAGEMENT } from '@shell/config/types';
+
+// Default endpoint ($dist is either 'community' or 'prime')
+const DEFAULT_ENDPOINT = 'https://updates.rancher.io/rancher/$dist/updates';
+
+// We only support retrieving content from secure endpoints
+const HTTPS_PREFIX = 'https://';
+
+/**
+ * Get configuration data based on the distribution and Rancher settings
+ *
+ * @param getters Store getters to access the store
+ * @returns Dynamic Content configuration
+ */
+export function getConfig(getters: any): Configuration {
+  const prime = isRancherPrime();
+  const distribution: Distribution = prime ? 'prime' : 'community';
+
+  // Default configuration
+  const config: Configuration = {
+    enabled:  true,
+    debug:    false,
+    log:      false,
+    endpoint: DEFAULT_ENDPOINT,
+    prime,
+    distribution,
+  };
+
+  // Update 'enabled' and 'endpoint' from Rancher settings, if applicable
+  try {
+    const enabledSetting = getters['management/byId'](MANAGEMENT.SETTING, SETTING.DYNAMIC_CONTENT_ENABLED);
+
+    if (enabledSetting?.value) {
+      // Any value other than 'false' means enabled (can't disable on Prime)
+      config.enabled = config.prime ? enabledSetting.value !== 'false' : true;
+      config.debug = enabledSetting.value === 'debug';
+      config.log = enabledSetting.value === 'log' || config.debug;
+    }
+
+    // Can only override the url when Prime
+    const urlSetting = getters['management/byId'](MANAGEMENT.SETTING, SETTING.DYNAMIC_CONTENT_ENDPOINT);
+
+    // Are we Prime, do we have a URL and does the URL start with the https prefix? If so, use it
+    if (prime && urlSetting?.value && urlSetting.value.startsWith(HTTPS_PREFIX)) {
+      config.endpoint = urlSetting.value;
+    }
+  } catch (e) {
+    console.error('Error reading dynamic content settings', e); // eslint-disable-line no-console
+  }
+
+  return config;
+}