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

package/test/dataunit/formatting/PrettyFormatter.spec.ts

@@ -0,0 +1,177 @@
+import { getFormattedValue } from '../../../src/dataunit/formatting/PrettyFormatter';
+import { DataType, FieldDescriptor, UserInterface } from '../../../src';
+
+/**
+ * É preciso importart o utilitário DateUtils para que seus métodos
+ * estáticos sejam executados no ambiente de testes
+ */
+
+import { DateUtils } from '../../../src';
+
+describe('getFormattedValue', () => {
+  it('should return empty string when value is null', () => {
+    const value = null;
+    const descriptor = getFileFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('');
+  });
+
+  it('should return empty string when value is not an array', () => {
+    const value = 'not an array';
+    const descriptor = getFileFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('');
+  });
+
+  it('should return empty string when value is an empty array', () => {
+    const value: any[] = [];
+    const descriptor  = getFileFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('0 arquivos');
+  });
+
+  it('should return file name when value is an array with one file object', () => {
+    const value = [{ name: 'file1.txt' }];
+    const descriptor = getFileFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('file1.txt');
+  });
+
+  it('should return file count when value is an array with multiple file objects', () => {
+    const value = [{ name: 'file1.txt' }, { name: 'file2.txt' }];
+    const descriptor = getFileFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('2 arquivos');
+  });
+
+  it('should return empty string for undefined file', () => {
+    const value = undefined;
+    const descriptor = { userInterface: UserInterface.FILE } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('');
+  });
+
+  it('should handle OBJECT type with value field', () => {
+    const value = { value: 'code', label: 'label' };
+    const descriptor = { dataType: DataType.OBJECT, userInterface: UserInterface.SEARCH } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('code - label');
+  });
+
+  it('should return empty string when value is undefined', () => {
+    const value = undefined;
+    const descriptor = getObjectFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('');
+  });
+
+  it('should return value as string when value is not an object', () => {
+    const value = 12345;
+    const descriptor = getObjectFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('12345');
+  });
+
+  it('should return value.toString() when value is an object without value property', () => {
+    const value = { someProperty: 'someValue' };
+    const descriptor = getObjectFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe(value.toString());
+  });
+
+  it('should handle BOOLEAN type', () => {
+    expect(getFormattedValue(true, { dataType: DataType.BOOLEAN } as FieldDescriptor)).toBe('Sim');
+    expect(getFormattedValue(false, { dataType: DataType.BOOLEAN } as FieldDescriptor)).toBe('Não');
+  });
+
+  it('should format numbers correctly', () => {
+    const value = 1234.567;
+    const descriptor = {
+      dataType: DataType.NUMBER,
+      properties: { precision: 2, prettyPrecision: 2 },
+    } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('1.234,57');
+  });
+
+  it('should format dates correctly', () => {
+    const value = new Date('2023-07-01T14:30:00');
+    const descriptor = { userInterface: UserInterface.DATE } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('01/07/2023');
+  });
+
+  it('should format times correctly', () => {
+    const value = new Date('2023-07-01T14:30:00');
+    const descriptor = { userInterface: UserInterface.TIME } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('14:30');
+  });
+
+  it('should format datetime correctly', () => {
+    const value = new Date('2023-07-01T14:30:00');
+    const descriptor = { userInterface: UserInterface.DATETIME } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('01/07/2023 14:30');
+  });
+
+  it('should call toString with correct parameters', () => {
+    const value = 123;
+    const descriptor = { dataType: DataType.NUMBER } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('123,00');
+  });
+
+  it('should handle undefined descriptor gracefully', () => {
+    const value = 123;
+    expect(getFormattedValue(value)).toBe('123');
+  });
+
+  it('should format value correctly with OPTIONSELECTOR and matching option', () => {
+    const value = 'option1';
+    const descriptor = buildOptionSelectorFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('option1');
+  });
+
+  it('should return value with OPTIONSELECTOR and no matching option', () => {
+    const value = 'option2';
+    const descriptor = buildOptionSelectorFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('option2');
+  });
+
+  it('should format value correctly with OPTIONSELECTOR and value as object', () => {
+    const value = { value: 'option1' };
+    const descriptor = buildOptionSelectorFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('option1');
+  });
+
+  it('should return empty string with OPTIONSELECTOR and value as null', () => {
+    const value = null;
+    const descriptor = buildOptionSelectorFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('');
+  });
+
+  it('should format value correctly with OPTIONSELECTOR and options as JSON string', () => {
+    const value = 'option1';
+    const descriptor: FieldDescriptor = {
+      userInterface: UserInterface.OPTIONSELECTOR,
+      properties: { options: JSON.stringify([{ label: 'Option 1', value: 'option1' }]) },
+    } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('option1');
+  });
+
+  it('should return value with OPTIONSELECTOR and options as empty array', () => {
+    const value = 'option1';
+    const descriptor: FieldDescriptor = {
+      userInterface: UserInterface.OPTIONSELECTOR,
+      properties: { options: [] },
+    } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('option1');
+  });
+
+  it('should format masked values correctly', () => {
+    const value = '12345678901';
+    const descriptor = { properties: { mask: 'cpf' } } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('123.456.789-01');
+  });
+});
+
+function buildOptionSelectorFieldDescriptor(): FieldDescriptor {
+  return {
+    userInterface: UserInterface.OPTIONSELECTOR,
+    properties: { options: [{ label: 'Option 1', value: 'option1' }] },
+  } as FieldDescriptor;
+}
+
+function getFileFieldDescriptor(): FieldDescriptor{
+  return { userInterface: UserInterface.FILE } as FieldDescriptor;
+}
+
+function getObjectFieldDescriptor(): FieldDescriptor{
+  return { dataType: DataType.OBJECT } as FieldDescriptor;
+}

