DigitalConsumer.FixMyGlass/src/layouts/quote/service-package-question/service-package-question.spec.js

import { shallowMount, mount } from "@vue/test-utils";
import servicePackageQuestion from "./service-package-question";
import { getMountOptions } from "@/helpers/unit-test-helper.js";
import {
    expectedModifiedAnswers,
    mockProcessedCmsContent,
    inputQuestionWidgetAnswers,
} from "./service-package-question-test-helper";

jest.mock("@/store", () => ({
    commit: jest.fn(),
    dispatch: jest.fn(),
}));

describe("service-package-question.vue", () => {
    beforeEach(async () => {
        processedCmsContent = inputQuestionWidgetAnswers;
        mockMixin = {
            methods: {
                getCmsContent: jest.fn((widgetName, cmsFieldName) => {
                    return processedCmsContent[widgetName][cmsFieldName];
                }),
            },
        };
        mockProps = {
            modelValue: "initialValue",
            isInsuranceSelected: false,
            insuranceCmsWidgetName: "InsuranceServicePackageQuestionWidget",
            cashCmsWidgetName: "CashServicePackageQuestionWidget",
            availableLineItems: [
                {
                    partNumber: "001",
                    Description: "Windshield with Recal",
                    partType: "Windshield",
                    Quantity: "1",
                    BasePartNumber: "001",
                    Color: "Green",
                    CanSafeliteRecalibrate: true,
                    price: 350.22,
                },
                {
                    partNumber: "RAIN DEFENSE",
                    description: null,
                    partType: "RAIN DEFENSE",
                    price: 35.5,
                },
            ],
        };
        const packageNameKey = "05_01_CSR_Quote_Standard_Repair";
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
    });
    it("should emit captured value", () => {
        // Arrange
        const wrapper = setupMocks({});
        // Act
        wrapper.componentVM.selectedValues = "newValue";

        // Assert
        expect(wrapper.emitted()["update:modelValue"][0][0]).toEqual("newValue");
    });
    it("should have the correct insurance pricing text when insurance is selected", () => {
        // Arrange
        mockProps.isInsuranceSelected = true;
        const wrapper = setupMocks({});
        // Act

        // Assert
        expect(
            wrapper.vm.servicePackageAnswers[0].buttonAuxillaryCopy.includes("As little as")
        ).toBe(true);
    });
    it("should return [] from nullSafeAvailableLineItems and not error out if availableLineItems is null", () => {
        // Arrange
        mockProps.availableLineItems = null;
        const wrapper = setupMocks({});
        // Act

        // Assert
        expect(wrapper.vm.nullSafeAvailableLineItems).toEqual([]);
    });
    it("should return a null servicePackageAnswers if the cmsContent is falsy", () => {
        // Arrange
        mockMixin = {
            methods: {
                getCmsContent: jest.fn((widgetName, cmsFieldName) => {
                    return null;
                }),
            },
        };
        const wrapper = setupMocks({});

        // Assert
        expect(wrapper.vm.servicePackageAnswers).toBe(null);
    });
    it("should treat an undefined 'getCustomValueFromString' as a false value and not error out", () => {
        // Arrange
        const packageNameKey = "badCustomValue";
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
        const wrapper = setupMocks({
            mountOptionsMockData: {
                store: {
                    getters: {
                        order: {
                            damage: {
                                isRepair: false,
                                glassToReplace: [{ glassLocation: "Windshield" }],
                            },
                        },
                        hasAnyNonWindshieldGlassParts: false,
                    },
                },
            },
        });

        // Assert
        // economy answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[0],
            expectedModifiedAnswers[packageNameKey].tierOne
        );
        // standard answer should not be created
        expect(wrapper.vm.servicePackageAnswers.length).toBe(2);
        // premium answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[1],
            expectedModifiedAnswers[packageNameKey].tierThree
        );
    });
});
describe("service-package-question.vue, matching business rules for package display", () => {
    // mock scenarios in figma:
    // https://www.figma.com/file/Spt9hBtGj8r8PFFGNIN3G5/New-Funnel?node-id=100%3A11383
    beforeEach(async () => {
        processedCmsContent = inputQuestionWidgetAnswers;
        mockMixin = {
            methods: {
                getCmsContent: jest.fn((widgetName, cmsFieldName) => {
                    return processedCmsContent[widgetName][cmsFieldName];
                }),
            },
        };
        mockProps = {
            modelValue: "initialValue",
            isInsuranceSelected: false,
            insuranceCmsWidgetName: "InsuranceServicePackageQuestionWidget",
            cashCmsWidgetName: "CashServicePackageQuestionWidget",
            availableLineItems: [
                {
                    partNumber: "001",
                    Description: "Windshield with Recal",
                    partType: "Windshield",
                    Quantity: "1",
                    BasePartNumber: "001",
                    Color: "Green",
                    CanSafeliteRecalibrate: true,
                    price: 350.22,
                },
                {
                    partNumber: "RAIN DEFENSE",
                    description: null,
                    partType: "RAIN DEFENSE",
                    price: 35.5,
                },
            ],
        };
    });
    it("should match the 05_01_CSR_Quote_Standard_Repair mock", () => {
        // Arrange
        const packageNameKey = "05_01_CSR_Quote_Standard_Repair";
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
        mockProps.availableLineItems.push(driverFrontWiperLineItem);
        mockProps.availableLineItems.push(passengerFrontWiperLineItem);
        const wrapper = setupMocks({
            mountOptionsMockData: {
                store: {
                    getters: {
                        order: {
                            damage: {
                                isRepair: true,
                                glassToReplace: [],
                            },
                        },
                        hasAnyNonWindshieldGlassParts: false,
                    },
                },
            },
        });

        // Assert
        // economy answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[0],
            expectedModifiedAnswers[packageNameKey].tierOne
        );
        // standard answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[1],
            expectedModifiedAnswers[packageNameKey].tierTwo
        );
        // premium answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[2],
            expectedModifiedAnswers[packageNameKey].tierThree
        );
    });
    it("should match the 05_01_CSR_Quote_Recal mock", () => {
        // Arrange
        const packageNameKey = "05_01_CSR_Quote_Recal";
        mockProps.availableLineItems.push(recalLineItem);
        mockProps.availableLineItems.push(driverFrontWiperLineItem);
        mockProps.availableLineItems.push(passengerFrontWiperLineItem);
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
        const wrapper = setupMocks({
            mountOptionsMockData: {
                store: {
                    getters: {
                        order: {
                            damage: {
                                isRepair: false,
                                glassToReplace: [{ glassLocation: "Windshield" }],
                            },
                        },
                        hasAnyNonWindshieldGlassParts: false,
                    },
                },
            },
        });

        // Assert
        // economy answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[0],
            expectedModifiedAnswers[packageNameKey].tierOne
        );
        // standard answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[1],
            expectedModifiedAnswers[packageNameKey].tierTwo
        );
        // premium answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[2],
            expectedModifiedAnswers[packageNameKey].tierThree
        );
    });
    it("should match the 05_01_CSR_Quote_RearGlass mock", () => {
        // Arrange
        const packageNameKey = "05_01_CSR_Quote_RearGlass";
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
        mockProps.availableLineItems.push(driverFrontWiperLineItem);
        mockProps.availableLineItems.push(passengerFrontWiperLineItem);
        mockProps.availableLineItems.push(rearWiperLineItem);
        const wrapper = setupMocks({
            mountOptionsMockData: {
                store: {
                    getters: {
                        order: {
                            damage: {
                                isRepair: false,
                                glassToReplace: [{ glassLocation: "Rear" }],
                            },
                        },
                        hasAnyNonWindshieldGlassParts: true,
                    },
                },
            },
        });

        // Assert
        // economy answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[0],
            expectedModifiedAnswers[packageNameKey].tierOne
        );
        // standard answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[1],
            expectedModifiedAnswers[packageNameKey].tierTwo
        );
        // premium answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[2],
            expectedModifiedAnswers[packageNameKey].tierThree
        );
    });
    it("should match the 05_01_CSR_Quote_RearGlass+NonWindshield mock", () => {
        // Arrange
        const packageNameKey = "05_01_CSR_Quote_RearGlass+NonWindshield";
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
        mockProps.availableLineItems.push(driverFrontWiperLineItem);
        mockProps.availableLineItems.push(passengerFrontWiperLineItem);
        mockProps.availableLineItems.push(rearWiperLineItem);
        const wrapper = setupMocks({
            mountOptionsMockData: {
                store: {
                    getters: {
                        order: {
                            damage: {
                                isRepair: false,
                                glassToReplace: [
                                    { glassLocation: "Rear" },
                                    { glassLocation: "Driver" },
                                ],
                            },
                        },
                        hasAnyNonWindshieldGlassParts: true,
                    },
                },
            },
        });
        //console.log(wrapper.vm.servicePackageAnswers);

        // Assert
        // economy answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[0],
            expectedModifiedAnswers[packageNameKey].tierOne
        );
        // standard answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[1],
            expectedModifiedAnswers[packageNameKey].tierTwo
        );
        // premium answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[2],
            expectedModifiedAnswers[packageNameKey].tierThree
        );
    });
    it("should match the 05_01_CSR_Quote_RearGlass+Windshield mock", () => {
        // Arrange
        const packageNameKey = "05_01_CSR_Quote_RearGlass+Windshield";
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
        mockProps.availableLineItems.push(driverFrontWiperLineItem);
        mockProps.availableLineItems.push(passengerFrontWiperLineItem);
        mockProps.availableLineItems.push(rearWiperLineItem);
        const wrapper = setupMocks({
            mountOptionsMockData: {
                store: {
                    getters: {
                        order: {
                            damage: {
                                isRepair: false,
                                glassToReplace: [
                                    { glassLocation: "Rear" },
                                    { glassLocation: "Windshield" },
                                ],
                            },
                        },
                        hasAnyNonWindshieldGlassParts: true,
                    },
                },
            },
        });

        // Assert
        // economy answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[0],
            expectedModifiedAnswers[packageNameKey].tierOne
        );
        // standard answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[1],
            expectedModifiedAnswers[packageNameKey].tierTwo
        );
        // premium answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[2],
            expectedModifiedAnswers[packageNameKey].tierThree
        );
    });
    it("should match the 05_01_CSR_Quote_RearGlassNoFrontFit mock", () => {
        // Arrange
        const packageNameKey = "05_01_CSR_Quote_RearGlassNoFrontFit";
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
        mockProps.availableLineItems.push(rearWiperLineItem);
        const wrapper = setupMocks({
            mountOptionsMockData: {
                store: {
                    getters: {
                        order: {
                            damage: {
                                isRepair: false,
                                glassToReplace: [{ glassLocation: "Rear" }],
                            },
                        },
                        hasAnyNonWindshieldGlassParts: true,
                    },
                },
            },
        });

        // Assert
        // economy answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[0],
            expectedModifiedAnswers[packageNameKey].tierOne
        );
        // standard answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[1],
            expectedModifiedAnswers[packageNameKey].tierTwo
        );
        // premium answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[2],
            expectedModifiedAnswers[packageNameKey].tierThree
        );
    });
    it("should match the 05_01_CSR_Quote_Windshield+SideGlass mock", () => {
        // Arrange
        const packageNameKey = "05_01_CSR_Quote_Windshield+SideGlass";
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
        mockProps.availableLineItems.push(driverFrontWiperLineItem);
        mockProps.availableLineItems.push(passengerFrontWiperLineItem);
        mockProps.availableLineItems.push(rearWiperLineItem);
        const wrapper = setupMocks({
            mountOptionsMockData: {
                store: {
                    getters: {
                        order: {
                            damage: {
                                isRepair: false,
                                glassToReplace: [
                                    { glassLocation: "Driver" },
                                    { glassLocation: "Windshield" },
                                ],
                            },
                        },
                        hasAnyNonWindshieldGlassParts: true,
                    },
                },
            },
        });

        // Assert
        // economy answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[0],
            expectedModifiedAnswers[packageNameKey].tierOne
        );
        // standard answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[1],
            expectedModifiedAnswers[packageNameKey].tierTwo
        );
        // premium answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[2],
            expectedModifiedAnswers[packageNameKey].tierThree
        );
    });
    it("should match the 05_01_CSR_Quote_SideGlass mock", () => {
        // Arrange
        const packageNameKey = "05_01_CSR_Quote_SideGlass";
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
        mockProps.availableLineItems.push(driverFrontWiperLineItem);
        mockProps.availableLineItems.push(passengerFrontWiperLineItem);
        mockProps.availableLineItems.push(rearWiperLineItem);
        const wrapper = setupMocks({
            mountOptionsMockData: {
                store: {
                    getters: {
                        order: {
                            damage: {
                                isRepair: false,
                                glassToReplace: [{ glassLocation: "Driver" }],
                            },
                        },
                        hasAnyNonWindshieldGlassParts: true,
                    },
                },
            },
        });

        // Assert
        // economy answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[0],
            expectedModifiedAnswers[packageNameKey].tierOne
        );
        // standard answer should not be created
        expect(wrapper.vm.servicePackageAnswers.length).toBe(2);
        // premium answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[1],
            expectedModifiedAnswers[packageNameKey].tierThree
        );
    });
    it("should match the 05_01_CSR_Quote_NoWiperFit mock", () => {
        // Arrange
        const packageNameKey = "05_01_CSR_Quote_NoWiperFit";
        Object.assign(processedCmsContent, mockProcessedCmsContent[packageNameKey]);
        const wrapper = setupMocks({
            mountOptionsMockData: {
                store: {
                    getters: {
                        order: {
                            damage: {
                                isRepair: false,
                                glassToReplace: [{ glassLocation: "Windshield" }],
                            },
                        },
                        hasAnyNonWindshieldGlassParts: false,
                    },
                },
            },
        });

        // Assert
        // economy answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[0],
            expectedModifiedAnswers[packageNameKey].tierOne
        );
        // standard answer should not be created
        expect(wrapper.vm.servicePackageAnswers.length).toBe(2);
        // premium answer
        runPackageAnswerExpectStatements(
            wrapper.vm.servicePackageAnswers[1],
            expectedModifiedAnswers[packageNameKey].tierThree
        );
    });
});

