@bytebrand/fe-ui-core 4.8.49 → 4.8.50

package/__tests__/components/_common/StarButton/StarButton.test.tsx

@@ -0,0 +1,46 @@
+import React from 'react';
+import { render, fireEvent } from '@testing-library/react';
+import StarButton from '../../../../source/components/_common/StarButton/StarButton';
+
+
+describe('StarButton', () => {
+  const defaultProps = {
+    onClick: jest.fn(),
+    isFavorite: true,
+    amountOfFavorite: 5
+  }
+
+  it('render StarButton component', () => {
+    const { container } = render(<StarButton {...defaultProps} />);
+    const svgIcon = container.querySelector('svg');
+    expect(svgIcon.firstChild).toBeTruthy();
+  });
+
+  it('should trigger the onClick function when clicked', () => {
+    const { container } = render(<StarButton {...defaultProps} />);
+    fireEvent.click(container.querySelector('svg'));
+    expect(defaultProps.onClick).toHaveBeenCalled();
+  });
+  
+  it('render amount of favorite if is amountOfFavorite are true', () => {
+    const { container, queryByTitle } = render(<StarButton {...defaultProps} amountOfFavorite={5} />);
+    expect(container.querySelector('span')).toBeInTheDocument();
+    expect(queryByTitle(`${defaultProps.amountOfFavorite}`));
+  });
+
+  it('removes amount of favorite if no favorites are present', () => {
+    const { queryByTitle } = render(<StarButton {...defaultProps} amountOfFavorite={0} />);
+    expect(queryByTitle(`${defaultProps.amountOfFavorite}`)).toBeFalsy();
+  });
+  
+  it('renders custom container class when custom container prop exists', () => {
+    const customContainerClass = 'custom-container-class';
+    const { container } = render(<StarButton {...defaultProps} customContainer={customContainerClass} />);
+    expect(container.firstChild).toHaveClass(customContainerClass);
+  });
+  
+  it('adds "active" className when isFavorite is true', () => {
+    const { container } = render(<StarButton isFavorite />);
+    expect(container.querySelector('svg')).toHaveClass('active');
+  });
+});

package/__tests__/mockedData/financingConfig.js

