@rancher/shell 3.0.7 → 3.0.8-rc.2

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

@@ -0,0 +1,263 @@
+import { SystemInfoProvider } from '../info';
+import { MANAGEMENT, COUNT } from '@shell/config/types';
+import { SETTING } from '@shell/config/settings';
+import * as version from '@shell/config/version';
+import { sha256 } from '@shell/utils/crypto';
+
+// Mock dependencies from @shell
+jest.mock('@shell/config/version', () => ({ getVersionData: jest.fn(), isRancherPrime: jest.fn() }));
+
+jest.mock('@shell/utils/crypto', () => ({ sha256: jest.fn((val: string) => `hashed_${ val }`) }));
+
+describe('systemInfoProvider', () => {
+  let mockGetters: any;
+  let mockSettings: any[];
+  let mockClusters: any[];
+  let mockCounts: any;
+  let mockPlugins: any[];
+  let originalWindowLocation: Location;
+
+  beforeAll(() => {
+    originalWindowLocation = window.location;
+    // Mock window.location
+    delete (window as any).location;
+    (window as any).location = { host: 'fallback.host' };
+  });
+
+  afterAll(() => {
+    (window as any).location = originalWindowLocation;
+  });
+
+  beforeEach(() => {
+    // Reset mocks
+    (version.getVersionData as jest.Mock).mockClear();
+    (version.isRancherPrime as jest.Mock).mockClear();
+    (sha256 as jest.Mock).mockClear();
+
+    // Mock window properties
+    Object.defineProperty(window, 'screen', {
+      value:    { width: 1920, height: 1080 },
+      writable: true
+    });
+    Object.defineProperty(window, 'innerWidth', { value: 1024, writable: true });
+    Object.defineProperty(window, 'innerHeight', { value: 768, writable: true });
+    Object.defineProperty(window.navigator, 'language', { value: 'en-US', writable: true });
+
+    mockSettings = [
+      { id: SETTING.SERVER_URL, value: 'https://rancher.test' },
+      { id: 'install-uuid', value: 'test-uuid' },
+    ];
+
+    mockClusters = [
+      {
+        id:                    'local',
+        isLocal:               true,
+        kubernetesVersionBase: '1.25',
+        provisioner:           'k3s',
+        status:                { nodeCount: 3 },
+      },
+      {
+        id:      'c-12345',
+        isLocal: false,
+      }
+    ];
+
+    mockCounts = [{ counts: { [MANAGEMENT.CLUSTER]: { summary: { count: 2 } } } }];
+
+    mockPlugins = [
+      { name: 'harvester', builtin: false },
+      { name: 'some-custom-ext', builtin: false },
+      { name: 'core', builtin: true },
+    ];
+
+    mockGetters = {
+      'management/typeRegistered': jest.fn().mockReturnValue(true),
+      'management/all':            jest.fn((type: string) => {
+        if (type === MANAGEMENT.SETTING) {
+          return mockSettings;
+        }
+        if (type === MANAGEMENT.CLUSTER) {
+          return mockClusters;
+        }
+        if (type === COUNT) {
+          return mockCounts;
+        }
+
+        return [];
+      }),
+      'auth/principalId':  'user-123',
+      'uiplugins/plugins': mockPlugins,
+      isSingleProduct:     false,
+      'management/byId':   jest.fn((type: string, id: string) => {
+        if (type === MANAGEMENT.SETTING) {
+          return mockSettings.find((s) => s.id === id) || null;
+        }
+
+        return undefined;
+      }),
+      'management/schemaFor': jest.fn(),
+    };
+
+    (version.getVersionData as jest.Mock).mockReturnValue({
+      Version:      '2.8.0-rc1',
+      RancherPrime: 'false',
+    });
+
+    (version.isRancherPrime as jest.Mock).mockReturnValue(false);
+  });
+
+  it('should build a complete query string with all available data', () => {
+    const infoProvider = new SystemInfoProvider(mockGetters, {});
+    const qs = infoProvider.buildQueryString();
+
+    expect(qs).toContain('dcv=v1');
+    expect(qs).toContain('s=hashed_https://rancher.test');
+    expect(qs).toContain('u=hashed_user-123');
+    expect(qs).toContain('uuid=test-uuid');
+    expect(qs).toContain('v=2.8.0');
+    expect(qs).toContain('dev=true');
+    expect(qs).toContain('p=false');
+    // Add back when LTS is added
+    // expect(qs).toContain('lts=false');
+    expect(qs).toContain('cc=2');
+    expect(qs).toContain('lkv=1.25');
+    expect(qs).toContain('lcp=k3s');
+    expect(qs).toContain('lnc=3');
+    expect(qs).toContain('xkn=harvester');
+    expect(qs).toContain('xcc=1');
+    expect(qs).toContain('bl=en-US');
+    expect(qs).toContain('bs=1024x768');
+    expect(qs).toContain('ss=1920x1080');
+  });
+
+  it('should handle missing or partial data gracefully', () => {
+    // Override mocks for this test
+    (version.getVersionData as jest.Mock).mockReturnValue({
+      Version:      '2.9.0', // Not a dev version
+      RancherPrime: 'true',
+    });
+    (version.isRancherPrime as jest.Mock).mockReturnValue(true);
+
+    mockGetters['management/all'].mockImplementation((type: string) => {
+      if (type === MANAGEMENT.SETTING) {
+        return [{ id: 'install-uuid', value: 'only-uuid' }]; // No server-url
+      }
+      if (type === COUNT) {
+        return [{ counts: { [MANAGEMENT.CLUSTER]: { summary: { count: 27 } } } }];
+      }
+      if (type === MANAGEMENT.CLUSTER) {
+        return []; // No clusters
+      }
+
+      return [];
+    });
+    mockGetters['management/byId'].mockImplementation((type: string, id: string) => {
+      if (type === MANAGEMENT.SETTING && id === 'install-uuid') {
+        return { id: 'install-uuid', value: 'only-uuid' }; // No server-url
+      }
+    });
+
+    mockGetters['uiplugins/plugins'] = null; // No plugins
+    mockGetters['auth/principalId'] = null; // No user
+
+    const infoProvider = new SystemInfoProvider(mockGetters, {});
+    const qs = infoProvider.buildQueryString();
+
+    expect(qs).toContain('s=hashed_fallback.host');
+    expect(qs).toContain('u=hashed_unknown');
+    expect(qs).toContain('uuid=only-uuid');
+    expect(qs).toContain('v=2.9.0');
+    expect(qs).toContain('dev=false');
+    expect(qs).toContain('p=true');
+    expect(qs).toContain('cc=27');
+    expect(qs).not.toContain('lkv=');
+    expect(qs).not.toContain('lcp=');
+    expect(qs).not.toContain('lnc=');
+    expect(qs).not.toContain('xkn=');
+    expect(qs).not.toContain('xcc=');
+  });
+
+  it('should handle getAll returning undefined when types are not registered', () => {
+    // Override mocks for this test
+    (version.getVersionData as jest.Mock).mockReturnValue({
+      Version:      '2.9.1',
+      RancherPrime: 'false',
+    });
+
+    // Simulate that the management types are not registered in the store
+    mockGetters['management/typeRegistered'].mockReturnValue(false);
+    mockGetters['management/all'].mockImplementation();
+    mockGetters['management/byId'].mockImplementation();
+
+    mockGetters['auth/principalId'] = 'user-456';
+    mockGetters['uiplugins/plugins'] = []; // No plugins
+
+    const infoProvider = new SystemInfoProvider(mockGetters, {});
+    const qs = infoProvider.buildQueryString();
+
+    expect(mockGetters['management/byId']).toHaveBeenCalledWith(MANAGEMENT.SETTING, 'server-url');
+    expect(mockGetters['management/byId']).toHaveBeenCalledWith(MANAGEMENT.SETTING, 'install-uuid');
+    expect(mockGetters['management/byId']).toHaveBeenCalledWith(MANAGEMENT.SETTING, 'server-version-type');
+    expect(mockGetters['management/typeRegistered']).toHaveBeenCalledWith(COUNT);
+    expect(mockGetters['management/typeRegistered']).toHaveBeenCalledWith(MANAGEMENT.CLUSTER);
+    expect(mockGetters['management/all']).not.toHaveBeenCalled();
+
+    // Verify the query string is built with fallback or empty values
+    expect(qs).toContain('s=hashed_fallback.host');
+    expect(qs).toContain('u=hashed_user-456');
+    expect(qs).toContain('v=2.9.1');
+    expect(qs).toContain('p=false');
+    expect(qs).toContain('xcc=0');
+    expect(qs).not.toContain('uuid=');
+    expect(qs).not.toContain('lkv=');
+  });
+
+  it('should use UNKNOWN for missing system properties', () => {
+    // Override mocks for this test
+    (version.getVersionData as jest.Mock).mockReturnValue({
+      Version:      '2.9.0',
+      RancherPrime: 'false',
+    });
+    (version.isRancherPrime as jest.Mock).mockReturnValue(false);
+
+    mockGetters['management/byId'].mockImplementation((type: string, id: string) => {
+      if (type === MANAGEMENT.SETTING) {
+        return { id, value: '' }; // Empty values for all settings
+      }
+    });
+    mockGetters['management/all'].mockImplementation((type: string) => {
+      if (type === MANAGEMENT.SETTING) {
+        // Return settings, but with empty values
+        return [
+          { id: SETTING.SERVER_URL, value: '' },
+          { id: 'install-uuid', value: '' },
+        ];
+      }
+      if (type === COUNT) {
+        return [{ counts: { [MANAGEMENT.CLUSTER]: { summary: { count: 1 } } } }];
+      }
+      if (type === MANAGEMENT.CLUSTER) {
+        // local cluster with missing properties
+        return [{
+          id:      'local',
+          isLocal: true,
+          status:  { nodeCount: 1 },
+          // kubernetesVersionBase is missing
+          // provisioner is missing
+        }];
+      }
+
+      return [];
+    });
+
+    mockGetters['auth/principalId'] = null; // No user
+
+    const infoProvider = new SystemInfoProvider(mockGetters, {});
+    const qs = infoProvider.buildQueryString();
+
+    expect(qs).toContain('u=hashed_unknown');
+    expect(qs).toContain('lkv=unknown');
+    expect(qs).toContain('lcp=unknown');
+    expect(qs).not.toContain('uuid='); // systemUUID is UNKNOWN, so it's skipped
+  });
+});

