@rancher/shell 3.0.12-rc.3 → 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__/computed.test.ts

@@ -0,0 +1,193 @@
+import { integerString, keyValueStrings } from '@shell/utils/computed';
+
+describe('integerString', () => {
+  describe('get', () => {
+    it.each([
+      {
+        desc:     'integer string',
+        initial:  '42',
+        expected: 42,
+      },
+      {
+        desc:     'float string',
+        initial:  '3.14',
+        expected: 3.14,
+      },
+      {
+        desc:     'zero string',
+        initial:  '0',
+        expected: 0,
+      },
+      {
+        desc:     'negative integer string',
+        initial:  '-7',
+        expected: -7,
+      },
+      {
+        desc:     'undefined value',
+        initial:  undefined as unknown as string,
+        expected: NaN,
+      },
+    ])('returns a number for $desc', ({ initial, expected }) => {
+      const computed = integerString('value');
+      const ctx = { value: initial };
+
+      expect(computed.get.call(ctx)).toStrictEqual(expected);
+    });
+
+    it('reads from a nested dot-notation path', () => {
+      const computed = integerString('a.b');
+      const ctx = { a: { b: '99' } };
+
+      expect(computed.get.call(ctx)).toStrictEqual(99);
+    });
+  });
+
+  describe('set', () => {
+    it.each([
+      {
+        desc:     'positive integer',
+        input:    42,
+        expected: '42',
+      },
+      {
+        desc:     'float',
+        input:    3.14,
+        expected: '3.14',
+      },
+      {
+        desc:     'zero',
+        input:    0,
+        expected: '0',
+      },
+      {
+        desc:     'negative integer',
+        input:    -7,
+        expected: '-7',
+      },
+    ])('stores a string representation for $desc', ({ input, expected }) => {
+      const computed = integerString('value');
+      const ctx = { value: '' };
+
+      computed.set.call(ctx, input);
+
+      expect(ctx.value).toStrictEqual(expected);
+    });
+
+    it('writes to a nested dot-notation path', () => {
+      const computed = integerString('a.b');
+      const ctx = { a: { b: '' } };
+
+      computed.set.call(ctx, 5);
+
+      expect((ctx.a as { b: string }).b).toStrictEqual('5');
+    });
+  });
+});
+
+describe('keyValueStrings', () => {
+  describe('get', () => {
+    it('returns an empty object for an empty array', () => {
+      const computed = keyValueStrings('items');
+      const ctx = { items: [] as string[] };
+
+      expect(computed.get.call(ctx)).toStrictEqual({});
+    });
+
+    it('returns an empty object when path value is undefined', () => {
+      const computed = keyValueStrings('items');
+      const ctx = { items: undefined as unknown as string[] };
+
+      expect(computed.get.call(ctx)).toStrictEqual({});
+    });
+
+    it.each([
+      {
+        desc:      'single entry with default delimiter',
+        entries:   ['key=value'],
+        delimiter: '=',
+        expected:  { key: 'value' },
+      },
+      {
+        desc:      'multiple entries with default delimiter',
+        entries:   ['foo=bar', 'baz=qux'],
+        delimiter: '=',
+        expected:  {
+          foo: 'bar',
+          baz: 'qux',
+        },
+      },
+      {
+        desc:      'single entry with custom colon delimiter',
+        entries:   ['key:value'],
+        delimiter: ':',
+        expected:  { key: 'value' },
+      },
+      {
+        desc:      'multiple entries with custom colon delimiter',
+        entries:   ['a:1', 'b:2'],
+        delimiter: ':',
+        expected:  {
+          a: '1',
+          b: '2',
+        },
+      },
+    ])('returns an object for $desc', ({ entries, delimiter, expected }) => {
+      const computed = keyValueStrings('items', delimiter);
+      const ctx = { items: entries };
+
+      expect(computed.get.call(ctx)).toStrictEqual(expected);
+    });
+  });
+
+  describe('set', () => {
+    it('stores an empty array for an empty object', () => {
+      const computed = keyValueStrings('items');
+      const ctx = { items: ['existing=val'] };
+
+      computed.set.call(ctx, {});
+
+      expect(ctx.items).toStrictEqual([]);
+    });
+
+    it.each([
+      {
+        desc:      'single key-value pair with default delimiter',
+        input:     { key: 'value' },
+        delimiter: '=',
+        expected:  ['key=value'],
+      },
+      {
+        desc:  'multiple key-value pairs with default delimiter',
+        input: {
+          foo: 'bar',
+          baz: 'qux',
+        },
+        delimiter: '=',
+        expected:  ['foo=bar', 'baz=qux'],
+      },
+      {
+        desc:      'single pair with custom colon delimiter',
+        input:     { key: 'value' },
+        delimiter: ':',
+        expected:  ['key:value'],
+      },
+      {
+        desc:  'multiple pairs with custom colon delimiter',
+        input: {
+          a: '1',
+          b: '2',
+        },
+        delimiter: ':',
+        expected:  ['a:1', 'b:2'],
+      },
+    ])('stores delimited strings for $desc', ({ input, delimiter, expected }) => {
+      const computed = keyValueStrings('items', delimiter);
+      const ctx = { items: [] as string[] };
+
+      computed.set.call(ctx, input);
+
+      expect(ctx.items).toStrictEqual(expected);
+    });
+  });
+});