@@ -0,0 +1,202 @@
+export const financingConfig = {
+  offerIndex: 0,
+  isStrike: false,
+  comparable: {
+    annualMileage: 40000,
+    firstInstallment: 16100,
+    paybackPeriod: 24,
+    withAddServices: true,
+    withTransportation: false,
+    isUpdated: 1677632978,
+    withFinalInstallment: false
+  },
+  checkout: {
+    warrantyRates: [
+        30.33,
+        0,
+        39.01
+    ],
+    warrantyPackage: 0,
+    warrantyPeriod: 1,
+    admissionService: 6.47,
+    licensePlateFee: 2.13,
+    licensePlateFeeFinalInstallment: 0,
+    admissionServiceFinalInstallment: 0
+  },
+  common: {
+    firstRegistration: 1572562800,
+    mileage: 102000,
+    currentSalesPrice: 21666,
+    highestPrice: 21666,
+    isStrikeShown: false,
+    isHybridOrElectric: false
+  },
+  financing: {
+    grossLoanAmountWithoutFinalInstallment: 5796.24,
+    purchasePrice: 0,
+    hasPaymentProtection: false,
+    paymentProtectionInsurance: 0,
+    monthlyInstallment: 241.51,
+    oldMonthlyInstallment: 241.51,
+    annualMileage: 40000,
+    firstInstallment: 16100,
+    withTransportation: false,
+    withAddServices: true,
+    addServicesCostRaw: 799,
+    addServicesCost: 34.67,
+    transportationCostRaw: 499,
+    transportationCost: 21.65,
+    withFinalInstallment: false,
+    paybackPeriod: 24,
+    rawPaybackPeriod: 24,
+    nominalInterestRate: 3.92,
+    annualPercentageRate: 3.99,
+    financialInstitution: 'Santander Consumer Bank AG, Santander-Platz 1, 41061 Mönchengladbach',
+    periodInterestRate: [
+      {
+        duration: 12,
+        recommended: 70,
+        current: 88,
+        inEUR: null,
+        value: 17566,
+        highestValue: 19066.08
+      },
+      {
+        duration: 24,
+        recommended: 66,
+        current: 77,
+        inEUR: null,
+        value: 16067.59,
+        highestValue: 16682.82
+      },
+      {
+        duration: 36,
+        recommended: 60,
+        current: 66,
+        inEUR: null,
+        value: 13772.22,
+        highestValue: 14299.56
+      },
+      {
+        duration: 48,
+        recommended: 50,
+        current: 60,
+        inEUR: null,
+        value: 12520.2,
+        highestValue: 12999.6
+      },
+      {
+        duration: 60,
+        recommended: 40,
+        current: 50,
+        inEUR: null,
+        value: 10433.5,
+        highestValue: 10833
+      },
+      {
+        duration: 72,
+        recommended: 30,
+        current: 40,
+        inEUR: null,
+        value: 8346.8,
+        highestValue: 8666.4
+      },
+      {
+        duration: 84,
+        recommended: 20,
+        current: 30,
+        inEUR: null,
+        value: 6260.1,
+        highestValue: 6499.8
+      },
+      {
+        duration: 96,
+        recommended: 10,
+        current: 20,
+        inEUR: null,
+        value: 4173.4,
+        highestValue: 4333.2
+      }
+    ],
+    closingCosts: 0,
+    offersFinancing: true,
+    rateMode: 'dealer',
+    isStrikeShown: false,
+    totalInterestPayments: 197.16,
+    grossLoanAmount: 5796.24,
+    onetimeSpecialPayment: 16100,
+    currentSalesPrice: 21666,
+    highestPrice: 21666,
+    oldMonthlyCarPrice: 206.84,
+    monthlyCarPrice: 206.84,
+    currentSalesPriceExtraCost: 21666,
+    finalInstallment: 0,
+    netLoanAmount: 5566
+  },
+  buy: {
+    withTransportation: false,
+    withAddServices: true,
+    withoutAddServices: true,
+    transportationCost: 499,
+    addServicesCost: 799,
+    currentSalesPriceExtra: 21666,
+    highestPriceExtra: 21666,
+    extraCost: 0
+  },
+  leasing: {
+    RWG: 4,
+    maxAge: 24,
+    maxMileage: 1000000,
+    isActive: false,
+    withTransportation: false,
+    withAddServices: true,
+    addServicesCostRaw: 799,
+    transportationCostRaw: 499,
+    addServicesCost: 18.76,
+    transportationCost: 11.71,
+    monthlyAddServices: 0,
+    monthlyTransportation: 0,
+    monthlyInstallment: 77.25,
+    oldMonthlyInstallment: 77.25,
+    firstInstallment: 11871.64,
+    firstInstallmentMax: 11871.64,
+    annualMileage: 40000,
+    paybackPeriodRange: [
+      30,
+      36,
+      42,
+      48,
+      54,
+      60
+    ],
+    paybackPeriod: 30,
+    santanderPayBackMin: 250,
+    nominalInterestRate: 6.78,
+    financialInstitution: 'Santander Consumer Bank AG, Santander-Platz 1, 41061 Mönchengladbach',
+    grossLoanAmountWithoutFinalInstallment: 2317.5,
+    hasPaymentProtection: false,
+    paymentProtectionInsurance: 0,
+    leasingMode: 'default',
+    currentSalesPrice: 21666,
+    monthlyCarPrice: 58.49,
+    oldMonthlyCarPrice: 58.49,
+    currentSalesPriceExtraCost: 21666,
+    onetimeSpecialPayment: 11871.64,
+    netLoanAmount: 9794.36,
+    grossLoanAmount: 11062.86,
+    finalInstallment: 0,
+    annualPercentageRate: 6.99
+  },
+  abo: {
+    paybackPeriod: 6,
+    annualMileage: 40000
+  },
+  firstRegistration: 1572562800,
+  mileage: 102000,
+  currentSalesPrice: 21666,
+  highestPrice: 21666,
+  isStrikeShown: false,
+  carId: '26ee4c6c-2c55-48e8-bba7-c22aa185558d',
+  offerName: 'financing',
+  vehicleId: '26ee4c6c-2c55-48e8-bba7-c22aa185558d'
+}

