1023 lines
32 KiB
JavaScript
1023 lines
32 KiB
JavaScript
import * as servicePackageHelper from "@/helpers/service-package-helper";
|
|
import { partTypeStrings } from "@/constants/part-type-strings";
|
|
import { damageLocationsSelected as glassLocations } from "@/constants/damage-locations-selected";
|
|
import { packageNames } from "@/constants/package-names";
|
|
|
|
describe("service-package-helper.js", () => {
|
|
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("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 DEfenSe";
|
|
|
|
// Act
|
|
const result = servicePackageHelper.findLineItemsWithPartType(partType, lineItems);
|
|
|
|
// Assert
|
|
expect(result.length).toBe(1);
|
|
expect(result[0].partType).toEqual(partTypeStrings.RAIN_DEFENSE);
|
|
});
|
|
});
|
|
|
|
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 = glassLocations.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 = glassLocations.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 = glassLocations.REAR;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.containsGlassPieceWithLocation(
|
|
locationName,
|
|
locations
|
|
);
|
|
|
|
// Assert
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it("Returns false with empty array", () => {
|
|
// Arrange
|
|
const locations = [];
|
|
|
|
const locationName = glassLocations.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);
|
|
});
|
|
});
|
|
|
|
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];
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const resultTwo = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_TWO
|
|
);
|
|
const resultThree = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
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 rear damage", () => {
|
|
// Arrange
|
|
const damageLocations = [frontWindshieldGlass];
|
|
const availableLineItems = [rearWiperLineItem];
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
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];
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
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,
|
|
];
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
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 = [];
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const resultOne = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_ONE
|
|
);
|
|
const resultTwo = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
packageNames.TIER_TWO
|
|
);
|
|
const resultThree = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
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 = [rearWindshieldGlass];
|
|
const availableLineItems = [rearWiperLineItem];
|
|
const isRepair = false;
|
|
|
|
// Act
|
|
const result = servicePackageHelper.shouldRearWipersBeAvailable(
|
|
damageLocations,
|
|
availableLineItems,
|
|
isRepair,
|
|
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);
|
|
});
|
|
});
|
|
});
|
|
|
|
// Constants
|
|
|
|
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 DEFENSE",
|
|
description: null,
|
|
partType: "RAIN DEFENSE",
|
|
price: 35.5,
|
|
};
|
|
|
|
const frontWindshieldGlass = {
|
|
glassLocation: "Windshield",
|
|
};
|
|
|
|
const rearWindshieldGlass = {
|
|
glassLocation: "Rear",
|
|
};
|
|
|
|
const sideGlass = {
|
|
glassLocation: "Driver",
|
|
};
|