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",
};