function runPackageAnswerExpectStatements(servicePackageAnswer, expectedOutput) {
    expect(servicePackageAnswer.buttonLabel).toBe(expectedOutput.buttonLabel);
    expect(servicePackageAnswer.buttonLabelSubCopy).toBe(expectedOutput.buttonLabelSubCopy);
    expect(servicePackageAnswer.buttonBodyCopy).toBe(expectedOutput.buttonBodyCopy);
    expect(servicePackageAnswer.buttonFooterCopy).toBe(expectedOutput.buttonFooterCopy);
}

function setupMocks({ mountOptionsMockData, props = mockProps }) {
    var mountOptionsMockDataDefault = {
        store: {
            getters: {
                order: {
                    damage: {
                        isRepair: false,
                        glassToReplace: [{ glassLocation: "Windshield" }],
                    },
                },
                hasAnyNonWindshieldGlassParts: false,
            },
        },
    };
    mountOptionsMockData = Object.assign(mountOptionsMockDataDefault, mountOptionsMockData);
    const mountOptions = getMountOptions(mountOptionsMockData);

    // Modify/augment default mount options
    mountOptions.global.mixins = [mockMixin];
    mountOptions.propsData = props;
    const wrapper = shallowMount(servicePackageQuestion, mountOptions);

    return wrapper;
}
///////////////
// Constants //
///////////////

let processedCmsContent;

let mockMixin;

let mockProps;

let recalLineItem = {
    partNumber: "RECAL STATIC",
    Description: "Recalibration",
    partType: "recalibration",
    Quantity: "1",
    price: 150.0,
};

let driverFrontWiperLineItem = {
    partNumber: "SBB16",
    description: "SAFELITE BEAM BLADE 16",
    partType: "FRONT WIPER",
    price: 32.64,
};

let passengerFrontWiperLineItem = {
    partNumber: "SBB26",
    description: "SAFELITE BEAM BLADE 26",
    partType: "FRONT WIPER",
    price: 53.04,
};

let rearWiperLineItem = {
    partNumber: "SBBR12A",
    description: "SAFELITE REAR BLADE 12A",
    partType: "REAR WIPER",
    price: 24.48,
};