@zeedhi/common 1.112.0 → 3.0.0

package/tests/unit/__helpers__/mock-i18n.ts

@@ -0,0 +1,13 @@
+import { I18n, IDictionary } from "@zeedhi/core";
+
+const translateFn = function translateFn(message: string | string[], variables?: IDictionary<any>) {
+  const messageVar = variables ? `: vars ${Object.keys(variables).join(', ')}` : '';
+  const messageString = Array.isArray(message) ? message.join(', ') : message;
+  return messageString + messageVar;
+};
+
+const mockI18n = () => {
+  jest.spyOn(I18n, 'translate').mockImplementation(translateFn);
+}
+
+export { mockI18n };

package/tests/unit/__helpers__/mock-loader-get-instance.ts

@@ -0,0 +1,6 @@
+import { IDictionary, Loader } from '@zeedhi/core';
+
+const mockLoaderGetInstance = (controller: IDictionary) => jest.spyOn(Loader, 'getInstance')
+  .mockImplementation(() => controller);
+
+export { mockLoaderGetInstance };

package/tests/unit/__helpers__/mock-loader-value-accessor.ts

@@ -0,0 +1,7 @@
+import { IDictionary, Loader } from '@zeedhi/core';
+
+const mockLoaderValueAccessor = (controller: IDictionary) => jest
+  .spyOn(Loader, 'getInstance')
+  .mockImplementation(() => controller);
+
+export { mockLoaderValueAccessor };

package/tests/unit/__helpers__/spy-on-all-methods.ts

@@ -0,0 +1,46 @@
+import { IDictionary } from "@zeedhi/core";
+
+// add a spy on all methods from a class prototype
+const spyOnAllMethods = (
+  prototype: any,
+  mockImplementations: IDictionary = {},
+  alreadySpiedMethods: Set<string> = new Set(),
+  depth: number = 0,
+  maxDepth: number = 10 // Safety limit
+) => {
+  // Safety check against infinite recursion
+  if (depth > maxDepth || prototype === null || prototype === Object.prototype) {
+    return {};
+  }
+
+  const methods = Object.getOwnPropertyNames(prototype).filter(
+    (prop) => typeof prototype[prop] === 'function' && prop !== 'constructor'
+  );
+
+  const spyObj: IDictionary<jest.SpyInstance> = {};
+
+  methods.forEach((method) => {
+    if (!alreadySpiedMethods.has(method)) {
+      const mockImplementation = mockImplementations[method] || jest.fn();
+      spyObj[method] = jest.spyOn(prototype, method).mockImplementation(mockImplementation);
+      alreadySpiedMethods.add(method);
+    }
+  });
+
+  // Get the parent prototype carefully
+  const parentPrototype = Object.getPrototypeOf(prototype);
+  if (parentPrototype && parentPrototype !== prototype) { // Additional check to prevent cycles
+    const parentSpyObj = spyOnAllMethods(
+      parentPrototype,
+      mockImplementations,
+      alreadySpiedMethods,
+      depth + 1,
+      maxDepth
+    );
+    Object.assign(spyObj, parentSpyObj);
+  }
+
+  return spyObj;
+};
+
+export { spyOnAllMethods };

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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,112 @@
+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

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,52 @@
+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';
+      TekFilterHelper.getLabel(testName);
+      expect(DateHelper.getLabel).toHaveBeenCalledWith(testName);
+    });
+  });
+
+  describe('getValue', () => {
+    it('should call DateHelper.getValue with name and column dateFormat', () => {
+      const testName = 'testValue';
+      const mockColumn = {
+        componentProps: {
+          dateFormat: 'YYYY-MM-DD'
+        }
+      } as TekGridColumn;
+
+      TekFilterHelper.getValue(testName, mockColumn);
+      expect(DateHelper.getValue).toHaveBeenCalledWith(testName, mockColumn.componentProps.dateFormat);
+    });
+  });
+
+  describe('register', () => {
+    it('should call DateHelper.register with provided parameters', () => {
+      const testName = 'testRegister';
+      const testLabel = 'Test Register';
+      const testFn = () => new Date();
+
+      TekFilterHelper.register(testName, testLabel, testFn);
+      expect(DateHelper.register).toHaveBeenCalledWith(testName, testLabel, testFn);
+    });
+  });
+
+  describe('unregister', () => {
+    it('should call DateHelper.unregister with the provided name', () => {
+      const testName = 'testUnregister';
+      TekFilterHelper.unregister(testName);
+      expect(DateHelper.unregister).toHaveBeenCalledWith(testName);
+    });
+  });
+});