@zeedhi/teknisa-components-common 3.1.0 → 3.2.0

package/tests/unit/components/tek-datasource/rest-datasource.spec.ts

@@ -1,362 +0,0 @@
-import {
-  type IConfig, Config, Router, Http, URL, type IDictionary, init,
-} from '@zeedhi/core';
-import {
-  TekRestDatasource, type ITekRestDatasource,
-} from '../../../../src';
-
-describe('TekRestDatasource', () => {
-  init({
-    controllers: {
-      AppController: class AppController {
-        public value = '1';
-
-        public join: string[] | number[] = ['1', '2'];
-      },
-    },
-  });
-  let datasource: ITekRestDatasource;
-  let router: any;
-  const config: IConfig = {
-    endPoint: 'http://localhost:9000/',
-    metadataEndPoint: 'http://localhost:9000/metadata/',
-    title: 'Samples',
-    mode: 'production',
-    datasourceLimit: 10,
-  };
-  let httpSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    datasource = {
-      uniqueKey: 'id',
-      route: '/zeedhi',
-      lazyLoad: true,
-    };
-    Config.set(config);
-    router = {
-      push: () => jest.fn,
-      replace: (route: any) => {
-        window.history.replaceState(null, '', `${window.location.pathname}?${URL.getFormattedQueryString(route.query)}`);
-      },
-      back: () => jest.fn,
-      getCurrentRoute: () => ({
-        path: '',
-        hash: '',
-        query: {},
-        params: {},
-        fullPath: '',
-      }),
-      getPath: () => '',
-      getHash: () => '',
-      getQuery: () => ({}),
-      getParams: () => ({}),
-      getFullPath: () => '',
-    };
-    Router.setInstance(router);
-    httpSpy = jest.spyOn(Http, 'get').mockImplementation(() => Promise.resolve({
-      data: {
-        data: [
-          { name: '1', id: 1 }, { name: '2', id: 2 }, { name: '3', id: 3 },
-          { name: '4', id: 4 }, { name: '5', id: 5 }, { name: '6', id: 6 },
-        ],
-        pagination: {
-          page: 1,
-          total: 6,
-          limit: 15,
-        },
-      },
-    }));
-  });
-
-  afterEach(() => {
-    httpSpy.mockClear();
-  });
-
-  describe('constuctor()', () => {
-    it('should assign all properties', async () => {
-      const flushPromises = () => new Promise(setImmediate);
-      const instance = new TekRestDatasource({
-        ...datasource,
-        dynamicFilter: {
-          name: { operation: 'EQUALS', relation: 'AND', value: '1' },
-        },
-        searchJoin: { col1: ['1', '2'], col2: [2], col3: [] },
-      });
-      await flushPromises();
-
-      expect(instance.route).toBe('/zeedhi');
-      expect(instance.lazyLoad).toBeTruthy();
-      expect(instance.dynamicFilter).toEqual({ name: { operation: 'EQUALS', relation: 'AND', value: '1' } });
-      expect(instance.data.length).toBe(0);
-      expect(instance.searchJoin).toEqual({ col1: ['1', '2'], col2: [2], col3: [] });
-    });
-
-    it('should assign all properties', async () => {
-      const flushPromises = () => new Promise(setImmediate);
-      const instance = new TekRestDatasource({
-        ...datasource,
-        dynamicFilter: {
-          name: { operation: 'EQUALS', relation: 'AND', value: '{{AppController.value}}' },
-        },
-        searchJoin: { col1: '{{AppController.join}}' as any, col2: [2], col3: [] },
-      });
-      await flushPromises();
-
-      expect(instance.route).toBe('/zeedhi');
-      expect(instance.lazyLoad).toBeTruthy();
-      expect(instance.dynamicFilter).toEqual({ name: { operation: 'EQUALS', relation: 'AND', value: '1' } });
-      expect(instance.data.length).toBe(0);
-      expect(instance.searchJoin).toEqual({ col1: ['1', '2'], col2: [2], col3: [] });
-    });
-
-    it('should create without lazyLoad', async () => {
-      const flushPromises = () => new Promise(setImmediate);
-      const instance = new TekRestDatasource({
-        ...datasource,
-        lazyLoad: false,
-        dynamicFilter: {
-          name: { operation: 'EQUALS', relation: 'AND', value: '1' },
-        },
-      });
-      instance.initialize();
-      await flushPromises();
-
-      expect(instance.data.length).toBe(6);
-    });
-
-    it('should set values from url', () => {
-      router.getFullPath = () => 'localhost/?page=2&limit=10&order=id.asc&search=2&id=1&filter=applied';
-      datasource.watchUrl = true;
-      const instance = new TekRestDatasource(datasource);
-      expect(instance.filter).toEqual({ id: '1' });
-      expect(instance.limit).toBe(10);
-      expect(instance.order).toEqual(['id.asc']);
-      expect(instance.page).toBe(2);
-      expect(instance.search).toBe('2');
-    });
-
-    it('should set dynamicFilter from url', () => {
-      router.getFullPath = () => 'localhost/?dynamic_filter=eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMSJ9XX0='; // eslint-disable-line max-len
-      datasource.watchUrl = true;
-      const instance = new TekRestDatasource(datasource);
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-    });
-
-    it('should set searchJoin from url', () => {
-      router.getFullPath = () => 'localhost/?search_join=eyAiY29sMSI6IFsiMSIsICIyIl0sICJjb2wyIjogWzJdLCAiY29sMyI6IFtdIH0='; // eslint-disable-line max-len
-      datasource.watchUrl = true;
-      const instance = new TekRestDatasource(datasource);
-      expect(instance.searchJoin).toEqual({ col1: ['1', '2'], col2: [2], col3: [] });
-    });
-  });
-
-  describe('addDynamicFilter()', () => {
-    it('should add/remove dynamic filter value', () => {
-      datasource.watchUrl = false;
-      const instance = new TekRestDatasource(datasource);
-      instance.addDynamicFilter('name', [{ operation: 'EQUALS', relation: 'AND', value: '1' }]);
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-      instance.addDynamicFilter('name', [{ operation: 'foo', relation: 'AND', value: '1' }]);
-      expect(instance.dynamicFilter).toEqual({});
-    });
-  });
-
-  describe('setDynamicFilter()', () => {
-    it('should add/remove dynamic filter value', () => {
-      datasource.watchUrl = false;
-      const instance = new TekRestDatasource(datasource);
-      instance.setDynamicFilter({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-
-      instance.setDynamicFilter({ name: [{ operation: 'foo', relation: 'AND', value: '1' }] });
-      expect(instance.dynamicFilter).toEqual({});
-
-      instance.setDynamicFilter({
-        department_id: undefined, hire_date: null, name: [], id: [{}],
-      });
-      expect(instance.dynamicFilter).toEqual({});
-    });
-
-    it('should add dynamic filter value with watchUrl', () => {
-      let dynamicFilterValue = 'eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMSJ9XX0=';
-      router.getFullPath = () => `localhost/?dynamic_filter=${dynamicFilterValue}`;
-      const urlSpy = jest.spyOn(URL, 'updateQueryString');
-
-      datasource.watchUrl = true;
-      const instance = new TekRestDatasource(datasource);
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-
-      dynamicFilterValue = 'eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMiJ9XX0=';
-      instance.setDynamicFilter({ name: [{ operation: 'EQUALS', relation: 'AND', value: '2' }] });
-      expect(urlSpy).toHaveBeenCalledWith({
-        dynamic_filter: dynamicFilterValue,
-      });
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '2' }] });
-      urlSpy.mockClear();
-    });
-  });
-
-  describe('clearDynamicFilter()', () => {
-    it('should clear dynamic filter', () => {
-      datasource.watchUrl = false;
-      const instance = new TekRestDatasource(datasource);
-      instance.setDynamicFilter({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-      instance.clearDynamicFilter();
-      expect(instance.dynamicFilter).toEqual({});
-    });
-
-    it('should clear dynamic filter value with watchUrl', () => {
-      let dynamicFilterValue = 'eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMSJ9XX0=';
-      router.getFullPath = () => `localhost/?dynamic_filter=${dynamicFilterValue}`;
-      const urlSpy = jest.spyOn(URL, 'updateQueryString');
-
-      datasource.watchUrl = true;
-      const instance = new TekRestDatasource(datasource);
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-
-      dynamicFilterValue = '';
-      instance.clearDynamicFilter();
-      expect(urlSpy).toHaveBeenCalledWith({
-        dynamic_filter: undefined,
-      });
-      expect(instance.dynamicFilter).toEqual({});
-      urlSpy.mockClear();
-    });
-  });
-
-  describe('get()', () => {
-    it('should send dynamic filter and searchJoin on get request params', async () => {
-      datasource.watchUrl = false;
-      const instance = new TekRestDatasource(datasource);
-      const dynFilter = { name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] };
-      const searchJoin = { join: [1, 2, 3] };
-      instance.setDynamicFilter(dynFilter);
-      instance.searchJoin = searchJoin;
-
-      await instance.get();
-
-      const expectedFilter = btoa(JSON.stringify(dynFilter));
-      const expectedSJoin = btoa(JSON.stringify(searchJoin));
-      expect(httpSpy).toHaveBeenCalledWith('/zeedhi',
-        expect.objectContaining({
-          params: expect.objectContaining({
-            dynamic_filter: expectedFilter,
-            search_join: expectedSJoin,
-          }),
-        }));
-    });
-
-    it('should send dynamic filter on get request params', async () => {
-      datasource.watchUrl = false;
-      const instance = new TekRestDatasource(datasource);
-      const dynFilter = { name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] };
-      instance.setDynamicFilter(dynFilter);
-
-      await instance.get();
-
-      const expectedFilter = btoa(JSON.stringify(dynFilter));
-
-      // should have dynamic_filter
-      expect(httpSpy).toHaveBeenCalledWith('/zeedhi',
-        expect.objectContaining({
-          params: expect.objectContaining({
-            dynamic_filter: expectedFilter,
-          }),
-        }));
-      // should not have search_join
-      expect(httpSpy).toHaveBeenCalledWith('/zeedhi',
-        expect.objectContaining({
-          params: expect.not.objectContaining({
-            search_join: expect.anything(),
-          }),
-        }));
-    });
-
-    it('should send search join on get request params', async () => {
-      datasource.watchUrl = false;
-      const instance = new TekRestDatasource(datasource);
-      const searchJoin = { join: [1, 2, 3] };
-      instance.searchJoin = searchJoin;
-
-      await instance.get();
-
-      const expectedSJoin = btoa(JSON.stringify(searchJoin));
-      // should have search_join
-      expect(httpSpy).toHaveBeenCalledWith('/zeedhi',
-        expect.objectContaining({
-          params: expect.objectContaining({
-            search_join: expectedSJoin,
-          }),
-        }));
-      // should not have dynamic_filter
-      expect(httpSpy).toHaveBeenCalledWith('/zeedhi',
-        expect.objectContaining({
-          params: expect.not.objectContaining({
-            dynamic_filter: expect.anything(),
-          }),
-        }));
-    });
-
-    it('should not send empty dynamic filter properties', async () => {
-      const filter: IDictionary = {
-        department_id: undefined, hire_date: null, name: [], id: [{}],
-      };
-      const instance = new TekRestDatasource(datasource);
-      instance.dynamicFilter = filter;
-
-      await instance.get();
-
-      expect(httpSpy).toHaveBeenCalledWith('/zeedhi', expect.objectContaining({
-        params: {
-          in: [],
-          order: [],
-          search: undefined,
-          search_in: [],
-          page: 1,
-          limit: 10,
-        },
-      }));
-    });
-  });
-
-  describe('clone', () => {
-    it('should return an object with all datasource props', async () => {
-      const data = [{ value: 'item 1' }];
-      const dynamicFilter = {
-        name: { operation: 'EQUALS', relation: 'AND', value: 'item 1' },
-      };
-      const searchJoin = { col1: ['1', '2'], col2: [2], col3: [] };
-      const instance = new TekRestDatasource({
-        route: '/zeedhi',
-        data,
-        dynamicFilter,
-        searchJoin,
-      });
-
-      const props = instance.clone();
-
-      expect(props).toEqual({
-        data,
-        dynamicFilter,
-        searchJoin,
-        currentRow: {},
-        filter: {},
-        find: {},
-        limit: 10,
-        order: [],
-        page: 1,
-        search: '',
-        searchIn: [],
-        uniqueKey: 'id',
-        watchUrl: false,
-        events: {},
-        loadAll: false,
-        lazyLoad: true,
-        arrayFormat: 'repeat',
-        route: '/zeedhi',
-        type: 'tek-rest',
-      });
-    });
-  });
-});

