jason/DigitalConsumer.ISS
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

SSR-1167 Coverage Rework unverified / coverage statement improvements

Browse source
This commit is contained in:
Josh Dassinger 2024-05-22 09:01:09 -05:00
parent 0753374b59
commit f63c4e0c7a
13 changed files with 174 additions and 591 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/constants/coverage-statement-page-variations.js
View file

@ -1,8 +0,0 @@
const coverageStatementPageVariations = Object.freeze({
DEDUCTIBLE: 0,
ITAC: 1,
NO_COMP: 2,
UNVERIFIED: 3
});
export default coverageStatementPageVariations;

11
src/constants/coverage-statuses.js
View file

@ -1,6 +1,17 @@
const coverageStatuses = Object.freeze({
/**
* We have not yet attempted claim registration
*/
PENDING: 0,
/**
* We have attempted claim registration, and we got a failure response
*/
NO_COVERAGE: 1,
/**
* We have attempted claim registration, and we got a success response
*/
VERIFIED: 2
});

19
src/constants/coverage-type.js
View file

@ -1,7 +1,26 @@
const coverageType = Object.freeze({
/**
* We attempted policy lookup and it failed or we are no comp and no comp quotes are disabled for this client
*/
NONE: 0,
/**
* We attempted policy lookup and got success response
* We have selected a vehicle that has comprehensive coverage
* We are not considered ITAC
*/
Deductible: 1,
/**
* We attempted policy lookup and got a success response
* We determined that we are in an ITAC case
*/
ITAC: 2,
/**
* We attempted policy lookup and got a success response
* The vehicle policy does not have comprehensive coverage
*/
NO_COMP: 3
});

49
src/iss-components/cart-dropdown/cart-dropdown.spec.js
View file

