unit tests and clean up

src/layouts/address-lookup/address-lookup.spec.js

@@ -468,5 +468,41 @@ describe('address-lookup.vue', () => {
             // Assert
             expect(wrapper.vm.navigateForwardWithSingleCarMatch).toHaveBeenCalledTimes(1);
         });
+
+        test('selected vehicle is a non-serviceable big truck, display no service alert', async () => {
+            // Arrange
+            const mockRegistrationAddress = {
+                streetAddress: '1234 Main St',
+                city: 'Columbus',
+                state: 'OH',
+                zipCode: '43215'
+            };
+
+            const { wrapper } = setupMocks({
+                vinVehicles: [
+                    { 
+                        vehicle: {
+                            carId: 'BIGTRUCKCARID',
+                            isBigTruck: true,
+                            canSafeliteService: false
+                        }
+                    }
+                ]
+            });
+
+            useMainStore().order.vehicle.carId = 'BIGTRUCKCARID';
+
+            await wrapper.setData({
+                customerQuestions: {
+                    addressQuestions: mockRegistrationAddress
+                },
+            });
+
+            // Act
+            await wrapper.vm.forwardButtonAction();
+
+            // Assert
+            expect(wrapper.findComponent({ ref: 'alertNoService' }).isVisible()).toBe(true);
+        });
     });
 });

src/layouts/address-lookup/address-lookup.vue

@@ -55,7 +55,7 @@
                         :isDismissible="false" />
                     <alert
                         v-if="displayNoServiceAlert"
-                        ref="AlertNoService"
+                        ref="alertNoService"
                         class="mt-5"
                         cmsWidgetName="AlertNoServiceWidget"
                         alertClass="alert-danger"
@@ -263,15 +263,6 @@ export default {
                 return this.$refs.siteFooter.removeLoader();
             }
 
-            // Check if vehicle is a non-servicable big truck
-            if (resultMap.vinLookupResponse.isBigTruck && !resultMap.vinLookupResponse.canSafeliteService) {
-                this.displayNoServiceAlert = true;
-                this.resetVehicleFromLookup();
-                this.$refs.siteFooter.disableForwardButton();
-                this.$refs.siteFooter.removeLoader();
-                return;
-            }
-
             const carsFound = resultMap.vinLookupResponse.vinVehicles;
 
             // Handle cases for different amounts of VINS found for the address.