package/test/dataunit/loader/dataUnitInMemoryLoader.spec.ts

@@ -0,0 +1,221 @@
+import { DataUnitInMemoryLoader } from '../../../src/dataunit/loader/dataUnitInMemoryLoader.js';
+import {
+  DataUnitInMemoryLoaderConfig,
+  RECORD_DATE_FORMAT,
+} from '../../../src/dataunit/loader/DataUnitInMemoryLoaderConfig.js';
+import { FieldDescriptor, UnitMetadata } from '../../../src/dataunit/metadata/UnitMetadata.js';
+import { DataType } from '../../../src/dataunit/metadata/DataType.js';
+import DateUtils from '../../../src/utils/DateUtils.js';
+import DataUnit, { Record } from '../../../src/dataunit/DataUnit.js';
+
+describe('DataUnitInMemoryLoader - loadData', () => {
+  const dataUnitMetetadata: UnitMetadata = {
+    name: 'test',
+    label: 'test',
+    fields: [],
+  };
+
+  it('should be called load data when auto load is true', async () => {
+    const config: DataUnitInMemoryLoaderConfig = {
+      autoLoad: true,
+    };
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, [], config);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).toHaveBeenCalled();
+  });
+
+  it('should be called load data when auto load is undefined', async () => {
+    const config: DataUnitInMemoryLoaderConfig = {
+      autoLoad: undefined,
+    };
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, [], config);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).toHaveBeenCalled();
+  });
+
+  it('should not be called load data when auto load is false', async () => {
+    const config: DataUnitInMemoryLoaderConfig = {
+      autoLoad: false,
+    };
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, [], config);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).not.toHaveBeenCalled();
+  });
+
+  it('should be called load data when config is undefined', async () => {
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, []);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).toHaveBeenCalled();
+  });
+});
+
+describe('DataUnitInMemoryLoader - getConvertedValue', () => {
+  let descriptor: FieldDescriptor;
+
+  beforeEach(() => {
+    descriptor = { name: 'testField', dataType: DataType.TEXT, label: 'mock' }; // Valor padrão para inicialização
+  });
+
+  it('should return the original string if descriptor is undefined', () => {
+    const result = DataUnitInMemoryLoader.getConvertedValue(undefined as any, 'testValue');
+    expect(result).toBe('testValue');
+  });
+
+  it('should return the original string if dataType is TEXT', () => {
+    descriptor.dataType = DataType.TEXT;
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, 'testValue');
+    expect(result).toBe('testValue');
+  });
+
+  it('should convert to boolean when dataType is BOOLEAN', () => {
+    descriptor.dataType = DataType.BOOLEAN;
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, 'S')).toBe(true);
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, 'N')).toBe(false);
+  });
+
+  it('should convert to number when dataType is NUMBER', () => {
+    descriptor.dataType = DataType.NUMBER;
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, '123')).toBe(123);
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, '45.67')).toBe(45.67);
+  });
+
+  it('should parse JSON when dataType is OBJECT', () => {
+    descriptor.dataType = DataType.OBJECT;
+    const jsonString = '{"key": "value"}';
+    const expectedObject = { key: 'value' };
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, jsonString)).toEqual(expectedObject);
+  });
+
+  it('should convert to date when dataType is DATE and format is ISO', () => {
+    descriptor.dataType = DataType.DATE;
+
+    const isoDate = '2023-01-01T00:00:00Z';
+    jest.spyOn(DateUtils, 'validateDate').mockImplementation((date) => date);
+
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, isoDate, RECORD_DATE_FORMAT.ISO);
+    expect(DateUtils.validateDate).toHaveBeenCalledWith(new Date(isoDate), true);
+    expect(result).toEqual(new Date(isoDate));
+  });
+
+  it('should convert to date when dataType is DATE and format is not ISO', () => {
+    descriptor.dataType = DataType.DATE;
+
+    const dateString = '01/01/2023';
+    jest.spyOn(DateUtils, 'strToDate').mockImplementation(() => new Date(2023, 0, 1));
+
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, dateString, RECORD_DATE_FORMAT.DD_MM_YYYY);
+    expect(DateUtils.strToDate).toHaveBeenCalledWith(dateString, true);
+    expect(result).toEqual(new Date(2023, 0, 1));
+  });
+
+  it('should return the original string if no dataType matches', () => {
+    descriptor.dataType = undefined as any; // Simula um caso inválido
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, 'testValue');
+    expect(result).toBe('testValue');
+  });
+});
+
+describe('DataUnitInMemoryLoader - removeLoader', () => {
+  let loader: DataUnitInMemoryLoader;
+  const mockedDataUnit = {} as DataUnit;
+
+  beforeEach(() => {
+    loader = new DataUnitInMemoryLoader();
+  });
+
+  it('should resolve with the provided record IDs', async () => {
+    const mockRecordIds = ['record1', 'record2', 'record3'];
+
+    const result = await loader.removeLoader(mockedDataUnit, mockRecordIds);
+
+    expect(result).toEqual(mockRecordIds);
+  });
+
+  it('should handle empty record ID array', async () => {
+    const mockRecordIds: string[] = [];
+
+    const result = await loader.removeLoader(mockedDataUnit, mockRecordIds);
+
+    expect(result).toEqual([]);
+  });
+
+  it('should resolve the promise', async () => {
+    const mockRecordIds = ['record1'];
+
+    await expect(loader.removeLoader(mockedDataUnit, mockRecordIds)).resolves.toEqual(mockRecordIds);
+  });
+});
+
+describe('DataUnitInMemoryLoader - buildInitialRecords (indiretamente via set records)', () => {
+  let loader: DataUnitInMemoryLoader;
+  let mockRecords: Array<Record> = [
+    { id: '1', amount: '100', isActive: 'S', createdAt: '01/01/2023' },
+    { id: '2', amount: '200.50', isActive: 'N', createdAt: '02/01/2023' },
+  ] as unknown as Record[];
+
+  let mockMetadata =  {
+    fields: [
+      { name: 'id', label: 'id', dataType: DataType.TEXT },
+      { name: 'amount', label: 'amount', dataType: DataType.NUMBER },
+      { name: 'isActive', label: 'isActive', dataType: DataType.BOOLEAN },
+      { name: 'createdAt', label: 'createdAt', dataType: DataType.DATE },
+    ],
+  };
+
+  beforeEach(() => {
+    loader = new DataUnitInMemoryLoader(mockMetadata as any, [], { recordDateFormat: RECORD_DATE_FORMAT.DD_MM_YYYY });
+  });
+
+  it('should build initial records and convert field values based on metadata', () => {
+    loader.records = mockRecords;
+    const initialRecords = loader['_initialRecords'];
+
+    expect(initialRecords).toHaveLength(2);
+
+    expect(initialRecords[0]).toEqual({
+      id: '1',
+      amount: 100,
+      isActive: true,
+      createdAt: expect.any(Date),
+      __record__id__: expect.any(String),
+    });
+
+    expect(initialRecords[1]).toEqual({
+      id: '2',
+      amount: 200.5,
+      isActive: false,
+      createdAt:  expect.any(Date),
+      __record__id__: expect.any(String),
+    });
+  });
+
+  it('should generate unique IDs for records without "__record__id__"', () => {
+    loader.records = [{ id: '3', amount: '300' }] as unknown as Record[];
+
+    const builtRecords = loader['_initialRecords'];
+    expect(builtRecords).toHaveLength(1);
+
+    expect(builtRecords[0]).toHaveProperty('__record__id__');
+    expect(typeof builtRecords[0]['__record__id__']).toBe('string');
+  });
+
+  it('should leave fields untouched if no matching metadata exists', () => {
+    mockRecords[0]['extraField'] = 'unchanged';
+    loader.records = mockRecords;
+
+    const builtRecords = loader['_initialRecords'];
+    expect(builtRecords[0]).toHaveProperty('extraField', 'unchanged');
+  });
+
+  it('should skip conversion for non-string field values', () => {
+    mockRecords[0].amount = 500;
+    loader.records = mockRecords;
+
+    const builtRecords = loader['_initialRecords'];
+    expect(builtRecords[0].amount).toBe(500);
+  });
+});