package/__tests__/mockedData/mockedPendingRequestedCar.js

@@ -0,0 +1,69 @@
+export const car = {
+  _id: '63e12296aeb426dad4af5e5c',
+  odooLead: 213907,
+  buyingType: 'leasing',
+  car: {
+    _id: '30b7bdeb-c193-4dc3-9f92-86680c9fcf59',
+    metaData: {
+      creationDate: 1675668285,
+      modificationDate: 1676979836,
+      ownerId: 'ZdHm8pCH0nWnIDdky6rm37JouFv1',
+      tsn: null,
+      codeKBA: null,
+      codeDAT: null,
+      codeSchwacke: null,
+      codeJato: null,
+      mainImageId: 'HekeLJ2ehJ9R',
+      secImageId: 'CdhVrQF7kXgP',
+      thirdImageId: 'oYLuytuZTBSb',
+      vehicleId: 'F6DF54',
+      imagesCount: 0,
+      allImagesCount: 13,
+      postProcessingConfigurationId: null,
+      imagePackageID: null,
+      imagesByApp: false,
+      ownerName: 'Guardian of Auto.de',
+      imagesRemovedBg: true
+    },
+    mainData: {
+      make: 'Fiat',
+      model: '500',
+      subModel: '1,0 GSE HYBRID PIU DOLCEVITA MJ22',
+      series: '500',
+      trimLine: null,
+      vehicleClass: 'selector_vehicleClass_car',
+      category: 'selector_category_convertible',
+      modelDescription: '',
+      condition: 'selector_condition_new',
+      usageType: 'selector_unknown',
+      firstRegistration: null,
+      mileage: 15,
+      doors: 3,
+      seats: 4,
+      constructionYear: null,
+      constructionDate: null,
+      firstModelsProductionDate: null,
+      countryVersion: null,
+      numberOfPreviousOwners: 0,
+      nonSmokerVehicle: null,
+      damageUnrepaired: null,
+      accidentDamaged: false,
+      roadworthy: true,
+      damageByHail: null,
+      taxi: null,
+      damaged: false
+    },
+    createdAt: '2023-02-06T15:53:58.836Z',
+    currentSalesPrice: 30666,
+    delivery: true,
+    monthlyInstallment: 401.28,
+    paybackPeriod: 36,
+    registration: true,
+    request: 'REQ228794',
+    selfPickup: false,
+    status: 'selector_status_handing_over',
+    updatedAt: '2023-02-10T09:31:31.859Z',
+    user: 'eGWQxSdo97UPkTlYmJrNZVNQCdy1',
+    wonStatus: 'pending'
+  }
+}

package/__tests__/utils/CommonUtils/addPrefixToKeys.test.ts

@@ -0,0 +1,18 @@
+import { addPrefixToKeys } from '../../../source/framework/utils/CommonUtils';
+
+describe('addPrefixToKeys', () => {
+  it('should return an empty object when given an empty object', () => {
+    const obj = {};
+    const prefix = 'test';
+    const result = addPrefixToKeys(obj, prefix);
+    expect(result).toEqual({});
+  });
+
+  it('should add the prefix to each key in the object', () => {
+    const obj = { a: 1, b: 2, c: 3 };
+    const prefix = 'test';
+    const result = addPrefixToKeys(obj, prefix);
+    const expected = { test_a: 1, test_b: 2, test_c: 3 };
+    expect(result).toEqual(expected);
+  });
+});

package/__tests__/utils/CommonUtils/arrToObj.test.js

