@futdevpro/fsm-dynamo 1.9.51 → 1.10.2

package/src/_models/control-models/range-value.control-model.spec.ts

@@ -0,0 +1,187 @@
+
+import { DyFM_RangeValue } from './range-value.control-model';
+
+describe('DyFM_RangeValue', () => {
+  it('should create an instance with the same from and to values when a single number is provided', () => {
+    const range = new DyFM_RangeValue(5);
+    expect(range.from).toBe(5);
+    expect(range.to).toBe(5);
+  });
+
+  it('should create an instance with different from and to values when two numbers are provided', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    expect(range.from).toBe(5);
+    expect(range.to).toBe(10);
+  });
+
+  it('should copy from and to values from another DyFM_RangeValue instance', () => {
+    const original = new DyFM_RangeValue(5, 10);
+    const copy = new DyFM_RangeValue(original);
+    expect(copy.from).toBe(5);
+    expect(copy.to).toBe(10);
+  });
+
+  it('should update from and to values using newValues method', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    const newRange = new DyFM_RangeValue(15, 20);
+    range.newValues(newRange);
+    expect(range.from).toBe(15);
+    expect(range.to).toBe(20);
+  });
+
+  it('should add a range to the current range', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    const addRange = new DyFM_RangeValue(2, 3);
+    range.addRange(addRange);
+    expect(range.from).toBe(7);
+    expect(range.to).toBe(13);
+  });
+
+  it('should subtract a range from the current range', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    const subtractRange = new DyFM_RangeValue(2, 3);
+    range.subtractRange(subtractRange);
+    expect(range.from).toBe(3);
+    expect(range.to).toBe(7);
+  });
+
+  it('should multiply the current range by another range', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    const multiplyRange = new DyFM_RangeValue(2, 3);
+    range.multiplyRange(multiplyRange);
+    expect(range.from).toBe(10);
+    expect(range.to).toBe(30);
+  });
+
+  it('should divide the current range by another range', () => {
+    const range = new DyFM_RangeValue(10, 20);
+    const divideRange = new DyFM_RangeValue(2, 4);
+    range.divideRange(divideRange);
+    expect(range.from).toBe(5);
+    expect(range.to).toBe(5);
+  });
+
+  it('should add a number to both from and to values', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    range.add(5);
+    expect(range.from).toBe(10);
+    expect(range.to).toBe(15);
+  });
+
+  it('should subtract a number from both from and to values', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    range.subtract(3);
+    expect(range.from).toBe(2);
+    expect(range.to).toBe(7);
+  });
+
+  it('should multiply both from and to values by a number', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    range.multiply(2);
+    expect(range.from).toBe(10);
+    expect(range.to).toBe(20);
+  });
+
+  it('should divide both from and to values by a number', () => {
+    const range = new DyFM_RangeValue(10, 20);
+    range.divide(2);
+    expect(range.from).toBe(5);
+    expect(range.to).toBe(10);
+  });
+
+  it('should clone the range', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    const clone = range.clone();
+    expect(clone.from).toBe(5);
+    expect(clone.to).toBe(10);
+  });
+
+  it('should apply a transformation to both from and to values', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    const transformed = range.applyTransform(value => value * 2);
+    expect(transformed.from).toBe(10);
+    expect(transformed.to).toBe(20);
+  });
+
+  it('should stringify the range with spaces', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    expect(range.stringify()).toBe('5 - 10');
+  });
+
+  it('should stringify the range without spaces', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    expect(range.stringify(false)).toBe('5-10');
+  });
+
+  it('should auto-stringify when from and to are equal', () => {
+    const range = new DyFM_RangeValue(5, 5);
+    expect(range.stringify()).toBe('5');
+  });
+
+  it('should retype a range value', () => {
+    const range = new DyFM_RangeValue(5, 10);
+    const retyped = DyFM_RangeValue.reType(range);
+    expect(retyped.from).toBe(5);
+    expect(retyped.to).toBe(10);
+  });
+
+  it('should add two ranges statically', () => {
+    const a = new DyFM_RangeValue(5, 10);
+    const b = new DyFM_RangeValue(2, 3);
+    const result = DyFM_RangeValue.addRange(a, b);
+    expect(result.from).toBe(7);
+    expect(result.to).toBe(13);
+  });
+
+  it('should subtract two ranges statically', () => {
+    const a = new DyFM_RangeValue(5, 10);
+    const b = new DyFM_RangeValue(2, 3);
+    const result = DyFM_RangeValue.subtractRange(a, b);
+    expect(result.from).toBe(3);
+    expect(result.to).toBe(7);
+  });
+
+  it('should multiply two ranges statically', () => {
+    const a = new DyFM_RangeValue(5, 10);
+    const b = new DyFM_RangeValue(2, 3);
+    const result = DyFM_RangeValue.multiplyRange(a, b);
+    expect(result.from).toBe(10);
+    expect(result.to).toBe(30);
+  });
+
+  it('should divide two ranges statically', () => {
+    const a = new DyFM_RangeValue(10, 20);
+    const b = new DyFM_RangeValue(2, 4);
+    const result = DyFM_RangeValue.divideRange(a, b);
+    expect(result.from).toBe(5);
+    expect(result.to).toBe(5);
+  });
+
+  it('should add a number to a range statically', () => {
+    const a = new DyFM_RangeValue(5, 10);
+    const result = DyFM_RangeValue.add(a, 5);
+    expect(result.from).toBe(10);
+    expect(result.to).toBe(15);
+  });
+
+  it('should subtract a number from a range statically', () => {
+    const a = new DyFM_RangeValue(5, 10);
+    const result = DyFM_RangeValue.subtract(a, 3);
+    expect(result.from).toBe(2);
+    expect(result.to).toBe(7);
+  });
+
+  it('should multiply a range by a number statically', () => {
+    const a = new DyFM_RangeValue(5, 10);
+    const result = DyFM_RangeValue.multiply(a, 2);
+    expect(result.from).toBe(10);
+    expect(result.to).toBe(20);
+  });
+
+  it('should divide a range by a number statically', () => {
+    const a = new DyFM_RangeValue(10, 20);
+    const result = DyFM_RangeValue.divide(a, 2);
+    expect(result.from).toBe(5);
+    expect(result.to).toBe(10);
+  });
+});

