466 lines
16 KiB
JavaScript
466 lines
16 KiB
JavaScript
import { useMainStore } from '@/store';
|
|
import { createApp } from 'vue';
|
|
import { setActivePinia, createPinia } from "pinia";
|
|
import globalMethods from "@/global-methods";
|
|
import App from '@/App';
|
|
import { getRandomString, getRandomGuid, getRandomInt, getRandomBoolean } from '@/helpers/data-generation';
|
|
import { coverageStatuses } from "@/constants/coverage-statuses.js";
|
|
|
|
describe("Store", () => {
|
|
|
|
let store;
|
|
|
|
const vueApp = createApp(App);
|
|
|
|
beforeEach(() => {
|
|
const pinia = createPinia();
|
|
setActivePinia(pinia);
|
|
vueApp.use(pinia);
|
|
store = useMainStore();
|
|
store.applicationUser.eventBus = [];
|
|
jest.resetAllMocks();
|
|
});
|
|
|
|
|
|
it("Should Store Vehicle Year", () => {
|
|
let 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);
|
|
let event = {
|
|
category: category,
|
|
subCategory: subCategory,
|
|
eventValue: {
|
|
isDismissible: isDismissible,
|
|
messageCopy: copy,
|
|
messageHeadline: headline,
|
|
type: 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);
|
|
let event = {
|
|
category: category,
|
|
subCategory: subCategory,
|
|
eventValue: {
|
|
isDismissible: isDismissible,
|
|
messageCopy: copy,
|
|
messageHeadline: headline,
|
|
type: 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);
|
|
let event = {
|
|
category: category,
|
|
subCategory: subCategory,
|
|
eventValue: {
|
|
isDismissible: isDismissible,
|
|
messageCopy: copy,
|
|
messageHeadline: headline,
|
|
type: 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: carId,
|
|
category: category,
|
|
year: year,
|
|
make: make,
|
|
model: model,
|
|
style: style,
|
|
imageUrl: imageUrl,
|
|
imageVifNumber: imageVifNumber,
|
|
imageVifColor: imageColor
|
|
};
|
|
|
|
const expectedVehicle = {
|
|
carId: carId,
|
|
category: category,
|
|
year: year,
|
|
make: make,
|
|
model: model,
|
|
style: style,
|
|
imageUrl: imageUrl,
|
|
imageVifNumber: imageVifNumber,
|
|
imageColor: imageColor
|
|
}
|
|
|
|
// Act
|
|
store.updateVehicle(providedVehicle);
|
|
|
|
// Assert
|
|
expect(store.order.vehicle).toMatchObject(expectedVehicle);
|
|
});
|
|
|
|
it("UpdateVehicle should set policy values appropriately with repair waived", () => {
|
|
// Arrange
|
|
const noCompensation = getRandomBoolean();
|
|
const deductible = getRandomInt(1,500);
|
|
const vehicle = {
|
|
noCoverage: noCompensation,
|
|
deductible: deductible,
|
|
repairWaived: true
|
|
};
|
|
|
|
const expectedPolicy = {
|
|
noCompensation: noCompensation,
|
|
deductible: {
|
|
replace: deductible,
|
|
repair: 0
|
|
}
|
|
};
|
|
|
|
// Act
|
|
store.updateVehicle(vehicle);
|
|
|
|
// Assert
|
|
expect(store.order.policy).toMatchObject(expectedPolicy);
|
|
});
|
|
|
|
it("UpdateVehicle should set policy values appropriately with repair not waived", () => {
|
|
// Arrange
|
|
const noCompensation = getRandomBoolean();
|
|
const deductible = getRandomInt(1,500);
|
|
const vehicle = {
|
|
noCoverage: noCompensation,
|
|
deductible: deductible,
|
|
repairWaived: false
|
|
};
|
|
|
|
const expectedPolicy = {
|
|
noCompensation: noCompensation,
|
|
deductible: {
|
|
replace: deductible,
|
|
repair: deductible
|
|
}
|
|
};
|
|
|
|
// Act
|
|
store.updateVehicle(vehicle);
|
|
|
|
// Assert
|
|
expect(store.order.policy).toMatchObject(expectedPolicy);
|
|
});
|
|
|
|
// 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: carId,
|
|
category: category,
|
|
year: year,
|
|
make: make,
|
|
model: model,
|
|
style: style,
|
|
imageUrl: imageUrl,
|
|
imageVifNumber: 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: glassName,
|
|
glassLocation: 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: glassName,
|
|
glassLocation: 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: streetAddress,
|
|
city: city,
|
|
state: state,
|
|
zipCode: zipCode,
|
|
},
|
|
firstName: firstName,
|
|
lastName: lastName,
|
|
}
|
|
|
|
store.order.vehicle.registration = {
|
|
licensePlate: null,
|
|
address: streetAddress,
|
|
city: city,
|
|
state: state,
|
|
zipCode: zipCode,
|
|
firstName: firstName,
|
|
lastName: 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: city,
|
|
state: state,
|
|
zipCode: zipCode,
|
|
},
|
|
firstName: firstName,
|
|
lastName: lastName,
|
|
}
|
|
|
|
store.order.vehicle.registration.address = null;
|
|
|
|
store.order.customer = {
|
|
address: {
|
|
streetAddress: address,
|
|
city: city,
|
|
state: state,
|
|
zipCode: zipCode
|
|
},
|
|
firstName: firstName,
|
|
lastName: 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),
|
|
correlationId: getRandomGuid(),
|
|
isSuccess: true,
|
|
isError: false,
|
|
successMessage: getRandomString(9, 9),
|
|
deductible: 0
|
|
}
|
|
};
|
|
store.policy.noCompensation = 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);
|
|
});
|
|
|
|
it("successful response with coverage => isVerified true and coverage status verified", async () => {
|
|
// Arrange
|
|
const response = {
|
|
data: {
|
|
claimantId: null,
|
|
claimNumber: getRandomString(9, 9),
|
|
correlationId: getRandomGuid(),
|
|
isSuccess: true,
|
|
isError: false,
|
|
successMessage: getRandomString(9, 9),
|
|
deductible: 0
|
|
}
|
|
};
|
|
store.policy.noCompensation = 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);
|
|
})
|
|
|
|
it("Call to client returns exception, resulting in object with error property being returned", async () => {
|
|
// Arrange
|
|
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject());
|
|
|
|
// Act
|
|
await store.registerClaim();
|
|
|
|
// Asserts
|
|
expect(globalMethods.callHttpClient).toHaveBeenCalled();
|
|
expect(store.payment.insuranceCoverage.isVerified).toBe(false);
|
|
expect(store.payment.insuranceCoverage.coverageStatus).toBe(coverageStatuses.PENDING);
|
|
});
|
|
});
|
|
|
|
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('');
|
|
});
|
|
});
|
|
});
|