@@ -0,0 +1,32 @@
+import { arrToObj } from '../../../source/framework/utils/CommonUtils';
+
+const mockArr = ['first', 'second', 'third'];
+
+describe('arrToObj', () => {
+  it('should return an empty object when passed a non-array value', () => {
+    expect(arrToObj(null)).toEqual({});
+    expect(arrToObj(undefined)).toEqual({});
+    expect(arrToObj('')).toEqual({});
+    expect(arrToObj(42)).toEqual({});
+    expect(arrToObj({})).toEqual({});
+  });
+
+  it('should convert an array of strings to an object where each string is a key with a value of true', () => {
+    const obj = arrToObj(mockArr);
+    expect(obj).toMatchObject({ first: true, second: true, third: true });
+    expect(Object.keys(obj)).toHaveLength(mockArr.length);
+    mockArr.forEach((val) => {
+      expect(obj[val]).toBe(true);
+    });
+  });
+
+  it('should not modify the original array', () => {
+    const originalArr = [...mockArr];
+    arrToObj(mockArr);
+    expect(mockArr).toEqual(originalArr);
+  });
+
+  it('should return an empty object when passed an empty array', () => {
+    expect(arrToObj([])).toEqual({});
+  });
+});

package/__tests__/utils/CommonUtils/checkRangeValuesOnEqual.test.ts

@@ -0,0 +1,17 @@
+import { checkRangeValuesOnEqual } from '../../../source/framework/utils/CommonUtils';
+
+describe('checkRangeValuesOnEqual', () => {
+  it('returns true when defaultValues and filterValues have exactly the same values', () => {
+    const defaultValues = { from: 1000, to: 2000 };
+    const filterValues = { from: 1000, to: 2000 };
+    const result = checkRangeValuesOnEqual(defaultValues, filterValues);
+    expect(result).toEqual(true);
+  });
+
+  it('returns false when defaultValues and filterValues have different values', () => {
+    const defaultValues = { from: 1000, to: 2000 };
+    const filterValues = { from: 500, to: 2000 };
+    const result = checkRangeValuesOnEqual(defaultValues, filterValues);
+    expect(result).toEqual(false);
+  });
+});

package/__tests__/utils/CommonUtils/fixNumber.test.ts

@@ -0,0 +1,20 @@
+import { fixNumber } from '../../../source/framework/utils/CommonUtils';
+
+describe('fixNumber', () => {
+    it('should return fix number when given a float with two decimals', () => {
+      expect(fixNumber(5.555)).toEqual(5.56);
+    });
+    
+    it('should return fix number when given an integer', () => {
+      expect(fixNumber(6)).toEqual(6);
+    });
+  
+    it('should return fix number when given a string which have two decimal places only', () => {
+      expect(fixNumber('7.225')).toEqual(7.23);
+    });
+  
+    it('should return fix number when given a string with extra whitespace characters', () => {
+      expect(fixNumber('   4.444 ')).toEqual(4.44);
+    });
+  });
+  

package/__tests__/utils/CommonUtils/formatMileage.test.ts

@@ -0,0 +1,8 @@
+import { formatMileage } from '../../../source/framework/utils/CommonUtils';
+
+describe('formatMileage', () => {
+  it('should correctly format millage when passed as number', () => {
+    const result = formatMileage(123456789);
+    expect(result).toEqual('123.456.789');
+  });
+});

package/__tests__/utils/CommonUtils/getChipFilterValue.test.ts

@@ -0,0 +1,22 @@
+import { getChipFilterValue } from "../../../source/framework/utils/CommonUtils";
+
+const translatePathFrom = 'SearchPage:filters.from';
+const translatePathTo = 'SearchPage:filters.to';
+const t = (key: string) => key;
+const language = 'en';
+
+describe('getChipFilterValue', () => {
+  it('should return the chip with original filter value', () => {
+    const chip = { filterKey: 'MANUFACTURER', filterValue: 'Audi' };
+    const filterValue = getChipFilterValue(chip);
+    expect(filterValue).toEqual('Audi');
+  });
+
+  it('should return the correct chip for a range values with title', () => {
+    const chip = { filterKey: 'PRICE', filterValue: { from: 10000, to: 20000 } };
+    const filterValue = getChipFilterValue(chip, t, language).replace(/\s+/g, ' ').trim();
+    const translatePathPrice = `SearchPage:filters.${chip.filterKey.toLocaleLowerCase()}`;
+    const expectedValue = `${translatePathPrice} ${translatePathFrom} 10.000 ${translatePathTo} 20.000`.replace(/\s+/g, ' ').trim()
+    expect(filterValue).toBe(expectedValue);
+  });
+});

