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

package/utils/__tests__/alertmanagerconfig.test.ts

@@ -0,0 +1,117 @@
+import { Buffer } from 'buffer';
+import { areRoutesSupportedFormat, canCreate, createDefaultRouteName } from '@shell/utils/alertmanagerconfig';
+
+function makeSecret(yaml: string | null): { data: Record<string, string> } {
+  if (yaml === null) {
+    return { data: {} };
+  }
+
+  return { data: { 'alertmanager.yaml': Buffer.from(yaml).toString('base64') } };
+}
+
+describe('alertmanagerconfig utils', () => {
+  describe('createDefaultRouteName', () => {
+    it.each([
+      {
+        desc:     'index 0',
+        index:    0,
+        expected: 'route-0',
+      },
+      {
+        desc:     'index 1',
+        index:    1,
+        expected: 'route-1',
+      },
+      {
+        desc:     'index 99',
+        index:    99,
+        expected: 'route-99',
+      },
+    ])('returns $expected for $desc', ({ index, expected }) => {
+      expect(createDefaultRouteName(index)).toStrictEqual(expected);
+    });
+  });
+
+  describe('areRoutesSupportedFormat', () => {
+    it('returns true when secret has no data', () => {
+      const secret = makeSecret(null);
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(true);
+    });
+
+    it('returns true when config has no routes', () => {
+      const secret = makeSecret('receivers: []\nroute: {}');
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(true);
+    });
+
+    it('returns true when all routes are non-empty', () => {
+      const yaml = `
+receivers: []
+route:
+  routes:
+    - receiver: team-a
+      match:
+        severity: critical
+`;
+      const secret = makeSecret(yaml);
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(true);
+    });
+
+    it('returns false when any route is an empty object', () => {
+      const yaml = `
+receivers: []
+route:
+  routes:
+    - {}
+`;
+      const secret = makeSecret(yaml);
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(false);
+    });
+
+    it('returns false when the yaml is invalid', () => {
+      const secret = { data: { 'alertmanager.yaml': Buffer.from(': invalid: yaml: {').toString('base64') } };
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(false);
+    });
+
+    it('returns true when routes array is empty', () => {
+      const yaml = `
+route:
+  routes: []
+`;
+      const secret = makeSecret(yaml);
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(true);
+    });
+
+    it('returns false when one of multiple routes is empty', () => {
+      const yaml = `
+receivers: []
+route:
+  routes:
+    - receiver: team-a
+    - {}
+`;
+      const secret = makeSecret(yaml);
+
+      expect(areRoutesSupportedFormat(secret)).toStrictEqual(false);
+    });
+  });
+
+  describe('canCreate', () => {
+    it('returns true when secret type is creatable', () => {
+      const rootGetters = { 'type-map/optionsFor': () => ({ isCreatable: true }) };
+
+      expect(canCreate(rootGetters)).toStrictEqual(true);
+    });
+
+    it('returns false when secret type is not creatable', () => {
+      const rootGetters = { 'type-map/optionsFor': () => ({ isCreatable: false }) };
+
+      expect(canCreate(rootGetters)).toStrictEqual(false);
+    });
+  });
+});

package/utils/__tests__/async.test.ts

