diff --git a/src/layouts/license-plate-lookup/license-plate-lookup.spec.js b/src/layouts/license-plate-lookup/license-plate-lookup.spec.js
index 281947ae4..99f1f86c8 100644
--- a/src/layouts/license-plate-lookup/license-plate-lookup.spec.js
+++ b/src/layouts/license-plate-lookup/license-plate-lookup.spec.js
@@ -30,8 +30,8 @@ jest.mock("@/store", () => ({
   dispatch: jest.fn(),
   getters: {
     order: {
-      customer: { emailAddress: "test@test.com"},
-      serviceLocation: {zip: "11111"},
+      customer: { emailAddress: "test@test.com" },
+      serviceLocation: { zip: "11111" },
     },
     vehicle: {
       carId: "TESTID",
@@ -48,382 +48,353 @@ jest.mock("@/store", () => ({
 }));
 
 describe("license-plate-lookup.vue", () => {
-  test("CarId set, arePagePrerequisitesValid should be true ", async () => {
-    //Arrange
-    const { wrapper } = setupMocks({});
+  describe("get values from store", () => {
+    test("getLicensePlateFromStore returns store license plate", async () => {
+      // Arrange
+      const { wrapper } = setupMocks({});
 
-    //Act
-    licensePlateLookup.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "license-plate-lookup" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
+      // ACT
+      const licensePlate = wrapper.vm.getLicensePlateFromStore();
 
-    let arePagePrerequisitesValid = wrapper.vm.arePagePrerequisitesValid();
-    await nextTick();
+      // Assert
+      expect(licensePlate).toEqual("TESTPLATE");
+    });
 
-    //Assert
-    expect(arePagePrerequisitesValid).toBe(true);
+    test("getRegistrationZipFromStore returns store registration zip", async () => {
+      // Arrange
+      const { wrapper } = setupMocks({});
+
+      // ACT
+      const registrationZip = wrapper.vm.getRegistrationZipFromStore();
+
+      // Assert
+      expect(registrationZip).toEqual("12345");
+    });
+
+    test("getEmailFromStore returns store customer email", async () => {
+      // Arrange
+      const { wrapper } = setupMocks({});
+
+      // ACT
+      const customerEmail = wrapper.vm.getEmailFromStore();
+
+      // Assert
+      expect(customerEmail).toEqual("test@test.com");
+    });
+
+    test("getServiceZipFromStore returns store service zip", async () => {
+      // Arrange
+      const { wrapper } = setupMocks({});
+
+      // ACT
+      const serviceZip = wrapper.vm.getServiceZipFromStore();
+
+      // Assert
+      expect(serviceZip).toEqual("11111");
+    });
   });
-});
 
-describe("license-plate-lookup.vue", () => {
-  test("BackButtonAction triggers a router.navigate change", async () => {
+  describe("navigation", () => {
+    test("BackButtonAction triggers a router.navigate change", async () => {
 
-    //Arrange
-    const { wrapper } = setupMocks({});
+      //Arrange
+      const { wrapper } = setupMocks({});
+  
+      //Act
+      licensePlateLookup.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "license-plate-lookup" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+  
+      wrapper.vm.backButtonAction();
+  
+      //Assert
+      expect(wrapper.vm.$router.navigate).toHaveBeenCalled();
+    });
 
-    //Act
-    licensePlateLookup.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "license-plate-lookup" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
+    describe("on forwardButtonAction click", () => {
+      test("Navigate forward should be called and isCarId should be set to false when data entered matches store data on forwardButtonAction click", async () => {
 
-    wrapper.vm.backButtonAction();
-
-    //Assert
-    expect(wrapper.vm.$router.navigate).toHaveBeenCalled();
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("getLicensePlateFromStore returns store license plate", async () => {
+        // Arrange
+        const { wrapper } = setupMocks({});
     
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    // ACT
-    const licensePlate = wrapper.vm.getLicensePlateFromStore();
-
-    // Assert
-    expect(licensePlate).toEqual("TESTPLATE");
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("getRegistrationZipFromStore returns store registration zip", async () => {
+        wrapper.vm.validateZip = jest.fn().mockImplementation(() => {
+          return { data: { isServiceable: true } };
+        });
+        wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
+          return '';
+        });
+        const vinLookup = { data: { vehicle: { carId: "TESTID" } } }
+        wrapper.vm.lookupVin = jest.fn().mockImplementation(() => {
+          return { catch: () => vinLookup };
+        });
+        wrapper.vm.navigateForward = jest.fn();
     
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    // ACT
-    const registrationZip = wrapper.vm.getRegistrationZipFromStore();
-
-    // Assert
-    expect(registrationZip).toEqual("12345");
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("getEmailFromStore returns store customer email", async () => {
+        //Act
+        licensePlateLookup.beforeRouteEnter.call(
+          wrapper.vm,
+          { query: { fmgPage: "license-plate-lookup" } },
+          undefined,
+          (c) => c(wrapper.vm)
+        );
     
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    // ACT
-    const customerEmail = wrapper.vm.getEmailFromStore();
-
-    // Assert
-    expect(customerEmail).toEqual("test@test.com");
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("getServiceZipFromStore returns store service zip", async () => {
+        await wrapper.vm.forwardButtonAction();
     
-    // Arrange
-    const { wrapper } = setupMocks({});
+        //Assert
+        expect(wrapper.vm.navigateForward).toHaveBeenCalled();
+        expect(wrapper.vm.isCarIdDifferent).toEqual(false);
+      });
 
-    // ACT
-    const serviceZip = wrapper.vm.getServiceZipFromStore();
+      test("Function should stop and datam isRegistrationZipServicable should be set to false when service zip entered returns false on forwardButtonAction click", async () => {
+        // Arrange
+        const { wrapper } = setupMocks({});
+    
+        wrapper.vm.validateZip = jest.fn().mockImplementation(() => {
+          return { data: { isServiceable: false } };
+        });
+        wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
+          return '';
+        });
+        wrapper.vm.$refs.funnelFooter.removeLoader = jest.fn();
 
-    // Assert
-    expect(serviceZip).toEqual("11111");
-  });
-});
+        //Act
+        licensePlateLookup.beforeRouteEnter.call(
+          wrapper.vm,
+          { query: { fmgPage: "license-plate-lookup" } },
+          undefined,
+          (c) => c(wrapper.vm)
+        );
+    
+        await wrapper.vm.forwardButtonAction();
+    
+        //Assert
+        expect(wrapper.vm.isRegistrationZipServicable).toEqual(false);
+      });
 
-describe("license-plate-lookup.vue", () => {
-  test("Navigate forward should be called and isCarId should be set to false when data entered matches store data on forwardButtonAction click", async () => {
+      test("Function should stop and datam isCarIdDifferent should be set to true when carId entered doesn't match store carId or previously entered carId on forwardButtonAction click", async () => {
+        // Arrange
+        const { wrapper } = setupMocks({});
+    
+        wrapper.vm.validateZip = jest.fn().mockImplementation(() => {
+          return { data: { isServiceable: true } };
+        });
+        wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
+          return '';
+        });
+        const vinLookup = { data: { vehicle: { carId: "TESTID1" } } }
+        wrapper.vm.lookupVin = jest.fn().mockImplementation(() => {
+          return { catch: () => vinLookup };
+        });
+        wrapper.vm.$refs.funnelFooter.removeLoader = jest.fn();
+        wrapper.vm.$refs.funnelFooter.updateButtonText = jest.fn();
+    
+        //Act
+        licensePlateLookup.beforeRouteEnter.call(
+          wrapper.vm,
+          { query: { fmgPage: "license-plate-lookup" } },
+          undefined,
+          (c) => c(wrapper.vm)
+        );
+    
+        await wrapper.vm.forwardButtonAction();
+    
+        //Assert
+        expect(wrapper.vm.isCarIdDifferent).toEqual(true);
+      });
 
-    // Arrange
-    const { wrapper } = setupMocks({});
+      test("Navigate forward should be called and isCarId should be set to true when carId entered matches previously entered carId and rest of data entered matches store data on forwardButtonAction click", async () => {
 
-    wrapper.vm.validateZip = jest.fn().mockImplementation(() => {
-      return {data: {isServiceable: true}};
+        // Arrange
+        const { wrapper } = setupMocks({});
+    
+        wrapper.vm.validateZip = jest.fn().mockImplementation(() => {
+          return { data: { isServiceable: true } };
+        });
+        wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
+          return '';
+        });
+        const vinLookup = { data: { vehicle: { carId: "TESTID1" } } }
+        wrapper.vm.lookupVin = jest.fn().mockImplementation(() => {
+          return { catch: () => vinLookup };
+        });
+        wrapper.vm.previouslyEnteredCarId = "TESTID1";
+        wrapper.vm.navigateForward = jest.fn();
+    
+        //Act
+        licensePlateLookup.beforeRouteEnter.call(
+          wrapper.vm,
+          { query: { fmgPage: "license-plate-lookup" } },
+          undefined,
+          (c) => c(wrapper.vm)
+        );
+    
+        await wrapper.vm.forwardButtonAction();
+    
+        //Assert
+        expect(wrapper.vm.navigateForward).toHaveBeenCalled();
+        expect(wrapper.vm.isCarIdDifferent).toEqual(true);
+      });
     });
-    wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
-      return '';
-   });
-    const vinLookup = {data: {vehicle: {carId: "TESTID"}}}
-    wrapper.vm.lookupVin = jest.fn().mockImplementation(() => {
-      return {catch: () => vinLookup};
+
+    describe("navigateForward", () => {
+      test("NavigateAfterSave should be called if isCarIdDifferent is true and isSelectedGlassAvailableForVehicle is false when navigateForward is called", async () => {
+
+        // Arrange
+        const { wrapper } = setupMocks({});
+    
+        //Act
+        wrapper.vm.isCarIdDifferent = true;
+        wrapper.vm.isSelectedGlassAvailableForVehicle = false;
+        wrapper.vm.$router.navigateAfterSave = jest.fn();
+        wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
+          return '';
+        });
+        store.dispatch = jest.fn();
+    
+        await wrapper.vm.navigateForward();
+    
+        //Assert
+        expect(wrapper.vm.$router.navigateAfterSave).toHaveBeenCalled();
+      });
+
+      test("navigateAfterSaveToHeritageFunnel should be called if isCarIdDifferent is false or isSelectedGlassAvailableForVehicle is true when navigateForward is called", async () => {
+
+        // Arrange
+        const { wrapper } = setupMocks({});
+    
+        //Act
+        wrapper.vm.isCarIdDifferent = false;
+        wrapper.vm.$refs.loadingModal.showModal = jest.fn();
+        wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
+          return '';
+        });
+        navigateToHeritage.navigateAfterSaveToHeritageFunnel = jest.fn();
+        await wrapper.vm.navigateForward();
+    
+        //Assert
+        expect(navigateToHeritage.navigateAfterSaveToHeritageFunnel).toHaveBeenCalled();
+      });
     });
-    wrapper.vm.navigateForward = jest.fn();
-
-    //Act
-    licensePlateLookup.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "license-plate-lookup" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-      
-    await wrapper.vm.forwardButtonAction();
-
-    //Assert
-    expect(wrapper.vm.navigateForward).toHaveBeenCalled();
-    expect(wrapper.vm.isCarIdDifferent).toEqual(false);
   });
-});
 
-describe("license-plate-lookup.vue", () => {
-  test("Function should stop and datam isRegistrationZipServicable should be set to false when service zip entered returns false on forwardButtonAction click", async () => {
+  describe("button text", () => {
+    test("Button Text should revert to initial value when licensePlate textfield has new text", async () => {
 
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    wrapper.vm.validateZip = jest.fn().mockImplementation(() => {
-      return {data: {isServiceable: false}};
+      // Arrange
+      const { wrapper } = setupMocks({});
+  
+      //Act
+      wrapper.vm.licensePlate = "NEWPLATE";
+      wrapper.vm.getCmsContent = jest.fn();
+      wrapper.vm.$refs.funnelFooter.updateButtonText = jest.fn();
+      await wrapper.vm.$nextTick();
+  
+      //Assert
+      expect(wrapper.vm.$refs.funnelFooter.updateButtonText).toHaveBeenCalled();
     });
-    wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
-      return '';
-   });
-    wrapper.vm.$refs.funnelFooter.removeLoader = jest.fn();
-    //Act
-    licensePlateLookup.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "license-plate-lookup" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-      
-    await wrapper.vm.forwardButtonAction();
 
-    //Assert
-    expect(wrapper.vm.isRegistrationZipServicable).toEqual(false);
-  });
-});
+    test("Button Text should revert to initial value when registrationZip textfield has new text", async () => {
 
-describe("license-plate-lookup.vue", () => {
-  test("Function should stop and datam isCarIdDifferent should be set to true when carId entered doesn't match store carId or previously entered carId on forwardButtonAction click", async () => {
-
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    wrapper.vm.validateZip = jest.fn().mockImplementation(() => {
-      return {data: {isServiceable: true}};
+      // Arrange
+      const { wrapper } = setupMocks({});
+  
+      //Act
+      wrapper.vm.registrationZip = "55555";
+      wrapper.vm.getCmsContent = jest.fn();
+      wrapper.vm.$refs.funnelFooter.updateButtonText = jest.fn();
+      await wrapper.vm.$nextTick();
+  
+      //Assert
+      expect(wrapper.vm.$refs.funnelFooter.updateButtonText).toHaveBeenCalled();
     });
-    wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
-      return '';
-   });
-    const vinLookup = {data: {vehicle: {carId: "TESTID1"}}}
-    wrapper.vm.lookupVin = jest.fn().mockImplementation(() => {
-      return {catch: () => vinLookup};
+
+    test("Button Text should revert to initial value when serviceZip textfield has new text", async () => {
+
+      // Arrange
+      const { wrapper } = setupMocks({});
+  
+      //Act
+      wrapper.vm.serviceZip = "55555";
+      wrapper.vm.getCmsContent = jest.fn();
+      wrapper.vm.$refs.funnelFooter.updateButtonText = jest.fn();
+      await wrapper.vm.$nextTick();
+  
+      //Assert
+      expect(wrapper.vm.$refs.funnelFooter.updateButtonText).toHaveBeenCalled();
     });
-    wrapper.vm.$refs.funnelFooter.removeLoader = jest.fn();
-    wrapper.vm.$refs.funnelFooter.updateButtonText = jest.fn();
+  })
 
-    //Act
-    licensePlateLookup.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "license-plate-lookup" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-      
-    await wrapper.vm.forwardButtonAction();
-
-    //Assert
-    expect(wrapper.vm.isCarIdDifferent).toEqual(true);
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("Navigate forward should be called and isCarId should be set to true when carId entered matches previously entered carId and rest of data entered matches store data on forwardButtonAction click", async () => {
-
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    wrapper.vm.validateZip = jest.fn().mockImplementation(() => {
-      return {data: {isServiceable: true}};
+  describe("miscellaneous", () => {
+    test("CarId set, arePagePrerequisitesValid should be true ", async () => {
+      //Arrange
+      const { wrapper } = setupMocks({});
+    
+      //Act
+      licensePlateLookup.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "license-plate-lookup" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+    
+      let arePagePrerequisitesValid = wrapper.vm.arePagePrerequisitesValid();
+      await nextTick();
+    
+      //Assert
+      expect(arePagePrerequisitesValid).toBe(true);
     });
-    wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
-      return '';
-   });
-    const vinLookup = {data: {vehicle: {carId: "TESTID1"}}}
-    wrapper.vm.lookupVin = jest.fn().mockImplementation(() => {
-      return {catch: () => vinLookup};
+
+    test("Dispatch reset damage and dependencies should be called if isCarIdDifferent is true and isSelectedGlassAvailableForVehicle is false when updateCustomerInfo is called", async () => {
+
+      // Arrange
+      const { wrapper } = setupMocks({});
+  
+      //Act
+      wrapper.vm.isCarIdDifferent = true;
+      wrapper.vm.isSelectedGlassAvailableForVehicle = false;
+      wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
+        return '';
+      });
+      store.commit = jest.fn();
+      store.dispatch = jest.fn();
+  
+      const vehicleInfo = { year: "2020", make: "honda", model: "civic", style: "2 door", carId: "TestId", category: "testCat", imageUrl: "image.jpg", imageVifNumber: "123", imageColor: "blue" }
+      await wrapper.vm.updateCustomerInfo('vin', vehicleInfo, 'registrationState');
+  
+      //Assert
+      expect(store.dispatch).toHaveBeenCalled();
     });
-    wrapper.vm.previouslyEnteredCarId = "TESTID1";
-    wrapper.vm.navigateForward = jest.fn();
 
-    //Act
-    licensePlateLookup.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "license-plate-lookup" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-      
-    await wrapper.vm.forwardButtonAction();
+    test("dispatch non blocking store action called on validate zip", async () => {
 
-    //Assert
-    expect(wrapper.vm.navigateForward).toHaveBeenCalled();
-    expect(wrapper.vm.isCarIdDifferent).toEqual(true);
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("Button Text should revert to initial value when licensePlate textfield has new text", async () => {
-
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    wrapper.vm.licensePlate = "NEWPLATE";
-    wrapper.vm.getCmsContent = jest.fn();
-    wrapper.vm.$refs.funnelFooter.updateButtonText = jest.fn();
-    await wrapper.vm.$nextTick();
-
-    //Assert
-    expect(wrapper.vm.$refs.funnelFooter.updateButtonText).toHaveBeenCalled();
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("Button Text should revert to initial value when registrationZip textfield has new text", async () => {
-
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    wrapper.vm.registrationZip = "55555";
-    wrapper.vm.getCmsContent = jest.fn();
-    wrapper.vm.$refs.funnelFooter.updateButtonText = jest.fn();
-    await wrapper.vm.$nextTick();
-
-    //Assert
-    expect(wrapper.vm.$refs.funnelFooter.updateButtonText).toHaveBeenCalled();
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("Button Text should revert to initial value when serviceZip textfield has new text", async () => {
-
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    wrapper.vm.serviceZip = "55555";
-    wrapper.vm.getCmsContent = jest.fn();
-    wrapper.vm.$refs.funnelFooter.updateButtonText = jest.fn();
-    await wrapper.vm.$nextTick();
-
-    //Assert
-    expect(wrapper.vm.$refs.funnelFooter.updateButtonText).toHaveBeenCalled();
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("Dispatch reset damage and dependencies should be called if isCarIdDifferent is true and isSelectedGlassAvailableForVehicle is false when updateCustomerInfo is called", async () => {
-
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    wrapper.vm.isCarIdDifferent = true;
-    wrapper.vm.isSelectedGlassAvailableForVehicle = false;
-    wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
-       return '';
+      // Arrange
+      const { wrapper } = setupMocks({});
+  
+      //Act
+      await wrapper.vm.validateZip("12345");
+  
+  
+      //Assert
+      expect(baseMixin.methods.dispatchStoreAction).toHaveBeenCalled();
     });
-    store.commit = jest.fn();
-    store.dispatch = jest.fn();
 
-    const vehicleInfo = {year: "2020", make: "honda", model: "civic", style: "2 door", carId: "TestId", category: "testCat", imageUrl: "image.jpg", imageVifNumber: "123", imageColor: "blue"}
-    await wrapper.vm.updateCustomerInfo('vin', vehicleInfo, 'registrationState');
+    test("dispatch non blocking store action called on lookup vin", async () => {
 
-    //Assert
-    expect(store.dispatch).toHaveBeenCalled();
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("NavigateAfterSave should be called if isCarIdDifferent is true and isSelectedGlassAvailableForVehicle is false when navigateForward is called", async () => {
-
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    wrapper.vm.isCarIdDifferent = true;
-    wrapper.vm.isSelectedGlassAvailableForVehicle = false;
-    wrapper.vm.$router.navigateAfterSave = jest.fn();
-    wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
-      return '';
+      // Arrange
+      const { wrapper } = setupMocks({});
+  
+      //Act
+      await wrapper.vm.lookupVin("zzz123fqsfwg");
+  
+  
+      //Assert
+      expect(baseMixin.methods.dispatchStoreAction).toHaveBeenCalled();
     });
-    store.dispatch = jest.fn();
-
-    await wrapper.vm.navigateForward();
-
-    //Assert
-    expect(wrapper.vm.$router.navigateAfterSave).toHaveBeenCalled();
-  });
+  })
 });
 
-describe("license-plate-lookup.vue", () => {
-  test("navigateAfterSaveToHeritageFunnel should be called if isCarIdDifferent is false or isSelectedGlassAvailableForVehicle is true when navigateForward is called", async () => {
-
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    wrapper.vm.isCarIdDifferent = false;
-    wrapper.vm.$refs.loadingModal.showModal = jest.fn();
-    wrapper.vm.getCmsContent = jest.fn().mockImplementation(() => {
-      return '';
-    });
-    navigateToHeritage.navigateAfterSaveToHeritageFunnel = jest.fn();
-    await wrapper.vm.navigateForward();
-
-    //Assert
-    expect(navigateToHeritage.navigateAfterSaveToHeritageFunnel).toHaveBeenCalled();
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("dispatch non blocking store action called on validate zip", async () => {
-
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    await wrapper.vm.validateZip("12345");
-
-
-    //Assert
-    expect(baseMixin.methods.dispatchStoreAction).toHaveBeenCalled();
-  });
-});
-
-describe("license-plate-lookup.vue", () => {
-  test("dispatch non blocking store action called on lookup vin", async () => {
-
-    // Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    await wrapper.vm.lookupVin("zzz123fqsfwg");
-
-
-    //Assert
-    expect(baseMixin.methods.dispatchStoreAction).toHaveBeenCalled();
-  });
-});
-
-
-
 function setupMocks({
   pageHeaderWidgetHeaderText = {},
   mountOptionsMockData = {
diff --git a/src/layouts/vehicle-damage/vehicle-damage.spec.js b/src/layouts/vehicle-damage/vehicle-damage.spec.js
index 0ce0fe085..46fa7763e 100644
--- a/src/layouts/vehicle-damage/vehicle-damage.spec.js
+++ b/src/layouts/vehicle-damage/vehicle-damage.spec.js
@@ -51,650 +51,663 @@ jest.mock("@/store", () => ({
     },
     eventBusItem: jest.fn(),
     damage: {
-      glassToReplace: [] 
+      glassToReplace: []
     },
   },
 }));
 
 describe("vehicle-damage.vue", () => {
-  test("CarId set, arePagePrerequisitesValid should be true ", async () => {
-    //Arrange
-    const { wrapper } = setupMocks({});
+  describe("navigation", () => {
+    test("BackButtonAction triggers a router.navigate change", async () => {
 
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
+      //Arrange
+      const { wrapper } = setupMocks({});
 
-    let arePagePrerequisitesValid = wrapper.vm.arePagePrerequisitesValid();
-    await nextTick();
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
 
-    //Assert
-    expect(arePagePrerequisitesValid).toBe(true);
-  });
-});
+      wrapper.vm.backButtonAction();
 
-describe("vehicle-damage.vue", () => {
-  test("BackButtonAction triggers a router.navigate change", async () => {
+      //Assert
+      expect(wrapper.vm.$router.navigate).toHaveBeenCalled();
 
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    wrapper.vm.backButtonAction();
-
-    //Assert
-    expect(wrapper.vm.$router.navigate).toHaveBeenCalled();
-
-  });
-});
-
-describe("vehicle-damage.vue", () => {
-  test("Replace several pieces of glass on ForwardButtonAction triggers a router.navigateAfterSave and saves selections to store", async () => {
-    //Arrange
-    const partsData = {
-      partsOrQuestions: [{
-        glassName: "Single",
-        glassLocation: "Windshield",
-        parts: null,
-        partQuestions: [{
-          questionSequence: 1,
-          questionText: "Is your vehicle equipped with a heated steering wheel?",
-          answers: [{
-            answerText: "Yes",
-            nextQuestionSequence: null,
-            answerResult: "FW04957"
-          },
-          {
-            answerText: "No",
-            nextQuestionSequence: 2,
-            answerResult: ""
-          }]
-        },
-        {
-          questionSequence: 2,
-          questionText: "Is your vehicle equipped with a remote start?",
-          answers: [{
-            answerText: "Yes",
-            nextQuestionSequence: null,
-            answerResult: "FW04181"
-          },
-          {
-            answerText: "No",
-            nextQuestionSequence: null,
-            answerResult: "FW04179"
-          }]
-        }]
-      }]
-    };
-
-    const { wrapper } = setupMocks({
-      pageHeaderWidgetHeaderText: "",
-      mountOptionsMockData: {
-        router: { navigateAfterSave: jest.fn(), },
-        actionList: [{ actionName: storeActions.GET_PARTS_OR_QUESTIONS, data: partsData, },],
-        store: {
-          getters: {
-            vehicle: {},
-            payment: { insuranceCoverage: { isVerified: false } },
-          },
-        },
-      },
     });
 
-    wrapper.vm.selectedDamageLocations = ["Windshield", "SideDoor", "RearWindow"];
-    wrapper.vm.selectedWindshieldOptions = { 
-      selectedWindshieldChipCount : null,
-      selectedWindshieldReplaceOptions : ["Single"], 
-      selectedWindshieldDamageType: ["Replace"]
-    };
-
-    wrapper.vm.sideDoorOptionsData = { 
-      selectedDoorSides: ["DriverSide", "PassengerSide"],
-      selectedDriverSideReplaceOptions: ["Back"], 
-      selectedPassengerSideReplaceOptions: ["Quarter"]
-    };
-
-    wrapper.vm.selectedRearReplaceOptions = ["Stationary"];
-
-    const expectedGlassToReplace = [{location: "Windshield", name: "Single"}, {location: "Driver", name: "Back"}, 
-      {location: "Passenger", name: "Quarter"}, {location: "Rear", name: "Stationary"}];
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-      
-    await wrapper.vm.forwardButtonAction();
-
-    //Assert
-    expect(wrapper.vm.$router.navigateAfterSave).toHaveBeenCalled();
-    expect(wrapper.vm.selectedGlassToReplace()).toEqual(expectedGlassToReplace);
-    expect(store.commit).toBeCalledWith(storeMutations.UPDATE_IS_REPAIR, false);
-    expect(store.commit).toBeCalledWith(storeMutations.UPDATE_GLASS_TO_REPLACE, expectedGlassToReplace);
-  });
-});
-
-describe("vehicle-damage.vue", () => {
-  test("Windshield replace with multiple parts on ForwardButtonAction triggers a router.navigateAfterSave and saves selections to store", async () => {
-    //Arrange
-    const partsData = { partsOrQuestions: [
-      {
-        glassLocation: "Windshield",
-        glassName: "Single",
-        partQuestions: null,
-        parts: [
-          {
-            color: "Green Tint, Green Shade",
-            description: "rain sensor, solar",
-            partNumber: "FW02728GGYN",
-            requiresCapabilityQuestions: false,
-            requiresRecalibration: false 
-          },
-          {
-            color: "Green Tint, Green Shade",
-            description: "rain sensor, solar, hydrophobic coating",
-            partNumber: "FW02760GGYN",
-            requiresCapabilityQuestions: false,
-            requiresRecalibration: false
-          }
-        ]},
-        {
-          glassName: "Stationary",
-          glassLocation: "Rear",
-          parts: [
-            {
-              partNumber: "DB09626GTYN",
-              description: "heated glass, solar, antenna",
-              color: "Green Tint",
-              requiresRecalibration: false,
-              requiresCapabilityQuestions: false,
-              childParts: null
+    test("Replace several pieces of glass on ForwardButtonAction triggers a router.navigateAfterSave and saves selections to store", async () => {
+      //Arrange
+      const partsData = {
+        partsOrQuestions: [{
+          glassName: "Single",
+          glassLocation: "Windshield",
+          parts: null,
+          partQuestions: [{
+            questionSequence: 1,
+            questionText: "Is your vehicle equipped with a heated steering wheel?",
+            answers: [{
+              answerText: "Yes",
+              nextQuestionSequence: null,
+              answerResult: "FW04957"
             },
             {
-              partNumber: "DB09821GTYN",
-              description: "heated glass, solar, antenna, onstar",
-              color: "Green Tint",
-              requiresRecalibration: false,
-              requiresCapabilityQuestions: false,
-              childParts: null
-            }
-          ],
-          "partQuestions": null
-        }
-      ]};
-
-    const { wrapper } = setupMocks({
-      pageHeaderWidgetHeaderText: "",
-      mountOptionsMockData: {
-        router: { navigateAfterSave: jest.fn(), },
-        actionList: [{ actionName: storeActions.GET_PARTS_OR_QUESTIONS, data: partsData, },],
-        store: {
-          getters: {
-            vehicle: {},
-            payment: { insuranceCoverage: { isVerified: false } },
+              answerText: "No",
+              nextQuestionSequence: 2,
+              answerResult: ""
+            }]
           },
-        },
-      },
-    });
-
-    wrapper.vm.selectedDamageLocations = ["Windshield"];
-    wrapper.vm.selectedWindshieldOptions = { 
-      selectedWindshieldChipCount : null,
-      selectedWindshieldReplaceOptions : ["Single"], 
-      selectedWindshieldDamageType: ["Replace"]
-    };
-
-    const expectedGlassToReplace = [{location: "Windshield", name: "Single"},];
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-      
-    await wrapper.vm.forwardButtonAction();
-
-    //Assert
-    expect(wrapper.vm.$router.navigateAfterSave).toHaveBeenCalled();
-    expect(wrapper.vm.selectedGlassToReplace()).toEqual(expectedGlassToReplace);
-    expect(store.commit).toBeCalledWith(storeMutations.UPDATE_IS_REPAIR, false);
-    expect(store.commit).toBeCalledWith(storeMutations.UPDATE_GLASS_TO_REPLACE, expectedGlassToReplace);
-  });
-});
-
-describe("vehicle-damage.vue", () => {
-  test("isWindshieldDamageLocation is true when windshield is selected", async () => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    wrapper.vm.selectedDamageLocations = ["Windshield"];
-
-    //Assert
-    expect(wrapper.vm.isWindshieldDamageLocation).toEqual(true);
-  });
-});
-
-describe("vehicle-damage.vue", () => {
-  test("isSideDoorDamageLocation is true Side door is selected", async () => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    wrapper.vm.selectedDamageLocations = ["Sidedoor"];
-
-    //Assert
-    expect(wrapper.vm.isSideDoorDamageLocation).toEqual(true);
-  });
-});
-
-
-describe("vehicle-damage.vue", () => {
-  test("isRearWindowDamageLocation is true if Rear Window damage is selected", async () => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    wrapper.vm.selectedDamageLocations = ["RearWindow"];
-
-    //Assert
-    expect(wrapper.vm.isRearWindowDamageLocation).toEqual(true);
-  });
-});
-
-describe("vehicle-damage.vue", () => {
-  test("isWindshieldRepair is true if windshield repair is selected", async () => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    wrapper.vm.selectedDamageLocations = ["Windshield"];
-    wrapper.vm.selectedWindshieldOptions = { selectedWindshieldDamageType: ["Repair"]};
-
-    //Assert
-    expect(wrapper.vm.isWindshieldRepair).toEqual(true);
-  });
-});
-
-describe("vehicle-damage.vue", () => {
-  test("isWindshieldRepair is false if windshield damage is not selected", async () => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    wrapper.vm.selectedDamageLocations = ["SideDoor"];
-    wrapper.vm.selectedWindshieldOptions = { selectedWindshieldDamageType: ["Repair"]};
-
-    //Assert
-    expect(wrapper.vm.isWindshieldRepair).toEqual(false);
-  });
-});
-
-describe("vehicle-damage.vue", () => {
-  test("isDriverSideReplace is true if side door driver is selected", async () => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    wrapper.vm.selectedDamageLocations = ["Sidedoor"];
-    wrapper.vm.sideDoorOptionsData = { selectedDoorSides: ["DriverSide"]};
-
-    //Assert
-    expect(wrapper.vm.isDriverSideReplace).toEqual(true);
-  });
-});
-
-describe("vehicle-damage.vue", () => {
-  test("isPassengerSideReplace is true if side door passenger selected", async () => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    wrapper.vm.selectedDamageLocations = ["Sidedoor"];
-    wrapper.vm.sideDoorOptionsData = { selectedDoorSides: ["PassengerSide"]};
-
-    //Assert
-    expect(wrapper.vm.isPassengerSideReplace).toEqual(true);
-  });
-});
-
-describe("vehicle-damage.vue", () => {
-  test("Call invalidation, ResetPartsAndState should be called", async () => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    wrapper.vm.resetDependentState();
-
-    //Assert
-    expect(store.dispatch).toBeCalledWith(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES)
-
-  });
-});
-
-const damageLocations = [["Windshield", [damageLocationsSelected.WINDSHIELD]],
-               ["Driver", [damageLocationsSelected.SIDEDOOR]],
-               ["Passenger", [damageLocationsSelected.SIDEDOOR]],
-               ["Rear", [damageLocationsSelected.REARWINDOW]]];
-describe("vehicle-damage.vue", () => {
-  test.each(damageLocations)("getDamageLocationsFromStore for %s returns expected %s", async (damageLocation, expectedGlass) => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    store.getters = { vehicle: { carId: "C0000000" }, eventBusItem: jest.fn(), damage: { glassToReplace: [{location: damageLocation}] }, isRepair: true};
-
-    var glassSelections = wrapper.vm.getDamageLocationsFromStore();
-      
-    //Assert
-    expect(glassSelections).toEqual(expectedGlass);
-
-  });
-});
-
-const storeWindshieldOptions = [[1, false, "Windshield", "Single", { selectedWindshieldDamageType: [damageLocationsSelected.REPLACE], 
-                                selectedWindshieldChipCount: [], selectedWindshieldReplaceOptions: [damageLocationsSelected.SINGLE]}],
-                                [2, false, "Windshield", "Driver", { selectedWindshieldDamageType: [damageLocationsSelected.REPLACE], 
-                                  selectedWindshieldChipCount: [], selectedWindshieldReplaceOptions: [damageLocationsSelected.DRIVER]}],
-                                [3, false, "Windshield", "Passenger", { selectedWindshieldDamageType: [damageLocationsSelected.REPLACE], 
-                                  selectedWindshieldChipCount: [], selectedWindshieldReplaceOptions: [damageLocationsSelected.PASSENGER]}],
-                                [4, true, "", "", { selectedWindshieldDamageType: [damageLocationsSelected.REPAIR], 
-                                  selectedWindshieldChipCount: [2], selectedWindshieldReplaceOptions: []}]
-                               ];
-describe("vehicle-damage.vue", () => {
-  test.each(storeWindshieldOptions)("getWindshieldOptionsFromStore test #%s", async (testNum, isRepair, damageLocation, damageName, expectedWindshieldOptions) => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    store.getters = { 
-      vehicle: 
-        { carId: "C0000000" }, 
-        eventBusItem: jest.fn(),
-        damage: 
-          { 
-            glassToReplace: [{location: damageLocation, name: damageName}],
-            isRepair: isRepair,
-            numberOfChips: 2 
-          }, 
+          {
+            questionSequence: 2,
+            questionText: "Is your vehicle equipped with a remote start?",
+            answers: [{
+              answerText: "Yes",
+              nextQuestionSequence: null,
+              answerResult: "FW04181"
+            },
+            {
+              answerText: "No",
+              nextQuestionSequence: null,
+              answerResult: "FW04179"
+            }]
+          }]
+        }]
       };
 
-    var windshieldSelections = wrapper.vm.getWindshieldOptionsFromStore();
-      
-    //Assert
-    expect(windshieldSelections).toEqual(expectedWindshieldOptions);
+      const { wrapper } = setupMocks({
+        pageHeaderWidgetHeaderText: "",
+        mountOptionsMockData: {
+          router: { navigateAfterSave: jest.fn(), },
+          actionList: [{ actionName: storeActions.GET_PARTS_OR_QUESTIONS, data: partsData, },],
+          store: {
+            getters: {
+              vehicle: {},
+              payment: { insuranceCoverage: { isVerified: false } },
+            },
+          },
+        },
+      });
+
+      wrapper.vm.selectedDamageLocations = ["Windshield", "SideDoor", "RearWindow"];
+      wrapper.vm.selectedWindshieldOptions = {
+        selectedWindshieldChipCount: null,
+        selectedWindshieldReplaceOptions: ["Single"],
+        selectedWindshieldDamageType: ["Replace"]
+      };
+
+      wrapper.vm.sideDoorOptionsData = {
+        selectedDoorSides: ["DriverSide", "PassengerSide"],
+        selectedDriverSideReplaceOptions: ["Back"],
+        selectedPassengerSideReplaceOptions: ["Quarter"]
+      };
+
+      wrapper.vm.selectedRearReplaceOptions = ["Stationary"];
+
+      const expectedGlassToReplace = [{ location: "Windshield", name: "Single" }, { location: "Driver", name: "Back" },
+      { location: "Passenger", name: "Quarter" }, { location: "Rear", name: "Stationary" }];
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      await wrapper.vm.forwardButtonAction();
+
+      //Assert
+      expect(wrapper.vm.$router.navigateAfterSave).toHaveBeenCalled();
+      expect(wrapper.vm.selectedGlassToReplace()).toEqual(expectedGlassToReplace);
+      expect(store.commit).toBeCalledWith(storeMutations.UPDATE_IS_REPAIR, false);
+      expect(store.commit).toBeCalledWith(storeMutations.UPDATE_GLASS_TO_REPLACE, expectedGlassToReplace);
+    });
+
+    test("Windshield replace with multiple parts on ForwardButtonAction triggers a router.navigateAfterSave and saves selections to store", async () => {
+      //Arrange
+      const partsData = {
+        partsOrQuestions: [
+          {
+            glassLocation: "Windshield",
+            glassName: "Single",
+            partQuestions: null,
+            parts: [
+              {
+                color: "Green Tint, Green Shade",
+                description: "rain sensor, solar",
+                partNumber: "FW02728GGYN",
+                requiresCapabilityQuestions: false,
+                requiresRecalibration: false
+              },
+              {
+                color: "Green Tint, Green Shade",
+                description: "rain sensor, solar, hydrophobic coating",
+                partNumber: "FW02760GGYN",
+                requiresCapabilityQuestions: false,
+                requiresRecalibration: false
+              }
+            ]
+          },
+          {
+            glassName: "Stationary",
+            glassLocation: "Rear",
+            parts: [
+              {
+                partNumber: "DB09626GTYN",
+                description: "heated glass, solar, antenna",
+                color: "Green Tint",
+                requiresRecalibration: false,
+                requiresCapabilityQuestions: false,
+                childParts: null
+              },
+              {
+                partNumber: "DB09821GTYN",
+                description: "heated glass, solar, antenna, onstar",
+                color: "Green Tint",
+                requiresRecalibration: false,
+                requiresCapabilityQuestions: false,
+                childParts: null
+              }
+            ],
+            "partQuestions": null
+          }
+        ]
+      };
+
+      const { wrapper } = setupMocks({
+        pageHeaderWidgetHeaderText: "",
+        mountOptionsMockData: {
+          router: { navigateAfterSave: jest.fn(), },
+          actionList: [{ actionName: storeActions.GET_PARTS_OR_QUESTIONS, data: partsData, },],
+          store: {
+            getters: {
+              vehicle: {},
+              payment: { insuranceCoverage: { isVerified: false } },
+            },
+          },
+        },
+      });
+
+      wrapper.vm.selectedDamageLocations = ["Windshield"];
+      wrapper.vm.selectedWindshieldOptions = {
+        selectedWindshieldChipCount: null,
+        selectedWindshieldReplaceOptions: ["Single"],
+        selectedWindshieldDamageType: ["Replace"]
+      };
+
+      const expectedGlassToReplace = [{ location: "Windshield", name: "Single" },];
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      await wrapper.vm.forwardButtonAction();
+
+      //Assert
+      expect(wrapper.vm.$router.navigateAfterSave).toHaveBeenCalled();
+      expect(wrapper.vm.selectedGlassToReplace()).toEqual(expectedGlassToReplace);
+      expect(store.commit).toBeCalledWith(storeMutations.UPDATE_IS_REPAIR, false);
+      expect(store.commit).toBeCalledWith(storeMutations.UPDATE_GLASS_TO_REPLACE, expectedGlassToReplace);
+    });
+
 
   });
-});
 
-const driverDoorSides = [["Driver", "Front", [damageLocationsSelected.FRONT]],
-                   ["Driver", "Back", [damageLocationsSelected.BACK]],
-                   ["Driver", "Vent", [damageLocationsSelected.VENT]],
-                   ["Driver", "Quarter", [damageLocationsSelected.QUARTER]]
-                  ];
-describe("vehicle-damage.vue", () => {
-  test.each(driverDoorSides)("getDriverSideReplaceOptionsFromStore for %s-%s returns expected %s", async (damageLocation, damageName, expectedGlass) => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    store.getters = { vehicle: { carId: "C0000000" }, eventBusItem: jest.fn(), damage: { glassToReplace: [{location: damageLocation, name: damageName}] }, isRepair: true};
-
-    var glassSelections = wrapper.vm.getDriverSideReplaceOptionsFromStore();
-      
-    //Assert
-    expect(glassSelections).toEqual(expectedGlass);
-
-  });
-});
-
-const passengerDoorSides = [["Passenger", "Front", [damageLocationsSelected.FRONT]],
-                   ["Passenger", "Back", [damageLocationsSelected.BACK]],
-                   ["Passenger", "Vent", [damageLocationsSelected.VENT]],
-                   ["Passenger", "Quarter", [damageLocationsSelected.QUARTER]]
-                  ];
-describe("vehicle-damage.vue", () => {
-  test.each(passengerDoorSides)("getPassengerSideReplaceOptionsFromStore for %s-%s returns expected %s", async (damageLocation, damageName, expectedGlass) => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    store.getters = { vehicle: { carId: "C0000000" }, eventBusItem: jest.fn(), damage: { glassToReplace: [{location: damageLocation, name: damageName}] }, isRepair: true};
-
-    var glassSelections = wrapper.vm.getPassengerSideReplaceOptionsFromStore();
-      
-    //Assert
-    expect(glassSelections).toEqual(expectedGlass);
-
-  });
-});
-
-const rearReplaceOptions = [["Rear", "Stationary", [damageLocationsSelected.STATIONARY]],
-                   ["Rear", "Slider", [damageLocationsSelected.SLIDER]]
-                  ];
-describe("vehicle-damage.vue", () => {
-  test.each(rearReplaceOptions)("getRearReplaceOptionsFromStore for %s-%s returns expected %s", async (damageLocation, damageName, expectedGlass) => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-
-    store.getters = { vehicle: { carId: "C0000000" }, eventBusItem: jest.fn(), damage: { glassToReplace: [{location: damageLocation, name: damageName}] }, isRepair: true};
-
-    var glassSelections = wrapper.vm.getRearReplaceOptionsFromStore();
-      
-    //Assert
-    expect(glassSelections).toEqual(expectedGlass);
-
-  });
-});
-
-describe("vehicle-damage.vue", () => {
-  test("when displayVehicleChangeAlert router params is true, the alert: 'vehicleChangeAlert' should be visible", () => {
-    // Arrange & Act
-    const { wrapper } = setupMocks({
-      mountOptionsMockData: {
-        route: {
-          params: {
-            [routerParams.DISPLAY_VEHICLE_CHANGE_ALERT]: true
+  describe("alert", () => {
+    test("when displayVehicleChangeAlert router params is true, the alert: 'vehicleChangeAlert' should be visible", () => {
+      // Arrange & Act
+      const { wrapper } = setupMocks({
+        mountOptionsMockData: {
+          route: {
+            params: {
+              [routerParams.DISPLAY_VEHICLE_CHANGE_ALERT]: true
+            }
           }
         }
-      }
+      });
+      // Assert
+      expect(wrapper.findComponent({ ref: 'vehicleChangeAlert' }).isVisible()).toBe(true);
     });
-    // Assert
-    expect(wrapper.findComponent({ref: 'vehicleChangeAlert'}).isVisible()).toBe(true);
-  })
-});
 
-describe("vehicle-damage.vue", () => {
-  test("when displayVehicleChangeAlert router params is false, the alert: 'vehicleChangeAlert' should not be visible", () => {
-    // Arrange & Act
-    const { wrapper } = setupMocks({
-      mountOptionsMockData: {
-        route: {
-          params: {
-            [routerParams.DISPLAY_VEHICLE_CHANGE_ALERT]: false
+    test("when displayVehicleChangeAlert router params is false, the alert: 'vehicleChangeAlert' should not be visible", () => {
+      // Arrange & Act
+      const { wrapper } = setupMocks({
+        mountOptionsMockData: {
+          route: {
+            params: {
+              [routerParams.DISPLAY_VEHICLE_CHANGE_ALERT]: false
+            }
           }
         }
-      }
+      });
+      // Assert
+      expect(wrapper.findComponent({ ref: 'vehicleChangeAlert' }).isVisible()).toBe(false);
     });
-    // Assert
-    expect(wrapper.findComponent({ref: 'vehicleChangeAlert'}).isVisible()).toBe(false);
-  })
-});
 
-describe("vehicle-damage.vue", () => {
-  test("when displayVehicleChangeAlert router params is undefined, the alert: 'vehicleChangeAlert' should not be visible", () => {
-    // Arrange & Act
-    const { wrapper } = setupMocks({
-      mountOptionsMockData: {
-        route: {
-          params: {
-            [routerParams.DISPLAY_VEHICLE_CHANGE_ALERT]: undefined
+    test("when displayVehicleChangeAlert router params is undefined, the alert: 'vehicleChangeAlert' should not be visible", () => {
+      // Arrange & Act
+      const { wrapper } = setupMocks({
+        mountOptionsMockData: {
+          route: {
+            params: {
+              [routerParams.DISPLAY_VEHICLE_CHANGE_ALERT]: undefined
+            }
           }
         }
-      }
+      });
+      // Assert
+      expect(wrapper.findComponent({ ref: 'vehicleChangeAlert' }).isVisible()).toBe(false);
+    })
+  });
+
+  describe("glass selections and corresponding variables", () => {
+    test("isWindshieldDamageLocation is true when windshield is selected", async () => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      wrapper.vm.selectedDamageLocations = ["Windshield"];
+
+      //Assert
+      expect(wrapper.vm.isWindshieldDamageLocation).toEqual(true);
+    });
+
+    test("isSideDoorDamageLocation is true Side door is selected", async () => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      wrapper.vm.selectedDamageLocations = ["Sidedoor"];
+
+      //Assert
+      expect(wrapper.vm.isSideDoorDamageLocation).toEqual(true);
+    });
+
+    test("isRearWindowDamageLocation is true if Rear Window damage is selected", async () => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      wrapper.vm.selectedDamageLocations = ["RearWindow"];
+
+      //Assert
+      expect(wrapper.vm.isRearWindowDamageLocation).toEqual(true);
+    });
+
+    test("isWindshieldRepair is true if windshield repair is selected", async () => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      wrapper.vm.selectedDamageLocations = ["Windshield"];
+      wrapper.vm.selectedWindshieldOptions = { selectedWindshieldDamageType: ["Repair"] };
+
+      //Assert
+      expect(wrapper.vm.isWindshieldRepair).toEqual(true);
+    });
+
+    test("isWindshieldRepair is false if windshield damage is not selected", async () => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      wrapper.vm.selectedDamageLocations = ["SideDoor"];
+      wrapper.vm.selectedWindshieldOptions = { selectedWindshieldDamageType: ["Repair"] };
+
+      //Assert
+      expect(wrapper.vm.isWindshieldRepair).toEqual(false);
+    });
+
+    test("isDriverSideReplace is true if side door driver is selected", async () => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      wrapper.vm.selectedDamageLocations = ["Sidedoor"];
+      wrapper.vm.sideDoorOptionsData = { selectedDoorSides: ["DriverSide"] };
+
+      //Assert
+      expect(wrapper.vm.isDriverSideReplace).toEqual(true);
+    });
+
+    test("isPassengerSideReplace is true if side door passenger selected", async () => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      wrapper.vm.selectedDamageLocations = ["Sidedoor"];
+      wrapper.vm.sideDoorOptionsData = { selectedDoorSides: ["PassengerSide"] };
+
+      //Assert
+      expect(wrapper.vm.isPassengerSideReplace).toEqual(true);
+    });
+  });
+
+  describe("state validations", () => {
+    test("CarId set, arePagePrerequisitesValid should be true ", async () => {
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      let arePagePrerequisitesValid = wrapper.vm.arePagePrerequisitesValid();
+      await nextTick();
+
+      //Assert
+      expect(arePagePrerequisitesValid).toBe(true);
+    });
+
+    test("Call invalidation, ResetPartsAndState should be called", async () => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      wrapper.vm.resetDependentState();
+
+      //Assert
+      expect(store.dispatch).toBeCalledWith(storeActions.RESET_PARTS_STATE_AND_DEPENDENCIES)
+
+    });
+  });
+
+  describe("input validations", () => {
+    // THE FOLLOWING TEST IS NOT NECESSARILY REQUIRED FOR COVERAGE
+    //    BUT KEEP FOR AN EXAMPLE OF A VALIDATION TEST
+    test("when validation rules are set they should validate correctly", async () => {
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+      const testNull = validate("", "replace-options-required");
+      const testString = validate("sldfj", "replace-options-required");
+
+      //Assert
+      testNull.then(function (data) {
+        expect(data.valid).toEqual(false);
+      });
+      testString.then(function (data) {
+        expect(data.valid).toEqual(true);
+      });
+    });
+  });
+
+  describe("get glass options from store", () => {
+    const damageLocations = [["Windshield", [damageLocationsSelected.WINDSHIELD]],
+    ["Driver", [damageLocationsSelected.SIDEDOOR]],
+    ["Passenger", [damageLocationsSelected.SIDEDOOR]],
+    ["Rear", [damageLocationsSelected.REARWINDOW]]];
+    test.each(damageLocations)("getDamageLocationsFromStore for %s returns expected %s", async (damageLocation, expectedGlass) => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      store.getters = { vehicle: { carId: "C0000000" }, eventBusItem: jest.fn(), damage: { glassToReplace: [{ location: damageLocation }] }, isRepair: true };
+
+      var glassSelections = wrapper.vm.getDamageLocationsFromStore();
+
+      //Assert
+      expect(glassSelections).toEqual(expectedGlass);
+    });
+
+    const storeWindshieldOptions = [[1, false, "Windshield", "Single", {
+      selectedWindshieldDamageType: [damageLocationsSelected.REPLACE],
+      selectedWindshieldChipCount: [], selectedWindshieldReplaceOptions: [damageLocationsSelected.SINGLE]
+    }],
+    [2, false, "Windshield", "Driver", {
+      selectedWindshieldDamageType: [damageLocationsSelected.REPLACE],
+      selectedWindshieldChipCount: [], selectedWindshieldReplaceOptions: [damageLocationsSelected.DRIVER]
+    }],
+    [3, false, "Windshield", "Passenger", {
+      selectedWindshieldDamageType: [damageLocationsSelected.REPLACE],
+      selectedWindshieldChipCount: [], selectedWindshieldReplaceOptions: [damageLocationsSelected.PASSENGER]
+    }],
+    [4, true, "", "", {
+      selectedWindshieldDamageType: [damageLocationsSelected.REPAIR],
+      selectedWindshieldChipCount: [2], selectedWindshieldReplaceOptions: []
+    }]
+    ];
+    test.each(storeWindshieldOptions)("getWindshieldOptionsFromStore test #%s", async (testNum, isRepair, damageLocation, damageName, expectedWindshieldOptions) => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      store.getters = {
+        vehicle:
+          { carId: "C0000000" },
+        eventBusItem: jest.fn(),
+        damage:
+        {
+          glassToReplace: [{ location: damageLocation, name: damageName }],
+          isRepair: isRepair,
+          numberOfChips: 2
+        },
+      };
+
+      var windshieldSelections = wrapper.vm.getWindshieldOptionsFromStore();
+
+      //Assert
+      expect(windshieldSelections).toEqual(expectedWindshieldOptions);
+    });
+
+    const driverDoorSides = [["Driver", "Front", [damageLocationsSelected.FRONT]],
+    ["Driver", "Back", [damageLocationsSelected.BACK]],
+    ["Driver", "Vent", [damageLocationsSelected.VENT]],
+    ["Driver", "Quarter", [damageLocationsSelected.QUARTER]]
+    ];
+    test.each(driverDoorSides)("getDriverSideReplaceOptionsFromStore for %s-%s returns expected %s", async (damageLocation, damageName, expectedGlass) => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      store.getters = { vehicle: { carId: "C0000000" }, eventBusItem: jest.fn(), damage: { glassToReplace: [{ location: damageLocation, name: damageName }] }, isRepair: true };
+
+      var glassSelections = wrapper.vm.getDriverSideReplaceOptionsFromStore();
+
+      //Assert
+      expect(glassSelections).toEqual(expectedGlass);
+
+    });
+
+    const passengerDoorSides = [["Passenger", "Front", [damageLocationsSelected.FRONT]],
+    ["Passenger", "Back", [damageLocationsSelected.BACK]],
+    ["Passenger", "Vent", [damageLocationsSelected.VENT]],
+    ["Passenger", "Quarter", [damageLocationsSelected.QUARTER]]
+    ];
+    test.each(passengerDoorSides)("getPassengerSideReplaceOptionsFromStore for %s-%s returns expected %s", async (damageLocation, damageName, expectedGlass) => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      store.getters = { vehicle: { carId: "C0000000" }, eventBusItem: jest.fn(), damage: { glassToReplace: [{ location: damageLocation, name: damageName }] }, isRepair: true };
+
+      var glassSelections = wrapper.vm.getPassengerSideReplaceOptionsFromStore();
+
+      //Assert
+      expect(glassSelections).toEqual(expectedGlass);
+    });
+
+    const rearReplaceOptions = [["Rear", "Stationary", [damageLocationsSelected.STATIONARY]],
+    ["Rear", "Slider", [damageLocationsSelected.SLIDER]]
+    ];
+    test.each(rearReplaceOptions)("getRearReplaceOptionsFromStore for %s-%s returns expected %s", async (damageLocation, damageName, expectedGlass) => {
+
+      //Arrange
+      const { wrapper } = setupMocks({});
+
+      //Act
+      vehicleDamage.beforeRouteEnter.call(
+        wrapper.vm,
+        { query: { fmgPage: "vehicle-damage" } },
+        undefined,
+        (c) => c(wrapper.vm)
+      );
+
+      store.getters = { vehicle: { carId: "C0000000" }, eventBusItem: jest.fn(), damage: { glassToReplace: [{ location: damageLocation, name: damageName }] }, isRepair: true };
+
+      var glassSelections = wrapper.vm.getRearReplaceOptionsFromStore();
+
+      //Assert
+      expect(glassSelections).toEqual(expectedGlass);
     });
-    // Assert
-    expect(wrapper.findComponent({ref: 'vehicleChangeAlert'}).isVisible()).toBe(false);
   })
-});
 
-describe("vehicle-damage.vue wasDelayedClaimRegistration", () => {
-  test.todo("if wasDelayedClaimRegistration, should hide back button")
-});
+  describe("hide back button", () => {
+    test("if claim registration is delayed => should hide back button", () => {
+      // Arrange
+      const { wrapper } = setupMocks({
+        funnelCookie: {
+          HasDelayedClaimRegistration: true
+        }
+      });
 
-// THE FOLLOWING TEST IS NOT NECESSARILY REQUIRED FOR COVERAGE
-//    BUT KEEP FOR AN EXAMPLE OF A VALIDATION TEST
-// 
-describe("vehicle-damage.vue", () => {
-  test("when validation rules are set they should validate correctly", async () => {
-
-    //Arrange
-    const { wrapper } = setupMocks({});
-    
-    //Act
-    vehicleDamage.beforeRouteEnter.call(
-      wrapper.vm,
-      { query: { fmgPage: "vehicle-damage" } },
-      undefined,
-      (c) => c(wrapper.vm)
-    );
-    const testNull = validate( "", "replace-options-required");
-    const testString = validate( "sldfj", "replace-options-required");
-
-    //Assert
-    testNull.then(function(data) {
-      expect(data.valid).toEqual(false);
-    });
-    testString.then(function(data) {
-      expect(data.valid).toEqual(true);
+      // Assert
+      expect(wrapper.vm.shouldHideBackButton).toBe(true);
     });
 
+    test("if claim is verified => should hide back button", () => {
+      // Arrange
+      const { wrapper } = setupMocks({
+        mountOptionsMockData: {
+          router: { navigateAfterSave: jest.fn(), },
+          actionList: [{ actionName: storeActions.GET_PARTS_OR_QUESTIONS, data: {}, },],
+          store: {
+            getters: {
+              vehicle: {},
+              payment: { insuranceCoverage: { isVerified: true } },
+            },
+          },
+        },
+      })
+
+      // Assert
+      expect(wrapper.vm.shouldHideBackButton).toBe(true);
+    })
+
+    test("if claim isn't verified yet => allow user to go back", () => {
+      // Arrange
+      const { wrapper } = setupMocks({});
+
+      // Assert
+      expect(wrapper.vm.shouldHideBackButton).toBeFalsy();
+    })
   });
 });
 
-
-function setupMocks({pageHeaderWidgetHeaderText, mountOptionsMockData}) {
+function setupMocks({ pageHeaderWidgetHeaderText, mountOptionsMockData, funnelCookie = {} }) {
   var pageHeaderWidgetHeaderTextDefault = {};
   var mountOptionsMockDataDefault = {
     router: {
@@ -751,7 +764,7 @@ function setupMocks({pageHeaderWidgetHeaderText, mountOptionsMockData}) {
 
   settleAllPromises.mockImplementation(() => apiPromise);
   fetchCmsContentForPage.mockImplementation(() => Promise.resolve());
-  cookieHelper.getFunnelCookie = jest.spyOn(cookieHelper, "getFunnelCookie").mockReturnValue({});
+  cookieHelper.getFunnelCookie = jest.spyOn(cookieHelper, "getFunnelCookie").mockReturnValue(funnelCookie);
 
   //Mock damage initialize methods
   damageLocationQuestion.methods = {
@@ -787,11 +800,11 @@ function setupMocks({pageHeaderWidgetHeaderText, mountOptionsMockData}) {
 
   const backGlassOptionsWrapper = wrapper.findComponent({ name: "replaceOptionsQuestion" });
   backGlassOptionsWrapper.vm.initializeComponent =
-  replaceOptionsQuestion.methods.initializeComponent;
+    replaceOptionsQuestion.methods.initializeComponent;
 
   const damageLocationQuestionWrapper = wrapper.findComponent({ name: "damageLocationQuestion" });
   damageLocationQuestionWrapper.vm.initializeComponent =
-  damageLocationQuestion.methods.initializeComponent;
+    damageLocationQuestion.methods.initializeComponent;
 
   wrapper.vm.setCmsContent = baseMixin.methods.setCmsContent;
 
diff --git a/src/layouts/vehicle-damage/vehicle-damage.vue b/src/layouts/vehicle-damage/vehicle-damage.vue
index d4e44feb7..266e2ba1a 100644
--- a/src/layouts/vehicle-damage/vehicle-damage.vue
+++ b/src/layouts/vehicle-damage/vehicle-damage.vue
@@ -405,7 +405,7 @@ export default {
     shouldDisplayVehicleChangeAlert() {
       return this.$route.params[this.routerParams.DISPLAY_VEHICLE_CHANGE_ALERT];
     },
-    shouldHideBackButton(){
+    shouldHideBackButton() {
       return this.$store.getters.payment.insuranceCoverage.isVerified || getFunnelCookie().HasDelayedClaimRegistration;
     }
   },