From af6809256e966e385b04b02dec26ef5f1210abae Mon Sep 17 00:00:00 2001
From: Chloe Herd <chloe.herd@safelite.com>
Date: Thu, 22 Jun 2023 08:57:32 -0400
Subject: [PATCH] Extract & refactor service package logic to helper class.

---
 src/helpers/service-package-helper.js      |  252 +++++
 src/helpers/service-package-helper.spec.js | 1054 ++++++++++++++++++++
 2 files changed, 1306 insertions(+)
 create mode 100644 src/helpers/service-package-helper.js
 create mode 100644 src/helpers/service-package-helper.spec.js

diff --git a/src/helpers/service-package-helper.js b/src/helpers/service-package-helper.js
new file mode 100644
index 000000000..7ce612ce3
--- /dev/null
+++ b/src/helpers/service-package-helper.js
@@ -0,0 +1,252 @@
+import { partTypeStrings } from "@/constants/part-type-strings";
+import { damageLocationsSelected as glassLocations } from "@/constants/damage-locations-selected";
+
+export const packageNames = {
+    TIER_ONE: "TierOne",
+    TIER_TWO: "TierTwo",
+    TIER_THREE: "TierThree",
+};
+
+export function containsLineItemWithPartType(typeToFind, itemsToSearch) {
+    const partTypeMatches = findLineItemsWithPartType(typeToFind, itemsToSearch);
+    return !!partTypeMatches.length;
+}
+
+export function findLineItemsWithPartType(typeToFind, itemsToSearch) {
+    const partTypeMatches = itemsToSearch.filter(
+        (lineItem) => lineItem.partType.toUpperCase() === typeToFind.toUpperCase()
+    );
+
+    return partTypeMatches;
+}
+
+export function getVapsLineItems(availableLineItems, vapTypes) {
+    let lineItems = [];
+
+    for (let i = 0; i < vapTypes.length; i++) {
+        lineItems.push(...findLineItemsWithPartType(vapTypes[i], availableLineItems));
+    }
+
+    return lineItems;
+}
+
+export function containsGlassPieceWithLocation(locationToFind, glassPiecesToSearch) {
+    const glassLocationMatches = glassPiecesToSearch.filter(
+        (glassPiece) => glassPiece.glassLocation.toUpperCase() === locationToFind.toUpperCase()
+    );
+
+    return !!glassLocationMatches.length;
+}
+
+export function getAvailablePackages(glassToReplace, availableLineItems, isRepair) {
+    let tierOneVaps = getPackageContents(
+        glassToReplace,
+        availableLineItems,
+        isRepair,
+        packageNames.TIER_ONE
+    );
+    let tierTwoVaps = getPackageContents(
+        glassToReplace,
+        availableLineItems,
+        isRepair,
+        packageNames.TIER_TWO
+    );
+    let tierThreeVaps = getPackageContents(
+        glassToReplace,
+        availableLineItems,
+        isRepair,
+        packageNames.TIER_THREE
+    );
+
+    if (tierTwoVaps.length === 0) {
+        return [
+            {
+                packageName: packageNames.TIER_ONE,
+                vapTypes: tierOneVaps,
+            },
+            {
+                packageName: packageNames.TIER_THREE,
+                vapTypes: tierThreeVaps,
+            },
+        ];
+    } else {
+        return [
+            {
+                packageName: packageNames.TIER_ONE,
+                vapTypes: tierOneVaps,
+            },
+            {
+                packageName: packageNames.TIER_TWO,
+                vapTypes: tierTwoVaps,
+            },
+            {
+                packageName: packageNames.TIER_THREE,
+                vapTypes: tierThreeVaps,
+            },
+        ];
+    }
+}
+
+export function getPackageContents(glassToReplace, availableLineItems, isRepair, targetTier) {
+    let vaps = [];
+
+    if (shouldFrontWipersBeAvailable(glassToReplace, availableLineItems, isRepair, targetTier)) {
+        vaps.push(partTypeStrings.FRONT_WIPER);
+    }
+    if (shouldRearWipersBeAvailable(glassToReplace, availableLineItems, isRepair, targetTier)) {
+        vaps.push(partTypeStrings.REAR_WIPER);
+    }
+    if (shouldRainDefenseBeAvailable(glassToReplace, availableLineItems, isRepair, targetTier)) {
+        vaps.push(partTypeStrings.RAIN_DEFENSE);
+    }
+
+    return vaps;
+}
+
+export function shouldFrontWipersBeAvailable(
+    glassToReplace,
+    availableLineItems,
+    isRepair,
+    targetTier
+) {
+    const frontWiperIsAvailable = containsLineItemWithPartType(
+        partTypeStrings.FRONT_WIPER,
+        availableLineItems
+    );
+    const isFrontWindshieldTask =
+        isRepair || containsGlassPieceWithLocation(glassLocations.WINDSHIELD, glassToReplace);
+
+    switch (targetTier) {
+        case packageNames.TIER_TWO:
+            return frontWiperIsAvailable && isFrontWindshieldTask;
+        case packageNames.TIER_THREE:
+            return frontWiperIsAvailable;
+        default:
+            return false;
+    }
+}
+
+export function shouldRearWipersBeAvailable(
+    glassToReplace,
+    availableLineItems,
+    isRepair,
+    targetTier
+) {
+    const rearWiperIsAvailable = containsLineItemWithPartType(
+        partTypeStrings.REAR_WIPER,
+        availableLineItems
+    );
+    const frontWiperIsAvailable = containsLineItemWithPartType(
+        partTypeStrings.FRONT_WIPER,
+        availableLineItems
+    );
+    const isRearWindshieldTask = containsGlassPieceWithLocation(
+        glassLocations.REAR,
+        glassToReplace
+    );
+
+    switch (targetTier) {
+        case packageNames.TIER_TWO:
+            return rearWiperIsAvailable && isRearWindshieldTask;
+        case packageNames.TIER_THREE:
+            return rearWiperIsAvailable && (isRearWindshieldTask || !frontWiperIsAvailable);
+        default:
+            return false;
+    }
+}
+
+export function shouldRainDefenseBeAvailable(
+    glassToReplace,
+    availableLineItems,
+    isRepair,
+    targetTier
+) {
+    const isTierThree = targetTier === packageNames.TIER_THREE;
+    const rainDefenseIsAvailable = containsLineItemWithPartType(
+        partTypeStrings.RAIN_DEFENSE,
+        availableLineItems
+    );
+    const frontWipersInTierTwo = shouldFrontWipersBeAvailable(
+        glassToReplace,
+        availableLineItems,
+        isRepair,
+        packageNames.TIER_TWO
+    );
+    const frontWipersInTierThree = shouldFrontWipersBeAvailable(
+        glassToReplace,
+        availableLineItems,
+        isRepair,
+        packageNames.TIER_THREE
+    );
+    const rearWipersInTierTwo = shouldRearWipersBeAvailable(
+        glassToReplace,
+        availableLineItems,
+        isRepair,
+        packageNames.TIER_TWO
+    );
+
+    return (
+        isTierThree &&
+        rainDefenseIsAvailable &&
+        !(rearWipersInTierTwo && !frontWipersInTierTwo && frontWipersInTierThree)
+    );
+}
+
+export function getLowestTierForType(glassToReplace, availableLineItems, isRepair, partType) {
+    const packages = getAvailablePackages(glassToReplace, availableLineItems, isRepair);
+    for (let i = 0; i < packages.length; i++) {
+        for (let j = 0; j < packages[i].vapTypes.length; j++) {
+            if (packages[i].vapTypes[j].toUpperCase() === partType.toUpperCase()) {
+                return packages[i].packageName;
+            }
+        }
+    }
+
+    return packageNames.TIER_ONE;
+}
+
+export function getHighestRequiredTier(glassToReplace, availableLineItems, isRepair, vaps) {
+    let currentHighestTier = packageNames.TIER_ONE;
+    for (let i = 0; i < vaps.length; i++) {
+        const lowestTierForItem = getLowestTierForType(
+            glassToReplace,
+            availableLineItems,
+            isRepair,
+            vaps[i].partType
+        );
+
+        currentHighestTier = maxTier(currentHighestTier, lowestTierForItem);
+    }
+
+    return currentHighestTier;
+}
+
+export function getHighestFullySatisfiedTier(glassToReplace, availableLineItems, isRepair, vaps) {
+    const packages = getAvailablePackages(glassToReplace, availableLineItems, isRepair);
+    let highestSatisfiedPackage = packageNames.TIER_ONE;
+
+    for (let i = 0; i < packages.length; i++) {
+        let isPackageSatisfied = true;
+        for (let j = 0; j < packages[i].vapTypes.length; j++) {
+            isPackageSatisfied =
+                isPackageSatisfied && containsLineItemWithPartType(packages[i].vapTypes[j], vaps);
+        }
+        if (isPackageSatisfied) {
+            highestSatisfiedPackage = packages[i].packageName;
+        }
+    }
+
+    return highestSatisfiedPackage;
+}
+
+function maxTier(tierA, tierB) {
+    if (tierA === packageNames.TIER_THREE || tierB === packageNames.TIER_THREE) {
+        return packageNames.TIER_THREE;
+    }
+
+    if (tierA === packageNames.TIER_TWO || tierB === packageNames.TIER_TWO) {
+        return packageNames.TIER_TWO;
+    }
+
+    return packageNames.TIER_ONE;
+}
diff --git a/src/helpers/service-package-helper.spec.js b/src/helpers/service-package-helper.spec.js
new file mode 100644
index 000000000..eaf787a96
--- /dev/null
+++ b/src/helpers/service-package-helper.spec.js
@@ -0,0 +1,1054 @@
+import * as servicePackageHelper from "@/helpers/service-package-helper";
+import { partTypeStrings } from "@/constants/part-type-strings";
+import { damageLocationsSelected as glassLocations } from "@/constants/damage-locations-selected";
+
+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(servicePackageHelper.packageNames.TIER_ONE);
+            expect(results[1].packageName).toEqual(servicePackageHelper.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(servicePackageHelper.packageNames.TIER_ONE);
+            expect(results[1].packageName).toEqual(servicePackageHelper.packageNames.TIER_TWO);
+            expect(results[2].packageName).toEqual(servicePackageHelper.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,
+                servicePackageHelper.packageNames.TIER_TWO
+            );
+            const resultThree = servicePackageHelper.shouldFrontWipersBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.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,
+                servicePackageHelper.packageNames.TIER_TWO
+            );
+            const resultThree = servicePackageHelper.shouldFrontWipersBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.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,
+                servicePackageHelper.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,
+                servicePackageHelper.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,
+                servicePackageHelper.packageNames.TIER_ONE
+            );
+            const resultTwo = servicePackageHelper.shouldFrontWipersBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.packageNames.TIER_TWO
+            );
+            const resultThree = servicePackageHelper.shouldFrontWipersBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.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,
+                servicePackageHelper.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,
+                servicePackageHelper.packageNames.TIER_TWO
+            );
+            const resultThree = servicePackageHelper.shouldRearWipersBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.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,
+                servicePackageHelper.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,
+                servicePackageHelper.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,
+                servicePackageHelper.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,
+                servicePackageHelper.packageNames.TIER_ONE
+            );
+            const resultTwo = servicePackageHelper.shouldRearWipersBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.packageNames.TIER_TWO
+            );
+            const resultThree = servicePackageHelper.shouldRearWipersBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.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,
+                servicePackageHelper.packageNames.TIER_ONE
+            );
+
+            // Assert
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("shouldRainDefenseBeAvailable", () => {
+        it("Should generally be available only in tier 3, if available", () => {
+            // Arrange
+            const damageLocations = [frontWindshieldGlass];
+            const availableLineItems = [
+                rainDefenseLineItem,
+                driverFrontWiperLineItem,
+                rearWiperLineItem,
+                recalLineItem,
+            ];
+            const isRepair = false;
+
+            // Act
+            const resultOne = servicePackageHelper.shouldRainDefenseBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.packageNames.TIER_ONE
+            );
+            const resultTwo = servicePackageHelper.shouldRainDefenseBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.packageNames.TIER_TWO
+            );
+            const resultThree = servicePackageHelper.shouldRainDefenseBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.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,
+                servicePackageHelper.packageNames.TIER_THREE
+            );
+
+            // Assert
+            expect(result).toBe(false);
+        });
+
+        it("Should not be available in any tier if not available", () => {
+            // Arrange
+            const damageLocations = [frontWindshieldGlass];
+            const availableLineItems = [driverFrontWiperLineItem, rearWiperLineItem, recalLineItem];
+            const isRepair = false;
+
+            // Act
+            const resultOne = servicePackageHelper.shouldRainDefenseBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.packageNames.TIER_ONE
+            );
+            const resultTwo = servicePackageHelper.shouldRainDefenseBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.packageNames.TIER_TWO
+            );
+            const resultThree = servicePackageHelper.shouldRainDefenseBeAvailable(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                servicePackageHelper.packageNames.TIER_THREE
+            );
+
+            // Assert
+            expect(resultOne).toBe(false);
+            expect(resultTwo).toBe(false);
+            expect(resultThree).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(servicePackageHelper.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(servicePackageHelper.packageNames.TIER_TWO);
+            expect(resultRear).toEqual(servicePackageHelper.packageNames.TIER_TWO);
+        });
+
+        it("Should return tier 1 for any item not in any tier", () => {
+            // Arrange
+            const damageLocations = [frontWindshieldGlass, rearWindshieldGlass];
+
+            const availableLineItems = [
+                driverFrontWiperLineItem,
+                passengerFrontWiperLineItem,
+                rearWiperLineItem,
+            ];
+
+            const isRepair = false;
+
+            // Act
+            const resultFront = servicePackageHelper.getLowestTierForType(
+                damageLocations,
+                availableLineItems,
+                isRepair,
+                partTypeStrings.RAIN_DEFENSE
+            );
+
+            // Assert
+            expect(resultFront).toEqual(servicePackageHelper.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(servicePackageHelper.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(servicePackageHelper.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(servicePackageHelper.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(servicePackageHelper.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(servicePackageHelper.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(servicePackageHelper.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(servicePackageHelper.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(servicePackageHelper.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",
+};