package/utils/dynamic-content/__tests__/new-release.test.ts

@@ -0,0 +1,216 @@
+import { processReleaseVersion } from '../new-release';
+import { NotificationLevel } from '@shell/types/notifications';
+import { READ_NEW_RELEASE } from '@shell/store/prefs';
+import { Context, VersionInfo } from '../types';
+import * as util from '../util'; // Import util to mock removeMatchingNotifications
+import semver from 'semver';
+
+describe('processReleaseVersion', () => {
+  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) => {
+        // Simple mock for i18n/t to return predictable strings
+        const { version, version1, version2 } = params || {};
+
+        if (key === 'dynamicContent.newRelease.title') return `A new Rancher release is available`;
+        if (key === 'dynamicContent.newRelease.message') return `Rancher ${ version } has been released`;
+        if (key === 'dynamicContent.newRelease.moreInfo') return `More Info`;
+        if (key === 'dynamicContent.multipleNewReleases.title') return 'New Rancher releases are available';
+        if (key === 'dynamicContent.multipleNewReleases.message') return `Message for ${ version1 } and ${ version2 }`;
+        if (key === 'dynamicContent.multipleNewReleases.moreInfo') return `More Info for ${ version }`;
+
+        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: 'https://example.com/releases/v$version',
+        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 releaseInfo is null/undefined or empty', async() => {
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+
+    await processReleaseVersion(mockContext, null as any, versionInfo);
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+
+    await processReleaseVersion(mockContext, [], versionInfo);
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+  });
+
+  it('should return early if versionInfo is null/undefined or version is missing', async() => {
+    const releaseInfo = [{ name: '2.12.1' }];
+
+    await processReleaseVersion(mockContext, releaseInfo, null as any);
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+
+    await processReleaseVersion(mockContext, releaseInfo, { version: null as any, isPrime: false });
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalled();
+  });
+
+  it('should not add notification if no newer release exists', async() => {
+    const releaseInfo = [{ name: '2.12.0' }, { name: '2.11.0' }];
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+
+    await processReleaseVersion(mockContext, releaseInfo, versionInfo);
+
+    expect(mockLogger.info).not.toHaveBeenCalledWith(expect.stringContaining('Found a newer release'));
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  it('should add a single new release notification for a newer patch version', async() => {
+    const releaseInfo = [{ name: '2.12.1' }, { name: '2.12.0' }, { name: '2.11.0' }];
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+
+    await processReleaseVersion(mockContext, releaseInfo, versionInfo);
+
+    expect(mockLogger.info).toHaveBeenCalledWith('Found a newer release: 2.12.1');
+    expect(mockLogger.info).not.toHaveBeenCalledWith(expect.stringContaining('Also found a newer patch release')); // Because newer and newerPatch are the same
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', {
+      id:         'new-release-2.12.1',
+      level:      NotificationLevel.Announcement,
+      title:      'A new Rancher release is available',
+      message:    'Rancher 2.12.1 has been released',
+      preference: {
+        key:   READ_NEW_RELEASE,
+        value: '2.12.1',
+      },
+      primaryAction: {
+        label:  'More Info',
+        target: 'https://example.com/releases/v2.12.1',
+      },
+    });
+    expect(mockRemoveMatchingNotifications).toHaveBeenCalledWith(mockContext, 'new-release-', '2.12.1');
+  });
+
+  it('should add a single new release notification for a newer major/minor version (no patch)', async() => {
+    const releaseInfo = [{ name: '2.13.0' }, { name: '2.12.0' }];
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+
+    await processReleaseVersion(mockContext, releaseInfo, versionInfo);
+
+    expect(mockLogger.info).toHaveBeenCalledWith('Found a newer release: 2.13.0');
+    expect(mockLogger.info).not.toHaveBeenCalledWith(expect.stringContaining('Also found a newer patch release'));
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', {
+      id:         'new-release-2.13.0',
+      level:      NotificationLevel.Announcement,
+      title:      'A new Rancher release is available',
+      message:    'Rancher 2.13.0 has been released',
+      preference: {
+        key:   READ_NEW_RELEASE,
+        value: '2.13.0',
+      },
+      primaryAction: {
+        label:  'More Info',
+        target: 'https://example.com/releases/v2.13.0',
+      },
+    });
+    expect(mockRemoveMatchingNotifications).toHaveBeenCalledWith(mockContext, 'new-release-', '2.13.0');
+  });
+
+  it('should add a multiple new releases notification when both newer patch and newer major/minor exist', async() => {
+    const releaseInfo = [{ name: '2.13.0' }, { name: '2.12.1' }, { name: '2.12.0' }];
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+
+    await processReleaseVersion(mockContext, releaseInfo, versionInfo);
+
+    expect(mockLogger.info).toHaveBeenCalledWith('Found a newer release: 2.13.0');
+    expect(mockLogger.info).toHaveBeenCalledWith('Also found a newer patch release: 2.12.1');
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', {
+      id:         'new-release-2.12.1-2.13.0',
+      level:      NotificationLevel.Announcement,
+      title:      'New Rancher releases are available',
+      message:    'Message for 2.12.1 and 2.13.0',
+      preference: {
+        key:   READ_NEW_RELEASE,
+        value: '2.12.1-2.13.0',
+      },
+      primaryAction: {
+        label:  'More Info for 2.12.1',
+        target: 'https://example.com/releases/v2.12.1',
+      },
+      secondaryAction: {
+        label:  'More Info for 2.13.0',
+        target: 'https://example.com/releases/v2.13.0',
+      },
+    });
+    expect(mockRemoveMatchingNotifications).toHaveBeenCalledWith(mockContext, 'new-release-', '2.12.1-2.13.0');
+  });
+
+  it('should not add notification if it was already read (single release)', async() => {
+    mockGetters['prefs/get'].mockReturnValue('2.12.1'); // Simulate already read
+    const releaseInfo = [{ name: '2.12.1' }];
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+
+    await processReleaseVersion(mockContext, releaseInfo, versionInfo);
+
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.debug).not.toHaveBeenCalledWith(expect.stringContaining('Adding new release notification'));
+  });
+
+  it('should not add notification if it was already read (multiple releases)', async() => {
+    mockGetters['prefs/get'].mockReturnValue('2.12.1-2.13.0'); // Simulate already read
+    const releaseInfo = [{ name: '2.13.0' }, { name: '2.12.1' }];
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+
+    await processReleaseVersion(mockContext, releaseInfo, versionInfo);
+
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.info).not.toHaveBeenCalledWith(expect.stringContaining('Adding new multiple release notification'));
+  });
+
+  it('should not add notification if removeMatchingNotifications indicates it exists', async() => {
+    mockRemoveMatchingNotifications.mockResolvedValue(true); // Simulate notification already exists
+    const releaseInfo = [{ name: '2.12.1' }];
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
+
+    await processReleaseVersion(mockContext, releaseInfo, versionInfo);
+
+    expect(mockDispatch).not.toHaveBeenCalled();
+    expect(mockLogger.debug).not.toHaveBeenCalledWith(expect.stringContaining('Adding new release notification'));
+  });
+});