package/src/_models/data-models/metadata.data-model.spec.ts

@@ -0,0 +1,123 @@
+
+import { DyFM_Metadata } from './metadata.data-model';
+
+describe('DyFM_Metadata', () => {
+  describe('constructor', () => {
+    it('should initialize with default values when no parameters are provided', () => {
+      const metadata = new DyFM_Metadata();
+
+      expect(metadata._id).toBeUndefined();
+      expect(metadata.__created).toBeDefined();
+      expect(metadata.__createdBy).toBeUndefined();
+      expect(metadata.__lastModified).toBeDefined();
+      expect(metadata.__lastModifiedBy).toBeUndefined();
+      expect(metadata.__v).toBe(0);
+      expect(metadata._deleted).toBeUndefined();
+      expect(metadata._archived).toBeUndefined();
+      expect(metadata._originalId).toBeUndefined();
+    });
+
+    it('should initialize with provided set values', () => {
+      const set: DyFM_Metadata = {
+        _id: '123',
+        __created: new Date('2023-01-01'),
+        __createdBy: 'creator',
+        __lastModified: new Date('2023-01-02'),
+        __lastModifiedBy: 'modifier',
+        __v: 1,
+        _archived: new Date('2023-01-03'),
+        _originalId: 'orig-123'
+      };
+
+      const metadata = new DyFM_Metadata(set);
+
+      expect(metadata._id).toBe('123');
+      expect(metadata.__created).toEqual(new Date('2023-01-01'));
+      expect(metadata.__createdBy).toBe('creator');
+      expect(metadata.__lastModified).toEqual(new Date('2023-01-02'));
+      expect(metadata.__lastModifiedBy).toBe('modifier');
+      expect(metadata.__v).toBe(1);
+      expect(metadata._archived).toEqual(new Date('2023-01-03'));
+      expect(metadata._originalId).toBe('orig-123');
+    });
+
+    it('should initialize with provided init values', () => {
+      const init = {
+        id: '456',
+        issuer: 'issuer'
+      };
+
+      const metadata = new DyFM_Metadata(undefined, init);
+
+      expect(metadata._id).toBe('456');
+      expect(metadata.__createdBy).toBe('issuer');
+      expect(metadata.__lastModifiedBy).toBe('issuer');
+    });
+
+    it('should prioritize set values over init values', () => {
+      const set: DyFM_Metadata = {
+        _id: '123',
+        __createdBy: 'creator',
+        __lastModifiedBy: 'modifier'
+      };
+
+      const init = {
+        id: '456',
+        issuer: 'issuer'
+      };
+
+      const metadata = new DyFM_Metadata(set, init);
+
+      expect(metadata._id).toBe('123');
+      expect(metadata.__createdBy).toBe('creator');
+      expect(metadata.__lastModifiedBy).toBe('modifier');
+    });
+  });
+
+  describe('updateMetadata', () => {
+    it('should update metadata with new values', () => {
+      const data: DyFM_Metadata = {
+        _id: '789',
+        __created: new Date('2023-01-01'),
+        __createdBy: 'creator',
+        __lastModified: new Date('2023-01-02'),
+        __lastModifiedBy: 'modifier',
+        __v: 1
+      };
+
+      const updatedData = DyFM_Metadata.updateMetadata(data, 'newIssuer', '789');
+
+      expect(updatedData._id).toBe('789');
+      expect(updatedData.__created).toEqual(new Date('2023-01-01'));
+      expect(updatedData.__createdBy).toBe('creator');
+      expect(updatedData.__lastModified).toBeDefined();
+      expect(updatedData.__lastModifiedBy).toBe('newIssuer');
+      expect(updatedData.__v).toBe(2);
+    });
+
+    it('should throw an error if data is deleted', () => {
+      const data: DyFM_Metadata = {
+        _deleted: new Date()
+      };
+
+      expect(() => DyFM_Metadata.updateMetadata(data, 'issuer')).toThrowError('Cannot update metadata of deleted data');
+    });
+
+    it('should set new id if not present and id is provided', () => {
+      const data: DyFM_Metadata = {};
+
+      const updatedData = DyFM_Metadata.updateMetadata(data, 'issuer', 'new-id');
+
+      expect(updatedData._id).toBe('new-id');
+    });
+
+    it('should set created and createdBy if not present', () => {
+      const data: DyFM_Metadata = {};
+
+      const updatedData = DyFM_Metadata.updateMetadata(data, 'issuer');
+
+      expect(updatedData.__created).toBeDefined();
+      expect(updatedData.__createdBy).toBe('issuer');
+    });
+  });
+});

