feat(tests): add OdataQueryBuilder full test suite

- renamed OdataService to OdataQueryBuilderService
- add couple more tests in the GridOdataService to cover more scenarios

Author: Ghislain Beaulac

src/app/modules/angular-slickgrid/models/odataOption.interface.ts

@@ -2,13 +2,30 @@ import { BackendServiceOption } from './backendServiceOption.interface';
 import { CaseType } from './caseType';
 
 export interface OdataOption extends BackendServiceOption {
-    caseType?: CaseType;
-    top?: number;
-    skip?: number;
-    filter?: string;
-    filterBy?: any;
-    filterBySeparator?: string;
-    filterQueue?: any[];
-    orderBy?: string;
-    [key: string]: any;
+  /** What is the casing type to use? Typically that would be 1 of the following 2: camelCase or PascalCase */
+  caseType?: CaseType;
+
+  /** How many rows to pull? */
+  top?: number;
+
+  /** How many rows to skip on the pagination? */
+  skip?: number;
+
+  /** (alias to "filter") Filter string (or array of string) that must be a valid OData string */
+  filter?: string | string[];
+
+  /** Filter string (or array of string) that must be a valid OData string */
+  filterBy?: any;
+
+  /** What is separator between each filters? Typically "and", "or" */
+  filterBySeparator?: 'and' | 'or';
+
+  /** Filter queue */
+  filterQueue?: any[];
+
+  /** Sorting string (or array of string) that must be a valid OData string */
+  orderBy?: string | string[];
+
+  /** When accessed as an object */
+  [key: string]: any;
 }

src/app/modules/angular-slickgrid/services/__tests__/grid-odata.service.spec.ts

@@ -1,5 +1,4 @@
 import { CaseType } from './../../models/caseType';
