1007 lines
32 KiB
JavaScript
1007 lines
32 KiB
JavaScript
import * as servicePackageHelper from '@/helpers/service-package-helper';
|
|
import partTypeStrings from '@/constants/part-type-strings.js';
|
|
import damageLocationsSelected from '@/constants/damage-locations-selected.js';
|
|
import packageNames from '@/constants/package-names.js';
|
|
|
|
const recalLineItem = {
|
|
partNumber: 'RECAL STATIC',
|
|
Description: 'Recalibration',
|
|
partType: 'recalibration',
|
|
Quantity: '1',
|
|
price: 150.0
|
|
};
|
|
|
|
const driverFrontWiperLineItem = {
|
|
partNumber: 'SBB16',
|
|
description: 'SAFELITE BEAM BLADE 16',
|
|
partType: 'FRONT WIPER',
|
|
price: 32.64
|
|
};
|
|
|
|
const passengerFrontWiperLineItem = {
|
|
partNumber: 'SBB26',
|
|
description: 'SAFELITE BEAM BLADE 26',
|
|
partType: 'FRONT WIPER',
|
|
price: 53.04
|
|
};
|
|
|
|
const rearWiperLineItem = {
|
|
partNumber: 'SBBR12A',
|
|
description: 'SAFELITE REAR BLADE 12A',
|
|
partType: 'REAR WIPER',
|
|
price: 24.48
|
|
};
|
|
|
|
const rainDefenseLineItem = {
|
|
partNumber: 'RAIN REPEL',
|
|
description: null,
|
|
partType: 'RAIN REPEL',
|
|
price: 35.5
|
|
};
|
|
|
|
const frontWindshieldGlass = {
|
|
glassLocation: 'Windshield'
|
|
};
|
|
|
|
const rearWindshieldGlass = {
|
|
glassLocation: 'Rear'
|
|
};
|
|
|
|
const sideGlass = {
|
|
glassLocation: 'Driver'
|
|
};
|
|
|
|
describe('service-package-helper.js', () => {
|
|
describe('findLineItemsWithPartType', () => {
|
|
it('Returns an item of the same type when present', () => {
|
|
// Arrange
|
|
const lineItems = [
|
|
recalLineItem,
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const partType = partTypeStrings.RAIN_DEFENSE;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.findLineItemsWithPartType(partType, lineItems);
|
|
|
|
// Assert
|
|
expect(result.length).toBe(1);
|
|
expect(result[0].partType).toEqual(partType);
|
|
});
|
|
|
|
it('Returns an empty array when no matching items are present', () => {
|
|
// Arrange
|
|
const lineItems = [
|
|
recalLineItem,
|
|
passengerFrontWiperLineItem,
|
|
driverFrontWiperLineItem
|
|
];
|
|
const partType = partTypeStrings.RAIN_DEFENSE;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.findLineItemsWithPartType(partType, lineItems);
|
|
|
|
// Assert
|
|
expect(result.length).toBe(0);
|
|
});
|
|
|
|
it('Returns all matching items when multiple are present', () => {
|
|
// Arrange
|
|
const lineItems = [
|
|
recalLineItem,
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const partType = partTypeStrings.FRONT_WIPER;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.findLineItemsWithPartType(partType, lineItems);
|
|
|
|
// Assert
|
|
expect(result.length).toBe(2);
|
|
expect(result[0].partType).toEqual(partType);
|
|
expect(result[1].partType).toEqual(partType);
|
|
expect(result[0].partNumber).not.toEqual(result[1].partNumber);
|
|
});
|
|
|
|
it('Is not case sensitive', () => {
|
|
// Arrange
|
|
const lineItems = [
|
|
recalLineItem,
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const partType = 'rAin rEpeL';
|
|
|
|
// Act
|
|
const result = servicePackageHelper.findLineItemsWithPartType(partType, lineItems);
|
|
|
|
// Assert
|
|
expect(result.length).toBe(1);
|
|
expect(result[0].partType).toEqual(partTypeStrings.RAIN_DEFENSE);
|
|
});
|
|
});
|
|
|
|
describe('containsLineItemWithPartType', () => {
|
|
it('Returns true when type is present', () => {
|
|
// Arrange
|
|
const lineItems = [
|
|
recalLineItem,
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const partType = partTypeStrings.RAIN_DEFENSE;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.containsLineItemWithPartType(partType, lineItems);
|
|
|
|
// Assert
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('Returns true when type is present multiple times', () => {
|
|
// Arrange
|
|
const lineItems = [
|
|
recalLineItem,
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const partType = partTypeStrings.FRONT_WIPER;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.containsLineItemWithPartType(partType, lineItems);
|
|
|
|
// Assert
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('Returns false when type is not present', () => {
|
|
// Arrange
|
|
const lineItems = [
|
|
recalLineItem,
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem
|
|
];
|
|
const partType = partTypeStrings.RAIN_DEFENSE;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.containsLineItemWithPartType(partType, lineItems);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('Returns false with empty array', () => {
|
|
// Arrange
|
|
const lineItems = [];
|
|
const partType = partTypeStrings.RAIN_DEFENSE;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.containsLineItemWithPartType(partType, lineItems);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('getVapsLineItems', () => {
|
|
it('Returns line items matching given types', () => {
|
|
// Arrange
|
|
const lineItems = [
|
|
recalLineItem,
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
|
|
const vapTypes = [partTypeStrings.RAIN_DEFENSE];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getVapsLineItems(lineItems, vapTypes);
|
|
|
|
// Assert
|
|
expect(result.length).toBe(1);
|
|
expect(result[0].partType).toEqual(partTypeStrings.RAIN_DEFENSE);
|
|
});
|
|
|
|
it('Returns all matching line items, when multiple match a single type', () => {
|
|
// Arrange
|
|
const lineItems = [
|
|
recalLineItem,
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
|
|
const vapTypes = [partTypeStrings.FRONT_WIPER];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getVapsLineItems(lineItems, vapTypes);
|
|
|
|
// Assert
|
|
expect(result.length).toBe(2);
|
|
expect(result[0].partType).toEqual(partTypeStrings.FRONT_WIPER);
|
|
expect(result[1].partType).toEqual(partTypeStrings.FRONT_WIPER);
|
|
expect(result[0].partNumber).not.toEqual(result[1].partNumber);
|
|
});
|
|
|
|
it('Returns only line items in the given set', () => {
|
|
// Arrange
|
|
const lineItems = [recalLineItem, passengerFrontWiperLineItem, rainDefenseLineItem];
|
|
|
|
const vapTypes = [partTypeStrings.FRONT_WIPER];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getVapsLineItems(lineItems, vapTypes);
|
|
|
|
// Assert
|
|
expect(result.length).toBe(1);
|
|
expect(result[0].partType).toEqual(partTypeStrings.FRONT_WIPER);
|
|
expect(result[0].partNumber).toEqual(passengerFrontWiperLineItem.partNumber);
|
|
});
|
|
|
|
it('Returns all matching items when multiple vap types are requested', () => {
|
|
// Arrange
|
|
const lineItems = [recalLineItem, passengerFrontWiperLineItem, rainDefenseLineItem];
|
|
|
|
const vapTypes = [partTypeStrings.FRONT_WIPER, partTypeStrings.RAIN_DEFENSE];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getVapsLineItems(lineItems, vapTypes);
|
|
|
|
// Assert
|
|
expect(result.length).toBe(2);
|
|
expect(result[0].partType).not.toEqual(result[1].partType);
|
|
});
|
|
});
|
|
|
|
describe('containsGlassPieceWithLocation', () => {
|
|
it('Returns true when location is present', () => {
|
|
// Arrange
|
|
const locations = [frontWindshieldGlass, sideGlass];
|
|
|
|
const locationName = damageLocationsSelected.WINDSHIELD;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.containsGlassPieceWithLocation(
|
|
locationName,
|
|
locations
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('Returns true when location is present multiple times', () => {
|
|
// Arrange
|
|
const locations = [frontWindshieldGlass, frontWindshieldGlass, sideGlass];
|
|
|
|
const locationName = damageLocationsSelected.WINDSHIELD;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.containsGlassPieceWithLocation(
|
|
locationName,
|
|
locations
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('Returns false when location is not present', () => {
|
|
// Arrange
|
|
const locations = [frontWindshieldGlass, sideGlass];
|
|
|
|
const locationName = damageLocationsSelected.REAR;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.containsGlassPieceWithLocation(
|
|
locationName,
|
|
locations
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('Returns false with empty array', () => {
|
|
// Arrange
|
|
const locations = [];
|
|
|
|
const locationName = damageLocationsSelected.WINDSHIELD;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.containsGlassPieceWithLocation(
|
|
locationName,
|
|
locations
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('Is not case sensitive', () => {
|
|
// Arrange
|
|
const locations = [frontWindshieldGlass, sideGlass];
|
|
|
|
const locationName = 'windShieLd';
|
|
|
|
// Act
|
|
const result = servicePackageHelper.containsGlassPieceWithLocation(
|
|
locationName,
|
|
locations
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('getAvailablePackages', () => {
|
|
it('Returns two packages when there is not a viable tier-two option.', () => {
|
|
// Arrange
|
|
const damageLocations = [sideGlass];
|
|
|
|
const availableLineItems = [rainDefenseLineItem];
|
|
|
|
// Act
|
|
const results = servicePackageHelper.getAvailablePackages(
|
|
damageLocations,
|
|
availableLineItems,
|
|
false
|
|
);
|
|
|
|
// Assert
|
|
expect(results.length).toBe(2);
|
|
expect(results[0].packageName).toEqual(packageNames.TIER_ONE);
|
|
expect(results[1].packageName).toEqual(packageNames.TIER_THREE);
|
|
});
|
|
|
|
it('Returns three packages when wipers are available in tier two', () => {
|
|
// Arrange
|
|
const damageLocations = [rearWindshieldGlass];
|
|
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
|
|
// Act
|
|
const results = servicePackageHelper.getAvailablePackages(
|
|
damageLocations,
|
|
availableLineItems,
|
|
true
|
|
);
|
|
|
|
// Assert
|
|
expect(results.length).toBe(3);
|
|
expect(results[0].packageName).toEqual(packageNames.TIER_ONE);
|
|
expect(results[1].packageName).toEqual(packageNames.TIER_TWO);
|
|
expect(results[2].packageName).toEqual(packageNames.TIER_THREE);
|
|
});
|
|
});
|
|
|
|
// TODO write tests
|
|
describe('getPackageContents', () => {
|
|
describe('Match figma cases', () => {
|
|
test.todo('Implement specific cases.');
|
|
});
|
|
});
|
|
|
|
describe('shouldFrontWipersBeAvailable', () => {
|
|
it('Should be available in tier 2 and 3 if windshield damage and available', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [driverFrontWiperLineItem, passengerFrontWiperLineItem];
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const resultTwo = servicePackageHelper.shouldFrontWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_TWO
|
|
);
|
|
const resultThree = servicePackageHelper.shouldFrontWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_THREE
|
|
);
|
|
|
|
// Assert
|
|
expect(resultTwo).toBe(true);
|
|
expect(resultThree).toBe(true);
|
|
});
|
|
|
|
it('Should be available in tier 2 and 3 if repair and available', () => {
|
|
// Arrange
|
|
const damageLocations = [];
|
|
const availableLineItems = [driverFrontWiperLineItem, passengerFrontWiperLineItem];
|
|
const isRepair = true;
|
|
|
|
// Act
|
|
const resultTwo = servicePackageHelper.shouldFrontWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_TWO
|
|
);
|
|
const resultThree = servicePackageHelper.shouldFrontWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_THREE
|
|
);
|
|
|
|
// Assert
|
|
expect(resultTwo).toBe(true);
|
|
expect(resultThree).toBe(true);
|
|
});
|
|
|
|
it('Should not be available in tier 2 if not windshield damage or repair', () => {
|
|
// Arrange
|
|
const damageLocations = [];
|
|
const availableLineItems = [driverFrontWiperLineItem, passengerFrontWiperLineItem];
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldFrontWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_TWO
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('Should be available in tier 3 even if not windshield repair or replace', () => {
|
|
// Arrange
|
|
const damageLocations = [];
|
|
const availableLineItems = [driverFrontWiperLineItem, passengerFrontWiperLineItem];
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldFrontWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_THREE
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('Should not be available in any tier if not available.', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [];
|
|
const isRepair = true;
|
|
|
|
// Act
|
|
const resultOne = servicePackageHelper.shouldFrontWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_ONE
|
|
);
|
|
const resultTwo = servicePackageHelper.shouldFrontWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_TWO
|
|
);
|
|
const resultThree = servicePackageHelper.shouldFrontWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_THREE
|
|
);
|
|
|
|
// Assert
|
|
expect(resultOne).toBe(false);
|
|
expect(resultTwo).toBe(false);
|
|
expect(resultThree).toBe(false);
|
|
});
|
|
|
|
it('Should not be available in tier 1', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [driverFrontWiperLineItem, passengerFrontWiperLineItem];
|
|
const isRepair = true;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldFrontWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_ONE
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('shouldRearWipersBeAvailable', () => {
|
|
it('Should be available in tier 2 and 3 if rear damage and available', () => {
|
|
// Arrange
|
|
const damageLocations = [rearWindshieldGlass];
|
|
const availableLineItems = [rearWiperLineItem];
|
|
|
|
// Act
|
|
const resultTwo = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
packageNames.TIER_TWO
|
|
);
|
|
const resultThree = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
packageNames.TIER_THREE
|
|
);
|
|
|
|
// Assert
|
|
expect(resultTwo).toBe(true);
|
|
expect(resultThree).toBe(true);
|
|
});
|
|
|
|
it('Should not be available in tier 2 if not rear damage', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [rearWiperLineItem];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
packageNames.TIER_TWO
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('Should be available in tier 3 without rear damage, if available and no front wipers available', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [rearWiperLineItem];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
packageNames.TIER_THREE
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it('Should not be available in tier 3 without rear damage if front wipers are available', () => {
|
|
// Arrange
|
|
const damageLocations = [];
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem
|
|
];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
packageNames.TIER_THREE
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('Should not be available in any tier if not available', () => {
|
|
// Arrange
|
|
const damageLocations = [rearWindshieldGlass];
|
|
const availableLineItems = [];
|
|
|
|
// Act
|
|
const resultOne = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
packageNames.TIER_ONE
|
|
);
|
|
const resultTwo = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
packageNames.TIER_TWO
|
|
);
|
|
const resultThree = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
packageNames.TIER_THREE
|
|
);
|
|
|
|
// Assert
|
|
expect(resultOne).toBe(false);
|
|
expect(resultTwo).toBe(false);
|
|
expect(resultThree).toBe(false);
|
|
});
|
|
|
|
it('Should not be available in tier 1', () => {
|
|
// Arrange
|
|
const damageLocations = [rearWindshieldGlass];
|
|
const availableLineItems = [rearWiperLineItem];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
packageNames.TIER_ONE
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('shouldRainDefenseBeAvailable', () => {
|
|
it('Should generally be available only in tier 3', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [
|
|
rainDefenseLineItem,
|
|
driverFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
recalLineItem
|
|
];
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const resultOne = servicePackageHelper.shouldRainDefenseBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_ONE
|
|
);
|
|
const resultTwo = servicePackageHelper.shouldRainDefenseBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_TWO
|
|
);
|
|
const resultThree = servicePackageHelper.shouldRainDefenseBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_THREE
|
|
);
|
|
|
|
// Assert
|
|
expect(resultOne).toBe(false);
|
|
expect(resultTwo).toBe(false);
|
|
expect(resultThree).toBe(true);
|
|
});
|
|
|
|
it('Should not be available in a specific scenario', () => {
|
|
// Arrange
|
|
// SPECIFICALLY: no front windshield
|
|
const damageLocations = [rearWindshieldGlass];
|
|
const availableLineItems = [
|
|
rainDefenseLineItem,
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem
|
|
];
|
|
// SPECIFICALLY: not repair
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldRainDefenseBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_THREE
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('getLowestTierForType', () => {
|
|
it('Should return the tier for items available in one tier only', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass, rearWindshieldGlass];
|
|
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getLowestTierForType(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
partTypeStrings.RAIN_DEFENSE
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toEqual(packageNames.TIER_THREE);
|
|
});
|
|
|
|
it('Should return tier 2 for items in tier 2 and 3', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass, rearWindshieldGlass];
|
|
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const resultFront = servicePackageHelper.getLowestTierForType(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
partTypeStrings.FRONT_WIPER
|
|
);
|
|
const resultRear = servicePackageHelper.getLowestTierForType(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
partTypeStrings.REAR_WIPER
|
|
);
|
|
|
|
// Assert
|
|
expect(resultFront).toEqual(packageNames.TIER_TWO);
|
|
expect(resultRear).toEqual(packageNames.TIER_TWO);
|
|
});
|
|
|
|
it('Should return tier 1 for any item not in any tier', () => {
|
|
// Arrange
|
|
const damageLocations = [rearWindshieldGlass];
|
|
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem
|
|
];
|
|
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const resultFront = servicePackageHelper.getLowestTierForType(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
partTypeStrings.RAIN_DEFENSE
|
|
);
|
|
|
|
// Assert
|
|
expect(resultFront).toEqual(packageNames.TIER_ONE);
|
|
});
|
|
});
|
|
|
|
describe('getHighestRequiredTier', () => {
|
|
it('Should return the highest tier among items', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const isRepair = false;
|
|
const vaps = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getHighestRequiredTier(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
vaps
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toEqual(packageNames.TIER_THREE);
|
|
});
|
|
|
|
it('Should not return a higher tier than items require', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const isRepair = false;
|
|
const vaps = [driverFrontWiperLineItem, passengerFrontWiperLineItem];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getHighestRequiredTier(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
vaps
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toEqual(packageNames.TIER_TWO);
|
|
});
|
|
|
|
it('Should return tier 1 for empty set', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const isRepair = false;
|
|
const vaps = [];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getHighestRequiredTier(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
vaps
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toEqual(packageNames.TIER_ONE);
|
|
});
|
|
|
|
it('Should return tier 1 if no vaps are part of tiers', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const isRepair = false;
|
|
const vaps = [recalLineItem];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getHighestRequiredTier(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
vaps
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toEqual(packageNames.TIER_ONE);
|
|
});
|
|
});
|
|
|
|
describe('getHighestSatisfiedTier', () => {
|
|
it('Should return the highest tier if multiple are satisfied', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass, rearWindshieldGlass];
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const isRepair = false;
|
|
const vaps = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rainDefenseLineItem,
|
|
rearWiperLineItem
|
|
];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getHighestFullySatisfiedTier(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
vaps
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toEqual(packageNames.TIER_THREE);
|
|
});
|
|
|
|
it('Should only return *satisfied* tier', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const isRepair = false;
|
|
const vaps = [driverFrontWiperLineItem, passengerFrontWiperLineItem];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getHighestFullySatisfiedTier(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
vaps
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toEqual(packageNames.TIER_TWO);
|
|
});
|
|
|
|
it('Should not return a tier if it is only partially satisfied', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const isRepair = false;
|
|
const vaps = [rainDefenseLineItem];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getHighestFullySatisfiedTier(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
vaps
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toEqual(packageNames.TIER_ONE);
|
|
});
|
|
|
|
it('Should return tier 1 if no vaps are selected.', () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [
|
|
driverFrontWiperLineItem,
|
|
passengerFrontWiperLineItem,
|
|
rearWiperLineItem,
|
|
rainDefenseLineItem
|
|
];
|
|
const isRepair = false;
|
|
const vaps = [];
|
|
|
|
// Act
|
|
const result = servicePackageHelper.getHighestFullySatisfiedTier(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
vaps
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toEqual(packageNames.TIER_ONE);
|
|
});
|
|
});
|
|
});
|