SSR-1167 Coverage Rework unverified / coverage statement improvements

src/constants/coverage-statement-page-variations.js

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

src/constants/coverage-statuses.js

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

src/constants/coverage-type.js

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

src/iss-components/cart-dropdown/cart-dropdown.spec.js

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

src/layouts/coverage-statement/coverage-statement.spec.js

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

src/layouts/coverage-statement/coverage-statement.vue

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

src/layouts/duplicate-check/duplicate-check.spec.js

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

src/layouts/payment-method/payment-method.spec.js

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

src/layouts/tpa-submit/tpa-submit.spec.js

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

src/layouts/welcome-page/welcome-page.spec.js

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

src/layouts/welcome-page/welcome-page.vue

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

src/store/index.js

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

src/store/store.spec.js

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