package/tests/unit/components/tek-grid/button-option.spec.ts

@@ -1,49 +0,0 @@
-import { Button } from '@zeedhi/common';
-import { TekGrid, ButtonOption } from '../../../../src';
-import { Loader, SimpleControllerBuilder } from '@zeedhi/core';
-
-describe('ButtonOption', () => {
-  beforeAll(() => {
-    Loader.setBuilder(new SimpleControllerBuilder());
-  });
-
-  describe('buildComponent()', () => {
-    it('when called, should build a simple button component', () => {
-      const grid = new TekGrid({ name: 'Grid', component: 'TekGrid' });
-      const config = {
-        type: 'pdf',
-        label: 'Exportar PDF',
-      };
-      const option = new ButtonOption(config);
-
-      const component = option.buildComponent(grid);
-
-      expect(component).toEqual(expect.objectContaining({
-        label: config.label,
-        name: 'Grid_export_pdf_portrait',
-        component: 'ZdButton',
-        iconName: undefined,
-        flat: true,
-      }));
-    });
-
-    it('the generated button component should call grid.getReport on click', () => {
-      const grid = new TekGrid({ name: 'Grid', component: 'TekGrid' });
-      const spy = jest.fn();
-      grid.getReport = spy;
-      const config = {
-        type: 'pdf',
-        label: 'Exportar PDF',
-        portrait: false,
-      };
-      const option = new ButtonOption(config);
-
-      const component = option.buildComponent(grid);
-
-      const instance = new Button(component);
-      instance.click();
-
-      expect(spy).toHaveBeenCalledTimes(1);
-    });
-  });
-});

package/tests/unit/components/tek-grid/columns-searcher.spec.ts

@@ -1,112 +0,0 @@
-import { ColumnsSearcher, ITekGridColumn } from '../../../../src';
-
-describe("ColumnsSearcher", () => {
-  let columnsSearcher: ColumnsSearcher;
-
-  beforeEach(() => {
-    columnsSearcher = new ColumnsSearcher();
-  });
-
-  describe("searchColumn", () => {
-    it("should return empty object when search string is empty", async () => {
-      const columns: ITekGridColumn[] = [
-        {
-          name: "testColumn",
-          componentProps: { name: 'testColumnName', datasource: { uniqueKey: "id" } },
-          memorySearch: jest.fn(),
-        },
-      ];
-      const search = "";
-
-      const result = await columnsSearcher.searchColumn(columns, search);
-
-      expect(result).toEqual({});
-      expect(columns[0].memorySearch).not.toHaveBeenCalled();
-    });
-
-    it("should skip columns without datasource", async () => {
-      const columns: ITekGridColumn[] = [
-        {
-          name: "noDataSourceColumn",
-          componentProps: { name: 'noDataSourceColumnName' },
-          memorySearch: jest.fn(),
-        },
-        {
-          name: "validColumn",
-          componentProps: { name: 'validColumnName', datasource: { uniqueKey: "id" } },
-          memorySearch: jest.fn().mockResolvedValue([{ id: 1 }]),
-        },
-      ];
-      const search = "test";
-
-      const result = await columnsSearcher.searchColumn(columns, search);
-
-      expect(result).toEqual({ validColumn: [1] });
-      expect(columns[0].memorySearch).not.toHaveBeenCalled();
-      expect(columns[1].memorySearch).toHaveBeenCalledWith("test");
-    });
-
-    it("should skip columns with skipLookupSearch=true", async () => {
-      const columns: ITekGridColumn[] = [
-        {
-          name: "skippedColumn",
-          componentProps: { name: 'skippedColumnName', datasource: { uniqueKey: "id" } },
-          skipLookupSearch: true,
-          memorySearch: jest.fn(),
-        },
-        {
-          name: "validColumn",
-          componentProps: { name: 'validColumnName', datasource: { uniqueKey: "id" } },
-          memorySearch: jest.fn().mockResolvedValue([{ id: 1 }]),
-        },
-      ];
-      const search = "test";
-
-      const result = await columnsSearcher.searchColumn(columns, search);
-
-      expect(result).toEqual({ validColumn: [1] });
-      expect(columns[0].memorySearch).not.toHaveBeenCalled();
-      expect(columns[1].memorySearch).toHaveBeenCalledWith("test");
-    });
-
-    it("should process multiple columns in parallel", async () => {
-      const columns: ITekGridColumn[] = [
-        {
-          name: "column1",
-          componentProps: { name: 'column1Name', datasource: { uniqueKey: "id" } },
-          memorySearch: jest.fn().mockResolvedValue([{ id: 1 }, { id: 2 }]),
-        },
-        {
-          name: "column2",
-          componentProps: { name: 'column2Name', datasource: { uniqueKey: "code" } },
-          memorySearch: jest.fn().mockResolvedValue([{ code: "A" }, { code: "B" }]),
-        },
-      ];
-      const search = "test";
-
-      const result = await columnsSearcher.searchColumn(columns, search);
-
-      expect(result).toEqual({
-        column1: [1, 2],
-        column2: ["A", "B"],
-      });
-      expect(columns[0].memorySearch).toHaveBeenCalledWith("test");
-      expect(columns[1].memorySearch).toHaveBeenCalledWith("test");
-    });
-
-    it("should handle empty search results", async () => {
-      const columns: ITekGridColumn[] = [
-        {
-          name: "emptyResultsColumn",
-          componentProps: { name: 'emptyResultsColumnName', datasource: { uniqueKey: "id" } },
-          memorySearch: jest.fn().mockResolvedValue([]),
-        },
-      ];
-      const search = "test";
-
-      const result = await columnsSearcher.searchColumn(columns, search);
-
-      expect(result).toEqual({ emptyResultsColumn: [] });
-    });
-  });
-});