package/utils/__tests__/cspAdaptor.test.ts

@@ -0,0 +1,163 @@
+import CspAdapterUtils from '@shell/utils/cspAdaptor';
+import { CATALOG } from '@shell/config/types';
+
+type App = { metadata?: { name?: string } };
+
+function makeStore({
+  canList = true,
+  paginationEnabled = false,
+  findAllResult = [] as App[],
+  findPageData = [] as App[],
+} = {}) {
+  return {
+    getters: {
+      'management/canList':           jest.fn().mockReturnValue(canList),
+      'management/paginationEnabled': jest.fn().mockReturnValue(paginationEnabled),
+    },
+    dispatch: jest.fn((action: string) => {
+      if (action === 'management/findAll') {
+        return Promise.resolve(findAllResult);
+      }
+      if (action === 'management/findPage') {
+        return Promise.resolve({ data: findPageData });
+      }
+
+      return Promise.resolve(null);
+    }),
+  };
+}
+
+describe('cspAdaptor', () => {
+  describe('hasCspAdapter', () => {
+    it.each([
+      {
+        desc:     'returns the matching app for rancher-csp-adapter',
+        apps:     [{ metadata: { name: 'rancher-csp-adapter' } }, { metadata: { name: 'other-app' } }],
+        expected: { metadata: { name: 'rancher-csp-adapter' } },
+      },
+      {
+        desc:     'returns the matching app for rancher-csp-billing-adapter',
+        apps:     [{ metadata: { name: 'rancher-csp-billing-adapter' } }],
+        expected: { metadata: { name: 'rancher-csp-billing-adapter' } },
+      },
+      {
+        desc:     'returns first match when multiple csp apps are present',
+        apps:     [{ metadata: { name: 'rancher-csp-billing-adapter' } }, { metadata: { name: 'rancher-csp-adapter' } }],
+        expected: { metadata: { name: 'rancher-csp-billing-adapter' } },
+      },
+      {
+        desc:     'returns undefined when no app name matches',
+        apps:     [{ metadata: { name: 'unrelated-app' } }],
+        expected: undefined,
+      },
+      {
+        desc:     'returns undefined for apps without metadata',
+        apps:     [{}],
+        expected: undefined,
+      },
+      {
+        desc:     'returns undefined when apps is an empty array',
+        apps:     [],
+        expected: undefined,
+      },
+      {
+        desc:     'returns undefined when apps is null',
+        apps:     null as unknown as App[],
+        expected: undefined,
+      },
+      {
+        desc:     'returns undefined when apps is undefined',
+        apps:     undefined as unknown as App[],
+        expected: undefined,
+      },
+    ])('$desc', ({ apps, expected }) => {
+      const result = CspAdapterUtils.hasCspAdapter({ $store: {} as any, apps });
+
+      expect(result).toStrictEqual(expected);
+    });
+  });
+
+  describe('fetchCspAdaptorApp', () => {
+    beforeEach(() => {
+      CspAdapterUtils.resetState();
+    });
+
+    it('returns empty array when canList returns false', async() => {
+      const store = makeStore({ canList: false });
+      const result = await CspAdapterUtils.fetchCspAdaptorApp(store as any);
+
+      expect(result).toStrictEqual([]);
+      expect(store.dispatch).not.toHaveBeenCalled();
+    });
+
+    it('uses findAll when canList is true and pagination is disabled', async() => {
+      const findAllResult: App[] = [{ metadata: { name: 'rancher-csp-adapter' } }];
+      const store = makeStore({
+        canList: true, paginationEnabled: false, findAllResult
+      });
+
+      const result = await CspAdapterUtils.fetchCspAdaptorApp(store as any);
+
+      expect(result).toStrictEqual(findAllResult);
+      expect(store.dispatch).toHaveBeenCalledWith('management/findAll', { type: CATALOG.APP });
+    });
+
+    it('uses findPage when canList is true and pagination is enabled', async() => {
+      const findPageData: App[] = [{ metadata: { name: 'rancher-csp-billing-adapter' } }];
+      const store = makeStore({
+        canList: true, paginationEnabled: true, findPageData
+      });
+
+      const result = await CspAdapterUtils.fetchCspAdaptorApp(store as any);
+
+      expect(result).toStrictEqual(findPageData);
+      expect(store.dispatch).toHaveBeenCalledWith('management/findPage', expect.objectContaining({ type: CATALOG.APP }));
+    });
+
+    it('caches the result and does not dispatch again on a second call', async() => {
+      const findAllResult: App[] = [{ metadata: { name: 'rancher-csp-adapter' } }];
+      const store = makeStore({
+        canList: true, paginationEnabled: false, findAllResult
+      });
+
+      await CspAdapterUtils.fetchCspAdaptorApp(store as any);
+      const result = await CspAdapterUtils.fetchCspAdaptorApp(store as any);
+
+      expect(result).toStrictEqual(findAllResult);
+      expect(store.dispatch).toHaveBeenCalledTimes(1);
+    });
+
+    it('fetches fresh data after resetState clears the cache', async() => {
+      const findAllResult: App[] = [{ metadata: { name: 'rancher-csp-adapter' } }];
+      const store = makeStore({
+        canList: true, paginationEnabled: false, findAllResult
+      });
+
+      await CspAdapterUtils.fetchCspAdaptorApp(store as any);
+
+      CspAdapterUtils.resetState();
+
+      const freshStore = makeStore({
+        canList: true, paginationEnabled: false, findAllResult: []
+      });
+      const result = await CspAdapterUtils.fetchCspAdaptorApp(freshStore as any);
+
+      expect(result).toStrictEqual([]);
+      expect(freshStore.dispatch).toHaveBeenCalledTimes(1);
+    });
+
+    it('passes pagination filters for known csp adapter app names when using findPage', async() => {
+      const store = makeStore({
+        canList: true, paginationEnabled: true, findPageData: []
+      });
+
+      await CspAdapterUtils.fetchCspAdaptorApp(store as any);
+
+      const [, args] = store.dispatch.mock.calls[0];
+
+      expect(args.type).toStrictEqual(CATALOG.APP);
+      expect(args.opt.watch).toStrictEqual(false);
+      expect(args.opt.transient).toStrictEqual(true);
+    });
+  });
+});