package/__tests__/utils/CommonUtils/getFormattedNumber.test.ts

@@ -0,0 +1,19 @@
+import { getFormattedNumber } from '../../../source/framework/utils/CommonUtils';
+
+describe('getFormattedNumber', () => {
+  it('should format a number with German locale', () => {
+    const formattedNumber = getFormattedNumber(123456789.5);
+    expect(formattedNumber).toBe('123.456.789,5');
+  });
+
+  it('should return null if input is not finite number', () => {
+    const formattedNumber = getFormattedNumber(NaN);
+    expect(formattedNumber).toBeNull();
+
+    const formattedNumber2 = getFormattedNumber(undefined);
+    expect(formattedNumber2).toBeNull();
+
+    const formattedNumber3 = getFormattedNumber('invalidNumber' as any);
+    expect(formattedNumber3).toBeNull();
+  });
+});

package/__tests__/utils/CommonUtils/getFormattedPrice.test.ts

@@ -0,0 +1,19 @@
+import { getFormattedPrice } from '../../../source/framework/utils/CommonUtils';
+
+describe('getFormattedPrice', () => {
+  it('should format the given price correctly with default parameters', () => {
+    const result = getFormattedPrice(1234567890);
+    expect(result).toEqual('1.234.567.890');
+  });
+
+  it('should format the given price correctly with custom format and currency', () => {
+    const result = getFormattedPrice(1990.75, '$.2f', 'USD');
+    expect(result).toEqual('1990,75USD');
+  });
+
+  it('should return "-" if price is not finite number or null/undefined', () => {
+    expect(getFormattedPrice(undefined)).toEqual('-');
+    expect(getFormattedPrice(null)).toEqual('-');
+    expect(getFormattedPrice(NaN)).toEqual('-');
+  });
+});

package/__tests__/utils/CommonUtils/getGroupValuesForQuery.test.ts

