@fluentui-react-native/tester 0.90.10 → 0.92.0

package/src/E2E/CheckboxExperimental/pages/ExperimentalCheckboxPageObject.ts

@@ -17,57 +17,47 @@ class ExperimentalCheckboxPageObject extends BasePage {
   /******************************************************************/
   /**************** UI Element Interaction Methods ******************/
   /******************************************************************/
-  isCheckboxChecked(): boolean {
-    return this._primaryComponent.isSelected();
+  async isCheckboxChecked(): Promise<boolean> {
+    return await this._primaryComponent.isSelected();
   }
 
-  waitForCheckboxChecked(timeout?: number): void {
-    browser.waitUntil(
-      () => {
-        return this.isCheckboxChecked();
-      },
-      {
-        timeout: timeout ?? this.waitForPageTimeout,
-        timeoutMsg: 'The Checkbox was not toggled correctly',
-        interval: 1000,
-      },
-    );
+  async waitForCheckboxChecked(timeout?: number): Promise<void> {
+    await browser.waitUntil(async () => await this.isCheckboxChecked(), {
+      timeout: timeout ?? this.waitForPageTimeout,
+      timeoutMsg: 'The Checkbox was not toggled correctly',
+      interval: 1000,
+    });
   }
 
   /* Useful in beforeEach() hook to reset the checkbox before every test */
-  toggleCheckboxToUnchecked(): void {
-    if (this.isCheckboxChecked()) {
-      this._primaryComponent.click();
+  async toggleCheckboxToUnchecked(): Promise<void> {
+    if (await this.isCheckboxChecked()) {
+      await this._primaryComponent.click();
     }
   }
 
-  didOnChangeCallbackFire(): boolean {
-    const callbackText = By(EXPERIMENTAL_CHECKBOX_ON_PRESS);
-    browser.waitUntil(
-      () => {
-        return callbackText.isDisplayed();
-      },
-      {
-        timeout: this.waitForPageTimeout,
-        timeoutMsg: 'The OnChange callback did not fire.',
-        interval: 1000,
-      },
-    );
+  async didOnChangeCallbackFire(): Promise<boolean> {
+    const callbackText = await By(EXPERIMENTAL_CHECKBOX_ON_PRESS);
+    await browser.waitUntil(async () => await callbackText.isDisplayed(), {
+      timeout: this.waitForPageTimeout,
+      timeoutMsg: 'The OnChange callback did not fire.',
+      interval: 1000,
+    });
 
-    return callbackText.isDisplayed();
+    return await callbackText.isDisplayed();
   }
 
   /* Sends a Keyboarding command on a specific UI element */
-  sendKey(selector: ExperimentalCheckboxSelector, key: string): void {
-    this.getCheckboxSelector(selector).addValue(key);
+  async sendKey(selector: ExperimentalCheckboxSelector, key: string): Promise<void> {
+    await (await this.getCheckboxSelector(selector)).addValue(key);
   }
 
   /* Returns the correct WebDriverIO element from the Checkbox Selector */
-  getCheckboxSelector(selector?: ExperimentalCheckboxSelector): WebdriverIO.Element {
+  async getCheckboxSelector(selector?: ExperimentalCheckboxSelector): Promise<WebdriverIO.Element> {
     if (selector == ExperimentalCheckboxSelector.Primary) {
-      return this._primaryComponent;
+      return await this._primaryComponent;
     }
-    return this._primaryComponent;
+    return await this._primaryComponent;
   }
 
   /*****************************************/

package/src/E2E/CheckboxExperimental/specs/ExperimentalCheckbox.spec.win.ts

@@ -8,97 +8,97 @@ import {
 import { PAGE_TIMEOUT, BOOT_APP_TIMEOUT, CHECKBOX_A11Y_ROLE, Keys } from '../../common/consts';
 
 describe('Experimental Checkbox Testing Initialization', () => {
-  it('Wait for app load', () => {
-    NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
-    expect(NavigateAppPage.isPageLoaded()).toBeTruthy(NavigateAppPage.ERRORMESSAGE_APPLOAD);
+  it('Wait for app load', async () => {
+    await NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
+    await expect(await NavigateAppPage.isPageLoaded()).toBeTruthy(NavigateAppPage.ERRORMESSAGE_APPLOAD);
   });
 
-  it('Click and navigate to Experimental Checkbox test page', () => {
+  it('Click and navigate to Experimental Checkbox test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    ExperimentalCheckboxPageObject.scrollToComponentButton();
-    ExperimentalCheckboxPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await ExperimentalCheckboxPageObject.scrollToComponentButton();
+    await ExperimentalCheckboxPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToCheckboxExperimentalPage();
-    ExperimentalCheckboxPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToCheckboxExperimentalPage();
+    await ExperimentalCheckboxPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(ExperimentalCheckboxPageObject.isPageLoaded()).toBeTruthy(ExperimentalCheckboxPageObject.ERRORMESSAGE_PAGELOAD);
-    expect(ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await ExperimentalCheckboxPageObject.isPageLoaded()).toBeTruthy(ExperimentalCheckboxPageObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });
 
 describe('Experimental Checkbox Accessibility Testing', () => {
   /* Scrolls and waits for the Checkbox to be visible on the Test Page */
-  beforeEach(() => {
-    ExperimentalCheckboxPageObject.scrollToTestElement();
-    ExperimentalCheckboxPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await ExperimentalCheckboxPageObject.scrollToTestElement();
+    await ExperimentalCheckboxPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
   });
 
-  it('Experimental Checkbox - Validate accessibilityRole is correct', () => {
-    ExperimentalCheckboxPageObject.scrollToTestElement();
-    ExperimentalCheckboxPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  it('Experimental Checkbox - Validate accessibilityRole is correct', async () => {
+    await ExperimentalCheckboxPageObject.scrollToTestElement();
+    await ExperimentalCheckboxPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    expect(ExperimentalCheckboxPageObject.getAccessibilityRole()).toEqual(CHECKBOX_A11Y_ROLE);
-    expect(ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await ExperimentalCheckboxPageObject.getAccessibilityRole()).toEqual(CHECKBOX_A11Y_ROLE);
+    await expect(await ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT);
   });
 
-  it('Experimental Checkbox - Set accessibilityLabel', () => {
-    ExperimentalCheckboxPageObject.scrollToTestElement();
-    ExperimentalCheckboxPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  it('Experimental Checkbox - Set accessibilityLabel', async () => {
+    await ExperimentalCheckboxPageObject.scrollToTestElement();
+    await ExperimentalCheckboxPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    expect(ExperimentalCheckboxPageObject.getAccessibilityLabel(ComponentSelector.Primary)).toEqual(
+    await expect(await ExperimentalCheckboxPageObject.getAccessibilityLabel(ComponentSelector.Primary)).toEqual(
       EXPERIMENTAL_CHECKBOX_ACCESSIBILITY_LABEL,
     );
-    expect(ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT);
   });
 
-  it('Experimental Checkbox - Do not set accessibilityLabel -> Default to Checkbox label', () => {
-    ExperimentalCheckboxPageObject.scrollToTestElement();
-    ExperimentalCheckboxPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  it('Experimental Checkbox - Do not set accessibilityLabel -> Default to Checkbox label', async () => {
+    await ExperimentalCheckboxPageObject.scrollToTestElement();
+    await ExperimentalCheckboxPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    expect(ExperimentalCheckboxPageObject.getAccessibilityLabel(ComponentSelector.Secondary)).toEqual(
+    await expect(await ExperimentalCheckboxPageObject.getAccessibilityLabel(ComponentSelector.Secondary)).toEqual(
       EXPERIMENTAL_CHECKBOX_TEST_COMPONENT_LABEL,
     );
-    expect(ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT);
   });
 });
 
 describe('Checkbox Functional Testing', () => {
   /* Scrolls and waits for the Checkbox to be visible on the Test Page AND un-checks the Checkbox */
-  beforeEach(() => {
-    ExperimentalCheckboxPageObject.scrollToTestElement();
-    ExperimentalCheckboxPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await ExperimentalCheckboxPageObject.scrollToTestElement();
+    await ExperimentalCheckboxPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    ExperimentalCheckboxPageObject.toggleCheckboxToUnchecked();
+    await ExperimentalCheckboxPageObject.toggleCheckboxToUnchecked();
   });
 
-  it("Click on a Checkbox -> Validate it toggles correctly AND calls the user's onChange", () => {
+  it("Click on a Checkbox -> Validate it toggles correctly AND calls the user's onChange", async () => {
     /* Validate the Checkbox is initially toggled OFF */
-    expect(ExperimentalCheckboxPageObject.isCheckboxChecked()).toBeFalsy();
+    await expect(await ExperimentalCheckboxPageObject.isCheckboxChecked()).toBeFalsy();
 
     /* Click on the Checkbox to toggle on */
-    ExperimentalCheckboxPageObject.clickComponent();
-    ExperimentalCheckboxPageObject.waitForCheckboxChecked(PAGE_TIMEOUT);
+    await ExperimentalCheckboxPageObject.clickComponent();
+    await ExperimentalCheckboxPageObject.waitForCheckboxChecked(PAGE_TIMEOUT);
 
-    expect(ExperimentalCheckboxPageObject.didOnChangeCallbackFire()).toBeTruthy();
+    expect(await ExperimentalCheckboxPageObject.didOnChangeCallbackFire()).toBeTruthy();
 
     /* Validate the Checkbox is toggled ON */
-    expect(ExperimentalCheckboxPageObject.isCheckboxChecked()).toBeTruthy();
+    expect(await ExperimentalCheckboxPageObject.isCheckboxChecked()).toBeTruthy();
 
-    ExperimentalCheckboxPageObject.clickComponent();
+    await ExperimentalCheckboxPageObject.clickComponent();
 
     /* Validate the Checkbox is toggled OFF */
-    expect(ExperimentalCheckboxPageObject.isCheckboxChecked()).toBeFalsy();
-    expect(ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT);
+    expect(await ExperimentalCheckboxPageObject.isCheckboxChecked()).toBeFalsy();
+    expect(await ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT);
   });
 
-  it('Click the "Spacebar" on a Checkbox and verify it toggles', () => {
+  it('Click the "Spacebar" on a Checkbox and verify it toggles', async () => {
     /* Presses the "space bar" to select the Checkbox */
-    ExperimentalCheckboxPageObject.sendKey(ExperimentalCheckboxSelector.Primary, Keys.Spacebar);
-    ExperimentalCheckboxPageObject.waitForCheckboxChecked(PAGE_TIMEOUT);
+    await ExperimentalCheckboxPageObject.sendKey(ExperimentalCheckboxSelector.Primary, Keys.Spacebar);
+    await ExperimentalCheckboxPageObject.waitForCheckboxChecked(PAGE_TIMEOUT);
 
     /* Validate the Checkbox is selected */
-    expect(ExperimentalCheckboxPageObject.isCheckboxChecked()).toBeTruthy();
-    expect(ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await ExperimentalCheckboxPageObject.isCheckboxChecked()).toBeTruthy();
+    await expect(await ExperimentalCheckboxPageObject.didAssertPopup()).toBeFalsy(ExperimentalCheckboxPageObject.ERRORMESSAGE_ASSERT);
   });
 });

package/src/E2E/ContextualMenu/pages/ContextualMenuPageObject.win.ts

@@ -17,37 +17,32 @@ class ContextualMenuPageObject extends BasePage {
   /******************************************************************/
   /**************** UI Element Interaction Methods ******************/
   /******************************************************************/
-  waitForContextualMenuItemsToOpen(timeout?: number): void {
-    browser.waitUntil(
-      () => {
-        return this.contextualMenuItemDisplayed();
-      },
-      {
-        timeout: timeout ?? this.waitForPageTimeout,
-        timeoutMsg: 'The Contextual Menu Items did not open.',
-        interval: 1000,
-      },
-    );
+  async waitForContextualMenuItemsToOpen(timeout?: number): Promise<void> {
+    await browser.waitUntil(async () => await this.contextualMenuItemDisplayed(), {
+      timeout: timeout ?? this.waitForPageTimeout,
+      timeoutMsg: 'The Contextual Menu Items did not open.',
+      interval: 1000,
+    });
   }
 
   /* Whether the contextual menu item is displayed or not. It should be displayed after clicking on the MenuButton */
-  contextualMenuItemDisplayed(): boolean {
-    return this._contextualMenuItem.isDisplayed();
+  async contextualMenuItemDisplayed(): Promise<boolean> {
+    return await this._contextualMenuItem.isDisplayed();
   }
 
   /* Sends a Keyboarding command on a specific UI element */
-  sendKey(contextualMenuSelector: ContextualMenuSelector, key: string): void {
-    this.getContextualMenuSelector(contextualMenuSelector).addValue(key);
+  async sendKey(contextualMenuSelector: ContextualMenuSelector, key: string): Promise<void> {
+    await (await this.getContextualMenuSelector(contextualMenuSelector)).addValue(key);
   }
 
   /* Returns the correct WebDriverIO element from the ContextualMenuSelector string */
-  getContextualMenuSelector(contextualMenuSelector?: ContextualMenuSelector): WebdriverIO.Element {
+  async getContextualMenuSelector(contextualMenuSelector?: ContextualMenuSelector): Promise<WebdriverIO.Element> {
     if (contextualMenuSelector == ContextualMenuSelector.ContextualMenu) {
-      return this._primaryComponent;
+      return await this._primaryComponent;
     } else if (contextualMenuSelector == ContextualMenuSelector.ContextualMenuItem) {
-      return this._contextualMenuItem;
+      return await this._contextualMenuItem;
     } else {
-      return this._primaryComponent;
+      return await this._primaryComponent;
     }
   }
 

package/src/E2E/ContextualMenu/specs/ContextualMenu.spec.win.ts

@@ -4,54 +4,54 @@ import { PAGE_TIMEOUT, BOOT_APP_TIMEOUT, Keys } from '../../common/consts';
 
 // Before testing begins, allow up to 60 seconds for app to open
 describe('ContextualMenu Testing Initialization', function () {
-  it('Wait for app load', () => {
-    NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
-    expect(NavigateAppPage.isPageLoaded()).toBeTruthy(NavigateAppPage.ERRORMESSAGE_APPLOAD);
+  it('Wait for app load', async () => {
+    await NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
+    await expect(await NavigateAppPage.isPageLoaded()).toBeTruthy(NavigateAppPage.ERRORMESSAGE_APPLOAD);
   });
 
-  it('Click and navigate to ContextualMenu test page', () => {
+  it('Click and navigate to ContextualMenu test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    ContextualMenuPageObjectObject.scrollToComponentButton();
-    ContextualMenuPageObjectObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await ContextualMenuPageObjectObject.scrollToComponentButton();
+    await ContextualMenuPageObjectObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToContextualMenuPage();
-    ContextualMenuPageObjectObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToContextualMenuPage();
+    await ContextualMenuPageObjectObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(ContextualMenuPageObjectObject.isPageLoaded()).toBeTruthy(ContextualMenuPageObjectObject.ERRORMESSAGE_PAGELOAD);
-    expect(ContextualMenuPageObjectObject.didAssertPopup()).toBeFalsy(ContextualMenuPageObjectObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await ContextualMenuPageObjectObject.isPageLoaded()).toBeTruthy(ContextualMenuPageObjectObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await ContextualMenuPageObjectObject.didAssertPopup()).toBeFalsy(ContextualMenuPageObjectObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });
 
-describe('ContextualMenu Functional Tests', () => {
+describe('ContextualMenu Functional Tests', async () => {
   /* Scrolls and waits for the ContextualMenu to be visible on the Test Page */
-  beforeEach(() => {
-    ContextualMenuPageObjectObject.scrollToTestElement();
-    ContextualMenuPageObjectObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await ContextualMenuPageObjectObject.scrollToTestElement();
+    await ContextualMenuPageObjectObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    ContextualMenuPageObjectObject.sendKey(ContextualMenuSelector.ContextualMenu, Keys.Escape); // Reset ContextualMenu state for next test
+    await ContextualMenuPageObjectObject.sendKey(ContextualMenuSelector.ContextualMenu, Keys.Escape); // Reset ContextualMenu state for next test
   });
 
-  it('Click on ContextualMenu Button and validate that the list of ContextualMenu Items open', () => {
+  it('Click on ContextualMenu Button and validate that the list of ContextualMenu Items open', async () => {
     /* Click on the ContextualMenu */
-    ContextualMenuPageObjectObject.clickComponent();
-    ContextualMenuPageObjectObject.waitForContextualMenuItemsToOpen(PAGE_TIMEOUT);
+    await ContextualMenuPageObjectObject.clickComponent();
+    await ContextualMenuPageObjectObject.waitForContextualMenuItemsToOpen(PAGE_TIMEOUT);
 
-    expect(ContextualMenuPageObjectObject.contextualMenuItemDisplayed()).toBeTruthy();
-    expect(ContextualMenuPageObjectObject.didAssertPopup()).toBeFalsy(ContextualMenuPageObjectObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await ContextualMenuPageObjectObject.contextualMenuItemDisplayed()).toBeTruthy();
+    await expect(await ContextualMenuPageObjectObject.didAssertPopup()).toBeFalsy(ContextualMenuPageObjectObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 
-  it('Type "SpaceBar" to select the ContextualMenu and validate that the list of ContextualMenu Items open', () => {
+  it('Type "SpaceBar" to select the ContextualMenu and validate that the list of ContextualMenu Items open', async () => {
     /* Type a space on the ContextualMenu */
-    ContextualMenuPageObjectObject.sendKey(ContextualMenuSelector.ContextualMenu, Keys.Spacebar);
-    ContextualMenuPageObjectObject.waitForContextualMenuItemsToOpen(PAGE_TIMEOUT);
+    await ContextualMenuPageObjectObject.sendKey(ContextualMenuSelector.ContextualMenu, Keys.Spacebar);
+    await ContextualMenuPageObjectObject.waitForContextualMenuItemsToOpen(PAGE_TIMEOUT);
 
-    expect(ContextualMenuPageObjectObject.contextualMenuItemDisplayed()).toBeTruthy();
-    expect(ContextualMenuPageObjectObject.didAssertPopup()).toBeFalsy(ContextualMenuPageObjectObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await ContextualMenuPageObjectObject.contextualMenuItemDisplayed()).toBeTruthy();
+    await expect(await ContextualMenuPageObjectObject.didAssertPopup()).toBeFalsy(ContextualMenuPageObjectObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 
   /* Runs after all tests. This ensures the ContextualMenu closes. If it stays open, the test driver won't be able to close the test app */
-  afterAll(() => {
-    ContextualMenuPageObjectObject.sendKey(ContextualMenuSelector.ContextualMenu, Keys.Escape); // Reset ContextualMenu state for next test
+  afterAll(async () => {
+    await ContextualMenuPageObjectObject.sendKey(ContextualMenuSelector.ContextualMenu, Keys.Escape); // Reset ContextualMenu state for next test
   });
 });

package/src/E2E/FocusTrapZone/pages/FocusTrapZonePageObject.win.ts

@@ -8,9 +8,9 @@ import { BasePage, By } from '../../common/BasePage.win';
 class FocusTrapZonePageObject extends BasePage {
   // OVERRIDE: We use isExisting() here instead of isDisplayed() because FocusTrapZone does not have any UI to it, it's simply
   // a wrapper that adds keyboard focus functionality
-  waitForPrimaryElementDisplayed(timeout?: number): void {
+  async waitForPrimaryElementDisplayed(timeout?: number): Promise<void> {
     const errorMsg = 'The FocusTrapZone UI Element did not load correctly. Please see logs.';
-    this.waitForCondition(() => this._primaryComponent.isExisting(), errorMsg, timeout);
+    await this.waitForCondition(async () => await this._primaryComponent.isExisting(), errorMsg, timeout);
   }
 
   /*****************************************/

package/src/E2E/FocusTrapZone/specs/FocusTrapZone.spec.win.ts

@@ -4,21 +4,21 @@ import { PAGE_TIMEOUT, BOOT_APP_TIMEOUT } from '../../common/consts';
 
 // Before testing begins, allow up to 60 seconds for app to open
 describe('FocusTrapZone Testing Initialization', function () {
-  it('Wait for app load', () => {
-    NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
-    expect(NavigateAppPage.isPageLoaded()).toBeTruthy(NavigateAppPage.ERRORMESSAGE_APPLOAD);
+  it('Wait for app load', async () => {
+    await NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
+    await expect(await NavigateAppPage.isPageLoaded()).toBeTruthy(NavigateAppPage.ERRORMESSAGE_APPLOAD);
   });
 
-  it('Click and navigate to FocusTrapZone test page', () => {
+  it('Click and navigate to FocusTrapZone test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    FocusTrapZonePageObject.scrollToComponentButton();
-    FocusTrapZonePageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await FocusTrapZonePageObject.scrollToComponentButton();
+    await FocusTrapZonePageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToFocusTrapZonePage();
-    FocusTrapZonePageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToFocusTrapZonePage();
+    await FocusTrapZonePageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(FocusTrapZonePageObject.isPageLoaded()).toBeTruthy(FocusTrapZonePageObject.ERRORMESSAGE_PAGELOAD);
-    expect(FocusTrapZonePageObject.didAssertPopup()).toBeFalsy(FocusTrapZonePageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await FocusTrapZonePageObject.isPageLoaded()).toBeTruthy(FocusTrapZonePageObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await FocusTrapZonePageObject.didAssertPopup()).toBeFalsy(FocusTrapZonePageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });

package/src/E2E/FocusZone/pages/FocusZonePageObject.macos.ts

@@ -4,9 +4,9 @@ import { BasePage, By } from '../../common/BasePage.macos';
 class FocusZonePageObject extends BasePage {
   // OVERRIDE: We use isExisting() here instead of isDisplayed() because FocusZone does not have any UI to it, it's simply
   // a wrapper that adds keyboard focus functionality
-  waitForPrimaryElementDisplayed(timeout?: number): void {
+  async waitForPrimaryElementDisplayed(timeout?: number): Promise<void> {
     const errorMsg = 'The FocusZone UI Element did not load correctly. Please see logs.';
-    this.waitForCondition(() => this._primaryComponent.isExisting(), errorMsg, timeout);
+    await this.waitForCondition(async () => await this._primaryComponent.isExisting(), errorMsg, timeout);
   }
 
   /*****************************************/

package/src/E2E/FocusZone/pages/FocusZonePageObject.win.ts

@@ -4,9 +4,9 @@ import { BasePage, By } from '../../common/BasePage.win';
 class FocusZonePageObject extends BasePage {
   // OVERRIDE: We use isExisting() here instead of isDisplayed() because FocusZone does not have any UI to it, it's simply
   // a wrapper that adds keyboard focus functionality
-  waitForPrimaryElementDisplayed(timeout?: number): void {
+  async waitForPrimaryElementDisplayed(timeout?: number): Promise<void> {
     const errorMsg = 'The FocusZone UI Element did not load correctly. Please see logs.';
-    this.waitForCondition(() => this._primaryComponent.isExisting(), errorMsg, timeout);
+    await this.waitForCondition(async () => await this._primaryComponent.isExisting(), errorMsg, timeout);
   }
 
   /*****************************************/

package/src/E2E/FocusZone/specs/FocusZone.spec.macos.ts

@@ -4,20 +4,20 @@ import { PAGE_TIMEOUT, BOOT_APP_TIMEOUT } from '../../common/consts';
 
 // Before testing begins, allow up to 60 seconds for app to open
 describe('FocusZone Testing Initialization', function () {
-  it('Wait for app load', () => {
-    NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
-    expect(NavigateAppPage.isPageLoaded()).toBeTruthy();
+  it('Wait for app load', async () => {
+    await NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
+    await expect(await NavigateAppPage.isPageLoaded()).toBeTruthy();
   });
 
-  it('Click and navigate to FocusZone test page', () => {
+  it('Click and navigate to FocusZone test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    FocusZonePageObject.scrollToComponentButton();
-    FocusZonePageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await FocusZonePageObject.scrollToComponentButton();
+    await FocusZonePageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToFocusZonePage();
-    FocusZonePageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToFocusZonePage();
+    await FocusZonePageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(FocusZonePageObject.isPageLoaded()).toBeTruthy();
+    await expect(await FocusZonePageObject.isPageLoaded()).toBeTruthy();
   });
 });

package/src/E2E/FocusZone/specs/FocusZone.spec.win.ts

@@ -4,21 +4,21 @@ import { PAGE_TIMEOUT, BOOT_APP_TIMEOUT } from '../../common/consts';
 
 // Before testing begins, allow up to 60 seconds for app to open
 describe('FocusZone Testing Initialization', function () {
-  it('Wait for app load', () => {
-    NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
-    expect(NavigateAppPage.isPageLoaded()).toBeTruthy(NavigateAppPage.ERRORMESSAGE_APPLOAD);
+  it('Wait for app load', async () => {
+    await NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
+    await expect(await NavigateAppPage.isPageLoaded()).toBeTruthy(NavigateAppPage.ERRORMESSAGE_APPLOAD);
   });
 
-  it('Click and navigate to FocusZone test page', () => {
+  it('Click and navigate to FocusZone test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    FocusZonePageObject.scrollToComponentButton();
-    FocusZonePageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await FocusZonePageObject.scrollToComponentButton();
+    await FocusZonePageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToFocusZonePage();
-    FocusZonePageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToFocusZonePage();
+    await FocusZonePageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(FocusZonePageObject.isPageLoaded()).toBeTruthy(FocusZonePageObject.ERRORMESSAGE_PAGELOAD);
-    expect(FocusZonePageObject.didAssertPopup()).toBeFalsy(FocusZonePageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await FocusZonePageObject.isPageLoaded()).toBeTruthy(FocusZonePageObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await FocusZonePageObject.didAssertPopup()).toBeFalsy(FocusZonePageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });

package/src/E2E/Icon/specs/Icon.spec.macos.ts

@@ -4,20 +4,20 @@ import { PAGE_TIMEOUT, BOOT_APP_TIMEOUT } from '../../common/consts';
 
 // Before testing begins, allow up to 60 seconds for app to open
 describe('Icon Testing Initialization', function () {
-  it('Wait for app load', () => {
-    NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
-    expect(NavigateAppPage.isPageLoaded()).toBeTruthy();
+  it('Wait for app load', async () => {
+    await NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
+    await expect(await NavigateAppPage.isPageLoaded()).toBeTruthy();
   });
 
-  it('Click and navigate to Icon test page', () => {
+  it('Click and navigate to Icon test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    IconPageObject.scrollToComponentButton();
-    IconPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await IconPageObject.scrollToComponentButton();
+    await IconPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToIconPage();
-    IconPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToIconPage();
+    await IconPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(IconPageObject.isPageLoaded()).toBeTruthy();
+    await expect(await IconPageObject.isPageLoaded()).toBeTruthy();
   });
 });

package/src/E2E/Icon/specs/Icon.spec.win.ts

@@ -4,21 +4,21 @@ import { PAGE_TIMEOUT, BOOT_APP_TIMEOUT } from '../../common/consts';
 
 // Before testing begins, allow up to 60 seconds for app to open
 describe('Icon Testing Initialization', function () {
-  it('Wait for app load', () => {
-    NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
-    expect(NavigateAppPage.isPageLoaded()).toBeTruthy(NavigateAppPage.ERRORMESSAGE_APPLOAD);
+  it('Wait for app load', async () => {
+    await NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
+    await expect(await NavigateAppPage.isPageLoaded()).toBeTruthy(NavigateAppPage.ERRORMESSAGE_APPLOAD);
   });
 
-  it('Click and navigate to Icon test page', () => {
+  it('Click and navigate to Icon test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    IconPageObject.scrollToComponentButton();
-    IconPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await IconPageObject.scrollToComponentButton();
+    await IconPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToIconPage();
-    IconPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToIconPage();
+    await IconPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(IconPageObject.isPageLoaded()).toBeTruthy(IconPageObject.ERRORMESSAGE_PAGELOAD);
-    expect(IconPageObject.didAssertPopup()).toBeFalsy(IconPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await IconPageObject.isPageLoaded()).toBeTruthy(IconPageObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await IconPageObject.didAssertPopup()).toBeFalsy(IconPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });

package/src/E2E/Link/specs/Link.spec.macos.ts

@@ -4,20 +4,20 @@ import { PAGE_TIMEOUT, BOOT_APP_TIMEOUT } from '../../common/consts';
 
 // Before testing begins, allow up to 60 seconds for app to open
 describe('Link Testing Initialization', function () {
-  it('Wait for app load', () => {
-    NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
-    expect(NavigateAppPage.isPageLoaded()).toBeTruthy();
+  it('Wait for app load', async () => {
+    await NavigateAppPage.waitForPageDisplayed(BOOT_APP_TIMEOUT);
+    await expect(await NavigateAppPage.isPageLoaded()).toBeTruthy();
   });
 
-  it('Click and navigate to Link test page', () => {
+  it('Click and navigate to Link test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    LinkPageObject.scrollToComponentButton();
-    LinkPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await LinkPageObject.scrollToComponentButton();
+    await LinkPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToLinkPage();
-    LinkPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToLinkPage();
+    await LinkPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(LinkPageObject.isPageLoaded()).toBeTruthy();
+    await expect(await LinkPageObject.isPageLoaded()).toBeTruthy();
   });
 });