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

package/store/__tests__/type-map.utils.test.ts

@@ -0,0 +1,433 @@
+import {
+  conditionalDepaginate,
+  configureConditionalDepaginate,
+  headerFromSchemaCol,
+  rowValueGetter,
+} from '../type-map.utils';
+
+const makeGetters = (overrides: any = {}) => ({
+  'i18n/exists': jest.fn(() => false),
+  'i18n/t':      jest.fn((key: string) => key),
+  currentStore:  jest.fn(() => 'cluster'),
+  'cluster/all': jest.fn(() => []),
+  ...overrides,
+});
+
+const makeCol = (overrides: any = {}) => ({
+  description: '',
+  field:       '$.metadata.name',
+  format:      '',
+  name:        'Name',
+  priority:    0,
+  type:        'string',
+  ...overrides,
+});
+
+const makeAgeColumn = () => ({
+  name:  'age',
+  label: 'Age',
+  value: 'metadata.creationTimestamp',
+  sort:  ['metadata.creationTimestamp'],
+});
+
+describe('rowValueGetter', () => {
+  describe('fields matching $.metadata.fields[N] pattern', () => {
+    it.each([
+      {
+        desc:          'returns function accessing index 0',
+        field:         '$.metadata.fields[0]',
+        asFn:          true as const,
+        expectedValue: { metadata: { fields: ['first', 'second'] } },
+        expectedIdx:   0,
+      },
+      {
+        desc:          'returns function accessing index 2',
+        field:         '$.metadata.fields[2]',
+        asFn:          true as const,
+        expectedValue: { metadata: { fields: ['a', 'b', 'c'] } },
+        expectedIdx:   2,
+      },
+    ])('$desc', ({
+      field, asFn, expectedValue, expectedIdx,
+    }) => {
+      const getter = rowValueGetter(makeCol({ field }), asFn) as (row: any) => any;
+
+      expect(typeof getter).toStrictEqual('function');
+      expect(getter(expectedValue)).toStrictEqual(expectedValue.metadata.fields[expectedIdx]);
+    });
+
+    it.each([
+      {
+        desc:     'returns string path for index 0',
+        field:    '$.metadata.fields[0]',
+        asFn:     false as const,
+        expected: 'metadata.fields.0',
+      },
+      {
+        desc:     'returns string path for index 3',
+        field:    '$.metadata.fields[3]',
+        asFn:     false as const,
+        expected: 'metadata.fields.3',
+      },
+    ])('$desc', ({ field, asFn, expected }) => {
+      expect(rowValueGetter(makeCol({ field }), asFn)).toStrictEqual(expected);
+    });
+
+    it('returns undefined when row has no fields array', () => {
+      const getter = rowValueGetter(makeCol({ field: '$.metadata.fields[0]' }), true) as (row: any) => any;
+
+      expect(getter({})).toBeUndefined();
+    });
+
+    it('returns undefined when metadata is missing', () => {
+      const getter = rowValueGetter(makeCol({ field: '$.metadata.fields[1]' }), true) as (row: any) => any;
+
+      expect(getter({ other: 'data' })).toBeUndefined();
+    });
+  });
+
+  describe('fields starting with . (dot-prefixed)', () => {
+    it('prepends $ to dot-prefixed fields', () => {
+      const result = rowValueGetter(makeCol({ field: '.metadata.name' }), false);
+
+      expect(result).toStrictEqual('$.metadata.name');
+    });
+
+    it('does not modify fields already starting with $', () => {
+      const result = rowValueGetter(makeCol({ field: '$.metadata.name' }), false);
+
+      expect(result).toStrictEqual('$.metadata.name');
+    });
+  });
+
+  describe('fields with escaped dots (rewriteJsonPath)', () => {
+    it.each([
+      {
+        desc:     'rewrites single escaped dot in label key',
+        field:    '$.metadata.labels.topology\\.kubernetes\\.io/zone',
+        expected: '$.metadata.labels.["topology.kubernetes.io/zone"]',
+      },
+      {
+        desc:     'rewrites escaped dot in annotation key',
+        field:    '$.metadata.annotations.cattle\\.io/hash',
+        expected: '$.metadata.annotations.["cattle.io/hash"]',
+      },
+    ])('$desc', ({ field, expected }) => {
+      expect(rowValueGetter(makeCol({ field }), false)).toStrictEqual(expected);
+    });
+
+    it('returns path unchanged when no escaped dots present', () => {
+      const field = '$.metadata.labels.app';
+
+      expect(rowValueGetter(makeCol({ field }), false)).toStrictEqual(field);
+    });
+  });
+});
+
+describe('conditionalDepaginate', () => {
+  it.each([
+    {
+      desc:       'returns true when depaginate is boolean true',
+      depaginate: true,
+      args:       undefined,
+      expected:   true,
+    },
+    {
+      desc:       'returns false when depaginate is boolean false',
+      depaginate: false,
+      args:       undefined,
+      expected:   false,
+    },
+    {
+      desc:       'returns undefined when depaginate is undefined',
+      depaginate: undefined,
+      args:       undefined,
+      expected:   undefined,
+    },
+  ])('$desc', ({ depaginate, args, expected }) => {
+    expect(conditionalDepaginate(depaginate as any, args)).toStrictEqual(expected);
+  });
+
+  it('calls function with args and returns its result when args are provided', () => {
+    const fn = jest.fn(() => true);
+    const args = { ctx: { rootGetters: {} as any }, args: { type: 'pod', opt: {} } };
+
+    const result = conditionalDepaginate(fn, args);
+
+    expect(fn).toHaveBeenCalledWith(args);
+    expect(result).toStrictEqual(true);
+  });
+
+  it('returns false when depaginate is a function but no args are provided', () => {
+    const fn = jest.fn(() => true);
+
+    expect(conditionalDepaginate(fn, undefined)).toStrictEqual(false);
+    expect(fn).not.toHaveBeenCalled();
+  });
+});
+
+describe('configureConditionalDepaginate', () => {
+  const makeRootGetters = (resourceCount: number | undefined, type: string, store = 'cluster') => {
+    const counts: any = {};
+
+    if (resourceCount !== undefined) {
+      counts[type] = { summary: { count: resourceCount } };
+    }
+
+    return {
+      currentStore:       jest.fn(() => store),
+      [`${ store }/all`]: jest.fn(() => [{ counts }]),
+    };
+  };
+
+  it('returns true when resource count is below maxResourceCount', () => {
+    const type = 'pod';
+    const rootGetters = makeRootGetters(50, type) as any;
+    const fn = configureConditionalDepaginate({ maxResourceCount: 100, isNorman: false });
+    const result = fn({
+      ctx:  { rootGetters },
+      args: { type, opt: {} },
+    });
+
+    expect(result).toStrictEqual(true);
+  });
+
+  it('returns false when resource count equals maxResourceCount', () => {
+    const type = 'pod';
+    const rootGetters = makeRootGetters(100, type) as any;
+    const fn = configureConditionalDepaginate({ maxResourceCount: 100, isNorman: false });
+    const result = fn({
+      ctx:  { rootGetters },
+      args: { type, opt: {} },
+    });
+
+    expect(result).toStrictEqual(false);
+  });
+
+  it('returns false when resource count exceeds maxResourceCount', () => {
+    const type = 'pod';
+    const rootGetters = makeRootGetters(200, type) as any;
+    const fn = configureConditionalDepaginate({ maxResourceCount: 100, isNorman: false });
+    const result = fn({
+      ctx:  { rootGetters },
+      args: { type, opt: {} },
+    });
+
+    expect(result).toStrictEqual(false);
+  });
+
+  it('returns false when resource count is undefined', () => {
+    const type = 'pod';
+    const rootGetters = makeRootGetters(undefined, type) as any;
+    const fn = configureConditionalDepaginate({ maxResourceCount: 100, isNorman: false });
+    const result = fn({
+      ctx:  { rootGetters },
+      args: { type, opt: {} },
+    });
+
+    expect(result).toStrictEqual(false);
+  });
+
+  it('uses management.cattle.io. prefix for Norman types', () => {
+    const type = 'node';
+    const normanType = `management.cattle.io.${ type }`;
+    const rootGetters = makeRootGetters(5, normanType) as any;
+    const fn = configureConditionalDepaginate({ maxResourceCount: 100, isNorman: true });
+    const result = fn({
+      ctx:  { rootGetters },
+      args: { type, opt: {} },
+    });
+
+    expect(result).toStrictEqual(true);
+  });
+});
+
+describe('headerFromSchemaCol', () => {
+  describe('age column shortcut', () => {
+    it.each([
+      {
+        desc: 'returns ageColumn when format is empty and name is age',
+        col:  makeCol({
+          name:   'age',
+          format: '',
+        }),
+      },
+      {
+        desc: 'returns ageColumn when format is date and name is age',
+        col:  makeCol({
+          name:   'age',
+          format: 'date',
+        }),
+      },
+      {
+        desc: 'returns ageColumn when type is date and name is age',
+        col:  makeCol({
+          name:   'age',
+          type:   'date',
+          format: '',
+        }),
+      },
+      {
+        desc: 'returns ageColumn when name is Age (case insensitive)',
+        col:  makeCol({
+          name:   'Age',
+          format: '',
+        }),
+      },
+    ])('$desc', ({ col }) => {
+      const ageColumn = makeAgeColumn() as any;
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, ageColumn);
+
+      expect(result).toStrictEqual(ageColumn);
+    });
+
+    it('does not return ageColumn when ageColumn is not provided', () => {
+      const col = makeCol({ name: 'age', format: '' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result).not.toStrictEqual(null);
+      expect(result.name).toStrictEqual('age');
+    });
+  });
+
+  describe('formatter assignment', () => {
+    it('sets formatter to Date and width 120 for date format', () => {
+      const col = makeCol({
+        name:   'created',
+        format: 'date',
+      });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.formatter).toStrictEqual('Date');
+      expect(result.width).toStrictEqual(120);
+      expect(result.formatterOpts).toStrictEqual({ multiline: true });
+    });
+
+    it('sets formatter to Date and width 120 when type is date', () => {
+      const col = makeCol({
+        name:   'modified',
+        format: '',
+        type:   'date',
+      });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.formatter).toStrictEqual('Date');
+      expect(result.width).toStrictEqual(120);
+    });
+
+    it('sets formatter to Number when type is number', () => {
+      const col = makeCol({
+        name: 'count',
+        type: 'number',
+      });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.formatter).toStrictEqual('Number');
+    });
+
+    it('sets formatter to Number when type is int', () => {
+      const col = makeCol({
+        name: 'replicas',
+        type: 'int',
+      });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.formatter).toStrictEqual('Number');
+    });
+
+    it('does not set formatter for plain text column', () => {
+      const col = makeCol({ name: 'status', type: 'string' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.formatter).toBeUndefined();
+    });
+  });
+
+  describe('label resolution', () => {
+    it('uses i18n translation when key exists', () => {
+      const getters = makeGetters({
+        'i18n/exists': jest.fn(() => true),
+        'i18n/t':      jest.fn((key: string) => `translated:${ key }`),
+      });
+      const col = makeCol({ name: 'status' });
+      const result = headerFromSchemaCol(col as any, getters as any, false, null as any);
+
+      expect(result.label).toStrictEqual('translated:tableHeaders.status');
+    });
+
+    it('uses column name when i18n key does not exist', () => {
+      const getters = makeGetters({ 'i18n/exists': jest.fn(() => false) });
+      const col = makeCol({ name: 'MyColumn' });
+      const result = headerFromSchemaCol(col as any, getters as any, false, null as any);
+
+      expect(result.label).toStrictEqual('MyColumn');
+    });
+
+    it('camelCases the i18n key when col name has spaces', () => {
+      const getters = makeGetters({
+        'i18n/exists': jest.fn((key: string) => key === 'tableHeaders.myLabel'),
+        'i18n/t':      jest.fn((key: string) => `t:${ key }`),
+      });
+      const col = makeCol({ name: 'my label' });
+      const result = headerFromSchemaCol(col as any, getters as any, false, null as any);
+
+      expect(result.label).toStrictEqual('t:tableHeaders.myLabel');
+    });
+  });
+
+  describe('tooltip from description', () => {
+    it('uses description as tooltip when not ending with dot', () => {
+      const col = makeCol({ name: 'status', description: 'Current status' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.tooltip).toStrictEqual('Current status');
+    });
+
+    it('strips trailing dot from description for tooltip', () => {
+      const col = makeCol({ name: 'status', description: 'Current status.' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.tooltip).toStrictEqual('Current status');
+    });
+
+    it('uses empty string as tooltip when description is empty', () => {
+      const col = makeCol({ name: 'status', description: '' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.tooltip).toStrictEqual('');
+    });
+  });
+
+  describe('pagination mode', () => {
+    it('uses string path as value when pagination is true', () => {
+      const col = makeCol({ name: 'status', field: '$.metadata.name' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, true, null as any);
+
+      expect(typeof result.value).toStrictEqual('string');
+    });
+
+    it('uses function as value when pagination is false', () => {
+      const col = makeCol({ name: 'status', field: '$.metadata.fields[0]' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(typeof result.value).toStrictEqual('function');
+    });
+  });
+
+  describe('output shape', () => {
+    it('sets name to lowercase version of col.name', () => {
+      const col = makeCol({ name: 'Status' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.name).toStrictEqual('status');
+    });
+
+    it('sets sort and search from string path', () => {
+      const col = makeCol({ name: 'name', field: '$.metadata.name' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, true, null as any);
+
+      expect(result.sort).toStrictEqual(['$.metadata.name']);
+      expect(result.search).toStrictEqual('$.metadata.name');
+    });
+  });
+});

package/store/__tests__/ui-context.test.ts

@@ -0,0 +1,255 @@
+import { state, getters, mutations, actions } from '../ui-context';
+
+describe('ui-context store', () => {
+  describe('state', () => {
+    it('returns initial state with empty elements and zero idCounter', () => {
+      expect(state()).toStrictEqual({ idCounter: 0, elements: {} });
+    });
+
+    it('returns a fresh object on each call', () => {
+      const s1 = state();
+      const s2 = state();
+
+      expect(s1).not.toBe(s2);
+    });
+  });
+
+  describe('getters', () => {
+    describe('all', () => {
+      it('returns empty array when no elements exist', () => {
+        expect(getters.all(state())).toStrictEqual([]);
+      });
+
+      it('returns contexts sorted alphabetically by tag', () => {
+        const s = state();
+
+        s.elements = {
+          1: { id: 1, context: { tag: 'z-tag', value: 'a' } },
+          2: { id: 2, context: { tag: 'a-tag', value: 'b' } },
+          3: { id: 3, context: { tag: 'm-tag', value: 'c' } },
+        } as any;
+
+        const result = getters.all(s);
+
+        expect(result.map((c: any) => c.tag)).toStrictEqual(['a-tag', 'm-tag', 'z-tag']);
+      });
+
+      it('sorts contexts without tag before tagged contexts', () => {
+        const s = state();
+
+        s.elements = {
+          1: { id: 1, context: { tag: 'b-tag', value: 'a' } },
+          2: { id: 2, context: { value: 'b' } },
+        } as any;
+
+        const result = getters.all(s);
+
+        expect(result[0]).toStrictEqual({ value: 'b' });
+        expect(result[1].tag).toBe('b-tag');
+      });
+
+      it('returns context objects, not full element wrappers', () => {
+        const context = { tag: 'my-tag', value: 'test-val' };
+        const s = state();
+
+        s.elements = { 1: { id: 1, context } } as any;
+
+        expect(getters.all(s)).toStrictEqual([context]);
+      });
+    });
+  });
+
+  describe('mutations', () => {
+    describe('add', () => {
+      it('adds element to state', () => {
+        const s = state();
+        const element = { id: 1, context: { tag: 'test', value: 'val' } };
+
+        mutations.add(s, element);
+
+        expect(s.elements[1]).toStrictEqual(element);
+      });
+
+      it('adds multiple elements without overwriting', () => {
+        const s = state();
+        const e1 = { id: 1, context: { tag: 'a', value: 1 } };
+        const e2 = { id: 2, context: { tag: 'b', value: 2 } };
+
+        mutations.add(s, e1);
+        mutations.add(s, e2);
+
+        expect(Object.keys(s.elements)).toStrictEqual(['1', '2']);
+      });
+    });
+
+    describe('update', () => {
+      it('updates context of existing element', () => {
+        const s = state();
+
+        s.elements[1] = { id: 1, context: { tag: 'test', value: 'original' } };
+        mutations.update(s, { id: 1, context: { tag: 'test', value: 'updated' } });
+
+        expect(s.elements[1].context).toStrictEqual({ tag: 'test', value: 'updated' });
+      });
+
+      it('does nothing when element id is not found', () => {
+        const s = state();
+        const element = { id: 1, context: { tag: 'test', value: 'val' } };
+
+        s.elements[1] = element;
+        mutations.update(s, { id: 999, context: { tag: 'other', value: 'new' } });
+
+        expect(s.elements[1]).toStrictEqual(element);
+      });
+    });
+
+    describe('remove', () => {
+      it('removes element from state by id', () => {
+        const s = state();
+        const element = { id: 1, context: { tag: 'test', value: 'val' } };
+
+        s.elements[1] = element;
+        mutations.remove(s, element);
+
+        expect(s.elements[1]).toBeUndefined();
+      });
+
+      it('leaves other elements intact when removing one', () => {
+        const s = state();
+        const e1 = { id: 1, context: { tag: 'a', value: 1 } };
+        const e2 = { id: 2, context: { tag: 'b', value: 2 } };
+
+        s.elements[1] = e1;
+        s.elements[2] = e2;
+        mutations.remove(s, e1);
+
+        expect(s.elements[2]).toStrictEqual(e2);
+      });
+    });
+  });
+
+  describe('actions', () => {
+    const makeStore = () => {
+      const s = state() as any;
+      const commit = jest.fn((mutation: string, payload: any) => {
+        (mutations as any)[mutation](s, payload);
+      });
+
+      return { s, commit };
+    };
+
+    describe('add', () => {
+      it.each([
+        {
+          desc: 'undefined context',
+          ctx:  undefined as any,
+        },
+        {
+          desc: 'null context',
+          ctx:  null as any,
+        },
+        {
+          desc: 'missing tag property',
+          ctx:  { value: 'something' } as any,
+        },
+        {
+          desc: 'empty string tag',
+          ctx:  { value: 'something', tag: '' } as any,
+        },
+        {
+          desc: 'missing value property',
+          ctx:  { tag: 'test' } as any,
+        },
+        {
+          desc: 'explicit undefined value',
+          ctx:  { tag: 'test', value: undefined } as any,
+        },
+      ])('throws for invalid context: $desc', ({ ctx }) => {
+        const { s, commit } = makeStore();
+
+        expect(() => actions.add({ commit, state: s }, ctx)).toThrow('[ui-context]');
+      });
+
+      it('commits add and returns generated id for valid context', () => {
+        const { s, commit } = makeStore();
+        const ctx = { tag: 'my-tag', value: 'my-value' };
+
+        const id = actions.add({ commit, state: s }, ctx);
+
+        expect(id).toBe('ctx-0');
+        expect(commit).toHaveBeenCalledWith('add', { id: 'ctx-0', context: ctx });
+      });
+
+      it('increments idCounter on successive calls', () => {
+        const { s, commit } = makeStore();
+        const ctx = { tag: 't', value: 'v' };
+
+        const id1 = actions.add({ commit, state: s }, ctx);
+        const id2 = actions.add({ commit, state: s }, ctx);
+
+        expect(id1).toBe('ctx-0');
+        expect(id2).toBe('ctx-1');
+      });
+
+      it.each([
+        {
+          desc: 'null value',
+          ctx:  { tag: 'test', value: null },
+        },
+        {
+          desc: 'false value',
+          ctx:  { tag: 'test', value: false },
+        },
+        {
+          desc: 'zero value',
+          ctx:  { tag: 'test', value: 0 },
+        },
+        {
+          desc: 'empty string value',
+          ctx:  { tag: 'test', value: '' },
+        },
+      ])('does not throw for valid context with $desc', ({ ctx }) => {
+        const { s, commit } = makeStore();
+
+        expect(() => actions.add({ commit, state: s }, ctx as any)).not.toThrow();
+      });
+    });
+
+    describe('update', () => {
+      it('throws when element id is not found in state', () => {
+        const { s, commit } = makeStore();
+
+        expect(() => actions.update({ commit, state: s }, { id: 42, context: { tag: 't', value: 'v' } } as any)).toThrow('[ui-context]');
+      });
+
+      it('commits update for existing element', () => {
+        const { s, commit } = makeStore();
+
+        s.elements[1] = { id: 1, context: { tag: 'test', value: 'original' } };
+        const updated = { id: 1, context: { tag: 'test', value: 'updated' } };
+
+        actions.update({ commit, state: s }, updated as any);
+
+        expect(commit).toHaveBeenCalledWith('update', updated);
+      });
+    });
+
+    describe('remove', () => {
+      it('throws when element id is not found in state', () => {
+        const { s, commit } = makeStore();
+
+        expect(() => actions.remove({ commit, state: s }, 999 as any)).toThrow('[ui-context]');
+      });
+
+      it('commits remove with the found element', () => {
+        const { s, commit } = makeStore();
+        const element = { id: 1, context: { tag: 'test', value: 'val' } };
+
+        s.elements[1] = element;
+        actions.remove({ commit, state: s }, 1 as any);
+
+        expect(commit).toHaveBeenCalledWith('remove', element);
+      });
+    });
+  });
+});