@sankhyalabs/core 5.20.0-dev.69 → 5.20.0-dev.70

package/test/util/ColumnFilterManager.spec.ts

@@ -0,0 +1,133 @@
+import { ColumnFilterManager, IColumnFilter } from '../../src/utils/ColumnFilterManager.js';
+import { FieldDescriptor, Filter, FilterParam } from '../../src/dataunit/metadata/UnitMetadata.js';
+import DataUnit, { Record } from '../../src/dataunit/DataUnit';
+
+
+describe('ColumnFilterManager', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+
+  describe('getColumnFilters', () => {
+    it('should return an empty map if filters are undefined or empty', () => {
+      expect(ColumnFilterManager.getColumnFilters(undefined as any, 'field')).toEqual(new Map());
+      expect(ColumnFilterManager.getColumnFilters([], 'field')).toEqual(new Map());
+    });
+
+    it('should return a map of filters matching the pattern and not the provided fieldName', () => {
+      const filters: Filter[] = [
+        { name: 'FILTRO_COLUNA_field1', expression: '' },
+        { name: 'FILTRO_COLUNA_field2', expression: '' },
+      ];
+
+      const result = ColumnFilterManager.getColumnFilters(filters, 'field1');
+
+      expect(result.size).toBe(1);
+      expect(result.has('FILTRO_COLUNA_field2')).toBe(true);
+      expect(result.get('FILTRO_COLUNA_field2')?.columnName).toBe('field2');
+    });
+  });
+
+
+  describe('getFilterFunction', () => {
+    const mockDataUnit = {
+      getField: jest.fn(),
+      valueFromString: jest.fn()
+    } as unknown as DataUnit;
+
+    mockDataUnit.getField = jest.fn().mockReturnValue({} as FieldDescriptor);
+    mockDataUnit.valueFromString = jest.fn().mockReturnValue('test');
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    })
+
+    it('should return undefined if no filters are provided', () => {
+      expect(ColumnFilterManager.getFilterFunction(mockDataUnit, undefined)).toBeUndefined();
+      expect(ColumnFilterManager.getFilterFunction(mockDataUnit, [])).toBeUndefined();
+    });
+
+    it('should return a function that evaluates records based on filters', () => {
+      const filters: IColumnFilter[] = [
+        {
+          columnName: 'field1',
+          name: 'FILTRO_COLUNA_field1',
+          expression: '',
+          params: [{value: "mockedPAram"} as FilterParam]
+        },
+      ];
+
+
+      const filterFunction = ColumnFilterManager.getFilterFunction(mockDataUnit, filters);
+      expect(filterFunction).toBeDefined();
+
+      const record: Record = { field1: 'test' } as unknown as Record;
+      expect(filterFunction!(record)).toBe(true);
+    });
+
+    it('should return a function that evaluates records and return false', () => {
+      const filters: IColumnFilter[] = [
+        {
+          columnName: 'field1',
+          name: 'FILTRO_COLUNA_field1',
+          expression: '',
+        },
+      ];
+
+      const filterFunction = ColumnFilterManager.getFilterFunction(mockDataUnit, filters);
+      expect(filterFunction).toBeDefined();
+
+      const record: Record = { field1: 'test' } as unknown as Record;
+      expect(filterFunction!(record)).toBe(false);
+    });
+  });
+
+
+  describe("compileDistinct", () => {
+    const mockDataUnit = {
+      getField: jest.fn(),
+      valueFromString: jest.fn()
+    } as unknown as DataUnit;
+
+    mockDataUnit.getFormattedValue = jest.fn().mockImplementation((_, value) => value);
+    mockDataUnit.getFormattedValue = jest.fn().mockImplementation((_, value) => value);
+
+    const filters: Filter[] = [{ name: "FILTRO_COLUNA_fieldName", expression: '' }];
+    mockDataUnit.getLastLoadRequest = jest.fn().mockReturnValue({ filters });
+
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    })
+
+    it("should return an array of distinct field values formatted correctly", () => {
+      mockDataUnit.records = [
+        { fieldName: "value1" },
+        { fieldName: "value2" },
+        { fieldName: "value1" },
+      ] as unknown as Record[];
+
+      const distinct = ColumnFilterManager.compileDistinct("fieldName", mockDataUnit);
+
+      expect(distinct).toEqual([
+        { label: "value1", value: "value1", check: true },
+        { label: "value2", value: "value2", check: true },
+      ]);
+    });
+
+    it("should filter records if a load request is present", () => {
+      mockDataUnit.records = [
+        { fieldName: "value1" },
+        { fieldName: "value2" },
+      ] as unknown as Record[];
+
+      const distinct = ColumnFilterManager.compileDistinct("fieldName", mockDataUnit);
+
+      expect(distinct).toEqual([
+        { label: "value1", value: "value1", check: true },
+        { label: "value2", value: "value2", check: true },
+      ]);
+    });
+  });
+});