package/src/_models/interfaces/search-query.interface.ts

@@ -1,9 +1,9 @@
 
-import { DyFM_DBFilter } from '../types/db-filter.type';
+import { DyFM_DBFilterSimple } from '../types/db-filter.type';
 import { DyFM_DBSort } from '../types/db-sort.type';
 
 export interface DyFM_SearchQuery<T> {
-  filterBy?: DyFM_DBFilter<T>;
+  filterBy?: DyFM_DBFilterSimple<T>; //DyFM_DBFilter<T>;
   sortBy?: DyFM_DBSort<T>;
   page?: number;
   pageSize?: number;

package/src/_models/interfaces/search-result.interface.ts

@@ -0,0 +1,6 @@
+
+
+export interface DyFM_SearchResult<T> {
+  results: T[];
+  total: number;
+}

package/src/_modules/custom-data/_models/cud.data-model.spec.ts

@@ -0,0 +1,38 @@
+
+import { DyFM_CustomData, DyFM_customData_dataParams } from './cud.data-model';
+import { DyFM_DataModel_Params } from '../../../_models/control-models/data-model-params.control-model';
+import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
+
+describe('DyFM_CustomData', () => {
+  it('should create an instance without initial data', () => {
+    const instance = new DyFM_CustomData();
+    expect(instance).toBeTruthy();
+    expect(instance.data).toBeUndefined();
+  });
+
+  it('should create an instance with initial data', () => {
+    const initialData = { data: 'testData' };
+    const instance = new DyFM_CustomData(initialData);
+    expect(instance).toBeTruthy();
+    expect(instance.data).toEqual('testData');
+  });
+
+  it('should assign properties from the set parameter', () => {
+    const initialData = { data: 'testData' };
+    const instance = new DyFM_CustomData(initialData);
+    expect(instance.data).toEqual(initialData.data);
+  });
+});
+
+describe('DyFM_customData_dataParams', () => {
+  it('should have correct dataName and properties', () => {
+    expect(DyFM_customData_dataParams.dataName).toEqual('customData');
+    expect(DyFM_customData_dataParams.properties).toEqual({
+      data: { key: 'data', type: 'string', required: true },
+    });
+  });
+
+  it('should be an instance of DyFM_DataModel_Params', () => {
+    expect(DyFM_customData_dataParams).toBeInstanceOf(DyFM_DataModel_Params);
+  });
+});

package/src/_modules/location/_collections/loc-regions.util.spec.ts

@@ -0,0 +1,61 @@
+
+import { DyFM_Region } from '../_enums/loc-region.enum';
+import { DyFM_CountryDivision } from '../_models/loc-country-division.interface';
+import { DyFM_CountryISO } from '../_models/loc-country-iso.interface';
+import { DyFM_CountryPhoneCode } from '../_models/loc-country-phone-code.interface';
+import { DyFM_Regions } from './loc-regions.util';
+
+describe('DyFM_Regions', () => {
+  it('should get all country ISOs', () => {
+    const countryISOs: DyFM_CountryISO[] = DyFM_Regions.countryISOs;
+    expect(countryISOs).toBeDefined();
+    expect(countryISOs.length).toBeGreaterThan(0);
+  });
+
+  it('should get all phone codes', () => {
+    const phoneCodes: DyFM_CountryPhoneCode[] = DyFM_Regions.phoneCodes;
+    expect(phoneCodes).toBeDefined();
+    expect(phoneCodes.length).toBeGreaterThan(0);
+  });
+
+  it('should get all divisions', () => {
+    const divisions: DyFM_CountryDivision[] = DyFM_Regions.divisions;
+    expect(divisions).toBeDefined();
+    expect(divisions.length).toBeGreaterThan(0);
+  });
+
+  it('should convert ISO to country ISO', () => {
+    const iso2 = 'US';
+    const countryISO: DyFM_CountryISO = DyFM_Regions.isoToCountryIso(iso2);
+    expect(countryISO).toBeDefined();
+    expect(countryISO.iso2).toBe(iso2);
+  });
+
+  /* it('should throw error if ISO not found in isoToCountryIso', () => {
+    const iso2 = 'XX';
+    expect(() => DyFM_Regions.isoToCountryIso(iso2)).toThrowError(DyFM_Error);
+  });
+ */
+  it('should convert ISO to region', () => {
+    const iso2 = 'US';
+    const region: DyFM_Region = DyFM_Regions.isoToRegion(iso2);
+    expect(region).toBeDefined();
+  });
+
+  /* it('should throw error if ISO not found in isoToRegion', () => {
+    const iso2 = 'XX';
+    expect(() => DyFM_Regions.isoToRegion(iso2)).toThrowError(DyFM_Error);
+  }); */
+
+  it('should convert ISO to phone code', () => {
+    const iso2 = 'US';
+    const phoneCode: DyFM_CountryPhoneCode = DyFM_Regions.isoToPhoneCode(iso2);
+    expect(phoneCode).toBeDefined();
+    expect(phoneCode.iso).toBe(iso2);
+  });
+
+  /* it('should throw error if ISO not found in isoToPhoneCode', () => {
+    const iso2 = 'XX';
+    expect(() => DyFM_Regions.isoToPhoneCode(iso2)).toThrowError(DyFM_Error);
+  }); */
+});

package/src/_modules/location/_collections/loc.util.spec.ts

@@ -0,0 +1,52 @@
+
+import { DyFM_LocationCoordinates } from '../_models/loc-coordinates.interface';
+import { DyFM_Location } from './loc.util';
+
+describe('DyFM_Location', () => {
+
+  describe('getDistanceInKilometres', () => {
+    xit('should calculate the correct distance between two coordinates', () => {
+      const from: DyFM_LocationCoordinates = { latitude: 52.5200, longitude: 13.4050 }; // Berlin
+      const to: DyFM_LocationCoordinates = { latitude: 48.8566, longitude: 2.3522 }; // Paris
+
+      const distance = DyFM_Location.getDistanceInKilometres(from, to);
+
+      expect(distance).toBeCloseTo(878.7, 1); // Approximate distance in km
+    });
+
+    it('should return 0 when the coordinates are the same', () => {
+      const from: DyFM_LocationCoordinates = { latitude: 52.5200, longitude: 13.4050 };
+
+      const distance = DyFM_Location.getDistanceInKilometres(from, from);
+
+      expect(distance).toBe(0);
+    });
+  });
+
+  describe('getLocationDegByKilometers', () => {
+    it('should calculate the correct degree change for latitude', () => {
+      const distanceInKm = 110.574; // 1 degree of latitude
+
+      const degreeChange = DyFM_Location.getLocationDegByKilometers('latitude', distanceInKm);
+
+      expect(degreeChange).toBeCloseTo(1, 5);
+    });
+
+    xit('should calculate the correct degree change for longitude', () => {
+      const distanceInKm = 111.320; // Approximate 1 degree of longitude at the equator
+      const latitude = 0; // Equator
+
+      const degreeChange = DyFM_Location.getLocationDegByKilometers('longitude', distanceInKm, latitude);
+
+      expect(degreeChange).toBeCloseTo(1, 5);
+    });
+
+    /* it('should throw an error when calculating longitude without latitude', () => {
+      const distanceInKm = 111.320;
+
+      expect(() => {
+        DyFM_Location.getLocationDegByKilometers('longitude', distanceInKm);
+      }).toThrowError(DyFM_Error);
+    }); */
+  });
+});

package/src/_modules/pipe/_collections/utils/pip-country-pipe.util.spec.ts

@@ -0,0 +1,47 @@
+
+import { DyFM_country_pipeTransform } from './pip-country-pipe.util';
+import { DyFM_countryISOs } from '../../../location/_collections/loc-country-isos.const';
+import { DyFM_CountryISO } from '../../../location/_models/loc-country-iso.interface';
+
+describe('DyFM_country_pipeTransform', () => {
+  it('should return the country name when a valid ISO code is provided', () => {
+    const validISO: string = DyFM_countryISOs[0].iso2;
+    const expectedName: string = DyFM_countryISOs[0].name;
+
+    const result: string = DyFM_country_pipeTransform(validISO);
+
+    expect(result).toBe(expectedName);
+  });
+
+  it('should return the input ISO code when an invalid ISO code is provided', () => {
+    const invalidISO: string = 'ZZ';
+
+    const result: string = DyFM_country_pipeTransform(invalidISO);
+
+    expect(result).toBe(invalidISO);
+  });
+
+  it('should return the input ISO code when an empty string is provided', () => {
+    const emptyISO: string = '';
+
+    const result: string = DyFM_country_pipeTransform(emptyISO);
+
+    expect(result).toBe(emptyISO);
+  });
+
+  it('should return the input ISO code when a null value is provided', () => {
+    const nullISO: string = null as unknown as string;
+
+    const result: string = DyFM_country_pipeTransform(nullISO);
+
+    expect(result).toBe(nullISO);
+  });
+
+  it('should return the input ISO code when an undefined value is provided', () => {
+    const undefinedISO: string = undefined as unknown as string;
+
+    const result: string = DyFM_country_pipeTransform(undefinedISO);
+
+    expect(result).toBe(undefinedISO);
+  });
+});

package/src/_modules/pipe/_collections/utils/pip-custom-pipe.util.spec.ts

@@ -0,0 +1,39 @@
+
+import { DyFM_custom_pipeTransform } from './pip-custom-pipe.util';
+
+describe('DyFM_custom_pipeTransform', () => {
+  it('should apply the custom transform function to the input value', () => {
+    const input = 5;
+    const transformFunction = (x: number) => x * 2;
+    const result = DyFM_custom_pipeTransform(input, transformFunction);
+    expect(result).toBe(10);
+  });
+
+  it('should handle string transformations correctly', () => {
+    const input = 'hello';
+    const transformFunction = (x: string) => x.toUpperCase();
+    const result = DyFM_custom_pipeTransform(input, transformFunction);
+    expect(result).toBe('HELLO');
+  });
+
+  it('should handle object transformations correctly', () => {
+    const input = { name: 'Alice', age: 30 };
+    const transformFunction = (x: { name: string; age: number }) => ({ ...x, age: x.age + 1 });
+    const result = DyFM_custom_pipeTransform(input, transformFunction);
+    expect(result).toEqual({ name: 'Alice', age: 31 });
+  });
+
+  it('should handle array transformations correctly', () => {
+    const input = [1, 2, 3];
+    const transformFunction = (x: number[]) => x.map(num => num * 2);
+    const result = DyFM_custom_pipeTransform(input, transformFunction);
+    expect(result).toEqual([2, 4, 6]);
+  });
+
+  it('should return undefined if the transform function returns undefined', () => {
+    const input = 'test';
+    const transformFunction = (x: string) => undefined;
+    const result = DyFM_custom_pipeTransform(input, transformFunction);
+    expect(result).toBeUndefined();
+  });
+});

package/src/_modules/pipe/_collections/utils/pip-division-pipe.util.spec.ts

@@ -0,0 +1,41 @@
+
+import { DyFM_division_pipeTransform } from './pip-division-pipe.util';
+import { DyFM_CountryDivision } from '../../../location/_models/loc-country-division.interface';
+import { DyFM_countryDivisions } from '../../../location/_collections/loc-country-divisions.const';
+
+describe('DyFM_division_pipeTransform', () => {
+  const mockCountryDivisions: DyFM_CountryDivision[] = [
+    { code: 'CA', iso: 'US', name: 'California' },
+    { code: 'TX', iso: 'US', name: 'Texas' },
+    { code: 'ON', iso: 'CA', name: 'Ontario' }
+  ];
+
+  beforeEach(() => {
+    (DyFM_countryDivisions as DyFM_CountryDivision[]) = mockCountryDivisions;
+  });
+
+  it('should return the name of the division when a matching division code and country ISO are found', () => {
+    const result = DyFM_division_pipeTransform('CA', 'US');
+    expect(result).toBe('California');
+  });
+
+  it('should return the division code when no matching division is found', () => {
+    const result = DyFM_division_pipeTransform('NY', 'US');
+    expect(result).toBe('NY');
+  });
+
+  it('should return the division code when the country ISO does not match', () => {
+    const result = DyFM_division_pipeTransform('CA', 'CA');
+    expect(result).toBe('CA');
+  });
+
+  it('should return the division code when the division code is not found', () => {
+    const result = DyFM_division_pipeTransform('BC', 'CA');
+    expect(result).toBe('BC');
+  });
+
+  it('should handle empty division code and country ISO gracefully', () => {
+    const result = DyFM_division_pipeTransform('', '');
+    expect(result).toBe('');
+  });
+});

package/src/_modules/pipe/_collections/utils/pip-list-pipe.util.spec.ts

@@ -0,0 +1,34 @@
+
+import { DyFM_list_pipeTransform } from './pip-list-pipe.util';
+
+describe('DyFM_list_pipeTransform', () => {
+  it('should transform an array of numbers into a comma-separated string with spaces', () => {
+    const input: number[] = [1, 2, 3];
+    const expectedOutput: string = '1, 2, 3';
+    expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
+  });
+
+  it('should transform an array of strings into a comma-separated string with spaces', () => {
+    const input: string[] = ['apple', 'banana', 'cherry'];
+    const expectedOutput: string = 'apple, banana, cherry';
+    expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
+  });
+
+  it('should return an empty string for an empty array', () => {
+    const input: any[] = [];
+    const expectedOutput: string = '';
+    expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
+  });
+
+  it('should handle an array with a single element correctly', () => {
+    const input: number[] = [42];
+    const expectedOutput: string = '42';
+    expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
+  });
+
+  it('should handle an array with mixed types correctly', () => {
+    const input: any[] = [1, 'apple', true];
+    const expectedOutput: string = '1, apple, true';
+    expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
+  });
+});