@@ -279,6 +270,13 @@ export default {
                 // Single VIN found
                 const carFound = carsFound[0].vehicle;
 
+                // Check if vehicle is a non-servicable big truck
+                if (carFound.isBigTruck && !carFound.canSafeliteService) {
+                    this.displayNoServiceAlert = true;
+                    this.$refs.siteFooter.disableForwardButton();
+                    return this.$refs.siteFooter.removeLoader();
+                }
+
                 this.isCarIdDifferent =
                     carFound.carId !== useMainStore().order.vehicle.carId;
                 if (this.isCarIdDifferent && carFound.carId !== this.previouslyEnteredCarId) {

src/layouts/address-vehicles/address-vehicles.spec.js

@@ -120,6 +120,7 @@ function setupMocks({
     wrapper.vm.navigateBack = baseMixin.methods.navigateBack;
     wrapper.vm.$refs.siteFooter.updateButtonText = jest.fn();
     wrapper.vm.$refs.siteFooter.removeLoader = jest.fn();
+    wrapper.vm.$refs.siteFooter.disableForwardButton = jest.fn();
 
     return { wrapper };
 }
@@ -165,7 +166,7 @@ describe('address-vehicles.vue', () => {
     });
 
     // TODO: Add () to toReturn and ensure test passes.
-    test.skip('Should return out of forwardButtonAction is lookupVin returns an error', async () => {
+    test('Should return out of forwardButtonAction is lookupVin returns an error', async () => {
         // Arrange
         const { wrapper } = setupMocks({});
         wrapper.vm.navigateForwardWithSingleCarMatch = jest.fn();
@@ -248,4 +249,50 @@ describe('address-vehicles.vue', () => {
         // Assert
         expect(arePagePrerequisitesValid).toBe(true);
     });
+
+    test('selected vehicle is a non-serviceable big truck, display no service alert', async () => {
+        // Arrange
+        const { wrapper } = setupMocks({});
+        useMainStore().order.vehicle.carId = 'BIGTRUCKCARID';
+        useMainStore().applicationUser = {
+            pageData: {
+                'address-vehicles':
+                    [
+                        {
+                            vehicle: {
+                                carId: 'BIGTRUCKCARID',
+                                make: 'Isuzu',
+                                model: 'Reach',
+                                style: 'Step Van',
+                                year: 2015,
+                                isBigTruck: true,
+                                canSafeliteService: false
+                            },
+                            vin: 'BIGTRUCKVIN'
+                        }
+                    ]
+            }
+        };
+
+        await wrapper.setData({
+            selectedVehicleVin: 'BIGTRUCKVIN',
+            previouslyEnteredCarId: 'BIGTRUCKCARID'
+        });
+
+        wrapper.vm.selectedVehicle = {
+            vin: 'BIGTRUCKVIN',
+            vehicle: {
+                carId: 'BIGTRUCKCARID',
+                isBigTruck: true,
+                canSafeliteService: false
+            }
+        }
+        
+        // Act
+        await wrapper.vm.$nextTick();
+
+        // Assert
+        expect(wrapper.findComponent({ ref: 'AlertNoService' }).isVisible()).toBe(true);
+    });
+    
 });

src/layouts/address-vehicles/address-vehicles.vue

@@ -26,6 +26,13 @@
                         :manualHeadline="AlertFoundMultipleVehiclesHeader"
                         manualCopy=""
                         :isDismissible="false" />
+                    <alert
+                        ref="AlertNoService"
+                        v-if="displayNoServiceAlert"
+                        class="mt-5"
+                        cmsWidgetName="AlertVehicleSelection"
+                        alertClass="alert-danger"
+                        :isDismissable="false" />
                     <addressVehiclesQuestion
                         ref="addressVehiclesQuestion"
                         v-model="selectedVehicleVin"
@@ -156,7 +163,8 @@ export default {
             displayMatchedDifferentVehicleAlert: false,
             displayMatchedTwoIdenticalYMMVehicleAlert: false,
             previouslyEnteredCarId: '',
-            forwardButtonCarStyle: ''
+            forwardButtonCarStyle: '',
+            displayNoServiceAlert: false
         };
     },
     computed: {
@@ -211,6 +219,12 @@ export default {
         selectedVehicleVin: {
             handler() {
                 this.resetWarningsAndErrors();
+                // check if selected vehicle is a non-serviceable big truck
+                if (this.selectedVehicle?.vehicle.isBigTruck
+                    && !this.selectedVehicle?.vehicle.canSafeliteService) {
+                    this.displayNoServiceAlert = true;
+                    return this.$refs.siteFooter.disableForwardButton();
+                }
                 // does this vehicle match the previously selected carId?
                 this.isCarIdDifferent =
                     this.selectedVehicle?.vehicle.carId

src/layouts/license-plate-lookup/license-plate-lookup.spec.js

@@ -151,6 +151,37 @@ describe('license-plate-lookup.vue', () => {
             // Assert
             expect(wrapper.findComponent({ ref: 'alertVinNotFound' }).isVisible()).toBe(true);
         });
+        test('non-serviceable big truck found, display NoServiceAlert', async () => {
+            // Arrange
+            const mockRegistrationLicensePlate = {
+                licensePlate: 'BIGTRUCKTEST'
+            };  
+
+            const { wrapper } = setupMocks({
+                lookupVinByPlateResponse: {
+                    vin: 'BIGTRUCKVIN',
+                    vehicle: {
+                        carId: 'BIGTRUCKTESTCARID',
+                        isBigTruck: true,
+                        canSafeliteService: false
+                    }
+                }
+            });
+
+            useMainStore().order.vehicle.carId = 'BIGTRUCKTESTCARID';
+
+            await wrapper.setData({
+                licensePlate: mockRegistrationLicensePlate
+            });
+
+            wrapper.vm.navigateForward = jest.fn();
+
+            // Act
+            await wrapper.vm.forwardButtonAction();
+
+            // Assert
+            expect(wrapper.findComponent({ ref: 'alertNoService' }).isVisible()).toBe(true);
+        });
     });
 
     describe('navigation', () => {

src/layouts/license-plate-lookup/license-plate-lookup.vue

@@ -49,7 +49,7 @@
                         :isDismissible="false" />
                     <alert
                         v-if="displayNoServiceAlert"
-                        ref="AlertNoService"
+                        ref="alertNoService"
                         class="mt-5 mb-5"
                         cmsWidgetName="AlertNoServiceWidget"
                         alertClass="alert-danger"
@@ -281,6 +281,13 @@ export default {
             // Vehicle found from VIN lookup
             const vehicleFromLookup = vinLookupResponse.data.vehicle;
 
+            // Check if vehicle is a non-servicable big truck
+            if (vehicleFromLookup.isBigTruck && !vehicleFromLookup.canSafeliteService) {
+                this.displayNoServiceAlert = true;
+                this.$refs.siteFooter.disableForwardButton();
+                return this.$refs.siteFooter.removeLoader();
+            }
+
             // Check if the CarId has changed
             this.isCarIdDifferent = vehicleFromLookup.carId !== useMainStore().order.vehicle.carId;
             // Handle changing car
@@ -307,14 +314,6 @@ export default {
                 return this.$refs.siteFooter.removeLoader();
             }
 
-            // Check if vehicle is a non-servicable big truck
-            if (vehicleFromLookup.isBigTruck && !vehicleFromLookup.canSafeliteService) {
-                this.displayNoServiceAlert = true;
-                this.resetVehicleFromLookup();
-                this.$refs.siteFooter.disableForwardButton();
-                return this.$refs.siteFooter.removeLoader();
-            }
-
             // Save vehicle, license plate, and registration information
             useMainStore().saveRegistrationLicensePlateLookup({
                 isSelectedGlassAvailableForVehicle: this.isSelectedGlassAvailableForVehicle,

src/layouts/policy-vehicles/policy-vehicles.spec.js

@@ -57,7 +57,7 @@ function setupMocks() {
                 }
             },
             plugins: [createTestingPinia()]
-        }
+        },
     });
 
     const apiResponses = {
@@ -737,4 +737,29 @@ describe('policy-vehicles.vue', () => {
         // Assert
         expect(wrapper.vm.selectedVehicleVin).toBe(vin);
     });
+
+    test('selected vehicle is a non-serviceable big truck, display no service alert', async () => {
+        // Arrange
+        const vin = getRandomString(17, 17);
+        const policyVehicle = {
+            vin,
+            isBigTruck: true,
+            canSafeliteService: false
+        };
+
+        const { wrapper } = setupMocks({});
+
+        await wrapper.setData({
+            selectedVehicleVin: vin,
+            selectedPolicyVehicle: policyVehicle,
+            policyVehicles: [policyVehicle],
+            policyVinFound: true
+        });
+
+        wrapper.vm.displayNoServiceAlert = true;
+        await wrapper.vm.$nextTick();
+
+        // Assert
+        expect(wrapper.findComponent({ ref: 'AlertNoService' }).isVisible()).toBe(true);
+    });
 });

src/layouts/policy-vehicles/policy-vehicles.vue

@@ -27,14 +27,14 @@
                         <alert
                             ref="AlertNoService"
                             v-if="displayNoServiceAlert"
-                            class="mt-5"
+                            class="mt-3"
                             cmsWidgetName="AlertVehicleSelection"
                             alertClass="alert-danger"
                             :isDismissable="false" />
                         <siteFooter
                             ref="siteFooter"
                             cmsWidgetName="SiteFooterWidget"
-                            :isForwardActionDisabled="!meta.valid || displayNoServiceAlert"
+                            :isForwardActionDisabled="!meta.valid"
                             @ForwardClicked="forwardButtonAction"
                             @backClicked="backButtonAction" />
                     </div>
@@ -161,8 +161,10 @@ export default {
                     this.displayGeneric = true;
                     return;
                 }
-                if (vehicle.data.isBigTruck && !vehicle.data.canSafeliteService) {
+                // check if vehicle is a non-serviceable big truck
+                if (vehicle?.data.isBigTruck && !vehicle?.data.canSafeliteService) {
                     this.displayNoServiceAlert = true;
+                    this.$refs.siteFooter.disableForwardButton();
                 }
                 if (vehicle) {
                     // save selected vehicle to the store

src/layouts/vin-lookup/vin-lookup-alerts/vin-lookup-alerts.spec.js

@@ -68,4 +68,17 @@ describe('vin-lookup-alerts.vue', () => {
 
         expect(twoIdenticalYMMVehicleAlert).toBeVisible();
     });
+    test('NoServiceAlert is displayed on the screen', () => {
+        mountOptions.props = {
+            activeAlertType: vehicleLookupAlertTypes.NO_SERVICE
+        };
+        mountOptions.global.provide = {
+            vehicleFromLookup: {}
+        };
+
+        const { queryByRole } = render(VinLookupAlertsComponent, mountOptions);
+        const noServiceAlert = queryByRole('alert', { name: 'no-service-alert' });
+
+        expect(noServiceAlert).toBeVisible();
+    });
 });

src/layouts/vin-lookup/vin-lookup.spec.js

@@ -34,6 +34,7 @@ const lookupVehicleByVinCannotService = {
     mockResponse: {
         data: {
             carId: mockCarId,
+            isBigTruck: true,
             canSafeliteService: false
         }
     }
@@ -494,13 +495,13 @@ describe('vin-lookup.vue', () => {
                         );
                 });
             });
-            test('Bailout if entered vin cannot be serviced', async () => {
+            test('Display no service alert if entered vin cannot be serviced', async () => {
                 const user = userEvent.setup();
                 mountOptions.global.stubs.vinQuestion = false;
 
                 mountOptions.data = () => ({
                     vinWithNonMatchingCarId: false,
-                    isCarIdDifferentFromTheStore: false,
+                    isCarIdDifferentFromTheStore: false,    
                     vin: mockValidVin
                 });
 
@@ -521,12 +522,7 @@ describe('vin-lookup.vue', () => {
 
                 await flushPromises();
                 await waitFor(() => {
-                    expect(mockRouter.navigate).toHaveBeenCalledTimes(1);
+                    expect(container).toContainHTML('noService');
-                    expect(mockRouter.navigate)
-                        .toHaveBeenCalledWith(
-                            navigationScenarios.CLICKED_FORWARD_WITH_BAILOUT,
-                            mockRoute
-                        );
                 });
             });
 

src/store/store.spec.js

@@ -238,20 +238,6 @@ describe('Store', () => {
             expect(store.order.insuranceCoverage.coverageType).toBe(expected);
         });
     });
-    it('setVehicle is bailout if the vehicle cannot be serviced by Safelite', () => {
-        // Arrange
-        const vehicle = {
-            carId: getRandomString(6, 6),
-            canSafeliteService: false
-        };
-
-        // Act
-        store.updateVehicle(vehicle);
-
-        // Assert
-        expect(store.isBailout).toBe(true);
-        expect(store.bailoutCode).toBe(bailoutCode.HeavyTruckVehicle);
-    });
 
     // TODO update test to work also checking store values
     it('setVehicle should call globalMethods.callHttpClient', () => {