1964 lines
82 KiB
JavaScript
1964 lines
82 KiB
JavaScript
import { setActivePinia, createPinia } from 'pinia';
|
|
import { useMainStore } from '@/store/index.js';
|
|
import globalMethods from '@/global-methods.js';
|
|
import { getRandomString, getRandomGuid, getRandomInt, getRandomBoolean } from '@/helpers/data-generation.js';
|
|
import coverageStatuses from '@/constants/coverage-statuses.js';
|
|
import { endpoints } from '@/constants/endpoints';
|
|
import { AppointmentTypeStrings } from '@/constants/schedule-constants';
|
|
|
|
describe('Store', () => {
|
|
let store;
|
|
|
|
beforeEach(() => {
|
|
const pinia = createPinia();
|
|
setActivePinia(pinia);
|
|
store = useMainStore();
|
|
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 providedVehicle = {
|
|
carId,
|
|
category,
|
|
year,
|
|
make,
|
|
model,
|
|
style,
|
|
imageUrl,
|
|
imageVifNumber,
|
|
imageVifColor: imageColor
|
|
};
|
|
|
|
const expectedVehicle = {
|
|
carId,
|
|
category,
|
|
year,
|
|
make,
|
|
model,
|
|
style,
|
|
imageUrl,
|
|
imageVifNumber,
|
|
imageColor
|
|
};
|
|
|
|
// Act
|
|
store.updateVehicle(providedVehicle);
|
|
|
|
// Assert
|
|
expect(store.order.vehicle).toMatchObject(expectedVehicle);
|
|
});
|
|
|
|
it('UpdateVehicle should set policy values appropriately with repair waived', () => {
|
|
// Arrange
|
|
const noCoverage = getRandomBoolean();
|
|
const deductible = getRandomInt(1, 500);
|
|
const endorsements = [getRandomString(10, 20)];
|
|
const vehicle = {
|
|
noCoverage,
|
|
deductible,
|
|
repairWaived: true,
|
|
endorsements
|
|
};
|
|
|
|
const expectedPolicy = {
|
|
noCoverage,
|
|
deductible: {
|
|
replace: deductible,
|
|
repair: 0
|
|
},
|
|
endorsements
|
|
};
|
|
|
|
// Act
|
|
store.updateVehicle(vehicle);
|
|
|
|
// 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 vehicle = {
|
|
noCoverage,
|
|
deductible,
|
|
repairWaived: false,
|
|
endorsements
|
|
};
|
|
|
|
const expectedPolicy = {
|
|
noCoverage,
|
|
deductible: {
|
|
replace: deductible,
|
|
repair: deductible
|
|
},
|
|
endorsements
|
|
};
|
|
|
|
// Act
|
|
store.updateVehicle(vehicle);
|
|
|
|
// Assert
|
|
expect(store.order.policy).toMatchObject(expectedPolicy);
|
|
});
|
|
|
|
it.each([
|
|
[true, coverageStatuses.NO_COMP],
|
|
[false, coverageStatuses.PENDING]
|
|
])(
|
|
'UpdateVehicle should set coverageStatus appropriately based on noCoverage value',
|
|
(expectedNoCoverage, expectedCoverageStatus) => {
|
|
// Arrange
|
|
const vehicle = {
|
|
noCoverage: expectedNoCoverage
|
|
};
|
|
|
|
// Act
|
|
store.updateVehicle(vehicle);
|
|
|
|
// Assert
|
|
expect(store.order.policy.noCoverage).toBe(expectedNoCoverage);
|
|
expect(store.order.payment.insuranceCoverage.coverageStatus).toBe(expectedCoverageStatus);
|
|
}
|
|
);
|
|
|
|
// 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.policy.noCoverage = true;
|
|
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
|
|
|
|
// Act
|
|
await store.registerClaim();
|
|
|
|
// Asserts
|
|
expect(globalMethods.callHttpClient).toHaveBeenCalled();
|
|
expect(store.payment.insuranceCoverage.isVerified).toBe(true);
|
|
expect(store.payment.insuranceCoverage.coverageStatus).toBe(coverageStatuses.NO_COMP);
|
|
expect(store.payment.insuranceCoverage.claimNumber).toBe(null);
|
|
});
|
|
|
|
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.policy.noCoverage = false;
|
|
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
|
|
|
|
// Act
|
|
await store.registerClaim();
|
|
|
|
// Asserts
|
|
expect(globalMethods.callHttpClient).toHaveBeenCalled();
|
|
expect(store.payment.insuranceCoverage.isVerified).toBe(true);
|
|
expect(store.payment.insuranceCoverage.coverageStatus).toBe(coverageStatuses.VERIFIED);
|
|
expect(store.payment.insuranceCoverage.claimNumber).toBe(response.data.claimNumber);
|
|
});
|
|
|
|
it('Call to client returns exception, resulting in object with error property being returned', async () => {
|
|
// Arrange
|
|
expect.assertions(5);
|
|
const error = 'register claim error';
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error));
|
|
|
|
// Act
|
|
await store.registerClaim().catch((e) => {
|
|
expect(e).toEqual(error);
|
|
});
|
|
|
|
// Asserts
|
|
expect(globalMethods.callHttpClient).toHaveBeenCalled();
|
|
expect(store.payment.insuranceCoverage.isVerified).toBe(false);
|
|
expect(store.payment.insuranceCoverage.coverageStatus).toBe(coverageStatuses.PENDING);
|
|
expect(store.payment.insuranceCoverage.claimNumber).toBe(null);
|
|
});
|
|
});
|
|
|
|
describe('updateContactInfo method', () => {
|
|
it('UpdateContactInfo updates contact info in store', () => {
|
|
// Arrange
|
|
const firstName = getRandomString(4, 10);
|
|
const lastName = getRandomString(5, 15);
|
|
const emailAddress = false;
|
|
const phoneNumber = getRandomInt(1000000000, 9999999999);
|
|
const requestTextUpdates = getRandomBoolean();
|
|
const notesForTechnician = getRandomString(50, 150);
|
|
|
|
// Act
|
|
store.updateContactInfo({ firstName,
|
|
lastName,
|
|
emailAddress,
|
|
phoneNumber,
|
|
requestTextUpdates,
|
|
notesForTechnician });
|
|
|
|
// Assert
|
|
expect(store.contactInfo.firstName).toEqual(firstName);
|
|
expect(store.contactInfo.lastName).toEqual(lastName);
|
|
expect(store.contactInfo.emailAddress).toEqual(emailAddress);
|
|
expect(store.contactInfo.phoneNumber).toEqual(phoneNumber);
|
|
expect(store.contactInfo.requestTextUpdates).toEqual(requestTextUpdates);
|
|
expect(store.contactInfo.notesForTechnician).toEqual(notesForTechnician);
|
|
});
|
|
it('All null values => contact info set in store to all nulls', () => {
|
|
// Act
|
|
store.updateContactInfo({});
|
|
|
|
// Assert
|
|
expect(store.contactInfo.firstName).toEqual('');
|
|
expect(store.contactInfo.lastName).toEqual('');
|
|
expect(store.contactInfo.emailAddress).toEqual('');
|
|
expect(store.contactInfo.phoneNumber).toEqual('');
|
|
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 policyLookupSuccessful = getRandomString(6, 6);
|
|
const noCoverage = getRandomString(6, 6);
|
|
const originalDeductible = getRandomString(6, 6);
|
|
const currentDeductible = getRandomString(6, 6);
|
|
store.order.originalDeductible = originalDeductible;
|
|
store.order.currentDeductible = currentDeductible;
|
|
store.order.customer.firstName = customerFirstName;
|
|
store.order.customer.lastName = customerLastName;
|
|
store.order.customer.emailAddress = customerEmail;
|
|
store.order.customer.phoneNumber = customerPhoneNumber;
|
|
store.order.customer.address.state = customerState;
|
|
store.order.policy.policyNumber = policyNumber;
|
|
store.order.policy.policyZipCode = policyZipCode;
|
|
store.order.policy.policyLookupSuccessful = policyLookupSuccessful;
|
|
store.order.policy.noCoverage = noCoverage;
|
|
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,
|
|
noCoverage,
|
|
policyLookupSuccessful,
|
|
originalDeductible,
|
|
currentDeductible
|
|
})
|
|
})
|
|
}));
|
|
});
|
|
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 contactPhoneNumber = getRandomString(6, 6);
|
|
const requestTextUpdates = getRandomBoolean();
|
|
store.order.contactInfo.firstName = contactFirstName;
|
|
store.order.contactInfo.lastName = contactLastName;
|
|
store.order.contactInfo.emailAddress = contactEmail;
|
|
store.order.contactInfo.phoneNumber = contactPhoneNumber;
|
|
store.order.contactInfo.requestTextUpdates = requestTextUpdates;
|
|
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,
|
|
phoneNumber: contactPhoneNumber,
|
|
optInSms: requestTextUpdates
|
|
})
|
|
})
|
|
}));
|
|
});
|
|
it('calls api with expected lineItems', async () => {
|
|
// Arrange
|
|
const glassParts = getRandomString(6, 6);
|
|
const supportingItems = getRandomString(6, 6);
|
|
const vaps = getRandomString(6, 6);
|
|
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.each([
|
|
[coverageStatuses.PENDING],
|
|
[coverageStatuses.NO_COMP],
|
|
[coverageStatuses.VERIFIED]
|
|
])('calls api with expected payment', async (coverageStatus) => {
|
|
// Arrange
|
|
const parentAccountNumber = getRandomString(6, 6);
|
|
const isVerified = getRandomBoolean();
|
|
store.issConfig.parentAccountNumber = parentAccountNumber;
|
|
store.order.payment.insuranceCoverage.isVerified = isVerified;
|
|
store.order.payment.insuranceCoverage.coverageStatus = coverageStatus;
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
|
|
|
|
// Act
|
|
await store.saveSession();
|
|
|
|
// Assert
|
|
expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
|
|
payload: expect.objectContaining({
|
|
payment: expect.objectContaining({
|
|
InsuranceCoverage: expect.objectContaining({
|
|
isVerified,
|
|
coverageStatus
|
|
}),
|
|
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('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('loadSession method', () => {
|
|
describe('successful method call', () => {
|
|
const applicationUser = {
|
|
crmCustomerId: getRandomString(6, 6),
|
|
experiments: getRandomString(6, 6),
|
|
lastPage: getRandomString(6, 6),
|
|
pageData: getRandomString(6, 6),
|
|
savedSessionId: getRandomString(6, 6),
|
|
hasSentSaveQuoteEmail: getRandomBoolean()
|
|
};
|
|
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),
|
|
category: getRandomString(6, 6),
|
|
registration: {
|
|
licensePlateNumber: getRandomString(6, 6)
|
|
},
|
|
imageUrl: getRandomString(6, 6),
|
|
imageVifNumber: getRandomString(6, 6),
|
|
imageVifColor: getRandomString(6, 6)
|
|
};
|
|
const damage = {
|
|
numberOfChips: getRandomString(6, 6),
|
|
isRepair: getRandomBoolean(),
|
|
glassToReplace: getRandomString(6, 6),
|
|
capabilityQuestionAnswers: getRandomString(6, 6),
|
|
moldingQuestionAnswers: getRandomString(6, 6),
|
|
partQuestionAnswers: getRandomString(6, 6),
|
|
dateOfLoss: getRandomString(6, 6),
|
|
damageCause: getRandomString(6, 6),
|
|
damageState: getRandomString(6, 6),
|
|
damageCity: getRandomString(6, 6),
|
|
isDamageGlassOnly: getRandomBoolean()
|
|
};
|
|
const policy = {
|
|
policyNumber: getRandomString(6, 6),
|
|
policyZipCode: getRandomBoolean(),
|
|
noCoverage: getRandomString(6, 6),
|
|
policyLookupSuccessful: getRandomBoolean(),
|
|
policyHolder: {
|
|
policyFirstName: getRandomString(6, 6),
|
|
policyLastName: getRandomString(6, 6),
|
|
policyPhoneNumber: getRandomString(6, 6),
|
|
policyState: getRandomString(6, 6)
|
|
},
|
|
originalDeductible: getRandomString(6, 6),
|
|
currentDeductible: getRandomString(6, 6)
|
|
};
|
|
const customer = {
|
|
firstName: getRandomString(6, 6),
|
|
lastName: getRandomString(6, 6),
|
|
emailAddress: getRandomString(6, 6),
|
|
phoneNumber: getRandomString(6, 6),
|
|
isSmsOptIn: getRandomString(6, 6),
|
|
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)
|
|
}
|
|
};
|
|
const provider = {
|
|
providerNumber: getRandomString(6, 6),
|
|
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)
|
|
}
|
|
};
|
|
const serviceLocation = {
|
|
streetAddress: getRandomString(6, 6),
|
|
streetAddress2: getRandomString(6, 6),
|
|
city: getRandomString(6, 6),
|
|
state: getRandomString(6, 6),
|
|
zipCode: getRandomString(6, 6),
|
|
zipCodeCtu: getRandomString(6, 6),
|
|
appointmentType: getRandomString(6, 6),
|
|
isVehicleProtected: getRandomBoolean(),
|
|
provider,
|
|
techNotes: getRandomString(6, 6),
|
|
phoneNumber: getRandomString(6, 6),
|
|
isSmsOptIn: getRandomBoolean()
|
|
};
|
|
const lineItems = {
|
|
glassParts: getRandomString(6, 6),
|
|
supportingItems: getRandomString(6, 6),
|
|
vaps: getRandomString(6, 6),
|
|
serverData: getRandomString(6, 6)
|
|
};
|
|
const payment = {
|
|
insuranceCoverage: {
|
|
isVerified: getRandomBoolean(),
|
|
coverageStatus: getRandomString(6, 6),
|
|
claimNumber: getRandomString(6, 6)
|
|
},
|
|
parentAccountNumber: getRandomString(6, 6)
|
|
};
|
|
const schedule = {
|
|
date: getRandomString(6, 6),
|
|
startTime: getRandomString(6, 6),
|
|
endTime: getRandomString(6, 6),
|
|
routeCode: getRandomString(6, 6),
|
|
jobMaxMinutes: getRandomString(6, 6),
|
|
jobMinMinutes: getRandomString(6, 6)
|
|
};
|
|
const fullApiResponse = {
|
|
data: {
|
|
applicationUser,
|
|
order: {
|
|
vehicle,
|
|
damage,
|
|
policy,
|
|
customer,
|
|
serviceLocation,
|
|
lineItems,
|
|
payment,
|
|
schedule,
|
|
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({}));
|
|
|
|
// Act
|
|
store.loadSession();
|
|
|
|
// Asserts
|
|
expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
|
|
method: endpoints.LoadSession.method,
|
|
endpoint: endpoints.LoadSession.url
|
|
}));
|
|
});
|
|
it('Returns expected response object', async () => {
|
|
// Arrange
|
|
const response = { data: {ReferralNumber: getRandomString(6, 6)} };
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
|
|
|
|
// Act
|
|
const result = store.loadSession();
|
|
|
|
// Asserts
|
|
await expect(result).resolves.toBe(response.data);
|
|
});
|
|
it('sets expected application user data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
const originalSavedSessionTimeout = store.applicationUser.savedSessionTimeout;
|
|
const originalEventBus = store.applicationUser.eventBus;
|
|
const originalSaveSessionPromise = store.applicationUser.saveSessionPromise;
|
|
const originalTriggeredSiteEntry = store.applicationUser.triggeredSiteEntry;
|
|
const originalDuplicateOrders = store.applicationUser.duplicateOrders;
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// Asserts
|
|
expect(store.applicationUser.experiments).toEqual(applicationUser.experiments);
|
|
expect(store.applicationUser.pageData).toBe(applicationUser.pageData);
|
|
expect(store.applicationUser.savedSessionId).toBe(applicationUser.savedSessionId);
|
|
expect(store.applicationUser.crmCustomerId).toBe(applicationUser.crmCustomerId);
|
|
expect(store.applicationUser.lastPageVisited).toBe(applicationUser.lastPage);
|
|
expect(store.applicationUser.hasSentSaveQuoteEmail).toBe(applicationUser.hasSentSaveQuoteEmail);
|
|
expect(store.applicationUser.eventBus).toEqual(originalEventBus);
|
|
expect(store.applicationUser.savedSessionTimeout).toBe(originalSavedSessionTimeout);
|
|
expect(store.applicationUser.saveSessionPromise).toBe(originalSaveSessionPromise);
|
|
expect(store.applicationUser.triggeredSiteEntry).toBe(originalTriggeredSiteEntry);
|
|
expect(store.applicationUser.duplicateOrders).toEqual(originalDuplicateOrders);
|
|
});
|
|
it('sets expected vehicle data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
const originalRegistrationAddress = store.vehicle.registration.address;
|
|
const originalRegistrationCity = store.vehicle.registration.city;
|
|
const originalRegistrationState = store.vehicle.registration.state;
|
|
const originalRegistrationZipCode = store.vehicle.registration.zipCode;
|
|
const originalRegistrationFirstName = store.vehicle.registration.firstName;
|
|
const originalRegistrationLastName = store.vehicle.registration.lastName;
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// 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);
|
|
expect(store.vehicle.carId).toBe(vehicle.carId);
|
|
expect(store.vehicle.category).toBe(vehicle.category);
|
|
expect(store.vehicle.vin).toBe(vehicle.vin);
|
|
expect(store.vehicle.imageUrl).toBe(vehicle.imageUrl);
|
|
expect(store.vehicle.imageVifNumber).toBe(vehicle.imageVifNumber);
|
|
expect(store.vehicle.imageColor).toBe(vehicle.imageVifColor);
|
|
expect(store.vehicle.registration.licensePlate).toBe(vehicle.registration.licensePlateNumber);
|
|
expect(store.vehicle.registration.address).toBe(originalRegistrationAddress);
|
|
expect(store.vehicle.registration.city).toBe(originalRegistrationCity);
|
|
expect(store.vehicle.registration.state).toBe(originalRegistrationState);
|
|
expect(store.vehicle.registration.zipCode).toBe(originalRegistrationZipCode);
|
|
expect(store.vehicle.registration.firstName).toBe(originalRegistrationFirstName);
|
|
expect(store.vehicle.registration.lastName).toBe(originalRegistrationLastName);
|
|
});
|
|
it('sets expected damage data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// Asserts
|
|
expect(store.damage.isRepair).toBe(damage.isRepair);
|
|
expect(store.damage.numberOfChips).toBe(damage.numberOfChips);
|
|
expect(store.damage.glassToReplace).toBe(damage.glassToReplace);
|
|
expect(store.damage.partQuestionAnswers).toBe(damage.partQuestionAnswers);
|
|
expect(store.damage.moldingQuestionAnswers).toBe(damage.moldingQuestionAnswers);
|
|
expect(store.damage.capabilityQuestionAnswers).toBe(damage.capabilityQuestionAnswers);
|
|
});
|
|
it('sets expected policy data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
const originalRepairDeductible = store.policy.deductible.repair;
|
|
const originalReplaceDeductible = store.policy.deductible.replace;
|
|
const originalVehicles = store.policy.vehicles;
|
|
const originalEndorsementQuestionAnswers = store.policy.endorsementQuestionAnswers;
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// Asserts
|
|
expect(store.policy.policyNumber).toBe(policy.policyNumber);
|
|
expect(store.policy.policyZipCode).toBe(policy.policyZipCode);
|
|
expect(store.policy.dateOfLoss).toBe(damage.dateOfLoss);
|
|
expect(store.policy.damageCause).toBe(damage.damageCause);
|
|
expect(store.policy.damageState).toBe(damage.damageState);
|
|
expect(store.policy.damageCity).toBe(damage.damageCity);
|
|
expect(store.policy.isDamageGlassOnly).toBe(damage.isDamageGlassOnly);
|
|
expect(store.policy.policyLookupSuccessful).toBe(policy.policyLookupSuccessful);
|
|
expect(store.policy.noCoverage).toBe(policy.noCoverage);
|
|
expect(store.policy.deductible.repair).toBe(originalRepairDeductible);
|
|
expect(store.policy.deductible.replace).toBe(originalReplaceDeductible);
|
|
expect(store.policy.vehicles).toEqual(originalVehicles);
|
|
expect(store.policy.endorsementQuestionAnswers).toBe(originalEndorsementQuestionAnswers);
|
|
});
|
|
it('sets expected customer data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// 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.customer.firstName).toBe(policy.policyHolder.policyFirstName);
|
|
expect(store.order.customer.lastName).toBe(policy.policyHolder.policyLastName);
|
|
expect(store.order.customer.emailAddress).toBe(customer.emailAddress);
|
|
expect(store.order.customer.phoneNumber).toBe(policy.policyHolder.policyPhoneNumber);
|
|
});
|
|
it('sets expected serviceLocation data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// Asserts
|
|
expect(store.order.serviceLocation.address).toBe(serviceLocation.streetAddress);
|
|
expect(store.order.serviceLocation.address2).toBe(serviceLocation.streetAddress2);
|
|
expect(store.order.serviceLocation.city).toBe(serviceLocation.city);
|
|
expect(store.order.serviceLocation.state).toBe(serviceLocation.state);
|
|
expect(store.order.serviceLocation.zipCode).toBe(serviceLocation.zipCode);
|
|
expect(store.order.serviceLocation.zipCodeCtu).toBe(serviceLocation.zipCodeCtu);
|
|
expect(store.order.serviceLocation.appointmentType).toBe(serviceLocation.appointmentType);
|
|
expect(store.order.serviceLocation.isVehicleProtected).toBe(serviceLocation.isVehicleProtected);
|
|
expect(store.order.serviceLocation.provider.providerNumber).toBe(provider.providerNumber);
|
|
expect(store.order.serviceLocation.provider.address.streetAddress).toBe(provider.address.streetAddress);
|
|
expect(store.order.serviceLocation.provider.address.city).toBe(provider.address.city);
|
|
expect(store.order.serviceLocation.provider.address.state).toBe(provider.address.state);
|
|
expect(store.order.serviceLocation.provider.address.zipCode).toBe(provider.address.zipCode);
|
|
expect(store.order.serviceLocation.provider.address.zipCodeCtu).toBe(provider.address.zipCodeCtu);
|
|
});
|
|
it('sets expected lineItems data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
const originalOtherParts = store.order.lineItems.otherParts;
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// Asserts
|
|
expect(store.order.lineItems.glassParts).toBe(lineItems.glassParts);
|
|
expect(store.order.lineItems.otherParts).toBe(originalOtherParts);
|
|
expect(store.order.lineItems.supportingItems).toBe(lineItems.supportingItems);
|
|
expect(store.order.lineItems.vaps).toBe(lineItems.vaps);
|
|
});
|
|
it('sets expected payment data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// Asserts
|
|
expect(store.order.payment.insuranceCoverage.isVerified).toBe(payment.insuranceCoverage.isVerified);
|
|
expect(store.order.payment.insuranceCoverage.coverageStatus).toBe(payment.insuranceCoverage.coverageStatus);
|
|
expect(store.order.payment.parentAccountNumber).toBe(payment.parentAccountNumber);
|
|
expect(store.issConfig.parentAccountNumber).toBe(payment.parentAccountNumber);
|
|
expect(store.order.payment.insuranceCoverage.claimNumber).toBe(payment.insuranceCoverage.claimNumber);
|
|
});
|
|
it('sets expected contactInfo data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// Asserts
|
|
expect(store.order.contactInfo.firstName).toBe(customer.firstName);
|
|
expect(store.order.contactInfo.lastName).toBe(customer.lastName);
|
|
expect(store.order.contactInfo.emailAddress).toBe(customer.emailAddress);
|
|
expect(store.order.contactInfo.phoneNumber).toBe(customer.phoneNumber);
|
|
expect(store.order.contactInfo.requestTextUpdates).toBe(customer.isSmsOptIn);
|
|
expect(store.order.contactInfo.notesForTechnician).toBe(serviceLocation.techNotes);
|
|
});
|
|
it('sets expected schedule data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// Asserts
|
|
expect(store.order.schedule.date).toBe(schedule.date);
|
|
expect(store.order.schedule.startTime).toBe(schedule.startTime);
|
|
expect(store.order.schedule.endTime).toBe(schedule.endTime);
|
|
expect(store.order.schedule.routeCode).toBe(schedule.routeCode);
|
|
expect(store.order.schedule.jobMaxMinutes).toBe(schedule.jobMaxMinutes);
|
|
});
|
|
it('sets expected remaining order data', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
|
|
const originalWorkOrderNumber = store.order.workOrderNumber;
|
|
|
|
// Act
|
|
await store.loadSession();
|
|
|
|
// Asserts
|
|
expect(store.order.referralNumber).toBe(fullApiResponse.data.order.referralNumber);
|
|
expect(store.order.referralDate).toBe(fullApiResponse.data.order.referralDate);
|
|
expect(store.order.referralCorrelationId).toBe(fullApiResponse.data.order.referralCorrelationId);
|
|
expect(store.order.referralSequenceNumber).toBe(fullApiResponse.data.order.referralSequenceNumber);
|
|
expect(store.order.eon).toBe(fullApiResponse.data.order.eon);
|
|
expect(store.order.workOrderNumber).toBe(originalWorkOrderNumber);
|
|
expect(store.order.originalDeductible).toBe(policy.originalDeductible);
|
|
expect(store.order.currentDeductible).toBe(policy.currentDeductible);
|
|
});
|
|
});
|
|
it('api call throws exception', async () => {
|
|
expect.assertions(2);
|
|
const error = 'load session error';
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error));
|
|
|
|
// Act
|
|
await store.loadSession().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
|
|
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('Returns expected response object', async () => {
|
|
// Arrange
|
|
const response = { ReferralNumber: getRandomString(6, 6) };
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
|
|
|
|
// Act
|
|
const result = store.getCoveragePolicyInfo();
|
|
|
|
// Asserts
|
|
await expect(result).resolves.toBe(response);
|
|
});
|
|
it('calls api with expected data', async () => {
|
|
// Arrange
|
|
const accountNumber = 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.accountNumber = accountNumber;
|
|
store.order.policy.policyNumber = policyNumber;
|
|
store.order.policy.dateOfLoss = dateOfLoss;
|
|
store.order.policy.policyZipCode = zipCode;
|
|
store.order.referralCorrelationId = referralCorrelationId;
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
|
|
|
|
// Act
|
|
await store.getCoveragePolicyInfo();
|
|
|
|
// Asserts
|
|
expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
|
|
payload: expect.objectContaining({
|
|
accountNumber,
|
|
policyNumber,
|
|
dateOfLoss,
|
|
zipCode,
|
|
referralCorrelationId
|
|
})
|
|
}));
|
|
});
|
|
it('null response by api => policyLookupSuccessful false', async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(null));
|
|
|
|
// Act
|
|
await store.getCoveragePolicyInfo();
|
|
|
|
// Asserts
|
|
expect(store.order.policy.policyLookupSuccessful).toBe(false);
|
|
});
|
|
it('no policies returned by api => policyLookupSuccessful false', async () => {
|
|
// Arrange
|
|
const responseNoPolicies = {
|
|
data: {
|
|
policies: []
|
|
}
|
|
};
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies));
|
|
|
|
// Act
|
|
await store.getCoveragePolicyInfo();
|
|
|
|
// Asserts
|
|
expect(store.order.policy.policyLookupSuccessful).toBe(false);
|
|
});
|
|
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)
|
|
};
|
|
const vehicles = [
|
|
{ name: getRandomString(6, 6) },
|
|
{ name: getRandomString(6, 6) }
|
|
];
|
|
const policy1 = {
|
|
insureds: [insured],
|
|
vehicles
|
|
};
|
|
const responseNoPolicies = {
|
|
data: {
|
|
policies: [policy1, {}]
|
|
}
|
|
};
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies));
|
|
|
|
// Act
|
|
await store.getCoveragePolicyInfo();
|
|
|
|
// Asserts
|
|
expect(store.order.policy.policyLookupSuccessful).toBe(true);
|
|
|
|
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.serviceLocation.zipCode).toBe(insured.zipCode);
|
|
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) }]
|
|
}]
|
|
}
|
|
};
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies));
|
|
|
|
// Act
|
|
await store.getCoveragePolicyInfo();
|
|
|
|
// Asserts
|
|
expect(store.order.policy.policyLookupSuccessful).toBe(true);
|
|
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: [] }]
|
|
}
|
|
};
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(responseNoPolicies));
|
|
|
|
// Act
|
|
await store.getCoveragePolicyInfo();
|
|
|
|
// Asserts
|
|
expect(store.order.policy.policyLookupSuccessful).toBe(true);
|
|
expect(store.order.policy.vehicles).toEqual([]);
|
|
});
|
|
});
|
|
it('api call throws exception => policyLookupSuccessful false', async () => {
|
|
expect.assertions(3);
|
|
const error = 'get coverage policy info error';
|
|
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.policy.policyLookupSuccessful).toBe(false);
|
|
});
|
|
});
|
|
|
|
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 []', async () => {
|
|
// Arrange
|
|
expect.assertions(3);
|
|
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('updatePolicyITACFlag method', () => {
|
|
it('updatePolicyITACFlag updates policy.isITAC flag in store', () => {
|
|
// Arrange
|
|
const moqIsITAC = getRandomBoolean();
|
|
|
|
// Act
|
|
store.updatePolicyITACFlag(moqIsITAC);
|
|
|
|
// Assert
|
|
expect(store.order.policy.isITAC).toEqual(moqIsITAC);
|
|
});
|
|
});
|
|
|
|
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 accountNumber = getRandomString(6, 6);
|
|
const endorsements = [];
|
|
const manualGlassNames = [location];
|
|
const policyState = getRandomString(2, 2);
|
|
const status = getRandomString(6, 8);
|
|
const currentDeductible = getRandomInt(0, 5000);
|
|
const noCoverage = getRandomBoolean();
|
|
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);
|
|
const isItac = getRandomBoolean();
|
|
|
|
store.order.referralCorrelationId = referralCorrelationId;
|
|
store.issConfig.parentAccountNumber = accountNumber;
|
|
store.order.currentDeductible = currentDeductible;
|
|
store.order.policy.noCoverage = noCoverage;
|
|
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.updatePolicyITACFlag(isItac);
|
|
|
|
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,
|
|
endorsements,
|
|
manualGlassNames,
|
|
policyState,
|
|
status,
|
|
currentDeductible,
|
|
noCoverage,
|
|
isRepair,
|
|
policyNumber,
|
|
insuredFirstName,
|
|
insuredLastName,
|
|
insuredZipCode,
|
|
policyVehicleId,
|
|
vehicleVin,
|
|
policyData,
|
|
isItac
|
|
})
|
|
}));
|
|
});
|
|
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 accountNumber = getRandomString(6, 6);
|
|
const manualGlassNames = [location];
|
|
const policyState = getRandomString(2, 2);
|
|
const status = getRandomString(6, 8);
|
|
const currentDeductible = getRandomInt(0, 5000);
|
|
const noCoverage = getRandomBoolean();
|
|
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);
|
|
const isItac = false;
|
|
|
|
store.order.referralCorrelationId = referralCorrelationId;
|
|
store.issConfig.parentAccountNumber = accountNumber;
|
|
store.order.currentDeductible = currentDeductible;
|
|
store.order.policy.noCoverage = noCoverage;
|
|
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;
|
|
|
|
store.updatePolicyITACFlag(isItac);
|
|
|
|
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,
|
|
endorsements: expected,
|
|
manualGlassNames,
|
|
policyState,
|
|
status,
|
|
currentDeductible,
|
|
noCoverage,
|
|
isRepair,
|
|
policyNumber,
|
|
insuredFirstName,
|
|
insuredLastName,
|
|
insuredZipCode,
|
|
policyVehicleId,
|
|
vehicleVin,
|
|
policyData,
|
|
isItac
|
|
})
|
|
}));
|
|
});
|
|
});
|
|
describe('unsuccessful api call', () => {
|
|
it('api call throws exception', async () => {
|
|
// Arrange
|
|
expect.assertions(2);
|
|
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
|
|
const finalDeductible = getRandomInt(0, 5000);
|
|
|
|
// Act
|
|
store.updateDeductible(finalDeductible);
|
|
|
|
// Assert
|
|
expect(store.order.currentDeductible).toEqual(finalDeductible);
|
|
});
|
|
it('null final deductible => currentDeductible in store set to null', () => {
|
|
// Arrange
|
|
const finalDeductible = null;
|
|
|
|
// Act
|
|
store.updateDeductible(finalDeductible);
|
|
|
|
// Assert
|
|
expect(store.order.currentDeductible).toEqual(finalDeductible);
|
|
});
|
|
});
|
|
});
|