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

SSR-1167 Coverage Rework

Browse source
This commit is contained in:
Josh Dassinger 2024-05-20 13:13:40 -05:00
parent 72b8b9d137
commit feb99ae400
28 changed files with 1050 additions and 1380 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -1,6 +1,6 @@
const coverageStatuses = Object.freeze({
PENDING: 0,
NO_COMP: 1,
NO_COVERAGE: 1,
VERIFIED: 2
});

8
src/constants/coverage-type.js Normal file
View file

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

5
src/helpers/cart-helper.js
View file

@ -2,6 +2,7 @@ import { useMainStore } from '@/store';
import { getPriceOfLineItems, getTaxOfLineItems } from '@/helpers/price-calculator';
import partNumberStrings from '@/constants/part-number-strings';
import partTypeStrings from '@/constants/part-type-strings';
import coverageType from "@/constants/coverage-type";
/**
* Returns the lineItems object from the order
@ -93,7 +94,7 @@ export function isOrderUnverified(order) {
* @returns {boolean} order NO COMP flag
*/
export function isOrderNoComp(order) {
return order.policy?.noCoverage ?? false;
return order.insuranceCoverage?.coverageType === coverageType.NO_COMP ?? false;
}
/**
@ -102,7 +103,7 @@ export function isOrderNoComp(order) {
* @returns {boolean} order ITAC flag
*/
export function isOrderITAC(order) {
return order.policy?.isITAC ?? false;
return order.insuranceCoverage?.coverageType === coverageType.ITAC ?? false;
}
/**

482
src/helpers/cart-helper.spec.js
View file

@ -10,6 +10,9 @@ import {
} from '@/helpers/cart-helper';
import partTypeStrings from '@/constants/part-type-strings';
import partNumberStrings from '@/constants/part-number-strings';
import coverageStatuses from '@/constants/coverage-statuses';
import coverageType from '@/constants/coverage-type';
import { getEnumName } from '@/helpers/unit-test-helper';
describe('cart-helper', () => {
function createDummyItem(partNumber, price, salesTax) {
@ -251,7 +254,7 @@ describe('cart-helper', () => {
});
describe('isOrderUnverified', () => {
test.each([[false, false], [true, true]])('Returns %p when policy.isUnverified is %p', (expected, isUnverified) => {
test.each([[false, false], [true, true]])('Returns %p when isUnverified is %p', (expected, isUnverified) => {
// Arrange
const order = {
isUnverified
@ -266,7 +269,7 @@ describe('cart-helper', () => {
});
describe('isOrderNoComp', () => {
test('Returns false when policy is null', () => {
test('Returns false when insuranceCoverage is null', () => {
// Arrange
const order = {};
@ -277,24 +280,30 @@ describe('cart-helper', () => {
expect(result).toBeFalsy();
});
test.each([[false, false], [true, true]])('Returns %p when policy.NoCoverage is %p', (expected, noCoverage) => {
// Arrange
const order = {
policy: {
noCoverage
}
};
describe.each([
[false, coverageType.NONE],
[false, coverageType.ITAC],
[true, coverageType.NO_COMP],
[false, coverageType.Deductible]])('isOrderNoComp by coverageType', (expected, type) => {
test(`Returns ${expected} when insuranceCoverage.coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
insuranceCoverage: {
coverageType: type
}
};
// Act
const result = isOrderNoComp(order);
// Act
const result = isOrderNoComp(order);
// Assert
expect(result).toBe(expected);
// Assert
expect(result).toBe(expected);
});
});
});
describe('isOrderITAC', () => {
test('Returns false when policy is null', () => {
test('Returns false when insuranceCoverage is null', () => {
// Arrange
const order = {};
@ -305,298 +314,247 @@ describe('cart-helper', () => {
expect(result).toBeFalsy();
});
test.each([[false, false], [true, true]])('Returns %p when policy.isITAC is %p', (expected, isITAC) => {
// Arrange
const order = {
policy: {
isITAC
}
};
describe.each([
[false, coverageType.NONE],
[true, coverageType.ITAC],
[false, coverageType.NO_COMP],
[false, coverageType.Deductible]])('isOrderITAC by coverageType ', (expected, type) => {
test(`Returns ${expected} when insuranceCoverage.coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
insuranceCoverage: {
coverageType: type
}
};
// Act
const result = isOrderITAC(order);
// Act
const result = isOrderITAC(order);
// Assert
expect(result).toBe(expected);
// Assert
expect(result).toBe(expected);
});
});
});
describe('getSubtotal', () => {
test('Returns 0 when there are null items', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: true
},
lineItems: nullLineItems
};
describe.each([
[0, coverageType.ITAC],
[0, coverageType.NO_COMP],
[100, coverageType.Deductible]])('getSubtotal null line items', (expected, type) => {
test(`Returns ${expected} when there are null items and verified ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
isUnverified: false,
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
currentDeductible: 100,
lineItems: nullLineItems
};
// Act
const result = getSubtotal(order);
// Act
const result = getSubtotal(order);
// Assert
expect(result).toBe(0);
// Assert
expect(result).toBe(expected);
});
});
test('Returns 0 when there are no items', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: true
},
lineItems: emptyLineItems
};
describe.each([
[0, coverageType.ITAC],
[0, coverageType.NO_COMP],
[100, coverageType.Deductible]])('getSubtotal no line items', (expected, type) => {
test(`Returns ${expected} when there are no items and verified ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
isUnverified: false,
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
currentDeductible: 100,
lineItems: emptyLineItems
};
// Act
const result = getSubtotal(order);
// Act
const result = getSubtotal(order);
// Assert
expect(result).toBe(0);
// Assert
expect(result).toBe(expected);
});
});
test('Returns sub total of deductible + vaps + fee line items when verified deductible', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: false,
isITAC: false
},
currentDeductible: 100,
lineItems: defaultLineItems
};
describe.each([
[330, coverageType.ITAC],
[330, coverageType.NO_COMP],
[310, coverageType.Deductible]])('getSubtotal with line items', (expected, type) => {
test(`Returns ${expected} cart subtotal when verified ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
isUnverified: false,
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
currentDeductible: 100,
lineItems: defaultLineItems
};
// Act
const result = getSubtotal(order);
// Act
const result = getSubtotal(order);
// Assert
expect(result).toBe(310);
});
test('Returns sub total of all line items when verified no comp', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: true,
isITAC: false
},
currentDeductible: 0,
lineItems: defaultLineItems
};
// Act
const result = getSubtotal(order);
// Assert
expect(result).toBe(330);
});
test('Returns sub total of all line items when verified ITAC', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: false,
isITAC: true
},
currentDeductible: 0,
lineItems: defaultLineItems
};
// Act
const result = getSubtotal(order);
// Assert
expect(result).toBe(330);
// Assert
expect(result).toBe(expected);
});
});
});
describe('getSalesTax', () => {
test('Returns 0 when there are null items', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: true
},
lineItems: nullLineItems
};
describe.each([
[0, coverageType.ITAC],
[0, coverageType.NO_COMP],
[0, coverageType.Deductible]])('getSalesTax null items', (expected, type) => {
test(`Returns ${expected} when there are null items and coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
isUnverified: false,
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
lineItems: nullLineItems
};
// Act
const result = getSalesTax(order);
// Act
const result = getSalesTax(order);
// Assert
expect(result).toBe(0);
// Assert
expect(result).toBe(expected);
});
});
test('Returns 0 when there are no items', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: true
},
lineItems: emptyLineItems
};
describe.each([
[0, coverageType.ITAC],
[0, coverageType.NO_COMP],
[0, coverageType.Deductible]])('getSalesTax with no items', (expected, type) => {
test(`Returns ${expected} when there are no items and coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
isUnverified: false,
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
lineItems: emptyLineItems
};
// Act
const result = getSalesTax(order);
// Act
const result = getSalesTax(order);
// Assert
expect(result).toBe(0);
// Assert
expect(result).toBe(expected);
});
});
test('Returns sales tax vaps + fee line items when verified', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: false,
isITAC: false
},
currentDeductible: 100,
lineItems: defaultLineItems
};
describe.each([
[21, coverageType.ITAC],
[21, coverageType.NO_COMP],
[15, coverageType.Deductible]])('getSalesTax with line items', (expected, type) => {
test(`Returns ${expected} when coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
isUnverified: false,
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
lineItems: defaultLineItems
};
// Act
const result = getSalesTax(order);
// Act
const result = getSalesTax(order);
// Assert
expect(result).toBe(15);
});
test('Returns sales tax of all line items when verified no comp', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: true,
isITAC: false
},
currentDeductible: 0,
lineItems: defaultLineItems
};
// Act
const result = getSalesTax(order);
// Assert
expect(result).toBe(21);
});
test('Returns sales tax of all line items when verified ITAC', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: false,
isITAC: true
},
currentDeductible: 0,
lineItems: defaultLineItems
};
// Act
const result = getSalesTax(order);
// Assert
expect(result).toBe(21);
// Assert
expect(result).toBe(expected);
});
});
});
describe('getCartTotal', () => {
test('Returns 0 when there are null items', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: true
},
lineItems: nullLineItems
};
describe.each([
[0, coverageType.ITAC],
[0, coverageType.NO_COMP],
[100, coverageType.Deductible]
])('getCartTotal null items', (expected, type) => {
test(`Returns ${expected} when there are null items and coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
isUnverified: false,
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
currentDeductible: 100,
lineItems: nullLineItems
};
// Act
const result = getCartTotal(order);
// Act
const result = getCartTotal(order);
// Assert
expect(result).toBe(0);
// Assert
expect(result).toBe(expected);
});
});
test('Returns 0 when there are no items', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: true
},
lineItems: emptyLineItems
};
describe.each([
[0, coverageType.ITAC],
[0, coverageType.NO_COMP],
[100, coverageType.Deductible]
])('getCartTotal no items', (expected, type) => {
test(`Returns ${expected} when there are no items and coverageType is ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
isUnverified: false,
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
currentDeductible: 100,
lineItems: emptyLineItems
};
// Act
const result = getCartTotal(order);
// Act
const result = getCartTotal(order);
// Assert
expect(result).toBe(0);
// Assert
expect(result).toBe(expected);
});
});
test('Returns total of vaps + fee line items when verified', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: false,
isITAC: false
},
currentDeductible: 100,
lineItems: defaultLineItems
};
describe.each([
[351, coverageType.ITAC],
[351, coverageType.NO_COMP],
[325, coverageType.Deductible]
])('getCartTotal items', (expected, type) => {
test(`Returns ${expected} cart total when verified ${getEnumName(coverageType, type)}`, () => {
// Arrange
const order = {
isUnverified: false,
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
currentDeductible: 100,
lineItems: defaultLineItems
};
// Act
const result = getCartTotal(order);
// Act
const result = getCartTotal(order);
// Assert
expect(result).toBe(325);
});
test('Returns total of all line items when verified no comp', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: true,
isITAC: false
},
currentDeductible: 0,
lineItems: defaultLineItems
};
// Act
const result = getCartTotal(order);
// Assert
expect(result).toBe(351);
});
test('Returns total of all line items when verified ITAC', () => {
// Arrange
const order = {
isUnverified: false,
policy: {
noCoverage: false,
isITAC: true
},
currentDeductible: 0,
lineItems: defaultLineItems
};
// Act
const result = getCartTotal(order);
// Assert
expect(result).toBe(351);
// Assert
expect(result).toBe(expected);
});
});
});
});

5
src/helpers/data-generation.js
View file

@ -26,3 +26,8 @@ export function getRandomString(minLength = 1, maxLength = 100) {
}
return result;
}
export function getRandomEnum(type) {
const keys = Object.keys(type);
return type[keys[getRandomInt(0, keys.length)]];
}

10
src/helpers/unit-test-helper.js
View file

@ -92,6 +92,16 @@ export function setupMocksForJsFiles() {
return { baseMixin };
}
export function getEnumName(object, value) {
for (const field in object) {
if (object[field] === value) {
return field;
}
}
return undefined;
}
// Private methods
/*

13
src/iss-components/cart-dropdown/__snapshots__/cart-dropdown.spec.js.snap
View file

@ -44,6 +44,11 @@ Object {
"partQuestionAnswers": null,
},
"eon": null,
"insuranceCoverage": Object {
"claimNumber": null,
"coverageStatus": 0,
"coverageType": 0,
},
"lineItems": Object {
"feeItems": Array [],
"glassParts": null,
@ -70,11 +75,6 @@ Object {
"transReferenceNumber": null,
"transactionId": null,
},
"insuranceCoverage": Object {
"claimNumber": null,
"coverageStatus": 0,
"isVerified": false,
},
"isPayInAdvance": null,
"parentAccountNumber": 0,
"payInAdvanceType": null,
@ -92,10 +92,7 @@ Object {
"endorsementQuestionAnswers": Array [],
"endorsements": Array [],
"isDamageGlassOnly": null,
"isITAC": false,
"noCoverage": null,
"policyData": null,
"policyLookupSuccessful": null,
"policyNumber": null,
"policyZipCode": null,
"status": null,

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

@ -10,6 +10,8 @@ import partTypeStrings from '@/constants/part-type-strings';
import partNumberStrings from '@/constants/part-number-strings';
import { getHighestFullySatisfiedTier, getPackageContents } from '@/helpers/service-package-helper.js';
import { getPriceOfLineItems } from '@/helpers/price-calculator.js';
import coverageStatuses from "@/constants/coverage-statuses";
import coverageType from "@/constants/coverage-type";
const VERIFYING_COVERAGE = 'Verifying coverage';
@ -125,11 +127,9 @@ describe('cart-dropdown component', () => {
const initialData = { isExpanded };
const storeData = {
order: {
payment: {
insuranceCoverage: { isVerified: true }
},
policy: {
isITAC: false
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
}
}
};
@ -150,12 +150,9 @@ describe('cart-dropdown component', () => {
order: {
currentDeductible: 0,
lineItems: { },
payment: {
insuranceCoverage: { isVerified: true }
},
policy: {
isITAC: true,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.ITAC
}
},
issConfig: {
@ -303,12 +300,9 @@ describe('cart-dropdown component', () => {
order: {
currentDeductible: 0,
lineItems: { },
payment: {
insuranceCoverage: { isVerified: true }
},
policy: {
isITAC: true,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.ITAC
}
},
issConfig: {
@ -330,11 +324,9 @@ describe('cart-dropdown component', () => {
const initialData = { isExpanded };
const storeData = {
order: {
payment: {
insuranceCoverage: { isVerified: true }
},
policy: {
isITAC: false
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
}
}
};
@ -1322,9 +1314,9 @@ describe('cart-dropdown component', () => {
// Arrange
const storeData = {
order: {
policy: {
noCoverage: false,
isITAC: false
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: null
}
@ -1343,9 +1335,9 @@ describe('cart-dropdown component', () => {
// Arrange
const storeData = {
order: {
policy: {
noCoverage: false,
isITAC: false
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.NONE
},
currentDeductible: 321
}
@ -1364,13 +1356,9 @@ describe('cart-dropdown component', () => {
// Arrange
const storeData = {
order: {
payment: {
insuranceCoverage: { isVerified: true }
},
policy: {
isITAC: true,
noCoverage: false,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.ITAC
},
currentDeductible: 321
}
@ -1390,13 +1378,9 @@ describe('cart-dropdown component', () => {
// Arrange
const storeData = {
order: {
payment: {
insuranceCoverage: { isVerified: true }
},
policy: {
isITAC: false,
noCoverage: true,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.NO_COMP
},
currentDeductible: 321
},
@ -1419,13 +1403,9 @@ describe('cart-dropdown component', () => {
// Arrange
const storeData = {
order: {
payment: {
insuranceCoverage: { isVerified: true }
},
policy: {
isITAC: false,
noCoverage: true,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.NO_COMP
},
currentDeductible: 321
},
@ -1446,16 +1426,11 @@ describe('cart-dropdown component', () => {
// Arrange
const storeData = {
order: {
policy: {
isITAC: false,
noCoverage: false,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: 321,
policyLookupSuccessful: true,
payment: {
insuranceCoverage: { isVerified: true }
}
}
};
const { wrapper } = getMountedComponent(storeData);

2
src/layouts/coverage-statement/__snapshots__/coverage-statement.spec.js.snap
View file

@ -1,6 +1,6 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`coverageStatement.vue-working returns the initial data 1`] = `
exports[`coverageStatement.vue returns the initial data 1`] = `
Object {
"baseServiceLineItems": Array [],
"deductibleText": "Your deductible is",

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

@ -4,14 +4,17 @@ import coverageStatement from '@/layouts/coverage-statement/coverage-statement.v
// Supporting Files
import { nextTick } from 'vue';
import { shallowMount } from '@vue/test-utils';
import { getMountOptions } from '@/helpers/unit-test-helper.js';
import { getEnumName, getMountOptions } from '@/helpers/unit-test-helper.js';
import { createTestingPinia } from '@pinia/testing';
import navigationScenarios from '@/router/router-constants/navigation-scenarios.js';
import { getRandomString, getRandomInt } from '@/helpers/data-generation.js';
import settleAllPromises from '@/helpers/layout-helper.js';
import { fetchCmsContentForPage } from '@/helpers/cms-content-helper';
import { useMainStore, getDefaultState } from '@/store';
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', () => ({
@ -92,15 +95,7 @@ function getMountedComponent(mainInitialState = {}, initialData = {}, methodToRu
return { wrapper };
}
beforeEach(() => {
const store = useMainStore();
const defaultState = getDefaultState();
Object.keys(defaultState).forEach((key) => {
store[key] = defaultState[key];
});
});
describe('coverageStatement.vue-working', () => {
describe('coverageStatement.vue', () => {
test('returns the initial data', () => {
// Arrange
const mainInitialState = {
@ -108,9 +103,9 @@ describe('coverageStatement.vue-working', () => {
damage: {
isRepair: true
},
policy: {
noCoverage: false,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.Deductible
}
}
};
@ -173,16 +168,20 @@ describe('coverageStatement.vue-working', () => {
});
});
describe('Computed', () => {
describe('verifiedNoComp', () => {
describe('isNoCompQuoteVisible true', () => {
const enableNoCompQuote = true;
test.each([true, false])('returns false when policyLookupSuccessful false', (isNoComp) => {
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)}`, () => {
// Arrange
const mainInitialState = {
order: {
policy: {
noCoverage: isNoComp,
policyLookupSuccessful: false
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
}
},
issConfig: { enableNoCompQuote }
@ -193,340 +192,156 @@ describe('coverageStatement.vue-working', () => {
const result = wrapper.vm.isNoCompQuoteVisible;
// Assert
expect(result).toBeFalsy();
expect(result).toBe(expected);
});
test.each([true, false])('returns false when isNoComp false', (policyLookupSuccessful) => {
// Arrange
const mainInitialState = {
order: {
policy: {
noCoverage: false,
policyLookupSuccessful
}
},
issConfig: { enableNoCompQuote }
};
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isNoCompQuoteVisible;
// Assert
expect(result).toBeFalsy();
});
test('returns true when policyLookupSuccessful true, noCoverage true, and enableNoCompQuote true', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
noCoverage: true,
policyLookupSuccessful: true
}
},
issConfig: { enableNoCompQuote }
};
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isNoCompQuoteVisible;
// Assert
expect(result).toBeTruthy();
});
});
test('returns false when policyLookupSuccessful true, noCoverage true and enableNoCompQuote false', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
noCoverage: true,
policyLookupSuccessful: true
}
},
issConfig: {
enableNoCompQuote: false
}
};
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isNoCompQuoteVisible;
// Assert
expect(result).toBeFalsy();
});
});
describe('isITACQuoteVisible', () => {
const priceOfLineItems = 213;
test.each([true, false])('returns false when policyLookupSuccessful false', (isNoComp) => {
// Arrange
const mainInitialState = {
order: {
policy: {
noCoverage: isNoComp,
policyLookupSuccessful: false
},
currentDeductible: priceOfLineItems + 1
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isITACQuoteVisible;
// Assert
expect(result).toBeFalsy();
});
test.each([true, false])('returns false when isNoComp true', (policyLookupSuccessful) => {
// Arrange
const mainInitialState = {
order: {
policy: {
noCoverage: true,
policyLookupSuccessful
},
currentDeductible: priceOfLineItems + 1
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isITACQuoteVisible;
// Assert
expect(result).toBeFalsy();
});
test.each([
[true, false],
[true, true],
[false, false],
[false, true]
])('returns false when deductibleValue equals totalServicePrice', (noCoverage, policyLookupSuccessful) => {
// Arrange
const mainInitialState = {
order: {
policy: {
noCoverage,
policyLookupSuccessful
},
currentDeductible: priceOfLineItems
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isITACQuoteVisible;
// Assert
expect(result).toBeFalsy();
});
test.each([
[true, false],
[true, true],
[false, false],
[false, true]
])(
'returns false when deductibleValue less than totalServicePrice when noCoverage is %p and policyLookupSuccessful is %p',
(noCoverage, policyLookupSuccessful) => {
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}`, () => {
// Arrange
const mainInitialState = {
order: {
policy: {
noCoverage,
policyLookupSuccessful
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: type
},
currentDeductible: priceOfLineItems - 1
currentDeductible: deductible
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
getPriceOfLineItems.mockReturnValue(priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isITACQuoteVisible;
// Assert
expect(result).toBeFalsy();
}
);
test('returns true when deductibleValue more than totalServicePrice, noComp is false, and policyLookupSuccessful true', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
noCoverage: false,
policyLookupSuccessful: true
},
currentDeductible: priceOfLineItems + 1
}
};
getPriceOfLineItems.mockImplementationOnce(() => priceOfLineItems);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isITACQuoteVisible;
// Assert
expect(result).toBeTruthy();
expect(result).toBe(expected);
});
});
});
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}`, () => {
// 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
const result = wrapper.vm.isDeductibleVisible;
// Assert
expect(result).toBe(expected);
});
});
});
describe('isDeductibleVisible', () => {
const servicePrice = 123;
describe('claim registration required', () => {
const issConfig = { isClaimRegistrationRequired: true };
let verifiedDeductibleStoreState;
beforeEach(() => {
verifiedDeductibleStoreState = {
issConfig,
order: {
payment: {
insuranceCoverage: {
isVerified: true
}
},
policy: {
noCoverage: false,
policyLookupSuccessful: true
},
currentDeductible: servicePrice - 1
}
};
getPriceOfLineItems.mockImplementation(() => servicePrice);
});
test('returns false when deductible is null', () => {
// Arrange
const mainInitialState = verifiedDeductibleStoreState;
mainInitialState.order.currentDeductible = null;
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isDeductibleVisible;
// Assert
expect(result).toBeFalsy();
});
test('returns false when register claim not successful', () => {
// Arrange
const mainInitialState = verifiedDeductibleStoreState;
mainInitialState.order.payment.insuranceCoverage.isVerified = false;
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isDeductibleVisible;
// Assert
expect(result).toBeFalsy();
});
test('returns true when register claim successful, isNoComp false, and service price over deductible', () => {
// Arrange
const { wrapper } = getMountedComponent(verifiedDeductibleStoreState);
// Act
const result = wrapper.vm.isDeductibleVisible;
// Assert
expect(result).toBeTruthy();
});
});
describe('claim registration not required', () => {
const issConfig = { isClaimRegistrationRequired: false };
let verifiedDeductibleStoreState;
beforeEach(() => {
verifiedDeductibleStoreState = {
issConfig,
order: {
payment: {
insuranceCoverage: {
isVerified: false
}
},
policy: {
noCoverage: false,
policyLookupSuccessful: true
},
currentDeductible: servicePrice - 1
}
};
});
test('returns false when policy lookup not successful', () => {
// Arrange
const mainInitialState = verifiedDeductibleStoreState;
mainInitialState.order.policy.policyLookupSuccessful = false;
const { wrapper } = getMountedComponent(mainInitialState);
// Act
const result = wrapper.vm.isDeductibleVisible;
// Assert
expect(result).toBeFalsy();
});
test('returns true when policyLookupSuccessful, isNoComp false, and deductible over service price', () => {
// Arrange
const { wrapper } = getMountedComponent(verifiedDeductibleStoreState);
// Act
const result = wrapper.vm.isDeductibleVisible;
// Assert
expect(result).toBeTruthy();
});
});
test('returns false when isNoComp true', () => {
// Arrange
const isNoComp = true;
const storeState = {
issConfig: {
isClaimRegistrationRequired: false
const verifiedDeductibleStoreState = {
issConfig : {
isClaimRegistrationRequired: true
},
order: {
payment: {
insuranceCoverage: {
isVerified: true
}
},
policy: {
noCoverage: isNoComp,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: servicePrice - 1
}
};
const { wrapper } = getMountedComponent(storeState);
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;
// Act
const result = wrapper.vm.isDeductibleVisible;
// Assert
expect(result).toBeFalsy();
});
test('returns false when service price below deductible', () => {
// Arrange
const storeState = {
issConfig: {
isClaimRegistrationRequired: false
},
order: {
payment: {
insuranceCoverage: {
isVerified: true
}
},
policy: {
noCoverage: false,
policyLookupSuccessful: true
},
currentDeductible: servicePrice + 1
}
};
const { wrapper } = getMountedComponent(storeState);
// 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;
// Assert
expect(result).toBeFalsy();
// Act
const result = wrapper.vm.isDeductibleVisible;
// Assert
expect(result).toBeFalsy();
});
});
});
describe('isADAS', () => {
@ -622,8 +437,9 @@ describe('coverageStatement.vue-working', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
policyLookupSuccessful: false
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.NONE
}
}
};
@ -641,9 +457,9 @@ describe('coverageStatement.vue-working', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
policyLookupSuccessful: true,
noCoverage: false
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: priceOfLineItems
}
@ -661,9 +477,9 @@ describe('coverageStatement.vue-working', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
policyLookupSuccessful: true,
noCoverage: false
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: priceOfLineItems - 1
}
@ -681,9 +497,9 @@ describe('coverageStatement.vue-working', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
policyLookupSuccessful: true,
noCoverage: false
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: priceOfLineItems + 1
}
@ -704,9 +520,9 @@ describe('coverageStatement.vue-working', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
policyLookupSuccessful: true,
noCoverage: false
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: priceOfLineItems
}
@ -724,9 +540,9 @@ describe('coverageStatement.vue-working', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
policyLookupSuccessful: true,
noCoverage: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.NO_COMP
},
currentDeductible: priceOfLineItems
},
@ -747,9 +563,9 @@ describe('coverageStatement.vue-working', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
policyLookupSuccessful: true,
noCoverage: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.NO_COMP
},
currentDeductible: priceOfLineItems
},
@ -774,14 +590,10 @@ describe('coverageStatement.vue-working', () => {
beforeEach(() => {
shouldRegisterClaimStoreStateItac = {
order: {
payment: {
insuranceCoverage: {
claimNumber: null
}
},
policy: {
policyLookupSuccessful: true,
noCoverage: false
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible,
claimNumber: null
},
vehicle: {
policyVehicleId
@ -798,7 +610,7 @@ describe('coverageStatement.vue-working', () => {
test('returns false when policy lookup not successful', () => {
// Arrange
const mainInitialState = shouldRegisterClaimStoreStateItac;
mainInitialState.order.policy.policyLookupSuccessful = false;
mainInitialState.order.insuranceCoverage.coverageType = coverageType.NONE;
const { wrapper } = getMountedComponent(mainInitialState);
// Act
@ -846,7 +658,7 @@ describe('coverageStatement.vue-working', () => {
test('returns false when claim already registered', () => {
// Arrange
const mainInitialState = shouldRegisterClaimStoreStateItac;
mainInitialState.order.payment.insuranceCoverage.claimNumber = 13;
mainInitialState.order.insuranceCoverage.claimNumber = '13';
const { wrapper } = getMountedComponent(mainInitialState);
// Act
@ -948,8 +760,9 @@ describe('coverageStatement.vue-working', () => {
damage: {
isRepair: true
},
policy: {
policyLookupSuccessful: false
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.NONE
},
currentDeductible: null
}
@ -974,9 +787,9 @@ describe('coverageStatement.vue-working', () => {
damage: {
isRepair: true
},
policy: {
noCoverage: false,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: deductible
}
@ -1001,9 +814,9 @@ describe('coverageStatement.vue-working', () => {
damage: {
isRepair: true
},
policy: {
noCoverage: false,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.ITAC,
},
currentDeductible: deductible
}
@ -1031,9 +844,9 @@ describe('coverageStatement.vue-working', () => {
damage: {
isRepair: true
},
policy: {
noCoverage: false,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.ITAC,
},
currentDeductible: deductible
}
@ -1060,10 +873,10 @@ describe('coverageStatement.vue-working', () => {
damage: {
isRepair: true
},
policy: {
noCoverage: true,
policyLookupSuccessful: true
}
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.NO_COMP,
},
},
issConfig: {
enableNoCompQuote: true
@ -1091,9 +904,9 @@ describe('coverageStatement.vue-working', () => {
damage: {
isRepair: true
},
policy: {
noCoverage: true,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.NO_COMP
}
},
issConfig: {
@ -1122,22 +935,25 @@ describe('coverageStatement.vue-working', () => {
// Arrange
const mainInitialState = {
order: {
policy: {
isITAC: null
}
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: 666
}
};
const mockStoreActions = () => {
useMainStore().getPriceOrderItems = jest.fn().mockImplementation(() => Promise.resolve([]));
};
const { wrapper } = getMountedComponent(mainInitialState, {}, mockStoreActions);
getPriceOfLineItems.mockReturnValue(333);
const { wrapper } = getMountedComponent(mainInitialState);
// Act
wrapper.vm.initializeComponent();
await wrapper.vm.initializeComponent();
// Assert
expect(wrapper.vm.mainStore.updatePolicyITACFlag)
expect(wrapper.vm.mainStore.updateCoverageType)
.toHaveBeenCalledTimes(1);
expect(wrapper.vm.mainStore.updateCoverageType)
.toHaveBeenCalledWith(coverageType.ITAC);
});
it('Loaded duplicate with previously registered claim => claim registration is not called', async () => {
@ -1146,20 +962,18 @@ describe('coverageStatement.vue-working', () => {
const deductible = sellingPrice - 1;
const initialStore = {
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible,
claimNumber: getRandomString(10, 10)
},
policy: {
policyLookupSuccessful: true,
noCoverage: false,
deductible: {
repair: deductible
}
},
damage: {
isRepair: false
},
payment: {
insuranceCoverage: {
claimNumber: getRandomString(10, 10)
}
}
},
issConfig: {
@ -1225,16 +1039,10 @@ describe('coverageStatement.vue-working', () => {
const deductible = servicePrice - 1;
const initialStore = {
order: {
payment: {
insuranceCoverage: {
claimNumber: null,
isVerified: true
}
},
policy: {
noCoverage: false,
isITAC: false,
policyLookupSuccessful: true
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.Deductible,
claimNumber: null
},
vehicle: {
policyVehicleId: 1
@ -1255,14 +1063,8 @@ describe('coverageStatement.vue-working', () => {
const { wrapper } = getMountedComponent(initialStore, {}, mockStoreActions);
const next = (method) => { method(wrapper.vm); };
console.log(wrapper.vm.pageVariation);
// Act
coverageStatement.beforeRouteEnter.call(wrapper.vm, undefined, undefined, next);
for (let i = 0; i < 7; i++) {
// eslint-disable-next-line no-await-in-loop
await nextTick();
}
await coverageStatement.beforeRouteEnter.call(wrapper.vm, undefined, undefined, next);
// Assert
expect(wrapper.vm.mainStore.registerClaim).toHaveBeenCalled();

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

@ -121,11 +121,12 @@ import baseFormMixin from '@/mixins/base-form-mixin.js';
import navigationScenarios from '@/router/router-constants/navigation-scenarios.js';
import issPageValues from '@/router/router-constants/issPage-values';
import bailoutMessage from '@/constants/bailoutMessage';
import coverageStatuses from '@/constants/coverage-statuses';
import widgetFields from '@/constants/cms-widget-fields.js';
import { formatAmountInDollars } from '@/helpers/text-helper.js';
import showIssLoadingModal from '@/helpers/loading-modal-helper';
import { getPriceOfLineItems } from '@/helpers/price-calculator';
import coverageType from '@/constants/coverage-type';
import coverageStatuses from '@/constants/coverage-statuses';
const SAFELITE_PROVIDER = 'Safelite';
@ -173,8 +174,8 @@ export default {
let hasBailedOut = false;
let pricingResults = [];
const { policy, vehicle } = useMainStore();
if (policy.policyLookupSuccessful && vehicle.policyVehicleId >= 0) {
const { vehicle, isPolicyLookupSuccessful } = useMainStore();
if (isPolicyLookupSuccessful && vehicle.policyVehicleId >= 0) {
await useMainStore().getFinalDeductible();
pricingResults = await useMainStore()
.getPriceOrderItems(availableLineItems)
@ -194,19 +195,23 @@ export default {
if (!hasBailedOut) {
// Call the "next" function to complete the transition to this page.
next((vm) => {
next(async (vm) => {
showIssLoadingModal(true);
vm.setCmsContent(resultMap.cmsContent);
vm.setSupportingItems(resultMap.supportingItems);
// eslint-disable-next-line no-param-reassign
vm.setBaseServiceLineItems(pricingResults);
vm.initializeComponent();
await vm.initializeComponent();
if (!vm.unverified) {
useMainStore().disableKeyFields();
}
});
}
},
setup() {
const mainStore = useMainStore();
return { mainStore };
},
data() {
return {
baseServiceLineItems: [],
@ -231,14 +236,13 @@ export default {
const {
isNoComp,
issConfig,
policy,
payment,
isClaimRegistrationRequired
isClaimRegistrationRequired,
isPolicyLookupSuccessful,
isVerified,
isUnverified
} = useMainStore();
const registerClaimSuccessful =
payment.insuranceCoverage.isVerified;
if (!policy.policyLookupSuccessful) {
if (!isPolicyLookupSuccessful) {
return pageVariations.UNVERIFIED;
}
@ -249,7 +253,7 @@ export default {
return pageVariations.UNVERIFIED;
}
if (this.deductibleValue == null) {
if (isUnverified) {
return pageVariations.UNVERIFIED;
}
@ -260,13 +264,10 @@ export default {
return pageVariations.ITAC;
}
if (isClaimRegistrationRequired) {
if (registerClaimSuccessful) {
return pageVariations.DEDUCTIBLE;
}
return pageVariations.UNVERIFIED;
if (!isClaimRegistrationRequired || isVerified) {
return pageVariations.DEDUCTIBLE;
}
return pageVariations.DEDUCTIBLE;
return pageVariations.UNVERIFIED;
},
coverageStatementSubHeader() {
return this.getTextFromCmsWithCustomIfStatements(
@ -363,14 +364,14 @@ export default {
},
shouldRegisterClaim() {
const {
policy,
vehicle,
isClaimRegistrationRequired,
isClaimAlreadyRegistered
isClaimAlreadyRegistered,
isPolicyLookupSuccessful
} = useMainStore();
const { policyVehicleId } = vehicle;
return (
policy.policyLookupSuccessful
isPolicyLookupSuccessful
&& policyVehicleId != null
&& policyVehicleId >= 0
&& isClaimRegistrationRequired
@ -401,17 +402,14 @@ export default {
return !!useMainStore().vehicle.carId;
},
async initializeComponent() {
useMainStore().updatePolicyITACFlag(this.isITACQuoteVisible);
// TODO how should coverage status be updated
const coverageStatus =
this.isITACQuoteVisible || this.isNoCompQuoteVisible
? coverageStatuses.VERIFIED
: coverageStatuses.PENDING;
useMainStore().updateCoverageStatus(coverageStatus);
if (this.isNoCompQuoteVisible) {
this.mainStore.updateCoverageStatus(coverageStatuses.VERIFIED);
}
if (this.shouldRegisterClaim) {
await useMainStore()
.registerClaim()
?.catch(() => {});
await this.mainStore.registerClaim();
}
if (this.isITACQuoteVisible) {
this.mainStore.updateCoverageType(coverageType.ITAC);
}
showIssLoadingModal(false);
},

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

@ -11,6 +11,8 @@ import { getRandomString } from '@/helpers/data-generation.js';
import { useMainStore } from '@/store';
import settleAllPromises from '@/helpers/layout-helper.js';
import { fetchCmsContentForPage } from '@/helpers/cms-content-helper';
import coverageStatuses from '@/constants/coverage-statuses';
import coverageType from '@/constants/coverage-type';
// Mock fetchCmsContentForPage
jest.mock('@/helpers/cms-content-helper', () => ({
@ -420,12 +422,15 @@ describe('duplicateCheck.vue', () => {
expect(wrapper.vm.mainStore.loadSession).toHaveBeenCalledTimes(1);
expect(wrapper.vm.$router.navigate).toHaveBeenCalledTimes(1);
});
test('policyLookupSuccessful true and policy vehicles returned => CLICKED_FORWARD_POLICY_VERIFIED_WITH_VEHICLES', async () => {
test('coverageType deductible and policy vehicles returned => CLICKED_FORWARD_POLICY_VERIFIED_WITH_VEHICLES', async () => {
// Arrange
const { wrapper } = getMountedComponent({
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.Deductible
},
policy: {
policyLookupSuccessful: true,
vehicles: [{ test: 'a' }]
}
}
@ -439,12 +444,15 @@ describe('duplicateCheck.vue', () => {
expect(wrapper.vm.$router.navigate)
.toHaveBeenCalledWith(navigationScenarios.CLICKED_FORWARD_POLICY_VERIFIED_WITH_VEHICLES, undefined);
});
test('policyLookupSuccessful true and no policy vehicles returned => CLICKED_FORWARD_POLICY_VERIFIED_NO_VEHICLES', async () => {
test('coverageType deductible and no policy vehicles returned => CLICKED_FORWARD_POLICY_VERIFIED_NO_VEHICLES', async () => {
// Arrange
const { wrapper } = getMountedComponent({
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.Deductible
},
policy: {
policyLookupSuccessful: true,
vehicles: []
}
}
@ -458,12 +466,13 @@ describe('duplicateCheck.vue', () => {
expect(wrapper.vm.$router.navigate)
.toHaveBeenCalledWith(navigationScenarios.CLICKED_FORWARD_POLICY_VERIFIED_NO_VEHICLES, undefined);
});
test('policyLookupSuccessful false => CLICKED_FORWARD_POLICY_UNVERIFIED', async () => {
test('coverageType none false => CLICKED_FORWARD_POLICY_UNVERIFIED', async () => {
// Arrange
const { wrapper } = getMountedComponent({
order: {
policy: {
policyLookupSuccessful: false
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.NONE
}
}
});
@ -477,13 +486,16 @@ describe('duplicateCheck.vue', () => {
.toHaveBeenCalledWith(navigationScenarios.CLICKED_FORWARD_POLICY_UNVERIFIED, undefined);
});
// eslint-disable-next-line max-len
test('policyLookupSuccessful true and loaded duplicate with policy vehicle => CLICKED_FORWARD_LOADED_DUPLICATE_WITH_POLICY_VEHICLE', async () => {
test('coverageType deductible and loaded duplicate with policy vehicle => CLICKED_FORWARD_LOADED_DUPLICATE_WITH_POLICY_VEHICLE', async () => {
// Arrange
const vin = getRandomString(17, 17);
const { wrapper } = getMountedComponent({
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.Deductible
},
policy: {
policyLookupSuccessful: true,
vehicles: [{ vin }]
},
vehicle: {
@ -502,13 +514,16 @@ describe('duplicateCheck.vue', () => {
.toHaveBeenCalledWith(navigationScenarios.CLICKED_FORWARD_LOADED_DUPLICATE_WITH_POLICY_VEHICLE, undefined);
});
// eslint-disable-next-line max-len
test('policyLookupSuccessful true and loaded duplicate with non policy vehicle => CLICKED_FORWARD_LOADED_DUPLICATE_WITH_NON_POLICY_VEHICLE', async () => {
test('coverageType deductible and loaded duplicate with non policy vehicle => CLICKED_FORWARD_LOADED_DUPLICATE_WITH_NON_POLICY_VEHICLE', async () => {
// Arrange
const vin = getRandomString(17, 17);
const { wrapper } = getMountedComponent({
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.Deductible
},
policy: {
policyLookupSuccessful: true,
vehicles: [{ vin }]
},
vehicle: {
@ -527,12 +542,15 @@ describe('duplicateCheck.vue', () => {
.toHaveBeenCalledWith(navigationScenarios.CLICKED_FORWARD_LOADED_DUPLICATE_WITH_NON_POLICY_VEHICLE, undefined);
});
// eslint-disable-next-line max-len
test('policyLookupSuccessful true and loaded duplicate with no policy vehicles => CLICKED_FORWARD_LOADED_DUPLICATE_WITH_NO_POLICY_VEHICLES', async () => {
test('coverageType deductible and loaded duplicate with no policy vehicles => CLICKED_FORWARD_LOADED_DUPLICATE_WITH_NO_POLICY_VEHICLES', async () => {
// Arrange
const { wrapper } = getMountedComponent({
order: {
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.Deductible
},
policy: {
policyLookupSuccessful: true,
vehicles: []
},
vehicle: {

2
src/layouts/duplicate-check/duplicate-check.vue
View file

@ -155,7 +155,7 @@ export default {
this.navigateForward();
},
navigateForward() {
if (!this.mainStore.order.policy.policyLookupSuccessful) {
if (!this.mainStore.isPolicyLookupSuccessful) {
this.$router.navigate(
this.navigationScenarios.CLICKED_FORWARD_POLICY_UNVERIFIED,
this.$route

154
src/layouts/order-confirmation/order-confirmation.spec.js
View file

@ -9,6 +9,8 @@ import { fetchCmsContentForPage } from '@/helpers/cms-content-helper';
import { mount } from '@vue/test-utils';
import { createTestingPinia } from '@pinia/testing';
import { nextTick } from 'vue';
import coverageStatuses from "@/constants/coverage-statuses";
import coverageType from "@/constants/coverage-type";
jest.mock('@/helpers/layout-helper.js', () => jest.fn());
@ -70,12 +72,13 @@ const initialStore = {
}
}
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isInsurance: true,
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
contactInfo: {
firstName: 'Test',
@ -110,18 +113,17 @@ const sessionStorage = {
}
}
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
@ -320,18 +322,17 @@ describe('OrderConfirmation.vue', () => {
serviceLocation: {
appointmentType: 'Mobile'
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
window.sessionStorage.setItem('submittedOrder', JSON.stringify(testSessionStorage));
@ -362,18 +363,17 @@ describe('OrderConfirmation.vue', () => {
}
}
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
window.sessionStorage.setItem('submittedOrder', JSON.stringify(testSessionStorage));
@ -412,18 +412,17 @@ describe('OrderConfirmation.vue', () => {
zipCode: '12345',
appointmentType: 'Mobile'
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
window.sessionStorage.setItem('submittedOrder', JSON.stringify(testSessionStorage));
@ -454,18 +453,17 @@ describe('OrderConfirmation.vue', () => {
},
appointmentType: 'Dropoff'
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
window.sessionStorage.setItem('submittedOrder', JSON.stringify(testSessionStorage));
@ -496,18 +494,17 @@ describe('OrderConfirmation.vue', () => {
},
appointmentType: 'Inshop'
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
window.sessionStorage.setItem('submittedOrder', JSON.stringify(testSessionStorage));
@ -535,18 +532,17 @@ describe('OrderConfirmation.vue', () => {
zipCode: '12345',
appointmentType: 'Mobile'
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
window.sessionStorage.setItem('submittedOrder', JSON.stringify(testSessionStorage));
@ -577,18 +573,17 @@ describe('OrderConfirmation.vue', () => {
},
appointmentType: 'Inshop'
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
window.sessionStorage.setItem('submittedOrder', JSON.stringify(testSessionStorage));
@ -616,18 +611,17 @@ describe('OrderConfirmation.vue', () => {
zipCode: '12345',
appointmentType: 'Mobile'
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
window.sessionStorage.setItem('submittedOrder', JSON.stringify(testSessionStorage));
@ -658,18 +652,17 @@ describe('OrderConfirmation.vue', () => {
},
appointmentType: 'Dropoff'
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
window.sessionStorage.setItem('submittedOrder', JSON.stringify(testSessionStorage));
@ -701,18 +694,17 @@ describe('OrderConfirmation.vue', () => {
},
appointmentType: 'Inshop'
},
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
payment: {
isPayInAdvance: false,
insuranceCoverage: {
isVerified: true
}
isPayInAdvance: false
},
lineItems: {
vaps: []
},
policy: {
noCoverage: false
},
policy: {},
damage: {}
};
window.sessionStorage.setItem('submittedOrder', JSON.stringify(testSessionStorage));

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

@ -11,6 +11,8 @@ import { paymentMethods } from '@/constants/payment-method-constants';
import queryStrings from '@/constants/query-strings';
import { experimentSettings } from '@/constants/experiments';
import { submitWorkOrder } from '@/helpers/order-helper.js';
import coverageStatuses from '@/constants/coverage-statuses';
import coverageType from '@/constants/coverage-type';
// Mock so it can be used as an assertion
jest.mock('@/helpers/order-helper.js', () => ({
@ -139,15 +141,9 @@ describe('payment-method.vue', () => {
beforeEach(() => {
store = {
order: {
policy: {
isITAC: false,
noCoverage: false,
policyLookupSuccessful: true
},
payment: {
insuranceCoverage: {
isVerified: true
}
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED,
coverageType: coverageType.Deductible
},
currentDeductible: 123
},
@ -166,9 +162,9 @@ describe('payment-method.vue', () => {
}
};
});
test('returns true when policyLookupSuccessful false', () => {
test('returns true when coverageType none', () => {
// Arrange
store.order.policy.policyLookupSuccessful = false;
store.order.insuranceCoverage.coverageType = coverageType.NONE;
const wrapper = setupMocks({}, store, mixin);
// Act
@ -179,7 +175,7 @@ describe('payment-method.vue', () => {
});
test('returns true when no comp and enableNoCompQuote false', () => {
// Arrange
store.order.policy.noCoverage = true;
store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
store.issConfig.enableNoCompQuote = false;
const wrapper = setupMocks({}, store, mixin);
@ -191,7 +187,6 @@ describe('payment-method.vue', () => {
});
test('returns true when not no comp and currentDeductible null', () => {
// Arrange
store.order.policy.noCoverage = false;
store.order.currentDeductible = null;
const wrapper = setupMocks({}, store, mixin);
@ -203,7 +198,7 @@ describe('payment-method.vue', () => {
});
test('returns true when isClaimRegistrationRequired true and insurance coverage not verified', () => {
// Arrange
store.order.payment.insuranceCoverage.isVerified = false;
store.order.insuranceCoverage.coverageStatus = coverageStatuses.PENDING;
store.issConfig.isClaimRegistrationRequired = true;
const wrapper = setupMocks({}, store, mixin);
@ -215,7 +210,7 @@ describe('payment-method.vue', () => {
});
test('returns false when no comp, enableNoCompQuote true, and currentDeductible null and pia enabled', () => {
// Arrange
store.order.policy.noCoverage = true;
store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
store.issConfig.enableNoCompQuote = true;
store.order.currentDeductible = null;
const wrapper = setupMocks({}, store, mixin);

10
src/layouts/payment-page/payment-page.spec.js
View file

@ -200,13 +200,13 @@ const defaultOrder = {
vaps: [parts.frontWipers],
promos: []
},
insuranceCoverage: {
coverageStatus: null,
coverageType: null,
claimNumber: null
},
payment: {
isInsurance: false,
insuranceCoverage: {
isVerified: null,
coverageStatus: null,
coverageVerificationType: null
},
isPayInAdvance: true,
payInAdvanceType: 'Afterpay',
inactivePromos: []

30
src/layouts/policy-vehicles/policy-vehicles.spec.js
View file

@ -121,9 +121,12 @@ describe('policy-vehicles.vue', () => {
const store = useMainStore();
store.lookupVehicleByVin.mockReturnValue(Promise.resolve(lookupVehicleResponse));
const expectedInput = {
const updateVehicleInput = {
year,
vin,
vin
};
const updateVehicleCoverage = {
noCoverage: true,
deductible: 0,
repairWaived: false,
@ -136,7 +139,8 @@ describe('policy-vehicles.vue', () => {
// Assert
expect(wrapper.vm.bailout).toBeFalsy();
expect(wrapper.vm.policyVinFound).toBeTruthy();
expect(store.updateVehicle).toHaveBeenCalledWith(expectedInput);
expect(store.updateVehicle).toHaveBeenCalledWith(updateVehicleInput);
expect(store.updateVehicleCoverage).toHaveBeenCalledWith(updateVehicleCoverage);
expect(wrapper.vm.$router.navigate).toHaveBeenCalledWith(
navigationScenarios.CLICKED_FORWARD_LISTED_VEHICLE,
undefined,
@ -174,9 +178,12 @@ describe('policy-vehicles.vue', () => {
const store = useMainStore();
store.lookupVehicleByVin.mockReturnValue(Promise.resolve(lookupVehicleResponse));
const expectedInput = {
const updateVehicleInput = {
year,
vin,
vin
};
const updateVehicleCoverage = {
noCoverage: true,
deductible: 0,
repairWaived: false,
@ -187,7 +194,8 @@ describe('policy-vehicles.vue', () => {
await wrapper.vm.forwardButtonAction();
// Assert
expect(store.updateVehicle).toHaveBeenCalledWith(expectedInput);
expect(store.updateVehicle).toHaveBeenCalledWith(updateVehicleInput);
expect(store.updateVehicleCoverage).toHaveBeenCalledWith(updateVehicleCoverage);
expect(wrapper.vm.$router.navigate).toHaveBeenCalledWith(
navigationScenarios.CLICKED_FORWARD_WITH_ENDORSEMENTS,
undefined
@ -225,9 +233,12 @@ describe('policy-vehicles.vue', () => {
const store = useMainStore();
store.lookupVehicleByVin.mockReturnValue(Promise.resolve(lookupVehicleResponse));
const expectedInput = {
const updateVehicleInput = {
year,
vin,
vin
};
const updateVehicleCoverage = {
noCoverage: true,
deductible: 0,
repairWaived: false,
@ -238,7 +249,8 @@ describe('policy-vehicles.vue', () => {
await wrapper.vm.forwardButtonAction();
// Assert
expect(store.updateVehicle).toHaveBeenCalledWith(expectedInput);
expect(store.updateVehicle).toHaveBeenCalledWith(updateVehicleInput);
expect(store.updateVehicleCoverage).toHaveBeenCalledWith(updateVehicleCoverage);
expect(wrapper.vm.$router.navigate).toHaveBeenCalledWith(
navigationScenarios.CLICKED_FORWARD_WITH_ENDORSEMENTS,
undefined

35
src/layouts/policy-vehicles/policy-vehicles.vue
View file

@ -148,9 +148,13 @@ export default {
}
if (vehicle) {
// save selected vehicle to the store
this.mainStore.updateVehicle(vehicle.data);
this.displayGeneric = false;
this.selectedPolicyVehicle = this.policyVehicles.find((p) => p.vin === value);
useMainStore().updateVehicle({
...vehicle.data,
policyVehicleId: this.selectedPolicyVehicle?.id,
vin: value
});
}
}
}
@ -186,10 +190,7 @@ export default {
make: vehicle.vehicleMake || '',
model: vehicle.vehicleModel || '',
style: vehicle.vehicleStyle || '',
vin: vehicle.vin,
noCoverage: this.noCoverageForSelectedVehicle,
deductible: this.deductibleForSelectedVehicle,
repairWaived: this.repairWaivedForSelectedVehicle
vin: vehicle.vin
});
this.policyVinFound = false;
return this.navigateForward();
@ -202,19 +203,17 @@ export default {
return this.navigateForward();
}
this.vehicleFromLookup = Object.assign(
vehicleLookupResponse.data,
{
policyVehicleId: vehicle.id,
vin: this.selectedVehicleVin,
noCoverage: this.noCoverageForSelectedVehicle,
deductible: this.deductibleForSelectedVehicle,
repairWaived: this.repairWaivedForSelectedVehicle,
endorsements: this.endorsementsForSelectedVehicle
}
);
useMainStore().updateVehicle(this.vehicleFromLookup);
useMainStore().updateVehicle({
...vehicleLookupResponse.data,
policyVehicleId: vehicle.id,
vin: this.selectedVehicleVin
});
useMainStore().updateVehicleCoverage({
noCoverage: this.noCoverageForSelectedVehicle,
deductible: this.deductibleForSelectedVehicle,
repairWaived: this.repairWaivedForSelectedVehicle,
endorsements: this.endorsementsForSelectedVehicle
});
}
return this.navigateForward();
},

4
src/layouts/service-location/appointment-type-question/appointment-type-question.vue
View file

@ -73,10 +73,10 @@ export default {
}
},
isITAC() {
return useMainStore().policy.isITAC;
return useMainStore().isITAC;
},
isItacOrNoComp() {
return useMainStore().policy.isITAC || useMainStore().policy.noCoverage;
return this.isITAC || useMainStore().isNoComp;
},
isMobileOnly() {
return this.isServiceableMobile && !this.isServiceableInshop;

4
src/layouts/service-location/mobile-location-modal-questions/mobile-location-modal-questions.vue
View file

@ -171,10 +171,10 @@ export default {
},
computed: {
isITAC() {
return useMainStore().policy.isITAC;
return useMainStore().isITAC;
},
isItacOrNoComp() {
return useMainStore().policy.isITAC || useMainStore().policy.noCoverage;
return this.isITAC || useMainStore().isNoComp;
},
mobileLocationLinkPromptText() {
return this.getCmsContent(this.linkWidgetName, 'HeaderText');

157
src/layouts/tpa-confirmation/tpa-confirmation.spec.js
View file

@ -2,13 +2,14 @@
import tpaConfirmation from '@/layouts/tpa-confirmation/tpa-confirmation.vue';
// Supporting Files
import { getMountOptions } from '@/helpers/unit-test-helper.js';
import { getEnumName, getMountOptions } from '@/helpers/unit-test-helper.js';
import { useMainStore } from '@/store/index.js';
import settleAllPromises from '@/helpers/layout-helper.js';
import { fetchCmsContentForPage } from '@/helpers/cms-content-helper';
import { mount } from '@vue/test-utils';
import { createTestingPinia } from '@pinia/testing';
import bailoutMessage from '@/constants/bailoutMessage';
import coverageStatuses from '@/constants/coverage-statuses';
jest.mock('@/helpers/layout-helper.js', () => jest.fn());
@ -187,8 +188,8 @@ describe('TPAConfirmation.vue', () => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified: false }
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING
}
}
};
@ -203,8 +204,8 @@ describe('TPAConfirmation.vue', () => {
const currentDeductible = '500';
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified: true }
insuranceCoverage: {
coverageStatus: coverageStatuses.VERIFIED
},
currentDeductible
}
@ -219,72 +220,51 @@ describe('TPAConfirmation.vue', () => {
});
describe('Methods', () => {
describe('getCustomValueFromString', () => {
describe('with argument deductibleAboveZero', () => {
test.each([
[false],
[true]
])(
'returns false when isVerified %p and currentDeductible is zero',
(isVerified) => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified }
},
currentDeductible: 0
}
};
const { wrapper } = getMountedComponent(initialStore);
const argument = 'deductibleAboveZero';
describe.each([
[false, coverageStatuses.PENDING, 0],
[false, coverageStatuses.PENDING, 500],
[false, coverageStatuses.NO_COVERAGE, 0],
[false, coverageStatuses.NO_COVERAGE, 500],
[false, coverageStatuses.VERIFIED, 0],
[true, coverageStatuses.VERIFIED, 500]
])('with argument deductibleAboveZero', (expected, status, deductible) => {
test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)} and currentDeductible is ${deductible}`, () => {
// Arrange
const initialStore = {
order: {
insuranceCoverage: {
coverageStatus: status
},
currentDeductible: deductible
}
};
const { wrapper } = getMountedComponent(initialStore);
const argument = 'deductibleAboveZero';
// Act
const result = wrapper.vm.getCustomValueFromString(argument);
// Act
const result = wrapper.vm.getCustomValueFromString(argument);
// Assert
expect(result).toBe(false);
}
);
test.each([
[true, true],
[false, false]
])(
'returns %p when isVerified %p and currentDeductible is not zero',
(expected, isVerified) => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified }
},
currentDeductible: 500
}
};
const { wrapper } = getMountedComponent(initialStore);
const argument = 'deductibleAboveZero';
// Act
const result = wrapper.vm.getCustomValueFromString(argument);
// Assert
expect(result).toBe(expected);
}
);
// Assert
expect(result).toBe(expected);
});
});
describe('with argument zeroDeductible', () => {
test.each([
[true, true],
[false, false]
])(
'returns %p when isVerified is %p currentDeductible is zero',
(expected, isVerified) => {
describe.each([
[false, coverageStatuses.PENDING, 0],
[false, coverageStatuses.PENDING, 500],
[false, coverageStatuses.NO_COVERAGE, 0],
[false, coverageStatuses.NO_COVERAGE, 500],
[true, coverageStatuses.VERIFIED, 0],
[false, coverageStatuses.VERIFIED, 500]
])('with argument zeroDeductible', (expected, status, deductible) => {
test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)} and currentDeductible is ${deductible}`, () => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified }
insuranceCoverage: {
coverageStatus: status
},
currentDeductible: 0
currentDeductible: deductible
}
};
const { wrapper } = getMountedComponent(initialStore);
@ -295,48 +275,23 @@ describe('TPAConfirmation.vue', () => {
// Assert
expect(result).toBe(expected);
}
);
test.each([
[false],
[true]
])(
'returns false when isVerified is %p currentDeductible is not zero',
(isVerified) => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified }
},
currentDeductible: 250
}
};
const { wrapper } = getMountedComponent(initialStore);
const argument = 'zeroDeductible';
// Act
const result = wrapper.vm.getCustomValueFromString(argument);
// Assert
expect(result).toBe(false);
}
);
});
});
});
describe('with argument verifyingCoverage', () => {
test.each([
[true, false],
[false, true]
])(
'with argument verifyingCoverage returns %p when isVerified %p',
(expected, isVerified) => {
describe.each([
[true, coverageStatuses.PENDING],
[true, coverageStatuses.NO_COVERAGE],
[false, coverageStatuses.VERIFIED]
])('with argument zeroDeductible', (expected, status) => {
test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)}`, () => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified }
insuranceCoverage: {
coverageStatus: status
},
currentDeductible: 26
currentDeductible: 123
}
};
const { wrapper } = getMountedComponent(initialStore);
@ -347,8 +302,8 @@ describe('TPAConfirmation.vue', () => {
// Assert
expect(result).toBe(expected);
}
);
});
});
});
});
describe('setBailoutInfo', () => {

2
src/layouts/tpa-confirmation/tpa-confirmation.vue
View file

@ -205,7 +205,7 @@ export default {
);
},
isVerified() {
return useMainStore().order.payment.insuranceCoverage.isVerified;
return useMainStore().isVerified;
},
carrierName() {
return this.mainStore.issConfig.clientName;

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

@ -4,14 +4,15 @@ import { createTestingPinia } from '@pinia/testing';
import tpaSubmit from '@/layouts/tpa-submit/tpa-submit.vue';
// Supporting Files
import { getMountOptions } from '@/helpers/unit-test-helper.js';
import { getEnumName, getMountOptions } from '@/helpers/unit-test-helper.js';
import { useMainStore } from '@/store';
import { fetchCmsContentForPage } from '@/helpers/cms-content-helper';
import settleAllPromises from '@/helpers/layout-helper.js';
import widgetFields from '@/constants/cms-widget-fields.js';
import { toTitleCase, formatAddress, toDisplayPhoneNumber } from '@/helpers/text-helper.js';
import { toTitleCase, formatAddress, toDisplayPhoneNumber, formatAmountInDollars } from '@/helpers/text-helper.js';
import { getDamageDisplayContent } from '@/helpers/damage-review-content-generator.js';
import baseMixin from '@/mixins/base-mixin';
import coverageStatuses from '@/constants/coverage-statuses';
// Mock fetchCmsContentForPage
jest.mock('@/helpers/cms-content-helper', () => ({
@ -76,6 +77,7 @@ beforeEach(() => {
formatAddress.mockClear();
toDisplayPhoneNumber.mockClear();
getDamageDisplayContent.mockClear();
formatAmountInDollars.mockClear();
});
describe('tpa-submit', () => {
@ -557,22 +559,26 @@ describe('tpa-submit', () => {
// Assert
expect(result).toEqual(expected);
});
test.each([
[true, true],
[false, false]
])('isVerified returns %p when store value %p', (expected, storeValue) => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified: storeValue }
}
}
};
const { wrapper } = getMountedComponent(initialStore);
// Assert
expect(wrapper.vm.isVerified).toBe(expected);
describe.each([
[false, coverageStatuses.PENDING],
[true, coverageStatuses.VERIFIED],
[false, coverageStatuses.NO_COVERAGE]
])('isVerified', (expected, status) => {
test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)}`, () => {
// Arrange
const initialStore = {
order: {
insuranceCoverage: {
coverageStatus: status
}
}
};
const { wrapper } = getMountedComponent(initialStore);
// Assert
expect(wrapper.vm.isVerified).toBe(expected);
});
});
test.each([
[5, 5],
@ -592,160 +598,100 @@ describe('tpa-submit', () => {
// Assert
expect(wrapper.vm.currentDeductible).toBe(expected);
});
describe('deductible box value', () => {
test('returns "Verifying coverage" when isVerified false', () => {
describe.each([
['Verifying coverage', coverageStatuses.PENDING],
['$123.46', coverageStatuses.VERIFIED],
['Verifying coverage', coverageStatuses.NO_COVERAGE]
])('deductibleBoxValue', (expected, status) => {
test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)}`, () => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified: false }
}
insuranceCoverage: {
coverageStatus: status
},
currentDeductible: 123.456
}
};
formatAmountInDollars.mockReturnValue('$123.46');
const { wrapper } = getMountedComponent(initialStore);
const expected = 'Verifying coverage';
// Assert
expect(wrapper.vm.deductibleBoxValue).toBe(expected);
});
test('returns in dollars response when isVerified true', () => {
// Arrange
const currentDeductible = '123094';
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified: true }
},
currentDeductible
}
};
const { wrapper } = getMountedComponent(initialStore);
const notExpected = 'Verifying coverage';
// Assert
expect(wrapper.vm.deductibleBoxValue).not.toBe(notExpected);
});
});
});
describe('methods', () => {
describe('getCustomValueFromString', () => {
describe('with argument deductibleAboveZero', () => {
test.each([
[false],
[true]
])(
'returns false when isVerified %p and currentDeductible is zero',
(isVerified) => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified }
},
currentDeductible: 0
}
};
const { wrapper } = getMountedComponent(initialStore);
const argument = 'deductibleAboveZero';
// Act
const result = wrapper.vm.getCustomValueFromString(argument);
// Assert
expect(result).toBe(false);
}
);
test.each([
[true, true],
[false, false]
])(
'returns %p when isVerified %p and currentDeductible is not zero',
(expected, isVerified) => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified }
},
currentDeductible: 10
}
};
const { wrapper } = getMountedComponent(initialStore);
const argument = 'deductibleAboveZero';
// Act
const result = wrapper.vm.getCustomValueFromString(argument);
// Assert
expect(result).toBe(expected);
}
);
});
describe('with argument zeroDeductible', () => {
test.each([
[true, true],
[false, false]
])(
'returns %p when isVerified is %p currentDeductible is zero',
(expected, isVerified) => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified }
},
currentDeductible: 0
}
};
const { wrapper } = getMountedComponent(initialStore);
const argument = 'zeroDeductible';
// Act
const result = wrapper.vm.getCustomValueFromString(argument);
// Assert
expect(result).toBe(expected);
}
);
test.each([
[false],
[true]
])(
'returns false when isVerified is %p currentDeductible is not zero',
(isVerified) => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified }
},
currentDeductible: 76
}
};
const { wrapper } = getMountedComponent(initialStore);
const argument = 'zeroDeductible';
// Act
const result = wrapper.vm.getCustomValueFromString(argument);
// Assert
expect(result).toBe(false);
}
);
});
test.each([
[true, false],
[false, true]
])(
'with argument verifyingCoverage returns %p when isVerified %p',
(expected, isVerified) => {
describe.each([
[false, coverageStatuses.PENDING, 0],
[false, coverageStatuses.PENDING, 100],
[false, coverageStatuses.VERIFIED, 0],
[true, coverageStatuses.VERIFIED, 100],
[false, coverageStatuses.NO_COVERAGE, 0],
[false, coverageStatuses.NO_COVERAGE, 100]
])('with argument deductibleAboveZero', (expected, status, deductible) => {
test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)} and currentDeductible is ${deductible}`, () => {
// Arrange
const initialStore = {
order: {
payment: {
insuranceCoverage: { isVerified }
insuranceCoverage: {
coverageStatus: status
},
currentDeductible: 26
currentDeductible: deductible
}
};
const { wrapper } = getMountedComponent(initialStore);
const argument = 'deductibleAboveZero';
// Act
const result = wrapper.vm.getCustomValueFromString(argument);
// Assert
expect(result).toBe(expected);
});
});
describe.each([
[false, coverageStatuses.PENDING, 0],
[false, coverageStatuses.PENDING, 100],
[true, coverageStatuses.VERIFIED, 0],
[false, coverageStatuses.VERIFIED, 100],
[false, coverageStatuses.NO_COVERAGE, 0],
[false, coverageStatuses.NO_COVERAGE, 100]
])('with argument zeroDeductible', (expected, status, deductible) => {
test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)} and currentDeductible is ${deductible}`, () => {
// Arrange
const initialStore = {
order: {
insuranceCoverage: {
coverageStatus: status
},
currentDeductible: deductible
}
};
const { wrapper } = getMountedComponent(initialStore);
const argument = 'zeroDeductible';
// Act
const result = wrapper.vm.getCustomValueFromString(argument);
// Assert
expect(result).toBe(expected);
});
});
describe.each([
[true, coverageStatuses.PENDING],
[false, coverageStatuses.VERIFIED],
[true, coverageStatuses.NO_COVERAGE]
])('with argument zeroDeductible', (expected, status) => {
test(`returns ${expected} when coverageStatus is ${getEnumName(coverageStatuses, status)}`, () => {
// Arrange
const initialStore = {
order: {
insuranceCoverage: {
coverageStatus: status
}
}
};
const { wrapper } = getMountedComponent(initialStore);
@ -756,8 +702,9 @@ describe('tpa-submit', () => {
// Assert
expect(result).toBe(expected);
}
);
});
});
test('with unknown argument returns null', () => {
// Arrange
const initialStore = {

2
src/layouts/tpa-submit/tpa-submit.vue
View file

@ -232,7 +232,7 @@ export default {
);
},
isVerified() {
return useMainStore().order.payment.insuranceCoverage.isVerified;
return useMainStore().isVerified;
},
currentDeductible() {
return useMainStore().order.currentDeductible;

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

@ -11,6 +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";
// Mock our module for promises.
jest.mock('@/helpers/layout-helper.js', () => jest.fn());
@ -286,7 +287,7 @@ describe('navigation', () => {
useMainStore().getDuplicateReferrals = jest.fn().mockImplementation(() => Promise.resolve({}));
useMainStore().applicationUser.duplicateOrders = [];
useMainStore().order.policy.policyLookupSuccessful = true;
useMainStore().order.insuranceCoverage.coverageType = coverageType.Deductible;
useMainStore().order.policy.vehicles = [
{ vin: 'TEST_VIN' },
{ vin: 'TEST_VIN2' }
@ -314,7 +315,7 @@ describe('navigation', () => {
useMainStore().getDuplicateReferrals = jest.fn().mockImplementation(() => Promise.resolve({}));
useMainStore().applicationUser.duplicateOrders = [];
useMainStore().order.policy.policyLookupSuccessful = true;
useMainStore().order.insuranceCoverage.coverageType = coverageType.Deductible;
useMainStore().order.policy.vehicles = [];
wrapper.vm.mainStore.validateZip = jest.fn().mockImplementation(() => Promise.resolve({
data: {
@ -339,7 +340,7 @@ describe('navigation', () => {
useMainStore().getDuplicateReferrals = jest.fn().mockImplementation(() => Promise.resolve({}));
useMainStore().applicationUser.duplicateOrders = [];
useMainStore().order.policy.policyLookupSuccessful = true;
useMainStore().order.insuranceCoverage.coverageType = coverageType.Deductible;
useMainStore().order.policy.vehicles = null;
wrapper.vm.mainStore.validateZip = jest.fn().mockImplementation(() => Promise.resolve({
@ -364,7 +365,7 @@ describe('navigation', () => {
const { wrapper } = setupMocks({});
useMainStore().getDuplicateReferrals = jest.fn().mockImplementation(() => Promise.resolve({}));
useMainStore().order.policy.policyLookupSuccessful = false;
useMainStore().order.insuranceCoverage.coverageType = coverageType.NONE;
useMainStore().applicationUser.duplicateOrders = [];
wrapper.vm.mainStore.validateZip = jest.fn().mockImplementation(() => Promise.resolve({

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

@ -176,6 +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";
// define validation rules
defineRule(
@ -331,23 +332,13 @@ export default {
await this.mainStore
.getDuplicateReferrals()
.then(
() => {},
() => {}
)
.catch(() => {})
.finally(async () => {
if (
this.isCoverageEnabled
&& !this.maxCoverageLookupAttemptsReached
) {
await this.mainStore
.getCoveragePolicyInfo()
?.then(
() => {},
() => {}
);
if (this.isCoverageEnabled
&& !this.maxCoverageLookupAttemptsReached) {
await this.mainStore.getCoveragePolicyInfo();
} else {
this.mainStore.order.policy.policyLookupSuccessful = false;
this.mainStore.updateCoverageType(coverageType.NONE);
}
this.navigateForward();
});
@ -388,7 +379,7 @@ export default {
{},
{ [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
);
} else if (this.mainStore.policy.policyLookupSuccessful) {
} else if (this.mainStore.isPolicyLookupSuccessful) {
if (this.mainStore.order.policy.vehicles?.length > 0 ?? false) {
// navigate to policy-vehicles page
this.$router.navigate(

162
src/store/index.js
View file

@ -27,6 +27,7 @@ import bailoutCode from '@/constants/bailoutCode';
import partNumberStrings from '@/constants/part-number-strings';
import { getLineItemsFlattened } from '@/helpers/line-items-helper';
import { buildQueryStringParameterFromArrayOfComplexObjects, getLineItemQueryString, getTaxLineItemQueryString } from '@/helpers/querystring-helper';
import coverageType from '@/constants/coverage-type';
const storeId = 'main';
@ -99,13 +100,10 @@ export const getDefaultState = () => ({
damageState: null,
damageCity: null,
isDamageGlassOnly: null,
policyLookupSuccessful: null,
noCoverage: null,
deductible: {
repair: null, // numerical value; how much customer owes on deductible in repair case
replace: null // numerical value; how much customer owes on deductible in replace case,
},
isITAC: false,
vehicles: [],
endorsements: [],
endorsementQuestionAnswers: [],
@ -156,12 +154,12 @@ export const getDefaultState = () => ({
vaps: null,
serverData: null
},
insuranceCoverage: {
coverageStatus: coverageStatuses.PENDING,
coverageType: coverageType.NONE,
claimNumber: null
},
payment: {
insuranceCoverage: {
isVerified: false,
coverageStatus: coverageStatuses.PENDING,
claimNumber: null
},
parentAccountNumber: 0,
isPayInAdvance: null,
payInAdvanceType: null,
@ -288,16 +286,15 @@ export const useMainStore = defineStore({
isDropOffAppointment: (state) => state.order.serviceLocation.appointmentType === AppointmentTypeStrings.DROP_OFF,
isInShopAppointment: (state) => state.order.serviceLocation.appointmentType === AppointmentTypeStrings.IN_SHOP,
isClaimRegistrationRequired: (state) => state.issConfig.isClaimRegistrationRequired,
isClaimAlreadyRegistered: (state) => state.order.payment.insuranceCoverage.claimNumber !== null,
isClaimAlreadyRegistered: (state) => state.order.insuranceCoverage.claimNumber !== null,
isBailout: (state) => state.applicationUser.pageData[issPageValues.BAILOUT_PAGE] != null,
bailoutCode: (state) => state.applicationUser.pageData[issPageValues.BAILOUT_PAGE]?.bailoutCode,
isNoComp: (s) => !!s.order.policy.noCoverage,
isITAC: (state) => !!state.order.policy.isITAC,
isPolicyLookupSuccessful: (s) => s.order.insuranceCoverage.coverageType !== coverageType.NONE,
isNoComp: (s) => s.order.insuranceCoverage.coverageType === coverageType.NO_COMP,
isITAC: (state) => state.order.insuranceCoverage.coverageType === coverageType.ITAC,
isUnverified: (s) => {
const { payment, currentDeductible, policy } = s.order;
const { policyLookupSuccessful } = policy;
const registerClaimSuccessful = !!payment.insuranceCoverage.isVerified;
if (!policyLookupSuccessful) {
const { currentDeductible } = s.order;
if (!s.isPolicyLookupSuccessful) {
return true;
}
if (s.isNoComp && !s.issConfig.enableNoCompQuote) {
@ -306,13 +303,13 @@ export const useMainStore = defineStore({
if (!s.isNoComp && currentDeductible == null) {
return true;
}
if (s.isClaimRegistrationRequired && !registerClaimSuccessful) {
if (s.isClaimRegistrationRequired && !s.isVerified) {
return true;
}
return false;
},
// TODO condense verification logic
isVerifiedCoverageStatus: (state) => state.order.payment.insuranceCoverage.coverageStatus === coverageStatuses.VERIFIED,
isVerified: (state) => state.order.insuranceCoverage.coverageStatus === coverageStatuses.VERIFIED,
eventBusItem: (state) => (eventCategory, eventSubCategory) => {
const matchedEvent = state.applicationUser.eventBus.find(({ category, subCategory }) => category === eventCategory && subCategory === eventSubCategory);
return matchedEvent?.eventValue;
@ -402,7 +399,7 @@ export const useMainStore = defineStore({
funnelServiceZipCodeCtu: ctuToUse,
funnelParentAccountNumber: s.order.accountNumber,
funnelProviderNumber: s.order.serviceLocation.provider.providerNumber,
funnelIsCoverageVerified: s.order.payment.insuranceCoverage.isVerified,
funnelIsCoverageVerified: s.isVerified,
funnelHasRecalibrationPart: getHasRecalibrationPart(s),
funnelSelectedMultiGlass: s.order.damage.glassToReplace?.length > 1,
funnelSelectedWindshieldGlass: getNonFalseValuesOfPropertyInArrayOfObjects(s.order.damage.glassToReplace, 'glassLocation')
@ -556,8 +553,8 @@ export const useMainStore = defineStore({
}
}).then((r) => {
const responsePolicy = r?.data?.policies?.[0];
policy.policyLookupSuccessful = !!responsePolicy;
if (policy.policyLookupSuccessful) {
if (responsePolicy) {
this.updateCoverageType(coverageType.Deductible);
const insured = responsePolicy.insureds?.[0];
// populate policy holder details from policy lookup
@ -574,20 +571,25 @@ export const useMainStore = defineStore({
// populate vehicles
order.policy.vehicles = responsePolicy.vehicles ?? [];
} else {
this.updateCoverageType(coverageType.NONE);
}
return resolve(r);
}).catch((error) => {
policy.policyLookupSuccessful = false;
this.updateCoverageType(coverageType.NONE);
return reject(error);
});
});
},
updateCoverageStatus(newStatus) {
this.order.payment.insuranceCoverage.coverageStatus = newStatus;
updateCoverageStatus(status) {
this.order.insuranceCoverage.coverageStatus = status;
},
updateCoverageType(type) {
this.order.insuranceCoverage.coverageType = type;
},
registerClaim() {
const nonNumberCharRegex = /[^0-9]/g;
const { order } = this;
const { order, isITAC } = this;
return new Promise((resolve, reject) => {
globalMethods.callHttpClient({
method: endpoints.RegisterClaim.method,
@ -597,7 +599,7 @@ export const useMainStore = defineStore({
referralCorrelationId: this.order.referralCorrelationId,
accountNumber: this.issConfig.parentAccountNumber?.toString() ?? '',
policyData: this.order.policy.policyData,
isItac: this.order.policy.isITAC,
isItac: isITAC,
insured: {
firstName: this.order.customer.firstName,
lastName: this.order.customer.lastName,
@ -647,18 +649,19 @@ export const useMainStore = defineStore({
}
}).then((response) => {
const registerClaimFailed = response.data.isError;
order.payment.insuranceCoverage.isVerified = !registerClaimFailed;
order.payment.insuranceCoverage.claimNumber = null;
if (this.policy?.noCoverage ?? false) {
this.updateCoverageStatus(coverageStatuses.NO_COMP);
order.insuranceCoverage.claimNumber = null;
if (this.isNoComp) {
this.updateCoverageStatus(coverageStatuses.VERIFIED);
} else if (!registerClaimFailed) {
this.updateCoverageStatus(coverageStatuses.VERIFIED);
this.order.payment.insuranceCoverage.claimNumber = response.data.claimNumber;
this.order.insuranceCoverage.claimNumber = response.data.claimNumber;
} else {
this.updateCoverageStatus(coverageStatuses.NO_COVERAGE);
}
return resolve(response);
}, (error) => {
this.order.payment.insuranceCoverage.isVerified = false;
this.order.payment.insuranceCoverage.claimNumber = null;
this.updateCoverageStatus(coverageStatuses.NO_COVERAGE);
this.order.insuranceCoverage.claimNumber = null;
return reject(error);
});
});
@ -693,7 +696,7 @@ export const useMainStore = defineStore({
status: this.order.policy.status,
originalDeductible: this.order.originalDeductible,
currentDeductible: this.order.currentDeductible,
noCoverage: this.order.policy.noCoverage,
noCoverage: this.isNoComp,
isRepair: this.order.damage.isRepair,
policyNumber: this.order.policy.policyNumber,
insuredFirstName: this.order.customer.firstName,
@ -702,7 +705,7 @@ export const useMainStore = defineStore({
policyVehicleId: this.order.vehicle.policyVehicleId?.toString() ?? '',
vehicleVin: this.order.vehicle.vin,
policyData: this.order.policy.policyData,
isItac: this.order.policy.isITAC
isItac: this.isITAC
}
}).then((r) => {
this.order.policy.policyData = r.data.policyData;
@ -1216,7 +1219,7 @@ export const useMainStore = defineStore({
saveSession({ submitAfterSave }) {
const { vehicle, damage, policy, customer, contactInfo, payment,
lineItems, serviceLocation, schedule } = this.order;
lineItems, serviceLocation, schedule, insuranceCoverage } = this.order;
// We don't want to save the session for a loaded session until the car ID is set
if (this.order.loadedFromDupeCheck && !vehicle.carId) {
@ -1271,11 +1274,8 @@ export const useMainStore = defineStore({
},
policyNumber: policy.policyNumber,
policyZipCode: policy.policyZipCode,
noCoverage: policy.noCoverage,
policyLookupSuccessful: policy.policyLookupSuccessful,
originalDeductible: this.order.originalDeductible,
currentDeductible: this.order.currentDeductible,
IsItac: this.order.policy.isITAC,
OemEndorsement: policy.endorsements?.indexOf('OEM Approved') !== -1 ?? false
},
customer: {
@ -1300,12 +1300,12 @@ export const useMainStore = defineStore({
supportingItems: lineItems.supportingItems,
vaps: lineItems.vaps
},
insuranceCoverage: {
coverageType: insuranceCoverage.coverageType,
coverageStatus: insuranceCoverage.coverageStatus,
claimNumber: insuranceCoverage.claimNumber
},
payment: {
InsuranceCoverage: {
isVerified: payment.insuranceCoverage?.isVerified ?? false,
coverageStatus: payment.insuranceCoverage?.coverageStatus,
claimNumber: payment.insuranceCoverage?.claimNumber
},
parentAccountNumber: this.issConfig.parentAccountNumber,
paypalToken: payment.paypalToken,
isPaypal: payment.payInAdvanceType === paymentMethods.PAYPAL,
@ -1391,7 +1391,7 @@ export const useMainStore = defineStore({
return response;
}
if (order.policy.policyLookupSuccessful) {
if (this.isPolicyLookupSuccessful) {
order.customer.emailAddress = data.customer?.emailAddress;
order.customer.firstName = data.customer?.firstName;
order.customer.lastName = data.customer?.lastName;
@ -1410,9 +1410,9 @@ export const useMainStore = defineStore({
order.contactInfo.alternativePhone = data?.customer?.alternativePhone;
order.contactInfo.requestTextUpdates = data?.customer?.isSmsOptIn;
order.payment.insuranceCoverage.isVerified = data?.payment?.insuranceCoverage?.isVerified;
order.payment.insuranceCoverage.coverageStatus = data?.payment?.insuranceCoverage?.coverageStatus;
order.payment.insuranceCoverage.claimNumber = data?.payment?.insuranceCoverage?.claimNumber;
order.insuranceCoverage.coverageType = data?.insuranceCoverage?.coverageType;
order.insuranceCoverage.coverageStatus = data?.insuranceCoverage?.coverageStatus;
order.insuranceCoverage.claimNumber = data?.insuranceCoverage?.claimNumber;
if (order.policy.vehicles.length !== 0 && data.vehicle?.carId) {
order.vehicle.registration.licensePlate = data?.vehicle?.licensePlateNumber;
@ -1421,18 +1421,17 @@ export const useMainStore = defineStore({
if (vehicle) {
const vehicleResponse = await this.lookupVehicleByVin(vehicle.vin);
if (vehicleResponse) {
Object.assign(
vehicleResponse.data,
{
policyVehicleId: vehicle.id,
vin: vehicle.vin,
noCoverage: noCoverageForSelectedVehicle(vehicle),
deductible: deductibleForSelectedVehicle(vehicle),
repairWaived: repairWaivedForSelectedVehicle(vehicle),
endorsements: endorsementsForSelectedVehicle(vehicle)
}
);
this.updateVehicle(vehicleResponse.data);
this.updateVehicle({
...vehicleResponse.data,
policyVehicleId: vehicle.id,
vin: vehicle.vin
});
this.updateVehicleCoverage({
noCoverage: noCoverageForSelectedVehicle(vehicle),
deductible: deductibleForSelectedVehicle(vehicle),
repairWaived: repairWaivedForSelectedVehicle(vehicle),
endorsements: endorsementsForSelectedVehicle(vehicle)
});
}
}
}
@ -1604,9 +1603,9 @@ export const useMainStore = defineStore({
},
resetInsurance() {
this.order.payment.insuranceCoverage.coverageStatus = coverageStatuses.PENDING;
this.order.payment.insuranceCoverage.claimNumber = null;
this.order.payment.insuranceCoverage.isVerified = false;
this.order.insuranceCoverage.coverageStatus = coverageStatuses.PENDING;
this.order.insuranceCoverage.coverageType = coverageType.NONE;
this.order.insuranceCoverage.claimNumber = null;
},
updateSupportingItems(partsData) {
@ -1628,7 +1627,7 @@ export const useMainStore = defineStore({
updateMobileFee(fee) {
// Mobile Fee is only added for NO COMP or ITAC
if (fee && !this.isUnverified && (this.isNoComp || this.isITAC)) {
if (fee && this.isVerified && (this.isNoComp || this.isITAC)) {
this.addPartTypeFeeItem(fee, partTypeStrings.MOBILE_FEE);
} else {
this.addPartTypeFeeItem(null, partTypeStrings.MOBILE_FEE);
@ -1637,7 +1636,7 @@ export const useMainStore = defineStore({
updateRecycleFee(fee) {
// Recycle Fee is only added for NO COMP or ITAC and has Windshield Replacement
if (fee && !this.isUnverified && (this.isNoComp || this.isITAC) && this.hasWindshieldReplacement) {
if (fee && this.isVerified && (this.isNoComp || this.isITAC) && this.hasWindshieldReplacement) {
this.addPartNumberFeeItem(fee, partNumberStrings.RECYCLE_FEE);
} else {
this.addPartNumberFeeItem(null, partNumberStrings.RECYCLE_FEE);
@ -1697,22 +1696,29 @@ export const useMainStore = defineStore({
this.resetBailout();
}
// These could be undefined
this.order.policy.noCoverage = vehicle.noCoverage;
const currentCoverageStatus = vehicle.noCoverage ? coverageStatuses.NO_COMP : coverageStatuses.PENDING;
this.updateCoverageStatus(currentCoverageStatus);
this.order.policy.deductible.replace = vehicle.deductible;
this.order.policy.deductible.repair = vehicle?.repairWaived ?? false ? 0 : vehicle.deductible;
this.order.policy.endorsements = vehicle?.endorsements;
// TODO logic should be more complicated later on
this.order.originalDeductible = vehicle.deductible;
this.order.currentDeductible = vehicle.deductible;
this.updateSupportingItems(null);
this.updateVaps(null);
},
updateVehicleCoverage(coverage) {
if (coverage.noCoverage) {
this.updateCoverageType(coverageType.NO_COMP);
} else {
this.updateCoverageType(coverageType.Deductible);
}
if (!this.isClaimRegistrationRequired) {
this.updateCoverageStatus(coverageStatuses.VERIFIED);
}
this.order.policy.deductible.replace = coverage.deductible;
this.order.policy.deductible.repair = coverage?.repairWaived ?? false ? 0 : coverage.deductible;
this.order.policy.endorsements = coverage?.endorsements;
// TODO logic should be more complicated later on
this.order.originalDeductible = coverage.deductible;
this.order.currentDeductible = coverage.deductible;
},
updateVehicleVin(vin) {
this.order.vehicle.vin = vin;
},
@ -1739,7 +1745,6 @@ export const useMainStore = defineStore({
this.order.policy.damageCause = null;
this.order.policy.damageCity = null;
this.order.policy.damageState = null;
this.order.policy.isITAC = false;
},
resetCustomer() {
@ -1943,9 +1948,6 @@ export const useMainStore = defineStore({
this.order.customer.lastName = customerQuestions.lastName;
this.order.serviceLocation.zipCode = customerQuestions.addressQuestions.zipCode;
},
updatePolicyITACFlag(isITAC) {
this.order.policy.isITAC = isITAC;
},
updateIsSafeliteProvider(isSafelite) {
this.order.serviceLocation.IsSafeliteProvider = isSafelite;
},

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

@ -1,12 +1,20 @@
import { setActivePinia, createPinia } from 'pinia';
import { useMainStore, getDefaultState } from '@/store/index.js';
import globalMethods from '@/global-methods.js';
import { getRandomString, getRandomGuid, getRandomInt, getRandomBoolean } from '@/helpers/data-generation.js';
import {
getRandomString,
getRandomGuid,
getRandomInt,
getRandomBoolean,
getRandomEnum
} from '@/helpers/data-generation.js';
import coverageStatuses from '@/constants/coverage-statuses.js';
import { paymentMethods } from '@/constants/payment-method-constants';
import { endpoints } from '@/constants/endpoints';
import { AppointmentTypeStrings } from '@/constants/schedule-constants';
import bailoutCode from '@/constants/bailoutCode';
import coverageType from '@/constants/coverage-type';
import { getEnumName } from '@/helpers/unit-test-helper';
describe('Store', () => {
let store;
@ -157,12 +165,12 @@ describe('Store', () => {
expect(store.order.vehicle).toMatchObject(expectedVehicle);
});
it('UpdateVehicle should set policy values appropriately with repair waived', () => {
it('updateVehicleCoverage should set policy values appropriately with repair waived', () => {
// Arrange
const noCoverage = getRandomBoolean();
const deductible = getRandomInt(1, 500);
const endorsements = [getRandomString(10, 20)];
const vehicle = {
const vehicleCoverage = {
noCoverage,
deductible,
repairWaived: true,
@ -170,7 +178,6 @@ describe('Store', () => {
};
const expectedPolicy = {
noCoverage,
deductible: {
replace: deductible,
repair: 0
@ -178,11 +185,16 @@ describe('Store', () => {
endorsements
};
const expectedInsuranceCoverage = {
coverageType: noCoverage ? coverageType.NO_COMP : coverageType.Deductible
};
// Act
store.updateVehicle(vehicle);
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', () => {
@ -190,7 +202,7 @@ describe('Store', () => {
const noCoverage = getRandomBoolean();
const deductible = getRandomInt(1, 500);
const endorsements = [getRandomString(10, 20)];
const vehicle = {
const vehicleCoverage = {
noCoverage,
deductible,
repairWaived: false,
@ -198,7 +210,6 @@ describe('Store', () => {
};
const expectedPolicy = {
noCoverage,
deductible: {
replace: deductible,
repair: deductible
@ -206,35 +217,35 @@ describe('Store', () => {
endorsements
};
const expectedInsuranceCoverage = {
coverageType: noCoverage ? coverageType.NO_COMP : coverageType.Deductible
};
// Act
store.updateVehicle(vehicle);
store.updateVehicleCoverage(vehicleCoverage);
// Assert
expect(store.order.policy).toMatchObject(expectedPolicy);
expect(store.order.insuranceCoverage).toMatchObject(expectedInsuranceCoverage);
});
it.each([
[true, coverageStatuses.NO_COMP],
[false, coverageStatuses.PENDING]
])(
'UpdateVehicle should set coverageStatus appropriately based on noCoverage value',
(expectedNoCoverage, expectedCoverageStatus) => {
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}`, () => {
// Arrange
const vehicle = {
noCoverage: expectedNoCoverage
const vehicleCoverage = {
noCoverage
};
store.order.payment.insuranceCoverage.coverageStatus = coverageStatuses.PENDING;
// Act
store.updateVehicle(vehicle);
store.updateVehicleCoverage(vehicleCoverage);
// Assert
expect(store.order.policy.noCoverage).toBe(expectedNoCoverage);
expect(store.order.payment.insuranceCoverage.coverageStatus).toBe(expectedCoverageStatus);
}
);
expect(store.order.insuranceCoverage.coverageType).toBe(expected);
});
});
it('setVehicle is bailout if the vehicle cannot be serviced by Safelite', () => {
// Arrange
const vehicle = {
@ -417,7 +428,7 @@ describe('Store', () => {
deductible: 0
}
};
store.policy.noCoverage = true;
store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
@ -426,9 +437,9 @@ describe('Store', () => {
// 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);
expect(store.order.insuranceCoverage.coverageStatus).toBe(coverageStatuses.VERIFIED);
expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NO_COMP);
expect(store.order.insuranceCoverage.claimNumber).toBe(null);
});
it('successful response with coverage => isVerified true and coverage status verified', async () => {
@ -444,7 +455,7 @@ describe('Store', () => {
deductible: 0
}
};
store.policy.noCoverage = false;
store.order.insuranceCoverage.coverageType = coverageType.Deductible;
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
@ -453,17 +464,17 @@ describe('Store', () => {
// 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);
expect(store.order.insuranceCoverage.coverageStatus).toBe(coverageStatuses.VERIFIED);
expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.Deductible);
expect(store.order.insuranceCoverage.claimNumber).not.toBeNull();
});
it('Call to client returns exception, resulting in object with error property being returned', async () => {
// Arrange
expect.assertions(5);
expect.assertions(4);
const error = 'register claim error';
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error));
store.payment.insuranceCoverage.coverageStatus = coverageStatuses.PENDING;
store.order.insuranceCoverage.coverageStatus = coverageStatuses.PENDING;
// Act
await store.registerClaim().catch((e) => {
@ -472,9 +483,8 @@ describe('Store', () => {
// 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);
expect(store.order.insuranceCoverage.coverageStatus).toBe(coverageStatuses.NO_COVERAGE);
expect(store.order.insuranceCoverage.claimNumber).toBe(null);
});
});
@ -677,8 +687,8 @@ describe('Store', () => {
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 status = getRandomEnum(coverageStatuses);
const type = getRandomEnum(coverageType);
const originalDeductible = getRandomString(6, 6);
const currentDeductible = getRandomString(6, 6);
store.order.originalDeductible = originalDeductible;
@ -691,8 +701,8 @@ describe('Store', () => {
store.order.contactInfo.servicePhone = customerPhoneNumber;
store.order.policy.policyNumber = policyNumber;
store.order.policy.policyZipCode = policyZipCode;
store.order.policy.policyLookupSuccessful = policyLookupSuccessful;
store.order.policy.noCoverage = noCoverage;
store.order.insuranceCoverage.coverageStatus = status;
store.order.insuranceCoverage.coverageType = type;
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
// Act
@ -711,10 +721,12 @@ describe('Store', () => {
}),
policyNumber,
policyZipCode,
noCoverage,
policyLookupSuccessful,
originalDeductible,
currentDeductible
}),
insuranceCoverage: expect.objectContaining({
coverageStatus: status,
coverageType: type
})
})
}));
@ -798,17 +810,40 @@ describe('Store', () => {
})
}));
});
it.each([
[coverageStatuses.PENDING],
[coverageStatuses.NO_COMP],
[coverageStatuses.VERIFIED]
])('calls api with expected payment', async (coverageStatus) => {
describe.each([
[coverageStatuses.PENDING, coverageType.NO_COMP, null],
[coverageStatuses.PENDING, coverageType.ITAC, null],
[coverageStatuses.PENDING, coverageType.Deductible, null],
[coverageStatuses.VERIFIED, coverageType.ITAC, 'V_ITAC_123'],
[coverageStatuses.VERIFIED, coverageType.Deductible, 'V_Deductible_123'],
[coverageStatuses.NO_COVERAGE, coverageType.NONE, null],
])('calls api with expected insuranceCoverage', (status, type, claimNumber) => {
test(`calls api with coverageStatus is ${getEnumName(coverageStatuses, status)} and coverageType is ${getEnumName(coverageType, type)} and claimNumber is ${claimNumber}`, async () => {
// Arrange
store.order.insuranceCoverage.coverageStatus = status;
store.order.insuranceCoverage.coverageType = type;
store.order.insuranceCoverage.claimNumber = claimNumber;
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
// Act
await store.saveSession({});
// Assert
expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
payload: expect.objectContaining({
insuranceCoverage: expect.objectContaining({
coverageStatus: status,
coverageType: type,
claimNumber
})
})
}));
});
});
it('calls api with expected payment', async () => {
// Arrange
const parentAccountNumber = getRandomString(6, 6);
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
@ -818,10 +853,6 @@ describe('Store', () => {
expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
payload: expect.objectContaining({
payment: expect.objectContaining({
InsuranceCoverage: expect.objectContaining({
isVerified,
coverageStatus
}),
parentAccountNumber
})
})
@ -1105,7 +1136,7 @@ describe('Store', () => {
referralCorrelationId: getRandomGuid()
};
store.order.policy.policyLookupSuccessful = true;
store.order.insuranceCoverage.coverageType = coverageType.Deductible;
store.policy.vehicles = [{ vin: vehicle.vin }];
// Act
@ -1134,7 +1165,7 @@ describe('Store', () => {
referralCorrelationId: getRandomGuid()
};
store.order.policy.policyLookupSuccessful = true;
store.order.insuranceCoverage.coverageType = coverageType.Deductible;
store.policy.vehicles = [{ vin: vehicle.vin }];
// Act
@ -1255,7 +1286,7 @@ describe('Store', () => {
})
}));
});
it('null response by api => policyLookupSuccessful false', async () => {
it('null response by api => insuranceCoverage.coverageType is NONE', async () => {
// Arrange
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(null));
@ -1263,9 +1294,9 @@ describe('Store', () => {
await store.getCoveragePolicyInfo();
// Asserts
expect(store.order.policy.policyLookupSuccessful).toBe(false);
expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NONE);
});
it('no policies returned by api => policyLookupSuccessful false', async () => {
it('no policies returned by api => insuranceCoverage.coverageType is NONE', async () => {
// Arrange
const responseNoPolicies = {
data: {
@ -1278,7 +1309,7 @@ describe('Store', () => {
await store.getCoveragePolicyInfo();
// Asserts
expect(store.order.policy.policyLookupSuccessful).toBe(false);
expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NONE);
});
it('multiple policies returned by api => data set based on first policy returned', async () => {
// Arrange
@ -1309,7 +1340,7 @@ describe('Store', () => {
await store.getCoveragePolicyInfo();
// Asserts
expect(store.order.policy.policyLookupSuccessful).toBe(true);
expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.Deductible);
expect(store.order.customer.address.streetAddress).toBe(insured.address);
expect(store.order.customer.address.city).toBe(insured.city);
@ -1344,7 +1375,7 @@ describe('Store', () => {
await store.getCoveragePolicyInfo();
// Asserts
expect(store.order.policy.policyLookupSuccessful).toBe(true);
expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.Deductible);
expect(store.order.customer.address.streetAddress).toBe(insured1.address);
});
it('no policy vehicles on first policy => order.policy.vehicles empty list', async () => {
@ -1360,11 +1391,11 @@ describe('Store', () => {
await store.getCoveragePolicyInfo();
// Asserts
expect(store.order.policy.policyLookupSuccessful).toBe(true);
expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.Deductible);
expect(store.order.policy.vehicles).toEqual([]);
});
});
it('api call throws exception => policyLookupSuccessful false', async () => {
it('api call throws exception => insuranceCoverage.coverageType is NONE', async () => {
expect.assertions(3);
const error = 'get coverage policy info error';
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error));
@ -1380,7 +1411,7 @@ describe('Store', () => {
method: endpoints.CoveragePolicyInfo.method,
endpoint: endpoints.CoveragePolicyInfo.url
}));
expect(store.order.policy.policyLookupSuccessful).toBe(false);
expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NONE);
});
});
@ -1452,32 +1483,17 @@ describe('Store', () => {
});
});
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('isUnverified', () => {
beforeEach(() => {
store.order.policy.isITAC = false;
store.order.policy.noCoverage = false;
store.order.payment.insuranceCoverage.isVerified = true;
store.order.currentDeductible = 123;
store.order.policy.policyLookupSuccessful = true;
store.order.insuranceCoverage.coverageStatus = coverageStatuses.VERIFIED;
store.order.insuranceCoverage.coverageType = coverageType.Deductible;
store.issConfig.isClaimRegistrationRequired = true;
store.issConfig.enableNoCompQuote = true;
});
it('returns true when policyLookupSuccessful false', () => {
it('returns true when coverageType is NONE', () => {
// Arrange
store.order.policy.policyLookupSuccessful = false;
store.order.insuranceCoverage.coverageType = coverageType.NONE;
// Act
const result = store.isUnverified;
@ -1487,7 +1503,7 @@ describe('Store', () => {
});
it('returns true when no comp and enableNoCompQuote false', () => {
// Arrange
store.order.policy.noCoverage = true;
store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
store.issConfig.enableNoCompQuote = false;
// Act
@ -1498,7 +1514,6 @@ describe('Store', () => {
});
it('returns true when not no comp and currentDeductible null', () => {
// Arrange
store.order.policy.noCoverage = false;
store.order.currentDeductible = null;
// Act
@ -1509,7 +1524,7 @@ describe('Store', () => {
});
it('returns true when isClaimRegistrationRequired true and insurance coverage not verified', () => {
// Arrange
store.order.payment.insuranceCoverage.isVerified = false;
store.order.insuranceCoverage.coverageStatus = coverageStatuses.NO_COVERAGE;
// Act
const result = store.isUnverified;
@ -1519,7 +1534,7 @@ describe('Store', () => {
});
it('returns false when no comp, enableNoCompQuote true, and currentDeductible null', () => {
// Arrange
store.order.policy.noCoverage = true;
store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
store.order.currentDeductible = null;
store.issConfig.enableNoCompQuote = true;
@ -1686,7 +1701,6 @@ describe('Store', () => {
const status = getRandomString(6, 8);
const currentDeductible = getRandomInt(0, 5000);
const originalDeductible = getRandomInt(0, 5000);
const noCoverage = getRandomBoolean();
const isRepair = getRandomBoolean();
const policyNumber = getRandomString(10, 20);
const insuredFirstName = getRandomString(10, 20);
@ -1695,13 +1709,11 @@ describe('Store', () => {
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.originalDeductible = originalDeductible;
store.order.policy.noCoverage = noCoverage;
store.order.policy.status = status;
store.order.customer.address.state = policyState;
store.order.damage.isRepair = isRepair;
@ -1713,8 +1725,6 @@ describe('Store', () => {
store.order.vehicle.vin = vehicleVin;
store.order.policy.policyData = policyData;
store.updatePolicyITACFlag(isItac);
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
// Act
@ -1733,7 +1743,7 @@ describe('Store', () => {
status,
currentDeductible,
originalDeductible,
noCoverage,
noCoverage: store.isNoComp,
isRepair,
policyNumber,
insuredFirstName,
@ -1742,7 +1752,7 @@ describe('Store', () => {
policyVehicleId,
vehicleVin,
policyData,
isItac
isItac: store.isITAC
})
}));
});
@ -1768,7 +1778,6 @@ describe('Store', () => {
const status = getRandomString(6, 8);
const currentDeductible = getRandomInt(0, 5000);
const originalDeductible = getRandomInt(0, 5000);
const noCoverage = getRandomBoolean();
const isRepair = getRandomBoolean();
const endorsementAnswers = [
{
@ -1797,13 +1806,11 @@ describe('Store', () => {
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.originalDeductible = originalDeductible;
store.order.policy.noCoverage = noCoverage;
store.order.policy.status = status;
store.order.customer.address.state = policyState;
store.order.policy.endorsementQuestionAnswers = endorsementAnswers;
@ -1816,8 +1823,6 @@ describe('Store', () => {
store.order.vehicle.vin = vehicleVin;
store.order.policy.policyData = policyData;
store.updatePolicyITACFlag(isItac);
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
// Act
@ -1837,7 +1842,7 @@ describe('Store', () => {
status,
currentDeductible,
originalDeductible,
noCoverage,
noCoverage: store.isNoComp,
isRepair,
policyNumber,
insuredFirstName,
@ -1846,7 +1851,7 @@ describe('Store', () => {
policyVehicleId,
vehicleVin,
policyData,
isItac
isItac: store.isITAC
})
}));
});
@ -1991,7 +1996,7 @@ describe('Store', () => {
expect(result.data.shopProviders[1]).toBe(provider2);
});
});
it('api call throws exception => policyLookupSuccessful false', async () => {
it('api call throws exception => coverageType none', async () => {
expect.assertions(3);
const error = 'get coverage policy info error';
globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error));
@ -2007,7 +2012,7 @@ describe('Store', () => {
method: endpoints.CoveragePolicyInfo.method,
endpoint: endpoints.CoveragePolicyInfo.url
}));
expect(store.order.policy.policyLookupSuccessful).toBe(false);
expect(store.order.insuranceCoverage.coverageType).toBe(coverageType.NONE);
});
});
@ -2052,7 +2057,7 @@ describe('Store', () => {
describe('billToNumberToUse getter', () => {
it('returns itacCashBillToNumber when in ITAC flow', () => {
// Arrange
store.order.policy.isITAC = true;
store.order.insuranceCoverage.coverageType = coverageType.ITAC;
store.issConfig.itacCashBillToNumber = '12345';
// Assert
@ -2061,7 +2066,7 @@ describe('Store', () => {
it('returns itacFnrBillToNumber when in NoComp flow', () => {
// Arrange
store.order.policy.noCoverage = true;
store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
store.issConfig.itacFnrBillToNumber = '12345';
// Assert
@ -2070,8 +2075,7 @@ describe('Store', () => {
it('returns billToAccountNumber when not ITAC and not NoComp', () => {
// Arrange
store.order.policy.isITAC = null;
store.order.policy.noCoverage = null;
store.order.insuranceCoverage.coverageType = coverageType.Deductible;
store.issConfig.billToAccountNumber = '12345';
// Assert