@@ -0,0 +1,87 @@
+import { waitFor, wait } from '@shell/utils/async';
+
+describe('wait', () => {
+  it('resolves after the specified delay', async() => {
+    jest.useFakeTimers();
+
+    const p = wait(1000);
+
+    jest.advanceTimersByTime(1000);
+    await expect(p).resolves.toBeUndefined();
+
+    jest.useRealTimers();
+  });
+
+  it('does not resolve before the delay elapses', async() => {
+    jest.useFakeTimers();
+
+    let resolved = false;
+    const p = wait(500).then(() => {
+      resolved = true;
+    });
+
+    jest.advanceTimersByTime(499);
+    expect(resolved).toBe(false);
+
+    jest.advanceTimersByTime(1);
+    await p;
+    expect(resolved).toBe(true);
+
+    jest.useRealTimers();
+  });
+});
+
+describe('waitFor', () => {
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('resolves immediately when testFn returns true on first call', async() => {
+    jest.useFakeTimers();
+    const testFn = jest.fn().mockReturnValue(true);
+
+    const p = waitFor(testFn, 'ready');
+
+    await expect(p).resolves.toBeDefined();
+    expect(testFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('resolves after testFn eventually returns true', async() => {
+    jest.useFakeTimers();
+    let count = 0;
+    const testFn = jest.fn().mockImplementation(() => {
+      count++;
+
+      return count >= 3;
+    });
+
+    const p = waitFor(testFn, 'ready', 10000, 500);
+
+    // first call returns false (immediate check), then intervals fire
+    jest.advanceTimersByTime(500); // interval 1 → count=2, false
+    jest.advanceTimersByTime(500); // interval 2 → count=3, true
+    await p;
+
+    expect(testFn).toHaveBeenCalledTimes(3);
+  });
+
+  it('rejects with msg when timeout elapses', async() => {
+    jest.useFakeTimers();
+    const testFn = jest.fn().mockReturnValue(false);
+
+    const p = waitFor(testFn, 'some condition', 1000, 500);
+
+    jest.advanceTimersByTime(1001);
+    await expect(p).rejects.toThrow('Failed waiting for: some condition');
+  });
+
+  it('rejects with generic message when no msg provided and timeout elapses', async() => {
+    jest.useFakeTimers();
+    const testFn = jest.fn().mockReturnValue(false);
+
+    const p = waitFor(testFn, '', 2000, 500);
+
+    jest.advanceTimersByTime(2001);
+    await expect(p).rejects.toThrow('waitFor timed out after 2 seconds');
+  });
+});

package/utils/__tests__/aws.test.ts

@@ -0,0 +1,140 @@
+import { isIpv4Network, isIpv6Network, getVpcDisplayName, getSubnetDisplayName } from '@shell/utils/aws';
+
+describe('aws utils', () => {
+  describe('isIpv4Network', () => {
+    it.each([
+      {
+        desc:     'returns true when CidrBlock is set',
+        network:  { CidrBlock: '10.0.0.0/16' },
+        expected: true,
+      },
+      {
+        desc:     'returns false when CidrBlock is absent',
+        network:  {},
+        expected: false,
+      },
+      {
+        desc:     'returns false when CidrBlock is an empty string',
+        network:  { CidrBlock: '' },
+        expected: false,
+      },
+      {
+        desc:     'returns true when CidrBlock is a non-empty string',
+        network:  { CidrBlock: '0.0.0.0/0' },
+        expected: true,
+      },
+    ])('$desc', ({ network, expected }) => {
+      expect(isIpv4Network(network as any)).toStrictEqual(expected);
+    });
+  });
+
+  describe('isIpv6Network', () => {
+    it.each([
+      {
+        desc:     'returns true when Ipv6CidrBlockAssociationSet has entries',
+        network:  { Ipv6CidrBlockAssociationSet: [{ Ipv6CidrBlock: '::/0' }] },
+        expected: true,
+      },
+      {
+        desc:     'returns false when Ipv6CidrBlockAssociationSet is an empty array',
+        network:  { Ipv6CidrBlockAssociationSet: [] },
+        expected: false,
+      },
+      {
+        desc:     'returns false when Ipv6CidrBlockAssociationSet is absent',
+        network:  {},
+        expected: false,
+      },
+      {
+        desc:     'returns false when Ipv6CidrBlockAssociationSet is undefined',
+        network:  { Ipv6CidrBlockAssociationSet: undefined },
+        expected: false,
+      },
+    ])('$desc', ({ network, expected }) => {
+      expect(isIpv6Network(network as any)).toStrictEqual(expected);
+    });
+  });
+
+  describe('getVpcDisplayName', () => {
+    it.each([
+      {
+        desc: 'returns "Name (VpcId)" when Name tag is present',
+        vpc:  {
+          VpcId: 'vpc-abc123',
+          Tags:  [{ Key: 'Name', Value: 'my-vpc' }],
+        },
+        expected: 'my-vpc (vpc-abc123)',
+      },
+      {
+        desc: 'returns VpcId alone when Tags array is empty',
+        vpc:  {
+          VpcId: 'vpc-abc123',
+          Tags:  [],
+        },
+        expected: 'vpc-abc123',
+      },
+      {
+        desc:     'returns VpcId alone when Tags is absent',
+        vpc:      { VpcId: 'vpc-abc123' },
+        expected: 'vpc-abc123',
+      },
+      {
+        desc: 'returns VpcId alone when no tag has Key "Name"',
+        vpc:  {
+          VpcId: 'vpc-abc123',
+          Tags:  [{ Key: 'Env', Value: 'prod' }],
+        },
+        expected: 'vpc-abc123',
+      },
+      {
+        desc: 'uses the first Name tag when multiple tags exist',
+        vpc:  {
+          VpcId: 'vpc-abc123',
+          Tags:  [
+            { Key: 'Env', Value: 'prod' },
+            { Key: 'Name', Value: 'primary-vpc' },
+          ],
+        },
+        expected: 'primary-vpc (vpc-abc123)',
+      },
+    ])('$desc', ({ vpc, expected }) => {
+      expect(getVpcDisplayName(vpc as any)).toStrictEqual(expected);
+    });
+  });
+
+  describe('getSubnetDisplayName', () => {
+    it.each([
+      {
+        desc:   'returns "Name (SubnetId)" when Name tag is present',
+        subnet: {
+          SubnetId: 'subnet-xyz789',
+          Tags:     [{ Key: 'Name', Value: 'my-subnet' }],
+        },
+        expected: 'my-subnet (subnet-xyz789)',
+      },
+      {
+        desc:   'returns SubnetId alone when Tags array is empty',
+        subnet: {
+          SubnetId: 'subnet-xyz789',
+          Tags:     [],
+        },
+        expected: 'subnet-xyz789',
+      },
+      {
+        desc:     'returns SubnetId alone when Tags is absent',
+        subnet:   { SubnetId: 'subnet-xyz789' },
+        expected: 'subnet-xyz789',
+      },
+      {
+        desc:   'returns SubnetId alone when no tag has Key "Name"',
+        subnet: {
+          SubnetId: 'subnet-xyz789',
+          Tags:     [{ Key: 'Zone', Value: 'us-east-1a' }],
+        },
+        expected: 'subnet-xyz789',
+      },
+    ])('$desc', ({ subnet, expected }) => {
+      expect(getSubnetDisplayName(subnet as any)).toStrictEqual(expected);
+    });
+  });
+});

package/utils/__tests__/banners.test.ts

@@ -0,0 +1,176 @@
+import { getIndividualBanners, overlayIndividualBanners } from '@shell/utils/banners';
+
+describe('banners', () => {
+  describe('getIndividualBanners', () => {
+    it('returns an empty object when no settings match', () => {
+      const store = { getters: { 'management/all': () => [] } };
+
+      expect(getIndividualBanners(store)).toStrictEqual({});
+    });
+
+    it('ignores settings without a value', () => {
+      const store = {
+        getters: {
+          'management/all': () => [
+            {
+              id:    'ui-banner-header',
+              value: '',
+            },
+          ],
+        },
+      };
+
+      expect(getIndividualBanners(store)).toStrictEqual({});
+    });
+
+    it('ignores settings not in the known banner id list', () => {
+      const store = {
+        getters: {
+          'management/all': () => [
+            {
+              id:    'ui-some-other-setting',
+              value: 'some-value',
+            },
+          ],
+        },
+      };
+
+      expect(getIndividualBanners(store)).toStrictEqual({});
+    });
+
+    it.each([
+      {
+        desc:        'maps ui-banner-header to bannerHeader',
+        id:          'ui-banner-header',
+        expectedKey: 'bannerHeader',
+      },
+      {
+        desc:        'maps ui-banner-footer to bannerFooter',
+        id:          'ui-banner-footer',
+        expectedKey: 'bannerFooter',
+      },
+      {
+        desc:        'maps ui-banner-login-consent to bannerConsent',
+        id:          'ui-banner-login-consent',
+        expectedKey: 'bannerConsent',
+      },
+    ])('$desc', ({ id, expectedKey }) => {
+      const setting = {
+        id,
+        value: '{"text":"hello"}',
+      };
+      const store = { getters: { 'management/all': () => [setting] } };
+      const result = getIndividualBanners(store);
+
+      expect(Object.keys(result)).toStrictEqual([expectedKey]);
+      expect(result[expectedKey]).toStrictEqual(setting);
+    });
+
+    it('collects multiple matching banner settings', () => {
+      const headerSetting = {
+        id:    'ui-banner-header',
+        value: '{"text":"header"}',
+      };
+      const footerSetting = {
+        id:    'ui-banner-footer',
+        value: '{"text":"footer"}',
+      };
+      const store = { getters: { 'management/all': () => [headerSetting, footerSetting] } };
+      const result = getIndividualBanners(store);
+
+      expect(result['bannerHeader']).toStrictEqual(headerSetting);
+      expect(result['bannerFooter']).toStrictEqual(footerSetting);
+    });
+  });
+
+  describe('overlayIndividualBanners', () => {
+    it('does nothing when banners object is empty', () => {
+      const parsedBanner = { showHeader: 'false' };
+
+      overlayIndividualBanners(parsedBanner, {});
+      expect(parsedBanner).toStrictEqual({ showHeader: 'false' });
+    });
+
+    it('overlays bannerHeader and sets showHeader to true', () => {
+      const parsedBanner: Record<string, unknown> = {};
+      const banners = { bannerHeader: { value: '{"text":"Top banner","color":"#fff"}' } };
+
+      overlayIndividualBanners(parsedBanner, banners);
+
+      expect(parsedBanner['bannerHeader']).toStrictEqual({ text: 'Top banner', color: '#fff' });
+      expect(parsedBanner['showHeader']).toStrictEqual('true');
+    });
+
+    it('overlays bannerFooter and sets showFooter to true', () => {
+      const parsedBanner: Record<string, unknown> = {};
+      const banners = { bannerFooter: { value: '{"text":"Footer"}' } };
+
+      overlayIndividualBanners(parsedBanner, banners);
+
+      expect(parsedBanner['bannerFooter']).toStrictEqual({ text: 'Footer' });
+      expect(parsedBanner['showFooter']).toStrictEqual('true');
+    });
+
+    it('overlays bannerConsent and sets showConsent to true', () => {
+      const parsedBanner: Record<string, unknown> = {};
+      const banners = { bannerConsent: { value: '{"text":"Consent"}' } };
+
+      overlayIndividualBanners(parsedBanner, banners);
+
+      expect(parsedBanner['bannerConsent']).toStrictEqual({ text: 'Consent' });
+      expect(parsedBanner['showConsent']).toStrictEqual('true');
+    });
+
+    it('overlays multiple banners at once', () => {
+      const parsedBanner: Record<string, unknown> = {};
+      const banners = {
+        bannerHeader:  { value: '{"text":"Header"}' },
+        bannerFooter:  { value: '{"text":"Footer"}' },
+        bannerConsent: { value: '{"text":"Consent"}' },
+      };
+
+      overlayIndividualBanners(parsedBanner, banners);
+
+      expect(parsedBanner['bannerHeader']).toStrictEqual({ text: 'Header' });
+      expect(parsedBanner['bannerFooter']).toStrictEqual({ text: 'Footer' });
+      expect(parsedBanner['bannerConsent']).toStrictEqual({ text: 'Consent' });
+      expect(parsedBanner['showHeader']).toStrictEqual('true');
+      expect(parsedBanner['showFooter']).toStrictEqual('true');
+      expect(parsedBanner['showConsent']).toStrictEqual('true');
+    });
+
+    it('silently skips a banner with invalid JSON value', () => {
+      const parsedBanner: Record<string, unknown> = { existing: 'value' };
+      const banners = { bannerHeader: { value: 'not-valid-json{{{' } };
+
+      overlayIndividualBanners(parsedBanner, banners);
+
+      expect(parsedBanner).toStrictEqual({ existing: 'value' });
+    });
+
+    it('skips invalid banner but still processes valid ones', () => {
+      const parsedBanner: Record<string, unknown> = {};
+      const banners = {
+        bannerHeader: { value: 'bad json' },
+        bannerFooter: { value: '{"text":"Footer"}' },
+      };
+
+      overlayIndividualBanners(parsedBanner, banners);
+
+      expect(parsedBanner['bannerHeader']).toBeUndefined();
+      expect(parsedBanner['showHeader']).toBeUndefined();
+      expect(parsedBanner['bannerFooter']).toStrictEqual({ text: 'Footer' });
+      expect(parsedBanner['showFooter']).toStrictEqual('true');
+    });
+
+    it('overwrites existing parsedBanner field when overlaying', () => {
+      const parsedBanner: Record<string, unknown> = { bannerHeader: { text: 'Old' }, showHeader: 'false' };
+      const banners = { bannerHeader: { value: '{"text":"New"}' } };
+
+      overlayIndividualBanners(parsedBanner, banners);
+
+      expect(parsedBanner['bannerHeader']).toStrictEqual({ text: 'New' });
+      expect(parsedBanner['showHeader']).toStrictEqual('true');
+    });
+  });
+});

package/utils/__tests__/chart.test.ts

@@ -1,4 +1,7 @@
-import { compareChartVersions } from '@shell/utils/chart';
+import { compareChartVersions, getStandaloneReadmeUrl } from '@shell/utils/chart';
+import {
+  CHART, REPO, REPO_TYPE, VERSION, DEPRECATED
+} from '@shell/config/query-params';
 
 describe('compareChartVersions', () => {
   describe('standard SemVer Comparison', () => {
@@ -94,3 +97,63 @@ describe('compareChartVersions', () => {
     });
   });
 });
+
+describe('getStandaloneReadmeUrl', () => {
+  it('builds readme route with defaults', () => {
+    const router = { resolve: jest.fn(() => ({ href: '/c/local/readme' })) };
+
+    const href = getStandaloneReadmeUrl(router as any, {
+      cluster:     'local',
+      repoType:    'cluster',
+      repoName:    'rancher-charts',
+      chartName:   'my-chart',
+      versionName: '1.2.3',
+      deprecated:  'false',
+    });
+
+    expect(href).toBe('/c/local/readme');
+    expect(router.resolve).toHaveBeenCalledWith({
+      name:   'readme',
+      params: { cluster: 'local' },
+      query:  {
+        [REPO_TYPE]:          'cluster',
+        [REPO]:               'rancher-charts',
+        [CHART]:              'my-chart',
+        [VERSION]:            '1.2.3',
+        [DEPRECATED]:         'false',
+        showAppReadme:        'true',
+        hideReadmeFirstTitle: 'true'
+      }
+    });
+  });
+
+  it('builds readme route with explicit options', () => {
+    const router = { resolve: jest.fn(() => ({ href: '/c/c-abc/readme' })) };
+
+    const href = getStandaloneReadmeUrl(router as any, {
+      cluster:              'c-abc',
+      repoType:             'cluster',
+      repoName:             'partner-charts',
+      chartName:            'other-chart',
+      versionName:          '9.9.9',
+      deprecated:           'true',
+      showAppReadme:        false,
+      hideReadmeFirstTitle: false,
+    });
+
+    expect(href).toBe('/c/c-abc/readme');
+    expect(router.resolve).toHaveBeenCalledWith({
+      name:   'readme',
+      params: { cluster: 'c-abc' },
+      query:  {
+        [REPO_TYPE]:          'cluster',
+        [REPO]:               'partner-charts',
+        [CHART]:              'other-chart',
+        [VERSION]:            '9.9.9',
+        [DEPRECATED]:         'true',
+        showAppReadme:        'false',
+        hideReadmeFirstTitle: 'false'
+      }
+    });
+  });
+});