@ -1310,27 +1310,6 @@ describe('cart-dropdown component', () => {
});
describe('method', () => {
describe('getDisplayed', () => {
test('returns "Verifying coverage" when not no comp, not itac, and deductible null', () => {
// Arrange
const storeData = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: null
}
};
const { wrapper } = getMountedComponent(storeData);
const amount = 123;
// Act
const result = wrapper.vm.getDisplayed(amount);
// Assert
expect(result).toBe(VERIFYING_COVERAGE);
});
test('returns "Verifying coverage" when not no comp, not itac, and coverage status PENDING', () => {
// Arrange
const storeData = {
@ -1374,7 +1353,7 @@ describe('cart-dropdown component', () => {
// Assert
expect(result).toBe(dollarAmount);
});
test('returns dollar amount when no comp and enableNoCompQuotes true', () => {
test('returns dollar amount when no comp', () => {
// Arrange
const storeData = {
order: {
@ -1384,9 +1363,6 @@ describe('cart-dropdown component', () => {
},
currentDeductible: 321
},
issConfig: {
enableNoCompQuote: true
}
};
const { wrapper } = getMountedComponent(storeData);
const amount = 123;
@ -1399,29 +1375,6 @@ describe('cart-dropdown component', () => {
// Assert
expect(result).toBe(dollarAmount);
});
test('returns "Verifying Coverage" when no comp and enableNoCompQuotes false', () => {
// Arrange
const storeData = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.NO_COMP
},
currentDeductible: 321
},
issConfig: {
enableNoCompQuote: false
}
};
const { wrapper } = getMountedComponent(storeData);
const amount = 123;
// Act
const result = wrapper.vm.getDisplayed(amount);
// Assert
expect(result).toBe(VERIFYING_COVERAGE);
});
test('returns dollar amount when deductible set, not itac, not no comp, and verified', () => {
// Arrange
const storeData = {

417
src/layouts/coverage-statement/coverage-statement.spec.js
View file

@ -14,7 +14,6 @@ import { useMainStore } from '@/store';
import { getPriceOfLineItems } from '@/helpers/price-calculator.js';
import coverageStatuses from '@/constants/coverage-statuses';
import coverageType from '@/constants/coverage-type';
import coverageStatementPageVariations from '@/constants/coverage-statement-page-variations';
jest.mock('@/helpers/layout-helper.js', () => jest.fn());
jest.mock('@/helpers/price-calculator.js', () => ({
@ -169,13 +168,10 @@ describe('coverageStatement.vue', () => {
});
describe('Computed', () => {
describe('verified No Comp', () => {
describe.each([[false, false, coverageType.NONE],
[false, true, coverageType.NONE],
[false, false, coverageType.Deductible],
[false, true, coverageType.Deductible],
[false, false, coverageType.NO_COMP],
[true, true, coverageType.NO_COMP]])('isNoCompQuoteVisible', (expected, enableNoCompQuote, type) => {
test(`returns ${expected} when enableNoCompQuote is ${enableNoCompQuote} coverageStatus is Verified and coverageType is ${getEnumName(coverageType, type)}`, () => {
describe.each([[false, coverageType.NONE],
[false, coverageType.Deductible],
[true, coverageType.NO_COMP]])('isNoCompQuoteVisible', (expected, type) => {
test(`returns ${expected} coverageStatus is Verified and coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const mainInitialState = {
order: {
@ -183,8 +179,7 @@ describe('coverageStatement.vue', () => {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
}
},
issConfig: { enableNoCompQuote }
}
};
const { wrapper } = getMountedComponent(mainInitialState);
@ -198,28 +193,21 @@ describe('coverageStatement.vue', () => {
});
describe('verified ITAC', () => {
describe.each([[false, coverageType.NONE, 50, 100],
[false, coverageType.NONE, 100, 100],
[false, coverageType.NONE, 200, 100],
[false, coverageType.Deductible, 50, 100],
[false, coverageType.Deductible, 100, 100],
[true, coverageType.Deductible, 200, 100],
[false, coverageType.NO_COMP, 50, 100],
[false, coverageType.NO_COMP, 100, 100],
[false, coverageType.NO_COMP, 200, 100]])('isITACQuoteVisible', (expected, type, deductible, priceOfLineItems) => {
test(`returns ${expected} when coverageType is ${getEnumName(coverageType, type)} and deductible is ${deductible} and price of line items is ${priceOfLineItems}`, () => {
describe.each([[false, coverageType.NONE],
[false, coverageType.Deductible],
[true, coverageType.ITAC],
[false, coverageType.NO_COMP]])('isITACQuoteVisible', (expected, type) => {
test(`returns ${expected} when coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
currentDeductible: deductible
}
}
};
getPriceOfLineItems.mockReturnValue(priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
@ -232,66 +220,21 @@ describe('coverageStatement.vue', () => {
});
describe('verified Deductible', () => {
describe.each([[false, coverageType.NONE, 100, 100],
[false, coverageType.NONE, 50, 100],
[false, coverageType.NONE, 100, 50],
[true, coverageType.Deductible, 100, 100],
[true, coverageType.Deductible, 50, 100],
[false, coverageType.Deductible, 100, 50],
[false, coverageType.NO_COMP, 100, 100],
[false, coverageType.NO_COMP, 100, 50],
[false, coverageType.NO_COMP, 50, 100]])('isDeductibleVisible when isClaimRegistrationRequired is true', (expected, type, deductible, priceOfLineItems) => {
test(`returns ${expected} when coverageType is ${getEnumName(coverageType, type)} and deductible is ${deductible} and price of line items is ${priceOfLineItems}`, () => {
describe.each([[false, coverageType.NONE],
[true, coverageType.Deductible],
[false, coverageType.ITAC],
[false, coverageType.NO_COMP]])('isDeductibleVisible', (expected, type) => {
test(`returns ${expected} when coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
currentDeductible: deductible
},
issConfig: {
isClaimRegistrationRequired: true
}
}
};
getPriceOfLineItems.mockReturnValue(priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isDeductibleVisible;
// Assert
expect(result).toBe(expected);
});
});
describe.each([[false, coverageType.NONE, 100, 100],
[false, coverageType.NONE, 50, 100],
[false, coverageType.NONE, 100, 50],
[true, coverageType.Deductible, 100, 100],
[true, coverageType.Deductible, 50, 100],
[false, coverageType.Deductible, 100, 50],
[false, coverageType.NO_COMP, 100, 100],
[false, coverageType.NO_COMP, 100, 50],
[false, coverageType.NO_COMP, 50, 100]])('isDeductibleVisible when isClaimRegistrationRequired is false', (expected, type, deductible, priceOfLineItems) => {
test(`returns ${expected} when coverageType is ${getEnumName(coverageType, type)} and deductible is ${deductible} and price of line items is ${priceOfLineItems}`, () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
currentDeductible: deductible
},
issConfig: {
isClaimRegistrationRequired: false
}
};
getPriceOfLineItems.mockReturnValue(priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
@ -307,7 +250,7 @@ describe('coverageStatement.vue', () => {
const servicePrice = 123;
describe('claim registration required', () => {
const verifiedDeductibleStoreState = {
issConfig : {
issConfig: {
isClaimRegistrationRequired: true
},
order: {
@ -319,23 +262,11 @@ describe('coverageStatement.vue', () => {
}
};
getPriceOfLineItems.mockReturnValue(servicePrice);
test('returns false when deductible is null', () => {
// Arrange
const { wrapper } = getMountedComponent(verifiedDeductibleStoreState);
useMainStore().order.currentDeductible = null;
// Act
const result = wrapper.vm.isDeductibleVisible;
// Assert
expect(result).toBeFalsy();
});
test('returns false when register claim not successful', async () => {
// Arrange
const { wrapper } = getMountedComponent(verifiedDeductibleStoreState);
useMainStore().order.insuranceCoverage.coverageStatus = coverageStatuses.NO_COVERAGE;
// Act
const result = wrapper.vm.isDeductibleVisible;
@ -433,266 +364,84 @@ describe('coverageStatement.vue', () => {
});
});
describe('isQuoteDisplayed', () => {
test('returns false when policy lookup not successful', () => {
describe.each([
[false, coverageStatuses.PENDING, coverageType.NONE],
[false, coverageStatuses.PENDING, coverageType.ITAC],
[false, coverageStatuses.PENDING, coverageType.NO_COMP],
[false, coverageStatuses.PENDING, coverageType.Deductible],
[true, coverageStatuses.VERIFIED, coverageType.NO_COMP],
[true, coverageStatuses.VERIFIED, coverageType.ITAC],
[false, coverageStatuses.VERIFIED, coverageType.Deductible],
[false, coverageStatuses.NO_COVERAGE, coverageType.NO_COMP],
[false, coverageStatuses.NO_COVERAGE, coverageType.ITAC],
[false, coverageStatuses.NO_COVERAGE, coverageType.Deductible]
])('isQuoteDisplayed', (expected, status, type) => {
// eslint-disable-next-line max-len
test(`$returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)} and coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: status,
coverageType: type
}
}
};
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isQuoteDisplayed;
// Assert
expect(result).toBe(expected);
});
});
});
describe.each([
[false, false, false, true, true, 0],
[false, true, true, true, true, 0],
[false, true, false, false, true, 0],
[false, true, false, true, false, 0],
[false, true, false, true, true, -1],
[false, true, false, true, true, null],
[true, true, false, true, true, 0]
])('shouldRegisterClaim', (
expected,
isClaimRegistrationRequired,
isClaimAlreadyRegistered,
isPolicyLookupSuccessful,
isPendingClaimRegistration,
policyVehicleId
) => {
test(`returns ${expected} when isClaimRegistrationRequired is ${isClaimRegistrationRequired} `
+ `and isClaimAlreadyRegistered is ${isClaimAlreadyRegistered} `
+ `and isPolicyLookupSuccessful is ${isPolicyLookupSuccessful} `
+ `and isPendingClaimRegistration is ${isPendingClaimRegistration} `
+ `and policyVehicleId is ${(policyVehicleId == null ? 'NULL' : policyVehicleId)}`, () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.NONE
}
}
};
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isQuoteDisplayed;
// Assert
expect(result).toBeFalsy();
});
describe('not no comp', () => {
const priceOfLineItems = 341;
test('returns false when deductible equal to service price', () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: priceOfLineItems
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isQuoteDisplayed;
// Assert
expect(result).toBeFalsy();
});
test('returns false when deductible less than service price', () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: priceOfLineItems - 1
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isQuoteDisplayed;
// Assert
expect(result).toBeFalsy();
});
test('returns true when policy lookup successful and deductible over service price', () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: priceOfLineItems + 1
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isQuoteDisplayed;
// Assert
expect(result).toBeTruthy();
});
});
describe('not itac', () => {
const priceOfLineItems = 23;
test('returns false when isNoComp false', () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: priceOfLineItems
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isQuoteDisplayed;
// Assert
expect(result).toBeFalsy();
});
test('returns false when isNoComp true and enableNoCompQuote false', () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.NO_COMP
},
currentDeductible: priceOfLineItems
},
issConfig: {
enableNoCompQuote: false
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isQuoteDisplayed;
// Assert
expect(result).toBeFalsy();
});
test('returns true when isNoComp true and enableNoCompQuote true', () => {
// Arrange
const mainInitialState = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.NO_COMP
},
currentDeductible: priceOfLineItems
},
issConfig: {
enableNoCompQuote: true
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isQuoteDisplayed;
// Assert
expect(result).toBeTruthy();
});
});
});
describe.each([[0], [12]])('shouldRegisterClaim', (policyVehicleId) => {
const servicePrice = 90;
let shouldRegisterClaimStoreStateItac;
beforeEach(() => {
shouldRegisterClaimStoreStateItac = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible,
claimNumber: null
coverageStatus: isPendingClaimRegistration ? coverageStatuses.PENDING : coverageStatuses.VERIFIED,
coverageType: isPolicyLookupSuccessful ? coverageType.Deductible : coverageType.NONE,
claimNumber: isClaimAlreadyRegistered ? getRandomString(6, 6) : null
},
vehicle: {
policyVehicleId
},
currentDeductible: servicePrice - 1
}
},
issConfig: {
isClaimRegistrationRequired: true,
enableNoCompQuote: true
isClaimRegistrationRequired
}
};
getPriceOfLineItems.mockImplementation(() => servicePrice);
});
test('returns false when policy lookup not successful', () => {
// Arrange
const mainInitialState = shouldRegisterClaimStoreStateItac;
mainInitialState.order.insuranceCoverage.coverageType = coverageType.NONE;
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.shouldRegisterClaim;
// Assert
expect(result).toBeFalsy();
});
test('returns false when policy vehicle id is less than 0', () => {
// Arrange
const mainInitialState = shouldRegisterClaimStoreStateItac;
mainInitialState.order.vehicle.policyVehicleId = -3;
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.shouldRegisterClaim;
// Assert
expect(result).toBeFalsy();
});
test('returns false when policy vehicle id is null', () => {
// Arrange
const mainInitialState = shouldRegisterClaimStoreStateItac;
mainInitialState.order.vehicle.policyVehicleId = null;
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.shouldRegisterClaim;
// Assert
expect(result).toBeFalsy();
});
test('returns false when claim registration is not required', () => {
// Arrange
const mainInitialState = shouldRegisterClaimStoreStateItac;
mainInitialState.issConfig.isClaimRegistrationRequired = false;
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.shouldRegisterClaim;
// Assert
expect(result).toBeFalsy();
});
test('returns false when claim already registered', () => {
// Arrange
const mainInitialState = shouldRegisterClaimStoreStateItac;
mainInitialState.order.insuranceCoverage.claimNumber = '13';
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.shouldRegisterClaim;
// Assert
expect(result).toBeFalsy();
});
describe('returns true when policy lookup success, vehicleId set to %p, claim reg req, claim not yet reg', () => {
test('and itac', () => {
// Arrange
const { wrapper } = getMountedComponent(shouldRegisterClaimStoreStateItac);
// Act
const result = wrapper.vm.shouldRegisterClaim;
// Assert
expect(result).toBeTruthy();
});
test.each([
[servicePrice],
[servicePrice + 1]
])('and deductible case', (deductibleValue) => {
// Arrange
const mainInitialState = shouldRegisterClaimStoreStateItac;
mainInitialState.currentDeductible = deductibleValue;
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.shouldRegisterClaim;
// Assert
expect(result).toBeTruthy();
});
expect(result).toBe(expected);
});
});
});
@ -816,7 +565,7 @@ describe('coverageStatement.vue', () => {
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.ITAC,
coverageType: coverageType.ITAC
},
currentDeductible: deductible
}
@ -846,7 +595,7 @@ describe('coverageStatement.vue', () => {
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.ITAC,
coverageType: coverageType.ITAC
},
currentDeductible: deductible
}
@ -875,8 +624,8 @@ describe('coverageStatement.vue', () => {
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.NO_COMP,
},
coverageType: coverageType.NO_COMP
}
},
issConfig: {
enableNoCompQuote: true

62
src/layouts/coverage-statement/coverage-statement.vue
View file

@ -104,7 +104,6 @@ import alert from '@/ux-components/alert/alert.vue';
import contentGroupModal from '@/iss-components/content-group-modal/content-group-modal.vue';
import buttonQuestion from '@/digital-components/button-question/button-question.vue';
import textBlock from '@/digital-components/text-block/text-block.vue';
import pageVariations from '@/constants/coverage-statement-page-variations';
// Import Supporting Files
import {
@ -232,43 +231,6 @@ export default {
};
},
computed: {
pageVariation() {
const {
isNoComp,
issConfig,
isClaimRegistrationRequired,
isPolicyLookupSuccessful,
isVerified,
isUnverified
} = useMainStore();
if (!isPolicyLookupSuccessful) {
return pageVariations.UNVERIFIED;
}
if (isNoComp) {
if (issConfig.enableNoCompQuote) {
return pageVariations.NO_COMP;
}
return pageVariations.UNVERIFIED;
}
if (isUnverified) {
return pageVariations.UNVERIFIED;
}
// TODO this should be determined based on the result of the ITAC price call
// TODO it seems that ITAC now requires claim registration calls. If this call fails
// should the page become unverified?
if (this.deductibleValue > this.totalServicePrice) {
return pageVariations.ITAC;
}
if (!isClaimRegistrationRequired || isVerified) {
return pageVariations.DEDUCTIBLE;
}
return pageVariations.UNVERIFIED;
},
coverageStatementSubHeader() {
return this.getTextFromCmsWithCustomIfStatements(
this.widget.subheader,
@ -325,17 +287,16 @@ export default {
return useMainStore().order.currentDeductible;
},
isNoCompQuoteVisible() {
return this.pageVariation === pageVariations.NO_COMP;
return this.mainStore.isVerified && this.mainStore.isNoComp;
},
isITACQuoteVisible() {
return this.pageVariation === pageVariations.ITAC;
return this.mainStore.isVerified && this.mainStore.isITAC;
},
isDeductibleVisible() {
return this.pageVariation === pageVariations.DEDUCTIBLE;
return this.mainStore.isVerified && this.mainStore.isDeductible;
},
isUnverifiedVisible() {
return this.pageVariation === pageVariations.UNVERIFIED;
return this.mainStore.isUnverified;
},
isADAS() {
const { glassParts } = useMainStore().order.lineItems;
@ -367,7 +328,8 @@ export default {
vehicle,
isClaimRegistrationRequired,
isClaimAlreadyRegistered,
isPolicyLookupSuccessful
isPolicyLookupSuccessful,
isPendingClaimRegistration
} = useMainStore();
const { policyVehicleId } = vehicle;
return (
@ -376,6 +338,7 @@ export default {
&& policyVehicleId >= 0
&& isClaimRegistrationRequired
&& !isClaimAlreadyRegistered
&& isPendingClaimRegistration
);
}
},
@ -402,13 +365,16 @@ export default {
return !!useMainStore().vehicle.carId;
},
async initializeComponent() {
if (this.isNoCompQuoteVisible) {
this.mainStore.updateCoverageStatus(coverageStatuses.VERIFIED);
}
if (this.shouldRegisterClaim) {
await this.mainStore.registerClaim();
} else if (!this.mainStore.isClaimRegistrationRequired) {
this.mainStore.updateCoverageStatus(coverageStatuses.VERIFIED);
}
if (this.isITACQuoteVisible) {
// TODO this should be determined based on the result of the ITAC price call
// TODO it seems that ITAC now requires claim registration calls. If this call fails
console.log(`${this.mainStore.isDeductible} - ${this.deductibleValue} > ${this.totalServicePrice}`);
if (this.mainStore.isDeductible && this.deductibleValue > this.totalServicePrice) {
console.log('Do update0');
this.mainStore.updateCoverageType(coverageType.ITAC);
}
showIssLoadingModal(false);

2
src/layouts/duplicate-check/duplicate-check.spec.js
View file

@ -466,7 +466,7 @@ describe('duplicateCheck.vue', () => {
expect(wrapper.vm.$router.navigate)
.toHaveBeenCalledWith(navigationScenarios.CLICKED_FORWARD_POLICY_VERIFIED_NO_VEHICLES, undefined);
});
test('coverageType none false => CLICKED_FORWARD_POLICY_UNVERIFIED', async () => {
test('coverageType none => CLICKED_FORWARD_POLICY_UNVERIFIED', async () => {
// Arrange
const { wrapper } = getMountedComponent({
order: {

66
src/layouts/payment-method/payment-method.spec.js
View file

@ -162,44 +162,9 @@ describe('payment-method.vue', () => {
}
};
});
test('returns true when coverageType none', () => {
// Arrange
store.order.insuranceCoverage.coverageType = coverageType.NONE;
const wrapper = setupMocks({}, store, mixin);
// Act
const result = wrapper.vm.isPayInAdvanceDisabled;
// Assert
expect(result).toBeTruthy();
});
test('returns true when no comp and enableNoCompQuote false', () => {
// Arrange
store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
store.issConfig.enableNoCompQuote = false;
const wrapper = setupMocks({}, store, mixin);
// Act
const result = wrapper.vm.isPayInAdvanceDisabled;
// Assert
expect(result).toBeTruthy();
});
test('returns true when not no comp and currentDeductible null', () => {
// Arrange
store.order.currentDeductible = null;
const wrapper = setupMocks({}, store, mixin);
// Act
const result = wrapper.vm.isPayInAdvanceDisabled;
// Assert
expect(result).toBeTruthy();
});
test('returns true when isClaimRegistrationRequired true and insurance coverage not verified', () => {
test('returns true when coverageStatus is pending', () => {
// Arrange
store.order.insuranceCoverage.coverageStatus = coverageStatuses.PENDING;
store.issConfig.isClaimRegistrationRequired = true;
const wrapper = setupMocks({}, store, mixin);
// Act
@ -208,11 +173,20 @@ describe('payment-method.vue', () => {
// Assert
expect(result).toBeTruthy();
});
test('returns false when no comp, enableNoCompQuote true, and currentDeductible null and pia enabled', () => {
test('returns true when coverageStatus is no coverage', () => {
// Arrange
store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
store.issConfig.enableNoCompQuote = true;
store.order.currentDeductible = null;
store.order.insuranceCoverage.coverageStatus = coverageStatuses.NO_COVERAGE;
const wrapper = setupMocks({}, store, mixin);
// Act
const result = wrapper.vm.isPayInAdvanceDisabled;
// Assert
expect(result).toBeTruthy();
});
test('returns false when coverageStatus is verified', () => {
// Arrange
store.order.insuranceCoverage.coverageStatus = coverageStatuses.VERIFIED;
const wrapper = setupMocks({}, store, mixin);
// Act
@ -221,17 +195,7 @@ describe('payment-method.vue', () => {
// Assert
expect(result).toBeFalsy();
});
test('returns false when not no comp, currentDeductible not null and pia enabled', () => {
// Arrange
const wrapper = setupMocks({}, store, mixin);
// Act
const result = wrapper.vm.isPayInAdvanceDisabled;
// Assert
expect(result).toBeFalsy();
});
test.skip('returns true when pia not enabled', () => {
test('returns true when pia not enabled', () => {
// Arrange
mixin = {
methods: {

2
src/layouts/tpa-submit/tpa-submit.spec.js
View file

@ -684,7 +684,7 @@ describe('tpa-submit', () => {
[true, coverageStatuses.PENDING],
[false, coverageStatuses.VERIFIED],
[true, coverageStatuses.NO_COVERAGE]
])('with argument zeroDeductible', (expected, status) => {
])('with argument verifyingCoverage', (expected, status) => {
test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)}`, () => {
// Arrange
const initialStore = {

2
src/layouts/welcome-page/welcome-page.spec.js
View file

@ -11,7 +11,7 @@ import applicationConfig from '@/constants/application-config';
import { useMainStore } from '@/store';
import navigationScenarios from '@/router/router-constants/navigation-scenarios';
import routerParams from '@/router/router-constants/router-params';
import coverageType from "@/constants/coverage-type";
import coverageType from '@/constants/coverage-type';
// Mock our module for promises.
jest.mock('@/helpers/layout-helper.js', () => jest.fn());

5
src/layouts/welcome-page/welcome-page.vue
View file

@ -176,7 +176,7 @@ import routerParams from '@/router/router-constants/router-params';
import MaskaFormattedMasks from '@/constants/maska-masks';
import globalMethods from '@/global-methods';
import { endpoints } from '@/constants/endpoints';
import coverageType from "@/constants/coverage-type";
import coverageType from '@/constants/coverage-type';
// define validation rules
defineRule(
@ -336,7 +336,8 @@ export default {
.finally(async () => {
if (this.isCoverageEnabled
&& !this.maxCoverageLookupAttemptsReached) {
await this.mainStore.getCoveragePolicyInfo();
await this.mainStore.getCoveragePolicyInfo()
?.catch(() => this.mainStore.updateCoverageType(coverageType.NONE));
} else {
this.mainStore.updateCoverageType(coverageType.NONE);
}

31
src/store/index.js
View file

@ -292,25 +292,12 @@ export const useMainStore = defineStore({
bailoutCode: (state) => state.applicationUser.pageData[issPageValues.BAILOUT_PAGE]?.bailoutCode,
isPolicyLookupSuccessful: (s) => s.order.insuranceCoverage.coverageType !== coverageType.NONE,
isNoComp: (s) => s.order.insuranceCoverage.coverageType === coverageType.NO_COMP,
isNoCompQuoteEnabled: (s) => s.issConfig.enableNoCompQuote,
isITAC: (state) => state.order.insuranceCoverage.coverageType === coverageType.ITAC,
isUnverified: (s) => {
const { currentDeductible } = s.order;
if (!s.isPolicyLookupSuccessful) {
return true;
}
if (s.isNoComp && !s.issConfig.enableNoCompQuote) {
return true;
}
if (!s.isNoComp && currentDeductible == null) {
return true;
}
if (s.isClaimRegistrationRequired && !s.isVerified) {
return true;
}
return false;
},
// TODO condense verification logic
isDeductible: (state) => state.order.insuranceCoverage.coverageType === coverageType.Deductible,
isUnverified: (s) => s.order.insuranceCoverage.coverageStatus !== coverageStatuses.VERIFIED,
isVerified: (state) => state.order.insuranceCoverage.coverageStatus === coverageStatuses.VERIFIED,
isPendingClaimRegistration: (state) => state.order.insuranceCoverage.coverageStatus === coverageStatuses.PENDING,
eventBusItem: (state) => (eventCategory, eventSubCategory) => {
const matchedEvent = state.applicationUser.eventBus.find(({ category, subCategory }) => category === eventCategory && subCategory === eventSubCategory);
return matchedEvent?.eventValue;
@ -651,9 +638,7 @@ export const useMainStore = defineStore({
}).then((response) => {
const registerClaimFailed = response.data.isError;
order.insuranceCoverage.claimNumber = null;
if (this.isNoComp) {
this.updateCoverageStatus(coverageStatuses.VERIFIED);
} else if (!registerClaimFailed) {
if (!registerClaimFailed) {
this.updateCoverageStatus(coverageStatuses.VERIFIED);
this.order.insuranceCoverage.claimNumber = response.data.claimNumber;
} else {
@ -1703,7 +1688,11 @@ export const useMainStore = defineStore({
updateVehicleCoverage(coverage) {
if (coverage.noCoverage) {
this.updateCoverageType(coverageType.NO_COMP);
if (this.isNoCompQuoteEnabled) {
this.updateCoverageType(coverageType.NO_COMP);
} else {
this.updateCoverageType(coverageType.NONE);
}
} else {
this.updateCoverageType(coverageType.Deductible);
}

91
src/store/store.spec.js
View file

@ -185,16 +185,11 @@ describe('Store', () => {
endorsements
};
const expectedInsuranceCoverage = {
coverageType: noCoverage ? coverageType.NO_COMP : coverageType.Deductible
};
// Act
store.updateVehicleCoverage(vehicleCoverage);
// Assert
expect(store.order.policy).toMatchObject(expectedPolicy);
expect(store.order.insuranceCoverage).toMatchObject(expectedInsuranceCoverage);
});
it('UpdateVehicle should set policy values appropriately with repair not waived', () => {
@ -217,24 +212,21 @@ describe('Store', () => {
endorsements
};
const expectedInsuranceCoverage = {
coverageType: noCoverage ? coverageType.NO_COMP : coverageType.Deductible
};
// Act
store.updateVehicleCoverage(vehicleCoverage);
// Assert
expect(store.order.policy).toMatchObject(expectedPolicy);
expect(store.order.insuranceCoverage).toMatchObject(expectedInsuranceCoverage);
});
describe.each([
[coverageType.NO_COMP, true],
[coverageType.Deductible, false]
])('updateVehicleCoverage noCoverage', (expected, noCoverage) => {
test(`CoverageType is set to expected ${getEnumName(coverageType, expected)} when vehicle noCoverage is ${noCoverage}`, () => {
[coverageType.NO_COMP, true, true],
[coverageType.NONE, false, true],
[coverageType.Deductible, true, false]
])('updateVehicleCoverage noCoverage', (expected, enableNoCompQuote, noCoverage) => {
test(`CoverageType is set to expected ${getEnumName(coverageType, expected)} when vehicle noCoverage is ${noCoverage} and enableNoCompQuote is ${enableNoCompQuote}`, () => {
// Arrange
store.issConfig.enableNoCompQuote = enableNoCompQuote;
const vehicleCoverage = {
noCoverage
};
@ -439,7 +431,7 @@ describe('Store', () => {
expect(globalMethods.callHttpClient).toHaveBeenCalled();
expect(store.order.insuranceCoverage.coverageStatus).toBe(coverageStatuses.VERIFIED);
expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NO_COMP);
expect(store.order.insuranceCoverage.claimNumber).toBe(null);
expect(store.order.insuranceCoverage.claimNumber).toBe(response.data.claimNumber);
});
it('successful response with coverage => isVerified true and coverage status verified', async () => {
@ -1483,73 +1475,20 @@ describe('Store', () => {
});
});
describe('isUnverified', () => {
beforeEach(() => {
store.order.currentDeductible = 123;
store.order.insuranceCoverage.coverageStatus = coverageStatuses.VERIFIED;
store.order.insuranceCoverage.coverageType = coverageType.Deductible;
store.issConfig.isClaimRegistrationRequired = true;
store.issConfig.enableNoCompQuote = true;
});
it('returns true when coverageType is NONE', () => {
describe.each([
[true, coverageStatuses.PENDING],
[true, coverageStatuses.NO_COVERAGE],
[false, coverageStatuses.VERIFIED]
])('isUnverified', (expected, status) => {
test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)}`, () => {
// Arrange
store.order.insuranceCoverage.coverageType = coverageType.NONE;
store.order.insuranceCoverage.coverageStatus = status;
// Act
const result = store.isUnverified;
// Assert
expect(result).toBeTruthy();
});
it('returns true when no comp and enableNoCompQuote false', () => {
// Arrange
store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
store.issConfig.enableNoCompQuote = false;
// Act
const result = store.isUnverified;
// Assert
expect(result).toBeTruthy();
});
it('returns true when not no comp and currentDeductible null', () => {
// Arrange
store.order.currentDeductible = null;
// Act
const result = store.isUnverified;
// Assert
expect(result).toBeTruthy();
});
it('returns true when isClaimRegistrationRequired true and insurance coverage not verified', () => {
// Arrange
store.order.insuranceCoverage.coverageStatus = coverageStatuses.NO_COVERAGE;
// Act
const result = store.isUnverified;
// Assert
expect(result).toBeTruthy();
});
it('returns false when no comp, enableNoCompQuote true, and currentDeductible null', () => {
// Arrange
store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
store.order.currentDeductible = null;
store.issConfig.enableNoCompQuote = true;
// Act
const result = store.isUnverified;
// Assert
expect(result).toBeFalsy();
});
it('returns false when not no comp, currentDeductible not null', () => {
// Act
const result = store.isUnverified;
// Assert
expect(result).toBeFalsy();
expect(result).toBe(expected);
});
});