-import { TranslateService } from '@ngx-translate/core';
 import { GridOdataService } from '../grid-odata.service';
 import {
   Column,
@@ -127,7 +126,7 @@ describe('GridOdataService', () => {
       expect(query).toBe(expectation);
     });
 
-    it('should be able to provide "orderBy" and see the query string include the sorting', () => {
+    it('should be able to provide "orderBy" through the "init" and see the query string include the sorting', () => {
       const expectation = `$top=20&$skip=40&$orderby=Name desc`;
       const columns = [{ id: 'field1', field: 'field1', width: 100 }, { id: 'field2', field: 'field2', width: 100 }];
 
@@ -138,16 +137,40 @@ describe('GridOdataService', () => {
       expect(query).toBe(expectation);
     });
 
-    it('should be able to provide "filter" and see the query string include the sorting', () => {
+    it('should be able to provide "orderBy" through the "updateOptions" and see the query string include the sorting', () => {
+      const expectation = `$top=20&$skip=40&$orderby=Name desc`;
+      const columns = [{ id: 'field1', field: 'field1', width: 100 }, { id: 'field2', field: 'field2', width: 100 }];
+
+      service.init({ columnDefinitions: columns }, paginationOptions, gridStub);
+      service.updatePagination(3, 20);
+      service.updateOptions({ orderBy: 'Name desc' });
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should be able to provide "filter" through the "init" and see the query string include the filter', () => {
       const expectation = `$top=20&$skip=40&$filter=(IsActive eq true)`;
       const columns = [{ id: 'field1', field: 'field1', width: 100 }, { id: 'field2', field: 'field2', width: 100 }];
 
-      service.init({ columnDefinitions: columns, filter: `IsActive eq true` }, paginationOptions, gridStub);
+      service.init({ columnDefinitions: columns, filterBy: `IsActive eq true` }, paginationOptions, gridStub);
       service.updatePagination(3, 20);
       const query = service.buildQuery();
 
       expect(query).toBe(expectation);
     });
+
+    it('should be able to provide "filter" through the "updateOptions" and see the query string include the filter', () => {
+      const expectation = `$top=20&$skip=40&$filter=(IsActive eq true)`;
+      const columns = [{ id: 'field1', field: 'field1', width: 100 }, { id: 'field2', field: 'field2', width: 100 }];
+
+      service.init({ columnDefinitions: columns }, paginationOptions, gridStub);
+      service.updatePagination(3, 20);
+      service.updateOptions({ filterBy: `IsActive eq true` });
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
   });
 
   describe('clearFilters method', () => {
@@ -571,8 +594,8 @@ describe('GridOdataService', () => {
       expect(query).toBe(expectation);
     });
 
-    it('should return a query with the new filter search value of empty string when searchTerms has an undefined value', () => {
-      const expectation = `$top=10&$filter=(Gender eq '')`;
+    it('should return a query without any filters when the "searchTerms" has an undefined value', () => {
+      const expectation = `$top=10`;
       const mockColumn = { id: 'gender', field: 'gender' } as Column;
       const mockColumnFilters = {
         gender: { columnId: 'gender', columnDef: mockColumn, searchTerms: [undefined], operator: 'EQ' },
@@ -585,6 +608,20 @@ describe('GridOdataService', () => {
       expect(query).toBe(expectation);
     });
 
+    it('should return a query without any filters when the "searchTerms" has an empty string', () => {
+      const expectation = `$top=10`;
+      const mockColumn = { id: 'gender', field: 'gender' } as Column;
+      const mockColumnFilters = {
+        gender: { columnId: 'gender', columnDef: mockColumn, searchTerms: [''], operator: 'EQ' },
+      } as ColumnFilters;
+
+      service.init(serviceOptions, paginationOptions, gridStub);
+      service.updateFilters(mockColumnFilters, false);
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
     it('should return a query using a different field to query when the column has a "queryField" defined in its definition', () => {
       const expectation = `$top=10&$filter=(IsMale eq true)`;
       const mockColumn = { id: 'gender', field: 'gender', type: FieldType.boolean, queryField: 'isMale' } as Column;

src/app/modules/angular-slickgrid/services/__tests__/odata.service.spec.ts

@@ -0,0 +1,223 @@
+import { CaseType } from '../../models/caseType';
+import { OdataQueryBuilderService } from '../odataQueryBuilder.service';
+import {
+  Column,
+  ColumnFilter,
+  ColumnSort,
+  CurrentFilter,
+  FilterChangedArgs,
+  GridOption,
+  MultiColumnSort,
+  Pagination,
+  ColumnFilters,
+  OperatorType,
+  FieldType,
+  CurrentSorter,
+  OdataOption,
+} from '../../models';
+
+const DEFAULT_ITEMS_PER_PAGE = 25;
+const DEFAULT_PAGE_SIZE = 20;
+
+const gridOptionMock = {
+  enablePagination: true,
+  backendServiceApi: {
+    service: undefined,
+    preProcess: jest.fn(),
+    process: jest.fn(),
+    postProcess: jest.fn(),
+  }
+} as GridOption;
+
+const gridStub = {
+  autosizeColumns: jest.fn(),
+  getColumnIndex: jest.fn(),
+  getScrollbarDimensions: jest.fn(),
+  getOptions: () => gridOptionMock,
+  getColumns: jest.fn(),
+  setColumns: jest.fn(),
+  registerPlugin: jest.fn(),
+  setSelectedRows: jest.fn(),
+  setSortColumns: jest.fn(),
+};
+
+describe('OdataService', () => {
+  let mockColumns: Column[];
+  let service: OdataQueryBuilderService;
+
+  beforeEach(() => {
+    mockColumns = [{ id: 'field1', field: 'field1', width: 100 }, { id: 'field2', field: 'field2', width: 100 }];
+    service = new OdataQueryBuilderService();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should create the service', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('buildQuery method', () => {
+    beforeEach(() => {
+      service.options = { filterQueue: [], orderBy: '' };
+    });
+
+    it('should throw an error when odata options are null', () => {
+      service.options = undefined;
+      expect(() => service.buildQuery()).toThrow();
+    });
+
+    it('should return a query with $top pagination', () => {
+      const expectation = '$top=25';
+
+      service.options = { top: 25 };
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should return a query with $top and $skip pagination', () => {
+      const expectation = '$top=25&$skip=10';
+
+      service.options = { top: 25, skip: 10 };
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should return a query with sorting when "orderBy" is provided as a string', () => {
+      const expectation = '$top=10&$orderby=Gender asc';
+
+      service.options = { top: 10, orderBy: 'Gender asc' };
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should return a query with sorting when "orderBy" is provided as an array', () => {
+      const expectation = '$top=10&$orderby=Gender asc,Company desc';
+
+      service.options = { top: 10, orderBy: ['Gender asc', 'Company desc'] };
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should return a query with sorting when "filter" is provided as a string', () => {
+      const expectation = `$top=10&$filter=(FirstName eq 'John')`;
+
+      service.options = { top: 10, filter: `FirstName eq 'John'` };
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should return a query with sorting when "filterBy" is provided as a string', () => {
+      const expectation = `$top=10&$filter=(FirstName eq 'John')`;
+
+      service.options = { top: 10, filterBy: `FirstName eq 'John'` };
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should return a query with sorting when "filterBy" is provided as an array', () => {
+      const expectation = `$top=10&$filter=(FirstName eq 'John' and FirstName eq 'Jane')`;
+
+      service.options = { top: 10, filter: [`FirstName eq 'John'`, `FirstName eq 'Jane'`] };
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should return a query with sorting when "filterBy" is provided as an array', () => {
+      const expectation = `$top=10&$filter=(FirstName eq 'John' or FirstName eq 'Jane')`;
+
+      service.options = { top: 10, filterBy: [`FirstName eq 'John'`, `FirstName eq 'Jane'`], filterBySeparator: 'or' };
+      const query = service.buildQuery();
+      const filterCount = service.getFilterCount();
+
+      expect(query).toBe(expectation);
+      expect(filterCount).toBe(2);
+    });
+  });
+
+  describe('saveColumnFilter method', () => {
+    it('should return "columnFilters" object with multiple properties as the filter names', () => {
+      service.saveColumnFilter('FirstName', 'John', ['John']);
+
+      const columnFilters = service.columnFilters;
+
+      expect(columnFilters).toEqual({ FirstName: { search: ['John'], value: 'John' } });
+    });
+
+    it('should return "columnFilters" object with multiple properties as the filter names', () => {
+      service.saveColumnFilter('FirstName', 'John', ['John']);
+      service.saveColumnFilter('LastName', 'Doe', ['Doe']);
+
+      const columnFilters = service.columnFilters;
+
+      expect(columnFilters).toEqual({
+        FirstName: { search: ['John'], value: 'John' },
+        LastName: { search: ['Doe'], value: 'Doe' }
+      });
+    });
+  });
+
+  describe('removeColumnFilter method', () => {
+    it('should return "columnFilters" object without the one deleted', () => {
+      service.saveColumnFilter('FirstName', 'John', ['John']);
+      service.saveColumnFilter('LastName', 'Doe', ['Doe']);
+
+      service.removeColumnFilter('LastName');
+      const columnFilters = service.columnFilters;
+
+      expect(columnFilters).toEqual({
+        FirstName: { search: ['John'], value: 'John' }
+      });
+    });
+  });
+
+  describe('updateOptions method', () => {
+    beforeEach(() => {
+      service.updateOptions({ caseType: CaseType.pascalCase });
+    });
+
+    it('should be able to provide "filterBy" array and expect see the query string include the filter', () => {
+      const expectation = `$filter=(FirstName eq 'John')`;
+
+      service.updateOptions({ filterBy: `FirstName eq 'John'` });
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should be able to provide "filterBy" array and expect see the query string include the filter', () => {
+      const expectation = `$filter=(FirstName eq 'John' and substring(Gender 'male')`;
+
+      service.updateOptions({ filterBy: [`FirstName eq 'John'`, `substring(Gender 'male'`] });
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should be able to provide "orderBy" array and expect see the query string include the filter', () => {
+      const expectation = `$orderby=FirstName desc`;
+
+      service.updateOptions({ orderBy: 'FirstName desc' });
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+
+    it('should be able to provide "orderBy" array and expect see the query string include the filter', () => {
+      const expectation = `$orderby=FirstName desc,LastName asc`;
+
+      service.updateOptions({ orderBy: ['FirstName desc', 'LastName asc'] });
+      const query = service.buildQuery();
+
+      expect(query).toBe(expectation);
+    });
+  });
+});