diff --git a/force-app/main/default/lwc/__tests__/data/apexError.json b/force-app/main/default/lwc/__tests__/data/apexError.json
new file mode 100644
index 000000000..fa3f27887
--- /dev/null
+++ b/force-app/main/default/lwc/__tests__/data/apexError.json
@@ -0,0 +1,6 @@
+{
+    "body": { "message": "An internal server error has occurred" },
+    "ok": false,
+    "status": 400,
+    "statusText": "Bad Request"
+}
diff --git a/force-app/main/default/lwc/__tests__/lightning/uiRecordApi.js b/force-app/main/default/lwc/__tests__/lightning/uiRecordApi.js
new file mode 100644
index 000000000..1db4367bd
--- /dev/null
+++ b/force-app/main/default/lwc/__tests__/lightning/uiRecordApi.js
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+export const getRecord = jest.fn();
+export const getRecordCreateDefaults = jest.fn();
+export const updateRecord = jest.fn();
+export const createRecord = jest.fn().mockResolvedValue({});
+export const deleteRecord = jest.fn().mockResolvedValue();
+export const generateRecordInputForCreate = jest.fn();
+export const generateRecordInputForUpdate = jest.fn();
+export const createRecordInputFilteredByEditedFields = jest.fn();
+export const getRecordInput = jest.fn();
+export const refresh = jest.fn().mockResolvedValue();
+export const getRecordUi = jest.fn();
+export const getFieldValue = jest.fn((data, fieldReference) => {
+    if (data) {
+        const fields = fieldReference.fieldApiName.split(".");
+        if (data.result) {
+            const fieldData = fields.reduce((o, i) => o[i], data.result.fields);
+            if (fieldData && fieldData.value) {
+                return fieldData.value;
+            }
+        } else {
+            const fieldData = fields.reduce((o, i) => o[i], data.fields);
+            if (fieldData && fieldData.value) {
+                return fieldData.value;
+            }
+        }
+        return null;
+    }
+    return null;
+});
+export const getFieldDisplayValue = jest.fn();
diff --git a/force-app/main/default/lwc/accordionSection/__tests__/accordionSection.test.js b/force-app/main/default/lwc/accordionSection/__tests__/accordionSection.test.js
new file mode 100644
index 000000000..4f66a2b93
--- /dev/null
+++ b/force-app/main/default/lwc/accordionSection/__tests__/accordionSection.test.js
@@ -0,0 +1,113 @@
+/*
+ *
+ *  * Copyright (c) 2020, salesforce.com, inc.
+ *  * All rights reserved.
+ *  * SPDX-License-Identifier: BSD-3-Clause
+ *  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ *
+ */
+
+import { createElement } from "lwc";
+import AccordionSection from "c/accordionSection";
+
+describe("c-accordionSection", () => {
+    let element;
+
+    afterEach(global.clearDOM);
+
+    beforeEach(() => {
+        element = createElement("c-accordionSection", {
+            is: AccordionSection,
+        });
+    });
+
+    it("is closed by default", () => {
+        document.body.appendChild(element);
+
+        return global.flushPromises().then(() => {
+            const button = element.shadowRoot.querySelector("button");
+            expect(button.ariaExpanded).toBe("false");
+            return global.isAccessible(element);
+        });
+    });
+
+    it("is open when open current section is true", () => {
+        element.openCurrentSection = true;
+        document.body.appendChild(element);
+
+        return global.flushPromises().then(() => {
+            const button = element.shadowRoot.querySelector("button");
+            expect(button.ariaExpanded).toBe("true");
+            return global.isAccessible(element);
+        });
+    });
+
+    it("is accessible with background shaded", () => {
+        element.shadeOnOpen = "#EFEFEF";
+        element.openCurrentSection = true;
+        document.body.appendChild(element);
+
+        return global.flushPromises().then(() => {
+            // TODO: see if we can verify background color
+            return global.isAccessible(element);
+        });
+    });
+
+    it("opens", () => {
+        document.body.appendChild(element);
+        element.open();
+
+        return global.flushPromises().then(() => {
+            const button = element.shadowRoot.querySelector("button");
+            expect(button.ariaExpanded).toBe("true");
+            return global.isAccessible(element);
+        });
+    });
+
+    it("closes", () => {
+        element.openCurrentSection = true;
+        document.body.appendChild(element);
+        element.close();
+
+        return global.flushPromises().then(() => {
+            const button = element.shadowRoot.querySelector("button");
+            expect(button.ariaExpanded).toBe("false");
+            return global.isAccessible(element);
+        });
+    });
+
+    it("does not open when prevent toggle is set", () => {
+        element.preventToggle = true;
+        document.body.appendChild(element);
+        element.open();
+
+        return global.flushPromises().then(() => {
+            const button = element.shadowRoot.querySelector("button");
+            expect(button.ariaExpanded).toBe("false");
+            return global.isAccessible(element);
+        });
+    });
+
+    it("override open overrides prevent toggle and opens", () => {
+        element.preventToggle = true;
+        document.body.appendChild(element);
+        element.overrideOpen();
+
+        return global.flushPromises().then(() => {
+            const button = element.shadowRoot.querySelector("button");
+            expect(button.ariaExpanded).toBe("true");
+            return global.isAccessible(element);
+        });
+    });
+
+    it("opens on button click", () => {
+        document.body.appendChild(element);
+        const button = element.shadowRoot.querySelector("button");
+        button.click();
+
+        return global.flushPromises().then(() => {
+            expect(button.ariaExpanded).toBe("true");
+            return global.isAccessible(element);
+        });
+    });
+});
diff --git a/force-app/main/default/lwc/accordionSection/accordionSection.html b/force-app/main/default/lwc/accordionSection/accordionSection.html
index 2c435e652..9706a17d3 100644
--- a/force-app/main/default/lwc/accordionSection/accordionSection.html
+++ b/force-app/main/default/lwc/accordionSection/accordionSection.html
@@ -1,3 +1,4 @@
+<!-- sldsValidatorIgnore -->
 <!--
   - /*
   -  * Copyright (c) 2020, salesforce.com, inc.
@@ -21,11 +22,11 @@
                         onclick={handleToggle}
                         aria-controls="accordion-details"
                         aria-expanded={isOpen}
+                        aria-label={toggleInstructions}
                         class="slds-align-middle slds-text-link_reset slds-button"
                     >
                         <lightning-icon
                             icon-name={toggleIcon}
-                            alternative-text={toggleInstructions}
                             size="x-small"
                         ></lightning-icon>
                     </button>
diff --git a/force-app/main/default/lwc/attendance/__tests__/attendance.test.js b/force-app/main/default/lwc/attendance/__tests__/attendance.test.js
index be85aa878..b972ed0b8 100644
--- a/force-app/main/default/lwc/attendance/__tests__/attendance.test.js
+++ b/force-app/main/default/lwc/attendance/__tests__/attendance.test.js
@@ -9,39 +9,60 @@
 
 import { createElement } from "lwc";
 import Attendance from "c/attendance";
-import { getRecord } from "lightning/uiRecordApi";
+import { getRecord, updateRecord } from "lightning/uiRecordApi";
 import { getObjectInfo } from "lightning/uiObjectInfoApi";
 import { CurrentPageReference } from "lightning/navigation";
+import * as cUtil from "c/util";
 import generateRoster from "@salesforce/apex/AttendanceController.generateRoster";
 import checkFieldPermissions from "@salesforce/apex/AttendanceController.checkFieldPermissions";
+import upsertRows from "@salesforce/apex/AttendanceController.upsertServiceDeliveries";
 import getServiceSessionStatusBuckets from "@salesforce/apex/AttendanceController.getServiceSessionStatusBuckets";
 
 import {
     registerApexTestWireAdapter,
     registerLdsTestWireAdapter,
+    registerTestWireAdapter,
 } from "@salesforce/sfdx-lwc-jest";
+import SUBMIT_LABEL from "@salesforce/label/c.Submit";
+import UPDATE_LABEL from "@salesforce/label/c.Update";
+import PRINT_LABEL from "@salesforce/label/c.Print";
+import PRINTABLE_VIEW_LABEL from "@salesforce/label/c.Printable_View";
+import SESSION_STATUS_FIELD from "@salesforce/schema/ServiceSession__c.Status__c";
+import SAVE_LABEL from "@salesforce/label/c.Save";
+import CANCEL_LABEL from "@salesforce/label/c.Cancel";
+import QUANTITY_LABEL from "@salesforce/label/c.Quantity";
 
 const mockGenerateRoster = require("./data/generateRoster.json");
 const mockGenerateRosterEmpty = require("./data/emptyRoster.json");
 const mockWiredSession = require("./data/wiredPendingSession.json");
 const mockWiredPermissions = require("./data/wiredPermissions.json");
 const mockWiredNoPermissions = require("./data/wiredNoPermissions.json");
-const mockwiredGetSessionStatuses = require("./data/wiredGetSessionStatuses.json");
-const mockCurrentPageReference = require("./data/currentPageReference.json");
+const mockAttendanceTabPageReference = require("./data/attendanceTabPageReference.json");
+const mockServiceSessionPageReference = require("./data/serviceSessionPageReference.json");
+const mockApexError = require("../../__tests__/data/apexError.json");
+const mockWiredGetSessionStatuses = require("./data/wiredGetSessionStatuses.json");
 const mockWiredContactObjectInfo = require("./data/wiredContactObjectInfo.json");
 
 //Register the  wire adapters
 const generateRosterAdapter = registerApexTestWireAdapter(generateRoster);
 const wiredSessionAdapter = registerLdsTestWireAdapter(getRecord);
 const wiredPermissionsAdapter = registerApexTestWireAdapter(checkFieldPermissions);
+const currentPageReferenceAdapter = registerTestWireAdapter(CurrentPageReference);
 const wiredGetSessionStatusesAdapter = registerApexTestWireAdapter(
     getServiceSessionStatusBuckets
 );
-const wiredCurrentPageReference = registerApexTestWireAdapter(CurrentPageReference);
 const wiredContactObjectInfoAdapter = registerLdsTestWireAdapter(getObjectInfo);
 
 jest.mock("c/attendanceRow");
-
+jest.mock(
+    "@salesforce/apex/AttendanceController.upsertServiceDeliveries",
+    () => {
+        return {
+            default: jest.fn(),
+        };
+    },
+    { virtual: true }
+);
 describe("c-attendance", () => {
     let element;
 
@@ -52,18 +73,19 @@ describe("c-attendance", () => {
             is: Attendance,
         });
         element.recordId = "a06630000074mVnAAI";
+        currentPageReferenceAdapter.emit(mockAttendanceTabPageReference);
     });
 
-    it("shows multiple returned rows with perms", async () => {
+    it("shows multiple returned rows with perms", () => {
         document.body.appendChild(element);
         wiredSessionAdapter.emit(mockWiredSession);
         generateRosterAdapter.emit(mockGenerateRoster);
         wiredPermissionsAdapter.emit(mockWiredPermissions);
-        wiredGetSessionStatusesAdapter.emit(mockwiredGetSessionStatuses);
-        wiredCurrentPageReference.emit(mockCurrentPageReference);
+        wiredGetSessionStatusesAdapter.emit(mockWiredGetSessionStatuses);
+        currentPageReferenceAdapter.emit(mockServiceSessionPageReference);
         wiredContactObjectInfoAdapter.emit(mockWiredContactObjectInfo);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const attendanceRows = element.shadowRoot.querySelectorAll(
                 "c-attendance-row"
             );
@@ -71,15 +93,14 @@ describe("c-attendance", () => {
             global.isAccessible(element);
         });
     });
-    it("shows empty state and no buttons when zero returned rows with no perms", async () => {
+    it("shows empty state and no buttons when zero returned rows with no perms", () => {
         document.body.appendChild(element);
         wiredSessionAdapter.emit(mockWiredSession);
         generateRosterAdapter.emit(mockGenerateRosterEmpty);
         wiredPermissionsAdapter.emit(mockWiredNoPermissions);
-        wiredCurrentPageReference.emit(mockCurrentPageReference);
         wiredContactObjectInfoAdapter.emit(mockWiredContactObjectInfo);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const attendanceRows = element.shadowRoot.querySelectorAll(
                 "c-attendance-row"
             );
@@ -97,19 +118,16 @@ describe("c-attendance", () => {
 
             const buttons = element.shadowRoot.querySelectorAll("lightning-button");
             expect(buttons).toHaveLength(0);
-
-            global.isAccessible(element);
         });
     });
-    it("shows empty state and no buttons when zero returned rows with perms", async () => {
+    it("shows empty state and no buttons when zero returned rows with perms", () => {
         document.body.appendChild(element);
         wiredSessionAdapter.emit(mockWiredSession);
         generateRosterAdapter.emit(mockGenerateRosterEmpty);
         wiredPermissionsAdapter.emit(mockWiredPermissions);
-        wiredCurrentPageReference.emit(mockCurrentPageReference);
         wiredContactObjectInfoAdapter.emit(mockWiredContactObjectInfo);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const attendanceRows = element.shadowRoot.querySelectorAll(
                 "c-attendance-row"
             );
@@ -128,18 +146,17 @@ describe("c-attendance", () => {
             const buttons = element.shadowRoot.querySelectorAll("lightning-button");
             expect(buttons).toHaveLength(0);
 
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
-    it("shows perms error when rows are returned with no perms", async () => {
+    it("shows perms error when rows are returned with no perms", () => {
         document.body.appendChild(element);
         wiredSessionAdapter.emit(mockWiredSession);
         generateRosterAdapter.emit(mockGenerateRoster);
         wiredPermissionsAdapter.emit(mockWiredNoPermissions);
-        wiredCurrentPageReference.emit(mockCurrentPageReference);
         wiredContactObjectInfoAdapter.emit(mockWiredContactObjectInfo);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const attendanceRows = element.shadowRoot.querySelectorAll(
                 "c-attendance-row"
             );
@@ -153,7 +170,341 @@ describe("c-attendance", () => {
             );
             expect(scopedNotification).toHaveLength(1);
 
-            global.isAccessible(element);
+            return global.isAccessible(element);
+        });
+    });
+    it("shows the default unit of measurement", () => {
+        let sessionSinUom = JSON.parse(JSON.stringify(mockWiredSession));
+        delete sessionSinUom.fields.ServiceSchedule__r.value.fields.Service__r.value
+            .fields.UnitOfMeasurement__c;
+        wiredSessionAdapter.emit(sessionSinUom);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        document.body.appendChild(element);
+
+        return global.flushPromises().then(() => {
+            const attendanceRow = element.shadowRoot.querySelector("c-attendance-row");
+            expect(attendanceRow.unitOfMeasurement).toBe(QUANTITY_LABEL);
+        });
+    });
+    it("loads form without a status value", () => {
+        let sessionSinUom = JSON.parse(JSON.stringify(mockWiredSession));
+        delete sessionSinUom.fields.Status__c;
+        wiredSessionAdapter.emit(sessionSinUom);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        document.body.appendChild(element);
+
+        return global.flushPromises().then(() => {
+            const attendanceRows = element.shadowRoot.querySelectorAll(
+                "c-attendance-row"
+            );
+            expect(attendanceRows).toHaveLength(mockGenerateRoster.deliveries.length);
+        });
+    });
+
+    it("logs errors on generateRoster", () => {
+        document.body.appendChild(element);
+        console.log = jest.fn();
+        wiredSessionAdapter.emit(mockWiredSession);
+        generateRosterAdapter.error();
+        wiredPermissionsAdapter.emit(mockWiredNoPermissions);
+        expect(console.log).toHaveBeenCalled();
+    });
+
+    it("logs errors on getRecord", () => {
+        document.body.appendChild(element);
+        console.log = jest.fn();
+        wiredSessionAdapter.error();
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredNoPermissions);
+        expect(console.log).toHaveBeenCalled();
+    });
+    it("logs errors on checkFieldPermissions", () => {
+        document.body.appendChild(element);
+        console.log = jest.fn();
+        wiredSessionAdapter.emit(mockWiredSession);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.error();
+        expect(console.log).toHaveBeenCalled();
+    });
+});
+
+describe("c-attendance saving rows", () => {
+    let element;
+
+    afterEach(global.clearDOM);
+
+    beforeEach(() => {
+        element = createElement("c-attendance", {
+            is: Attendance,
+        });
+        element.recordId = "a06630000074mVnAAI";
+        currentPageReferenceAdapter.emit(mockAttendanceTabPageReference);
+    });
+
+    it("upserts rows calls save on row when successful", () => {
+        document.body.appendChild(element);
+        wiredSessionAdapter.emit(mockWiredSession);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        wiredGetSessionStatusesAdapter.emit(mockWiredGetSessionStatuses);
+        upsertRows.mockResolvedValue();
+        updateRecord.mockResolvedValue();
+        let spy;
+
+        return global
+            .flushPromises()
+            .then(() => {
+                const attendanceRow = element.shadowRoot.querySelector(
+                    "c-attendance-row"
+                );
+                spy = jest.spyOn(attendanceRow, "save");
+                const submit = element.shadowRoot.querySelectorAll("lightning-button")[1];
+                expect(submit.label).toBe(SUBMIT_LABEL);
+                submit.click();
+            })
+            .then(() => {
+                expect(
+                    upsertRows.mock.calls[0][0].serviceDeliveriesToUpsert.length
+                ).toEqual(mockGenerateRoster.deliveries.length);
+                expect(spy).toHaveBeenCalled();
+            });
+    });
+    it("updates the session status to complete", () => {
+        document.body.appendChild(element);
+        wiredSessionAdapter.emit(mockWiredSession);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        wiredGetSessionStatusesAdapter.emit(mockWiredGetSessionStatuses);
+        upsertRows.mockResolvedValue();
+        updateRecord.mockResolvedValue();
+
+        return global
+            .flushPromises()
+            .then(() => {
+                const submit = element.shadowRoot.querySelectorAll("lightning-button")[1];
+                expect(submit.label).toBe(SUBMIT_LABEL);
+                submit.click();
+            })
+            .then(() => {
+                let record = { fields: { Id: element.recordId } };
+                record.fields[SESSION_STATUS_FIELD.fieldApiName] = "Complete";
+                expect(updateRecord).toHaveBeenCalledWith(record);
+            });
+    });
+    it("upserts empty rows sends an empty list", () => {
+        let rosterWithEmptyRecord = JSON.parse(JSON.stringify(mockGenerateRosterEmpty));
+        rosterWithEmptyRecord.deliveries.push({});
+        document.body.appendChild(element);
+        wiredSessionAdapter.emit(mockWiredSession);
+        generateRosterAdapter.emit(rosterWithEmptyRecord);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        wiredGetSessionStatusesAdapter.emit(mockWiredGetSessionStatuses);
+        upsertRows.mockResolvedValue();
+
+        return global
+            .flushPromises()
+            .then(() => {
+                const row = element.shadowRoot.querySelector("c-attendance-row");
+                // Setting record to undefined to simulate what is returned when there
+                // are no edits to the record.
+                row.record = undefined;
+                const submit = element.shadowRoot.querySelectorAll("lightning-button")[1];
+                expect(submit.label).toBe(SUBMIT_LABEL);
+                submit.click();
+            })
+            .then(() => {
+                expect(
+                    upsertRows.mock.calls[0][0].serviceDeliveriesToUpsert.length
+                ).toEqual(0);
+            });
+    });
+    it("sends upsert error to the error handler", () => {
+        const handleErrorSpy = jest.spyOn(cUtil, "handleError");
+        document.body.appendChild(element);
+        wiredSessionAdapter.emit(mockWiredSession);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        wiredGetSessionStatusesAdapter.emit(mockWiredGetSessionStatuses);
+        upsertRows.mockRejectedValue(mockApexError);
+
+        return global
+            .flushPromises()
+            .then(() => {
+                const submit = element.shadowRoot.querySelectorAll("lightning-button")[1];
+                expect(submit.label).toBe(SUBMIT_LABEL);
+                submit.click();
+            })
+            .then(() => {
+                expect(handleErrorSpy).not.toHaveBeenCalled();
+            });
+    });
+    it("sends update error to the error handler", () => {
+        const handleErrorSpy = jest.spyOn(cUtil, "handleError");
+        document.body.appendChild(element);
+        wiredSessionAdapter.emit(mockWiredSession);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        wiredGetSessionStatusesAdapter.emit(mockWiredGetSessionStatuses);
+        upsertRows.mockResolvedValue();
+        updateRecord.mockRejectedValue({});
+
+        return global
+            .flushPromises()
+            .then(() => {
+                const submit = element.shadowRoot.querySelectorAll("lightning-button")[1];
+                expect(submit.label).toBe(SUBMIT_LABEL);
+                submit.click();
+            })
+            .then(() => {
+                // We just need this step to enter the catch
+            })
+            .then(() => {
+                expect(handleErrorSpy).toHaveBeenCalled();
+            });
+    });
+});
+
+describe("c-attendance printing the roster", () => {
+    let element;
+
+    afterEach(global.clearDOM);
+
+    beforeEach(() => {
+        element = createElement("c-attendance", {
+            is: Attendance,
         });
+        element.recordId = "a06630000074mVnAAI";
+    });
+
+    it("prints from attendance tab", () => {
+        currentPageReferenceAdapter.emit(mockAttendanceTabPageReference);
+        document.body.appendChild(element);
+        wiredSessionAdapter.emit(mockWiredSession);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        window.print = jest.fn();
+
+        return global
+            .flushPromises()
+            .then(() => {
+                const print = element.shadowRoot.querySelector("lightning-button");
+                expect(print.label).toBe(PRINT_LABEL);
+                print.click();
+            })
+            .then(() => {
+                expect(window.print).toHaveBeenCalled();
+            });
+    });
+
+    it("navigates to the attendance tab", () => {
+        currentPageReferenceAdapter.emit(mockServiceSessionPageReference);
+        document.body.appendChild(element);
+        wiredSessionAdapter.emit(mockWiredSession);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        window.open = jest.fn();
+
+        return global
+            .flushPromises()
+            .then(() => {
+                const print = element.shadowRoot.querySelector("lightning-button");
+                expect(print.label).toBe(PRINTABLE_VIEW_LABEL);
+                print.click();
+            })
+            .then(() => {
+                expect(window.open).toHaveBeenCalled();
+            });
+    });
+});
+
+describe("c-attendance updating records", () => {
+    let element;
+
+    afterEach(global.clearDOM);
+
+    beforeEach(() => {
+        element = createElement("c-attendance", {
+            is: Attendance,
+        });
+        element.recordId = "a06630000074mVnAAI";
+        currentPageReferenceAdapter.emit(mockAttendanceTabPageReference);
+    });
+
+    it("allows updates on completed records", () => {
+        document.body.appendChild(element);
+        let completedSession = JSON.parse(JSON.stringify(mockWiredSession));
+        completedSession.fields[SESSION_STATUS_FIELD.fieldApiName].value = "Complete";
+        wiredSessionAdapter.emit(completedSession);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        wiredGetSessionStatusesAdapter.emit(mockWiredGetSessionStatuses);
+
+        return global
+            .flushPromises()
+            .then(() => {
+                const update = element.shadowRoot.querySelector("lightning-button");
+                expect(update.label).toBe(UPDATE_LABEL);
+                update.click();
+            })
+            .then(() => {
+                const save = element.shadowRoot.querySelectorAll("lightning-button")[2];
+                expect(save.label).toBe(SAVE_LABEL);
+            });
+    });
+
+    it("allows cancel when updating completed records", () => {
+        document.body.appendChild(element);
+        let completedSession = JSON.parse(JSON.stringify(mockWiredSession));
+        completedSession.fields[SESSION_STATUS_FIELD.fieldApiName].value = "Complete";
+        wiredSessionAdapter.emit(completedSession);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        wiredGetSessionStatusesAdapter.emit(mockWiredGetSessionStatuses);
+
+        return global
+            .flushPromises()
+            .then(() => {
+                const update = element.shadowRoot.querySelector("lightning-button");
+                expect(update.label).toBe(UPDATE_LABEL);
+                update.click();
+            })
+            .then(() => {
+                const cancel = element.shadowRoot.querySelectorAll("lightning-button")[1];
+                expect(cancel.label).toBe(CANCEL_LABEL);
+                cancel.click();
+            })
+            .then(() => {
+                const update = element.shadowRoot.querySelector("lightning-button");
+                expect(update.label).toBe(UPDATE_LABEL);
+            });
+    });
+
+    it("does not update session when not pending", () => {
+        document.body.appendChild(element);
+        let completedSession = JSON.parse(JSON.stringify(mockWiredSession));
+        completedSession.fields[SESSION_STATUS_FIELD.fieldApiName].value = "Complete";
+        wiredSessionAdapter.emit(completedSession);
+        generateRosterAdapter.emit(mockGenerateRoster);
+        wiredPermissionsAdapter.emit(mockWiredPermissions);
+        wiredGetSessionStatusesAdapter.emit(mockWiredGetSessionStatuses);
+        upsertRows.mockResolvedValue();
+
+        return global
+            .flushPromises()
+            .then(() => {
+                const update = element.shadowRoot.querySelector("lightning-button");
+                expect(update.label).toBe(UPDATE_LABEL);
+                update.click();
+            })
+            .then(() => {
+                const save = element.shadowRoot.querySelectorAll("lightning-button")[2];
+                expect(save.label).toBe(SAVE_LABEL);
+                save.click();
+            })
+            .then(() => {
+                expect(updateRecord).not.toHaveBeenCalled();
+            });
     });
 });
diff --git a/force-app/main/default/lwc/attendance/__tests__/data/attendanceTabPageReference.json b/force-app/main/default/lwc/attendance/__tests__/data/attendanceTabPageReference.json
new file mode 100644
index 000000000..9789204a8
--- /dev/null
+++ b/force-app/main/default/lwc/attendance/__tests__/data/attendanceTabPageReference.json
@@ -0,0 +1,5 @@
+{
+    "type": "standard__navItemPage",
+    "attributes": { "apiName": "Attendance" },
+    "state": { "c__sessionId": "a0663000007xC61AAE" }
+}
diff --git a/force-app/main/default/lwc/attendance/__tests__/data/currentPageReference.json b/force-app/main/default/lwc/attendance/__tests__/data/currentPageReference.json
deleted file mode 100644
index 5a3aba050..000000000
--- a/force-app/main/default/lwc/attendance/__tests__/data/currentPageReference.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-    "type": "standard__navItemPage",
-    "attributes": {
-        "apiName": "Attendance"
-    },
-    "state": {}
-}
diff --git a/force-app/main/default/lwc/attendance/__tests__/data/getFieldSet.json b/force-app/main/default/lwc/attendance/__tests__/data/getFieldSet.json
deleted file mode 100644
index 389e7cf31..000000000
--- a/force-app/main/default/lwc/attendance/__tests__/data/getFieldSet.json
+++ /dev/null
@@ -1,34 +0,0 @@
-[
-    {
-        "apiName": "Contact__c",
-        "label": "Client",
-        "type": "REFERENCE",
-        "isRequired": false,
-        "isAccessible": true,
-        "relationshipName": "Contact__r",
-        "referenceTo": "Contact",
-        "referenceNameField": "Name"
-    },
-    {
-        "apiName": "Quantity__c",
-        "label": "Quantity",
-        "type": "DOUBLE",
-        "isRequired": false,
-        "helpText": "A 2-decimal numeric field for Quantity of a Service Delivery expressed in the Unit of Measurement in the Service. For example, 30 minutes of tutoring where the Unit of Measure is hours, Quantity is .50.",
-        "isAccessible": true
-    },
-    {
-        "apiName": "AttendanceStatus__c",
-        "label": "Attendance Status",
-        "type": "PICKLIST",
-        "isRequired": false,
-        "isAccessible": true
-    },
-    {
-        "apiName": "CreatedDate",
-        "label": "Created Date",
-        "type": "DATETIME",
-        "isRequired": true,
-        "isAccessible": true
-    }
-]
diff --git a/force-app/main/default/lwc/attendance/__tests__/data/serviceSessionPageReference.json b/force-app/main/default/lwc/attendance/__tests__/data/serviceSessionPageReference.json
new file mode 100644
index 000000000..dea6f847d
--- /dev/null
+++ b/force-app/main/default/lwc/attendance/__tests__/data/serviceSessionPageReference.json
@@ -0,0 +1,9 @@
+{
+    "type": "standard__recordPage",
+    "attributes": {
+        "recordId": "a0663000007xC5DAAU",
+        "actionName": "view",
+        "objectApiName": "ServiceSession__c"
+    },
+    "state": {}
+}
diff --git a/force-app/main/default/lwc/attendance/attendance.js b/force-app/main/default/lwc/attendance/attendance.js
index fb473e5aa..f0f283860 100644
--- a/force-app/main/default/lwc/attendance/attendance.js
+++ b/force-app/main/default/lwc/attendance/attendance.js
@@ -157,6 +157,8 @@ export default class Attendance extends NavigationMixin(LightningElement) {
         if (result.data) {
             this.hasReadPermissions = result.data.read;
             this.hasWritePermissions = result.data.write;
+        } else {
+            console.log(result.error);
         }
     }
 
@@ -172,17 +174,18 @@ export default class Attendance extends NavigationMixin(LightningElement) {
         if (result.data) {
             let schedule = getChildObjectByName(result.data.fields, "ServiceSchedule__r");
             let service = getChildObjectByName(schedule.value.fields, "Service__r");
-            this.unitOfMeasurement = service.value.fields[
-                UNIT_MEASUREMENT_SERVICE_FIELD.fieldApiName
-            ].value
-                ? service.value.fields[UNIT_MEASUREMENT_SERVICE_FIELD.fieldApiName].value
-                : this.labels.quantity;
+            this.unitOfMeasurement =
+                service.value.fields[UNIT_MEASUREMENT_SERVICE_FIELD.fieldApiName] &&
+                service.value.fields[UNIT_MEASUREMENT_SERVICE_FIELD.fieldApiName].value
+                    ? service.value.fields[UNIT_MEASUREMENT_SERVICE_FIELD.fieldApiName]
+                          .value
+                    : this.labels.quantity;
             this.sessionStatus = result.data.fields[
                 this.fields.sessionStatus.fieldApiName
             ]
                 ? result.data.fields[this.fields.sessionStatus.fieldApiName].value
                 : undefined;
-        } else if (result.error) {
+        } else {
             console.log(result.error);
         }
     }
@@ -341,7 +344,6 @@ export default class Attendance extends NavigationMixin(LightningElement) {
             }
         });
         this.showSpinner = true;
-
         upsertRows({
             serviceDeliveriesToUpsert: editedRows,
         })
diff --git a/force-app/main/default/lwc/attendanceRow/__mocks__/attendanceRow.js b/force-app/main/default/lwc/attendanceRow/__mocks__/attendanceRow.js
index f5eaff3d4..1b5db0169 100644
--- a/force-app/main/default/lwc/attendanceRow/__mocks__/attendanceRow.js
+++ b/force-app/main/default/lwc/attendanceRow/__mocks__/attendanceRow.js
@@ -16,4 +16,12 @@ export default class AttendanceRow extends LightningElement {
     @api record;
     @api fieldSet;
     @api readOnly;
+
+    @api getRow() {
+        return this.record;
+    }
+
+    @api save() {
+        jest.fn();
+    }
 }
diff --git a/force-app/main/default/lwc/attendanceRow/__tests__/attendanceRow.test.js b/force-app/main/default/lwc/attendanceRow/__tests__/attendanceRow.test.js
new file mode 100644
index 000000000..f345d1a95
--- /dev/null
+++ b/force-app/main/default/lwc/attendanceRow/__tests__/attendanceRow.test.js
@@ -0,0 +1,32 @@
+/*
+ *
+ *  * Copyright (c) 2022, salesforce.com, inc.
+ *  * All rights reserved.
+ *  * SPDX-License-Identifier: BSD-3-Clause
+ *  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ *
+ */
+
+import { createElement } from "lwc";
+import AttendanceRow from "c/attendanceRow";
+
+describe("c-attendanceRow", () => {
+    let element;
+
+    afterEach(global.clearDOM);
+
+    beforeEach(() => {
+        element = createElement("c-attendance-row", {
+            is: AttendanceRow,
+        });
+    });
+
+    // TODO: Finish writing tests, need to pass in data
+    it("loads in read only mode", () => {
+        document.body.appendChild(element);
+
+        return global.flushPromises().then(() => {
+            return global.isAccessible(element);
+        });
+    });
+});
diff --git a/force-app/main/default/lwc/formattedField/__tests__/formattedField.test.js b/force-app/main/default/lwc/formattedField/__tests__/formattedField.test.js
index 2f6b6ccbf..e6568efb9 100644
--- a/force-app/main/default/lwc/formattedField/__tests__/formattedField.test.js
+++ b/force-app/main/default/lwc/formattedField/__tests__/formattedField.test.js
@@ -36,78 +36,78 @@ describe("c-formattedField", () => {
         };
     });
 