@@ -0,0 +1,51 @@
+import { getGroupValuesForQuery } from '../../../source/framework/utils/CommonUtils';
+
+describe('getGroupValuesForQuery', () => {
+  it('should return array of objects, each containing key/value pairs for all properties with truthy values', () => {
+    const filterObj = [
+      {
+        MANUFACTURER: {
+            field: 'mainData_make',
+            value: 'Audi',
+            isAbsolute: true
+        },
+        MODEL: {
+            field: 'mainData_model',
+            value: 'A5',
+            isAbsolute: true
+        },
+        SUB_MODEL: {
+            field: 'mainData_subModel',
+            value: 'sportback',
+            isAbsolute: true
+        },
+        SERIES: {
+            field: 'mainData_series',
+            value: 'series',
+            isAbsolute: true
+        }
+    }
+    ];
+
+    const result = getGroupValuesForQuery(filterObj);
+
+    const expectedResult = [
+      {
+        MANUFACTURER: 'Audi',
+        MODEL: 'A5',
+        SUB_MODEL: 'sportback',
+        SERIES: 'series'
+      }
+    ]
+
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('should return empty array if argument is an empty array', () => {
+    const groups: any[] = [];
+
+    const result = getGroupValuesForQuery(groups);
+
+    expect(result).toEqual([]);
+  });
+});

package/__tests__/utils/CommonUtils/getOfferSliders.test.ts

@@ -0,0 +1,64 @@
+import { getOfferSliders } from '../../../source/framework/utils/CommonUtils';
+import { financingConfig } from '../../mockedData/financingConfig';
+
+const expectedResultCDP = [
+  {
+    name: 'firstInstallment',
+    min: 0,
+    step: 100,
+    unit: 'euro',
+    max: 21666,
+    value: 16100,
+    unitName: 'modals:financing.euro',
+    caption: 'modals:financing.firstInstallment',
+    withRangeLimit: true
+  },
+  {
+    name: 'annualMileage',
+    min: 5000,
+    max: 60000,
+    step: 5000,
+    unit: 'km',
+    value: 40000,
+    unitName: 'modals:financing.km',
+    caption: 'modals:financing.annualMileage'
+  }
+]
+
+const expectedResultCheckout = [
+  {
+    name: 'firstInstallment',
+    min: 0,
+    step: 100,
+    unit: 'euro',
+    max: 21666,
+    value: 16100,
+    unitName: 'modals:financing.euro',
+    caption: 'modals:financing.firstInstallment',
+    withRangeLimit: true
+  }
+]
+
+const t = (phrase: string, options?: object) => {
+  return `${phrase} ${options ? options : ''}`.trim();
+}
+
+describe('getOfferSliders', () => {
+  it('should return correct array with slider data for CDP', () => {
+
+    const priceTabIndex = 0; // financing tab
+    const componentType = 'main';
+
+    const result = getOfferSliders(financingConfig, t, priceTabIndex, componentType);
+    expect(result).toEqual(expectedResultCDP);
+  })
+
+  it('should return correct array with slider data for checkout page without annual mileage for financing', () => {
+
+    const priceTabIndex = 0; // financing tab
+    const componentType = 'checkout';
+
+    const result = getOfferSliders(financingConfig, t, priceTabIndex, componentType);
+    expect(result).toEqual(expectedResultCheckout);
+  })
+})

package/__tests__/utils/CommonUtils/getPriceRating.test.ts

@@ -0,0 +1,26 @@
+import { getPriceRating } from "../../../utils";
+
+describe('getPriceRating', () => {
+  it('should return 0 when input price is undefined or null', () => {
+    expect(getPriceRating(undefined, undefined)).toBe(0);
+    expect(getPriceRating(null, null)).toBe(0);
+  });
+
+  it('should return 1 when current price match the highest price in ratingConfig', () => {
+    const currentSalesPrice = 3800;
+    const predictablePrice = 3000;
+    expect(getPriceRating(currentSalesPrice, predictablePrice)).toBe(1);
+  });
+
+  it('should return topPrice index in priceRatings when current sales price less than or equals to range of topPrice', () => {
+    const currentSalesPrice = 1000;
+    const predictablePrice = 10000;
+    expect(getPriceRating(currentSalesPrice, predictablePrice)).toBe(5);
+  });
+
+  it('should return correct price rating index based on currentSalesPrice and predictablePrice', () => {
+    const currentSalesPrice = 9600;
+    const predictablePrice = 10000;
+    expect(getPriceRating(currentSalesPrice, predictablePrice)).toBe(3); // fairPrice index in priceRatings array
+  });
+});

package/__tests__/utils/CommonUtils/getPriceRatingConfig.test.ts

@@ -0,0 +1,33 @@
+import { getPriceRatingConfig } from '../../../utils';
+
+describe('getPriceRatingConfig', () => {
+  it('should generate the pricing config correctly', () => {
+    const currentPrice = 5000
+    const pricePredicted = 4000
+
+    const expectedOutput = {
+      topPrice: { min: 3000, max: 3600 },
+      goodPrice: { min: 3600, max: 3800 },
+      fairPrice: { min: 3800, max: 4200 },
+      increasedPrice: { min: 4200, max: 4700 },
+      highPrice: { min: 4700, max: 5000 }
+    }
+
+    expect(getPriceRatingConfig(currentPrice, pricePredicted)).toEqual(expectedOutput)
+  })
+
+  it('should return "???" for invalid predicted prices', () => {
+    const currentPrice = 5000
+    const pricePredicted = NaN
+
+    const expectedOutput = {
+      topPrice: { min: '???', max: '???' },
+      goodPrice: { min: '???', max: '???' },
+      fairPrice: { min: '???', max: '???' },
+      increasedPrice: { min: '???', max: '???' },
+      highPrice: { min: '???', max: '???' }
+    }
+
+    expect(getPriceRatingConfig(currentPrice, pricePredicted)).toEqual(expectedOutput)
+  })
+})

package/__tests__/utils/CommonUtils/preloadNearbyImages.test.ts

@@ -0,0 +1,9 @@
+import { preloadNearbyImages } from '../../../source/framework/utils/CommonUtils';
+
+describe('preloadNearbyImages', () => {
+  it('should not break when no images provided', () => {
+    preloadNearbyImages([], 0, 'imageUrlMedium');
+
+    expect(document.images).toHaveLength(0);
+  });
+});