diff --git a/src/helpers/order-helper.js b/src/helpers/order-helper.js
index c37ca5f9..a4c9c44b 100644
--- a/src/helpers/order-helper.js
+++ b/src/helpers/order-helper.js
@@ -46,7 +46,8 @@ export async function submitWorkOrder({ submitType }) {
         && store.vehicle.policyVehicleId != null
         && store.vehicle.policyVehicleId >= 0
         && store.isClaimRegistrationRequired
-        && store.issConfig.callClaimRegistrationAtEnd;
+        && store.issConfig.callClaimRegistrationAtEnd
+        && !store.isNoComp;
     if (shouldRegisterClaimAfterSubmission) {
         await store.registerClaim();
     }
diff --git a/src/helpers/order-helper.spec.js b/src/helpers/order-helper.spec.js
index 3b9ac027..bbc34165 100644
--- a/src/helpers/order-helper.spec.js
+++ b/src/helpers/order-helper.spec.js
@@ -1,36 +1,35 @@
+import coverageType from '@/constants/coverage-type';
 import { submitWorkOrder } from '@/helpers/order-helper';
+import { createTestingPinia } from '@pinia/testing';
+import { getDefaultState, useMainStore } from '@/store';
 
-let mockStore;
-
-jest.mock('@/store', () => ({
-    useMainStore: jest.fn(() => mockStore)
-}));
+let store;
 
 describe('order-helper.js', () => {
     describe('submitWorkOrder', () => {
         beforeEach(() => {
-            mockStore = {
-                resetSubmittedOrder: jest.fn(),
-                createSubmittedOrder: jest.fn(() => Promise.resolve()),
-                registerClaim: jest.fn(() => Promise.resolve()),
-                isPolicyLookupSuccessful: false,
-                vehicle: {
-                    policyVehicleId: null
-                },
-                isClaimRegistrationRequired: false,
-                issConfig: {
-                    callClaimRegistrationAtEnd: false
-                },
-                applicationUser: {
-                    saveSessionPromise: null
-                },
-                order: {
-                    referralNumber: null
-                },
-                saveSession: jest.fn(() => Promise.resolve({ data: { referralNumber: 'REF-001' } })),
-                setSaveSessionInfo: jest.fn(),
-                setSaveSessionPromise: jest.fn()
-            };
+            const testingPinia = createTestingPinia({
+                initialState: {
+                    main: getDefaultState()
+                }
+            });
+
+            store = useMainStore(testingPinia);
+
+            store.resetSubmittedOrder = jest.fn();
+            store.createSubmittedOrder = jest.fn(() => Promise.resolve());
+            store.registerClaim = jest.fn(() => Promise.resolve());
+            store.saveSession = jest.fn(() => Promise.resolve({ data: { referralNumber: 'REF-001' } }));
+            store.setSaveSessionInfo = jest.fn();
+            store.setSaveSessionPromise = jest.fn((promise) => {
+                store.applicationUser.saveSessionPromise = promise;
+            });
+
+            store.order.referralNumber = null;
+            store.order.vehicle.policyVehicleId = null;
+            store.order.insuranceCoverage.coverageType = coverageType.NONE;
+            store.issConfig.isClaimRegistrationRequired = false;
+            store.issConfig.callClaimRegistrationAtEnd = false;
 
             jest.clearAllMocks();
         });
@@ -43,101 +42,115 @@ describe('order-helper.js', () => {
             await submitWorkOrder({ submitType });
 
             // Assert
-            expect(mockStore.resetSubmittedOrder).toHaveBeenCalledTimes(1);
-            expect(mockStore.saveSession).toHaveBeenCalledTimes(1);
-            expect(mockStore.saveSession).toHaveBeenCalledWith({
+            expect(store.resetSubmittedOrder).toHaveBeenCalledTimes(1);
+            expect(store.saveSession).toHaveBeenCalledTimes(1);
+            expect(store.saveSession).toHaveBeenCalledWith({
                 submitAfterSave: true,
                 createWorkOrderNumberForPIA: false,
                 bailoutOnError: true
             });
-            expect(mockStore.setSaveSessionPromise).toHaveBeenCalledTimes(1);
-            expect(mockStore.setSaveSessionInfo).toHaveBeenCalledWith({ referralNumber: 'REF-001' });
-            expect(mockStore.createSubmittedOrder).toHaveBeenCalledTimes(1);
-            expect(mockStore.createSubmittedOrder).toHaveBeenCalledWith(submitType);
+            expect(store.setSaveSessionPromise).toHaveBeenCalledTimes(1);
+            expect(store.setSaveSessionInfo).toHaveBeenCalledWith({ referralNumber: 'REF-001' });
+            expect(store.createSubmittedOrder).toHaveBeenCalledTimes(1);
+            expect(store.createSubmittedOrder).toHaveBeenCalledWith(submitType);
         });
 
         test('Registers claim when all claim registration conditions are met', async () => {
             // Arrange
-            mockStore.isPolicyLookupSuccessful = true;
-            mockStore.vehicle.policyVehicleId = 42;
-            mockStore.isClaimRegistrationRequired = true;
-            mockStore.issConfig.callClaimRegistrationAtEnd = true;
+            store.order.insuranceCoverage.coverageType = coverageType.Deductible;
+            store.order.vehicle.policyVehicleId = 42;
+            store.issConfig.isClaimRegistrationRequired = true;
+            store.issConfig.callClaimRegistrationAtEnd = true;
 
             // Act
             await submitWorkOrder({ submitType: 'SUBMIT' });
 
             // Assert
-            expect(mockStore.registerClaim).toHaveBeenCalledTimes(1);
+            expect(store.registerClaim).toHaveBeenCalledTimes(1);
         });
 
         test('Does not register claim when policy lookup is not successful', async () => {
             // Arrange
-            mockStore.isPolicyLookupSuccessful = false;
-            mockStore.vehicle.policyVehicleId = 42;
-            mockStore.isClaimRegistrationRequired = true;
-            mockStore.issConfig.callClaimRegistrationAtEnd = true;
+            store.order.insuranceCoverage.coverageType = coverageType.NONE;
+            store.order.vehicle.policyVehicleId = 42;
+            store.issConfig.isClaimRegistrationRequired = true;
+            store.issConfig.callClaimRegistrationAtEnd = true;
 
             // Act
             await submitWorkOrder({ submitType: 'SUBMIT' });
 
             // Assert
-            expect(mockStore.registerClaim).not.toHaveBeenCalled();
+            expect(store.registerClaim).not.toHaveBeenCalled();
         });
 
         test('Does not register claim when policyVehicleId is null', async () => {
             // Arrange
-            mockStore.isPolicyLookupSuccessful = true;
-            mockStore.vehicle.policyVehicleId = null;
-            mockStore.isClaimRegistrationRequired = true;
-            mockStore.issConfig.callClaimRegistrationAtEnd = true;
+            store.order.insuranceCoverage.coverageType = coverageType.Deductible;
+            store.order.vehicle.policyVehicleId = null;
+            store.issConfig.isClaimRegistrationRequired = true;
+            store.issConfig.callClaimRegistrationAtEnd = true;
 
             // Act
             await submitWorkOrder({ submitType: 'SUBMIT' });
 
             // Assert
-            expect(mockStore.registerClaim).not.toHaveBeenCalled();
+            expect(store.registerClaim).not.toHaveBeenCalled();
         });
 
         test('Does not register claim when policyVehicleId is negative', async () => {
             // Arrange
-            mockStore.isPolicyLookupSuccessful = true;
-            mockStore.vehicle.policyVehicleId = -1;
-            mockStore.isClaimRegistrationRequired = true;
-            mockStore.issConfig.callClaimRegistrationAtEnd = true;
+            store.order.insuranceCoverage.coverageType = coverageType.Deductible;
+            store.order.vehicle.policyVehicleId = -1;
+            store.issConfig.isClaimRegistrationRequired = true;
+            store.issConfig.callClaimRegistrationAtEnd = true;
 
             // Act
             await submitWorkOrder({ submitType: 'SUBMIT' });
 
             // Assert
-            expect(mockStore.registerClaim).not.toHaveBeenCalled();
+            expect(store.registerClaim).not.toHaveBeenCalled();
         });
 
         test('Does not register claim when claim registration is not required', async () => {
             // Arrange
-            mockStore.isPolicyLookupSuccessful = true;
-            mockStore.vehicle.policyVehicleId = 42;
-            mockStore.isClaimRegistrationRequired = false;
-            mockStore.issConfig.callClaimRegistrationAtEnd = true;
+            store.order.insuranceCoverage.coverageType = coverageType.Deductible;
+            store.order.vehicle.policyVehicleId = 42;
+            store.issConfig.isClaimRegistrationRequired = false;
+            store.issConfig.callClaimRegistrationAtEnd = true;
 
             // Act
             await submitWorkOrder({ submitType: 'SUBMIT' });
 
             // Assert
-            expect(mockStore.registerClaim).not.toHaveBeenCalled();
+            expect(store.registerClaim).not.toHaveBeenCalled();
         });
 
         test('Does not register claim when claim registration is disabled in config', async () => {
             // Arrange
-            mockStore.isPolicyLookupSuccessful = true;
-            mockStore.vehicle.policyVehicleId = 42;
-            mockStore.isClaimRegistrationRequired = true;
-            mockStore.issConfig.callClaimRegistrationAtEnd = false;
+            store.order.insuranceCoverage.coverageType = coverageType.Deductible;
+            store.order.vehicle.policyVehicleId = 42;
+            store.issConfig.isClaimRegistrationRequired = true;
+            store.issConfig.callClaimRegistrationAtEnd = false;
 
             // Act
             await submitWorkOrder({ submitType: 'SUBMIT' });
 
             // Assert
-            expect(mockStore.registerClaim).not.toHaveBeenCalled();
+            expect(store.registerClaim).not.toHaveBeenCalled();
+        });
+
+        test('Does not register claim when coverage type is NoComp', async () => {
+            // Arrange
+            store.order.insuranceCoverage.coverageType = coverageType.NO_COMP;
+            store.order.vehicle.policyVehicleId = 42;
+            store.issConfig.isClaimRegistrationRequired = true;
+            store.issConfig.callClaimRegistrationAtEnd = true;
+
+            // Act
+            await submitWorkOrder({ submitType: 'SUBMIT' });
+
+            // Assert
+            expect(store.registerClaim).not.toHaveBeenCalled();
         });
 
     });