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

package/utils/__tests__/auth.test.ts

@@ -0,0 +1,273 @@
+import {
+  checkPermissions,
+  parseAuthProvidersInfo,
+  returnTo,
+} from '@shell/utils/auth';
+
+describe('parseAuthProvidersInfo', () => {
+  it.each([
+    {
+      desc:     'empty rows',
+      rows:     [],
+      expected: {
+        nonLocal:        [],
+        enabled:         [],
+        enabledLocation: null,
+      },
+    },
+    {
+      desc: 'only local provider',
+      rows: [{
+        name: 'local', id: 'local', enabled: true
+      }],
+      expected: {
+        nonLocal:        [],
+        enabled:         [],
+        enabledLocation: null,
+      },
+    },
+    {
+      desc: 'one disabled non-local provider',
+      rows: [{
+        name: 'github', id: 'github', enabled: false
+      }],
+      expected: {
+        nonLocal: [{
+          name: 'github', id: 'github', enabled: false
+        }],
+        enabled:         [],
+        enabledLocation: null,
+      },
+    },
+    {
+      desc: 'one enabled non-local provider',
+      rows: [{
+        name: 'github', id: 'github', enabled: true
+      }],
+      expected: {
+        nonLocal: [{
+          name: 'github', id: 'github', enabled: true
+        }],
+        enabled: [{
+          name: 'github', id: 'github', enabled: true
+        }],
+        enabledLocation: {
+          name:   'c-cluster-auth-config-id',
+          params: { id: 'github' },
+          query:  { mode: 'edit' },
+        },
+      },
+    },
+    {
+      desc: 'oidc provider excluded from nonLocal but included in enabled',
+      rows: [{
+        name: 'oidc', id: 'oidc', enabled: true
+      }],
+      expected: {
+        nonLocal: [],
+        enabled:  [{
+          name: 'oidc', id: 'oidc', enabled: true
+        }],
+        enabledLocation: {
+          name:   'c-cluster-auth-config-id',
+          params: { id: 'oidc' },
+          query:  { mode: 'edit' },
+        },
+      },
+    },
+    {
+      desc: 'two enabled non-local providers gives null enabledLocation',
+      rows: [
+        {
+          name: 'github', id: 'github', enabled: true
+        },
+        {
+          name: 'activedirectory', id: 'activedirectory', enabled: true
+        },
+      ],
+      expected: {
+        nonLocal: [
+          {
+            name: 'github', id: 'github', enabled: true
+          },
+          {
+            name: 'activedirectory', id: 'activedirectory', enabled: true
+          },
+        ],
+        enabled: [
+          {
+            name: 'github', id: 'github', enabled: true
+          },
+          {
+            name: 'activedirectory', id: 'activedirectory', enabled: true
+          },
+        ],
+        enabledLocation: null,
+      },
+    },
+    {
+      desc: 'local provider excluded while non-local disabled provider is retained',
+      rows: [
+        {
+          name: 'local', id: 'local', enabled: true
+        },
+        {
+          name: 'github', id: 'github', enabled: false
+        },
+      ],
+      expected: {
+        nonLocal: [{
+          name: 'github', id: 'github', enabled: false
+        }],
+        enabled:         [],
+        enabledLocation: null,
+      },
+    },
+  ])('returns provider info for $desc', ({ rows, expected }) => {
+    expect(parseAuthProvidersInfo(rows)).toStrictEqual(expected);
+  });
+});
+
+describe('checkPermissions', () => {
+  it('returns empty object for empty types', async() => {
+    const getters = { 'management/schemaFor': jest.fn() };
+    const result = await checkPermissions({}, getters);
+
+    expect(result).toStrictEqual({});
+  });
+
+  it('returns false when schema is not found', async() => {
+    const getters = { 'management/schemaFor': jest.fn().mockReturnValue(null) };
+    const result = await checkPermissions({ pods: { type: 'pod' } }, getters);
+
+    expect(result).toStrictEqual({ pods: false });
+    expect(getters['management/schemaFor']).toHaveBeenCalledWith('pod');
+  });
+
+  it('returns true when schema exists with no method constraints', async() => {
+    const mockSchema = { resourceMethods: ['GET', 'PUT'] };
+    const getters = { 'management/schemaFor': jest.fn().mockReturnValue(mockSchema) };
+    const result = await checkPermissions({ pods: { type: 'pod' } }, getters);
+
+    expect(result).toStrictEqual({ pods: true });
+  });
+
+  it('uses schemaValidator result when provided', async() => {
+    const mockSchema = { resourceMethods: ['GET'] };
+    const schemaValidator = jest.fn().mockReturnValue(false);
+    const getters = { 'management/schemaFor': jest.fn().mockReturnValue(mockSchema) };
+    const result = await checkPermissions({ pods: { type: 'pod', schemaValidator } }, getters);
+
+    expect(result).toStrictEqual({ pods: false });
+    expect(schemaValidator).toHaveBeenCalledWith(mockSchema);
+  });
+
+  it('returns true when all resourceMethods are available', async() => {
+    const mockSchema = { resourceMethods: ['GET', 'PUT', 'DELETE'] };
+    const getters = { 'management/schemaFor': jest.fn().mockReturnValue(mockSchema) };
+    const types = { pods: { type: 'pod', resourceMethods: ['GET', 'PUT'] } };
+    const result = await checkPermissions(types, getters);
+
+    expect(result).toStrictEqual({ pods: true });
+  });
+
+  it('returns false when a resourceMethod is not in schema', async() => {
+    const mockSchema = { resourceMethods: ['GET'] };
+    const getters = { 'management/schemaFor': jest.fn().mockReturnValue(mockSchema) };
+    const types = { pods: { type: 'pod', resourceMethods: ['GET', 'DELETE'] } };
+    const result = await checkPermissions(types, getters);
+
+    expect(result).toStrictEqual({ pods: false });
+  });
+
+  it('returns false when schema has no resourceMethods and type requires them', async() => {
+    const mockSchema = {};
+    const getters = { 'management/schemaFor': jest.fn().mockReturnValue(mockSchema) };
+    const types = { pods: { type: 'pod', resourceMethods: ['GET'] } };
+    const result = await checkPermissions(types, getters);
+
+    expect(result).toStrictEqual({ pods: false });
+  });
+
+  it('returns true when all collectionMethods are available', async() => {
+    const mockSchema = { collectionMethods: ['GET', 'POST'] };
+    const getters = { 'management/schemaFor': jest.fn().mockReturnValue(mockSchema) };
+    const types = { pods: { type: 'pod', collectionMethods: ['GET'] } };
+    const result = await checkPermissions(types, getters);
+
+    expect(result).toStrictEqual({ pods: true });
+  });
+
+  it('returns false when a collectionMethod is not in schema', async() => {
+    const mockSchema = { collectionMethods: ['GET'] };
+    const getters = { 'management/schemaFor': jest.fn().mockReturnValue(mockSchema) };
+    const types = { pods: { type: 'pod', collectionMethods: ['GET', 'DELETE'] } };
+    const result = await checkPermissions(types, getters);
+
+    expect(result).toStrictEqual({ pods: false });
+  });
+
+  it('handles multiple types independently', async() => {
+    const getters = {
+      'management/schemaFor': jest.fn()
+        .mockReturnValueOnce({ resourceMethods: ['GET'] })
+        .mockReturnValueOnce(null),
+    };
+    const types = {
+      pods:  { type: 'pod' },
+      nodes: { type: 'node' },
+    };
+    const result = await checkPermissions(types, getters);
+
+    expect(result).toStrictEqual({ pods: true, nodes: false });
+  });
+});
+
+describe('returnTo', () => {
+  it.each([
+    {
+      desc:     'default route when no route in opt',
+      opt:      {},
+      vm:       { $router: {} },
+      expected: 'http://localhost/auth/verify',
+    },
+    {
+      desc:     'custom route from opt',
+      opt:      { route: '/my/page' },
+      vm:       { $router: {} },
+      expected: 'http://localhost/my/page',
+    },
+    {
+      desc:     'router base prepended to route',
+      opt:      {},
+      vm:       { $router: { options: { base: '/ui' } } },
+      expected: 'http://localhost/ui/auth/verify',
+    },
+    {
+      desc:     'router base of "/" does not alter route',
+      opt:      {},
+      vm:       { $router: { options: { base: '/' } } },
+      expected: 'http://localhost/auth/verify',
+    },
+    {
+      desc:     'backTo option adds back-to query param',
+      opt:      { backTo: 'dashboard' },
+      vm:       { $router: {} },
+      expected: 'http://localhost/auth/verify?back-to=dashboard',
+    },
+    {
+      desc:     'config option adds config query param',
+      opt:      { config: 'github' },
+      vm:       { $router: {} },
+      expected: 'http://localhost/auth/verify?config=github',
+    },
+    {
+      desc:     'isSlo option adds is-slo and logged-out params',
+      opt:      { isSlo: true },
+      vm:       { $router: {} },
+      expected: 'http://localhost/auth/verify?is-slo&logged-out',
+    },
+  ])('builds return URL for $desc', ({ opt, vm, expected }) => {
+    expect(returnTo(opt, vm)).toStrictEqual(expected);
+  });
+});

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'
+      }
+    });
+  });
+});