906 lines
30 KiB
JavaScript
906 lines
30 KiB
JavaScript
// Components
|
|
import coverageStatement from '@/layouts/coverage-statement/coverage-statement.vue';
|
|
|
|
// Supporting Files
|
|
import { nextTick } from 'vue';
|
|
import { mount } from '@vue/test-utils';
|
|
import { 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 routerParams from '@/router/router-constants/router-params';
|
|
import { useMainStore } from '@/store/index.js';
|
|
|
|
jest.mock('@/helpers/layout-helper.js', () => jest.fn());
|
|
|
|
jest.mock('@/helpers/cms-content-helper', () => ({
|
|
fetchCmsContentForPage: jest.fn(),
|
|
setupModalLinks: jest.fn(),
|
|
processIfStatements: jest.fn()
|
|
}));
|
|
|
|
const mockMixin = {
|
|
methods: {
|
|
getCmsContent: jest.fn().mockImplementation(() => ''),
|
|
setCmsContent: jest.fn()
|
|
}
|
|
};
|
|
|
|
const footerStub = {
|
|
render: () => {},
|
|
methods: {
|
|
updateButtonText: jest.fn()
|
|
}
|
|
};
|
|
|
|
const loadingModalStub = {
|
|
render: () => {},
|
|
methods: {
|
|
showModal: jest.fn(),
|
|
hideModal: jest.fn()
|
|
}
|
|
};
|
|
|
|
function getMountedComponent(mainInitialState = {}, initialData = {}, methodToRun = () => {}) {
|
|
const mountOptions = getMountOptions({
|
|
router: {
|
|
navigate: jest.fn()
|
|
}
|
|
});
|
|
|
|
mountOptions.global.stubs = {
|
|
siteFooter: footerStub,
|
|
siteHeader: true,
|
|
recalModal: true,
|
|
contentGroupModal: true,
|
|
alert: true,
|
|
loadingModal: loadingModalStub
|
|
};
|
|
const testingPinia = createTestingPinia({
|
|
initialState: {
|
|
main: mainInitialState
|
|
}
|
|
});
|
|
useMainStore(testingPinia);
|
|
methodToRun();
|
|
|
|
mountOptions.global.plugins = [testingPinia];
|
|
mountOptions.mixins = [mockMixin];
|
|
mountOptions.data = () => (
|
|
initialData
|
|
);
|
|
|
|
const apiResponses = {
|
|
supportingItems: []
|
|
};
|
|
const apiPromise = Promise.resolve(apiResponses);
|
|
settleAllPromises.mockImplementation(() => apiPromise);
|
|
fetchCmsContentForPage.mockImplementation(() => Promise.resolve());
|
|
|
|
const wrapper = mount(coverageStatement, mountOptions);
|
|
return { wrapper };
|
|
}
|
|
|
|
describe.skip('coverageStatement.vue', () => {
|
|
describe('method arePagePrerequisitesValid...', () => {
|
|
test('Should return true for valid page requisites if vin exists', () => {
|
|
// Arrange
|
|
const { wrapper } = getMountedComponent({
|
|
order: {
|
|
vehicle: {
|
|
vin: getRandomString(5, 20)
|
|
}
|
|
}
|
|
});
|
|
|
|
// Act
|
|
const arePagePrerequisitesValid = wrapper.vm.arePagePrerequisitesValid();
|
|
|
|
// Assert
|
|
expect(arePagePrerequisitesValid).toBeTruthy();
|
|
});
|
|
test('Should return false for valid page requisites if vin is missing', () => {
|
|
// Arrange
|
|
const { wrapper } = getMountedComponent({
|
|
order: {
|
|
vehicle: {
|
|
vin: null
|
|
}
|
|
}
|
|
});
|
|
|
|
// Act
|
|
const arePagePrerequisitesValid = wrapper.vm.arePagePrerequisitesValid();
|
|
|
|
// Assert
|
|
expect(arePagePrerequisitesValid).not.toBeTruthy();
|
|
});
|
|
});
|
|
describe('Rendering', () => {
|
|
test('Should render site header', () => {
|
|
// Arrange
|
|
const { wrapper } = getMountedComponent({});
|
|
|
|
// Act
|
|
const siteHeader = wrapper.findComponent({ ref: 'siteHeader' });
|
|
|
|
// Assert
|
|
expect(siteHeader.exists()).toBe(true);
|
|
});
|
|
test('Should render site subheader', () => {
|
|
// Arrange
|
|
const { wrapper } = getMountedComponent({});
|
|
|
|
// Act
|
|
const subheader = wrapper.find({ ref: 'siteSubHeader' });
|
|
|
|
// Assert
|
|
expect(subheader.exists()).toBe(true);
|
|
});
|
|
|
|
test('Should render explanatory text', () => {
|
|
// Arrange
|
|
const { wrapper } = getMountedComponent({});
|
|
|
|
// Act
|
|
const explanatoryText = wrapper.find({ ref: 'explanatoryText' });
|
|
|
|
// Assert
|
|
expect(explanatoryText.exists()).toBe(true);
|
|
});
|
|
test('Should render secondary text', () => {
|
|
// Arrange
|
|
const { wrapper } = getMountedComponent({});
|
|
|
|
// Act
|
|
const secondaryText = wrapper.find({ ref: 'secondaryText' });
|
|
|
|
// Assert
|
|
expect(secondaryText.exists()).toBe(true);
|
|
});
|
|
test('Should render site footer', () => {
|
|
// Arrange
|
|
const { wrapper } = getMountedComponent({});
|
|
|
|
// Act
|
|
const footer = wrapper.findComponent({ ref: 'siteFooter' });
|
|
|
|
// Assert
|
|
expect(footer.exists()).toBe(true);
|
|
});
|
|
});
|
|
describe('Verified ITAC scenario', () => {
|
|
test('If policy lookup successful, not No Comp, and deductible > service price, verifiedITAC returns true', () => {
|
|
// Arrange
|
|
const sellingPrice = getRandomInt(100, 500);
|
|
const deductible = sellingPrice + 1;
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
},
|
|
policyLookupSuccessful: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
wrapper.setData({
|
|
availableLineItems: [
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
]
|
|
});
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedITAC).toBeTruthy();
|
|
});
|
|
test('If policy lookup unsuccessful, verifiedITAC returns false', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
policyLookupSuccessful: false
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedITAC).toBeFalsy();
|
|
});
|
|
test('If No Comp, verifiedITAC returns false', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedITAC).toBeFalsy();
|
|
});
|
|
test('If deductible < service price, verifiedITAC returns false', () => {
|
|
// Arrange
|
|
const sellingPrice = getRandomInt(100, 500);
|
|
const deductible = sellingPrice - 1;
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
wrapper.setData({
|
|
availableLineItems: [
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
]
|
|
});
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedITAC).toBeFalsy();
|
|
});
|
|
});
|
|
describe('Verified Deductible scenario', () => {
|
|
test('If policy lookup successful, not No Comp, and service price > deductible, verifiedITAC returns true', () => {
|
|
// Arrange
|
|
const sellingPrice = getRandomInt(100, 500);
|
|
const deductible = sellingPrice - 1;
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
},
|
|
policyLookupSuccessful: true
|
|
}
|
|
}
|
|
};
|
|
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
wrapper.setData({
|
|
availableLineItems: [
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
]
|
|
});
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedDeductible).toBeTruthy();
|
|
});
|
|
test('If policy lookup unsuccessful, verifiedDeductible returns false', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
policyLookupSuccessful: false
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedDeductible).toBeFalsy();
|
|
});
|
|
test('If No Comp, verifiedDeductible returns false', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedDeductible).toBeFalsy();
|
|
});
|
|
test('If service price < deductible, verifiedDeductible returns false', () => {
|
|
const sellingPrice = getRandomInt(100, 500);
|
|
const deductible = sellingPrice + 1;
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
wrapper.setData({
|
|
availableLineItems: [
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
]
|
|
});
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedDeductible).toBeFalsy();
|
|
});
|
|
test('If deductible is null, verifiedDeductible returns false', () => {
|
|
const sellingPrice = getRandomInt(100, 500);
|
|
const deductible = null;
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
wrapper.setData({
|
|
availableLineItems: [
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
]
|
|
});
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedDeductible).toBeFalsy();
|
|
});
|
|
});
|
|
describe('No Comp scenario', () => {
|
|
test('If noCoverage = true, verifiedNoComp returns true', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: true,
|
|
policyLookupSuccessful: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedNoComp).toBeTruthy();
|
|
});
|
|
test('If noCoverage = false, verifiedNoComp returns false', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: false
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.verifiedNoComp).toBeFalsy();
|
|
});
|
|
});
|
|
describe('Unverified scenario', () => {
|
|
test('If policyLookupSuccessful false, unverified returns true', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
policyLookupSuccessful: false
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.unverified).toBeTruthy();
|
|
});
|
|
test('If policyLookupSuccessful is true, unverified returns false', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
policyLookupSuccessful: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.unverified).toBeFalsy();
|
|
});
|
|
});
|
|
describe('Navigation', () => {
|
|
test('If Unverified, navigate forward with CLICKED_FORWARD scenario', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
policyLookupSuccessful: false
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Act
|
|
wrapper.vm.forwardButtonAction();
|
|
|
|
// Assert
|
|
expect(wrapper.vm.$router.navigate)
|
|
.toHaveBeenCalledWith(
|
|
navigationScenarios.CLICKED_FORWARD,
|
|
undefined,
|
|
{},
|
|
{ [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
|
|
);
|
|
});
|
|
test('If Verified Deductible, navigate forward with CLICKED_FORWARD scenario', () => {
|
|
// Arrange
|
|
const sellingPrice = getRandomInt(100, 500);
|
|
const deductible = sellingPrice - 1;
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
},
|
|
policyLookupSuccessful: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
wrapper.setData({
|
|
availableLineItems: [
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
]
|
|
});
|
|
|
|
// Act
|
|
wrapper.vm.forwardButtonAction();
|
|
|
|
// Assert
|
|
expect(wrapper.vm.$router.navigate)
|
|
.toHaveBeenCalledWith(
|
|
navigationScenarios.CLICKED_FORWARD,
|
|
undefined,
|
|
{},
|
|
{ [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
|
|
);
|
|
});
|
|
test('If Verified ITAC and selected Safelite, navigate forward with CLICKED_FORWARD_WITH_SAFELITE scenario', () => {
|
|
// Arrange
|
|
const sellingPrice = getRandomInt(100, 500);
|
|
const deductible = sellingPrice + 1;
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
},
|
|
policyLookupSuccessful: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
wrapper.setData({
|
|
availableLineItems: [
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
],
|
|
selectedProvider: 'Safelite'
|
|
});
|
|
|
|
// Act
|
|
wrapper.vm.forwardButtonAction();
|
|
|
|
// Assert
|
|
expect(wrapper.vm.$router.navigate)
|
|
.toHaveBeenCalledWith(
|
|
navigationScenarios.CLICKED_FORWARD_WITH_SAFELITE,
|
|
undefined,
|
|
{},
|
|
{ [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
|
|
);
|
|
});
|
|
test('If Verified ITAC, selected other shop, and TPA enabled, navigate forward w/ CLICKED_FORWARD_WITH_TPA_ENABLED', () => {
|
|
// Arrange
|
|
const sellingPrice = getRandomInt(100, 500);
|
|
const deductible = sellingPrice + 1;
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
},
|
|
policyLookupSuccessful: true
|
|
}
|
|
},
|
|
issConfig: {
|
|
enableTPAFlow: true
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
wrapper.setData({
|
|
availableLineItems: [
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
],
|
|
selectedProvider: 'Other'
|
|
});
|
|
|
|
// Act
|
|
wrapper.vm.forwardButtonAction();
|
|
|
|
// Assert
|
|
expect(wrapper.vm.$router.navigate)
|
|
.toHaveBeenCalledWith(
|
|
navigationScenarios.CLICKED_FORWARD_WITH_TPA_ENABLED,
|
|
undefined,
|
|
{},
|
|
{ [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
|
|
);
|
|
});
|
|
test('If Verified ITAC, selected other shop, and TPA disabled, navigate forward w/ CLICKED_FORWARD_WITH_TPA_DISABLED', () => {
|
|
// Arrange
|
|
const sellingPrice = getRandomInt(100, 500);
|
|
const deductible = sellingPrice + 1;
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
},
|
|
policyLookupSuccessful: true
|
|
}
|
|
},
|
|
issConfig: {
|
|
enableTPAFlow: false
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
wrapper.setData({
|
|
availableLineItems: [
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
],
|
|
selectedProvider: 'Other'
|
|
});
|
|
|
|
// Act
|
|
wrapper.vm.forwardButtonAction();
|
|
|
|
// Assert
|
|
expect(wrapper.vm.$router.navigate)
|
|
.toHaveBeenCalledWith(
|
|
navigationScenarios.CLICKED_FORWARD_WITH_TPA_DISABLED,
|
|
undefined,
|
|
{},
|
|
{ [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
|
|
);
|
|
});
|
|
test('If No Comp and selected Safelite, navigate forward with CLICKED_FORWARD scenario', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
},
|
|
policy: {
|
|
noCoverage: true,
|
|
policyLookupSuccessful: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
wrapper.setData({
|
|
isVerified: false,
|
|
selectedProvider: 'Safelite'
|
|
});
|
|
|
|
// Act
|
|
wrapper.vm.forwardButtonAction();
|
|
|
|
// Assert
|
|
expect(wrapper.vm.$router.navigate)
|
|
.toHaveBeenCalledWith(
|
|
navigationScenarios.CLICKED_FORWARD_WITH_SAFELITE,
|
|
undefined,
|
|
{},
|
|
{ [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
|
|
);
|
|
});
|
|
});
|
|
describe('ADAS', () => {
|
|
test('if Replace and parts require recalibration, isADAS should return true', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: false
|
|
},
|
|
lineItems: {
|
|
glassParts: [
|
|
{
|
|
requiresRecalibration: true
|
|
}
|
|
]
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.isADAS).toBeTruthy();
|
|
});
|
|
test('if Replace and parts do not require recalibration, isADAS should return false', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: false
|
|
},
|
|
lineItems: {
|
|
glassParts: [
|
|
{
|
|
requiresRecalibration: false
|
|
}
|
|
]
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.isADAS).toBeFalsy();
|
|
});
|
|
test('if Repair, isADAS should return true', () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
damage: {
|
|
isRepair: true
|
|
}
|
|
}
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState);
|
|
|
|
// Assert
|
|
expect(wrapper.vm.isADAS).toBeFalsy();
|
|
});
|
|
});
|
|
describe('claim registration api call', () => {
|
|
it('claim registration not required => method not called', async () => {
|
|
// Arrange
|
|
const { wrapper } = getMountedComponent({
|
|
issConfig: {
|
|
isClaimRegistrationRequired: false
|
|
}
|
|
});
|
|
|
|
// Assert
|
|
expect(wrapper.vm.mainStore.registerClaim).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('claim registration required => register claim method called', async () => {
|
|
// Arrange
|
|
const sellingPrice = getRandomInt(50, 100);
|
|
const deductible = sellingPrice - 1;
|
|
const initialStore = {
|
|
order: {
|
|
policy: {
|
|
policyLookupSuccessful: true,
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
}
|
|
},
|
|
damage: {
|
|
isRepair: true
|
|
}
|
|
},
|
|
issConfig: {
|
|
isClaimRegistrationRequired: true
|
|
}
|
|
};
|
|
const mockStoreActions = () => {
|
|
useMainStore().getWipers = jest.fn().mockImplementation(() => Promise.resolve());
|
|
useMainStore().getRainDefense = jest.fn().mockImplementation(() => Promise.resolve());
|
|
useMainStore().getSupportingItems = jest.fn().mockImplementation(() => Promise.resolve());
|
|
useMainStore().getPriceOrderItems = jest.fn().mockImplementation(() => Promise.resolve([
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
]));
|
|
};
|
|
const { wrapper } = getMountedComponent(initialStore, {}, mockStoreActions);
|
|
const next = (method) => { method(wrapper.vm); };
|
|
|
|
// 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();
|
|
}
|
|
|
|
// Assert
|
|
expect(wrapper.vm.mainStore.registerClaim).toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('coverageStatement.vue-working', () => {
|
|
describe('ITAC flag', () => {
|
|
test('ITAC flag updated once component is initialized', async () => {
|
|
// Arrange
|
|
const mainInitialState = {
|
|
order: {
|
|
policy: {
|
|
isITAC: null
|
|
}
|
|
}
|
|
};
|
|
const mockStoreActions = () => {
|
|
useMainStore().getPriceOrderItems = jest.fn().mockImplementation(() => Promise.resolve([]));
|
|
};
|
|
const { wrapper } = getMountedComponent(mainInitialState, {}, mockStoreActions);
|
|
|
|
// Act
|
|
wrapper.vm.initializeComponent();
|
|
|
|
// Assert
|
|
expect(wrapper.vm.mainStore.updatePolicyITACFlag)
|
|
.toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('Loaded duplicate with previously registered claim => claim registration is not called', async () => {
|
|
// Arrange
|
|
const sellingPrice = getRandomInt(50, 100);
|
|
const deductible = sellingPrice - 1;
|
|
const initialStore = {
|
|
order: {
|
|
policy: {
|
|
policyLookupSuccessful: true,
|
|
noCoverage: false,
|
|
deductible: {
|
|
repair: deductible
|
|
}
|
|
},
|
|
damage: {
|
|
isRepair: false
|
|
},
|
|
payment: {
|
|
insuranceCoverage: {
|
|
claimNumber: getRandomString(10, 10)
|
|
}
|
|
}
|
|
},
|
|
issConfig: {
|
|
isClaimRegistrationRequired: true
|
|
}
|
|
};
|
|
const mockStoreActions = () => {
|
|
useMainStore().getWipers = jest.fn().mockImplementation(() => Promise.resolve());
|
|
useMainStore().getRainDefense = jest.fn().mockImplementation(() => Promise.resolve());
|
|
useMainStore().getSupportingItems = jest.fn().mockImplementation(() => Promise.resolve());
|
|
useMainStore().getPriceOrderItems = jest.fn().mockImplementation(() => Promise.resolve([
|
|
{
|
|
sellingPrice,
|
|
kitPrice: 0,
|
|
laborAmount: 0
|
|
}
|
|
]));
|
|
};
|
|
const { wrapper } = getMountedComponent(initialStore, {}, mockStoreActions);
|
|
const next = (method) => { method(wrapper.vm); };
|
|
|
|
// 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();
|
|
}
|
|
|
|
// Assert
|
|
expect(wrapper.vm.mainStore.registerClaim).toHaveBeenCalledTimes(0);
|
|
});
|
|
});
|
|
});
|