package/tests/unit/components/tek-grid/dynamic-filter-datasource-factory.spec.ts

@@ -1,90 +0,0 @@
-import { Datasource, DatasourceFactory, IDictionary } from '@zeedhi/core';
-import { DynamicFilterDatasourceFactory } from '../../../../src';
-
-describe('DynamicFilterDatasourceFactory', () => {
-  let factory: DynamicFilterDatasourceFactory;
-  let mockDatasourceFactory: jest.Mocked<typeof DatasourceFactory>;
-
-  beforeEach(() => {
-    factory = new DynamicFilterDatasourceFactory();
-    
-    // Create a mock for just the DatasourceFactory.factory method
-    mockDatasourceFactory = {
-      factory: jest.fn(),
-    } as unknown as jest.Mocked<typeof DatasourceFactory>;
-    
-    // Replace the original implementation with our mock
-    jest.spyOn(DatasourceFactory, 'factory').mockImplementation(mockDatasourceFactory.factory);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  describe('factory', () => {
-    it('should create a datasource with correct configuration', () => {
-      const mockOptions: IDictionary<boolean> = {
-        option1: true,
-        option2: false,
-      };
-      const expectedData = [
-        { text: 'TEKGRID_option1', value: 'option1' },
-        { text: 'TEKGRID_option2', value: 'option2' },
-      ];
-      const mockDatasource = {} as Datasource;
-      
-      mockDatasourceFactory.factory.mockReturnValue(mockDatasource);
-
-      const result = factory.factory(mockOptions);
-
-      expect(mockDatasourceFactory.factory).toHaveBeenCalledWith({
-        data: expectedData,
-        loadAll: true,
-        translate: ['text'],
-      });
-      expect(result).toBe(mockDatasource);
-    });
-
-    it('should handle empty options', () => {
-      const mockOptions: IDictionary<boolean> = {};
-      const mockDatasource = {} as Datasource;
-      
-      mockDatasourceFactory.factory.mockReturnValue(mockDatasource);
-
-      const result = factory.factory(mockOptions);
-
-      expect(mockDatasourceFactory.factory).toHaveBeenCalledWith({
-        data: [],
-        loadAll: true,
-        translate: ['text'],
-      });
-      expect(result).toBe(mockDatasource);
-    });
-  });
-
-  describe('getFilterOptionsData', () => {
-    // Since this is a private method, we'll test it indirectly through the public factory method
-    // If you want to test it directly, you might need to make it public or use type assertions
-    
-    it('should transform options correctly (tested through factory)', () => {
-      const mockOptions: IDictionary<boolean> = {
-        active: true,
-        inactive: false,
-      };
-      const mockDatasource = {} as Datasource;
-      
-      mockDatasourceFactory.factory.mockReturnValue(mockDatasource);
-
-      factory.factory(mockOptions);
-
-      expect(mockDatasourceFactory.factory).toHaveBeenCalledWith({
-        data: [
-          { text: 'TEKGRID_active', value: 'active' },
-          { text: 'TEKGRID_inactive', value: 'inactive' },
-        ],
-        loadAll: true,
-        translate: ['text'],
-      });
-    });
-  });
-});

package/tests/unit/components/tek-grid/filter-helper.spec.ts

@@ -1,56 +0,0 @@
-import { DateHelper } from '@zeedhi/core';
-import { TekGridColumn, TekFilterHelper } from '../../../../src';
-
-// Mock the DateHelper module
-jest.mock('@zeedhi/core');
-
-describe('TekFilterHelper', () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('getLabel', () => {
-    it('should call DateHelper.getLabel with the provided name', () => {
-      const testName = 'testFilter';
-      const getLabelspy = jest.spyOn(DateHelper, 'getLabel');
-      TekFilterHelper.getLabel(testName);
-      expect(getLabelspy).toHaveBeenCalledWith(testName);
-    });
-  });
-
-  describe('getValue', () => {
-    it('should call DateHelper.getValue with name and column dateFormat', () => {
-      const testName = 'testValue';
-      const getValuespy = jest.spyOn(DateHelper, 'getValue');
-      const mockColumn = {
-        componentProps: {
-          dateFormat: 'YYYY-MM-DD'
-        }
-      } as TekGridColumn;
-
-      TekFilterHelper.getValue(testName, mockColumn);
-      expect(getValuespy).toHaveBeenCalledWith(testName, mockColumn.componentProps.dateFormat);
-    });
-  });
-
-  describe('register', () => {
-    it('should call DateHelper.register with provided parameters', () => {
-      const testName = 'testRegister';
-      const testLabel = 'Test Register';
-      const registerspy = jest.spyOn(DateHelper, 'register');
-      const testFn = () => new Date();
-
-      TekFilterHelper.register(testName, testLabel, testFn);
-      expect(registerspy).toHaveBeenCalledWith(testName, testLabel, testFn);
-    });
-  });
-
-  describe('unregister', () => {
-    it('should call DateHelper.unregister with the provided name', () => {
-      const testName = 'testUnregister';
-      const unregisterspy = jest.spyOn(DateHelper, 'unregister');
-      TekFilterHelper.unregister(testName);
-      expect(unregisterspy).toHaveBeenCalledWith(testName);
-    });
-  });
-});