@zeedhi/teknisa-components-common 1.117.1 → 3.0.1

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

@@ -1,21 +1,22 @@
 /* eslint-disable no-underscore-dangle */
 
 import {
-  Button, Date, Form, IButton, IForm, IModal, ISelectMultiple, Modal, ModalService, SelectMultiple,
+  Button, Form, IButton, IForm, IModal, Modal, ModalService,
 } from '@zeedhi/common';
 import {
-  Http, Metadata, DateHelper, Config,
+  Http, Metadata, DateHelper,
+  Loader,
+  SimpleControllerBuilder,
 } from '@zeedhi/core';
 import {
-  IFilterPropsComponent,
   ITekGridFilterButton,
-  TekGrid, TekGridColumn, TekGridFilterButton, TekRestDatasource,
+  TekGrid, TekGridFilterButton, TekRestDatasource,
 } from '../../../../src';
-import { setClick, getChild } from '../../../__helpers__';
+import { flushPromises, getChild, setClick } from '../../__helpers__';
 
 jest.mock('lodash.debounce', () => jest.fn((fn) => fn));
 
-jest.useFakeTimers();
+// jest.useFakeTimers();
 
 const clickOnFilterButton = (grid: TekGrid, event?: any) => {
   const buttonProps = getChild<ITekGridFilterButton>(grid.toolbarSlot, `${grid.name}_filterButton`);
@@ -26,6 +27,10 @@ const clickOnFilterButton = (grid: TekGrid, event?: any) => {
 };
 
 describe('TekGridFilterButton', () => {
+  beforeAll(() => {
+    Loader.setBuilder(new SimpleControllerBuilder());
+  });
+
   beforeEach(() => {
     // clear all metadata instances before testing
     const { instances } = Metadata as any;
@@ -33,7 +38,7 @@ describe('TekGridFilterButton', () => {
       Metadata.clearInstance(key, instances[key].componentId);
     });
 
-    jest.clearAllTimers();
+    // jest.clearAllTimers();
   });
 
   describe('loadGrid()', () => {
@@ -92,6 +97,7 @@ describe('TekGridFilterButton', () => {
         name: 'grid_filterClick1',
         component: 'TekGrid',
       });
+      instance.onCreated();
 
       const formInstance = new Form({
         name: 'form',
@@ -105,11 +111,10 @@ describe('TekGridFilterButton', () => {
       const button = clickOnFilterButton(instance);
       button.onCreated();
 
-      expect(spy).toBeCalledTimes(1);
+      expect(spy).toHaveBeenCalledTimes(1);
       button.click();
-      expect(spy).toBeCalledTimes(1);
+      expect(spy).toHaveBeenCalledTimes(1);
       expect(button.isVisible).toBeFalsy();
-      (instance as any).gridBase.hideFilterModal();
 
       button.onBeforeDestroy();
 
@@ -153,7 +158,7 @@ describe('TekGridFilterButton', () => {
       clickOnFilterButton(instance, { defaultPrevented: true });
 
       expect(filterClickCalled).toBeTruthy();
-      expect(spy).not.toBeCalled();
+      expect(spy).not.toHaveBeenCalled();
 
       spy.mockReset();
     });
@@ -280,58 +285,6 @@ describe('TekGridFilterButton', () => {
       spy.mockReset();
     });
 
-    it('when creating a SelectMultiple filter, should change the filter value depending on checkboxAll', () => {
-      const instance = new TekGrid({
-        name: 'grid_filterClick5',
-        component: 'TekGrid',
-        columns: [
-          {
-            name: 'id',
-            filterable: true,
-            filterProps: [{
-              name: 'id_edit', label: 'id', component: 'ZdSelectMultiple', showCheckboxAll: false,
-            }],
-          },
-        ],
-      });
-
-      let form: IForm = { name: 'form', component: 'ZdForm' };
-      let select: ISelectMultiple = { name: 'select', component: 'ZdSelectMultiple' };
-      let applyButton: IButton = { name: 'apply', component: 'ZdButton' };
-      const spy = jest.spyOn(ModalService, 'create').mockImplementation((modal: IModal) => {
-        const modalFooter = getChild(modal.children || [], `${instance.name}-filter-footer`);
-        form = getChild(modal.children || [], `${instance.name}-filter-form`);
-        select = getChild(form.children || [], `${instance.name}-filter-AND-CONTAINS-id-0`);
-        applyButton = getChild(modalFooter.rightSlot, `${instance.name}-filter-okButton`);
-
-        return new Modal(modal);
-      });
-      instance.onCreated();
-      clickOnFilterButton(instance);
-      const applyButtonObject = new Button(applyButton);
-
-      const formObject = new Form(form);
-      const selectObject = new SelectMultiple(select);
-      jest.spyOn(Metadata, 'getInstance').mockReturnValue(formObject);
-      jest.spyOn(formObject, 'getChildInstance').mockReturnValue(selectObject);
-
-      formObject.value['grid_filterClick5-filter-AND-CONTAINS-id-0'] = ['example'];
-      setClick(applyButtonObject);
-
-      expect(instance.datasource.filter).toEqual({});
-
-      selectObject.checkboxAll = true;
-      setClick(applyButtonObject);
-
-      expect(instance.datasource.filter).toEqual({});
-
-      (Config as any).set({ selectAllCompatibilityMode: true });
-      setClick(applyButtonObject);
-      expect(instance.datasource.filter).toEqual({});
-
-      spy.mockReset();
-    });
-
     it('should create modal with filterable and ordered form elements', () => {
       const instance = new TekGrid({
         name: 'grid-filter-order',
@@ -482,171 +435,6 @@ describe('TekGridFilterButton', () => {
       dateHelperSpy.mockReset();
     });
 
-    it('should apply helper value', () => {
-      const instance = new TekGrid({
-        name: 'grid_filterClick8',
-        component: 'TekGrid',
-        datasource: {
-          type: 'tek-rest',
-          lazyLoad: true,
-        },
-        columns: [
-          {
-            name: 'date1',
-            componentProps: { name: 'date_edit1', component: 'ZdDate' },
-            filterProps: {
-              name: 'date_edit1',
-              label: 'date1',
-              operation: 'NOT_EQUALS',
-              relation: 'OR',
-              helperOptions: [
-                'TODAY',
-                'TOMORROW',
-              ],
-            },
-          },
-          {
-            name: 'date2',
-            componentProps: { name: 'date_edit2', component: 'ZdDate' },
-            filterProps: [
-              {
-                name: 'date_edit21',
-                label: 'date21',
-                operation: 'NOT_EQUALS',
-                relation: 'OR',
-                helperOptions: [
-                  'TODAY',
-                  'TOMORROW',
-                ],
-              },
-              {
-                name: 'date_edit22',
-                label: 'date22',
-                helperOptions: [
-                  'TODAY',
-                  'TOMORROW',
-                ],
-              },
-            ],
-          },
-        ],
-      });
-
-      let formElements: any = [];
-      let form: IForm;
-      const spy = jest.spyOn(ModalService, 'create').mockImplementation((modal: IModal) => {
-        form = getChild<IForm>(modal.children || [], `${instance.name}-filter-form`);
-        formElements = form.children;
-
-        return new Modal(modal);
-      });
-      instance.onCreated();
-      clickOnFilterButton(instance);
-
-      const dateComp = new Date(formElements[0]);
-      dateComp.helperValue = 'TODAY';
-      dateComp.changeEvent({} as Event, {} as HTMLElement);
-      expect((instance.columns[0].filterProps as IFilterPropsComponent).helperValue).toBe('TODAY');
-
-      const dateComp21 = new Date(formElements[1]);
-      dateComp21.helperValue = 'TODAY';
-      dateComp21.changeEvent({} as Event, {} as HTMLElement);
-      expect((instance.columns[1].filterProps as IFilterPropsComponent[])[0].helperValue).toBe('TODAY');
-
-      const dateComp22 = new Date(formElements[2]);
-      dateComp22.helperValue = 'TODAY';
-      dateComp22.changeEvent({} as Event, {} as HTMLElement);
-      expect((instance.columns[1].filterProps as IFilterPropsComponent[])[1].helperValue).toBe('TODAY');
-
-      spy.mockReset();
-    });
-
-    it('should load form values from tekdatasource', () => {
-      const instance = new TekGrid({
-        name: 'grid_filterClick9',
-        component: 'TekGrid',
-        datasource: {
-          type: 'tek-rest',
-          lazyLoad: true,
-          dynamicFilter: {
-            name: [
-              {
-                operation: 'NOT_EQUALS',
-                relation: 'OR',
-                value: 'teste',
-              },
-            ],
-            phone: [
-              {
-                value: '9',
-              },
-            ],
-            date: [
-              {
-                operation: 'IN',
-                relation: 'OR',
-                value: ['2021-11-12', '2021-12-12'],
-              },
-            ],
-          },
-        },
-        columns: [
-          {
-            name: 'id',
-            filterProps: [{ name: 'id_edit' }],
-          },
-          {
-            name: 'name',
-            componentProps: { name: 'name_edit', component: 'ZdSelect' },
-            filterProps: {
-              name: 'name_edit', label: 'name', operation: 'NOT_EQUALS', relation: 'OR',
-            },
-          },
-          {
-            name: 'phone',
-            filterProps: [{ name: 'phone_edit' }],
-          },
-          {
-            name: 'date',
-            filterProps: { name: 'date_edit', helperValue: 'TODAY' },
-          },
-        ],
-      });
-
-      let form: IForm = { name: 'form', component: 'ZdForm' };
-      const dateHelperSpy = jest.spyOn(DateHelper, 'getLabel').mockImplementation((name: string) => name);
-      const spy = jest.spyOn(ModalService, 'create').mockImplementation((modal: IModal) => {
-        form = getChild<IForm>(modal.children || [], `${instance.name}-filter-form`);
-
-        return new Modal(modal);
-      });
-      instance.onCreated();
-
-      clickOnFilterButton(instance);
-
-      expect(form.name).toBe('grid_filterClick9-filter-form');
-      const formObject = new Form(form);
-      formObject.value = {
-        'grid_filterClick9-filter-AND_CONTAINS-id-0': null,
-        'grid_filterClick9-filter-OR-NOT_EQUALS-name-0': null,
-        'grid_filterClick9-filter-AND-CONTAINS-phone-0': null,
-        'grid_filterClick9-filter-OR-IN-date-0': null,
-      };
-      const dateObject = new Date({ name: 'date', component: 'ZdDate' });
-      const spyMetadata = jest.spyOn(Metadata, 'getInstances').mockImplementation(() => [dateObject]);
-      formObject.onMounted({} as HTMLElement);
-      expect(formObject.value).toEqual({
-        'grid_filterClick9-filter-AND_CONTAINS-id-0': null,
-        'grid_filterClick9-filter-OR-NOT_EQUALS-name-0': 'teste',
-        'grid_filterClick9-filter-AND-CONTAINS-phone-0': '9',
-        'grid_filterClick9-filter-OR-IN-date-0': ['2021-11-12', '2021-12-12'],
-      });
-      expect(dateObject.hint).toBe('TODAY');
-      spyMetadata.mockReset();
-      dateHelperSpy.mockReset();
-      spy.mockReset();
-    });
-
     it('should load form values from datasource', () => {
       const instance = new TekGrid({
         name: 'grid_filterClick10',
@@ -690,7 +478,7 @@ describe('TekGridFilterButton', () => {
       spy.mockReset();
     });
 
-    it('should apply filter from form to tekdatasource', () => {
+    it('should apply filter from form to tekdatasource', async () => {
       const httpSpy = jest.spyOn(Http, 'get').mockImplementation(() => Promise.resolve({
         data: {
           data: [
@@ -756,6 +544,8 @@ describe('TekGridFilterButton', () => {
       const button = new TekGridFilterButton(buttonProps);
       setClick(button);
 
+      await flushPromises();
+
       const formObject = new Form(form);
       const spyMetadata = jest.spyOn(Metadata, 'getInstance').mockImplementation(() => formObject);
       const spyDatasourceGet = jest.spyOn(instance.datasource, 'get');
@@ -767,12 +557,23 @@ describe('TekGridFilterButton', () => {
         'grid_filterClick11-filter-AND-LESS_THAN_EQUALS-salary-0': '2000',
       };
       const applyButtonObject = new Button(applyButton);
-      formObject.validate = () => false;
+      formObject.validate = () => {
+        return new Promise((resolve) => {
+          resolve({ valid: false });
+        });
+      };
       setClick(applyButtonObject);
       expect((instance.datasource as TekRestDatasource).dynamicFilter).toEqual({});
 
-      formObject.validate = () => true;
+      formObject.validate = () => {
+        return new Promise((resolve) => {
+          resolve({ valid: true });
+        });
+      };
       setClick(applyButtonObject);
+
+      await flushPromises();
+
       expect((instance.datasource as TekRestDatasource).dynamicFilter).toEqual({
         id: [
           {
@@ -801,8 +602,8 @@ describe('TekGridFilterButton', () => {
           },
         ],
       });
-      expect(instance.columnHasFilterData({ name: 'name' } as TekGridColumn)).toBeTruthy();
-      expect(spyDatasourceGet).toBeCalled();
+      expect(instance.columnHasFilter('name')).toBeTruthy();
+      expect(spyDatasourceGet).toHaveBeenCalled();
       spyMetadata.mockReset();
       spyDatasourceGet.mockReset();
       spyModalService.mockReset();
@@ -900,7 +701,7 @@ describe('TekGridFilterButton', () => {
       httpSpy.mockReset();
     });
 
-    it('should apply filter from form to datasource', () => {
+    it('should apply filter from form to datasource', async () => {
       let beforeApplyFilterCalled = false;
       let changeLayoutCalled = false;
       const instance = new TekGrid({
@@ -926,6 +727,8 @@ describe('TekGridFilterButton', () => {
         },
       });
 
+      instance.onCreated();
+
       let form: IForm = { name: 'form', component: 'ZdForm' };
       let applyButton: IButton = { name: 'apply', component: 'ZdButton' };
       const spyModalService = jest.spyOn(ModalService, 'create').mockImplementation((modal: IModal) => {
@@ -937,8 +740,6 @@ describe('TekGridFilterButton', () => {
         return new Modal(modal);
       });
 
-      instance.onCreated();
-
       clickOnFilterButton(instance);
 
       const formObject = new Form(form);
@@ -952,16 +753,90 @@ describe('TekGridFilterButton', () => {
       };
       const applyButtonObject = new Button(applyButton);
       setClick(applyButtonObject);
-      expect(instance.datasource.filter).toEqual({});
+
+      await flushPromises();
+
+      expect(instance.datasource.filter).toEqual({
+        id: '1;2;3',
+        name: 'teste',
+        salary: '1000',
+      });
       expect(beforeApplyFilterCalled).toBeTruthy();
       expect(changeLayoutCalled).toBeTruthy();
-      expect(instance.columnHasFilterData({ name: 'name' } as TekGridColumn)).toBe(undefined);
+      expect(instance.columnHasFilter('name')).toBeTruthy();
 
       setClick(applyButtonObject, { defaultPrevented: true });
-      expect(spyDatasourceGet).toBeCalledTimes(1);
+      expect(spyDatasourceGet).toHaveBeenCalledTimes(1);
       spyMetadata.mockReset();
       spyDatasourceGet.mockReset();
       spyModalService.mockReset();
     });
+
+    it('should load form values from tekdatasource', () => {
+      const instance = new TekGrid({
+        name: 'grid_filterClick9',
+        component: 'TekGrid',
+        datasource: {
+          type: 'tek-rest',
+          lazyLoad: true,
+          dynamicFilter: {
+            name: [
+              {
+                operation: 'NOT_EQUALS',
+                relation: 'OR',
+                value: 'teste',
+              },
+            ],
+            phone: [
+              {
+                value: '9',
+              },
+            ],
+          },
+        },
+        columns: [
+          {
+            name: 'id',
+            filterProps: [{ name: 'id_edit' }],
+          },
+          {
+            name: 'name',
+            componentProps: { name: 'name_edit', component: 'ZdSelect' },
+            filterProps: {
+              name: 'name_edit', label: 'name', operation: 'NOT_EQUALS', relation: 'OR',
+            },
+          },
+          {
+            name: 'phone',
+            filterProps: [{ name: 'phone_edit' }],
+          },
+        ],
+      });
+
+      let form: IForm = { name: 'form', component: 'ZdForm' };
+      const spy = jest.spyOn(ModalService, 'create').mockImplementation((modal: IModal) => {
+        form = getChild<IForm>(modal.children || [], `${instance.name}-filter-form`);
+
+        return new Modal(modal);
+      });
+      instance.onCreated();
+
+      clickOnFilterButton(instance);
+
+      expect(form.name).toBe('grid_filterClick9-filter-form');
+      const formObject = new Form(form);
+      formObject.value = {
+        'grid_filterClick9-filter-AND_CONTAINS-id-0': null,
+        'grid_filterClick9-filter-OR-NOT_EQUALS-name-0': null,
+        'grid_filterClick9-filter-AND-CONTAINS-phone-0': null,
+      };
+      formObject.onMounted({} as HTMLElement);
+      expect(formObject.value).toEqual({
+        'grid_filterClick9-filter-AND_CONTAINS-id-0': null,
+        'grid_filterClick9-filter-OR-NOT_EQUALS-name-0': 'teste',
+        'grid_filterClick9-filter-AND-CONTAINS-phone-0': '9',
+      });
+      spy.mockReset();
+    });
   });
 });