import globalMethods from "@/global-methods"; import store from "@/store"; import { mutations, state, actions, getters } from "@/store"; import { storeMutations } from "@/constants/store-mutations"; import { storeActions } from "@/constants/store-actions"; import { endpoints } from "@/constants/endpoints.js"; import { sessionStorageKeyConstants } from "@/constants/session-storage"; import { experimentTriggers } from "@/constants/experiments"; import { routeData } from "@/router/constants/routes"; import { AppointmentTypeStrings } from "@/constants/schedule-constants"; // Mock global method globalMethods.callHttpClient = jest.fn(); global.crypto = { randomUUID: jest.fn() }; describe("Mutations", () => { it("Updates vehicle year in state", () => { // Arrange const storeState = state; // Act mutations.updateYear(storeState, "2019"); // Assert expect(storeState.order.vehicle.year).toEqual("2019"); }); it("Updates vehicle make in state", () => { // Arrange const storeState = state; // Act mutations.updateMake(storeState, "Acura"); // Assert expect(storeState.order.vehicle.make).toEqual("Acura"); }); it("Updates vehicle model in state", () => { // Arrange const storeState = state; // Act mutations.updateModel(storeState, "ILX"); // Assert expect(storeState.order.vehicle.model).toEqual("ILX"); }); it("Updates vehicle style in state", () => { // Arrange const storeState = state; // Act mutations.updateStyle(storeState, "4 DOOR SEDAN"); // Assert expect(storeState.order.vehicle.style).toEqual("4 DOOR SEDAN"); }); it("Updates vehicle carId in state", () => { // Arrange const storeState = state; // Act mutations.updateCarId(storeState, "C0000001"); // Assert expect(storeState.order.vehicle.carId).toEqual("C0000001"); }); it("Updates vehicle vehicle category in state", () => { // Arrange const storeState = state; // Act mutations.updateVehicleCategory(storeState, "CAR"); // Assert expect(storeState.order.vehicle.category).toEqual("CAR"); }); it("Remove item to eventBus in state", () => { // Arrange const storeState = state; const event = { category: "CategoryOne", subCategory: "SubCategoryOne" }; // Act / Assert mutations.addEventToBus(storeState, event); expect(storeState.applicationUser.eventBus).toEqual([event]); // Act / Assert mutations.removeEventFromBus(storeState, event); expect(storeState.applicationUser.eventBus).toEqual([]); }); it("Adds item to eventBus in state", () => { // Arrange const storeState = state; // Act mutations.addEventToBus(storeState, { EventOne: "ValueOne" }); // Assert expect(storeState.applicationUser.eventBus).toEqual([{ EventOne: "ValueOne" }]); }); it("resetVehicleState, should set fields to null", () => { // Arrange const storeState = state; mutations.updateYear(storeState, "2019"); mutations.updateMake(storeState, "Acura"); mutations.updateModel(storeState, "ILX"); mutations.updateStyle(storeState, "4 DOOR SEDAN"); mutations.updateCarId(storeState, "C0000001"); mutations.updateVehicleCategory(storeState, "CAR"); // Expect expect(storeState.order.vehicle.year).toEqual("2019"); expect(storeState.order.vehicle.make).toEqual("Acura"); expect(storeState.order.vehicle.model).toEqual("ILX"); expect(storeState.order.vehicle.style).toEqual("4 DOOR SEDAN"); expect(storeState.order.vehicle.carId).toEqual("C0000001"); expect(storeState.order.vehicle.category).toEqual("CAR"); // Act mutations.resetVehicleState(storeState); // Expect expect(storeState.order.vehicle.year).toEqual(null); expect(storeState.order.vehicle.make).toEqual(null); expect(storeState.order.vehicle.model).toEqual(null); expect(storeState.order.vehicle.style).toEqual(null); expect(storeState.order.vehicle.carId).toEqual(null); expect(storeState.order.vehicle.category).toEqual(null); }); it("resetDamageState, should set fields to null", () => { // Arrange const storeState = state; storeState.order.damage = { isRepair: true, numberOfChips: 2, glassToReplace: [{ location: "Rear", name: "Stationary" }], }; // Expect expect(storeState.order.damage.isRepair).toEqual(true); expect(storeState.order.damage.numberOfChips).toEqual(2); expect(storeState.order.damage.glassToReplace).toStrictEqual([ { location: "Rear", name: "Stationary" }, ]); // Act mutations.resetDamageState(storeState); // Expect expect(storeState.order.damage.isRepair).toEqual(null); expect(storeState.order.damage.numberOfChips).toEqual(null); expect(storeState.order.damage.glassToReplace).toEqual(null); }); it("Updates number of chips in state", () => { // Arrange const storeState = state; // Act mutations.updateNumberOfChips(storeState, "1"); // Assert expect(storeState.order.damage.numberOfChips).toEqual("1"); }); it("Updates glass to replace in state", () => { // Arrange const storeState = state; // Act mutations.updateGlassToReplace(storeState, ["Windshield"]); // Assert expect(storeState.order.damage.glassToReplace).toEqual(["Windshield"]); }); it("Updates Parts in state", () => { // Arrange const storeState = state; // Act mutations.updateGlassParts(storeState, { "Windshield-Single": "PARTNUM101" }); // Assert expect(storeState.order.lineItems.glassParts).toEqual({ "Windshield-Single": "PARTNUM101", }); }); it("Updates page data in state", () => { // Arrange const storeState = state; // Act mutations.updatePageData(storeState, { page: "vehicle-year", data: {} }); // Assert expect(storeState.applicationUser.pageData["vehicle-year"]).toEqual({}); }); it("updateStateWithSessonInformation, should set session information in state", () => { // Arrange const storeState = state; // Act mutations.updateStateWithOrderInformation(storeState, { order: { referralNumber: 123, referralDate: new Date().toUTCString(), referralCorrelationId: "xxx-xxx-xxx", vehicle: { year: "2019", make: "Acura", model: "ILX", style: "4 DOOR SEDAN", carId: "C0000001", category: "CAR", registration: {}, }, policy: { insuranceCompanyName: "LibertyBibity", }, damage: { glassToReplace: ["Windshield"], isRepair: false, numberOfChips: 0, }, lineItems: { glassParts: null, }, payment: { isInsurance: false, parentAccountNumber: "123456789", }, insuranceCoverage: { isVerified: false, coverageStatus: "Pending", }, parts: [], insuranceInfo: {}, serviceLocation: {}, customer: {}, }, applicationUser: { experiments: [ { universeName: "Concept Funnel Test With Rules", universeId: 463, testName: "Concept Dev Test", testId: 392, variationName: "Concept Test Variation", variationId: 1133, isActive: false, isExposed: true, userPartitionNumber: 84, assignmentId: 12211739, settings: { someKey: "false", sampleSetting: "Hi, my name is Vidya", }, }, ], }, }); // Assert expect(storeState.order.referralNumber).toEqual(123); expect(storeState.order.referralCorrelationId).toEqual("xxx-xxx-xxx"); expect(storeState.order.vehicle.year).toEqual("2019"); expect(storeState.order.vehicle.make).toEqual("Acura"); expect(storeState.order.vehicle.model).toEqual("ILX"); }); it("updateInsuranceVerifiedStatus, should set isVerified flag", () => { // Arrange const storeState = state; // Act mutations.updateInsuranceVerifiedStatus(storeState, true); // Assert expect(storeState.order.payment.insuranceCoverage.isVerified).toEqual(true); }); it("updateExperiments, should set experiments", () => { // Arrange const storeState = state; const mockExperimentsList = [ { universeName: "XYZ", settings: { ExperimentSetting: "ExperimentValue", }, }, ]; // Act mutations.updateExperiments(storeState, mockExperimentsList); // Assert expect(storeState.applicationUser.experiments).toEqual(mockExperimentsList); }); it("updateTriggeredSiteEntry, should set triggeredSiteEntry", () => { // Arrange const storeState = state; // Act mutations.updateTriggeredSiteEntry(storeState, true); // Assert expect(storeState.applicationUser.triggeredSiteEntry).toEqual(true); }); it("updateServiceLocation, should set serviceLocation in state", () => { // Arrange const storeState = state; const serviceLocation = { address: "123 Test Lane", city: "Columbus", zipCode: "43212", state: "OH", zipCodeCtu: "01820", }; // Act mutations.updateServiceLocation(storeState, serviceLocation); // Assert expect(storeState.order.serviceLocation.address).toEqual("123 Test Lane"); expect(storeState.order.serviceLocation.city).toEqual("Columbus"); expect(storeState.order.serviceLocation.zipCode).toEqual("43212"); expect(storeState.order.serviceLocation.state).toEqual("OH"); expect(storeState.order.serviceLocation.zipCodeCtu).toEqual("01820"); }); it("updateCustomerDetails, should set customer details in state", () => { // Arrange const storeState = state; const customerDetails = { firstName: "foo", lastName: "bar", emailAddress: "foo@bar.com", phoneNumber: "555-555-5555", isSmsOptIn: true, }; // Act mutations.updateCustomerDetails(storeState, customerDetails); // Assert expect(state.order.customer.firstName).toEqual("foo"); expect(state.order.customer.lastName).toEqual("bar"); expect(state.order.customer.emailAddress).toEqual("foo@bar.com"); expect(state.order.customer.phoneNumber).toEqual("555-555-5555"); expect(state.order.customer.isSmsOptIn).toEqual(true); }); it("incrementSubmittedStateRevision, should increment submittedStateRevision", () => { const storeState = { submittedStateRevision: 0 }; mutations.incrementSubmittedStateRevision(storeState); expect(storeState.submittedStateRevision).toEqual(1); }); }); describe("Actions", () => { it("getVehicleYears action, should return years array", async () => { // Arrange const context = state; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: [2023, 2022, 2021] }); }); // Assert const response = await actions.getVehicleYears(context, { pageNameToLog: "test" }); expect(response.data).toEqual([2023, 2022, 2021]); }); it("lookupVehicleByYmms action, should return car data", async () => { // Arrange const context = state; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { carId: "C00000001" } }); }); // Assert const response = await actions.lookupVehicleByYmms(context, { payload: { year: "2019", make: "Acura", model: "ILX", style: "4 DOOR SEDAN", }, pageNameToLog: "test", }); expect(response.data).toEqual({ carId: "C00000001" }); }); it("lookupVehicleByVin action, should return car data", async () => { // Arrange const context = state; context.getters = { applicationUser: { loggingOption: false, }, }; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { carId: "C0000001" } }); }); // Assert const response = await actions.lookupVehicleByVin(context, { payload: { vin: "12345678901234567", }, pageNameToLog: "test", }); expect(response.data).toEqual({ carId: "C0000001" }); }); it("lookupVinByPlate action, should return car data", async () => { // Arrange const context = state; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { carId: "C00000001" } }); }); // Assert const response = await actions.lookupVinByPlate(context, { payload: { licensePlate: "12345678901234567", licenseState: "OH" }, pageNameToLog: "test", }); expect(response.data).toEqual({ carId: "C00000001" }); }); it("lookupVinByImage action, should return list of vins", async () => { // Arrange const context = state; const image = new File([], "test.jpg", { type: "image/jpeg", }); globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: ["1C6JJTAG3NL134044"] }); }); // Act const response = await actions.lookupVinByImage(context, { payload: image, pageNameToLog: "test", }); // Assert expect(response.data).toEqual(["1C6JJTAG3NL134044"]); }); it("lookupVinByImage action, should reject if error in calling API", async () => { // Arrange const context = state; const image = new File([], "test.jpg", { type: "image/jpeg", }); globalMethods.callHttpClient.mockImplementation(() => { return Promise.reject("An error occurred"); }); // Act // Assert await expect( actions.lookupVinByImage(context, { payload: image, pageNameToLog: "test" }) ).rejects.toEqual("An error occurred"); }); it("getVehicleMakes action, should return makes list", async () => { // Arrange const context = state; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: ["Acura", "Honda"] }); }); // Assert const response = await actions.getVehicleMakes(context, { payload: { year: "2019" }, pageNameToLog: "test", }); expect(response.data).toEqual(["Acura", "Honda"]); }); it("getVehicleModels action, should return models list", async () => { // Arrange const context = state; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: ["ILX", "RDX"] }); }); // Assert const response = await actions.getVehicleModels(context, { payload: { year: "2019", make: "Acura" }, pageNameToLog: "test", }); expect(response.data).toEqual(["ILX", "RDX"]); }); it("getVehicleStyles action, should return models list", async () => { // Arrange const context = state; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { style: "4 DOOR SEDAN" } }); }); // Assert const response = await actions.getVehicleStyles(context, { payload: { year: "2019", make: "Acura", model: "ILX" }, pageNameToLog: "test", }); expect(response.data).toEqual({ style: "4 DOOR SEDAN" }); }); it("getVehicle action, should get vehicle data ", async () => { // Arrange const context = state; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { carId: "C00000000", category: "CAR" } }); }); // Assert const response = await actions.getVehicle(context, { payload: { year: "2019", make: "Acura", model: "IDX", style: "4-door sedan" }, pageNameToLog: "test", }); expect(response.data).toEqual({ carId: "C00000000", category: "CAR" }); }); it("getDamageOptions action", async () => { // Arrange const context = state; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: ["Windshield", "DriversFrontDoor"] }); }); const response = await actions.getDamageOptions(context, { payload: { carId: "C00000000" }, pageNameToLog: "test", }); // Assert expect(response.data).toEqual(["Windshield", "DriversFrontDoor"]); }); it("validateZip action", async () => { // Arrange const context = state; context.getters = { damage: { isRepair: "false", }, }; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { isValid: true, isServiceable: true, state: "OH", zipCodeCtu: "01820", }, }); }); const response = await actions.validateZip(context, { payload: { zip: "43212" }, pageNameToLog: "test", }); // Assert expect(response.data).toEqual({ isValid: true, isServiceable: true, state: "OH", zipCodeCtu: "01820", }); }); it("resetDamageAndDependencies action", async () => { // Arrange const context = state; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act await actions.resetDamageAndDependencies(context); expect(commit).toBeCalledWith(storeMutations.RESET_DAMAGE_STATE); expect(dispatch).toBeCalledWith(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES); }); it("resetRegistrationAndDependencies action", async () => { // Arrange const context = state; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act await actions.resetRegistrationAndDependencies(context); expect(commit).toBeCalledWith(storeMutations.RESET_REGISTRATION_STATE); expect(dispatch).toBeCalledWith(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES); }); it("resetPartsAndDependencies action", async () => { // Arrange const context = state; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act await actions.resetPartsAndDependencies(context); expect(commit).toBeCalledWith(storeMutations.RESET_GLASS_PARTS_STATE); expect(dispatch).toBeCalledWith(storeActions.RESET_SERVICE_LOCATION_STATE_AND_DEPENDENCIES); }); it("resetState action", async () => { // Arrange const context = state; const commit = jest.fn(); context.commit = commit; // Act await actions.resetState(context); expect(commit).toBeCalledWith(storeMutations.RESET_STATE); }); it("getPageData action, returns page data", async () => { // Arrange const context = state; globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { Results: [{ Widget: "Data" }] } }); }); // Act const response = await actions.getPageData(context, "vehicle-year"); expect(response.data).toEqual({ Results: [{ Widget: "Data" }] }); }); it("getEvoxImage action, returns image url", async () => { // Arrange const context = state; globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { imageUrl: "https://test.com" } }); }); // Act const response = await actions.getEvoxImage(context, { relativeUrl: "https://relativeurl.com", }); expect(response.data).toEqual({ imageUrl: "https://test.com" }); }); it("saveSession action, returns order information", async () => { // Arrange const context = state; context.getters = { vehicle: { registration: {}, }, order: { damage: { numberOfChips: "2", partQuestionAnswers: {}, moldingQuestionAnswers: {}, capabilityQuestionAnswers: {}, }, }, damage: {}, applicationUser: { lastPageVisited: "test-page", crmCustomerId: "xxx-xxx-xxx", savedSessionId: "xxx-xxx-xxx", }, }; context.state = { order: { damage: { numberOfChips: "2", partQuestionAnswers: {}, moldingQuestionAnswers: {}, capabilityQuestionAnswers: {}, }, payment: { insuranceCoverage: { isVerified: false, }, isInsurance: false, ccToken: { subscriptionId: null, expMonth: null, expYear: null, cardType: null, billToPostalCode: null, billToFirstName: null, billToLastName: null, referenceNumber: null, authCode: null, transactionId: null, transReferenceNumber: null, lastFour: null, }, }, serviceLocation: {}, customer: { emailAddress: "test@safelite.com", firstName: "John", lastName: "Doe", isSmsOptIn: true, phoneNumber: "1234567890", address: { streetAddress: "123 Main St", streetAddress2: "Apt 1", city: "Anytown", state: "OH", zipCode: "12345", }, }, lineItems: {}, }, }; globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { referralNumber: 123 } }); }); // Act const response = await actions.saveSession(context, { pageNameToLog: "test" }); // Assert expect(response.data).toEqual({ referralNumber: 123 }); }); it("loadSession action, returns order information, calls mutation", async () => { // Arrange const context = state; globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { referralNumber: 123, order: {} } }); }); const commit = jest.fn(); context.commit = commit; // Act const response = await actions.loadSession(context, { payload: { savedSessionId: "", referralDate: "2024-12-11T00:29:41.967", }, pageNameToLog: "test", }); // Assert expect(response.data).toEqual({ referralNumber: 123, order: {} }); expect(commit).toBeCalledWith(storeMutations.UPDATE_STATE_WITH_ORDER_INFORMATION, { referralNumber: 123, order: {}, }); }); it("loadSession: state doesn't have EON => do not reset state", async () => { // Arrange const context = state; globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { eon: "123", order: {} } }); }); context.commit = jest.fn(); context.state = { order: {}, }; // Act const response = await actions.loadSession(context, { payload: { savedSessionId: "", referralDate: "2024-12-11T00:29:41.967", }, pageNameToLog: "test", }); // Assert expect(response.data.eon).toEqual("123"); expect(context.commit).not.toBeCalledWith(storeMutations.RESET_STATE); }); it("loadSession eon doesn't match eon in state => reset state", async () => { // Arrange const context = state; globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { eon: "123", order: {} } }); }); context.commit = jest.fn(); context.state = { order: { eon: "456", }, }; // Act const response = await actions.loadSession(context, { payload: { savedSessionId: "", referralDate: "2024-12-11T00:29:41.967", }, pageNameToLog: "test", }); // Assert expect(response.data.eon).toEqual("123"); expect(context.commit).toBeCalledWith(storeMutations.RESET_STATE); }); it("updateStoreWithSaveSessionResponse, should call commit six times", () => { // Arrange const context = state; const commit = jest.fn(); context.commit = commit; // Act actions.updateStoreWithSaveSessionResponse(context, { referralNumber: "123", referralSequenceNumber: 123, referralDate: new Date().toUTCString(), referralCorrelationId: "xxx-xxx-xxx", parentAccountNumber: "167132", savedSessionId: "xxx-xxx-xxx", crmCustomerId: "xxx-xxx-xxx", }); // Assert expect(commit).toBeCalledWith(storeMutations.UPDATE_REFERRAL_NUMBER, "123"); expect(commit).toBeCalledWith( storeMutations.UPDATE_REFERRAL_DATE, new Date().toUTCString() ); expect(commit).toBeCalledWith(storeMutations.UPDATE_REFERRAL_CORRELATION_ID, "xxx-xxx-xxx"); expect(commit).toBeCalledWith(storeMutations.UPDATE_PARENT_ACCT_NUMBER, "167132"); expect(commit).toBeCalledWith(storeMutations.UPDATE_SAVED_SESSION_ID, "xxx-xxx-xxx"); expect(commit).toBeCalledWith(storeMutations.UPDATE_CRM_CUSTOMER_ID, "xxx-xxx-xxx"); }); it("logPageView action, should return nothing", async () => { // Arrange const context = state; var pageEvent = { action: "", event: "ENTRY", }; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({}); }); // Assert const response = await actions.logPageView(context, { userId: "userId", sessionKey: "sessionKey", pageName: "pageName", sessionId: "sessionId", pageEvent: pageEvent, shouldUseSessionId: false, }); expect(response).toEqual({}); }); it("logCustomEvent action, should return nothing", async () => { // Arrange const context = state; var customEvent = { category: "tstCat", action: "click", label: "damage", value: "psych", }; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({}); }); // Assert const response = await actions.logCustomEvent(context, { userId: "userId", sessionKey: "sessionKey", pageName: "pageName", sessionId: "sessionId", customEvent: customEvent, category: "category", shouldUseSessionId: false, }); expect(response).toEqual({}); }); it("initializeSession action, should return nothing", async () => { // Arrange const context = state; // Act globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({}); }); // Assert const response = await actions.initializeSession(context, { userId: "userId", sessionId: "", userAgent: "", referrer: "", shouldUseSessionId: false, }); expect(response).toEqual({}); }); it("saveVin, should call mutation when CarId is different and selectedGlass is not available for vehicle", () => { // Arrange const context = state; context.state = { order: { vehicle: { vin: "YYYYY", }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act actions.saveVin(context, { isCarIdDifferent: true, isSelectedGlassAvailableForVehicle: false, vehicleInfo: { carId: "C010101", vin: "XXXXX" }, }); // Assert expect(dispatch).toBeCalledWith(storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES); expect(commit).toBeCalledWith(storeMutations.UPDATE_VEHICLE, { carId: "C010101", vin: "XXXXX", }); }); it("saveEmail, should call mutation", () => { // Arrange const context = state; const commit = jest.fn(); context.commit = commit; // Act actions.saveEmail(context, "test@safelite.com"); // Assert expect(commit).toBeCalledWith( storeMutations.UPDATE_CUSTOMER_EMAIL_ADDRESS, "test@safelite.com" ); }); it("saveServiceZipCodeInfo, should call mutation", () => { // Arrange const context = state; const commit = jest.fn(); context.commit = commit; const serviceZipCodeInfo = { zipCode: "43212", }; // Act actions.saveServiceLocation(context, serviceZipCodeInfo); // Assert expect(commit).toBeCalledWith(storeMutations.UPDATE_SERVICE_LOCATION, serviceZipCodeInfo); }); it("saveServiceZipCodeInfo, should reset if zip code is different", () => { // Arrange const context = { state: { order: { serviceLocation: { zipCode: "43212", }, }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; const serviceZipCodeInfo = { zipCode: "43202", }; // Act actions.saveServiceZipCodeInfo(context, serviceZipCodeInfo); // Assert expect(dispatch).toHaveBeenCalledWith( storeActions.RESET_SERVICE_LOCATION_STATE_AND_DEPENDENCIES ); expect(commit).toHaveBeenCalledWith(storeMutations.RESET_SERVICE_LOCATION_MOBILE_ADDRESS); }); it("saveServiceZipCodeInfo, should not reset if zip code is the same", () => { // Arrange const context = { state: { order: { serviceLocation: { zipCode: "43212", }, }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; const serviceZipCodeInfo = { zipCode: "43212", }; // Act actions.saveServiceZipCodeInfo(context, serviceZipCodeInfo); // Assert expect(dispatch).not.toHaveBeenCalledWith( storeActions.RESET_SERVICE_LOCATION_STATE_AND_DEPENDENCIES ); expect(commit).not.toHaveBeenCalledWith( storeMutations.RESET_SERVICE_LOCATION_MOBILE_ADDRESS ); }); it("saveServiceLocation, should call mutation", () => { // Arrange const context = state; const commit = jest.fn(); context.commit = commit; const serviceLocation = { address: "123 Test Lane", city: "Columbus", zipCode: "43212", state: "OH", zipCodeCtu: "01820", }; // Act actions.saveServiceLocation(context, serviceLocation); // Assert expect(commit).toBeCalledWith(storeMutations.UPDATE_SERVICE_LOCATION, serviceLocation); }); it("saveServiceLocation, should reset if zipcode is different", () => { // Arrange const context = { state: { order: { serviceLocation: { address: "123 Test Lane", city: "Columbus", zipCode: "43212", state: "OH", zipCodeCtu: "01820", appointmentType: "Mobile", isVehicleProtected: true, provider: { providerNumber: "11111", address: { streetAddress: "123 Test Lane", city: "Columbus", state: "OH", zipCode: "43212", zipCodeCtu: "01820", }, }, }, }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; const serviceLocation = { address: "123 Test Lane", city: "Columbus", zipCode: "43202", state: "OH", zipCodeCtu: "01820", appointmentType: "Mobile", isVehicleProtected: true, provider: { providerNumber: "11111", address: { streetAddress: "123 Test Lane", city: "Columbus", state: "OH", zipCode: "43212", zipCodeCtu: "01820", }, }, }; // Act actions.saveServiceLocation(context, serviceLocation); // Assert expect(commit).toHaveBeenCalledWith(storeMutations.RESET_SCHEDULE); }); it("saveServiceLocation, should reset if provider is different", () => { // Arrange const context = { state: { order: { serviceLocation: { address: "123 Test Lane", city: "Columbus", zipCode: "43212", state: "OH", zipCodeCtu: "01820", appointmentType: "Mobile", isVehicleProtected: true, provider: { providerNumber: "11111", address: { streetAddress: "123 Test Lane", city: "Columbus", state: "OH", zipCode: "43212", zipCodeCtu: "01820", }, }, }, }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; const serviceLocation = { address: "123 Test Lane", city: "Columbus", zipCode: "43212", state: "OH", zipCodeCtu: "01820", appointmentType: "Mobile", isVehicleProtected: true, provider: { providerNumber: "22222", address: { streetAddress: "321 Test Lane", city: "Columbus", state: "OH", zipCode: "43212", zipCodeCtu: "01820", }, }, }; // Act actions.saveServiceLocation(context, serviceLocation); // Assert expect(commit).toHaveBeenCalledWith(storeMutations.RESET_SCHEDULE); }); it("saveServiceLocation, should reset if appointment type is different", () => { // Arrange const context = { state: { order: { serviceLocation: { address: "123 Test Lane", city: "Columbus", zipCode: "43212", state: "OH", zipCodeCtu: "01820", appointmentType: "Mobile", isVehicleProtected: true, provider: { providerNumber: "11111", address: { streetAddress: "123 Test Lane", city: "Columbus", state: "OH", zipCode: "43212", zipCodeCtu: "01820", }, }, }, }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; const serviceLocation = { address: "123 Test Lane", city: "Columbus", zipCode: "43212", state: "OH", zipCodeCtu: "01820", appointmentType: "Inshop", isVehicleProtected: true, provider: { providerNumber: "11111", address: { streetAddress: "123 Test Lane", city: "Columbus", state: "OH", zipCode: "43212", zipCodeCtu: "01820", }, }, }; // Act actions.saveServiceLocation(context, serviceLocation); // Assert expect(commit).toHaveBeenCalledWith(storeMutations.RESET_SCHEDULE); }); it("saveServiceLocation, should not reset if parameters are the same", () => { // Arrange const context = { state: { order: { serviceLocation: { address: "123 Test Lane", city: "Columbus", zipCode: "43212", state: "OH", zipCodeCtu: "01820", appointmentType: "Mobile", isVehicleProtected: true, provider: { providerNumber: "11111", address: { streetAddress: "123 Test Lane", city: "Columbus", state: "OH", zipCode: "43212", zipCodeCtu: "01820", }, }, }, }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; const serviceLocation = { address: "123 Test Lane", city: "Columbus", zipCode: "43212", state: "OH", zipCodeCtu: "01820", appointmentType: "Mobile", isVehicleProtected: true, provider: { providerNumber: "11111", address: { streetAddress: "123 Test Lane", city: "Columbus", state: "OH", zipCode: "43212", zipCodeCtu: "01820", }, }, }; // Act actions.saveServiceLocation(context, serviceLocation); // Assert expect(commit).not.toHaveBeenCalledWith(storeMutations.RESET_SCHEDULE); }); it("saveCustomerDetails, should call mutation", () => { // Arrange const context = state; const commit = jest.fn(); context.commit = commit; const customerDetails = { firstName: "foo", lastName: "bar", emailAddress: "foo@bar.com", phoneNumber: "555-555-5555", isSmsOptIn: true, }; // Act actions.saveCustomerDetails(context, customerDetails); // Assert expect(commit).toBeCalledWith(storeMutations.UPDATE_CUSTOMER_DETAILS, customerDetails); }); it("saveGlassParts, should call mutation", () => { // Arrange const context = { state: state, }; context.state.order.lineItems = []; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act actions.saveGlassParts(context, []); // Assert expect(commit).toBeCalledWith(storeMutations.UPDATE_GLASS_PARTS, []); expect(dispatch).toBeCalledWith(storeActions.RESET_SERVICE_LOCATION_STATE_AND_DEPENDENCIES); }); it("saveSupportingItems, should call mutations", () => { // Arrange const context = { state: state, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act actions.saveSupportingItems(context, []); // Assert expect(commit).toBeCalledWith(storeMutations.UPDATE_SUPPORTING_ITEMS, []); }); it("saveSupportingItems, should call reset logic when value is new", () => { // Arrange const context = { state: { order: { lineItems: { supportingItems: [{ partNum: "TestValue1" }, { partNum: "TestValue2" }], }, }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act actions.saveSupportingItems(context, [ { partNum: "TestValue3" }, { partNum: "TestValue4" }, { partNum: "TestValue5" }, ]); // Assert expect(dispatch).toBeCalledWith(storeActions.RESET_SERVICE_LOCATION_STATE_AND_DEPENDENCIES); }); it("saveSupportingItems, should not call reset logic when value is the same", () => { // Arrange const context = { state: { order: { lineItems: { supportingItems: [{ partNum: "TestValue1" }, { partNum: "TestValue2" }], }, }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act actions.saveSupportingItems(context, [ { partNum: "TestValue1" }, { partNum: "TestValue2" }, ]); // Assert expect(dispatch).not.toBeCalledWith( storeActions.RESET_SERVICE_LOCATION_STATE_AND_DEPENDENCIES ); }); it("clearVin, should call mutation", () => { // Arrange const context = state; const commit = jest.fn(); context.commit = commit; // Act actions.clearVin(context); // Assert expect(commit).toBeCalledWith(storeMutations.UPDATE_VEHICLE_VIN, null); }); it("saveVinLookup, should call mutation if vin is different", () => { // Arrange const context = state; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act const payload = { isCarIdDifferent: true, isSelectedGlassAvailableForVehicle: false, vehicleInfo: { carId: "C010101", vin: "XXXXX", }, registrationInfo: { zipCode: "80020", }, serviceLocationInfo: { state: "CO", }, customerEmail: "test@safleite.com", }; actions.saveVinLookup(context, payload); // Assert expect(dispatch).toHaveBeenNthCalledWith( 1, storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES ); expect(dispatch).toHaveBeenNthCalledWith( 2, storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES ); expect(dispatch).toHaveBeenNthCalledWith( 3, storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES ); expect(commit).toBeCalledWith(storeMutations.UPDATE_VEHICLE, payload.vehicleInfo); expect(commit).toBeCalledWith(storeMutations.UPDATE_REGISTRATION, payload.registrationInfo); }); it("saveRegistrationLicensePlateLookup, should call mutation if LP is different", () => { // Arrange const context = state; context.state = { order: { vehicle: { registration: { licensePlate: "ABC123", }, }, customer: { firstName: "test", lastName: "test", }, }, }; context.getters = { ...getters, order: getters.order(context), }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act const payload = { isCarIdDifferent: true, isSelectedGlassAvailableForVehicle: false, vehicleInfo: { carId: "C010101", vin: "XXXXX" }, registrationInfo: { zipCode: "80020", licensePlate: "ALQX35" }, serviceLocationInfo: { state: "CO" }, customerEmail: "test@safelite.com", }; actions.saveRegistrationLicensePlateLookup(context, payload); // Assert expect(dispatch).toHaveBeenNthCalledWith( 1, storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES ); expect(dispatch).toHaveBeenNthCalledWith( 2, storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES ); expect(commit).toBeCalledWith(storeMutations.UPDATE_VEHICLE, payload.vehicleInfo); expect(commit).toBeCalledWith(storeMutations.UPDATE_REGISTRATION, payload.registrationInfo); }); it("saveRegistrationAddressLookup, should call mutation when address is different", () => { // Arrange const context = state; context.state = { order: { vehicle: { registration: { address: "123 Main St", }, }, customer: { firstName: "test", lastName: "test", }, }, }; context.getters = { ...getters, order: getters.order(context), }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act const payload = { isCarIdDifferent: true, isSelectedGlassAvailableForVehicle: false, vehicleInfo: { carId: "C010101", vin: "XXXXX" }, customerInfo: { firstName: "abc", lastName: "123" }, serviceLocationInfo: { state: "CO" }, customerEmail: "test@safelite.com", }; actions.saveRegistrationAddressLookup(context, payload); // Assert expect(dispatch).toHaveBeenNthCalledWith( 1, storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES ); expect(dispatch).toHaveBeenNthCalledWith( 2, storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES ); expect(commit).toBeCalledWith(storeMutations.UPDATE_VEHICLE, payload.vehicleInfo); }); it("saveVehicle, should save vehicle info", () => { // Arrange const context = state; context.state = { order: { vehicle: { year: "2016", make: "Toyota", model: "Accord", style: "SUV", }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; //Act const payload = { year: "2015", make: "Honda", model: "Civic", style: "Sedan", carId: "C00000000", category: "CAR", }; actions.saveVehicle(context, payload); //Assert expect(dispatch).toHaveBeenNthCalledWith( 1, storeActions.RESET_DAMAGE_STATE_AND_DEPENDENCIES ); expect(dispatch).toHaveBeenNthCalledWith( 2, storeActions.RESET_REGISTRATION_STATE_AND_DEPENDENCIES ); if (context.state.order.vehicle.year !== payload.year) { expect(commit).toBeCalledWith(storeMutations.UPDATE_YEAR, payload.year); } if (context.state.order.vehicle.make !== payload.make) { expect(commit).toBeCalledWith(storeMutations.UPDATE_MAKE, payload.make); } if (context.state.order.vehicle.model !== payload.model) { expect(commit).toBeCalledWith(storeMutations.UPDATE_MODEL, payload.model); } if (context.state.order.vehicle.style !== payload.style) { expect(commit).toBeCalledWith(storeMutations.UPDATE_STYLE, payload.style); } context.commit(storeMutations.UPDATE_CAR_ID, payload.carId); context.commit(storeMutations.UPDATE_VEHICLE_CATEGORY, payload.category); }); it("saveVehicleDamage, should wipe out damage if different", () => { // Arrange const context = state; context.state = { order: { damage: { glassToReplace: [{ glassName: "Single", glassLocation: "Windshield" }], }, }, }; const commit = jest.fn(); const dispatch = jest.fn(); context.commit = commit; context.dispatch = dispatch; // Act const payload = { isWindshieldRepair: false, selectedGlassToReplace: [{ glassName: "Rear", glassLocation: "quarter" }], selectedWindshieldChipCount: 0, }; actions.saveVehicleDamage(context, payload); // Assert expect(dispatch).toHaveBeenNthCalledWith( 1, storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES ); expect(commit).toBeCalledWith(storeMutations.UPDATE_IS_REPAIR, payload.isWindshieldRepair); expect(commit).toBeCalledWith( storeMutations.UPDATE_NUMBER_OF_CHIPS, payload.isWindshieldRepair ? parseInt(payload.selectedWindshieldChipCount) : null ); expect(commit).toBeCalledWith( storeMutations.UPDATE_GLASS_TO_REPLACE, payload.selectedGlassToReplace ); }); describe("runExperimentsForTrigger", () => { beforeEach(() => { mutations.resetState(state); globalMethods.callHttpClient = jest.fn().mockReturnValue({ data: { experiments: [ { mockProperty: "mockValue", }, ], }, }); }); test("triggerEvent is SiteEntry => set triggeredSiteEntry to true in store", async () => { // Arrange const context = state; context.commit = jest .fn() .mockImplementation((storeMutation, value) => mutations[storeMutation](context, value) ); context.getters = { ...getters, applicationUser: getters.applicationUser(context), }; // Act await actions.runExperimentsForTrigger(context, { payload: { triggerEvent: experimentTriggers.SITE_ENTRY, }, pageNameToLog: "test", }); // Assert expect(context.commit).toHaveBeenNthCalledWith( 1, storeMutations.UPDATE_TRIGGERED_SITE_ENTRY, true ); expect(context.getters.applicationUser.triggeredSiteEntry).toBe(true); expect(globalMethods.callHttpClient).toHaveBeenCalled(); expect(context.commit).toHaveBeenNthCalledWith(2, storeMutations.UPDATE_EXPERIMENTS, [ { mockProperty: "mockValue", }, ]); }); test("triggerEvent is not SiteEntry => triggeredSiteEntry is false in store", async () => { // Arrange const context = state; context.commit = jest .fn() .mockImplementation((storeMutation, value) => mutations[storeMutation](context, value) ); context.getters = { ...getters, applicationUser: getters.applicationUser(context), }; expect(context.commit).toHaveBeenCalledTimes(0); // Act await actions.runExperimentsForTrigger(context, { payload: { triggerEvent: "NotSiteEntry", }, pageNameToLog: "test", }); // Assert expect(context.commit).not.toHaveBeenCalledWith( storeMutations.UPDATE_TRIGGERED_SITE_ENTRY, expect.any ); expect(context.getters.applicationUser.triggeredSiteEntry).toBe(false); expect(globalMethods.callHttpClient).toHaveBeenCalledTimes(1); expect(context.commit).toHaveBeenNthCalledWith(1, storeMutations.UPDATE_EXPERIMENTS, [ { mockProperty: "mockValue", }, ]); }); }); describe("savePartQuestionAnswers", () => { let context; beforeEach(() => { jest.clearAllMocks(); mutations.resetState(state); context = state; context.commit = jest .fn() .mockImplementation((storeMutation, value) => mutations[storeMutation](context, value) ); context.getters = { ...getters, damage: getters.damage(context), }; }); function testPartQuestionAnswerDependenciesHaveBeenReset( context, shouldPartQuestionAnswersBeReset ) { if (shouldPartQuestionAnswersBeReset) { expect(context.commit).toBeCalledWith(storeMutations.UPDATE_GLASS_PARTS, null); expect(context.commit).toBeCalledWith( storeMutations.UPDATE_MOLDING_QUESTION_ANSWERS, null ); expect(context.commit).toBeCalledWith( storeMutations.UPDATE_CAPABILITY_QUESTION_ANSWERS, null ); expect(context.commit).toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.VEHICLE_PARTS.name, data: null, }); expect(context.commit).toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.MOLDING_QUESTIONS.name, data: null, }); expect(context.commit).toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.CAPABILITY_QUESTIONS.name, data: null, }); } else { expect(context.commit).not.toBeCalledWith(storeMutations.UPDATE_GLASS_PARTS, null); expect(context.commit).not.toBeCalledWith( storeMutations.UPDATE_MOLDING_QUESTION_ANSWERS, null ); expect(context.commit).not.toBeCalledWith( storeMutations.UPDATE_CAPABILITY_QUESTION_ANSWERS, null ); expect(context.commit).not.toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.VEHICLE_PARTS.name, data: null, }); expect(context.commit).not.toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.MOLDING_QUESTIONS.name, data: null, }); expect(context.commit).not.toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.CAPABILITY_QUESTIONS.name, data: null, }); } expect(context.commit).toBeCalledWith( storeMutations.UPDATE_PART_QUESTION_ANSWERS, expect.anything() ); } test("there are no previous answers => resets necessary fields", async () => { // Arrange const previousPartQuestionAnswers = []; const currentPartQuestionAnswers = [ { result: "I'M A PART!" }, { result: "I'M A PART3!" }, { result: "I'M A PART2!" }, ]; actions.savePartQuestionAnswers(context, previousPartQuestionAnswers); jest.clearAllMocks(); // Act actions.savePartQuestionAnswers(context, currentPartQuestionAnswers); // Assert testPartQuestionAnswerDependenciesHaveBeenReset(context, true); }); test("previous answers does not match current answers => resets necessary fields", () => { // Arrange const previousPartQuestionAnswers = [ { result: "I'M A PART2!" }, { result: "I'M A PART4!" }, { result: "I'M A PART3!" }, ]; const currentPartQuestionAnswers = [ { result: "I'M A PART!" }, { result: "I'M A PART3!" }, { result: "I'M A PART2!" }, ]; actions.savePartQuestionAnswers(context, previousPartQuestionAnswers); jest.clearAllMocks(); // Act actions.savePartQuestionAnswers(context, currentPartQuestionAnswers); // Assert testPartQuestionAnswerDependenciesHaveBeenReset(context, true); }); test("previous answers match current answers => does not reset fields", () => { // Arrange const previousPartQuestionAnswers = [ { result: "I'M A PART2!" }, { result: "I'M A PART!" }, { result: "I'M A PART3!" }, ]; const currentPartQuestionAnswers = [ { result: "I'M A PART!" }, { result: "I'M A PART3!" }, { result: "I'M A PART2!" }, ]; actions.savePartQuestionAnswers(context, previousPartQuestionAnswers); jest.clearAllMocks(); // Act actions.savePartQuestionAnswers(context, currentPartQuestionAnswers); // Assert testPartQuestionAnswerDependenciesHaveBeenReset(context, false); }); test("previous answers have more questions/answers than current => resets fields", () => { // Arrange const previousPartQuestionAnswers = [ { result: "I'M A PART2!" }, { result: "I'M A PART!" }, { result: "I'M A PART3!" }, ]; const currentPartQuestionAnswers = [ { result: "I'M A PART!" }, { result: "I'M A PART3!" }, ]; actions.savePartQuestionAnswers(context, previousPartQuestionAnswers); jest.clearAllMocks(); // Act actions.savePartQuestionAnswers(context, currentPartQuestionAnswers); // Assert testPartQuestionAnswerDependenciesHaveBeenReset(context, true); }); test("current answers have more questions/answers than previous => resets fields", () => { // Arrange const previousPartQuestionAnswers = [ { result: "I'M A PART2!" }, { result: "I'M A PART3!" }, ]; const currentPartQuestionAnswers = [ { result: "I'M A PART!" }, { result: "I'M A PART3!" }, { result: "I'M A PART2!" }, ]; actions.savePartQuestionAnswers(context, previousPartQuestionAnswers); jest.clearAllMocks(); // Act actions.savePartQuestionAnswers(context, currentPartQuestionAnswers); // Assert testPartQuestionAnswerDependenciesHaveBeenReset(context, true); }); }); describe("resetMoldingAndCapabilityQuestionAnswersIfNeeded", () => { let context; beforeEach(() => { mutations.resetState(state); context = state; context.commit = jest .fn() .mockImplementation((storeMutation, value) => mutations[storeMutation](context, value) ); context.getters = { ...getters, pageData: getters.pageData(context), }; }); function testVehiclePartDependenciesHaveBeenReset(context, shouldAnswersBeReset) { if (shouldAnswersBeReset) { expect(context.commit).toBeCalledWith(storeMutations.UPDATE_GLASS_PARTS, null); expect(context.commit).toBeCalledWith( storeMutations.UPDATE_MOLDING_QUESTION_ANSWERS, null ); expect(context.commit).toBeCalledWith( storeMutations.UPDATE_CAPABILITY_QUESTION_ANSWERS, null ); expect(context.commit).toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.MOLDING_QUESTIONS.name, data: null, }); expect(context.commit).toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.CAPABILITY_QUESTIONS.name, data: null, }); } else { expect(context.commit).not.toBeCalledWith(storeMutations.UPDATE_GLASS_PARTS, null); expect(context.commit).not.toBeCalledWith( storeMutations.UPDATE_MOLDING_QUESTION_ANSWERS, null ); expect(context.commit).not.toBeCalledWith( storeMutations.UPDATE_CAPABILITY_QUESTION_ANSWERS, null ); expect(context.commit).not.toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.MOLDING_QUESTIONS.name, data: null, }); expect(context.commit).not.toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.CAPABILITY_QUESTIONS.name, data: null, }); } } test("there are no saved parts from molding or capability question pages => resets necessary fields", () => { // Arrange const previouslySelectedParts = {}; const currentlySelectedParts = [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART3" }, { partNumber: "PART1" }, { partNumber: "PART2" }, ], }, ]; mutations.updatePageData(context, { page: routeData.MOLDING_QUESTIONS.name, data: previouslySelectedParts, }); mutations.updatePageData(context, { page: routeData.CAPABILITY_QUESTIONS.name, data: previouslySelectedParts, }); // Act actions.resetMoldingAndCapabilityQuestionAnswersIfNeeded( context, currentlySelectedParts ); // Assert testVehiclePartDependenciesHaveBeenReset(context, true); }); describe("previously saved parts from molding-questions match selected parts => does not reset fields", () => { test("single glass location", () => { // Arrange const previouslySelectedParts = { partsOrQuestions: [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART1" }, { partNumber: "PART2" }, { partNumber: "PART3" }, ], }, ], }; const currentlySelectedParts = [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART3" }, { partNumber: "PART1" }, { partNumber: "PART2" }, ], }, ]; mutations.updatePageData(context, { page: routeData.MOLDING_QUESTIONS.name, data: previouslySelectedParts, }); // Act actions.resetMoldingAndCapabilityQuestionAnswersIfNeeded( context, currentlySelectedParts ); // Assert testVehiclePartDependenciesHaveBeenReset(context, false); }); test("multiple glass locations", () => { // Arrange const previouslySelectedParts = { partsOrQuestions: [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART1" }, { partNumber: "PART2" }, { partNumber: "PART3" }, ], }, { glassLocation: "Driver", glassName: "Front", parts: [{ partNumber: "PART5" }, { partNumber: "PART4" }], }, ], }; const currentlySelectedParts = [ { glassLocation: "Driver", glassName: "Front", parts: [{ partNumber: "PART4" }, { partNumber: "PART5" }], }, { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART3" }, { partNumber: "PART1" }, { partNumber: "PART2" }, ], }, ]; mutations.updatePageData(context, { page: routeData.MOLDING_QUESTIONS.name, data: previouslySelectedParts, }); // Act actions.resetMoldingAndCapabilityQuestionAnswersIfNeeded( context, currentlySelectedParts ); // Assert testVehiclePartDependenciesHaveBeenReset(context, false); }); }); describe("previously saved parts from capability-questions match selected parts and there are none from molding-questions => does not reset fields", () => { test("Single glass location", () => { // Arrange const previouslySelectedParts = { partsOrQuestions: [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART1" }, { partNumber: "PART2" }, { partNumber: "PART3" }, ], }, ], }; const currentlySelectedParts = [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART3" }, { partNumber: "PART1" }, { partNumber: "PART2" }, ], }, ]; mutations.updatePageData(context, { page: routeData.CAPABILITY_QUESTIONS.name, data: previouslySelectedParts, }); // Act actions.resetMoldingAndCapabilityQuestionAnswersIfNeeded( context, currentlySelectedParts ); // Assert testVehiclePartDependenciesHaveBeenReset(context, false); }); test("multiple glass locations", () => { // Arrange const previouslySelectedParts = { partsOrQuestions: [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART1" }, { partNumber: "PART2" }, { partNumber: "PART3" }, ], }, { glassLocation: "Driver", glassName: "Front", parts: [{ partNumber: "PART5" }, { partNumber: "PART4" }], }, ], }; const currentlySelectedParts = [ { glassLocation: "Driver", glassName: "Front", parts: [{ partNumber: "PART4" }, { partNumber: "PART5" }], }, { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART3" }, { partNumber: "PART1" }, { partNumber: "PART2" }, ], }, ]; mutations.updatePageData(context, { page: routeData.CAPABILITY_QUESTIONS.name, data: previouslySelectedParts, }); // Act actions.resetMoldingAndCapabilityQuestionAnswersIfNeeded( context, currentlySelectedParts ); // Assert testVehiclePartDependenciesHaveBeenReset(context, false); }); }); describe("previously saved parts from molding-questions do not match selected parts => resets necessary fields", () => { test("single glass location", () => { // Arrange const previouslySelectedParts = { partsOrQuestions: [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART1" }, { partNumber: "PART6" }, { partNumber: "PART3" }, ], }, ], }; const currentlySelectedParts = [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART3" }, { partNumber: "PART1" }, { partNumber: "PART2" }, ], }, ]; mutations.updatePageData(context, { page: routeData.MOLDING_QUESTIONS.name, data: previouslySelectedParts, }); // Act actions.resetMoldingAndCapabilityQuestionAnswersIfNeeded( context, currentlySelectedParts ); // Assert testVehiclePartDependenciesHaveBeenReset(context, true); }); test("multiple glass locations", () => { // Arrange const previouslySelectedParts = { partsOrQuestions: [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART1" }, { partNumber: "PART6" }, { partNumber: "PART3" }, ], }, { glassLocation: "Driver", glassName: "Front", parts: [{ partNumber: "PART5" }, { partNumber: "PART4" }], }, ], }; const currentlySelectedParts = [ { glassLocation: "Driver", glassName: "Front", parts: [{ partNumber: "PART4" }, { partNumber: "PART5" }], }, { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART3" }, { partNumber: "PART1" }, { partNumber: "PART2" }, ], }, ]; mutations.updatePageData(context, { page: routeData.MOLDING_QUESTIONS.name, data: previouslySelectedParts, }); // Act actions.resetMoldingAndCapabilityQuestionAnswersIfNeeded( context, currentlySelectedParts ); // Assert testVehiclePartDependenciesHaveBeenReset(context, true); }); }); describe("previously saved parts from capability-questions do not match selected parts => resets necessary fields", () => { test("single glass location", () => { // Arrange const previouslySelectedParts = { partsOrQuestions: [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART1" }, { partNumber: "PART6" }, { partNumber: "PART3" }, ], }, ], }; const currentlySelectedParts = [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART3" }, { partNumber: "PART1" }, { partNumber: "PART2" }, ], }, ]; mutations.updatePageData(context, { page: routeData.MOLDING_QUESTIONS.name, data: previouslySelectedParts, }); // Act actions.resetMoldingAndCapabilityQuestionAnswersIfNeeded( context, currentlySelectedParts ); // Assert testVehiclePartDependenciesHaveBeenReset(context, true); }); test("multiple glass locations", () => { // Arrange const previouslySelectedParts = { partsOrQuestions: [ { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART1" }, { partNumber: "PART6" }, { partNumber: "PART3" }, ], }, { glassLocation: "Driver", glassName: "Front", parts: [{ partNumber: "PART5" }, { partNumber: "PART4" }], }, ], }; const currentlySelectedParts = [ { glassLocation: "Driver", glassName: "Front", parts: [{ partNumber: "PART4" }, { partNumber: "PART5" }], }, { glassLocation: "Windshield", glassName: "Single", parts: [ { partNumber: "PART3" }, { partNumber: "PART1" }, { partNumber: "PART2" }, ], }, ]; mutations.updatePageData(context, { page: routeData.CAPABILITY_QUESTIONS.name, data: previouslySelectedParts, }); // Act actions.resetMoldingAndCapabilityQuestionAnswersIfNeeded( context, currentlySelectedParts ); // Assert testVehiclePartDependenciesHaveBeenReset(context, true); }); }); }); describe("saveMoldingQuestionAnswers", () => { let context; beforeEach(() => { jest.clearAllMocks(); mutations.resetState(state); context = state; context.commit = jest .fn() .mockImplementation((storeMutation, value) => mutations[storeMutation](context, value) ); context.getters = { ...getters, damage: getters.damage(context), }; }); function testMoldingQuestionAnswerDependenciesHaveBeenReset(context, shouldAnswersBeReset) { if (shouldAnswersBeReset) { expect(context.commit).toBeCalledWith(storeMutations.UPDATE_GLASS_PARTS, null); expect(context.commit).toBeCalledWith( storeMutations.UPDATE_CAPABILITY_QUESTION_ANSWERS, null ); expect(context.commit).toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.CAPABILITY_QUESTIONS.name, data: null, }); } else { expect(context.commit).not.toBeCalledWith(storeMutations.UPDATE_GLASS_PARTS, null); expect(context.commit).not.toBeCalledWith( storeMutations.UPDATE_CAPABILITY_QUESTION_ANSWERS, null ); expect(context.commit).not.toBeCalledWith(storeMutations.UPDATE_PAGE_DATA, { page: routeData.CAPABILITY_QUESTIONS.name, data: null, }); } } test("there are no previous answers => resets necessary fields", () => { // Arrange const previousMoldingQuestionAnswers = []; const currentMoldingQuestionAnswers = [ { partNum: "I'M A PART!" }, { partNum: "I'M A PART3!" }, { partNum: "I'M A PART2!" }, ]; actions.saveMoldingQuestionAnswers(context, previousMoldingQuestionAnswers); jest.clearAllMocks(); // Act actions.saveMoldingQuestionAnswers(context, currentMoldingQuestionAnswers); // Assert testMoldingQuestionAnswerDependenciesHaveBeenReset(context, true); }); test("previous answers match current answers => does not reset fields", () => { // Arrange const previousMoldingQuestionAnswers = [ { partNum: "I'M A PART2!" }, { partNum: "I'M A PART3!" }, { partNum: "I'M A PART!" }, ]; const currentMoldingQuestionAnswers = [ { partNum: "I'M A PART!" }, { partNum: "I'M A PART3!" }, { partNum: "I'M A PART2!" }, ]; actions.saveMoldingQuestionAnswers(context, previousMoldingQuestionAnswers); jest.clearAllMocks(); // Act actions.saveMoldingQuestionAnswers(context, currentMoldingQuestionAnswers); // Assert testMoldingQuestionAnswerDependenciesHaveBeenReset(context, false); }); test("previous answers do not match current answers => resets necessary fields", () => { // Arrange const previousMoldingQuestionAnswers = [ { partNum: "I'M A PART2!" }, { partNum: "I'M A PART4!" }, { partNum: "I'M A PART!" }, ]; const currentMoldingQuestionAnswers = [ { partNum: "I'M A PART!" }, { partNum: "I'M A PART3!" }, { partNum: "I'M A PART2!" }, ]; actions.saveMoldingQuestionAnswers(context, previousMoldingQuestionAnswers); jest.clearAllMocks(); // Act actions.saveMoldingQuestionAnswers(context, currentMoldingQuestionAnswers); // Assert testMoldingQuestionAnswerDependenciesHaveBeenReset(context, true); }); test("previous answers have more questions/answers than current => resets fields", () => { // Arrange const previousMoldingQuestionAnswers = [ { partNum: "I'M A PART2!" }, { partNum: "I'M A PART4!" }, { partNum: "I'M A PART!" }, ]; const currentMoldingQuestionAnswers = [{ partNum: "I'M A PART!" }]; actions.saveMoldingQuestionAnswers(context, previousMoldingQuestionAnswers); jest.clearAllMocks(); // Act actions.saveMoldingQuestionAnswers(context, currentMoldingQuestionAnswers); // Assert testMoldingQuestionAnswerDependenciesHaveBeenReset(context, true); }); test("current answers have more questions/answers than previous => resets fields", () => { // Arrange const previousMoldingQuestionAnswers = [ { partNum: "I'M A PART2!" }, { partNum: "I'M A PART!" }, ]; const currentMoldingQuestionAnswers = [ { partNum: "I'M A PART!" }, { partNum: "I'M A PART3!" }, { partNum: "I'M A PART2!" }, ]; actions.saveMoldingQuestionAnswers(context, previousMoldingQuestionAnswers); jest.clearAllMocks(); // Act actions.saveMoldingQuestionAnswers(context, currentMoldingQuestionAnswers); // Assert testMoldingQuestionAnswerDependenciesHaveBeenReset(context, true); }); }); describe("saveCapabilityQuestionAnswers", () => { let context; beforeEach(() => { jest.clearAllMocks(); mutations.resetState(state); context = state; context.commit = jest .fn() .mockImplementation((storeMutation, value) => mutations[storeMutation](context, value) ); context.getters = { ...getters, damage: getters.damage(context), }; }); function testCapabilityQuestionAnswerDependenciesHaveBeenReset( context, shouldAnswersBeReset ) { if (shouldAnswersBeReset) { expect(context.commit).toBeCalledWith(storeMutations.UPDATE_GLASS_PARTS, null); } else { expect(context.commit).not.toBeCalledWith(storeMutations.UPDATE_GLASS_PARTS, null); } } test("there are no previous answers => resets necessary fields", () => { // Arrange const previousCapabilityQuestionAnswers = []; const currentCapabilityQuestionAnswers = [ { result: "DYNAMIC" }, { result: "STATIC" }, { result: "UNKNOWN" }, ]; actions.saveCapabilityQuestionAnswers(context, previousCapabilityQuestionAnswers); jest.clearAllMocks(); // Act actions.saveCapabilityQuestionAnswers(context, currentCapabilityQuestionAnswers); // Assert testCapabilityQuestionAnswerDependenciesHaveBeenReset(context, true); }); test("previous answers match current answers => does not reset fields", () => { // Arrange const previousCapabilityQuestionAnswers = [ { result: "STATIC" }, { result: "DYNAMIC" }, { result: "UNKNOWN" }, ]; const currentCapabilityQuestionAnswers = [ { result: "DYNAMIC" }, { result: "STATIC" }, { result: "UNKNOWN" }, ]; actions.saveCapabilityQuestionAnswers(context, previousCapabilityQuestionAnswers); jest.clearAllMocks(); // Act actions.saveCapabilityQuestionAnswers(context, currentCapabilityQuestionAnswers); // Assert testCapabilityQuestionAnswerDependenciesHaveBeenReset(context, false); }); test("previous answers do not match current answers => resets necessary fields", () => { // Arrange const previousCapabilityQuestionAnswers = [ { result: "DYNAMIC" }, { result: "DYNAMIC" }, { result: "STATIC" }, ]; const currentCapabilityQuestionAnswers = [ { result: "STATIC" }, { result: "STATIC" }, { result: "DYNAMIC" }, ]; actions.saveCapabilityQuestionAnswers(context, previousCapabilityQuestionAnswers); jest.clearAllMocks(); // Act actions.saveCapabilityQuestionAnswers(context, currentCapabilityQuestionAnswers); // Assert testCapabilityQuestionAnswerDependenciesHaveBeenReset(context, true); }); test("previous answers have more questions/answers than current => resets fields", () => { // Arrange const previousCapabilityQuestionAnswers = [ { result: "STATIC" }, { result: "DYNAMIC" }, { result: "UNKNOWN" }, ]; const currentCapabilityQuestionAnswers = [{ result: "DYNAMIC" }]; actions.saveCapabilityQuestionAnswers(context, previousCapabilityQuestionAnswers); jest.clearAllMocks(); // Act actions.saveCapabilityQuestionAnswers(context, currentCapabilityQuestionAnswers); // Assert testCapabilityQuestionAnswerDependenciesHaveBeenReset(context, true); }); test("current answers have more questions/answers than previous => resets fields", () => { // Arrange const previousCapabilityQuestionAnswers = [{ result: "STATIC" }, { result: "UNKNOWN" }]; const currentCapabilityQuestionAnswers = [ { result: "DYNAMIC" }, { result: "STATIC" }, { result: "UNKNOWN" }, ]; actions.saveCapabilityQuestionAnswers(context, previousCapabilityQuestionAnswers); jest.clearAllMocks(); // Act actions.saveCapabilityQuestionAnswers(context, currentCapabilityQuestionAnswers); // Assert testCapabilityQuestionAnswerDependenciesHaveBeenReset(context, true); }); }); describe("saveActiveAndOrInactivePromos", () => { it("should save empty arrays to promos and inactivePromos when provided with empty or null parameters", () => { // Arrange const context = state; context.commit = jest.fn(); const emptyActivePromos = []; const emptyInactivePromos = []; const nullActivePromos = []; const nullInactivePromos = []; // Act actions.saveActiveAndOrInactivePromos(context, { activePromos: emptyActivePromos, inactivePromos: emptyInactivePromos, }); actions.saveActiveAndOrInactivePromos(context, { activePromos: nullActivePromos, inactivePromos: nullInactivePromos, }); // Assert expect(context.commit).toHaveBeenNthCalledWith(1, storeMutations.UPDATE_PROMOS, []); expect(context.commit).toHaveBeenNthCalledWith( 2, storeMutations.UPDATE_INACTIVE_PROMOS, [] ); expect(context.commit).toHaveBeenNthCalledWith(3, storeMutations.UPDATE_PROMOS, []); expect(context.commit).toHaveBeenNthCalledWith( 4, storeMutations.UPDATE_INACTIVE_PROMOS, [] ); }); it("should save both active and inactivePromos when method is supplied with both active and inactive", () => { // Arrange const context = state; context.commit = jest.fn(); const activePromos = [{ promoCode: "activePromo" }]; const inactivePromos = ["inactivePromo"]; // Act actions.saveActiveAndOrInactivePromos(context, { activePromos: activePromos, inactivePromos: inactivePromos, }); // Assert expect(context.commit).toBeCalledWith(storeMutations.UPDATE_PROMOS, activePromos); expect(context.commit).toBeCalledWith( storeMutations.UPDATE_INACTIVE_PROMOS, inactivePromos ); }); it("should remove any inactivePromos that are already active when supplied with both active and inactive", () => { // Arrange const context = state; context.commit = jest.fn(); const activePromos = [{ promoCode: "duplicatePromo" }]; const inactivePromos = ["duplicatePromo", "uniquePromo"]; const expectedInactivePromos = ["uniquePromo"]; // Act actions.saveActiveAndOrInactivePromos(context, { activePromos: activePromos, inactivePromos: inactivePromos, }); // Assert expect(context.commit).toBeCalledWith( storeMutations.UPDATE_INACTIVE_PROMOS, expectedInactivePromos ); }); it("should save active promos from store and inactive promos from method call when only inactivePromos is provided", () => { // Arrange const context = state; context.commit = jest.fn(); const activePromos = [{ promoCode: "storedPromo" }]; const inactivePromos = ["inactivePromo"]; context["getters"] = { lineItems: { promos: activePromos } }; // Act actions.saveActiveAndOrInactivePromos(context, { inactivePromos: inactivePromos }); // Assert expect(context.commit).toBeCalledWith(storeMutations.UPDATE_PROMOS, activePromos); expect(context.commit).toBeCalledWith( storeMutations.UPDATE_INACTIVE_PROMOS, inactivePromos ); }); it("should save active promos but remove duplicates from store and inactive promos from method call when only inactivePromos is provided", () => { // If only inactivePromos is supplied, it will remove duplicates from active promos in the store // Arrange const context = state; context.commit = jest.fn(); const activePromos = [{ promoCode: "storedPromo" }, { promoCode: "duplicatePromo" }]; const inactivePromos = ["duplicatePromo"]; context["getters"] = { lineItems: { promos: activePromos } }; const expectedSavedActivePromos = [{ promoCode: "storedPromo" }]; // Act actions.saveActiveAndOrInactivePromos(context, { inactivePromos: inactivePromos }); // Assert expect(context.commit).toBeCalledWith( storeMutations.UPDATE_PROMOS, expectedSavedActivePromos ); expect(context.commit).toBeCalledWith( storeMutations.UPDATE_INACTIVE_PROMOS, inactivePromos ); }); it("should save inactivePromos from the store and provided activePromos when only activePromos is provided", () => { // Arrange const context = state; context.commit = jest.fn(); const activePromos = [{ promoCode: "activePromo" }]; const inactivePromos = ["inactivePromo"]; context["getters"] = { payment: { inactivePromos: inactivePromos } }; // Act actions.saveActiveAndOrInactivePromos(context, { activePromos: activePromos }); // Assert expect(context.commit).toBeCalledWith(storeMutations.UPDATE_PROMOS, activePromos); expect(context.commit).toBeCalledWith( storeMutations.UPDATE_INACTIVE_PROMOS, inactivePromos ); }); it("should save inactivePromos without duplicates from activePromos from the store and provided activePromos when only activePromos is provided", () => { // Arrange const context = state; context.commit = jest.fn(); const activePromos = [{ promoCode: "activePromo" }, { promoCode: "duplicatePromo" }]; const inactivePromos = ["inactivePromo", "duplicatePromo"]; context["getters"] = { payment: { inactivePromos: inactivePromos } }; const expectedInactivePromos = ["inactivePromo"]; // Act actions.saveActiveAndOrInactivePromos(context, { activePromos: activePromos }); // Assert expect(context.commit).toBeCalledWith(storeMutations.UPDATE_PROMOS, activePromos); expect(context.commit).toBeCalledWith( storeMutations.UPDATE_INACTIVE_PROMOS, expectedInactivePromos ); }); }); describe("validateOrderPromoAndSaveServerData", () => { it("should add GUIDs if not there to provided lineItemsToUse.vaps before sending the http call", async () => { // Arrange const context = state; const promoCode = "testPromo"; const lineItemsToUse = { vaps: [{ partNumber: 1 }], promos: [{ promoCode: "1wiper0" }], }; const addableVaps = [{ partNumber: "addableVap" }]; context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", }, referralSequenceNumber: "test", lineItems: { serverData: "test", }, }, }; globalMethods.callHttpClient = jest.fn().mockResolvedValue({ data: {}, }); crypto.randomUUID = jest.fn(() => "GUID"); // Act actions.validateOrderPromoAndSaveServerData(context, { payload: { promoCode: promoCode, lineItemsToUse: lineItemsToUse, addableVaps: addableVaps, }, pageNameToLog: "test", }); const firstCallArgs = globalMethods.callHttpClient.mock.calls[0]; // Assert const vapsItem = firstCallArgs[0].payload.order.lineItemsOnOrder.filter( (item) => item.partNumber == 1 )[0]; expect(vapsItem.id).toEqual("GUID"); }); it("should not duplicate ids during syncing if there are two identical vaps items", async () => { // Arrange const context = state; const promoCode = "testPromo"; // AddableVaps will sync its ids to vaps already on the order const lineItemsToUse = { vaps: [ { partNumber: "SBB22", id: "GUID1" }, { partNumber: "SBB22", id: "GUID2" }, ], promos: [{ promoCode: "1wiper0" }], }; const addableVaps = [{ partNumber: "SBB22" }, { partNumber: "SBB22" }]; context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", }, referralSequenceNumber: "test", lineItems: { serverData: "test", }, }, }; globalMethods.callHttpClient = jest.fn().mockResolvedValue({ data: {}, }); crypto.randomUUID = jest.fn(() => "GUID"); // Act actions.validateOrderPromoAndSaveServerData(context, { payload: { promoCode: promoCode, lineItemsToUse: lineItemsToUse, addableVaps: addableVaps, }, pageNameToLog: "test", }); const firstCallArgs = globalMethods.callHttpClient.mock.calls[0]; // Assert const vapsItems = firstCallArgs[0].payload.addableVaps.filter( (item) => item.partNumber == "SBB22" ); expect(vapsItems[1].id).toEqual("GUID1"); expect(vapsItems[0].id).toEqual("GUID2"); }); it("should add GUIDs if not there to provided addableVaps before sending the http call", async () => { // Arrange const context = state; const promoCode = "testPromo"; const lineItemsToUse = { vaps: [{ partNumber: 1 }], promos: [{ promoCode: "1wiper0" }], }; const addableVaps = [{ partNumber: "addableVap" }]; context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", }, referralSequenceNumber: "test", lineItems: { serverData: "test", }, }, }; globalMethods.callHttpClient = jest.fn().mockResolvedValue({ data: {}, }); crypto.randomUUID = jest.fn(() => "GUID"); // Act actions.validateOrderPromoAndSaveServerData(context, { payload: { promoCode: promoCode, lineItemsToUse: lineItemsToUse, addableVaps: addableVaps, }, pageNameToLog: "test", }); const firstCallArgs = globalMethods.callHttpClient.mock.calls[0]; // Assert expect(firstCallArgs[0].payload.addableVaps[0].id).toEqual("GUID"); }); it("should use lineItems from the store if not provided in the call", async () => { // Arrange const context = state; const promoCode = "testPromo"; const lineItemsToUse = null; const addableVaps = [{ partNumber: "addableVap" }]; context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", }, referralSequenceNumber: "test", lineItems: { vaps: [{ partNumber: 1 }], promos: [{ promoCode: "1wiper0" }], serverData: "test", }, }, }; globalMethods.callHttpClient = jest.fn().mockResolvedValue({ data: {}, }); crypto.randomUUID = jest.fn(() => "GUID"); const expectedLineItemsOnOrder = [ { partNumber: 1, isChildPart: false, id: "GUID" }, { promoCode: "1wiper0", isChildPart: false }, ]; // Act actions.validateOrderPromoAndSaveServerData(context, { payload: { promoCode: promoCode, lineItemsToUse: lineItemsToUse, addableVaps: addableVaps, }, pageNameToLog: "test", }); const firstCallArgs = globalMethods.callHttpClient.mock.calls[0]; // Assert expect(firstCallArgs[0].payload.order.lineItemsOnOrder).toEqual( expectedLineItemsOnOrder ); }); it("should not blow up if an error comes back from the http call", async () => { // Arrange const context = state; const promoCode = "testPromo"; const lineItemsToUse = null; const addableVaps = [{ partNumber: "addableVap" }]; context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", }, referralSequenceNumber: "test", lineItems: { vaps: [{ partNumber: 1 }], promos: [{ promoCode: "1wiper0" }], serverData: "test", }, }, }; globalMethods.callHttpClient = jest.fn(() => Promise.reject(new Error("Error message")) ); crypto.randomUUID = jest.fn(() => "GUID"); // Act try { await actions.validateOrderPromoAndSaveServerData(context, { payload: { promoCode: promoCode, lineItemsToUse: lineItemsToUse, addableVaps: addableVaps, }, pageNameToLog: "test", }); } catch (error) { // Assert fail("Unhandled error occurred"); } }); it("should always save serverData if any is received from the http call", async () => { // Arrange const context = state; const promoCode = "testPromo"; const lineItemsToUse = null; const addableVaps = [{ partNumber: "addableVap" }]; context.commit = jest.fn(() => {}); context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", }, referralSequenceNumber: "test", lineItems: { vaps: [{ partNumber: 1 }], promos: [{ promoCode: "1wiper0" }], serverData: "test", }, }, }; globalMethods.callHttpClient = jest.fn().mockResolvedValue({ data: { serverData: "serverData" }, }); crypto.randomUUID = jest.fn(() => "GUID"); // Act await actions.validateOrderPromoAndSaveServerData(context, { payload: { promoCode: promoCode, lineItemsToUse: lineItemsToUse, addableVaps: addableVaps, }, pageNameToLog: "test", }); // Assert expect(context.commit).toBeCalledWith( storeMutations.UPDATE_LINE_ITEMS_SERVER_DATA, expect.anything() ); }); }); describe("revalidateOrderPromosAndSaveServerData", () => { it("should add GUIDs if not there to provided vaps before sending the http call", async () => { // Arrange const context = state; context.commit = jest.fn(() => {}); context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", inactivePromos: ["inactiveTest"], }, referralSequenceNumber: "test", lineItems: { serverData: "test", promos: [{ promoCode: "test" }], vaps: [{ partNumber: "testVap" }], }, }, }; globalMethods.callHttpClient = jest.fn().mockResolvedValue({ data: { lineItemsServerData: "testData" }, }); crypto.randomUUID = jest.fn(() => "GUID"); // Act actions.revalidateOrderPromosAndSaveServerData(context, { payload: {}, pageNameToLog: "test", }); const firstCallArgs = globalMethods.callHttpClient.mock.calls[0]; // Assert const vapsLineItem = firstCallArgs[0].payload.order.lineItemsOnOrder.filter( (lineItem) => { return lineItem.partNumber == "testVap"; } ); expect(vapsLineItem[0].id).toEqual("GUID"); }); it("uses provided parameters in favor of store values", async () => { // Arrange const context = state; context.commit = jest.fn(() => {}); const activePromosToUse = [{ promoCode: "providedPromo", isChildPart: false }]; const inactivePromosToUse = ["providedInactivePromo"]; const vapsProvided = [{ id: 123, isChildPart: false }]; const lineItemsToUse = { vaps: vapsProvided }; context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", inactivePromos: ["inactiveTest"], }, referralSequenceNumber: "test", lineItems: { serverData: "test", promos: [{ promoCode: "test" }], vaps: [{ partNumber: "testVap" }], }, }, }; globalMethods.callHttpClient = jest.fn().mockResolvedValue({ data: { lineItemsServerData: "testData" }, }); crypto.randomUUID = jest.fn(() => "GUID"); // Act actions.revalidateOrderPromosAndSaveServerData(context, { payload: { activePromosToUse: activePromosToUse, inactivePromosToUse: inactivePromosToUse, lineItemsToUse: lineItemsToUse, }, pageNameToLog: "test", }); const firstCallArgs = globalMethods.callHttpClient.mock.calls[0]; const expectedInactivePromos = ["providedInactivePromo"]; const expectedLineItemsOnOrder = [...vapsProvided, ...activePromosToUse]; // Assert expect(firstCallArgs[0].payload.inactivePromos).toEqual(expectedInactivePromos); expect(firstCallArgs[0].payload.order.lineItemsOnOrder).toEqual( expectedLineItemsOnOrder ); }); it("can build a valid payload with store data only", async () => { // Arrange const context = state; context.commit = jest.fn(() => {}); context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", inactivePromos: ["inactiveTest"], }, referralSequenceNumber: "test", lineItems: { serverData: "test", promos: [{ promoCode: "test", isChildPart: false }], vaps: [{ partNumber: "testVap", isChildPart: false, id: "providedId" }], }, }, }; globalMethods.callHttpClient = jest.fn().mockResolvedValue({ data: { lineItemsServerData: "testData" }, }); crypto.randomUUID = jest.fn(() => "GUID"); // Act actions.revalidateOrderPromosAndSaveServerData(context, { payload: {}, pageNameToLog: "test", }); const expectedLineItemsOnOrder = [ ...context.getters.order.lineItems.vaps, ...context.getters.order.lineItems.promos, ]; const firstCallArgs = globalMethods.callHttpClient.mock.calls[0]; // Assert expect(firstCallArgs[0].payload.inactivePromos).toEqual( context.getters.order.payment.inactivePromos ); expect(firstCallArgs[0].payload.order.lineItemsOnOrder).toEqual( expectedLineItemsOnOrder ); }); it("removes any promos from inactivePromos that are already active before sending the request", async () => { // Arrange const context = state; context.commit = jest.fn(() => {}); const activePromosToUse = [{ promoCode: "providedPromoDuplicate" }]; const inactivePromosToUse = ["providedPromoDuplicate"]; const vapsProvided = [{ id: 123 }]; const lineItemsToUse = { vaps: vapsProvided }; context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", }, referralSequenceNumber: "test", lineItems: { serverData: "test", }, }, }; globalMethods.callHttpClient = jest.fn().mockResolvedValue({ data: { lineItemsServerData: "testData" }, }); crypto.randomUUID = jest.fn(() => "GUID"); // Act actions.revalidateOrderPromosAndSaveServerData(context, { payload: { activePromosToUse: activePromosToUse, inactivePromosToUse: inactivePromosToUse, lineItemsToUse: lineItemsToUse, }, pageNameToLog: "test", }); const firstCallArgs = globalMethods.callHttpClient.mock.calls[0]; // Assert expect(firstCallArgs[0].payload.inactivePromos).toEqual([]); }); it("saves serverData to the store", async () => { // Arrange const context = state; context.commit = jest.fn(() => {}); const activePromosToUse = [{ promoCode: "providedPromoDuplicate" }]; const inactivePromosToUse = ["providedPromoDuplicate"]; const vapsProvided = [{ id: 123 }]; const lineItemsToUse = { vaps: vapsProvided }; context["getters"] = { order: { serviceLocation: { appointmentType: "test", state: "test", zipCodeCtu: "test", }, vehicle: { carId: "test", year: "test", }, referralCorrelationId: "test", eon: "test", damage: { isRepair: true, glassToReplace: null, }, payment: { parentAccountNumber: "test", }, referralSequenceNumber: "test", lineItems: { serverData: "test", }, }, }; globalMethods.callHttpClient = jest.fn().mockResolvedValue({ data: { lineItemsServerData: "testData" }, }); crypto.randomUUID = jest.fn(() => "GUID"); // Act await actions.revalidateOrderPromosAndSaveServerData(context, { payload: { activePromosToUse: activePromosToUse, inactivePromosToUse: inactivePromosToUse, lineItemsToUse: lineItemsToUse, }, pageNameToLog: "test", }); // Assert expect(context.commit).toBeCalledWith( storeMutations.UPDATE_LINE_ITEMS_SERVER_DATA, expect.anything() ); }); }); describe("v2 time slot actions", () => { const buildTimeSlotContext = () => ({ state, getters: { payment: { billToAccountNumber: "87291" }, }, }); it("getShopTimeSlotsV2 calls v2 shop endpoint with providerNumbers and endDate", async () => { const context = buildTimeSlotContext(); globalMethods.callHttpClient.mockResolvedValue({ data: { providerTimeSlots: [] } }); await actions.getShopTimeSlotsV2(context, { payload: { startDate: "2026-07-07", endDate: "2026-07-21", shopAppointmentType: "InshopOrDropoff", providerNumbers: ["05018", "05019"], }, pageNameToLog: "scheduling", }); expect(globalMethods.callHttpClient).toHaveBeenCalledWith( expect.objectContaining({ method: endpoints.GetShopTimeSlotsV2.method, endpoint: endpoints.GetShopTimeSlotsV2.url, payload: expect.objectContaining({ startDate: "2026-07-07", endDate: "2026-07-21", providerNumbers: ["05018", "05019"], shopAppointmentType: "InshopOrDropoff", }), }) ); }); it("getMobileTimeSlotsV2 calls v2 mobile endpoint with endDate", async () => { const context = buildTimeSlotContext(); globalMethods.callHttpClient.mockResolvedValue({ data: { days: [] } }); await actions.getMobileTimeSlotsV2(context, { payload: { startDate: "2026-07-07", endDate: "2026-07-21", zipCode: "43235", }, pageNameToLog: "scheduling", }); expect(globalMethods.callHttpClient).toHaveBeenCalledWith( expect.objectContaining({ method: endpoints.GetMobileTimeSlotsV2.method, endpoint: endpoints.GetMobileTimeSlotsV2.url, payload: expect.objectContaining({ startDate: "2026-07-07", endDate: "2026-07-21", zipCode: "43235", }), }) ); }); }); }); describe("submittedStateRevision", () => { beforeEach(() => { mutations.resetState(store.state); window.sessionStorage.removeItem(sessionStorageKeyConstants.SUBMITTED_STATE); }); it("resetSubmittedState action commits INCREMENT_SUBMITTED_STATE_REVISION", async () => { const context = { commit: jest.fn() }; await actions.resetSubmittedState(context); expect(context.commit).toHaveBeenCalledWith( storeMutations.INCREMENT_SUBMITTED_STATE_REVISION ); }); it("createSubmittedState action commits INCREMENT_SUBMITTED_STATE_REVISION at end", async () => { const context = { commit: jest.fn(), state: { order: { payment: { insuranceCoverage: { isVerified: false } }, policy: { currentDeductible: 0 }, lineItems: {}, }, applicationUser: { experiments: [], affiliateCookies: [], }, }, }; await actions.createSubmittedState(context); expect(context.commit).toHaveBeenCalledWith( storeMutations.INCREMENT_SUBMITTED_STATE_REVISION ); }); it("addDonationToSubmittedState action commits INCREMENT_SUBMITTED_STATE_REVISION", async () => { window.sessionStorage.setItem( sessionStorageKeyConstants.SUBMITTED_STATE, JSON.stringify({ order: { lineItems: { supportingItems: [] }, }, applicationUser: {}, }) ); const context = { commit: jest.fn() }; await actions.addDonationToSubmittedState(context, 5); expect(context.commit).toHaveBeenCalledWith( storeMutations.INCREMENT_SUBMITTED_STATE_REVISION ); }); it("coverageIsVerified re-evaluates after resetSubmittedState clears sessionStorage", () => { window.sessionStorage.setItem( sessionStorageKeyConstants.SUBMITTED_STATE, JSON.stringify({ order: { payment: { insuranceCoverage: { isVerified: true } }, policy: { currentDeductible: 500 }, }, applicationUser: {}, }) ); expect(store.getters.coverageIsVerified).toBe(true); store.dispatch(storeActions.RESET_SUBMITTED_STATE); expect(store.getters.coverageIsVerified).toBe(false); }); }); describe("Getters", () => { it("Vehicle getter, should return vehicle data", () => { // Arrange const storeState = state; // Act mutations.updateYear(storeState, "2019"); mutations.updateMake(storeState, "Acura"); mutations.updateModel(storeState, "ILX"); // Assert expect(getters.vehicle(storeState).year).toEqual("2019"); expect(getters.vehicle(storeState).make).toEqual("Acura"); expect(getters.vehicle(storeState).model).toEqual("ILX"); }); it("Get event bus item by event category and eventSubCategory", () => { // Arrange const storeState = state; const event = { category: "CategoryOne", subCategory: "SubCategoryOne", eventValue: "EventValueOne", }; // Act mutations.addEventToBus(storeState, event); // Assert //expect(storeState.applicationUser.eventBus).toEqual([event]); expect(getters.eventBusItem(storeState)(event.category, event.subCategory)).toEqual( event.eventValue ); }); it("Get event bus", () => { // Arrange const storeState = state; storeState.applicationUser.eventBus = []; const event = { category: "CategoryOne", subCategory: "SubCategoryOne", eventValue: "EventValueOne", }; // Act mutations.addEventToBus(storeState, event); // Assert expect(getters.eventBus(storeState)).toEqual([event]); }); it("Damage getter, should return damage data", () => { // Arrange const storeState = state; // Act mutations.updateGlassToReplace(storeState, ["Rear"]); // Assert expect(getters.damage(storeState).glassToReplace).toEqual(["Rear"]); }); it("lineItems getter, should return lineItem data", () => { // Arrange const storeState = state; // Act mutations.updateGlassParts(storeState, { "Rear-Stationary": "PART101" }); // Assert expect(getters.lineItems(storeState).glassParts).toEqual({ "Rear-Stationary": "PART101" }); }); it("PageData getter, should return page data for specific page", () => { // Arrange const storeState = state; // Act mutations.updatePageData(storeState, { page: "vehicle-year", data: {} }); // Assert expect(getters.pageData(storeState)("vehicle-year")).toEqual({}); }); it("Payment getter, should return payment data", () => { // Arrange const storeState = state; //Act mutations.updateInsuranceVerifiedStatus(storeState, true); //Assert expect(getters.payment(storeState).insuranceCoverage.isVerified).toEqual(true); }); describe("isMobileAppointment", () => { it("Should return true for mobile appointments", () => { // Arrange const storeState = state; // Act mutations.updateServiceLocation(storeState, { appointmentType: AppointmentTypeStrings.MOBILE, }); // Assert expect(getters.isMobileAppointment(storeState)).toBe(true); }); it("Should return false for non-mobile appointments", () => { // Arrange const storeState = state; // Act mutations.updateServiceLocation(storeState, { appointmentType: AppointmentTypeStrings.IN_SHOP, }); // Assert expect(getters.isMobileAppointment(storeState)).toBe(false); }); it("Should return false for null appointments", () => { // Arrange const storeState = state; // Act mutations.updateServiceLocation(storeState, { appointmentType: null }); // Assert expect(getters.isMobileAppointment(storeState)).toBe(false); }); }); describe("experimentOrder", () => { test("glassToReplace, glassParts, and otherParts are null > return correct experimentOrder values", () => { // Arrange const storeState = state; const mockStateValues = { funnelVehicleYear: 1000, funnelVehicleMake: "CarMake", funnelVehicleModel: "CarModel", funnelVehicleStyle: "SuperCoolStyle", funnelIsRepair: true, funnelNumberOfChips: 9999999, funnelCarId: "Gibberish", funnelServiceCity: "Columbus", funnelServiceState: "OH-IO", funnelServiceZipCode: 43215, funnelParentAccountNumber: "999999", funnelPolicyIsItac: "false", funnelPolicyIsNoComp: "false", funnelIsCoverageVerified: true, funnelGlassParts: null, funnelSupportingItems: null, funnelVaps: null, funnelGlassToReplace: null, funnelProviderNumber: "1", funnelReferralType: "CASH QUOTE", funnelServiceZipCodeCtu: "11111", }; //Act mutations.updateYear(storeState, mockStateValues.funnelVehicleYear); mutations.updateMake(storeState, mockStateValues.funnelVehicleMake); mutations.updateModel(storeState, mockStateValues.funnelVehicleModel); mutations.updateStyle(storeState, mockStateValues.funnelVehicleStyle); mutations.updateIsRepair(storeState, mockStateValues.funnelIsRepair); mutations.updateNumberOfChips(storeState, mockStateValues.funnelNumberOfChips); mutations.updateCarId(storeState, mockStateValues.funnelCarId); mutations.updateServiceLocation(storeState, { city: mockStateValues.funnelServiceCity, state: mockStateValues.funnelServiceState, zipCode: mockStateValues.funnelServiceZipCode, zipCodeCtu: mockStateValues.funnelServiceZipCodeCtu, provider: { providerNumber: mockStateValues.funnelProviderNumber, }, }); mutations.updateParentAcctNumber(storeState, mockStateValues.funnelParentAccountNumber); mutations.updateInsuranceVerifiedStatus( storeState, mockStateValues.funnelIsCoverageVerified ); mutations.updateIsInsurance(storeState, false); mutations.updateGlassParts(storeState, mockStateValues.funnelGlassParts); mutations.updateSupportingItems(storeState, mockStateValues.funnelSupportingItems); mutations.updateVaps(storeState, mockStateValues.funnelVaps); mutations.updateGlassToReplace(storeState, mockStateValues.funnelGlassToReplace); //Assert expect(getters.experimentOrder(storeState)).toEqual({ funnelVehicleYear: mockStateValues.funnelVehicleYear, funnelVehicleMake: mockStateValues.funnelVehicleMake, funnelVehicleModel: mockStateValues.funnelVehicleModel, funnelVehicleStyle: mockStateValues.funnelVehicleStyle, funnelIsRepair: mockStateValues.funnelIsRepair, funnelNumberOfChips: mockStateValues.funnelNumberOfChips, funnelCarId: mockStateValues.funnelCarId, funnelServiceCity: mockStateValues.funnelServiceCity, funnelServiceState: mockStateValues.funnelServiceState, funnelServiceZipCode: mockStateValues.funnelServiceZipCode, funnelParentAccountNumber: mockStateValues.funnelParentAccountNumber, funnelPolicyIsItac: mockStateValues.funnelPolicyIsItac, funnelPolicyIsNoComp: mockStateValues.funnelPolicyIsNoComp, funnelIsCoverageVerified: mockStateValues.funnelIsCoverageVerified, funnelOrderPartNumbers: [], funnelOrderPartTypes: [], funnelHasRecalibrationPart: false, funnelSelectedMultiGlass: false, funnelSelectedWindshieldGlass: false, funnelSelectedBackGlass: false, funnelSelectedDriverSideGlass: false, funnelSelectedPassengerSideGlass: false, funnelProviderNumber: mockStateValues.funnelProviderNumber, funnelReferralType: mockStateValues.funnelReferralType, funnelServiceZipCodeCtu: mockStateValues.funnelServiceZipCodeCtu, }); }); test("glassToReplace, glassParts, and otherParts are empty > return correct experimentOrder values", () => { // Arrange const storeState = state; const mockStateValues = { funnelVehicleYear: 1000, funnelVehicleMake: "CarMake", funnelVehicleModel: "CarModel", funnelVehicleStyle: "SuperCoolStyle", funnelIsRepair: true, funnelNumberOfChips: 9999999, funnelCarId: "Gibberish", funnelServiceCity: "Columbus", funnelServiceState: "OH-IO", funnelServiceZipCode: 43215, funnelParentAccountNumber: "999999", funnelPolicyIsItac: "false", funnelPolicyIsNoComp: "false", funnelIsCoverageVerified: true, funnelGlassParts: [], funnelOtherParts: [], funnelGlassToReplace: [], funnelProviderNumber: "1", funnelReferralType: "CASH QUOTE", funnelServiceZipCodeCtu: "11111", }; //Act mutations.updateYear(storeState, mockStateValues.funnelVehicleYear); mutations.updateMake(storeState, mockStateValues.funnelVehicleMake); mutations.updateModel(storeState, mockStateValues.funnelVehicleModel); mutations.updateStyle(storeState, mockStateValues.funnelVehicleStyle); mutations.updateIsRepair(storeState, mockStateValues.funnelIsRepair); mutations.updateNumberOfChips(storeState, mockStateValues.funnelNumberOfChips); mutations.updateCarId(storeState, mockStateValues.funnelCarId); mutations.updateServiceLocation(storeState, { city: mockStateValues.funnelServiceCity, state: mockStateValues.funnelServiceState, zipCode: mockStateValues.funnelServiceZipCode, zipCodeCtu: mockStateValues.funnelServiceZipCodeCtu, provider: { providerNumber: mockStateValues.funnelProviderNumber, }, }); mutations.updateParentAcctNumber(storeState, mockStateValues.funnelParentAccountNumber); mutations.updateInsuranceVerifiedStatus( storeState, mockStateValues.funnelIsCoverageVerified ); mutations.updateIsInsurance(storeState, false); mutations.updateGlassParts(storeState, mockStateValues.funnelGlassParts); mutations.updateSupportingItems(storeState, mockStateValues.funnelSupportingItems); mutations.updateVaps(storeState, mockStateValues.funnelVaps); mutations.updateGlassToReplace(storeState, mockStateValues.funnelGlassToReplace); //Assert expect(getters.experimentOrder(storeState)).toEqual({ funnelVehicleYear: mockStateValues.funnelVehicleYear, funnelVehicleMake: mockStateValues.funnelVehicleMake, funnelVehicleModel: mockStateValues.funnelVehicleModel, funnelVehicleStyle: mockStateValues.funnelVehicleStyle, funnelIsRepair: mockStateValues.funnelIsRepair, funnelNumberOfChips: mockStateValues.funnelNumberOfChips, funnelCarId: mockStateValues.funnelCarId, funnelServiceCity: mockStateValues.funnelServiceCity, funnelServiceState: mockStateValues.funnelServiceState, funnelServiceZipCode: mockStateValues.funnelServiceZipCode, funnelParentAccountNumber: mockStateValues.funnelParentAccountNumber, funnelPolicyIsItac: mockStateValues.funnelPolicyIsItac, funnelPolicyIsNoComp: mockStateValues.funnelPolicyIsNoComp, funnelIsCoverageVerified: mockStateValues.funnelIsCoverageVerified, funnelOrderPartNumbers: [], funnelOrderPartTypes: [], funnelHasRecalibrationPart: false, funnelSelectedMultiGlass: false, funnelSelectedWindshieldGlass: false, funnelSelectedBackGlass: false, funnelSelectedDriverSideGlass: false, funnelSelectedPassengerSideGlass: false, funnelProviderNumber: mockStateValues.funnelProviderNumber, funnelReferralType: mockStateValues.funnelReferralType, funnelServiceZipCodeCtu: mockStateValues.funnelServiceZipCodeCtu, }); }); test("Single windshield requiring recalibration is selected > return correct experimentOrder values", () => { // Arrange const storeState = state; const mockStateValues = { vehicleYear: 1000, vehicleMake: "CarMake", vehicleModel: "CarModel", vehicleStyle: "SuperCoolStyle", isRepair: false, numberOfChips: 0, carId: "Gibberish", serviceCity: "Columbus", serviceState: "OH-IO", serviceZipCode: 43215, parentAccountNumber: "999999", funnelPolicyIsItac: "false", funnelPolicyIsNoComp: "false", isCoverageVerified: false, glassParts: [ { partNumber: "WINDSHIELDPARTNUMBER", description: "This is a windshield", recalibrationType: "ADAS, maybe", requiresRecalibration: true, requiresCapabilityQuestions: false, }, ], otherParts: [], glassToReplace: [ { glassLocation: "Windshield", glassName: "Single", }, ], funnelProviderNumber: "1", funnelReferralType: "CASH QUOTE", funnelServiceZipCodeCtu: "11111", }; //Act mutations.updateYear(storeState, mockStateValues.vehicleYear); mutations.updateMake(storeState, mockStateValues.vehicleMake); mutations.updateModel(storeState, mockStateValues.vehicleModel); mutations.updateStyle(storeState, mockStateValues.vehicleStyle); mutations.updateIsRepair(storeState, mockStateValues.isRepair); mutations.updateNumberOfChips(storeState, mockStateValues.numberOfChips); mutations.updateCarId(storeState, mockStateValues.carId); mutations.updateServiceLocation(storeState, { city: mockStateValues.serviceCity, state: mockStateValues.serviceState, zipCode: mockStateValues.serviceZipCode, zipCodeCtu: mockStateValues.funnelServiceZipCodeCtu, provider: { providerNumber: mockStateValues.funnelProviderNumber, }, }); mutations.updateParentAcctNumber(storeState, mockStateValues.parentAccountNumber); mutations.updateInsuranceVerifiedStatus(storeState, mockStateValues.isCoverageVerified); mutations.updateIsInsurance(storeState, false); mutations.updateGlassParts(storeState, mockStateValues.glassParts); mutations.updateSupportingItems(storeState, mockStateValues.funnelSupportingItems); mutations.updateVaps(storeState, mockStateValues.funnelVaps); mutations.updateGlassToReplace(storeState, mockStateValues.glassToReplace); //Assert expect(getters.experimentOrder(storeState)).toEqual({ funnelVehicleYear: mockStateValues.vehicleYear, funnelVehicleMake: mockStateValues.vehicleMake, funnelVehicleModel: mockStateValues.vehicleModel, funnelVehicleStyle: mockStateValues.vehicleStyle, funnelIsRepair: mockStateValues.isRepair, funnelNumberOfChips: mockStateValues.numberOfChips, funnelCarId: mockStateValues.carId, funnelServiceCity: mockStateValues.serviceCity, funnelServiceState: mockStateValues.serviceState, funnelServiceZipCode: mockStateValues.serviceZipCode, funnelParentAccountNumber: mockStateValues.parentAccountNumber, funnelPolicyIsItac: mockStateValues.funnelPolicyIsItac, funnelPolicyIsNoComp: mockStateValues.funnelPolicyIsNoComp, funnelIsCoverageVerified: mockStateValues.isCoverageVerified, funnelOrderPartNumbers: ["WINDSHIELDPARTNUMBER"], funnelOrderPartTypes: ["ADAS, maybe"], funnelHasRecalibrationPart: false, funnelSelectedMultiGlass: false, funnelSelectedWindshieldGlass: true, funnelSelectedBackGlass: false, funnelSelectedDriverSideGlass: false, funnelSelectedPassengerSideGlass: false, funnelProviderNumber: mockStateValues.funnelProviderNumber, funnelReferralType: mockStateValues.funnelReferralType, funnelServiceZipCodeCtu: mockStateValues.funnelServiceZipCodeCtu, }); }); test("Single windshield with recalibration child part > return correct experimentOrder values", () => { // Arrange const storeState = state; const mockStateValues = { vehicleYear: 1000, vehicleMake: "CarMake", vehicleModel: "CarModel", vehicleStyle: "SuperCoolStyle", isRepair: false, numberOfChips: 0, carId: "Gibberish", serviceCity: "Columbus", serviceState: "OH-IO", serviceZipCode: 43215, parentAccountNumber: "999999", funnelPolicyIsItac: "false", funnelPolicyIsNoComp: "false", isCoverageVerified: false, glassParts: [ { partNumber: "WINDSHIELDPARTNUMBER", description: "This is a windshield", recalibrationType: "ADAS, maybe", requiresRecalibration: true, requiresCapabilityQuestions: false, childParts: [ { partNumber: "THIRD RECAL", description: "Additional Static Recal", recalibrationType: "DUAL & RECAL THIRD & HC FUNCTION TEST & RL SENSOR", ribCode: "RL", safelitePartNumber: "THIRD RECAL", status: "ACTIVE", partType: "ADAS RECALIBRATION", childParts: [], recalibrationFees: [], salesTax: null, }, ], }, ], otherParts: [], glassToReplace: [ { glassLocation: "Windshield", glassName: "Single", }, ], funnelProviderNumber: "1", funnelReferralType: "CASH QUOTE", funnelServiceZipCodeCtu: "11111", }; //Act mutations.updateYear(storeState, mockStateValues.vehicleYear); mutations.updateMake(storeState, mockStateValues.vehicleMake); mutations.updateModel(storeState, mockStateValues.vehicleModel); mutations.updateStyle(storeState, mockStateValues.vehicleStyle); mutations.updateIsRepair(storeState, mockStateValues.isRepair); mutations.updateNumberOfChips(storeState, mockStateValues.numberOfChips); mutations.updateCarId(storeState, mockStateValues.carId); mutations.updateServiceLocation(storeState, { city: mockStateValues.serviceCity, state: mockStateValues.serviceState, zipCode: mockStateValues.serviceZipCode, zipCodeCtu: mockStateValues.funnelServiceZipCodeCtu, provider: { providerNumber: mockStateValues.funnelProviderNumber, }, }); mutations.updateParentAcctNumber(storeState, mockStateValues.parentAccountNumber); mutations.updateInsuranceVerifiedStatus(storeState, mockStateValues.isCoverageVerified); mutations.updateIsInsurance(storeState, false); mutations.updateGlassParts(storeState, mockStateValues.glassParts); mutations.updateSupportingItems(storeState, mockStateValues.funnelSupportingItems); mutations.updateVaps(storeState, mockStateValues.funnelVaps); mutations.updateGlassToReplace(storeState, mockStateValues.glassToReplace); //Assert expect(getters.experimentOrder(storeState)).toEqual({ funnelVehicleYear: mockStateValues.vehicleYear, funnelVehicleMake: mockStateValues.vehicleMake, funnelVehicleModel: mockStateValues.vehicleModel, funnelVehicleStyle: mockStateValues.vehicleStyle, funnelIsRepair: mockStateValues.isRepair, funnelNumberOfChips: mockStateValues.numberOfChips, funnelCarId: mockStateValues.carId, funnelServiceCity: mockStateValues.serviceCity, funnelServiceState: mockStateValues.serviceState, funnelServiceZipCode: mockStateValues.serviceZipCode, funnelParentAccountNumber: mockStateValues.parentAccountNumber, funnelPolicyIsItac: mockStateValues.funnelPolicyIsItac, funnelPolicyIsNoComp: mockStateValues.funnelPolicyIsNoComp, funnelIsCoverageVerified: mockStateValues.isCoverageVerified, funnelOrderPartNumbers: ["WINDSHIELDPARTNUMBER"], funnelOrderPartTypes: ["ADAS, maybe"], funnelHasRecalibrationPart: true, funnelSelectedMultiGlass: false, funnelSelectedWindshieldGlass: true, funnelSelectedBackGlass: false, funnelSelectedDriverSideGlass: false, funnelSelectedPassengerSideGlass: false, funnelProviderNumber: mockStateValues.funnelProviderNumber, funnelReferralType: mockStateValues.funnelReferralType, funnelServiceZipCodeCtu: mockStateValues.funnelServiceZipCodeCtu, }); }); test("Select multiglass > return correct experimentOrder values", () => { // Arrange const storeState = state; const mockStateValues = { vehicleYear: 1000, vehicleMake: "CarMake", vehicleModel: "CarModel", vehicleStyle: "SuperCoolStyle", isRepair: false, numberOfChips: 0, carId: "Gibberish", serviceCity: "Columbus", serviceState: "OH-IO", serviceZipCode: 43215, parentAccountNumber: "999999", funnelPolicyIsItac: "false", funnelPolicyIsNoComp: "false", isCoverageVerified: false, glassParts: [ { partNumber: "BACKGLASS_PN", description: "This is a back glass", recalibrationType: null, requiresRecalibration: false, requiresCapabilityQuestions: false, }, { partNumber: "DRIVERGLASS_PN", description: "This is a driver side glass", recalibrationType: null, requiresRecalibration: false, requiresCapabilityQuestions: false, }, { partNumber: "PASSENGERGLASS_PN", description: "This is a passenger side glass", recalibrationType: null, requiresRecalibration: false, requiresCapabilityQuestions: false, }, ], otherParts: [], glassToReplace: [ { glassLocation: "Rear", glassName: "Stationary", }, { glassLocation: "Driver", glassName: "Front", }, { glassLocation: "Passenger", glassName: "Front", }, { glassLocation: "Passenger", glassName: "Quarter", }, ], funnelProviderNumber: "1", funnelReferralType: "CASH QUOTE", funnelServiceZipCodeCtu: "11111", }; //Act mutations.updateYear(storeState, mockStateValues.vehicleYear); mutations.updateMake(storeState, mockStateValues.vehicleMake); mutations.updateModel(storeState, mockStateValues.vehicleModel); mutations.updateStyle(storeState, mockStateValues.vehicleStyle); mutations.updateIsRepair(storeState, mockStateValues.isRepair); mutations.updateNumberOfChips(storeState, mockStateValues.numberOfChips); mutations.updateCarId(storeState, mockStateValues.carId); mutations.updateServiceLocation(storeState, { city: mockStateValues.serviceCity, state: mockStateValues.serviceState, zipCode: mockStateValues.serviceZipCode, zipCodeCtu: mockStateValues.funnelServiceZipCodeCtu, provider: { providerNumber: mockStateValues.funnelProviderNumber, }, }); mutations.updateParentAcctNumber(storeState, mockStateValues.parentAccountNumber); mutations.updateInsuranceVerifiedStatus(storeState, mockStateValues.isCoverageVerified); mutations.updateIsInsurance(storeState, false); mutations.updateGlassParts(storeState, mockStateValues.glassParts); mutations.updateSupportingItems(storeState, mockStateValues.funnelSupportingItems); mutations.updateVaps(storeState, mockStateValues.funnelVaps); mutations.updateGlassToReplace(storeState, mockStateValues.glassToReplace); //Assert expect(getters.experimentOrder(storeState)).toEqual({ funnelVehicleYear: mockStateValues.vehicleYear, funnelVehicleMake: mockStateValues.vehicleMake, funnelVehicleModel: mockStateValues.vehicleModel, funnelVehicleStyle: mockStateValues.vehicleStyle, funnelIsRepair: mockStateValues.isRepair, funnelNumberOfChips: mockStateValues.numberOfChips, funnelCarId: mockStateValues.carId, funnelServiceCity: mockStateValues.serviceCity, funnelServiceState: mockStateValues.serviceState, funnelServiceZipCode: mockStateValues.serviceZipCode, funnelParentAccountNumber: mockStateValues.parentAccountNumber, funnelPolicyIsItac: mockStateValues.funnelPolicyIsItac, funnelPolicyIsNoComp: mockStateValues.funnelPolicyIsNoComp, funnelIsCoverageVerified: mockStateValues.isCoverageVerified, funnelOrderPartNumbers: ["BACKGLASS_PN", "DRIVERGLASS_PN", "PASSENGERGLASS_PN"], funnelOrderPartTypes: [], funnelHasRecalibrationPart: false, funnelSelectedMultiGlass: true, funnelSelectedWindshieldGlass: false, funnelSelectedBackGlass: true, funnelSelectedDriverSideGlass: true, funnelSelectedPassengerSideGlass: true, funnelProviderNumber: mockStateValues.funnelProviderNumber, funnelReferralType: mockStateValues.funnelReferralType, funnelServiceZipCodeCtu: mockStateValues.funnelServiceZipCodeCtu, }); }); }); }); describe("isVinOptionalVehicle", () => { const testVehicles = [ ["2017", "acura", false], ["2018", "bmw", false], ["2009", "bmw", true], ["2016", "bmw", false], ["2016", "mercedes benz", false], ["2016", "volkswagen", false], ["2016", "audi", false], ["2016", "porsche", true], ["2009", "audi", true], ]; test.each(testVehicles)( "%s %s should skip vin lookup is %s", async (year, make, expectedVinSkip) => { const context = state; context.state = { order: { vehicle: { year: year, make: make }, }, }; mutations.updateSkipVINLookup(context.state, expectedVinSkip); var vinOptionalResult = actions.isVinOptionalVehicle(context); expect(vinOptionalResult).toEqual(expectedVinSkip); } ); const testcarID = [ ["CR00000100", "make", [{ glassLocation: "driver" }], false], ["CR00067899", "make2", [{ glassLocation: "windshield" }], true], [ "CR00062396", "make3", [{ glassLocation: "windshield" }, { glassLocation: "driver" }], true, ], ["CR00066428", "make4", [{ glassLocation: "rear" }], false], ]; test.each(testcarID)( "%s %s %o should skip vin lookup is %s", async (carId, make, glassLocation, expectedVinSkip) => { const context = state; context.state = { order: { vehicle: { make: make, carId: carId }, damage: { glassToReplace: glassLocation, }, }, }; mutations.updateSkipVINLookup(context.state, expectedVinSkip); var vinOptionalResult = actions.isVinOptionalVehicle(context); expect(vinOptionalResult).toEqual(expectedVinSkip); } ); it("getParts action, should include problemQuestionId in answerResults payload", async () => { const context = { getters: { vehicle: { carId: "CR00065283", vin: "SAJWA6A73F8K13235" }, damage: { glassToReplace: [{ glassLocation: "Windshield", glassName: "Single" }], partQuestionAnswers: [ { glassLocation: "Windshield", glassName: "Single", result: "FW04848", problemQuestionId: 38560, answeredQuestions: [ { questionText: "Is your vehicle equipped with the Panoramic Sunroof which can be identified by having a glass panel over the rear seats?", selectedAnswer: "1|nextQuestion|2|Yes", selectedAnswerText: "Yes", questionNum: 1, problemQuestionId: 38557, }, { questionText: "Is your vehicle equipped with a heated windshield that melts snow and ice from underneath the windshield wiper blades?", selectedAnswer: "2|answer|FW04848|Yes", selectedAnswerText: "Yes", questionNum: 2, problemQuestionId: 38560, }, ], }, ], }, payment: { parentAccountNumber: "167132" }, }, state: { order: { serviceLocation: { zipCode: "43085", appointmentType: null }, referralSequenceNumber: "11330779", }, }, }; globalMethods.callHttpClient.mockImplementation(({ payload }) => { return Promise.resolve({ data: { glassPieceParts: [] }, payload }); }); await actions.getParts(context, { pageNameToLog: "part-questions" }); expect(globalMethods.callHttpClient).toHaveBeenCalledWith( expect.objectContaining({ endpoint: endpoints.GetParts.url, payload: expect.objectContaining({ answerResults: [ { location: "Windshield", name: "Single", result: "FW04848", problemQuestionId: 38560, }, ], }), }) ); }); it("getParts action, should omit problemQuestionId when not saved on part question answer", async () => { const context = { getters: { vehicle: { carId: "CR00065283", vin: "SAJWA6A73F8K13235" }, damage: { glassToReplace: [{ glassLocation: "Windshield", glassName: "Single" }], partQuestionAnswers: [ { glassLocation: "Windshield", glassName: "Single", result: "FW04848", }, ], }, payment: { parentAccountNumber: "167132" }, }, state: { order: { serviceLocation: { zipCode: "43085", appointmentType: null }, referralSequenceNumber: "11330779", }, }, }; globalMethods.callHttpClient.mockImplementation(() => { return Promise.resolve({ data: { glassPieceParts: [] } }); }); await actions.getParts(context, { pageNameToLog: "part-questions" }); expect(globalMethods.callHttpClient).toHaveBeenCalledWith( expect.objectContaining({ payload: expect.objectContaining({ answerResults: [ { location: "Windshield", name: "Single", result: "FW04848", }, ], }), }) ); }); });