package/test/dataunit/loader/utils/dataUnitLoaderUtils.spec.ts

@@ -0,0 +1,158 @@
+jest.mock('../../../../src/utils/ColumnFilterManager', () => ({
+  ColumnFilterManager: {
+    getColumnFilters: jest.fn(),
+    getFilterFunction: jest.fn(),
+  },
+}));
+
+jest.mock('../../../../src/utils/SortingUtils', () => {
+  return {
+    __esModule: true, // Indica que este módulo possui uma exportação padrão
+    default: {
+      getSortingFunction: jest.fn(),
+    },
+  };
+});
+
+
+import { DataUnitLoaderUtils } from '../../../../src/dataunit/loader/utils/dataUnitLoaderUtils';
+import { IColumnFilter } from '../../../../src/utils/ColumnFilterManager';
+import { Record } from '../../../../src/dataunit/DataUnit';
+import { Filter, Sort, SortMode } from '../../../../src/dataunit/metadata/UnitMetadata';
+import { DataType } from '../../../../src/dataunit/metadata/DataType';
+import { ColumnFilterManager } from '../../../../src/utils/ColumnFilterManager';
+import SortingUtils from '../../../../src/utils/SortingUtils';
+
+
+describe('Utility Functions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('applyFilter', () => {
+    it('should return the original records if no filters are provided', () => {
+      const records: Record[] = [{ __record__id__: '1' }, { __record__id__: '2' }];
+      const filters: Filter[] = [];
+      const columnFilterMock = new Map<string, IColumnFilter>();
+
+      (ColumnFilterManager.getColumnFilters as jest.Mock).mockReturnValue(columnFilterMock);
+      (ColumnFilterManager.getFilterFunction as jest.Mock).mockReturnValue(undefined);
+
+      const result = DataUnitLoaderUtils.applyFilter(records, {} as any, filters);
+
+      expect(result).toEqual(records);
+      expect(ColumnFilterManager.getColumnFilters).toHaveBeenCalledWith(filters, '');
+    });
+
+    it('should filter records based on provided filters', () => {
+      const records: Record[] = [{ __record__id__: '1' }, { __record__id__: '2' }];
+      const filters: Filter[] = [{ name: 'test', expression: '1' }];
+      const columnFilterMock = new Map<string, IColumnFilter>();
+      columnFilterMock.set('test', { columnName: 'name', ...filters[0] } as IColumnFilter);
+
+      (ColumnFilterManager.getColumnFilters as jest.Mock).mockReturnValue(columnFilterMock);
+      (ColumnFilterManager.getFilterFunction as jest.Mock).mockReturnValue((record: Record) => record.__record__id__ === '1');
+
+      const result = DataUnitLoaderUtils.applyFilter(records, {} as any, filters);
+
+      expect(result).toEqual([{ __record__id__: '1' }]);
+      expect(ColumnFilterManager.getFilterFunction).toHaveBeenCalledWith({}, Array.from(columnFilterMock.values()));
+    });
+  });
+
+  describe('buildPaginationInfo function', () => {
+    it('should return correct pagination info with default values', () => {
+
+      const result = DataUnitLoaderUtils.buildPaginationInfo({
+        recordsLength: 0,
+        offset: 0,
+        recordsPerPage: 5,
+      });
+
+      expect(result).toEqual({
+        currentPage: 0,
+        firstRecord: 0,
+        lastRecord: 0,
+        total: 0,
+        hasMore: false,
+      });
+    });
+
+    it('should redosLenth as same size as recordsPerPage', () => {
+      const result = DataUnitLoaderUtils.buildPaginationInfo({
+        recordsLength: 10,
+        offset: 0,
+        recordsPerPage: 10,
+      });
+
+      expect(result).toEqual({
+        currentPage: 0,
+        firstRecord: 1,
+        lastRecord: 10,
+        total: 10,
+        hasMore: false,
+      });
+    });
+
+
+    it('should handle case when totalRecordsLength and offset 0', () => {
+      const result = DataUnitLoaderUtils.buildPaginationInfo({
+        recordsLength: 10,
+        offset: 0,
+        recordsPerPage: 5,
+      });
+
+      expect(result).toEqual({
+        currentPage: 0,
+        firstRecord: 1,
+        lastRecord: 5,
+        total: 10,
+        hasMore: true,
+      });
+    });
+
+    it('should handle case when currentPageLength is less than totalRecordsLength and lastPage', () => {
+      const result = DataUnitLoaderUtils.buildPaginationInfo({
+        recordsLength: 10,
+        offset: 5,
+        recordsPerPage: 5,
+      });
+
+      expect(result).toEqual({
+        currentPage: 1,
+        firstRecord: 6,
+        lastRecord: 10,
+        total: 10,
+        hasMore: false,
+      });
+    });
+  });
+
+  describe('applySorting function', () => {
+
+    it('should return the original records if no sorting is provided', () => {
+      const records: Record[] = [{ __record__id__: '1' }, { __record__id__: '2' }];
+      const sorting: Sort[] = [];
+
+      const result = DataUnitLoaderUtils.applySorting(records, {} as any, sorting);
+
+      expect(result).toEqual(records);
+      expect(SortingUtils.getSortingFunction).not.toHaveBeenCalled();
+    });
+
+    it('should sort records based on provided sorting criteria', () => {
+      const records: Record[] = [{ __record__id__: '2' }, { __record__id__: '1' }];
+      const sorting: Sort[] = [{ field: '__record__id__', mode: SortMode.ASC, dataType: DataType.TEXT }];
+
+      const sortingFunction = (a: Record, b: Record) => (a.__record__id__ > b.__record__id__ ? 1 : -1);
+      (SortingUtils.getSortingFunction as jest.Mock).mockReturnValue(sortingFunction);
+
+      const result = DataUnitLoaderUtils.applySorting(records, {} as any, sorting);
+
+      expect(result).toEqual([{ __record__id__: '1' }, { __record__id__: '2' }]);
+      expect(SortingUtils.getSortingFunction).toHaveBeenCalledWith({}, sorting);
+    });
+  });
+
+
+});

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