-    it("displays a lightning formatted text field when a value is present", async () => {
+    it("displays a lightning formatted text field when a value is present", () => {
         element.field = mockField;
         element.record = mockRecord;
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const lightningFormattedText = element.shadowRoot.querySelector(
                 "lightning-formatted-text"
             );
             expect(lightningFormattedText.value).toBe(mockRecord.Name);
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
-    it("displays a lightning formatted text field when a related value is present", async () => {
+    it("displays a lightning formatted text field when a related value is present", () => {
         mockField.path = "Account.Name";
         mockRecord.Account = { Name: "Hola" };
         element.field = mockField;
         element.record = mockRecord;
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const lightningFormattedText = element.shadowRoot.querySelector(
                 "lightning-formatted-text"
             );
             expect(lightningFormattedText.value).toBe(mockRecord.Account.Name);
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
-    it("displays a lightning formatted text field when a related value is not present", async () => {
+    it("displays a lightning formatted text field when a related value is not present", () => {
         mockField.path = "Account.Name";
         element.field = mockField;
         element.record = mockRecord;
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const lightningFormattedText = element.shadowRoot.querySelector(
                 "lightning-formatted-text"
             );
             expect(lightningFormattedText.value).toBeUndefined();
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
-    it("displays a lightning formatted text field when a value is missing", async () => {
+    it("displays a lightning formatted text field when a value is missing", () => {
         mockField.apiName = "Title";
 
         element.field = mockField;
         element.record = mockRecord;
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const lightningFormattedText = element.shadowRoot.querySelector(
                 "lightning-formatted-text"
             );
             expect(lightningFormattedText.value).toBeUndefined();
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 
-    it("displays a lightning formatted text field when the record is missing", async () => {
+    it("displays a lightning formatted text field when the record is missing", () => {
         element.field = mockField;
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const lightningFormattedText = element.shadowRoot.querySelector(
                 "lightning-formatted-text"
             );
             expect(lightningFormattedText.value).toBeUndefined();
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 
-    it("displays a lightning formatted date time field when type is date", async () => {
+    it("displays a lightning formatted date time field when type is date", () => {
         let today = new Date();
         mockField.type = "DATE";
         mockField.apiName = "Today";
@@ -117,16 +117,16 @@ describe("c-formattedField", () => {
         element.record = mockRecord;
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const lightningFormattedDateTime = element.shadowRoot.querySelector(
                 "lightning-formatted-date-time"
             );
             expect(lightningFormattedDateTime.value).toBe(today);
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 
-    it("displays a lightning formatted date time field when type is date-time", async () => {
+    it("displays a lightning formatted date time field when type is date-time", () => {
         let today = new Date();
         mockField.type = "DATETIME";
         mockField.apiName = "Today";
@@ -136,16 +136,16 @@ describe("c-formattedField", () => {
         element.record = mockRecord;
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const lightningFormattedDateTime = element.shadowRoot.querySelector(
                 "lightning-formatted-date-time"
             );
             expect(lightningFormattedDateTime.value).toBe(today);
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 
-    it("displays a lightning formatted time field when type is time", async () => {
+    it("displays a lightning formatted time field when type is time", () => {
         let time = 1800000;
         mockField.type = "TIME";
         mockField.apiName = "Time";
@@ -155,14 +155,14 @@ describe("c-formattedField", () => {
         element.record = mockRecord;
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const lightningFormattedTime = element.shadowRoot.querySelector(
                 "lightning-formatted-time"
             );
             // Javascript will convert the number into time format, relying on TimeZones
             // validating the semi colons vs the actual time.
             expect(lightningFormattedTime.value.includes(":")).toBeTruthy();
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 });
diff --git a/force-app/main/default/lwc/listViewSelector/__tests__/listViewSelector.test.js b/force-app/main/default/lwc/listViewSelector/__tests__/listViewSelector.test.js
index cbc739028..7efaae629 100644
--- a/force-app/main/default/lwc/listViewSelector/__tests__/listViewSelector.test.js
+++ b/force-app/main/default/lwc/listViewSelector/__tests__/listViewSelector.test.js
@@ -29,16 +29,16 @@ describe("c-listViewSelector", () => {
         getListUiAdapter.emit(mockGetListViews);
     });
 
-    it("renders first list view returned as checked", async () => {
+    it("renders first list view returned as checked", () => {
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const lightningMenuItem = element.shadowRoot.querySelector(
                 "lightning-menu-item"
             );
             expect(lightningMenuItem.label).toBe("All");
             expect(lightningMenuItem.checked).toBeTruthy();
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 });
diff --git a/force-app/main/default/lwc/loadingStencil/__tests__/loadingStencil.test.js b/force-app/main/default/lwc/loadingStencil/__tests__/loadingStencil.test.js
index 9df5265fd..8627742e4 100644
--- a/force-app/main/default/lwc/loadingStencil/__tests__/loadingStencil.test.js
+++ b/force-app/main/default/lwc/loadingStencil/__tests__/loadingStencil.test.js
@@ -12,13 +12,16 @@ describe("c-loading-stencil", () => {
         });
     });
 
-    it("displays the stencils with default levels", async () => {
+    it("displays the stencils with default levels", () => {
         document.body.appendChild(element);
 
         let stencils = element.shadowRoot.querySelectorAll(".stencil");
-        expect(stencils.length).toBe(element.levels.length);
-        expect(element.levels.length).toBeGreaterThan(0);
-        global.isAccessible(element);
+
+        return global.flushPromises().then(() => {
+            expect(stencils.length).toBe(element.levels.length);
+            expect(element.levels.length).toBeGreaterThan(0);
+            return global.isAccessible(element);
+        });
     });
 
     it("displays the stencils with provided levels", () => {
diff --git a/force-app/main/default/lwc/modal/__tests__/modal.test.js b/force-app/main/default/lwc/modal/__tests__/modal.test.js
index eef84d549..88e5aec4f 100644
--- a/force-app/main/default/lwc/modal/__tests__/modal.test.js
+++ b/force-app/main/default/lwc/modal/__tests__/modal.test.js
@@ -38,7 +38,7 @@ describe("c-modal", () => {
         const HEADER_STRING = "Modal Header";
         element.header = HEADER_STRING;
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             //verify that the header is displayed
             const headerContainer = element.shadowRoot.querySelector(".header-string");
             expect(headerContainer).not.toBeNull();
@@ -47,7 +47,7 @@ describe("c-modal", () => {
             //verify that the header slot is not displayed because the header is present
             const slotContainer = element.shadowRoot.querySelector(".header-slot");
             expect(slotContainer).toBeNull();
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 
@@ -78,11 +78,11 @@ describe("c-modal", () => {
         element.addEventListener("dialogclose", handler);
         buttonContainer.click();
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const headerContainer = element.shadowRoot.querySelector(".header-string");
             expect(headerContainer.textContent).toBe(HEADER_STRING);
             expect(handler).toHaveBeenCalled();
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 
@@ -91,7 +91,7 @@ describe("c-modal", () => {
         const HEADER_STRING = "Modal Header";
         element.header = HEADER_STRING;
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const headerContainer = element.shadowRoot.querySelector(".header-string");
             expect(headerContainer.textContent).toBe(HEADER_STRING);
 
@@ -99,8 +99,6 @@ describe("c-modal", () => {
             element.show();
             //verify that there is no CSS class present
             expect(modalContainer.classList.value).toBe("");
-            global.isAccessible(element);
-
             element.hide();
             //verify that the CSS class exists
             expect(modalContainer.classList.value).toBe(MODAL_HIDDEN);
@@ -108,12 +106,12 @@ describe("c-modal", () => {
     });
 
     // This jest test below validates that the component is accessible
-    it("is accessible", async () => {
+    it("is accessible", () => {
         const h2Container = element.shadowRoot.querySelector("h2");
         let slot = document.createElement("span");
         slot.textContent = "Test Accessibility";
         h2Container.attachShadow({ mode: "open" }).appendChild(slot.cloneNode(true));
-        // assert that DOM is accessible (using extended preset-rule)
-        global.isAccessible(element);
+
+        return global.isAccessible(element);
     });
 });
diff --git a/force-app/main/default/lwc/newProgramEngagement/__tests__/newProgramEngagement.test.js b/force-app/main/default/lwc/newProgramEngagement/__tests__/newProgramEngagement.test.js
index b8a5e66c0..afdafa124 100644
--- a/force-app/main/default/lwc/newProgramEngagement/__tests__/newProgramEngagement.test.js
+++ b/force-app/main/default/lwc/newProgramEngagement/__tests__/newProgramEngagement.test.js
@@ -71,7 +71,7 @@ describe("c-new-program-engagement with a known contact", () => {
 
         element.showModal();
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const inputFields = element.shadowRoot.querySelectorAll(
                 "lightning-input-field"
             );
@@ -86,7 +86,7 @@ describe("c-new-program-engagement with a known contact", () => {
                 index++;
             });
 
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 
@@ -113,22 +113,22 @@ describe("c-new-program-engagement with a known contact", () => {
                     new CustomEvent("success", { detail: recordId })
                 );
             })
-            .then(async () => {
+            .then(() => {
                 expect(handler).toHaveBeenCalled();
-                global.isAccessible(element);
             });
     });
 
     it("closes the modal when the close button is clicked", () => {
-        document.body.appendChild(element);
-        element.newContactMode = false;
-        element.showModal();
-
         const handler = jest.fn();
         element.addEventListener("cancel", handler);
+        element.newContactMode = false;
+        document.body.appendChild(element);
 
         return global
             .flushPromises()
+            .then(() => {
+                element.showModal();
+            })
             .then(() => {
                 let cancelButton = element.shadowRoot.querySelectorAll(
                     "lightning-button"
@@ -137,15 +137,8 @@ describe("c-new-program-engagement with a known contact", () => {
                 expect(cancelButton.label).toBe(cancel);
                 cancelButton.click();
             })
-            .then(async () => {
+            .then(() => {
                 expect(handler).toHaveBeenCalled();
-                global.isAccessible(element);
             });
     });
-
-    it("is accessible", async () => {
-        document.body.appendChild(element);
-        // assert that DOM is accessible (using extended preset-rule)
-        global.isAccessible(element);
-    });
 });
diff --git a/force-app/main/default/lwc/scopedNotification/__tests__/scopedNotification.test.js b/force-app/main/default/lwc/scopedNotification/__tests__/scopedNotification.test.js
index 61506581f..b8deacecf 100644
--- a/force-app/main/default/lwc/scopedNotification/__tests__/scopedNotification.test.js
+++ b/force-app/main/default/lwc/scopedNotification/__tests__/scopedNotification.test.js
@@ -23,49 +23,71 @@ describe("c-scoped-notification", () => {
         });
     });
 
-    it("displays the info theme by default", async () => {
+    it("displays the info theme by default", () => {
         document.body.appendChild(element);
-        const icon = element.shadowRoot.querySelector("lightning-icon");
-        const themeDiv = element.shadowRoot.querySelector(".slds-theme_info");
-        const titlePara = element.shadowRoot.querySelector("p");
-
-        expect(themeDiv).toBeDefined();
-        expect(icon.iconName).toBe("utility:info");
-        expect(titlePara.textContent).toEqual("");
-        global.isAccessible(element);
+
+        return global.flushPromises().then(() => {
+            const icon = element.shadowRoot.querySelector("lightning-icon");
+            const themeDiv = element.shadowRoot.querySelector(".slds-theme_info");
+            const titlePara = element.shadowRoot.querySelector("p");
+
+            expect(themeDiv).toBeDefined();
+            expect(icon.iconName).toBe("utility:info");
+            expect(titlePara.textContent).toEqual("");
+            return global.isAccessible(element);
+        });
     });
 
-    it("displays the light info theme", async () => {
+    it("displays the light info theme", () => {
         element.title = TITLE;
         element.theme = "light";
         document.body.appendChild(element);
-        const icon = element.shadowRoot.querySelector("lightning-icon");
-        const themeDiv = element.shadowRoot.querySelector(
-            "slds-scoped-notification_light"
-        );
-        const titlePara = element.shadowRoot.querySelector("p");
-
-        expect(themeDiv).toBeDefined();
-        expect(icon.iconName).toBe("utility:info");
-        expect(titlePara.textContent).toEqual(TITLE);
-        global.isAccessible(element);
+
+        return global.flushPromises().then(() => {
+            const icon = element.shadowRoot.querySelector("lightning-icon");
+            const themeDiv = element.shadowRoot.querySelector(
+                "slds-scoped-notification_light"
+            );
+            const titlePara = element.shadowRoot.querySelector("p");
+
+            expect(themeDiv).toBeDefined();
+            expect(icon.iconName).toBe("utility:info");
+            expect(titlePara.textContent).toEqual(TITLE);
+            return global.isAccessible(element);
+        });
     });
 
-    it("displays the theme provided", () => {
-        const themes = ["warning", "info", "success", "error"];
+    it("displays the success theme", () => {
         element.title = TITLE;
+        element.theme = "success";
+        document.body.appendChild(element);
+
+        return global.flushPromises().then(() => {
+            const icon = element.shadowRoot.querySelector("lightning-icon");
+            const themeDiv = element.shadowRoot.querySelector(".slds-theme_success");
+            const titlePara = element.shadowRoot.querySelector("p");
+
+            expect(themeDiv).toBeDefined();
+            expect(icon.iconName).toBe("utility:success");
+            expect(titlePara.textContent).toEqual(TITLE);
+            return global.isAccessible(element);
+        });
+    });
+
+    it("displays the error theme", () => {
+        element.title = TITLE;
+        element.theme = "error";
+        document.body.appendChild(element);
 
-        themes.forEach(async theme => {
-            element.theme = theme;
-            document.body.appendChild(element);
+        return global.flushPromises().then(() => {
             const icon = element.shadowRoot.querySelector("lightning-icon");
-            const themeDiv = element.shadowRoot.querySelector(`.slds-theme_${theme}`);
+            const themeDiv = element.shadowRoot.querySelector(".slds-theme_error");
             const titlePara = element.shadowRoot.querySelector("p");
 
             expect(themeDiv).toBeDefined();
-            expect(icon.iconName).toBe(`utility:${theme}`);
+            expect(icon.iconName).toBe("utility:error");
             expect(titlePara.textContent).toEqual(TITLE);
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 });
diff --git a/force-app/main/default/lwc/serviceScheduleCreator/__tests__/serviceScheduleCreator.test.js b/force-app/main/default/lwc/serviceScheduleCreator/__tests__/serviceScheduleCreator.test.js
index 48007260b..1918e0b90 100644
--- a/force-app/main/default/lwc/serviceScheduleCreator/__tests__/serviceScheduleCreator.test.js
+++ b/force-app/main/default/lwc/serviceScheduleCreator/__tests__/serviceScheduleCreator.test.js
@@ -24,13 +24,10 @@ describe("c-service-schedule-creator", () => {
     it("element is accessible", () => {
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const spinner = element.shadowRoot.querySelector("lightning-spinner");
-
             expect(spinner).not.toBeNull();
-
-            // TODO: Validate accessibility when each step is loads.
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 });
diff --git a/force-app/main/default/lwc/serviceScheduleCreatorWrapper/__tests__/serviceScheduleCreatorWrapper.test.js b/force-app/main/default/lwc/serviceScheduleCreatorWrapper/__tests__/serviceScheduleCreatorWrapper.test.js
index 6d5ea3df7..b4fba5c59 100644
--- a/force-app/main/default/lwc/serviceScheduleCreatorWrapper/__tests__/serviceScheduleCreatorWrapper.test.js
+++ b/force-app/main/default/lwc/serviceScheduleCreatorWrapper/__tests__/serviceScheduleCreatorWrapper.test.js
@@ -25,7 +25,7 @@ describe("c-service-schedule-creator", () => {
         element.isCommunity = false;
         document.body.appendChild(element);
 
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const modal = element.shadowRoot.querySelector("c-modal");
 
             // Modal will only display with a spinner loaded
@@ -33,14 +33,14 @@ describe("c-service-schedule-creator", () => {
             modal.dispatchEvent(new CustomEvent("dialogclose"));
 
             // TODO: Validate accessibility when each step is loads.
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 
     it("modal does not appear in experience-cloud context and element is accessible", () => {
         element.isCommunity = true;
         document.body.appendChild(element);
-        return global.flushPromises().then(async () => {
+        return global.flushPromises().then(() => {
             const modal = element.shadowRoot.querySelector("c-modal");
             expect(modal).toBeNull();
 
@@ -54,7 +54,7 @@ describe("c-service-schedule-creator", () => {
             slot.textContent = "Test Accessibility";
             h2Container.attachShadow({ mode: "open" }).appendChild(slot.cloneNode(true));
             // assert that DOM is accessible (using extended preset-rule)
-            global.isAccessible(element);
+            return global.isAccessible(element);
         });
     });
 });
diff --git a/jest.config.js b/jest.config.js
index 802c4904d..4af8d0e71 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -1,7 +1,14 @@
 const { jestConfig } = require("@salesforce/sfdx-lwc-jest/config");
 module.exports = {
     ...jestConfig,
+    moduleNameMapper: {
+        "^lightning/navigation$":
+            "<rootDir>/force-app/main/default/lwc/__tests__/lightning/navigation",
+        "^lightning/uiRecordApi$":
+            "<rootDir>/force-app/main/default/lwc/__tests__/lightning/uiRecordApi"
+    },
     testPathIgnorePatterns: ["force-app/main/default/lwc/__tests__/", ".cci"],
+    coveragePathIgnorePatterns: ["force-app/main/default/lwc/__tests__/", ".cci"],
     reporters: ["default", "jest-junit"],
     setupFilesAfterEnv: ["./jest.setup.js"]
 };
diff --git a/jest.setup.js b/jest.setup.js
index f96ada462..375bce172 100644
--- a/jest.setup.js
+++ b/jest.setup.js
@@ -5,12 +5,9 @@ registerSa11yMatcher();
 
 global.flushPromises = () => new Promise(resolve => setImmediate(resolve));
 
+// assert that DOM is accessible (using extended preset-rule)
 global.isAccessible = async element => {
-    try {
-        await expect(element).toBeAccessible();
-    } catch (e) {
-        console.log(JSON.stringify(e.message));
-    }
+    await expect(element).toBeAccessible();
 };
 
 global.clearDOM = () => {