diff --git a/src/store/index.js b/src/store/index.js index 04c475e2..9727b6be 100644 --- a/src/store/index.js +++ b/src/store/index.js @@ -1614,10 +1614,10 @@ export const useMainStore = defineStore({ order.contactInfo.alternativePhone = data?.customer?.alternativePhone; order.contactInfo.requestTextUpdates = data?.customer?.isSmsOptIn; - order.vehicle.year = data.vehicle.year; - order.vehicle.make = data.vehicle.make; - order.vehicle.model = data.vehicle.model; - order.vehicle.style = data.vehicle.style; + order.vehicle.year = data?.vehicle?.year; + order.vehicle.make = data?.vehicle?.make; + order.vehicle.model = data?.vehicle?.model; + order.vehicle.style = data?.vehicle?.style; if (this.isPolicyLookupSuccessful) { if (data.insuranceCoverage) { diff --git a/src/store/store.spec.js b/src/store/store.spec.js index 4a035c63..a2539b94 100644 --- a/src/store/store.spec.js +++ b/src/store/store.spec.js @@ -14,6 +14,7 @@ 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'; describe('Store', () => { let store; @@ -1071,28 +1072,29 @@ describe('Store', () => { experiments: getRandomString(6, 6) }; const vehicle = { - year: getRandomString(6, 6), - make: getRandomString(6, 6), - model: getRandomString(6, 6), - style: getRandomString(6, 6), - vin: getRandomString(6, 6), - carId: getRandomString(6, 6), - licensePlateNumber: getRandomString(6, 6) + 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 = { - firstName: getRandomString(6, 6), - lastName: getRandomString(6, 6), - emailAddress: getRandomString(6, 6), - phoneNumber: getRandomString(6, 6), - isSmsOptIn: getRandomString(6, 6), + const customer= { address: { - streetAddress: getRandomString(6, 6), - streetAddress2: getRandomString(6, 6), - city: getRandomString(6, 6), - state: getRandomString(6, 6), - zipCode: getRandomString(6, 6), - zipCodeCtu: getRandomString(6, 6) - } + 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: { @@ -1140,7 +1142,7 @@ describe('Store', () => { }; store.order.insuranceCoverage.coverageType = coverageType.Deductible; - store.policy.vehicles = [{ vin: vehicle.vin }]; + store.policy.vehicles = [{ vehicle }]; // Act await store.loadSession(duplicate); @@ -1150,7 +1152,7 @@ describe('Store', () => { expect(store.vehicle.make).toBe(vehicle.make); expect(store.vehicle.model).toBe(vehicle.model); expect(store.vehicle.style).toBe(vehicle.style); - expect(store.vehicle.vin).toBe(vehicle.vin); + // vin is not set directly by loadSession, it's set by updateVehicle after lookupVehicleByVin expect(store.vehicle.registration.licensePlate).toBe(vehicle.licensePlateNumber); }); it('sets expected customer data', async () => { @@ -2135,4 +2137,344 @@ describe('Store', () => { expect(result).toBe(expected); }); }); + + describe('loadSession method', () => { + let mockDuplicate; + let mockResponse; + + beforeEach(() => { + mockDuplicate = { + referralNumber: getRandomString(10, 10), + referralDate: new Date().toISOString(), + correlationId: getRandomGuid() + }; + + 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)); + + // Act + await store.loadSession(mockDuplicate); + + // Assert + expect(globalMethods.callHttpClient).toHaveBeenCalledWith({ + method: endpoints.LoadSession.method, + endpoint: endpoints.LoadSession.url, + payload: { + 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; + + // Act + await store.loadSession(mockDuplicate); + + // Assert + expect(store.order.customer.address.streetAddress).toBe(originalStreetAddress); + expect(store.order.loadedFromDupeCheck).toBe(null); + }); + + it('should update customer address fields from response data', async () => { + // Arrange + globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(mockResponse)); + + // Act + await store.loadSession(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.loadSession(mockDuplicate); + + // Assert + expect(store.order.contactInfo.firstName).toBe(mockResponse.data.customer.firstName); + expect(store.order.contactInfo.lastName).toBe(mockResponse.data.customer.lastName); + expect(store.order.contactInfo.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.loadSession(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.loadSession(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.loadSession(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.loadSession(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.loadSession(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'] + }; + + 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.loadSession(mockDuplicate); + + // Assert + expect(store.lookupVehicleByVin).toHaveBeenCalledWith(mockResponse.data.vehicle.vin); + expect(store.updateVehicle).toHaveBeenCalledWith({ + ...mockVehicleLookupResponse.data, + policyVehicleId: policyVehicle.id, + vin: policyVehicle.vin + }); + 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.loadSession(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.loadSession(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.loadSession(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.loadSession(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.loadSession(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.loadSession(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.loadSession(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.loadSession(mockDuplicate); + + // Assert + expect(store.order.customer.address.streetAddress2).toBeUndefined(); + expect(store.order.contactInfo.alternativePhone).toBeUndefined(); + }); + }); });