package/utils/__tests__/dom.test.ts

@@ -0,0 +1,81 @@
+import { getParent } from '@shell/utils/dom';
+
+describe('getParent', () => {
+  it('returns null when element has no parent', () => {
+    const el = document.createElement('div');
+
+    expect(getParent(el, 'div')).toBeNull();
+  });
+
+  it('returns null when el is null', () => {
+    expect(getParent(null, 'div')).toBeNull();
+  });
+
+  it('returns null when el is undefined', () => {
+    expect(getParent(undefined, 'div')).toBeNull();
+  });
+
+  it('returns the direct parent matching the selector', () => {
+    const parent = document.createElement('section');
+    const child = document.createElement('div');
+
+    parent.appendChild(child);
+
+    expect(getParent(child, 'section')).toBe(parent);
+  });
+
+  it('returns an ancestor matching the selector when direct parent does not match', () => {
+    const grandparent = document.createElement('article');
+    const parent = document.createElement('div');
+    const child = document.createElement('span');
+
+    grandparent.appendChild(parent);
+    parent.appendChild(child);
+
+    expect(getParent(child, 'article')).toBe(grandparent);
+  });
+
+  it('returns null when no ancestor matches the selector', () => {
+    const parent = document.createElement('div');
+    const child = document.createElement('span');
+
+    parent.appendChild(child);
+
+    expect(getParent(child, 'article')).toBeNull();
+  });
+
+  it('matches by class selector', () => {
+    const parent = document.createElement('div');
+
+    parent.className = 'my-container';
+    const child = document.createElement('span');
+
+    parent.appendChild(child);
+
+    expect(getParent(child, '.my-container')).toBe(parent);
+  });
+
+  it('matches by id selector', () => {
+    const parent = document.createElement('div');
+
+    parent.id = 'root';
+    const child = document.createElement('span');
+
+    parent.appendChild(child);
+
+    expect(getParent(child, '#root')).toBe(parent);
+  });
+
+  it('skips intermediate non-matching ancestors and finds the correct one', () => {
+    const great = document.createElement('nav');
+    const grandparent = document.createElement('section');
+    const parent = document.createElement('div');
+    const child = document.createElement('span');
+
+    great.appendChild(grandparent);
+    grandparent.appendChild(parent);
+    parent.appendChild(child);
+
+    expect(getParent(child, 'nav')).toBe(great);
+  });
+});