@futdevpro/fsm-dynamo 1.15.17 → 1.15.20

package/src/_collections/utils/array.util.spec.ts

@@ -1,306 +1,306 @@
-import { DyFM_Paged } from '../../_models/interfaces/paged.interface';
-import { DyFM_Array } from './array.util';
-import { DyFM_Async } from './async.util';
-
-describe('| DyFM_Array', (): void => {
-
-  describe('| asyncForEach', (): void => {
-    it('| should call the function for each element in the list', async (): Promise<void> => {
-      const list: number[] = [ 1, 2, 3 ];
-      const result: number[] = [];
-      const func = async (e: number, i?: number): Promise<void> => { 
-        await DyFM_Async.delay(30);
-        result.push(e);
-      };
-
-      await DyFM_Array.asyncForEach(list, func);
-
-      expect(result).toEqual(list);
-    });
-  });
-
-  describe('| asyncMapArray', (): void => {
-    it('| should call the function for each element in the list', async (): Promise<void> => {
-      const list: number[] = [ 1, 2, 3 ];
-      
-      const func = async (e: number, i?: number): Promise<number> => { 
-        await DyFM_Async.delay(30);
-
-        return e * 2;
-      };
-
-      const result = await DyFM_Array.asyncMap(list, func);
-
-      expect(result).toEqual([ 2, 4, 6 ]);
-    });
-  });
-  
-  describe('| shuffle', () => {
-    it('| should shuffle the elements in the array', () => {
-      const inputArray: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
-      const shuffledArray: number[] = [ ...inputArray ];
-
-      DyFM_Array.shuffle(shuffledArray);
-
-      // Check if the elements are shuffled (at least one position is different)
-      let samePositionCount = 0;
-
-      for (let i = 0; i < inputArray.length; i++) {
-        if (inputArray[i] === shuffledArray[i]) {
-          samePositionCount++;
-        }
-      }
-      expect(samePositionCount).toBeLessThan(inputArray.length);
-
-      // Check if all elements are still present after shuffle
-      expect(shuffledArray.sort()).toEqual(inputArray.sort());
-    });
-
-    it('| should handle empty array', () => {
-      const inputArray: number[] = [];
-      const shuffledArray = DyFM_Array.shuffle(inputArray);
-
-      expect(shuffledArray).toEqual([]);
-    });
-  });
-  
-  describe('| page function', () => {
-    const array: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
-    const pageSize: number = 2;
-
-    it('| should return the correct page of items based on pageIndex and pageSize', () => {
-      expect(DyFM_Array.page(array, 0, pageSize)).toEqual([ 1, 2 ]);
-      expect(DyFM_Array.page(array, 1, pageSize)).toEqual([ 3, 4 ]);
-      expect(DyFM_Array.page(array, 2, pageSize)).toEqual([ 5, 6 ]);
-      expect(DyFM_Array.page(array, 3, pageSize)).toEqual([ 7, 8 ]);
-    });
-
-    it('| should return an empty array if the page is out of bounds', () => {
-      expect(DyFM_Array.page(array, 4, pageSize)).toEqual([]);
-      expect(DyFM_Array.page(array, -1, pageSize)).toEqual([]);
-    });
-  });
-  
-  describe('| paged function', () => {
-    it('| should return a paginated array', () => {
-      const array: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
-      const pageIndex: number = 1;
-      const pageSize: number = 4;
-      const expected: DyFM_Paged<any> = {
-        pageIndex: 1,
-        pageSize: 4,
-        total: 10,
-        totalPageCount: 3,
-        items: [ 5, 6, 7, 8 ],
-      };
-      
-      const result = DyFM_Array.paged(array, pageIndex, pageSize);
-      
-      expect(result).toEqual(expected);
-    });
-    
-    it('| should handle edge cases like empty array', () => {
-      const array: number[] = [];
-      const pageIndex: number = 1;
-      const pageSize: number = 5;
-      const expected: DyFM_Paged<any> = {
-        pageIndex: 1,
-        pageSize: 5,
-        total: 0,
-        totalPageCount: 0,
-        items: [],
-      };
-      
-      const result = DyFM_Array.paged(array, pageIndex, pageSize);
-      
-      expect(result).toEqual(expected);
-    });
-  });
-  
-  describe('| swap function test', () => {
-    it('| should swap elements in the array correctly', () => {
-      const array: number[] = [ 1, 2, 3, 4 ];
-      const indexA: number = 0;
-      const indexB: number = 2;
-      const expectedArray: number[] = [ 3, 2, 1, 4 ];
-
-      expect(DyFM_Array.swap(array, indexA, indexB)).toEqual(expectedArray);
-    });
-
-    it('| should return the same array if same indexes are provided', () => {
-      const array: number[] = [ 1, 2, 3, 4 ];
-      const indexA: number = 0;
-      const indexB: number = 0;
-
-      expect(DyFM_Array.swap(array, indexA, indexB)).toEqual(array);
-    });
-
-    // Add more test cases as needed
-  });
-
-  describe('| stringListHasMultiplications', () => {
-    it('| should return true if input string array contains duplicates', () => {
-      const input1: string[] = [ 'apple', 'banana', 'apple', 'orange' ];
-
-      expect(DyFM_Array.stringListHasMultiplications(input1)).toBe(true);
-  
-      const input2: string[] = [ 'apple', 'banana', 'orange' ];
-
-      expect(DyFM_Array.stringListHasMultiplications(input2)).toBe(false);
-    });
-  });
-
-  describe('| filterStringMultiplications', () => {
-    xit('should return an array with duplicates filtered out', () => {
-      const inputList: string[] = [ 'abc', 'def', 'abc', 'ghi', 'abc' ];
-      const expectedOutput: string[] = [ 'abc' ];
-
-      const result = DyFM_Array.filterStringMultiplications(inputList);
-
-      expect(result).toEqual(expectedOutput);
-    });
-
-    it('| should return an empty array if no duplicates are present', () => {
-      const inputList: string[] = [ 'abc', 'def', 'ghi' ];
-      const expectedOutput: string[] = [];
-
-      const result = DyFM_Array.filterStringMultiplications(inputList);
-
-      expect(result).toEqual(expectedOutput);
-    });
-
-    it('| should handle empty input array and return empty array', () => {
-      const inputList: string[] = [];
-      const expectedOutput: string[] = [];
-
-      const result = DyFM_Array.filterStringMultiplications(inputList);
-
-      expect(result).toEqual(expectedOutput);
-    });
-  });
-
-  describe('| gatherStringMultiplications', () => {
-    it('| should return an array of arrays containing duplicated strings', () => {
-      const input: string[] = [ 'apple', 'banana', 'apple', 'cherry', 'banana', 'banana' ];
-      const expectedOutput: string[][] = [[ 'apple', 'apple' ], [ 'banana', 'banana', 'banana' ]];
-
-      expect(DyFM_Array.gatherStringMultiplications(input)).toEqual(expectedOutput);
-    });
-  
-    it('| should return an empty array for no duplicated strings', () => {
-      const input: string[] = [ 'apple', 'banana', 'cherry' ];
-      const expectedOutput: string[][] = [];
-
-      expect(DyFM_Array.gatherStringMultiplications(input)).toEqual(expectedOutput);
-    });
-  
-    it('| should return empty array for an empty input array', () => {
-      const input: string[] = [];
-      const expectedOutput: string[][] = [];
-
-      expect(DyFM_Array.gatherStringMultiplications(input)).toEqual(expectedOutput);
-    });
-  
-    // Add more test cases as needed
-  });
-  
-  describe('| haveMultiplications', () => {
-    it('| should return true if dataList contains any duplicate entry based on the given key', () => {
-      const dataList: { _id: number, name: string }[] = [
-        { _id: 1, name: 'John' },
-        { _id: 2, name: 'Jane' },
-        { _id: 3, name: 'Alice' },
-        { _id: 1, name: 'Bob' },
-      ];
-
-      const result = DyFM_Array.haveMultiplications(dataList, '_id');
-
-      expect(result).toBe(true);
-    });
-
-    it('| should return false if dataList does not contain any duplicate entry based on the given key', () => {
-      const dataList: { _id: number, name: string }[] = [
-        { _id: 1, name: 'John' },
-        { _id: 2, name: 'Jane' },
-        { _id: 3, name: 'Alice' },
-        { _id: 4, name: 'Bob' },
-      ];
-
-      const result = DyFM_Array.haveMultiplications(dataList, '_id');
-
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('| filterMultiplications', () => {
-    xit('should filter out duplicate items based on the specified key', () => {
-      const dataList: { _id: number, name: string }[] = [
-        { _id: 1, name: 'Alice' },
-        { _id: 2, name: 'Bob' },
-        { _id: 1, name: 'Charlie' },
-        { _id: 3, name: 'David' },
-        { _id: 1, name: 'Eve' },
-      ];
-
-      const expectedFilteredData = [
-        { _id: 1, name: 'Alice' },
-        { _id: 2, name: 'Bob' },
-        { _id: 3, name: 'David' },
-      ];
-
-      const filteredData = DyFM_Array.filterMultiplications(dataList);
-
-      expect(filteredData).toEqual(expectedFilteredData);
-    });
-
-    it('| should return an empty array if no duplicates are found', () => {
-      const dataList: { _id: number, name: string }[] = [
-        { _id: 1, name: 'Alice' },
-        { _id: 2, name: 'Bob' },
-        { _id: 3, name: 'Charlie' },
-      ];
-
-      const filteredData = DyFM_Array.filterMultiplications(dataList);
-
-      expect(filteredData).toEqual([]);
-    });
-
-    it('| should handle empty input list', () => {
-      const dataList: any[] = [];
-
-      const filteredData = DyFM_Array.filterMultiplications(dataList);
-
-      expect(filteredData).toEqual([]);
-    });
-  });
-
-  describe('| gatherMultiplications', () => {
-    it('| should gather multiplications based on the specified key', () => {
-      const dataList: { _id: number, name: string }[] = [
-        { _id: 1, name: 'Alice' },
-        { _id: 2, name: 'Bob' },
-        { _id: 1, name: 'Charlie' },
-        { _id: 3, name: 'David' },
-        { _id: 2, name: 'Eve' },
-        { _id: 3, name: 'Frank' },
-      ];
-  
-      const expectedMultiplications = [
-        [
-          { _id: 1, name: 'Alice' },
-          { _id: 1, name: 'Charlie' },
-        ],
-        [
-          { _id: 2, name: 'Bob' },
-          { _id: 2, name: 'Eve' },
-        ],
-        [
-          { _id: 3, name: 'David' },
-          { _id: 3, name: 'Frank' },
-        ],
-      ];
-  
-      expect(DyFM_Array.gatherMultiplications(dataList)).toEqual(expectedMultiplications);
-    });
-  });
-});
+import { DyFM_Paged } from '../../_models/interfaces/paged.interface';
+import { DyFM_Array } from './array.util';
+import { DyFM_Async } from './async.util';
+
+describe('| DyFM_Array', (): void => {
+
+  describe('| asyncForEach', (): void => {
+    it('| should call the function for each element in the list', async (): Promise<void> => {
+      const list: number[] = [ 1, 2, 3 ];
+      const result: number[] = [];
+      const func = async (e: number, i?: number): Promise<void> => { 
+        await DyFM_Async.delay(30);
+        result.push(e);
+      };
+
+      await DyFM_Array.asyncForEach(list, func);
+
+      expect(result).toEqual(list);
+    });
+  });
+
+  describe('| asyncMapArray', (): void => {
+    it('| should call the function for each element in the list', async (): Promise<void> => {
+      const list: number[] = [ 1, 2, 3 ];
+      
+      const func = async (e: number, i?: number): Promise<number> => { 
+        await DyFM_Async.delay(30);
+
+        return e * 2;
+      };
+
+      const result = await DyFM_Array.asyncMap(list, func);
+
+      expect(result).toEqual([ 2, 4, 6 ]);
+    });
+  });
+  
+  describe('| shuffle', () => {
+    it('| should shuffle the elements in the array', () => {
+      const inputArray: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+      const shuffledArray: number[] = [ ...inputArray ];
+
+      DyFM_Array.shuffle(shuffledArray);
+
+      // Check if the elements are shuffled (at least one position is different)
+      let samePositionCount = 0;
+
+      for (let i = 0; i < inputArray.length; i++) {
+        if (inputArray[i] === shuffledArray[i]) {
+          samePositionCount++;
+        }
+      }
+      expect(samePositionCount).toBeLessThan(inputArray.length);
+
+      // Check if all elements are still present after shuffle
+      expect(shuffledArray.sort()).toEqual(inputArray.sort());
+    });
+
+    it('| should handle empty array', () => {
+      const inputArray: number[] = [];
+      const shuffledArray = DyFM_Array.shuffle(inputArray);
+
+      expect(shuffledArray).toEqual([]);
+    });
+  });
+  
+  describe('| page function', () => {
+    const array: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
+    const pageSize: number = 2;
+
+    it('| should return the correct page of items based on pageIndex and pageSize', () => {
+      expect(DyFM_Array.page(array, 0, pageSize)).toEqual([ 1, 2 ]);
+      expect(DyFM_Array.page(array, 1, pageSize)).toEqual([ 3, 4 ]);
+      expect(DyFM_Array.page(array, 2, pageSize)).toEqual([ 5, 6 ]);
+      expect(DyFM_Array.page(array, 3, pageSize)).toEqual([ 7, 8 ]);
+    });
+
+    it('| should return an empty array if the page is out of bounds', () => {
+      expect(DyFM_Array.page(array, 4, pageSize)).toEqual([]);
+      expect(DyFM_Array.page(array, -1, pageSize)).toEqual([]);
+    });
+  });
+  
+  describe('| paged function', () => {
+    it('| should return a paginated array', () => {
+      const array: number[] = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+      const pageIndex: number = 1;
+      const pageSize: number = 4;
+      const expected: DyFM_Paged<any> = {
+        pageIndex: 1,
+        pageSize: 4,
+        total: 10,
+        totalPageCount: 3,
+        items: [ 5, 6, 7, 8 ],
+      };
+      
+      const result = DyFM_Array.paged(array, pageIndex, pageSize);
+      
+      expect(result).toEqual(expected);
+    });
+    
+    it('| should handle edge cases like empty array', () => {
+      const array: number[] = [];
+      const pageIndex: number = 1;
+      const pageSize: number = 5;
+      const expected: DyFM_Paged<any> = {
+        pageIndex: 1,
+        pageSize: 5,
+        total: 0,
+        totalPageCount: 0,
+        items: [],
+      };
+      
+      const result = DyFM_Array.paged(array, pageIndex, pageSize);
+      
+      expect(result).toEqual(expected);
+    });
+  });
+  
+  describe('| swap function test', () => {
+    it('| should swap elements in the array correctly', () => {
+      const array: number[] = [ 1, 2, 3, 4 ];
+      const indexA: number = 0;
+      const indexB: number = 2;
+      const expectedArray: number[] = [ 3, 2, 1, 4 ];
+
+      expect(DyFM_Array.swap(array, indexA, indexB)).toEqual(expectedArray);
+    });
+
+    it('| should return the same array if same indexes are provided', () => {
+      const array: number[] = [ 1, 2, 3, 4 ];
+      const indexA: number = 0;
+      const indexB: number = 0;
+
+      expect(DyFM_Array.swap(array, indexA, indexB)).toEqual(array);
+    });
+
+    // Add more test cases as needed
+  });
+
+  describe('| stringListHasMultiplications', () => {
+    it('| should return true if input string array contains duplicates', () => {
+      const input1: string[] = [ 'apple', 'banana', 'apple', 'orange' ];
+
+      expect(DyFM_Array.stringListHasMultiplications(input1)).toBe(true);
+  
+      const input2: string[] = [ 'apple', 'banana', 'orange' ];
+
+      expect(DyFM_Array.stringListHasMultiplications(input2)).toBe(false);
+    });
+  });
+
+  describe('| filterStringMultiplications', () => {
+    xit('should return an array with duplicates filtered out', () => {
+      const inputList: string[] = [ 'abc', 'def', 'abc', 'ghi', 'abc' ];
+      const expectedOutput: string[] = [ 'abc' ];
+
+      const result = DyFM_Array.filterStringMultiplications(inputList);
+
+      expect(result).toEqual(expectedOutput);
+    });
+
+    it('| should return an empty array if no duplicates are present', () => {
+      const inputList: string[] = [ 'abc', 'def', 'ghi' ];
+      const expectedOutput: string[] = [];
+
+      const result = DyFM_Array.filterStringMultiplications(inputList);
+
+      expect(result).toEqual(expectedOutput);
+    });
+
+    it('| should handle empty input array and return empty array', () => {
+      const inputList: string[] = [];
+      const expectedOutput: string[] = [];
+
+      const result = DyFM_Array.filterStringMultiplications(inputList);
+
+      expect(result).toEqual(expectedOutput);
+    });
+  });
+
+  describe('| gatherStringMultiplications', () => {
+    it('| should return an array of arrays containing duplicated strings', () => {
+      const input: string[] = [ 'apple', 'banana', 'apple', 'cherry', 'banana', 'banana' ];
+      const expectedOutput: string[][] = [[ 'apple', 'apple' ], [ 'banana', 'banana', 'banana' ]];
+
+      expect(DyFM_Array.gatherStringMultiplications(input)).toEqual(expectedOutput);
+    });
+  
+    it('| should return an empty array for no duplicated strings', () => {
+      const input: string[] = [ 'apple', 'banana', 'cherry' ];
+      const expectedOutput: string[][] = [];
+
+      expect(DyFM_Array.gatherStringMultiplications(input)).toEqual(expectedOutput);
+    });
+  
+    it('| should return empty array for an empty input array', () => {
+      const input: string[] = [];
+      const expectedOutput: string[][] = [];
+
+      expect(DyFM_Array.gatherStringMultiplications(input)).toEqual(expectedOutput);
+    });
+  
+    // Add more test cases as needed
+  });
+  
+  describe('| haveMultiplications', () => {
+    it('| should return true if dataList contains any duplicate entry based on the given key', () => {
+      const dataList: { _id: number, name: string }[] = [
+        { _id: 1, name: 'John' },
+        { _id: 2, name: 'Jane' },
+        { _id: 3, name: 'Alice' },
+        { _id: 1, name: 'Bob' },
+      ];
+
+      const result = DyFM_Array.haveMultiplications(dataList, '_id');
+
+      expect(result).toBe(true);
+    });
+
+    it('| should return false if dataList does not contain any duplicate entry based on the given key', () => {
+      const dataList: { _id: number, name: string }[] = [
+        { _id: 1, name: 'John' },
+        { _id: 2, name: 'Jane' },
+        { _id: 3, name: 'Alice' },
+        { _id: 4, name: 'Bob' },
+      ];
+
+      const result = DyFM_Array.haveMultiplications(dataList, '_id');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('| filterMultiplications', () => {
+    xit('should filter out duplicate items based on the specified key', () => {
+      const dataList: { _id: number, name: string }[] = [
+        { _id: 1, name: 'Alice' },
+        { _id: 2, name: 'Bob' },
+        { _id: 1, name: 'Charlie' },
+        { _id: 3, name: 'David' },
+        { _id: 1, name: 'Eve' },
+      ];
+
+      const expectedFilteredData = [
+        { _id: 1, name: 'Alice' },
+        { _id: 2, name: 'Bob' },
+        { _id: 3, name: 'David' },
+      ];
+
+      const filteredData = DyFM_Array.filterMultiplications(dataList);
+
+      expect(filteredData).toEqual(expectedFilteredData);
+    });
+
+    it('| should return an empty array if no duplicates are found', () => {
+      const dataList: { _id: number, name: string }[] = [
+        { _id: 1, name: 'Alice' },
+        { _id: 2, name: 'Bob' },
+        { _id: 3, name: 'Charlie' },
+      ];
+
+      const filteredData = DyFM_Array.filterMultiplications(dataList);
+
+      expect(filteredData).toEqual([]);
+    });
+
+    it('| should handle empty input list', () => {
+      const dataList: any[] = [];
+
+      const filteredData = DyFM_Array.filterMultiplications(dataList);
+
+      expect(filteredData).toEqual([]);
+    });
+  });
+
+  describe('| gatherMultiplications', () => {
+    it('| should gather multiplications based on the specified key', () => {
+      const dataList: { _id: number, name: string }[] = [
+        { _id: 1, name: 'Alice' },
+        { _id: 2, name: 'Bob' },
+        { _id: 1, name: 'Charlie' },
+        { _id: 3, name: 'David' },
+        { _id: 2, name: 'Eve' },
+        { _id: 3, name: 'Frank' },
+      ];
+  
+      const expectedMultiplications = [
+        [
+          { _id: 1, name: 'Alice' },
+          { _id: 1, name: 'Charlie' },
+        ],
+        [
+          { _id: 2, name: 'Bob' },
+          { _id: 2, name: 'Eve' },
+        ],
+        [
+          { _id: 3, name: 'David' },
+          { _id: 3, name: 'Frank' },
+        ],
+      ];
+  
+      expect(DyFM_Array.gatherMultiplications(dataList)).toEqual(expectedMultiplications);
+    });
+  });
+});