import { setActivePinia, createPinia } from 'pinia'; import { useMainStore, getDefaultState } from '@/store/index.js'; import globalMethods from '@/global-methods.js'; import { getRandomString, getRandomGuid, getRandomInt, getRandomBoolean, getRandomEnum } from '@/helpers/data-generation.js'; import coverageStatuses from '@/constants/coverage-statuses.js'; import { paymentMethods } from '@/constants/payment-method-constants'; import endpoints from '@/constants/endpoints'; import { AppointmentTypeStrings } from '@/constants/schedule-constants'; import coverageType from '@/constants/coverage-type'; import { getEnumName } from '@/helpers/unit-test-helper'; import { strictEqual } from 'assert'; import partNumberStrings from '@/constants/part-number-strings'; import applicationConfig from '@/constants/application-config'; describe('Store', () => { let store; beforeEach(() => { const pinia = createPinia(); setActivePinia(pinia); store = useMainStore(); const defaultState = getDefaultState(); Object.keys(defaultState).forEach((key) => { store[key] = defaultState[key]; }); store.applicationUser.eventBus = []; jest.resetAllMocks(); }); it('Should Store Vehicle Year', () => { const testYear = '2001'; store.updateVehicleYear(testYear); expect(store.order.vehicle.year).toEqual(testYear); }); it('Should add events to the bus', () => { // Arrange const category = getRandomString(1, 25); const subCategory = getRandomString(5, 20); const isDismissible = getRandomBoolean(); const copy = getRandomString(5, 25); const headline = getRandomString(5, 25); const type = getRandomString(5, 15); const event = { category, subCategory, eventValue: { isDismissible, messageCopy: copy, messageHeadline: headline, type } }; // Act store.addEventToBus(event); // Assert expect(store.applicationUser.eventBus[0]).toEqual(event); }); it('Should remove events from the bus', () => { // Arrange const category = getRandomString(1, 25); const subCategory = getRandomString(5, 20); const isDismissible = getRandomBoolean(); const copy = getRandomString(5, 25); const headline = getRandomString(5, 25); const type = getRandomString(5, 15); const event = { category, subCategory, eventValue: { isDismissible, messageCopy: copy, messageHeadline: headline, type } }; store.addEventToBus(event); expect(store.applicationUser.eventBus.length).toBe(1); // Act store.removeEventFromBus({ category: event.category, subCategory: event.subCategory }); // Assert expect(store.applicationUser.eventBus.length).toBe(0); }); it('Should return correct event using the getter function eventBusItem', () => { // Arrange const category = getRandomString(1, 25); const subCategory = getRandomString(5, 20); const isDismissible = getRandomBoolean(); const copy = getRandomString(5, 25); const headline = getRandomString(5, 25); const type = getRandomString(5, 15); const event = { category, subCategory, eventValue: { isDismissible, messageCopy: copy, messageHeadline: headline, type } }; store.addEventToBus(event); // Act const actual = store.eventBusItem(event.category, event.subCategory); // Assert expect(actual).toEqual(event.eventValue); }); it('UpdateVehicle should merge vehicle with response object', () => { // Arrange const carId = getRandomString(10, 14); const category = getRandomString(3, 7); const year = getRandomInt(1960, 2023); const make = getRandomString(4, 10); const model = getRandomString(4, 10); const style = getRandomString(4, 15); const imageUrl = getRandomString(50, 100); const imageVifNumber = getRandomInt(10000, 99999).toString(); const imageColor = getRandomString(4, 10); const fleetNumber = getRandomString(1, 2); const fleetUnitNumber = getRandomString(1, 2); const providedVehicle = { carId, category, year, make, model, style, imageUrl, imageVifNumber, imageVifColor: imageColor, fleetNumber, fleetUnitNumber }; const expectedVehicle = { carId, category, year, make, model, style, imageUrl, imageVifNumber, imageColor, fleetNumber, fleetUnitNumber }; // Act store.updateVehicle(providedVehicle); // Assert expect(store.order.vehicle).toMatchObject(expectedVehicle); }); it('updateVehicleCoverage should set policy values appropriately with repair waived', () => { // Arrange const noCoverage = getRandomBoolean(); const deductible = getRandomInt(1, 500); const endorsements = [getRandomString(10, 20)]; const vehicleCoverage = { noCoverage, deductible, repairWaived: true, endorsements }; const expectedPolicy = { deductible: { replace: deductible, repair: 0 }, endorsements }; // Act store.updateVehicleCoverage(vehicleCoverage); // Assert expect(store.order.policy).toMatchObject(expectedPolicy); }); it('UpdateVehicle should set policy values appropriately with repair not waived', () => { // Arrange const noCoverage = getRandomBoolean(); const deductible = getRandomInt(1, 500); const endorsements = [getRandomString(10, 20)]; const vehicleCoverage = { noCoverage, deductible, repairWaived: false, endorsements }; const expectedPolicy = { deductible: { replace: deductible, repair: deductible }, endorsements }; // Act store.updateVehicleCoverage(vehicleCoverage); // Assert expect(store.order.policy).toMatchObject(expectedPolicy); }); describe.each([ [coverageType.NO_COMP, true, true], [coverageType.NONE, false, true], [coverageType.Deductible, true, false] ])('updateVehicleCoverage noCoverage', (expected, enableNoCompQuote, noCoverage) => { test(`CoverageType is set to expected ${getEnumName(coverageType, expected)} when vehicle noCoverage is ${noCoverage} and enableNoCompQuote is ${enableNoCompQuote}`, () => { // Arrange store.issConfig.enableNoCompQuote = enableNoCompQuote; store.order.currentDeductible = { replace: 500, repair: 0 }; const vehicleCoverage = { noCoverage }; // Act store.updateVehicleCoverage(vehicleCoverage); // Assert expect(store.order.insuranceCoverage.coverageType).toBe(expected); }); }); // TODO update test to work also checking store values it('setVehicle should call globalMethods.callHttpClient', () => { // Arrange const carId = getRandomString(10, 14); const category = getRandomString(3, 7); const year = getRandomInt(1960, 2023); const make = getRandomString(4, 10); const model = getRandomString(4, 10); const style = getRandomString(4, 15); const imageUrl = getRandomString(50, 100); const imageVifNumber = getRandomInt(10000, 99999).toString(); const imageColor = getRandomString(4, 10); const response = { data: { carId, category, year, make, model, style, imageUrl, imageVifNumber, imageVifColor: imageColor } }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); // Act const returned = store.setVehicle(); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalled(); expect(returned).resolves.toMatchObject(response); }); it('saveVehicleDamage with windshield repair should update damage with number of chips not null', () => { // Arrange const glassName = getRandomString(4, 10); const glassLocation = getRandomString(5, 15); const isWindshieldRepair = true; const selectedGlassToReplace = [{ glassName, glassLocation }]; const chipCount = getRandomInt(0, 3); // Act store.saveVehicleDamage(isWindshieldRepair, selectedGlassToReplace, chipCount); // Assert expect(store.order.damage.glassToReplace).toEqual(selectedGlassToReplace); expect(store.order.damage.isRepair).toEqual(isWindshieldRepair); expect(store.order.damage.numberOfChips).toEqual(chipCount); }); it('saveVehicleDamage without windshield repair should update damage with number of chips null', () => { // Arrange const glassName = getRandomString(4, 10); const glassLocation = getRandomString(5, 15); const isWindshieldRepair = false; const selectedGlassToReplace = [{ glassName, glassLocation }]; const chipCount = getRandomInt(0, 3); const expectedChipCount = null; // Act store.saveVehicleDamage(isWindshieldRepair, selectedGlassToReplace, chipCount); // Assert expect(store.order.damage.glassToReplace).toEqual(selectedGlassToReplace); expect(store.order.damage.isRepair).toEqual(isWindshieldRepair); expect(store.order.damage.numberOfChips).toEqual(expectedChipCount); }); it('should return registration data if available', () => { // Arrange const streetAddress = getRandomString(5, 15); const city = getRandomString(5, 15); const state = getRandomString(5, 10); const zipCode = getRandomInt(10000, 99999).toString(); const firstName = getRandomString(5, 20); const lastName = getRandomString(5, 20); const expected = { addressQuestions: { streetAddress, city, state, zipCode }, firstName, lastName }; store.order.vehicle.registration = { licensePlate: null, address: streetAddress, city, state, zipCode, firstName, lastName }; // Act const actual = store.customerData; // Assert expect(actual).toEqual(expected); }); it('should return customer data if registration data unavailable', () => { // Arrange const address = getRandomString(1, 25); const city = getRandomString(5, 20); const state = getRandomString(4, 20); const zipCode = getRandomInt(10000, 99999).toString(); const firstName = getRandomString(5, 25); const lastName = getRandomString(5, 25); const expected = { addressQuestions: { streetAddress: address, city, state, zipCode }, firstName, lastName }; store.order.vehicle.registration.address = null; store.order.customer = { address: { streetAddress: address, city, state, zipCode }, firstName, lastName }; // Act const actual = store.customerData; // Assert expect(actual).toMatchObject(expected); }); describe('registerClaim method', () => { it('successful response with no coverage => isVerified true and coverage status no comp', async () => { // Arrange const response = { data: { claimantId: null, claimNumber: getRandomString(9, 9), referralCorrelationId: getRandomGuid(), isSuccess: true, isError: false, successMessage: getRandomString(9, 9), deductible: 0 } }; store.order.insuranceCoverage.coverageType = coverageType.NO_COMP; store.order.currentDeductible = { replace: 500, repair: 0 }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); // Act await store.registerClaim(); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalled(); expect(store.order.insuranceCoverage.coverageStatus).toBe(coverageStatuses.VERIFIED); expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NO_COMP); expect(store.order.insuranceCoverage.claimNumber).toBe(response.data.claimNumber); }); it('successful response with coverage => isVerified true and coverage status verified', async () => { // Arrange const response = { data: { claimantId: null, claimNumber: getRandomString(9, 9), referralCorrelationId: getRandomGuid(), isSuccess: true, isError: false, successMessage: getRandomString(9, 9), deductible: 0 } }; store.order.insuranceCoverage.coverageType = coverageType.Deductible; store.order.currentDeductible = { replace: 500, repair: 0 }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); // Act await store.registerClaim(); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalled(); expect(store.order.insuranceCoverage.coverageStatus).toBe(coverageStatuses.VERIFIED); expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.Deductible); expect(store.order.insuranceCoverage.claimNumber).not.toBeNull(); }); it('Call to client returns exception, and no error is returned from registerClaim method', async () => { // Arrange expect.assertions(3); const error = 'register claim error'; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error)); store.order.insuranceCoverage.coverageStatus = coverageStatuses.PENDING; store.order.currentDeductible = { replace: 500, repair: 0 }; // Act await store.registerClaim().catch((e) => { expect(e).toEqual(error); }); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalled(); expect(store.order.insuranceCoverage.coverageStatus).toBe(coverageStatuses.NO_COVERAGE); expect(store.order.insuranceCoverage.claimNumber).toBe(null); }); it('calls api with expected data', async () => { // Arrange const companyCode = getRandomString(6, 6); const originalDeductible = { replace: 500, repair: 0 }; const currentDeductible = { replace: 500, repair: 0 }; const fleetNumber = getRandomString(1, 2); const fleetUnitNumber = getRandomString(1, 2); store.order.originalDeductible = { replace: originalDeductible.replace, repair: originalDeductible.repair }; store.order.currentDeductible = { replace: currentDeductible.replace, repair: currentDeductible.repair }; store.order.customer.companyCode = companyCode; store.order.vehicle.fleetNumber = fleetNumber; store.order.vehicle.fleetUnitNumber = fleetUnitNumber; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.registerClaim(); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ sourceSystem: applicationConfig.APPLICATION_NAME, policyInfo: expect.objectContaining({ company: companyCode }), fleetNumber, fleetUnitNumber }) })); }); it('calls api with memberNumber when useMemberNumber is true', async () => { // Arrange store.issConfig.useMemberNumber = true; const companyCode = getRandomString(6, 6); const policyNumber = getRandomString(6, 6); const originalDeductible = { replace: 500, repair: 0 }; const currentDeductible = { replace: 500, repair: 0 }; store.order.originalDeductible = { replace: originalDeductible.replace, repair: originalDeductible.repair }; store.order.currentDeductible = { replace: currentDeductible.replace, repair: currentDeductible.repair }; store.order.customer.companyCode = companyCode; store.order.policy.policyNumber = policyNumber; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({ data: { claimNumber: 'CLM123', isSuccess: true } })); // Act await store.registerClaim(); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ sourceSystem: applicationConfig.APPLICATION_NAME, memberNumber: policyNumber, policyInfo: expect.objectContaining({ company: companyCode }) }) })); }); }); describe('updateContactInfo method', () => { it('UpdateContactInfo updates contact info in store', () => { // Arrange const firstName = getRandomString(4, 10); const lastName = getRandomString(5, 15); const emailAddress = getRandomString(5, 15); const requestTextUpdates = getRandomBoolean(); const notesForTechnician = getRandomString(50, 150); // Act store.updateContactInfo({ firstName, lastName, emailAddress, requestTextUpdates, notesForTechnician }); // Assert expect(store.contactInfo.firstName).toEqual(firstName); expect(store.contactInfo.lastName).toEqual(lastName); expect(store.contactInfo.emailAddress).toEqual(emailAddress); expect(store.contactInfo.requestTextUpdates).toEqual(requestTextUpdates); expect(store.contactInfo.notesForTechnician).toEqual(notesForTechnician); }); it('updatePhoneNumbers updates phone info in store', () => { // Arrange const homePhone = getRandomInt(1000000000, 9999999999); const servicePhone = getRandomInt(1000000000, 9999999999); const altPhone = getRandomInt(1000000000, 9999999999); const extension = getRandomInt(10000, 99999); // Act store.updatePhoneNumbers({ home: homePhone, service: servicePhone, alternative: altPhone, extension }); // Assert expect(store.contactInfo.homePhone).toEqual(homePhone); expect(store.contactInfo.servicePhone).toEqual(servicePhone); expect(store.contactInfo.alternativePhone).toEqual(altPhone); expect(store.contactInfo.extension).toEqual(extension); }); it('All null values => contact info set in store to all null/default', () => { // Act store.updateContactInfo({}); // Assert expect(store.contactInfo.firstName).toEqual(null); expect(store.contactInfo.lastName).toEqual(null); expect(store.contactInfo.emailAddress).toEqual(null); expect(store.contactInfo.requestTextUpdates).toEqual(false); expect(store.contactInfo.notesForTechnician).toEqual(''); }); }); describe('saveSession method', () => { describe('successful method call', () => { it('calls save session api endpoint', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ method: endpoints.SaveSession.method, endpoint: endpoints.SaveSession.url })); }); it('Returns expected response object', async () => { // Arrange const response = { ReferralNumber: getRandomString(6, 6) }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); // Act const result = store.saveSession({}); // Asserts await expect(result).resolves.toBe(response); }); it('calls api with expected application user data', async () => { // Arrange const crmCustomerId = getRandomString(6, 6); const experiments = getRandomString(6, 6); const lastPageVisited = getRandomString(6, 6); const pageData = getRandomString(6, 6); const savedSessionId = getRandomString(6, 6); store.applicationUser.crmCustomerId = crmCustomerId; store.applicationUser.experiments = experiments; store.applicationUser.lastPageVisited = lastPageVisited; store.applicationUser.pageData = pageData; store.applicationUser.savedSessionId = savedSessionId; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ applicationUser: expect.objectContaining({ crmCustomerId, experiments, lastPage: lastPageVisited, pageData, savedSessionId }) }) })); }); it('calls api with expected vehicle', async () => { const year = getRandomString(6, 6); const make = getRandomString(6, 6); const model = getRandomString(6, 6); const style = getRandomString(6, 6); const carId = getRandomString(6, 6); const vin = getRandomString(6, 6); const licensePlate = getRandomString(6, 6); store.order.vehicle.year = year; store.order.vehicle.make = make; store.order.vehicle.model = model; store.order.vehicle.style = style; store.order.vehicle.carId = carId; store.order.vehicle.vin = vin; store.order.vehicle.registration.licensePlate = licensePlate; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ vehicle: expect.objectContaining({ year, make, model, style, carId, vin, licensePlateNumber: licensePlate }) }) })); }); it('calls api with expected damage', async () => { // Arrange const isRepair = getRandomString(6, 6); const numberOfChips = getRandomString(6, 6); const partQuestionAnswers = getRandomString(6, 6); const moldingQuestionAnswers = getRandomString(6, 6); const capabilityQuestionAnswers = getRandomString(6, 6); const dateOfLoss = getRandomString(6, 6); const damageCause = getRandomString(6, 6); const damageState = getRandomString(6, 6); const damageCity = getRandomString(6, 6); const isDamageGlassOnly = getRandomString(6, 6); store.order.damage.isRepair = isRepair; store.order.damage.numberOfChips = numberOfChips; store.order.damage.partQuestionAnswers = partQuestionAnswers; store.order.damage.moldingQuestionAnswers = moldingQuestionAnswers; store.order.damage.capabilityQuestionAnswers = capabilityQuestionAnswers; store.order.policy.dateOfLoss = dateOfLoss; store.order.policy.damageCause = damageCause; store.order.policy.damageState = damageState; store.order.policy.damageCity = damageCity; store.order.policy.isDamageGlassOnly = isDamageGlassOnly; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ damage: expect.objectContaining({ numberOfChips, isRepair, partQuestionAnswers, moldingQuestionAnswers, capabilityQuestionAnswers, dateOfLoss, damageCause, damageState, damageCity, isDamageGlassOnly }) }) })); }); it('calls api with expected policy', async () => { // Arrange const customerFirstName = getRandomString(6, 6); const customerLastName = getRandomString(6, 6); const customerEmail = getRandomString(6, 6); const customerPhoneNumber = getRandomString(6, 6); const customerState = getRandomString(2, 2); const policyNumber = getRandomString(6, 6); const policyZipCode = getRandomString(6, 6); const status = getRandomEnum(coverageStatuses); const type = getRandomEnum(coverageType); const originalDeductible = { replace: 500, repair: 0 }; const currentDeductible = { replace: 500, repair: 0 }; store.order.originalDeductible = { replace: originalDeductible.replace, repair: originalDeductible.repair }; store.order.currentDeductible = { replace: currentDeductible.replace, repair: currentDeductible.repair }; store.order.customer.firstName = customerFirstName; store.order.customer.lastName = customerLastName; store.order.customer.emailAddress = customerEmail; store.order.customer.address.state = customerState; store.order.contactInfo.homePhone = customerPhoneNumber; store.order.contactInfo.servicePhone = customerPhoneNumber; store.order.policy.policyNumber = policyNumber; store.order.policy.policyZipCode = policyZipCode; store.order.insuranceCoverage.coverageStatus = status; store.order.insuranceCoverage.coverageType = type; store.order.damage.isRepair = false; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ policy: expect.objectContaining({ policyHolder: expect.objectContaining({ policyFirstName: customerFirstName, policyLastName: customerLastName, policyPhoneNumber: customerPhoneNumber, policyEmail: customerEmail, policyState: customerState }), policyNumber, policyZipCode, originalDeductible: originalDeductible.replace, currentDeductible: currentDeductible.replace }), insuranceCoverage: expect.objectContaining({ coverageStatus: status, coverageType: type }) }) })); }); it('calls api with expected customer', async () => { // Arrange const streetAddress = getRandomString(6, 6); const streetAddress2 = getRandomString(6, 6); const city = getRandomString(6, 6); const state = getRandomString(6, 6); const zipCode = getRandomString(6, 6); const contactFirstName = getRandomString(6, 6); const contactLastName = getRandomString(6, 6); const contactEmail = getRandomString(6, 6); const contactHomePhone = getRandomString(6, 6); const contactServicePhone = getRandomString(6, 6); const contactAlternativePhone = getRandomString(6, 6); const requestTextUpdates = getRandomBoolean(); store.order.contactInfo.homePhone = contactHomePhone; store.order.contactInfo.servicePhone = contactServicePhone; store.order.contactInfo.alternativePhone = contactAlternativePhone; store.order.contactInfo.requestTextUpdates = requestTextUpdates; store.order.customer.firstName = contactFirstName; store.order.customer.lastName = contactLastName; store.order.customer.emailAddress = contactEmail; store.order.customer.address.streetAddress = streetAddress; store.order.customer.address.streetAddress2 = streetAddress2; store.order.customer.address.city = city; store.order.customer.address.state = state; store.order.customer.address.zipCode = zipCode; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ customer: expect.objectContaining({ address: expect.objectContaining({ streetAddress, streetAddress2, city, state, zipCode }), emailAddress: contactEmail, firstName: contactFirstName, lastName: contactLastName, homePhone: contactHomePhone, servicePhone: contactServicePhone, alternativePhone: contactAlternativePhone, isSmsOptIn: requestTextUpdates }) }) })); }); it('calls api with expected lineItems for verified deductible', async () => { // Arrange const glassParts = [{ partNumber: getRandomString(6, 6), clearOnSubmit: true }]; const supportingItems = [{ partNumber: getRandomString(6, 6), clearOnSubmit: true }]; const vaps = [{ partNumber: getRandomString(6, 6), clearOnSubmit: false }]; store.order.insuranceCoverage.coverageStatus = coverageStatuses.VERIFIED; store.order.insuranceCoverage.coverageType = coverageType.Deductible; store.order.lineItems.glassParts = glassParts; store.order.lineItems.supportingItems = supportingItems; store.order.lineItems.vaps = vaps; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ lineItems: expect.objectContaining({ glassParts, supportingItems, vaps }) }) })); }); it('calls api with expected lineItems for other coverage types', async () => { // Arrange const glassParts = [{ partNumber: getRandomString(6, 6), clearOnSubmit: false }]; const supportingItems = [{ partNumber: getRandomString(6, 6), clearOnSubmit: false }]; const vaps = [{ partNumber: getRandomString(6, 6), clearOnSubmit: false }]; store.order.lineItems.glassParts = glassParts; store.order.lineItems.supportingItems = supportingItems; store.order.lineItems.vaps = vaps; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ lineItems: expect.objectContaining({ glassParts, supportingItems, vaps }) }) })); }); describe.each([ [coverageStatuses.PENDING, coverageType.NO_COMP, null], [coverageStatuses.PENDING, coverageType.ITAC, null], [coverageStatuses.PENDING, coverageType.Deductible, null], [coverageStatuses.VERIFIED, coverageType.ITAC, 'V_ITAC_123'], [coverageStatuses.VERIFIED, coverageType.Deductible, 'V_Deductible_123'], [coverageStatuses.NO_COVERAGE, coverageType.NONE, null] ])('calls api with expected insuranceCoverage', (status, type, claimNumber) => { test(`calls api with coverageStatus is ${getEnumName(coverageStatuses, status)} and coverageType is ${getEnumName(coverageType, type)} and claimNumber is ${claimNumber}`, async () => { // Arrange store.order.insuranceCoverage.coverageStatus = status; store.order.insuranceCoverage.coverageType = type; store.order.insuranceCoverage.claimNumber = claimNumber; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ insuranceCoverage: expect.objectContaining({ coverageStatus: status, coverageType: type, claimNumber }) }) })); }); }); it('calls api with expected payment', async () => { // Arrange const parentAccountNumber = getRandomString(6, 6); store.order.parentAccountNumber = parentAccountNumber; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ payment: expect.objectContaining({ parentAccountNumber }) }) })); }); it('calls api with expected service location', async () => { // Arrange const notesForTechnician = getRandomString(6, 6); const address = getRandomString(6, 6); const city = getRandomString(6, 6); const state = getRandomString(6, 6); const zipCode = getRandomString(6, 6); const zipCodeCtu = getRandomString(6, 6); store.order.contactInfo.notesForTechnician = notesForTechnician; store.order.serviceLocation.address = address; store.order.serviceLocation.city = city; store.order.serviceLocation.state = state; store.order.serviceLocation.zipCode = zipCode; store.order.serviceLocation.zipCodeCtu = zipCodeCtu; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ serviceLocation: expect.objectContaining({ address: expect.objectContaining({ streetAddress: address, city, state, zipCode, zipCodeCtu }), techNotes: notesForTechnician }) }) })); }); it('calls api with expected schedule', async () => { // Arrange const date = getRandomString(6, 6); const startTime = getRandomString(6, 6); const endTime = getRandomString(6, 6); const routeCode = getRandomString(6, 6); const jobMaxMinutes = getRandomString(6, 6); const jobMinMinutes = getRandomString(6, 6); store.order.schedule.date = date; store.order.schedule.startTime = startTime; store.order.schedule.endTime = endTime; store.order.schedule.routeCode = routeCode; store.order.schedule.jobMaxMinutes = jobMaxMinutes; store.order.schedule.jobMinMinutes = jobMinMinutes; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ schedule: expect.objectContaining({ date, startTime, endTime, routeCode, jobMaxMinutes, jobMinMinutes }) }) })); }); it('calls api with expected referral date', async () => { // Arrange const referralDate = getRandomString(6, 6); store.order.referralDate = referralDate; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ referralDate }) })); }); it('calls api with expected referral number', async () => { // Arrange const referralNumber = getRandomString(6, 6); store.order.referralNumber = referralNumber; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ referralNumber }) })); }); }); it('No glassArray => empty list', async () => { store.damage.glassToReplace = null; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ damage: expect.objectContaining({ glassToReplace: [] }) }) })); }); it('glassArray empty => empty list', async () => { store.damage.glassToReplace = []; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ damage: expect.objectContaining({ glassToReplace: [] }) }) })); }); it('Nonempty glass array => expected glass array sent', async () => { const location1 = getRandomString(5); const location2 = getRandomString(5); const name1 = getRandomString(10); const name2 = getRandomString(10); store.damage.glassToReplace = [ { glassLocation: location1, glassName: name1 }, { glassLocation: location2, glassName: name2 } ]; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({}); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ damage: expect.objectContaining({ glassToReplace: expect.arrayContaining([ { location: location1, name: name1 }, { location: location2, name: name2 } ]) }) }) })); }); it('calls api with expected submitAfterSave', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.saveSession({ submitAfterSave: true }); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ submitAfterSave: true }) })); }); it('api call throws exception', async () => { expect.assertions(2); const error = 'save session error'; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error)); // Act await store.saveSession({}).catch((e) => { expect(e).toEqual(error); }); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ method: endpoints.SaveSession.method, endpoint: endpoints.SaveSession.url })); }); }); describe('loadSessionFromDuplicate method', () => { describe('successful method call', () => { const applicationUser = { experiments: getRandomString(6, 6) }; const vehicle = { year: getRandomInt(2000, 2024).toString(), make: getRandomString(5, 15), model: getRandomString(5, 15), style: getRandomString(5, 15), carId: getRandomInt(1000, 9999), vin: getRandomString(17, 17), licensePlateNumber: getRandomString(7, 7) }; const customer = { address: { streetAddress: getRandomString(10, 50), streetAddress2: getRandomString(5, 20), city: getRandomString(5, 20), state: getRandomString(2, 2), zipCode: getRandomString(5, 5) }, firstName: getRandomString(5, 15), lastName: getRandomString(5, 15), emailAddress: `${getRandomString(5, 10)}@test.com`, homePhone: getRandomString(10, 10), servicePhone: getRandomString(10, 10), alternativePhone: getRandomString(10, 10), isSmsOptIn: getRandomBoolean() }; const fullApiResponse = { data: { applicationUser, vehicle, customer, referralNumber: getRandomString(6, 6), referralDate: getRandomString(6, 6), referralCorrelationId: getRandomString(6, 6), referralSequenceNumber: getRandomString(6, 6), eon: getRandomString(6, 6) } }; it('calls load session api endpoint', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({ data: {} })); const duplicate = { referralNumber: getRandomString(6, 6), referralCorrelationId: getRandomGuid() }; // Act store.loadSessionFromDuplicate(duplicate); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ method: endpoints.LoadSession.method, endpoint: endpoints.LoadSession.url })); }); it('sets expected vehicle data', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse)); store.lookupVehicleByVin = jest.fn().mockReturnValue(Promise.resolve({ data: { vin: vehicle.vin, canSafeliteService: true } })); const duplicate = { referralNumber: getRandomString(6, 6), referralCorrelationId: getRandomGuid() }; store.order.insuranceCoverage.coverageType = coverageType.Deductible; store.policy.vehicles = [{ vehicle }]; // Act await store.loadSessionFromDuplicate(duplicate); // Asserts expect(store.vehicle.year).toBe(vehicle.year); expect(store.vehicle.make).toBe(vehicle.make); expect(store.vehicle.model).toBe(vehicle.model); expect(store.vehicle.style).toBe(vehicle.style); // vin is not set directly by loadSessionFromDuplicate, it's set by updateVehicle after lookupVehicleByVin expect(store.vehicle.registration.licensePlate).toBe(vehicle.licensePlateNumber); }); it('sets expected customer data', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse)); store.lookupVehicleByVin = jest.fn().mockReturnValue(Promise.resolve({ data: { vin: vehicle.vin, canSafeliteService: true } })); const duplicate = { referralNumber: getRandomString(6, 6), referralCorrelationId: getRandomGuid() }; store.order.insuranceCoverage.coverageType = coverageType.Deductible; store.policy.vehicles = [{ vin: vehicle.vin }]; // Act await store.loadSessionFromDuplicate(duplicate); // Asserts expect(store.order.customer.address.streetAddress).toBe(customer.address.streetAddress); expect(store.order.customer.address.streetAddress2).toBe(customer.address.streetAddress2); expect(store.order.customer.address.city).toBe(customer.address.city); expect(store.order.customer.address.state).toBe(customer.address.state); expect(store.order.customer.address.zipCode).toBe(customer.address.zipCode); expect(store.order.contactInfo.homePhone).toBe(customer.homePhone); }); it('sets expected remaining order data', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse)); store.lookupVehicleByVin = jest.fn().mockReturnValue(Promise.resolve({ data: { vin: vehicle.vin, canSafeliteService: true } })); const duplicate = { referralNumber: getRandomString(6, 6), referralCorrelationId: getRandomGuid() }; // Act await store.loadSessionFromDuplicate(duplicate); // Asserts expect(store.order.referralNumber).toBe(fullApiResponse.data.referralNumber); expect(store.order.referralDate).toBe(fullApiResponse.data.referralDate); expect(store.order.referralCorrelationId).toBe(fullApiResponse.data.referralCorrelationId); expect(store.order.referralSequenceNumber).toBe(fullApiResponse.data.referralSequenceNumber); expect(store.order.eon).toBe(fullApiResponse.data.eon); }); }); it('api call throws exception', async () => { expect.assertions(2); const error = 'load session error'; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error)); const duplicate = { referralNumber: getRandomString(6, 6), referralCorrelationId: getRandomGuid() }; // Act await store.loadSessionFromDuplicate(duplicate).catch((e) => { expect(e).toEqual(error); }); // Asserts expect(globalMethods.callHttpClient) .toHaveBeenCalledWith(expect.objectContaining({ method: endpoints.LoadSession.method, endpoint: endpoints.LoadSession.url })); }); }); describe('getCoveragePolicyInfo method', () => { describe('successful method call', () => { it('calls getCoveragePolicyInfo api endpoint', async () => { // Arrange store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.getCoveragePolicyInfo(); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ method: endpoints.CoveragePolicyInfo.method, endpoint: endpoints.CoveragePolicyInfo.url })); }); it('Sets policy fields for successful policy lookup', async () => { // Arrange store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; const address = getRandomString(6, 6); const city = getRandomString(6, 6); const state = getRandomString(6, 6); const zipCode = getRandomString(6, 6); const firstName = getRandomString(6, 6); const lastName = getRandomString(6, 6); const companyCode = getRandomString(6, 6); const vehicle = { id: '123' }; const response = { data: { policies: [ { insureds: [ { address, city, state, zipCode, firstName, lastName, companyCode } ], vehicles: [ vehicle ] } ] } }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); // Act await store.getCoveragePolicyInfo(); // Asserts await expect(store.order.customer.address.streetAddress).toBe(address); await expect(store.order.customer.address.city).toBe(city); await expect(store.order.customer.address.state).toBe(state); await expect(store.order.customer.address.zipCode).toBe(zipCode); await expect(store.order.customer.firstName).toBe(firstName); await expect(store.order.customer.lastName).toBe(lastName); await expect(store.order.customer.companyCode).toBe(companyCode) await expect(store.order.policy.vehicles).toStrictEqual([vehicle]); }); it('calls api with expected data', async () => { // Arrange const parentAccountNumber = getRandomString(6, 6); const policyNumber = getRandomString(6, 6); const dateOfLoss = getRandomString(6, 6); const zipCode = getRandomString(6, 6); const referralCorrelationId = getRandomString(6, 6); store.order.parentAccountNumber = parentAccountNumber; store.order.policy.policyNumber = policyNumber; store.order.policy.dateOfLoss = dateOfLoss; store.order.policy.policyZipCode = zipCode; store.order.referralCorrelationId = referralCorrelationId; store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.getCoveragePolicyInfo(); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ accountNumber: parentAccountNumber, policyNumber, dateOfLoss, zipCode, referralCorrelationId }) })); expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.not.objectContaining({ memberNumber: expect.anything() }) })); }); it('calls api with member number when useMemberNumber is true', async () => { // Arrange const parentAccountNumber = getRandomString(6, 6); const policyNumber = getRandomString(6, 6); const dateOfLoss = getRandomString(6, 6); const zipCode = getRandomString(6, 6); const referralCorrelationId = getRandomString(6, 6); store.order.parentAccountNumber = parentAccountNumber; store.order.policy.policyNumber = policyNumber; store.order.policy.dateOfLoss = dateOfLoss; store.order.policy.policyZipCode = zipCode; store.order.referralCorrelationId = referralCorrelationId; store.issConfig.isCoverageEnabled = true; store.issConfig.useMemberNumber = true; store.applicationUser.coverageLookupAttempts = 0; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); // Act await store.getCoveragePolicyInfo(); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ payload: expect.objectContaining({ accountNumber: parentAccountNumber, policyNumber, memberNumber: policyNumber, dateOfLoss, zipCode, referralCorrelationId }) })); }); it('useMemberNumber is true => member number set and policy number changed after response', async () => { // Arrange const originalPolicyNumber = getRandomString(6, 6); store.order.policy.policyNumber = originalPolicyNumber; const returnedPolicyNumber = getRandomString(6, 6); const responseNoPolicies = { data: { policies: [{ policyNumber: returnedPolicyNumber }] } }; store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; store.issConfig.useMemberNumber = true; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies)); // Act await store.getCoveragePolicyInfo(); // Asserts expect(store.order.policy.memberNumber).toBe(originalPolicyNumber); expect(store.order.policy.policyNumber).toBe(returnedPolicyNumber); // Act again await store.getCoveragePolicyInfo(); // Assert again expect(globalMethods.callHttpClient).toHaveBeenNthCalledWith(2, expect.objectContaining({ payload: expect.objectContaining({ policyNumber: returnedPolicyNumber, memberNumber: originalPolicyNumber }) })); }) it('null response by api => insuranceCoverage.coverageType is NONE', async () => { // Arrange store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(null)); // Act await store.getCoveragePolicyInfo(); // Asserts expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NONE); }); it('no policies returned by api => insuranceCoverage.coverageType is NONE', async () => { // Arrange store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; const responseNoPolicies = { data: { policies: [] } }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies)); // Act await store.getCoveragePolicyInfo(); // Asserts expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NONE); }); it('multiple policies returned by api => data set based on first policy returned', async () => { // Arrange const insured = { address: getRandomString(6, 6), firstName: getRandomString(6, 6), lastName: getRandomString(6, 6), city: getRandomString(6, 6), state: getRandomString(6, 6), zipCode: getRandomString(6, 6), companyCode: getRandomString(6, 6) }; const vehicles = [ { name: getRandomString(6, 6) }, { name: getRandomString(6, 6) } ]; const policy1 = { insureds: [insured], vehicles }; const responseNoPolicies = { data: { policies: [policy1, {}] } }; store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies)); // Act await store.getCoveragePolicyInfo(); // Asserts expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.Deductible); expect(store.order.customer.address.streetAddress).toBe(insured.address); expect(store.order.customer.address.city).toBe(insured.city); expect(store.order.customer.address.state).toBe(insured.state); expect(store.order.customer.address.zipCode).toBe(insured.zipCode); expect(store.order.customer.firstName).toBe(insured.firstName); expect(store.order.customer.lastName).toBe(insured.lastName); expect(store.order.customer.companyCode).toBe(insured.companyCode); expect(store.order.policy.vehicles).toEqual(vehicles); }); it('multiple insureds on first policy returned by api => data set based on first insured in first policy', async () => { // Arrange const insured1 = { address: getRandomString(6, 6), firstName: getRandomString(6, 6), lastName: getRandomString(6, 6), city: getRandomString(6, 6), state: getRandomString(6, 6), zipCode: getRandomString(6, 6) }; const responseNoPolicies = { data: { policies: [{ insureds: [insured1, { address: getRandomString(6, 6) }] }] } }; store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies)); // Act await store.getCoveragePolicyInfo(); // Asserts expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.Deductible); expect(store.order.customer.address.streetAddress).toBe(insured1.address); }); it('no policy vehicles on first policy => order.policy.vehicles empty list', async () => { // Arrange const responseNoPolicies = { data: { policies: [{ vehicles: [] }] } }; store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies)); // Act await store.getCoveragePolicyInfo(); // Asserts expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.Deductible); expect(store.order.policy.vehicles).toEqual([]); }); }); test('if isCoverageEnabled is false, then getCoveragePolicyInfo not called', async () => { // Arrange store.issConfig.isCoverageEnabled = false; store.applicationUser.coverageLookupAttempts = 0; // Act await store.getCoveragePolicyInfo(); // Assert expect(globalMethods.callHttpClient).not.toHaveBeenCalled(); }); test('if isCoverageEnabled is true, then getCoveragePolicyInfo called', async () => { // Arrange store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; // Act await store.getCoveragePolicyInfo(); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalled(); }); test('if maxCoverageLookupAttemptsReached is true, then getCoveragePolicyInfo not called', async () => { // Arrange store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 11; // Act await store.getCoveragePolicyInfo(); // Assert expect(globalMethods.callHttpClient).not.toHaveBeenCalled(); }); test('if maxCoverageLookupAttemptsReached is false, then getCoveragePolicyInfo called', async () => { // Arrange store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 10; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve()); // Act await store.getCoveragePolicyInfo(); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalled(); }); it('api call throws exception => no error is thrown from getCoveragePolicyInfo and insuranceCoverage.coverageType is NONE', async () => { expect.assertions(2); const error = 'get coverage policy info error'; store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error)); // Act await store.getCoveragePolicyInfo().catch((e) => { expect(e).toEqual(error); }); // Asserts expect(globalMethods.callHttpClient) .toHaveBeenCalledWith(expect.objectContaining({ method: endpoints.CoveragePolicyInfo.method, endpoint: endpoints.CoveragePolicyInfo.url })); expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NONE); }); }); describe('saveEndorsementQuestionAnswers method', () => { it('method should update endorsement question data in store', () => { // Arrange const questionNum = getRandomInt(1, 100); const questionText = getRandomString(50, 300); const selectedAnswer = getRandomString(2, 3); const endorsementQuestionAnswersArray = [ { questionNum, questionText, selectedAnswer } ]; // Act store.saveEndorsementQuestionAnswers(endorsementQuestionAnswersArray); // Assert expect(store.order.policy.endorsementQuestionAnswers).toEqual(endorsementQuestionAnswersArray); }); }); describe('duplicateSearch method', () => { it('successful response => duplicateReferrals set to expected', async () => { // Arrange const expected = [ { accountNumber: getRandomString(6, 6), claimNumber: getRandomString(9, 9) }, { accountNumber: getRandomString(6, 6), claimNumber: getRandomString(9, 9) }, { accountNumber: getRandomString(6, 6), claimNumber: getRandomString(9, 9) }]; const response = { data: expected }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); // Act await store.getDuplicateReferrals(); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalled(); expect(store.applicationUser.duplicateOrders).toEqual(expected); }); it('Call to client returns exception => object with error property returned and duplicateReferrals set to [] and no error is returned from getDuplicateReferrals', async () => { // Arrange expect.assertions(2); const error = 'get duplicate referrals error'; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error)); // Act await store.getDuplicateReferrals().catch((e) => { expect(e).toEqual(error); }); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalled(); expect(store.applicationUser.duplicateOrders.length).toBe(0); }); }); describe.each([ [true, coverageStatuses.PENDING], [true, coverageStatuses.NO_COVERAGE], [false, coverageStatuses.VERIFIED] ])('isUnverified', (expected, status) => { test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)}`, () => { // Arrange store.order.insuranceCoverage.coverageStatus = status; // Act const result = store.isUnverified; // Assert expect(result).toBe(expected); }); }); describe('isMobileAppointment', () => { it('Should return true for mobile appointments', () => { // Arrange // Act store.updateServiceLocation({ appointmentType: AppointmentTypeStrings.MOBILE }); // Assert expect(store.isMobileAppointment).toBe(true); }); it('Should return true for mobile-NotITAC-and-NotNoComp appointments', () => { // Arrange // Act store.updateServiceLocation({ appointmentType: AppointmentTypeStrings.MOBILE_NOT_ITAC_AND_NOT_NOCOMP }); // Assert expect(store.isMobileAppointment).toBe(true); }); it('Should return false for non-mobile appointments', () => { // Arrange // Act store.updateServiceLocation({ appointmentType: AppointmentTypeStrings.IN_SHOP }); // Assert expect(store.isMobileAppointment).toBe(false); }); it('Should return false for null appointments', () => { // Arrange // Act store.updateServiceLocation({ appointmentType: null }); // Assert expect(store.isMobileAppointment).toBe(false); }); }); describe('isDropoffAppointment', () => { it('Should return true for drop-off appointments', () => { // Arrange // Act store.updateServiceLocation({ appointmentType: AppointmentTypeStrings.DROP_OFF }); // Assert expect(store.isDropOffAppointment).toBe(true); }); it('Should return false for non-drop-off appointments', () => { // Arrange // Act store.updateServiceLocation({ appointmentType: AppointmentTypeStrings.MOBILE }); // Assert expect(store.isDropOffAppointment).toBe(false); }); it('Should return false for null appointments', () => { // Arrange // Act store.updateServiceLocation({ appointmentType: null }); // Assert expect(store.isDropOffAppointment).toBe(false); }); }); describe('getFinalDeductible method', () => { describe('successful method call', () => { it('calls get final deductible api endpoint', () => { // Arrange const response = { data: { deductible: getRandomInt(0, 5000), policyData: getRandomString(100, 200) } }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); store.order.damage.glassToReplace = [getRandomString(10, 15)]; // Act store.getFinalDeductible(); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ method: endpoints.FinalDeductible.method, endpoint: endpoints.FinalDeductible.url })); }); it('returns expected response object', async () => { // Arrange const response = { data: { deductible: getRandomInt(0, 5000), policyData: getRandomString(100, 200) } }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); store.order.damage.glassToReplace = [getRandomString(10, 15)]; // Act const result = store.getFinalDeductible(); // Assert await expect(result).resolves.toBe(response); }); it('calls api with expected payload', () => { // Arrange const response = { data: { deductible: getRandomInt(0, 5000), policyData: getRandomString(100, 200) } }; const location = getRandomString(10, 15).toUpperCase(); store.order.damage.glassToReplace = [ { glassLocation: location } ]; const referralCorrelationId = getRandomGuid(); const parentAccountNumber = getRandomString(6, 6); const endorsements = []; const manualGlassNames = [location]; const policyState = getRandomString(2, 2); const status = getRandomString(6, 8); const currentDeductible = 500; const originalDeductible = 500; const isRepair = getRandomBoolean(); const policyNumber = getRandomString(10, 20); const insuredFirstName = getRandomString(10, 20); const insuredLastName = getRandomString(10, 20); const insuredZipCode = getRandomInt(10000, 99999).toString(); const policyVehicleId = getRandomInt(1, 2).toString(); const vehicleVin = getRandomString(17, 17); const policyData = getRandomString(100, 200); store.order.referralCorrelationId = referralCorrelationId; store.order.parentAccountNumber = parentAccountNumber; store.order.currentDeductible = { replace: currentDeductible, repair: currentDeductible }; store.order.originalDeductible = { replace: originalDeductible, repair: originalDeductible }; store.order.policy.status = status; store.order.customer.address.state = policyState; store.order.damage.isRepair = isRepair; store.order.policy.policyNumber = policyNumber; store.order.customer.firstName = insuredFirstName; store.order.customer.lastName = insuredLastName; store.order.customer.address.zipCode = insuredZipCode; store.order.vehicle.policyVehicleId = policyVehicleId; store.order.vehicle.vin = vehicleVin; store.order.policy.policyData = policyData; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); // Act store.getFinalDeductible(); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(({ method: endpoints.FinalDeductible.method, endpoint: endpoints.FinalDeductible.url, payload: ({ referralCorrelationId, accountNumber: parentAccountNumber, endorsements, manualGlassNames, policyState, status, currentDeductible, originalDeductible, currentRepairDeductible: store.order.currentDeductible.repair, currentReplaceDeductible: store.order.currentDeductible.replace, noCoverage: store.isNoComp, isRepair, policyNumber, insuredFirstName, insuredLastName, insuredZipCode, policyVehicleId, vehicleVin, policyData, isItac: store.isITAC }), bailoutOnError: false })); }); it('includes memberNumber when flag is set', async () => { // Arrange const response = { data: { deductible: getRandomInt(0, 5000), policyData: getRandomString(100, 200) } }; const location = getRandomString(10, 15).toUpperCase(); store.order.damage.glassToReplace = [ { glassLocation: location } ]; const referralCorrelationId = getRandomGuid(); const parentAccountNumber = getRandomString(6, 6); const endorsements = []; const manualGlassNames = [location]; const policyState = getRandomString(2, 2); const status = getRandomString(6, 8); const currentDeductible = 500; const originalDeductible = 500; const isRepair = getRandomBoolean(); const policyNumber = getRandomString(10, 20); const insuredFirstName = getRandomString(10, 20); const insuredLastName = getRandomString(10, 20); const insuredZipCode = getRandomInt(10000, 99999).toString(); const policyVehicleId = getRandomInt(1, 2).toString(); const vehicleVin = getRandomString(17, 17); const policyData = getRandomString(100, 200); store.order.referralCorrelationId = referralCorrelationId; store.order.parentAccountNumber = parentAccountNumber; store.order.currentDeductible = { replace: currentDeductible, repair: currentDeductible }; store.order.originalDeductible = { replace: originalDeductible, repair: originalDeductible }; store.order.policy.status = status; store.order.customer.address.state = policyState; store.order.damage.isRepair = isRepair; store.order.policy.policyNumber = policyNumber; store.order.customer.firstName = insuredFirstName; store.order.customer.lastName = insuredLastName; store.order.customer.address.zipCode = insuredZipCode; store.order.vehicle.policyVehicleId = policyVehicleId; store.order.vehicle.vin = vehicleVin; store.order.policy.policyData = policyData; store.issConfig.useMemberNumber = true; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); // Act await store.getFinalDeductible(); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(({ method: endpoints.FinalDeductible.method, endpoint: endpoints.FinalDeductible.url, payload: ({ referralCorrelationId, accountNumber: parentAccountNumber, endorsements, manualGlassNames, policyState, status, currentDeductible, originalDeductible, currentRepairDeductible: currentDeductible, currentReplaceDeductible: currentDeductible, noCoverage: store.isNoComp, isRepair, policyNumber, insuredFirstName, insuredLastName, insuredZipCode, policyVehicleId, vehicleVin, policyData, isItac: store.isITAC, memberNumber: policyNumber }), bailoutOnError: false })); }); it('only "Yes" endorsement answers are added to payload', () => { // Arrange const response = { data: { deductible: getRandomInt(0, 5000), policyData: getRandomString(100, 200) } }; const location = getRandomString(10, 15).toUpperCase(); store.order.damage.glassToReplace = [ { glassLocation: location } ]; const referralCorrelationId = getRandomGuid(); const parentAccountNumber = getRandomString(6, 6); const manualGlassNames = [location]; const policyState = getRandomString(2, 2); const status = getRandomString(6, 8); const currentDeductible = getRandomInt(0, 5000); const originalDeductible = getRandomInt(0, 5000); const isRepair = getRandomBoolean(); const endorsementAnswers = [ { questionNum: getRandomInt(1, 10), endorsementName: getRandomString(8, 20), questionText: getRandomString(50, 100), selectedAnswer: 'Yes' }, { questionNum: getRandomInt(1, 10), endorsementName: getRandomString(8, 20), questionText: getRandomString(50, 100), selectedAnswer: 'Yes' }, { questionNum: getRandomInt(1, 10), endorsementName: getRandomString(8, 20), questionText: getRandomString(50, 100), selectedAnswer: 'No' } ]; const policyNumber = getRandomString(10, 20); const insuredFirstName = getRandomString(10, 20); const insuredLastName = getRandomString(10, 20); const insuredZipCode = getRandomInt(10000, 99999).toString(); const policyVehicleId = getRandomInt(1, 2).toString(); const vehicleVin = getRandomString(17, 17); const policyData = getRandomString(100, 200); store.order.referralCorrelationId = referralCorrelationId; store.order.parentAccountNumber = parentAccountNumber; store.order.currentDeductible = { replace: currentDeductible, repair: currentDeductible }; store.order.originalDeductible = { replace: originalDeductible, repair: originalDeductible }; store.order.policy.status = status; store.order.customer.address.state = policyState; store.order.policy.endorsementQuestionAnswers = endorsementAnswers; store.order.damage.isRepair = isRepair; store.order.policy.policyNumber = policyNumber; store.order.customer.firstName = insuredFirstName; store.order.customer.lastName = insuredLastName; store.order.customer.address.zipCode = insuredZipCode; store.order.vehicle.policyVehicleId = policyVehicleId; store.order.vehicle.vin = vehicleVin; store.order.policy.policyData = policyData; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); // Act store.getFinalDeductible(); // Assert const expected = [endorsementAnswers[0].endorsementName, endorsementAnswers[1].endorsementName]; expect(globalMethods.callHttpClient).toHaveBeenCalledWith(({ method: endpoints.FinalDeductible.method, endpoint: endpoints.FinalDeductible.url, payload: ({ referralCorrelationId, accountNumber: parentAccountNumber, endorsements: expected, manualGlassNames, policyState, status, currentDeductible, originalDeductible, currentRepairDeductible: store.order.currentDeductible.repair, currentReplaceDeductible: store.order.currentDeductible.replace, noCoverage: store.isNoComp, isRepair, policyNumber, insuredFirstName, insuredLastName, insuredZipCode, policyVehicleId, vehicleVin, policyData, isItac: store.isITAC }), bailoutOnError: false })); }); }); describe('unsuccessful api call', () => { it('api call throws exception. no error from getFinalDeductible', async () => { // Arrange expect.assertions(1); const error = 'final deductible error'; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error)); // Act await store.getFinalDeductible().catch((e) => { expect(e).toEqual(error); }); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ method: endpoints.FinalDeductible.method, endpoint: endpoints.FinalDeductible.url })); }); }); }); describe('updateDeductible method', () => { it('final deductible is saved as currentDeductible in store', () => { // Arrange store.order.damage.isRepair = false; const deductibleInfo = { deductible: 500 }; // Act store.updateDeductible(deductibleInfo); // Assert expect(store.order.currentDeductible.replace).toEqual(deductibleInfo.deductible); }); it('null final deductible => currentDeductible in store set to null', () => { // Arrange store.order.damage.isRepair = false; const deductibleInfo = { deductible: null }; // Act store.updateDeductible(deductibleInfo); // Assert expect(store.order.currentDeductible.replace).toEqual(deductibleInfo.deductible); }); }); describe('getTpaAndSafeliteProviders method', () => { describe('successful method call', () => { it.each([[true, 'Repair'], [false, 'Install']])( 'calls getProviders api endpoint with damageType %s', async (isRepair, damageType) => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); const carId = getRandomString(10, 14); const parentAccountNumber = getRandomString(6, 6); const partNumber = isRepair ? partNumberStrings.REPAIR : getRandomString(6, 6); store.order.parentAccountNumber = parentAccountNumber; store.order.damage.isRepair = isRepair; store.order.vehicle.carId = carId; store.order.lineItems.glassParts = [{ partNumber }]; const zipCode = getRandomString(5, 5); const expectedEndpoint = `${endpoints.GetTpaAndSafeliteProviders.url}/${zipCode}?accountNumber=${parentAccountNumber}&carId=${carId}&damageType=${damageType}&partNumbers=${partNumber}`; // Act await store.getTpaAndSafeliteProviders(zipCode); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ method: endpoints.GetTpaAndSafeliteProviders.method, endpoint: expectedEndpoint })); } ); it('includes providerNameSearchString in endpoint when provided', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({})); const carId = getRandomString(10, 14); const parentAccountNumber = getRandomString(6, 6); const partNumber = getRandomString(6, 6); store.order.parentAccountNumber = parentAccountNumber; store.order.damage.isRepair = true; store.order.vehicle.carId = carId; store.order.lineItems.glassParts = [{ partNumber }]; const zipCode = getRandomString(5, 5); const providerNameSearchString = 'Test Shop'; // Act await store.getTpaAndSafeliteProviders(zipCode, providerNameSearchString); // Asserts expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({ endpoint: expect.stringContaining(`&providerNameSearchString=${providerNameSearchString}`) })); }); it('Returns expected response object', async () => { // Arrange const response = { ReferralNumber: getRandomString(6, 6) }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response)); const zipCode = getRandomString(5, 5); // Act const result = store.getTpaAndSafeliteProviders(zipCode); // Asserts await expect(result).resolves.toBe(response); }); it('null response by api => no exceptions thrown', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(null)); const zipCode = getRandomString(5, 5); // Act await store.getTpaAndSafeliteProviders(zipCode); }); it('no providers returned by api => promise resolves to empty list', async () => { // Arrange const responseNoProviders = { data: { shopProviders: [] } }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoProviders)); const zipCode = getRandomString(5, 5); // Act const result = await store.getTpaAndSafeliteProviders(zipCode); // Asserts expect(result.data.shopProviders).toHaveLength(0); }); it('multiple providers returned by api => promise resolves to expected', async () => { // Arrange const provider1 = { companyName: getRandomString(6, 6) }; const provider2 = { companyName: getRandomString(6, 6) }; const responseProviders = { data: { shopProviders: [provider1, provider2] } }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseProviders)); // Act const result = await store.getTpaAndSafeliteProviders(); // Asserts expect(result.data.shopProviders).toHaveLength(2); expect(result.data.shopProviders[0]).toBe(provider1); expect(result.data.shopProviders[1]).toBe(provider2); }); }); it('api call throws exception => coverageType none and no error from getCoveragePolicyInfo', async () => { expect.assertions(2); const error = 'get coverage policy info error'; store.issConfig.isCoverageEnabled = true; store.applicationUser.coverageLookupAttempts = 0; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error)); // Act await store.getCoveragePolicyInfo().catch((e) => { expect(e).toEqual(error); }); // Asserts expect(globalMethods.callHttpClient) .toHaveBeenCalledWith(expect.objectContaining({ method: endpoints.CoveragePolicyInfo.method, endpoint: endpoints.CoveragePolicyInfo.url })); expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NONE); }); }); describe.each([ [paymentMethods.CREDIT_CARD], [paymentMethods.AFTERPAY], [paymentMethods.APPLEPAY], [paymentMethods.PAYPAL] ])('savePaymentMethodChoice method', (expected) => { test(`sets paymentMethod to ${getEnumName(paymentMethods, expected)} when value is ${getEnumName(paymentMethods, expected)}`, () => { // Arrange // Act store.savePaymentMethodChoice(expected); // Assert expect(store.order.payment.paymentMethod).toBe(expected); }); }); describe('updatePaypalToken method', () => { it('paypalToken is valid when set', () => { // Arrange const paypalToken = getRandomString(6, 6); // Act store.updatePaypalToken(paypalToken); // Assert expect(store.order.payment.paypalToken).toEqual(paypalToken); }); }); describe.each([ [true, true], [false, false], [false, null] ])('updateIsItacOptimized', (expected, isItacOptimized) => { test(`sets isItacOptimized to ${expected} when passed ${isItacOptimized}`, () => { // Arrange store.updateIsItacOptimized(isItacOptimized); // Act const result = store.order.insuranceCoverage.isItacOptimized; // Assert expect(result).toBe(expected); }); }); describe('loadSessionFromDuplicate method', () => { let mockDuplicate; let mockResponse; let savedSessionId = getRandomGuid(); beforeEach(() => { mockDuplicate = { referralNumber: getRandomString(10, 10), referralDate: new Date().toISOString(), correlationId: getRandomGuid(), savedSessionId: savedSessionId }; mockResponse = { data: { customer: { address: { streetAddress: getRandomString(10, 50), streetAddress2: getRandomString(5, 20), city: getRandomString(5, 20), state: getRandomString(2, 2), zipCode: getRandomString(5, 5) }, firstName: getRandomString(5, 15), lastName: getRandomString(5, 15), emailAddress: `${getRandomString(5, 10)}@test.com`, homePhone: getRandomString(10, 10), servicePhone: getRandomString(10, 10), alternativePhone: getRandomString(10, 10), isSmsOptIn: getRandomBoolean() }, vehicle: { year: getRandomInt(2000, 2024).toString(), make: getRandomString(5, 15), model: getRandomString(5, 15), style: getRandomString(5, 15), carId: getRandomInt(1000, 9999), vin: getRandomString(17, 17), licensePlateNumber: getRandomString(7, 7) }, insuranceCoverage: { coverageType: getRandomEnum(coverageType), coverageStatus: getRandomEnum(coverageStatuses), claimNumber: getRandomString(10, 10) }, referralNumber: getRandomString(10, 10), referralDate: new Date().toISOString(), referralCorrelationId: getRandomGuid(), referralSequenceNumber: getRandomInt(1, 100), eon: getRandomString(10, 10) } }; store.order.parentAccountNumber = getRandomString(6, 6); store.order.insuranceCoverage.coverageType = coverageType.Deductible; }); it('should call callHttpClient with correct parameters', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); store.applicationUser.savedSessionId = savedSessionId; // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(globalMethods.callHttpClient).toHaveBeenCalledWith({ method: endpoints.LoadSession.method, endpoint: endpoints.LoadSession.url, payload: { savedSessionId: mockDuplicate.savedSessionId, referralNumber: mockDuplicate.referralNumber, referralDate: mockDuplicate.referralDate, parentAccountNumber: store.order.parentAccountNumber, referralCorrelationId: mockDuplicate.correlationId } }); }); it('should return early when response data is null/undefined', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({ data: null })); const originalStreetAddress = store.order.customer.address.streetAddress; const originalLoadedFromDupeCheck = store.order.loadedFromDupeCheck; // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.customer.address.streetAddress).toBe(originalStreetAddress); expect(store.order.loadedFromDupeCheck).toBe(originalLoadedFromDupeCheck); }); it('should update customer address fields from response data', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.customer.address.streetAddress).toBe(mockResponse.data.customer.address.streetAddress); expect(store.order.customer.address.streetAddress2).toBe(mockResponse.data.customer.address.streetAddress2); expect(store.order.customer.address.city).toBe(mockResponse.data.customer.address.city); expect(store.order.customer.address.state).toBe(mockResponse.data.customer.address.state); expect(store.order.customer.address.zipCode).toBe(mockResponse.data.customer.address.zipCode); }); it('should update contact information from response data', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.customer.firstName).toBe(mockResponse.data.customer.firstName); expect(store.order.customer.lastName).toBe(mockResponse.data.customer.lastName); expect(store.order.customer.emailAddress).toBe(mockResponse.data.customer.emailAddress); expect(store.order.contactInfo.servicePhone).toBe(mockResponse.data.customer.servicePhone); expect(store.order.contactInfo.alternativePhone).toBe(mockResponse.data.customer.alternativePhone); expect(store.order.contactInfo.requestTextUpdates).toBe(mockResponse.data.customer.isSmsOptIn); }); it('should extract extension from homePhone correctly', async () => { // Arrange mockResponse.data.customer.homePhone = '12345678901234'; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.contactInfo.homePhone).toBe('1234567890'); expect(store.order.contactInfo.extension).toBe('1234'); }); it('should update vehicle information from response data', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.vehicle.year).toBe(mockResponse.data.vehicle.year); expect(store.order.vehicle.make).toBe(mockResponse.data.vehicle.make); expect(store.order.vehicle.model).toBe(mockResponse.data.vehicle.model); expect(store.order.vehicle.style).toBe(mockResponse.data.vehicle.style); }); it('should update insurance coverage when isPolicyLookupSuccessful is true and insuranceCoverage exists in response', async () => { // Arrange store.order.insuranceCoverage.coverageType = coverageType.Deductible; // Make isPolicyLookupSuccessful true globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.insuranceCoverage.coverageType).toBe(mockResponse.data.insuranceCoverage.coverageType); expect(store.order.insuranceCoverage.coverageStatus).toBe(mockResponse.data.insuranceCoverage.coverageStatus); expect(store.order.insuranceCoverage.claimNumber).toBe(mockResponse.data.insuranceCoverage.claimNumber); }); it('should update insurance coverage from payment.insuranceCoverage when main insuranceCoverage does not exist', async () => { // Arrange store.order.insuranceCoverage.coverageType = coverageType.Deductible; mockResponse.data.insuranceCoverage = null; mockResponse.data.payment = { insuranceCoverage: { isVerified: true, claimNumber: getRandomString(10, 10) } }; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.insuranceCoverage.coverageStatus).toBe(coverageStatuses.VERIFIED); expect(store.order.insuranceCoverage.claimNumber).toBe(mockResponse.data.payment.insuranceCoverage.claimNumber); }); it('should update vehicle registration license plate when policy vehicles exist and carId is present', async () => { // Arrange store.order.insuranceCoverage.coverageType = coverageType.Deductible; store.order.policy.vehicles = [ { id: 1, vin: mockResponse.data.vehicle.vin } ]; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.vehicle.registration.licensePlate).toBe(mockResponse.data.vehicle.licensePlateNumber); }); it('should call lookupVehicleByVin and update vehicle when vin matches policy vehicle', async () => { // Arrange const mockVehicleLookupResponse = { data: { carId: getRandomInt(1000, 9999), year: getRandomInt(2000, 2024).toString() } }; const policyVehicle = { id: getRandomInt(1, 100), vin: mockResponse.data.vehicle.vin, deductible: 100, repairWaived: false, endorsements: ['OEM Approved'], fleetNumber: getRandomString(1, 2), fleetUnitNumber: getRandomString(1, 2) }; store.order.insuranceCoverage.coverageType = coverageType.Deductible; store.order.policy.vehicles = [policyVehicle]; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); store.lookupVehicleByVin = jest.fn().mockReturnValue(Promise.resolve(mockVehicleLookupResponse)); store.updateVehicle = jest.fn(); store.updateVehicleCoverage = jest.fn(); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.lookupVehicleByVin).toHaveBeenCalledWith(mockResponse.data.vehicle.vin); expect(store.updateVehicle).toHaveBeenCalledWith({ ...mockVehicleLookupResponse.data, policyVehicleId: policyVehicle.id, vin: policyVehicle.vin, fleetNumber: policyVehicle.fleetNumber, fleetUnitNumber: policyVehicle.fleetUnitNumber }); expect(store.updateVehicleCoverage).toHaveBeenCalled(); }); it('should not call lookupVehicleByVin when policy vehicles array is empty', async () => { // Arrange store.order.insuranceCoverage.coverageType = coverageType.Deductible; store.order.policy.vehicles = []; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); store.lookupVehicleByVin = jest.fn(); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.lookupVehicleByVin).not.toHaveBeenCalled(); }); it('should not call lookupVehicleByVin when carId is not present', async () => { // Arrange store.order.insuranceCoverage.coverageType = coverageType.Deductible; store.order.policy.vehicles = [{ id: 1, vin: 'TEST123456789' }]; mockResponse.data.vehicle.carId = null; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); store.lookupVehicleByVin = jest.fn(); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.lookupVehicleByVin).not.toHaveBeenCalled(); }); it('should not call lookupVehicleByVin when vin is not present', async () => { // Arrange store.order.insuranceCoverage.coverageType = coverageType.Deductible; store.order.policy.vehicles = [{ id: 1, vin: 'TEST123456789' }]; mockResponse.data.vehicle.vin = null; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); store.lookupVehicleByVin = jest.fn(); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.lookupVehicleByVin).not.toHaveBeenCalled(); }); it('should not update insurance coverage when isPolicyLookupSuccessful is false', async () => { // Arrange store.order.insuranceCoverage.coverageType = coverageType.NONE; // Make isPolicyLookupSuccessful false const originalCoverageStatus = store.order.insuranceCoverage.coverageStatus; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.insuranceCoverage.coverageStatus).toBe(originalCoverageStatus); }); it('should update referral information from response data', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.referralNumber).toBe(mockResponse.data.referralNumber); expect(store.order.referralDate).toBe(mockResponse.data.referralDate); expect(store.order.referralCorrelationId).toBe(mockResponse.data.referralCorrelationId); expect(store.order.referralSequenceNumber).toBe(mockResponse.data.referralSequenceNumber); expect(store.order.eon).toBe(mockResponse.data.eon); }); it('should set loadedFromDupeCheck and loadedSessionClearedPreviousData flags', async () => { // Arrange globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.loadedFromDupeCheck).toBe(true); expect(store.order.loadedSessionClearedPreviousData).toBe(false); }); it('should handle API error gracefully', async () => { // Arrange const error = new Error('API Error'); globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error)); // Act & Assert await expect(store.loadSessionFromDuplicate(mockDuplicate)).rejects.toThrow('API Error'); }); it('should handle missing optional fields in response data', async () => { // Arrange mockResponse.data.customer.address.streetAddress2 = undefined; mockResponse.data.customer.alternativePhone = undefined; globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); // Act await store.loadSessionFromDuplicate(mockDuplicate); // Assert expect(store.order.customer.address.streetAddress2).toBeUndefined(); expect(store.order.contactInfo.alternativePhone).toBeUndefined(); }); }); describe('updateSupportingItems method', () => { it('updateSupportingItems removes Recycle Fee from supporting items in store', () => { // Arrange const partsData = [ { partNumber: 'RECYCLE FEE', partType: 'REPLACE FEE' } ]; // Act store.updateSupportingItems(partsData); // Assert expect(store.order.lineItems.supportingItems).not.toEqual( expect.arrayContaining([ expect.objectContaining({ partNumber: 'RECYCLE FEE', partType: 'REPLACE FEE' }) ]) ); }); it('updateSupportingItems removes Repair Supplies Fee from supporting items in store', () => { // Arrange const partsData = [ { partNumber: partNumberStrings.SUPPLIES_REPAIR, partType: 'REPAIR FEE' } ]; // Act store.updateSupportingItems(partsData); // Assert expect(store.order.lineItems.supportingItems).not.toEqual( expect.arrayContaining([ expect.objectContaining({ partNumber: partNumberStrings.SUPPLIES_REPAIR, partType: 'REPAIR FEE' }) ]) ); }); }); describe('updateGlassFees method', () => { it('updateGlassFees does not add Labor2 fee to feeItems', () => { // Arrange const feeData = [ { partNumber: 'LABOR2', partType: 'LABOR FEE' } ]; // Act store.updateGlassFees(feeData); // Assert expect(store.order.lineItems.feeItems).not.toEqual( expect.arrayContaining([ expect.objectContaining({ partNumber: 'LABOR2', partType: 'LABOR FEE' }) ]) ); }); }); });