@orchestrator-ui/orchestrator-ui-components 7.4.0 → 7.5.0

package/src/components/WfoTable/WfoTableWithFilter/updateQueryString.ts

@@ -3,58 +3,47 @@
 // 2 - queryString is empty
 // 3 - fieldName does not exist in query string
 // 4 - fieldName already exists in query string
-export const updateQueryString = (
-    queryString: string,
-    fieldName: string,
-    value: string,
-) => {
-    // 1 - Returning the exising query string when either fieldName or value is empty
-    if (fieldName === '' || value === '') {
-        return queryString;
-    }
+export const updateQueryString = (queryString: string, fieldName: string, value: string) => {
+  // 1 - Returning the exising query string when either fieldName or value is empty
+  if (fieldName === '' || value === '') {
+    return queryString;
+  }
 
-    // 2 - Empty query string returning directly fieldName:value
-    if (queryString === '') {
-        return `${fieldName}:${toQueryValue(value)}`;
-    }
+  // 2 - Empty query string returning directly fieldName:value
+  if (queryString === '') {
+    return `${fieldName}:${toQueryValue(value)}`;
+  }
 
-    // Finding fieldName with values in queryString in this order:
-    // - Value surrounded with double quotes
-    // field:"value"
-    // - Value is surrounded with brackets
-    // field:(value1|value2)
-    // field:("value1 with spaces"|value2|value3)
-    // - Value is a single word (no quotes and no brackets)
-    // field:value
-    const fieldRegex = new RegExp(
-        String.raw`(${fieldName}):(".*?"|\(.*?\)|[^()|!:<>*"\s]+\*?)`,
-        'i',
-    );
-    const match = queryString.match(fieldRegex);
+  // Finding fieldName with values in queryString in this order:
+  // - Value surrounded with double quotes
+  // field:"value"
+  // - Value is surrounded with brackets
+  // field:(value1|value2)
+  // field:("value1 with spaces"|value2|value3)
+  // - Value is a single word (no quotes and no brackets)
+  // field:value
+  const fieldRegex = new RegExp(String.raw`(${fieldName}):(".*?"|\(.*?\)|[^()|!:<>*"\s]+\*?)`, 'i');
+  const match = queryString.match(fieldRegex);
 
-    // 3 - Field name does not exist in query string yet, appending fieldName:value
-    if (!match) {
-        return `${queryString} ${fieldName}:${toQueryValue(value)}`;
-    }
+  // 3 - Field name does not exist in query string yet, appending fieldName:value
+  if (!match) {
+    return `${queryString} ${fieldName}:${toQueryValue(value)}`;
+  }
 
-    // 4 - Field name already exists in query string as:
-    const existingFieldName = match[1];
-    const existingValue = getValueWithoutBrackets(match[2]);
-    const updatedValue = `${existingValue}|${toQueryValue(value)}`;
-    return queryString.replace(
-        fieldRegex,
-        `${existingFieldName}:(${updatedValue})`,
-    );
+  // 4 - Field name already exists in query string as:
+  const existingFieldName = match[1];
+  const existingValue = getValueWithoutBrackets(match[2]);
+  const updatedValue = `${existingValue}|${toQueryValue(value)}`;
+  return queryString.replace(fieldRegex, `${existingFieldName}:(${updatedValue})`);
 };
 
 const getValueWithoutBrackets = (value: string) => {
-    if (value.startsWith('(') && value.endsWith(')')) {
-        return value.slice(1, -1);
-    }
-    return value;
+  if (value.startsWith('(') && value.endsWith(')')) {
+    return value.slice(1, -1);
+  }
+  return value;
 };
 
 const hasSpaces = (value: string) => value.indexOf(' ') !== -1;
 
-const toQueryValue = (value: string) =>
-    hasSpaces(value) ? `"${value}"` : value;
+const toQueryValue = (value: string) => (hasSpaces(value) ? `"${value}"` : value);

package/src/components/WfoTable/utils/columns.spec.ts

@@ -2,22 +2,22 @@ import { SortOrder } from '../../../types';
 import { getSortDirectionFromString } from './columns';
 
 describe('columns', () => {
-    describe('getSortOrderFromString', () => {
-        it('returns undefined if sortOrder is undefined', () => {
-            const result = getSortDirectionFromString(undefined);
-            expect(result).toBeUndefined();
-        });
-        it('returns SortDirection.Asc if sortOrder is "asc"', () => {
-            const result = getSortDirectionFromString('asc');
-            expect(result).toEqual(SortOrder.ASC);
-        });
-        it('returns SortDirection.Desc if sortOrder is "desc"', () => {
-            const result = getSortDirectionFromString('desc');
-            expect(result).toEqual(SortOrder.DESC);
-        });
-        it('returns undefined if sortOrder is anything other than "asc" or "desc', () => {
-            const result = getSortDirectionFromString('somethingElse');
-            expect(result).toBeUndefined();
-        });
+  describe('getSortOrderFromString', () => {
+    it('returns undefined if sortOrder is undefined', () => {
+      const result = getSortDirectionFromString(undefined);
+      expect(result).toBeUndefined();
     });
+    it('returns SortDirection.Asc if sortOrder is "asc"', () => {
+      const result = getSortDirectionFromString('asc');
+      expect(result).toEqual(SortOrder.ASC);
+    });
+    it('returns SortDirection.Desc if sortOrder is "desc"', () => {
+      const result = getSortDirectionFromString('desc');
+      expect(result).toEqual(SortOrder.DESC);
+    });
+    it('returns undefined if sortOrder is anything other than "asc" or "desc', () => {
+      const result = getSortDirectionFromString('somethingElse');
+      expect(result).toBeUndefined();
+    });
+  });
 });

package/src/components/WfoTable/utils/columns.ts

@@ -5,28 +5,26 @@ export const WFO_STATUS_COLOR_FIELD = 'statusColorField';
 export type TableColumnKeys<T> = Array<keyof T>;
 
 export type WfoDataSorting<T> = {
-    field: keyof T;
-    sortOrder: SortOrder;
+  field: keyof T;
+  sortOrder: SortOrder;
 };
 
 export type WfoDataSearch<T> = {
-    field: keyof T;
-    searchText: string;
+  field: keyof T;
+  searchText: string;
 };
 
-export const getSortDirectionFromString = (
-    sortOrder?: string,
-): SortOrder | undefined => {
-    if (!sortOrder) {
-        return undefined;
-    }
+export const getSortDirectionFromString = (sortOrder?: string): SortOrder | undefined => {
+  if (!sortOrder) {
+    return undefined;
+  }
 
-    switch (sortOrder.toUpperCase()) {
-        case SortOrder.ASC.toString():
-            return SortOrder.ASC;
-        case SortOrder.DESC.toString():
-            return SortOrder.DESC;
-        default:
-            return undefined;
-    }
+  switch (sortOrder.toUpperCase()) {
+    case SortOrder.ASC.toString():
+      return SortOrder.ASC;
+    case SortOrder.DESC.toString():
+      return SortOrder.DESC;
+    default:
+      return undefined;
+  }
 };

package/src/components/WfoTable/utils/constants.ts

@@ -1,23 +1,17 @@
 export const DEFAULT_PAGE_SIZES = [5, 10, 15, 20, 25, 50, 100];
 export const DEFAULT_PAGE_SIZE = 15;
 export const PAGE_SIZES_INCLUDING_SHOW_ALL = [...DEFAULT_PAGE_SIZES, 0];
-export const ACTIVE_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY =
-    'activeProcessesListTable';
-export const COMPLETED_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY =
-    'completedProcessesListTable';
+export const ACTIVE_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY = 'activeProcessesListTable';
+export const COMPLETED_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY = 'completedProcessesListTable';
 
 export const ACTIVE_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY = 'activeTasksListTable';
-export const COMPLETED_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY =
-    'completedTasksListTable';
+export const COMPLETED_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY = 'completedTasksListTable';
 
-export const METADATA_RESOURCE_TYPES_TABLE_LOCAL_STORAGE_KEY =
-    'metadataResourceTypesTable';
-export const METADATA_PRODUCT_BLOCKS_TABLE_LOCAL_STORAGE_KEY =
-    'metadataProductBlocksTable';
+export const METADATA_RESOURCE_TYPES_TABLE_LOCAL_STORAGE_KEY = 'metadataResourceTypesTable';
+export const METADATA_PRODUCT_BLOCKS_TABLE_LOCAL_STORAGE_KEY = 'metadataProductBlocksTable';
 export const METADATA_PRODUCT_TABLE_LOCAL_STORAGE_KEY = 'metadataProductTable';
 export const METADATA_SCHEDULES_LOCAL_STORAGE_KEY = 'metadataScheduleTable';
-export const METADATA_WORKFLOWS_TABLE_LOCAL_STORAGE_KEY =
-    'metadataWorkflowsTable';
+export const METADATA_WORKFLOWS_TABLE_LOCAL_STORAGE_KEY = 'metadataWorkflowsTable';
 export const METADATA_TASKS_TABLE_LOCAL_STORAGE_KEY = 'metadataTasksTable';
 
 export const SUBSCRIPTIONS_TABLE_LOCAL_STORAGE_KEY = 'subscriptionsTable';

package/src/components/WfoTable/utils/tableConfigPersistence.spec.ts

@@ -1,80 +1,80 @@
 import {
-    StoredTableConfig,
-    getTableConfigFromLocalStorage,
-    isValidLocalStorageTableConfig,
+  StoredTableConfig,
+  getTableConfigFromLocalStorage,
+  isValidLocalStorageTableConfig,
 } from './tableConfigPersistence';
 
 // Note: for some testcases a typecast is needed on the testObject to bypass TSC errors
 describe('tableConfigPersistence', () => {
-    describe('isValidLocalStorageTableConfig', () => {
-        it('returns true if the input-object does contain LocalStorageTableConfig properties', () => {
-            const testObject: StoredTableConfig<unknown> = {
-                hiddenColumns: [],
-                selectedPageSize: 10,
-            };
-            const result = isValidLocalStorageTableConfig(testObject);
-            expect(result).toEqual(true);
-        });
+  describe('isValidLocalStorageTableConfig', () => {
+    it('returns true if the input-object does contain LocalStorageTableConfig properties', () => {
+      const testObject: StoredTableConfig<unknown> = {
+        hiddenColumns: [],
+        selectedPageSize: 10,
+      };
+      const result = isValidLocalStorageTableConfig(testObject);
+      expect(result).toEqual(true);
+    });
 
-        it('returns false if the input-object contains undefined properties of the LocalStorageTableConfig type', () => {
-            const testObject = {
-                hiddenColumns: undefined,
-                selectedPageSize: undefined,
-            } as unknown as StoredTableConfig<unknown>;
-            const result = isValidLocalStorageTableConfig(testObject);
-            expect(result).toEqual(false);
-        });
+    it('returns false if the input-object contains undefined properties of the LocalStorageTableConfig type', () => {
+      const testObject = {
+        hiddenColumns: undefined,
+        selectedPageSize: undefined,
+      } as unknown as StoredTableConfig<unknown>;
+      const result = isValidLocalStorageTableConfig(testObject);
+      expect(result).toEqual(false);
+    });
 
-        it('returns false if the input-object does not contain LocalStorageTableConfig properties', () => {
-            const testObject = {} as StoredTableConfig<unknown>;
-            const result = isValidLocalStorageTableConfig(testObject);
-            expect(result).toEqual(false);
-        });
+    it('returns false if the input-object does not contain LocalStorageTableConfig properties', () => {
+      const testObject = {} as StoredTableConfig<unknown>;
+      const result = isValidLocalStorageTableConfig(testObject);
+      expect(result).toEqual(false);
     });
+  });
 
-    describe('getTableConfigFromLocalStorage', () => {
-        it('returns the tableConfig from LocalStorage when it is valid', () => {
-            // given
-            const testObject = {
-                hiddenColumns: [],
-                selectedPageSize: 10,
-            };
-            localStorage.removeItem('testCase1');
-            localStorage.setItem('testCase1', JSON.stringify(testObject));
+  describe('getTableConfigFromLocalStorage', () => {
+    it('returns the tableConfig from LocalStorage when it is valid', () => {
+      // given
+      const testObject = {
+        hiddenColumns: [],
+        selectedPageSize: 10,
+      };
+      localStorage.removeItem('testCase1');
+      localStorage.setItem('testCase1', JSON.stringify(testObject));
 
-            // when
-            const result = getTableConfigFromLocalStorage<unknown>('testCase1');
+      // when
+      const result = getTableConfigFromLocalStorage<unknown>('testCase1');
 
-            // then
-            expect(result).toEqual(testObject);
-        });
+      // then
+      expect(result).toEqual(testObject);
+    });
 
-        it('returns the undefined when the object in local storage is not a valid tableConfig', () => {
-            // given
-            const testObject = {
-                hiddenColumns: undefined,
-            };
-            localStorage.removeItem('testCase2');
-            localStorage.setItem('testCase2', JSON.stringify(testObject));
+    it('returns the undefined when the object in local storage is not a valid tableConfig', () => {
+      // given
+      const testObject = {
+        hiddenColumns: undefined,
+      };
+      localStorage.removeItem('testCase2');
+      localStorage.setItem('testCase2', JSON.stringify(testObject));
 
-            // when
-            const result = getTableConfigFromLocalStorage<unknown>('testCase2');
+      // when
+      const result = getTableConfigFromLocalStorage<unknown>('testCase2');
 
-            // then
-            expect(result).toEqual(undefined);
-        });
+      // then
+      expect(result).toEqual(undefined);
+    });
 
-        it('returns the undefined when the object in local storage is not valid json', () => {
-            // given
-            const testObject = '{ invalid json " ';
-            localStorage.removeItem('testCase3');
-            localStorage.setItem('testCase3', JSON.stringify(testObject));
+    it('returns the undefined when the object in local storage is not valid json', () => {
+      // given
+      const testObject = '{ invalid json " ';
+      localStorage.removeItem('testCase3');
+      localStorage.setItem('testCase3', JSON.stringify(testObject));
 
-            // when
-            const result = getTableConfigFromLocalStorage<unknown>('testCase3');
+      // when
+      const result = getTableConfigFromLocalStorage<unknown>('testCase3');
 
-            // then
-            expect(result).toEqual(undefined);
-        });
+      // then
+      expect(result).toEqual(undefined);
     });
+  });
 });

package/src/components/WfoTable/utils/tableConfigPersistence.ts

@@ -1,42 +1,33 @@
 import { TableColumnKeys } from './columns';
 
 export type StoredTableConfig<T> = {
-    hiddenColumns: TableColumnKeys<T>;
-    selectedPageSize: number;
+  hiddenColumns: TableColumnKeys<T>;
+  selectedPageSize: number;
 };
 
-export const isValidLocalStorageTableConfig = <T>(
-    object: StoredTableConfig<T>,
-): object is StoredTableConfig<T> =>
-    typeof object === 'object' &&
-    'hiddenColumns' in object &&
-    object.hiddenColumns !== undefined &&
-    'selectedPageSize' in object &&
-    object.selectedPageSize !== undefined;
+export const isValidLocalStorageTableConfig = <T>(object: StoredTableConfig<T>): object is StoredTableConfig<T> =>
+  typeof object === 'object'
+  && 'hiddenColumns' in object
+  && object.hiddenColumns !== undefined
+  && 'selectedPageSize' in object
+  && object.selectedPageSize !== undefined;
 
-export const getTableConfigFromLocalStorage = <T>(
-    key: string,
-): StoredTableConfig<T> | undefined => {
-    if (typeof window !== 'undefined' && window.localStorage) {
-        const parsedJson = JSON.parse(localStorage.getItem(key) ?? '{}');
-        return isValidLocalStorageTableConfig(parsedJson)
-            ? parsedJson
-            : undefined;
-    }
-    return undefined;
+export const getTableConfigFromLocalStorage = <T>(key: string): StoredTableConfig<T> | undefined => {
+  if (typeof window !== 'undefined' && window.localStorage) {
+    const parsedJson = JSON.parse(localStorage.getItem(key) ?? '{}');
+    return isValidLocalStorageTableConfig(parsedJson) ? parsedJson : undefined;
+  }
+  return undefined;
 };
 
-export const setTableConfigToLocalStorage = <T>(
-    key: string,
-    updatedTableConfig: StoredTableConfig<T>,
-) => {
-    if (typeof window !== 'undefined' && window.localStorage) {
-        localStorage.setItem(key, JSON.stringify(updatedTableConfig));
-    }
+export const setTableConfigToLocalStorage = <T>(key: string, updatedTableConfig: StoredTableConfig<T>) => {
+  if (typeof window !== 'undefined' && window.localStorage) {
+    localStorage.setItem(key, JSON.stringify(updatedTableConfig));
+  }
 };
 
 export const clearTableConfigFromLocalStorage = (key: string) => {
-    if (typeof window !== 'undefined' && window.localStorage) {
-        localStorage.removeItem(key);
-    }
+  if (typeof window !== 'undefined' && window.localStorage) {
+    localStorage.removeItem(key);
+  }
 };

package/src/components/WfoTable/utils/tableUtils.spec.ts

@@ -1,135 +1,118 @@
 import { Pagination } from '@/components';
 
 import { SortOrder } from '../../../types';
-import {
-    determineNewSortOrder,
-    determinePageIndex,
-    getPageCount,
-    hasSpecialCharacterOrSpace,
-} from './tableUtils';
+import { determineNewSortOrder, determinePageIndex, getPageCount, hasSpecialCharacterOrSpace } from './tableUtils';
 
 describe('tableUtils', () => {
-    describe('determinePageIndex()', () => {
-        it('returns page 0', () => {
-            const result = determinePageIndex(9, 10);
-            expect(result).toEqual(0);
-        });
-
-        it('returns page 1', () => {
-            const result = determinePageIndex(10, 10);
-            expect(result).toEqual(1);
-        });
-
-        it('returns page 1', () => {
-            const result = determinePageIndex(11, 10);
-            expect(result).toEqual(1);
-        });
+  describe('determinePageIndex()', () => {
+    it('returns page 0', () => {
+      const result = determinePageIndex(9, 10);
+      expect(result).toEqual(0);
     });
 
-    describe('determineNewSortOrder', () => {
-        type TestData = {
-            column1: object;
-            column2: object;
-        };
-
-        it('returns SortDirection.Asc when sorting on a new column', () => {
-            const currentSortColumnId = 'column1';
-            const currentSortDirection = SortOrder.ASC;
-            const newSortColumnId = 'column2';
-
-            const result = determineNewSortOrder<TestData>(
-                currentSortColumnId,
-                currentSortDirection,
-                newSortColumnId,
-            );
-
-            expect(result).toEqual(SortOrder.ASC);
-        });
-
-        it('returns SortDirection.Asc when sorting on the same column with SortDirection.Desc', () => {
-            const currentSortColumnId = 'column1';
-            const currentSortDirection = SortOrder.DESC;
-            const newSortColumnId = 'column1';
-
-            const result = determineNewSortOrder<TestData>(
-                currentSortColumnId,
-                currentSortDirection,
-                newSortColumnId,
-            );
-
-            expect(result).toEqual(SortOrder.ASC);
-        });
-
-        it('returns SortDirection.Desc when sorting on the same column with SortDirection.Asc', () => {
-            const currentSortColumnId = 'column1';
-            const currentSortDirection = SortOrder.DESC;
-            const newSortColumnId = 'column1';
-
-            const result = determineNewSortOrder<TestData>(
-                currentSortColumnId,
-                currentSortDirection,
-                newSortColumnId,
-            );
-
-            expect(result).toEqual(SortOrder.ASC);
-        });
+    it('returns page 1', () => {
+      const result = determinePageIndex(10, 10);
+      expect(result).toEqual(1);
     });
 
-    describe('hasSpecialCharacterOrSpace', () => {
-        it('should return true for strings with special characters', () => {
-            expect(hasSpecialCharacterOrSpace('hello@world')).toBe(true);
-            expect(hasSpecialCharacterOrSpace('hello#world')).toBe(true);
-            expect(hasSpecialCharacterOrSpace('hello!world')).toBe(true);
-        });
-
-        it('should return true for strings with spaces', () => {
-            expect(hasSpecialCharacterOrSpace('hello world')).toBe(true);
-            expect(hasSpecialCharacterOrSpace('hello  world')).toBe(true);
-        });
-
-        it('should return false for strings with only alphanumeric characters', () => {
-            expect(hasSpecialCharacterOrSpace('helloworld')).toBe(false);
-            expect(hasSpecialCharacterOrSpace('hello123')).toBe(false);
-            expect(hasSpecialCharacterOrSpace('123456')).toBe(false);
-        });
-
-        it('should return true for strings with mixed alphanumeric and special characters', () => {
-            expect(hasSpecialCharacterOrSpace('hello123@world')).toBe(true);
-            expect(hasSpecialCharacterOrSpace('123#world')).toBe(true);
-        });
-
-        it('should return false for empty strings', () => {
-            expect(hasSpecialCharacterOrSpace('')).toBe(false);
-        });
-
-        it('should return true for strings with only special characters', () => {
-            expect(hasSpecialCharacterOrSpace('@#$%^&*')).toBe(true);
-        });
+    it('returns page 1', () => {
+      const result = determinePageIndex(11, 10);
+      expect(result).toEqual(1);
     });
+  });
 
-    describe('getPageCount', () => {
-        it('returns the page count', () => {
-            const pagination: Pagination = {
-                pageIndex: 0,
-                pageSize: 10,
-                totalItemCount: 101,
-            };
+  describe('determineNewSortOrder', () => {
+    type TestData = {
+      column1: object;
+      column2: object;
+    };
 
-            const result = getPageCount(pagination);
+    it('returns SortDirection.Asc when sorting on a new column', () => {
+      const currentSortColumnId = 'column1';
+      const currentSortDirection = SortOrder.ASC;
+      const newSortColumnId = 'column2';
 
-            expect(result).toEqual(11);
-        });
+      const result = determineNewSortOrder<TestData>(currentSortColumnId, currentSortDirection, newSortColumnId);
 
-        it('returns the current page as value when the current page is out of range', () => {
-            const pagination: Pagination = {
-                pageIndex: 50,
-                pageSize: 10,
-                totalItemCount: 101,
-            };
+      expect(result).toEqual(SortOrder.ASC);
+    });
+
+    it('returns SortDirection.Asc when sorting on the same column with SortDirection.Desc', () => {
+      const currentSortColumnId = 'column1';
+      const currentSortDirection = SortOrder.DESC;
+      const newSortColumnId = 'column1';
+
+      const result = determineNewSortOrder<TestData>(currentSortColumnId, currentSortDirection, newSortColumnId);
+
+      expect(result).toEqual(SortOrder.ASC);
+    });
+
+    it('returns SortDirection.Desc when sorting on the same column with SortDirection.Asc', () => {
+      const currentSortColumnId = 'column1';
+      const currentSortDirection = SortOrder.DESC;
+      const newSortColumnId = 'column1';
+
+      const result = determineNewSortOrder<TestData>(currentSortColumnId, currentSortDirection, newSortColumnId);
+
+      expect(result).toEqual(SortOrder.ASC);
+    });
+  });
+
+  describe('hasSpecialCharacterOrSpace', () => {
+    it('should return true for strings with special characters', () => {
+      expect(hasSpecialCharacterOrSpace('hello@world')).toBe(true);
+      expect(hasSpecialCharacterOrSpace('hello#world')).toBe(true);
+      expect(hasSpecialCharacterOrSpace('hello!world')).toBe(true);
+    });
+
+    it('should return true for strings with spaces', () => {
+      expect(hasSpecialCharacterOrSpace('hello world')).toBe(true);
+      expect(hasSpecialCharacterOrSpace('hello  world')).toBe(true);
+    });
+
+    it('should return false for strings with only alphanumeric characters', () => {
+      expect(hasSpecialCharacterOrSpace('helloworld')).toBe(false);
+      expect(hasSpecialCharacterOrSpace('hello123')).toBe(false);
+      expect(hasSpecialCharacterOrSpace('123456')).toBe(false);
+    });
+
+    it('should return true for strings with mixed alphanumeric and special characters', () => {
+      expect(hasSpecialCharacterOrSpace('hello123@world')).toBe(true);
+      expect(hasSpecialCharacterOrSpace('123#world')).toBe(true);
+    });
+
+    it('should return false for empty strings', () => {
+      expect(hasSpecialCharacterOrSpace('')).toBe(false);
+    });
+
+    it('should return true for strings with only special characters', () => {
+      expect(hasSpecialCharacterOrSpace('@#$%^&*')).toBe(true);
+    });
+  });
+
+  describe('getPageCount', () => {
+    it('returns the page count', () => {
+      const pagination: Pagination = {
+        pageIndex: 0,
+        pageSize: 10,
+        totalItemCount: 101,
+      };
+
+      const result = getPageCount(pagination);
+
+      expect(result).toEqual(11);
+    });
+
+    it('returns the current page as value when the current page is out of range', () => {
+      const pagination: Pagination = {
+        pageIndex: 50,
+        pageSize: 10,
+        totalItemCount: 101,
+      };
 
-            const result = getPageCount(pagination);
+      const result = getPageCount(pagination);
 
-            expect(result).toEqual(51);
-        });
+      expect(result).toEqual(51);
     });
+  });
 });