@fluentui-react-native/tester 0.90.11 → 0.91.0

package/src/E2E/Menu/pages/MenuPageObject.ts

@@ -22,70 +22,60 @@ class MenuPageObject extends BasePage {
   /******************************************************************/
   /**************** UI Element Interaction Methods ******************/
   /******************************************************************/
-  didMenuOpen(): boolean {
-    const callbackText = By(MENU_ON_OPEN);
-    browser.waitUntil(
-      () => {
-        return callbackText.isDisplayed();
-      },
-      {
-        timeout: this.waitForPageTimeout,
-        timeoutMsg: 'The Menu did not open.',
-        interval: 1000,
-      },
-    );
-
-    return callbackText.isDisplayed();
+  async didMenuOpen(): Promise<boolean> {
+    const callbackText = await By(MENU_ON_OPEN);
+    await browser.waitUntil(async () => await callbackText.isDisplayed(), {
+      timeout: this.waitForPageTimeout,
+      timeoutMsg: 'The Menu did not open.',
+      interval: 1000,
+    });
+
+    return await callbackText.isDisplayed();
   }
 
-  didMenuClose(): boolean {
-    const callbackText = By(MENU_ON_CLOSE);
-    browser.waitUntil(
-      () => {
-        return callbackText.isDisplayed();
-      },
-      {
-        timeout: this.waitForPageTimeout,
-        timeoutMsg: 'The Menu did not close.',
-        interval: 1000,
-      },
-    );
-
-    return callbackText.isDisplayed();
+  async didMenuClose(): Promise<boolean> {
+    const callbackText = await By(MENU_ON_CLOSE);
+    await browser.waitUntil(async () => await callbackText.isDisplayed(), {
+      timeout: this.waitForPageTimeout,
+      timeoutMsg: 'The Menu did not close.',
+      interval: 1000,
+    });
+
+    return await callbackText.isDisplayed();
   }
 
-  getMenuItemAccessibilityLabel(componentSelector: MenuComponentSelector): string {
+  async getMenuItemAccessibilityLabel(componentSelector: MenuComponentSelector): Promise<string> {
     switch (componentSelector) {
       case MenuComponentSelector.PrimaryComponent:
-        return this._primaryComponent.getAttribute('Name');
+        return await this._primaryComponent.getAttribute('Name');
 
       case MenuComponentSelector.SecondaryComponent:
-        return this._secondaryComponent.getAttribute('Name');
+        return await this._secondaryComponent.getAttribute('Name');
 
       case MenuComponentSelector.TertiaryComponent:
-        return this._tertiaryComponent.getAttribute('Name');
+        return await this._tertiaryComponent.getAttribute('Name');
     }
   }
 
-  getMenuAccessibilityRole(): string {
-    return By(MENUPOPOVER_TEST_COMPONENT).getAttribute('ControlType');
+  async getMenuAccessibilityRole(): Promise<string> {
+    return await By(MENUPOPOVER_TEST_COMPONENT).getAttribute('ControlType');
   }
 
-  getMenuItemAccessibilityRole(): string {
-    return this._secondaryComponent.getAttribute('ControlType');
+  async getMenuItemAccessibilityRole(): Promise<string> {
+    return await this._secondaryComponent.getAttribute('ControlType');
   }
 
   /* Sends a Keyboarding command on a specific UI element */
-  sendKey(menuComponentSelector: MenuComponentSelector, key: string): void {
-    this.getMenuComponentSelector(menuComponentSelector).addValue(key);
+  async sendKey(menuComponentSelector: MenuComponentSelector, key: string): Promise<void> {
+    await (await this.getMenuComponentSelector(menuComponentSelector)).addValue(key);
   }
 
   /* Returns the correct WebDriverIO element from the Button Selector */
-  getMenuComponentSelector(menuComponentSelector?: MenuComponentSelector): WebdriverIO.Element {
+  async getMenuComponentSelector(menuComponentSelector?: MenuComponentSelector): Promise<WebdriverIO.Element> {
     if (menuComponentSelector == MenuComponentSelector.PrimaryComponent) {
-      return this._primaryComponent;
+      return await this._primaryComponent;
     }
-    return this._primaryComponent;
+    return await this._primaryComponent;
   }
 
   /*****************************************/

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

@@ -5,117 +5,119 @@ import { MENUITEM_ACCESSIBILITY_LABEL, MENUITEM_TEST_LABEL } from '../../../Test
 
 // Before testing begins, allow up to 60 seconds for app to open
 describe('Menu 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 Menu test page', () => {
+  it('Click and navigate to Menu test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    MenuPageObject.scrollToComponentButton();
-    MenuPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await MenuPageObject.scrollToComponentButton();
+    await MenuPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToMenuPage();
-    MenuPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToMenuPage();
+    await MenuPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(MenuPageObject.isPageLoaded()).toBeTruthy(MenuPageObject.ERRORMESSAGE_PAGELOAD);
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await MenuPageObject.isPageLoaded()).toBeTruthy(MenuPageObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });
 
 describe('Menu Functional Testing', () => {
   /* Scrolls and waits for the Menu to be visible on the Test Page */
-  beforeEach(() => {
-    MenuPageObject.scrollToTestElement();
-    MenuPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await MenuPageObject.scrollToTestElement();
+    await MenuPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
   });
 
-  it('Validate OnOpenChange() callback was fired -> Click', () => {
-    MenuPageObject.clickComponent();
-    expect(MenuPageObject.didMenuOpen()).toBeTruthy();
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+  it('Validate OnOpenChange() callback was fired -> Click', async () => {
+    await MenuPageObject.clickComponent();
+    await expect(await MenuPageObject.didMenuOpen()).toBeTruthy();
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
-    MenuPageObject.clickComponent();
-    expect(MenuPageObject.didMenuClose()).toBeTruthy();
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await MenuPageObject.clickComponent();
+    await expect(await MenuPageObject.didMenuClose()).toBeTruthy();
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
   });
 
-  it('Validate OnOpenChange() callback was fired -> Type "Enter"', () => {
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
-    expect(MenuPageObject.didMenuOpen()).toBeTruthy();
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+  it('Validate OnOpenChange() callback was fired -> Type "Enter"', async () => {
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
+    await expect(await MenuPageObject.didMenuOpen()).toBeTruthy();
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
-    expect(MenuPageObject.didMenuClose()).toBeTruthy();
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
+    await expect(await MenuPageObject.didMenuClose()).toBeTruthy();
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
   });
 
-  it('Validate OnOpenChange() callback was fired -> Type "Spacebar"', () => {
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Spacebar);
-    expect(MenuPageObject.didMenuOpen()).toBeTruthy();
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+  it('Validate OnOpenChange() callback was fired -> Type "Spacebar"', async () => {
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Spacebar);
+    await expect(await MenuPageObject.didMenuOpen()).toBeTruthy();
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
     MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Spacebar);
-    expect(MenuPageObject.didMenuClose()).toBeTruthy();
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await MenuPageObject.didMenuClose()).toBeTruthy();
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
   });
 });
 
 describe('Menu Accessibility Testing', () => {
-  it('Menu - Validate accessibilityRole of menu item is correct', () => {
-    MenuPageObject.scrollToTestElement();
-    MenuPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  it('Menu - Validate accessibilityRole of menu item is correct', async () => {
+    await MenuPageObject.scrollToTestElement();
+    await MenuPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
-    expect(MenuPageObject.didMenuOpen()).toBeTruthy();
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
+    await expect(await MenuPageObject.didMenuOpen()).toBeTruthy();
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
-    expect(MenuPageObject.getMenuItemAccessibilityRole()).toEqual(MENUITEM_A11Y_ROLE);
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await MenuPageObject.getMenuItemAccessibilityRole()).toEqual(MENUITEM_A11Y_ROLE);
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
   });
 
-  it('Menu - Validate accessibilityRole of menu is correct', () => {
-    MenuPageObject.scrollToTestElement();
-    MenuPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  it('Menu - Validate accessibilityRole of menu is correct', async () => {
+    await MenuPageObject.scrollToTestElement();
+    await MenuPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
-    expect(MenuPageObject.didMenuOpen()).toBeTruthy();
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
+    await expect(await MenuPageObject.didMenuOpen()).toBeTruthy();
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
-    expect(MenuPageObject.getMenuAccessibilityRole()).toEqual(MENU_A11Y_ROLE);
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await MenuPageObject.getMenuAccessibilityRole()).toEqual(MENU_A11Y_ROLE);
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
   });
 
-  it('Menu - Set accessibilityLabel', () => {
-    MenuPageObject.scrollToTestElement();
-    MenuPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  it('Menu - Set accessibilityLabel', async () => {
+    await MenuPageObject.scrollToTestElement();
+    await MenuPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
-    expect(MenuPageObject.didMenuOpen()).toBeTruthy();
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
+    await expect(await MenuPageObject.didMenuOpen()).toBeTruthy();
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
-    expect(MenuPageObject.getMenuItemAccessibilityLabel(MenuComponentSelector.SecondaryComponent)).toEqual(MENUITEM_ACCESSIBILITY_LABEL);
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await MenuPageObject.getMenuItemAccessibilityLabel(MenuComponentSelector.SecondaryComponent)).toEqual(
+      MENUITEM_ACCESSIBILITY_LABEL,
+    );
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
   });
 
-  it('Menu - Do not set accessibilityLabel -> Default to MenuItem label', () => {
-    MenuPageObject.scrollToTestElement();
-    MenuPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  it('Menu - Do not set accessibilityLabel -> Default to MenuItem label', async () => {
+    await MenuPageObject.scrollToTestElement();
+    await MenuPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
-    expect(MenuPageObject.didMenuOpen()).toBeTruthy();
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
+    await expect(await MenuPageObject.didMenuOpen()).toBeTruthy();
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
-    expect(MenuPageObject.getMenuItemAccessibilityLabel(MenuComponentSelector.TertiaryComponent)).toEqual(MENUITEM_TEST_LABEL);
-    expect(MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await MenuPageObject.getMenuItemAccessibilityLabel(MenuComponentSelector.TertiaryComponent)).toEqual(MENUITEM_TEST_LABEL);
+    await expect(await MenuPageObject.didAssertPopup()).toBeFalsy(MenuPageObject.ERRORMESSAGE_ASSERT);
 
-    MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
+    await MenuPageObject.sendKey(MenuComponentSelector.PrimaryComponent, Keys.Enter);
   });
 });

package/src/E2E/MenuButton/pages/MenuButtonPageObject.win.ts

@@ -16,37 +16,32 @@ class MenuButtonPageObject extends BasePage {
   /******************************************************************/
   /**************** UI Element Interaction Methods ******************/
   /******************************************************************/
-  waitForMenuItemsToOpen(timeout?: number): void {
-    browser.waitUntil(
-      () => {
-        return this.menuItemDisplayed();
-      },
-      {
-        timeout: timeout ?? this.waitForPageTimeout,
-        timeoutMsg: 'The Menu Items did not open.',
-        interval: 1000,
-      },
-    );
+  async waitForMenuItemsToOpen(timeout?: number): Promise<void> {
+    await browser.waitUntil(async () => await this.menuItemDisplayed(), {
+      timeout: timeout ?? this.waitForPageTimeout,
+      timeoutMsg: 'The Menu Items did not open.',
+      interval: 1000,
+    });
   }
 
   /* Whether the menu item is displayed or not. It should be displayed after clicking on the MenuButton */
-  menuItemDisplayed(): boolean {
-    return this._menuItem.isDisplayed();
+  async menuItemDisplayed(): Promise<boolean> {
+    return await this._menuItem.isDisplayed();
   }
 
   /* Sends a Keyboarding command on a specific UI element */
-  sendKey(selector: MenuButtonSelector, key: string): void {
-    this.getMenuButtonSelector(selector).addValue(key);
+  async sendKey(selector: MenuButtonSelector, key: string): Promise<void> {
+    await (await this.getMenuButtonSelector(selector)).addValue(key);
   }
 
   /* Returns the correct WebDriverIO element from the MenuButton Selector */
-  getMenuButtonSelector(selector?: MenuButtonSelector): WebdriverIO.Element {
+  async getMenuButtonSelector(selector?: MenuButtonSelector): Promise<WebdriverIO.Element> {
     if (selector == MenuButtonSelector.MenuButton) {
-      return this._primaryComponent;
+      return await this._primaryComponent;
     } else if (selector == MenuButtonSelector.MenuItem1) {
-      return this._menuItem;
+      return await this._menuItem;
     }
-    return this._primaryComponent;
+    return await this._primaryComponent;
   }
 
   /*****************************************/

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

@@ -6,78 +6,78 @@ import { ComponentSelector } from '../../common/BasePage.win';
 
 // Before testing begins, allow up to 60 seconds for app to open
 describe('MenuButton 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 MenuButton test page', () => {
+  it('Click and navigate to MenuButton test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    MenuButtonPageObject.scrollToComponentButton();
-    MenuButtonPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await MenuButtonPageObject.scrollToComponentButton();
+    await MenuButtonPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToMenuButtonPage();
-    MenuButtonPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToMenuButtonPage();
+    await MenuButtonPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(MenuButtonPageObject.isPageLoaded()).toBeTruthy(MenuButtonPageObject.ERRORMESSAGE_PAGELOAD);
-    expect(MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await MenuButtonPageObject.isPageLoaded()).toBeTruthy(MenuButtonPageObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });
 
 /* This will be re-enabled with a MenuButton Bug is fixed. Currently in PR - "Integrating accessibilityLabel functionality for MenuButton #1117" */
 describe('MenuButton Accessibility Testing', () => {
   /* Scrolls and waits for the MenuButton to be visible on the Test Page */
-  beforeEach(() => {
-    MenuButtonPageObject.scrollToTestElement();
-    MenuButtonPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await MenuButtonPageObject.scrollToTestElement();
+    await MenuButtonPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
   });
 
-  it('MenuButton - Validate accessibilityRole is correct', () => {
-    expect(MenuButtonPageObject.getAccessibilityRole()).toEqual(MENUBUTTON_A11Y_ROLE);
-    expect(MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT);
+  it('MenuButton - Validate accessibilityRole is correct', async () => {
+    await expect(await MenuButtonPageObject.getAccessibilityRole()).toEqual(MENUBUTTON_A11Y_ROLE);
+    await expect(await MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT);
   });
 
-  it('MenuButton - Set accessibilityLabel', () => {
-    expect(MenuButtonPageObject.getAccessibilityLabel(ComponentSelector.Primary)).toEqual(MENU_BUTTON_ACCESSIBILITY_LABEL);
-    expect(MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT);
+  it('MenuButton - Set accessibilityLabel', async () => {
+    await expect(await MenuButtonPageObject.getAccessibilityLabel(ComponentSelector.Primary)).toEqual(MENU_BUTTON_ACCESSIBILITY_LABEL);
+    await expect(await MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT);
   });
 
-  it('Do not set accessibilityLabel -> Default to MenuButton label', () => {
-    expect(MenuButtonPageObject.getAccessibilityLabel(ComponentSelector.Secondary)).toEqual(MENU_BUTTON_TEST_COMPONENT_LABEL);
-    expect(MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT);
+  it('Do not set accessibilityLabel -> Default to MenuButton label', async () => {
+    await expect(await MenuButtonPageObject.getAccessibilityLabel(ComponentSelector.Secondary)).toEqual(MENU_BUTTON_TEST_COMPONENT_LABEL);
+    await expect(await MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT);
   });
 });
 
 describe('MenuButton Functional Testing', () => {
   /* Scrolls and waits for the MenuButton to be visible on the Test Page */
-  beforeEach(() => {
-    MenuButtonPageObject.scrollToTestElement();
-    MenuButtonPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await MenuButtonPageObject.scrollToTestElement();
+    await MenuButtonPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    MenuButtonPageObject.sendKey(MenuButtonSelector.MenuButton, Keys.Escape); // Reset MenuButton state for next test
+    await MenuButtonPageObject.sendKey(MenuButtonSelector.MenuButton, Keys.Escape); // Reset MenuButton state for next test
   });
 
-  it('Click on MenuButton and validate that the list of Menu Items open', () => {
+  it('Click on MenuButton and validate that the list of Menu Items open', async () => {
     /* Click on the MenuButton */
-    MenuButtonPageObject.clickComponent();
-    MenuButtonPageObject.waitForMenuItemsToOpen(PAGE_TIMEOUT);
+    await MenuButtonPageObject.clickComponent();
+    await MenuButtonPageObject.waitForMenuItemsToOpen(PAGE_TIMEOUT);
 
-    expect(MenuButtonPageObject.menuItemDisplayed()).toBeTruthy();
-    expect(MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await MenuButtonPageObject.menuItemDisplayed()).toBeTruthy();
+    await expect(await MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT);
   });
 
-  it('Type "SpaceBar" to select the MenuButton and validate that the list of Menu Items open', () => {
+  it('Type "SpaceBar" to select the MenuButton and validate that the list of Menu Items open', async () => {
     /* Type a space on the MenuButton */
-    MenuButtonPageObject.sendKey(MenuButtonSelector.MenuButton, Keys.Spacebar);
-    MenuButtonPageObject.waitForMenuItemsToOpen(PAGE_TIMEOUT);
+    await MenuButtonPageObject.sendKey(MenuButtonSelector.MenuButton, Keys.Spacebar);
+    await MenuButtonPageObject.waitForMenuItemsToOpen(PAGE_TIMEOUT);
 
-    expect(MenuButtonPageObject.menuItemDisplayed()).toBeTruthy();
-    expect(MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await MenuButtonPageObject.menuItemDisplayed()).toBeTruthy();
+    await expect(await MenuButtonPageObject.didAssertPopup()).toBeFalsy(MenuButtonPageObject.ERRORMESSAGE_ASSERT);
   });
 
   /* Runs after all tests. This ensures the MenuButton closes. If it stays open, the test driver won't be able to close the test app */
-  afterAll(() => {
-    MenuButtonPageObject.sendKey(MenuButtonSelector.MenuButton, Keys.Escape);
+  afterAll(async () => {
+    await MenuButtonPageObject.sendKey(MenuButtonSelector.MenuButton, Keys.Escape);
   });
 });

package/src/E2E/MenuButtonExperimental/specs/ExperimentalMenuButton.spec.win.ts

@@ -9,52 +9,52 @@ import { ComponentSelector } from '../../common/BasePage.win';
 
 // Before testing begins, allow up to 60 seconds for app to open
 describe('Experimental MenuButton 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 Experimental MenuButton test page', () => {
+  it('Click and navigate to Experimental MenuButton test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    ExperimentalMenuButtonPageObject.scrollToComponentButton();
-    ExperimentalMenuButtonPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await ExperimentalMenuButtonPageObject.scrollToComponentButton();
+    await ExperimentalMenuButtonPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToExperimentalMenuButtonPage();
-    ExperimentalMenuButtonPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToExperimentalMenuButtonPage();
+    await ExperimentalMenuButtonPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(ExperimentalMenuButtonPageObject.isPageLoaded()).toBeTruthy(ExperimentalMenuButtonPageObject.ERRORMESSAGE_PAGELOAD);
-    expect(ExperimentalMenuButtonPageObject.didAssertPopup()).toBeFalsy(ExperimentalMenuButtonPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await ExperimentalMenuButtonPageObject.isPageLoaded()).toBeTruthy(ExperimentalMenuButtonPageObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await ExperimentalMenuButtonPageObject.didAssertPopup()).toBeFalsy(ExperimentalMenuButtonPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });
 
 /* This will be re-enabled with a MenuButton Bug is fixed. Currently in PR - "Integrating accessibilityLabel functionality for MenuButton #1117" */
 describe('Experimental MenuButton Accessibility Testing', () => {
-  it('Experimental MenuButton - Validate accessibilityRole is correct', () => {
-    ExperimentalMenuButtonPageObject.scrollToTestElement();
-    ExperimentalMenuButtonPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  it('Experimental MenuButton - Validate accessibilityRole is correct', async () => {
+    await ExperimentalMenuButtonPageObject.scrollToTestElement();
+    await ExperimentalMenuButtonPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    expect(ExperimentalMenuButtonPageObject.getAccessibilityRole()).toEqual(MENUBUTTON_A11Y_ROLE);
-    expect(ExperimentalMenuButtonPageObject.didAssertPopup()).toBeFalsy(ExperimentalMenuButtonPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await ExperimentalMenuButtonPageObject.getAccessibilityRole()).toEqual(MENUBUTTON_A11Y_ROLE);
+    await expect(await ExperimentalMenuButtonPageObject.didAssertPopup()).toBeFalsy(ExperimentalMenuButtonPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 
-  it('Experimental MenuButton - Set accessibilityLabel', () => {
-    ExperimentalMenuButtonPageObject.scrollToTestElement();
-    ExperimentalMenuButtonPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  it('Experimental MenuButton - Set accessibilityLabel', async () => {
+    await ExperimentalMenuButtonPageObject.scrollToTestElement();
+    await ExperimentalMenuButtonPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    expect(ExperimentalMenuButtonPageObject.getAccessibilityLabel(ComponentSelector.Primary)).toEqual(
+    await expect(await ExperimentalMenuButtonPageObject.getAccessibilityLabel(ComponentSelector.Primary)).toEqual(
       EXPERIMENTAL_MENU_BUTTON_ACCESSIBILITY_LABEL,
     );
-    expect(ExperimentalMenuButtonPageObject.didAssertPopup()).toBeFalsy(ExperimentalMenuButtonPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await ExperimentalMenuButtonPageObject.didAssertPopup()).toBeFalsy(ExperimentalMenuButtonPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 
-  it('Do not set accessibilityLabel -> Default to Experimental MenuButton label', () => {
-    ExperimentalMenuButtonPageObject.scrollToTestElement();
-    ExperimentalMenuButtonPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  it('Do not set accessibilityLabel -> Default to Experimental MenuButton label', async () => {
+    await ExperimentalMenuButtonPageObject.scrollToTestElement();
+    await ExperimentalMenuButtonPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
 
-    expect(ExperimentalMenuButtonPageObject.getAccessibilityLabel(ComponentSelector.Secondary)).toEqual(
+    await expect(await ExperimentalMenuButtonPageObject.getAccessibilityLabel(ComponentSelector.Secondary)).toEqual(
       EXPERIMENTAL_MENU_BUTTON_TEST_COMPONENT_LABEL,
     );
-    expect(ExperimentalMenuButtonPageObject.didAssertPopup()).toBeFalsy(ExperimentalMenuButtonPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await ExperimentalMenuButtonPageObject.didAssertPopup()).toBeFalsy(ExperimentalMenuButtonPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });

package/src/E2E/Persona/specs/Persona.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('Persona 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 Persona test page', () => {
+  it('Click and navigate to Persona test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    PersonaPageObject.scrollToComponentButton();
-    PersonaPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await PersonaPageObject.scrollToComponentButton();
+    await PersonaPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToPersonaPage();
-    PersonaPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToPersonaPage();
+    await PersonaPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(PersonaPageObject.isPageLoaded()).toBeTruthy();
+    await expect(await PersonaPageObject.isPageLoaded()).toBeTruthy();
   });
 });

package/src/E2E/Persona/specs/Persona.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('Persona 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 Persona test page', () => {
+  it('Click and navigate to Persona test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    PersonaPageObject.scrollToComponentButton();
-    PersonaPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await PersonaPageObject.scrollToComponentButton();
+    await PersonaPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
 
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToPersonaPage();
-    PersonaPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToPersonaPage();
+    await PersonaPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
 
-    expect(PersonaPageObject.isPageLoaded()).toBeTruthy(PersonaPageObject.ERRORMESSAGE_PAGELOAD);
-    expect(PersonaPageObject.didAssertPopup()).toBeFalsy(PersonaPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await PersonaPageObject.isPageLoaded()).toBeTruthy(PersonaPageObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await PersonaPageObject.didAssertPopup()).toBeFalsy(PersonaPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });