npm - @fluentui-react-native/tester - Versions diffs - 0.90.10 → 0.92.0 - Mend

@fluentui-react-native/tester 0.90.10 → 0.92.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (624) hide show

package/src/E2E/Svg/specs/Svg.spec.win.ts CHANGED Viewed

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

package/src/E2E/Switch/pages/SwitchPageObject.ts CHANGED Viewed

@@ -18,58 +18,48 @@ class SwitchPageObject extends BasePage {
   /******************************************************************/
   /**************** UI Element Interaction Methods ******************/
   /******************************************************************/
-  isSwitchChecked(): boolean {
-    return this._primaryComponent.isSelected();
+  async isSwitchChecked(): Promise<boolean> {
+    return await this._primaryComponent.isSelected();
   }
-  waitForSwitchChecked(timeout?: number): void {
-    browser.waitUntil(
-      () => {
-        return this.isSwitchChecked();
-      },
-      {
-        timeout: timeout ?? this.waitForPageTimeout,
-        timeoutMsg: 'The Switch was not toggled correctly',
-        interval: 1000,
-      },
-    );
+  async waitForSwitchChecked(timeout?: number): Promise<void> {
+    browser.waitUntil(async () => await this.isSwitchChecked(), {
+      timeout: timeout ?? this.waitForPageTimeout,
+      timeoutMsg: 'The Switch was not toggled correctly',
+      interval: 1000,
+    });
   }
-  toggleSwitchToUnchecked(): void {
-    if (this.isSwitchChecked()) {
-      this._primaryComponent.click();
+  async toggleSwitchToUnchecked(): Promise<void> {
+    if (await this.isSwitchChecked()) {
+      await this._primaryComponent.click();
     }
   }
-  didOnChangeCallbackFire(): boolean {
-    const callbackText = By(SWITCH_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(SWITCH_ON_PRESS);
+    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(switchSelector: SwitchComponentSelector, key: string): void {
-    this.getButtonSelector(switchSelector).addValue(key);
+  async sendKey(switchSelector: SwitchComponentSelector, key: string): Promise<void> {
+    await (await this.getButtonSelector(switchSelector)).addValue(key);
   }
   /* Returns the correct WebDriverIO element from the Button Selector */
-  getButtonSelector(switchSelector?: SwitchComponentSelector): WebdriverIO.Element {
+  async getButtonSelector(switchSelector?: SwitchComponentSelector): Promise<WebdriverIO.Element> {
     if (switchSelector == SwitchComponentSelector.PrimaryComponent) {
-      return this._primaryComponent;
+      return await this._primaryComponent;
     } else if (switchSelector === SwitchComponentSelector.SecondaryComponent) {
-      return this._secondaryComponent;
+      return await this._secondaryComponent;
     }
-    return this._primaryComponent;
+    return await this._primaryComponent;
   }
   /*****************************************/

package/src/E2E/Switch/specs/Switch.spec.win.ts CHANGED Viewed

@@ -7,114 +7,114 @@ import { SWITCH_TEST_COMPONENT_LABEL, SWITCH_ACCESSIBILITY_LABEL } from '../../.
 // Before testing begins, allow up to 60 seconds for app to open
 describe('Switch 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 Switch test page', () => {
+  it('Click and navigate to Switch test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    SwitchPageObject.scrollToComponentButton();
-    SwitchPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await SwitchPageObject.scrollToComponentButton();
+    await SwitchPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToSwitchPage();
-    SwitchPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToSwitchPage();
+    await SwitchPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
-    expect(SwitchPageObject.isPageLoaded()).toBeTruthy(SwitchPageObject.ERRORMESSAGE_PAGELOAD);
-    expect(SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await SwitchPageObject.isPageLoaded()).toBeTruthy(SwitchPageObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });
 describe('Switch Accessibility Testing', () => {
   /* Scrolls and waits for the Switch to be visible on the Test Page */
-  beforeEach(() => {
-    SwitchPageObject.scrollToTestElement();
-    SwitchPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await SwitchPageObject.scrollToTestElement();
+    await SwitchPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
   });
-  it('Switch - Validate accessibilityRole is correct', () => {
-    expect(SwitchPageObject.getAccessibilityRole()).toEqual(BUTTON_A11Y_ROLE);
-    expect(SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
+  it('Switch - Validate accessibilityRole is correct', async () => {
+    await expect(await SwitchPageObject.getAccessibilityRole()).toEqual(BUTTON_A11Y_ROLE);
+    await expect(await SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
   });
-  it('Switch - Set accessibilityLabel', () => {
-    expect(SwitchPageObject.getAccessibilityLabel(ComponentSelector.Primary)).toEqual(SWITCH_ACCESSIBILITY_LABEL);
-    expect(SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
+  it('Switch - Set accessibilityLabel', async () => {
+    await expect(await SwitchPageObject.getAccessibilityLabel(ComponentSelector.Primary)).toEqual(SWITCH_ACCESSIBILITY_LABEL);
+    await expect(await SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
   });
-  it('Switch - Do not set accessibilityLabel -> Default to Switch label', () => {
-    expect(SwitchPageObject.getAccessibilityLabel(ComponentSelector.Secondary)).toEqual(SWITCH_TEST_COMPONENT_LABEL);
-    expect(SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
+  it('Switch - Do not set accessibilityLabel -> Default to Switch label', async () => {
+    await expect(await SwitchPageObject.getAccessibilityLabel(ComponentSelector.Secondary)).toEqual(SWITCH_TEST_COMPONENT_LABEL);
+    await expect(await SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
   });
 });
 describe('Switch Functional Testing', () => {
   /* Scrolls and waits for the Switch to be visible on the Test Page */
-  beforeEach(() => {
-    SwitchPageObject.scrollToTestElement();
-    SwitchPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await SwitchPageObject.scrollToTestElement();
+    await SwitchPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
   });
-  it("Click on a Switch -> Validate it toggles correctly AND calls the user's onChange", () => {
+  it("Click on a Switch -> Validate it toggles correctly AND calls the user's onChange", async () => {
     /* Validate the Switch is initially toggled OFF */
-    expect(SwitchPageObject.isSwitchChecked()).toBeFalsy();
+    await expect(await SwitchPageObject.isSwitchChecked()).toBeFalsy();
     /* Click on the Switch to toggle on */
-    SwitchPageObject.clickComponent();
-    SwitchPageObject.waitForSwitchChecked(PAGE_TIMEOUT);
+    await SwitchPageObject.clickComponent();
+    await SwitchPageObject.waitForSwitchChecked(PAGE_TIMEOUT);
-    expect(SwitchPageObject.didOnChangeCallbackFire()).toBeTruthy();
+    await expect(await SwitchPageObject.didOnChangeCallbackFire()).toBeTruthy();
     /* Validate the Switch is toggled ON */
-    expect(SwitchPageObject.isSwitchChecked()).toBeTruthy();
+    await expect(await SwitchPageObject.isSwitchChecked()).toBeTruthy();
-    SwitchPageObject.clickComponent();
+    await SwitchPageObject.clickComponent();
     /* Validate the Switch is toggled OFF */
-    expect(SwitchPageObject.isSwitchChecked()).toBeFalsy();
-    expect(SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await SwitchPageObject.isSwitchChecked()).toBeFalsy();
+    await expect(await SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
   });
-  it("Click the 'Enter' on a Switch and verify it toggles correctly AND calls the user's onChange", () => {
+  it("Click the 'Enter' on a Switch and verify it toggles correctly AND calls the user's onChange", async () => {
     /* Validate the Switch is initially toggled OFF */
-    expect(SwitchPageObject.isSwitchChecked()).toBeFalsy();
+    await expect(await SwitchPageObject.isSwitchChecked()).toBeFalsy();
     /* Presses the "Enter" to select the Switch */
-    SwitchPageObject.sendKey(SwitchComponentSelector.PrimaryComponent, Keys.Enter);
-    SwitchPageObject.waitForSwitchChecked(PAGE_TIMEOUT);
+    await SwitchPageObject.sendKey(SwitchComponentSelector.PrimaryComponent, Keys.Enter);
+    await SwitchPageObject.waitForSwitchChecked(PAGE_TIMEOUT);
-    expect(SwitchPageObject.didOnChangeCallbackFire()).toBeTruthy();
+    await expect(await SwitchPageObject.didOnChangeCallbackFire()).toBeTruthy();
     /* Validate the Switch is toggled ON */
-    expect(SwitchPageObject.isSwitchChecked()).toBeTruthy();
-    expect(SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await SwitchPageObject.isSwitchChecked()).toBeTruthy();
+    await expect(await SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
-    SwitchPageObject.sendKey(SwitchComponentSelector.PrimaryComponent, Keys.Enter);
+    await SwitchPageObject.sendKey(SwitchComponentSelector.PrimaryComponent, Keys.Enter);
     /* Validate the Switch is toggled OFF */
-    expect(SwitchPageObject.isSwitchChecked()).toBeFalsy();
-    expect(SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await SwitchPageObject.isSwitchChecked()).toBeFalsy();
+    await expect(await SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
   });
-  it("Click the 'Spacebar' on a Switch and verify it toggles correctly AND calls the user's onChange", () => {
+  it("Click the 'Spacebar' on a Switch and verify it toggles correctly AND calls the user's onChange", async () => {
     /* Validate the Switch is initially toggled OFF */
-    expect(SwitchPageObject.isSwitchChecked()).toBeFalsy();
+    await expect(await SwitchPageObject.isSwitchChecked()).toBeFalsy();
     /* Presses the "space bar" to select the Switch */
-    SwitchPageObject.sendKey(SwitchComponentSelector.PrimaryComponent, Keys.Spacebar);
-    SwitchPageObject.waitForSwitchChecked(PAGE_TIMEOUT);
+    await SwitchPageObject.sendKey(SwitchComponentSelector.PrimaryComponent, Keys.Spacebar);
+    await SwitchPageObject.waitForSwitchChecked(PAGE_TIMEOUT);
-    expect(SwitchPageObject.didOnChangeCallbackFire()).toBeTruthy();
+    await expect(await SwitchPageObject.didOnChangeCallbackFire()).toBeTruthy();
     /* Validate the Switch is toggled ON */
-    expect(SwitchPageObject.isSwitchChecked()).toBeTruthy();
-    expect(SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await SwitchPageObject.isSwitchChecked()).toBeTruthy();
+    await expect(await SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
-    SwitchPageObject.sendKey(SwitchComponentSelector.PrimaryComponent, Keys.Spacebar);
+    await SwitchPageObject.sendKey(SwitchComponentSelector.PrimaryComponent, Keys.Spacebar);
     /* Validate the Switch is toggled OFF */
-    expect(SwitchPageObject.isSwitchChecked()).toBeFalsy();
-    expect(SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await SwitchPageObject.isSwitchChecked()).toBeFalsy();
+    await expect(await SwitchPageObject.didAssertPopup()).toBeFalsy(SwitchPageObject.ERRORMESSAGE_ASSERT);
   });
 });

package/src/E2E/Tabs/pages/TabsPageObject.macos.ts CHANGED Viewed

@@ -5,8 +5,8 @@ class TabsPageObject extends BasePage {
   /******************************************************************/
   /**************** UI Element Interaction Methods ******************/
   /******************************************************************/
-  getTabItemAccesibilityRole(): string {
-    return this._tabItem.getAttribute('ControlType');
+  async getTabItemAccesibilityRole(): Promise<string> {
+    return await this._tabItem.getAttribute('ControlType');
   }
   /*****************************************/

package/src/E2E/Tabs/pages/TabsPageObject.win.ts CHANGED Viewed

@@ -25,56 +25,51 @@ class TabsPageObject extends BasePage {
   /******************************************************************/
   /**************** UI Element Interaction Methods ******************/
   /******************************************************************/
-  waitForTabsItemsToOpen(tabItemSelector: TabItemSelector, timeout?: number): void {
-    browser.waitUntil(
-      () => {
-        return this.didTabItemContentLoad(tabItemSelector);
-      },
-      {
-        timeout: timeout ?? this.waitForPageTimeout,
-        timeoutMsg: 'The Tab Items content did not open.',
-        interval: 1000,
-      },
-    );
+  async waitForTabsItemsToOpen(tabItemSelector: TabItemSelector, timeout?: number): Promise<void> {
+    await browser.waitUntil(async () => await this.didTabItemContentLoad(tabItemSelector), {
+      timeout: timeout ?? this.waitForPageTimeout,
+      timeoutMsg: 'The Tab Items content did not open.',
+      interval: 1000,
+    });
   }
-  getTabItemAccesibilityRole(tabItemSelector: TabItemSelector): string {
-    return this.getTabItem(tabItemSelector).getAttribute('ControlType');
+  async getTabItemAccesibilityRole(tabItemSelector: TabItemSelector): Promise<string> {
+    return await (await this.getTabItem(tabItemSelector)).getAttribute('ControlType');
   }
-  clickOnTabItem(tabItemSelector: TabItemSelector): void {
-    this.getTabItem(tabItemSelector).click();
+  async clickOnTabItem(tabItemSelector: TabItemSelector): Promise<void> {
+    await (await this.getTabItem(tabItemSelector)).click();
   }
-  didTabItemContentLoad(tabItemSelector: TabItemSelector): boolean {
-    return this.getTabItemContent(tabItemSelector).isDisplayed();
+  async didTabItemContentLoad(tabItemSelector: TabItemSelector): Promise<boolean> {
+    return await (await this.getTabItemContent(tabItemSelector)).isDisplayed();
   }
   /* Returns the correct WebDriverIO element from the TabItem Selector */
-  getTabItem(tabItemSelector: TabItemSelector): WebdriverIO.Element {
+  async getTabItem(tabItemSelector: TabItemSelector): Promise<WebdriverIO.Element> {
     if (tabItemSelector == TabItemSelector.First) {
-      return this._firstTabItem;
+      return await this._firstTabItem;
     } else if (tabItemSelector == TabItemSelector.Second) {
-      return this._secondTabItem;
+      return await this._secondTabItem;
     } else {
-      return this._thirdTabItem;
+      return await this._thirdTabItem;
     }
   }
   /* Returns the correct WebDriverIO element from the TabItem Selector */
-  getTabItemContent(tabItemSelector: TabItemSelector): WebdriverIO.Element {
+  async getTabItemContent(tabItemSelector: TabItemSelector): Promise<WebdriverIO.Element> {
     if (tabItemSelector == TabItemSelector.First) {
-      return this._firstTabItemContent;
+      return await this._firstTabItemContent;
     } else if (tabItemSelector == TabItemSelector.Second) {
-      return this._secondTabItemContent;
+      return await this._secondTabItemContent;
     } else {
-      return this._thirdTabItemContent;
+      return await this._thirdTabItemContent;
     }
   }
   /* Sends a Keyboarding command on a specific UI element */
-  sendKey(key: string, tabItemSelector: TabItemSelector): void {
-    this.getTabItem(tabItemSelector).addValue(key);
+  async sendKey(key: string, tabItemSelector: TabItemSelector): Promise<void> {
+    await (await this.getTabItem(tabItemSelector)).addValue(key);
   }
   /*****************************************/

package/src/E2E/Tabs/specs/Tabs.spec.macos.ts CHANGED Viewed

@@ -4,20 +4,20 @@ import { BOOT_APP_TIMEOUT, PAGE_TIMEOUT } from '../../common/consts';
 // Before testing begins, allow up to 60 seconds for app to open
 describe('Tabs 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 Tabs test page', () => {
+  it('Click and navigate to Tabs test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    TabsPageObject.scrollToComponentButton();
-    TabsPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await TabsPageObject.scrollToComponentButton();
+    await TabsPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToTabsPage();
-    TabsPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToTabsPage();
+    await TabsPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
-    expect(TabsPageObject.isPageLoaded()).toBeTruthy();
+    await expect(await TabsPageObject.isPageLoaded()).toBeTruthy();
   });
 });

package/src/E2E/Tabs/specs/Tabs.spec.win.ts CHANGED Viewed

@@ -4,85 +4,85 @@ import { TAB_A11Y_ROLE, BOOT_APP_TIMEOUT, PAGE_TIMEOUT, TABITEM_A11Y_ROLE, Keys
 // Before testing begins, allow up to 60 seconds for app to open
 describe('Tabs 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 Tabs test page', () => {
+  it('Click and navigate to Tabs test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    TabsPageObject.scrollToComponentButton();
-    TabsPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await TabsPageObject.scrollToComponentButton();
+    await TabsPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToTabsPage();
-    TabsPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToTabsPage();
+    await TabsPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
-    expect(TabsPageObject.isPageLoaded()).toBeTruthy(TabsPageObject.ERRORMESSAGE_PAGELOAD);
-    expect(TabsPageObject.didAssertPopup()).toBeFalsy(TabsPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
+    await expect(await TabsPageObject.isPageLoaded()).toBeTruthy(TabsPageObject.ERRORMESSAGE_PAGELOAD);
+    await expect(await TabsPageObject.didAssertPopup()).toBeFalsy(TabsPageObject.ERRORMESSAGE_ASSERT); // Ensure no asserts popped up
   });
 });
 describe('Tabs Accessibility Testing', () => {
   /* Scrolls and waits for the Tabs to be visible on the Test Page */
-  beforeEach(() => {
-    TabsPageObject.scrollToTestElement();
-    TabsPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await TabsPageObject.scrollToTestElement();
+    await TabsPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
   });
-  it("Validate Tab's accessibilityRole is correct", () => {
-    expect(TabsPageObject.getAccessibilityRole()).toEqual(TAB_A11Y_ROLE);
-    expect(TabsPageObject.didAssertPopup()).toBeFalsy(TabsPageObject.ERRORMESSAGE_ASSERT);
+  it("Validate Tab's accessibilityRole is correct", async () => {
+    await expect(await TabsPageObject.getAccessibilityRole()).toEqual(TAB_A11Y_ROLE);
+    await expect(await TabsPageObject.didAssertPopup()).toBeFalsy(TabsPageObject.ERRORMESSAGE_ASSERT);
   });
-  it("Validate TabItem's accessibilityRole is correct", () => {
-    expect(TabsPageObject.getTabItemAccesibilityRole(TabItemSelector.First)).toEqual(TABITEM_A11Y_ROLE);
-    expect(TabsPageObject.didAssertPopup()).toBeFalsy(TabsPageObject.ERRORMESSAGE_ASSERT);
+  it("Validate TabItem's accessibilityRole is correct", async () => {
+    await expect(await TabsPageObject.getTabItemAccesibilityRole(TabItemSelector.First)).toEqual(TABITEM_A11Y_ROLE);
+    await expect(await TabsPageObject.didAssertPopup()).toBeFalsy(TabsPageObject.ERRORMESSAGE_ASSERT);
   });
 });
 describe('Tabs Functional Tests', () => {
   /* Scrolls and waits for the Tabs to be visible on the Test Page */
-  beforeEach(() => {
-    TabsPageObject.scrollToTestElement();
-    TabsPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await TabsPageObject.scrollToTestElement();
+    await TabsPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
     // Reset the TabGroup by putting focus on First tab item
-    TabsPageObject.clickOnTabItem(TabItemSelector.First);
+    await TabsPageObject.clickOnTabItem(TabItemSelector.First);
   });
-  it('Click on the second tab header and validate the correct TabItem content is shown', () => {
-    TabsPageObject.clickOnTabItem(TabItemSelector.Second);
-    TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.Second, PAGE_TIMEOUT);
+  it('Click on the second tab header and validate the correct TabItem content is shown', async () => {
+    await TabsPageObject.clickOnTabItem(TabItemSelector.Second);
+    await TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.Second, PAGE_TIMEOUT);
-    expect(TabsPageObject.didTabItemContentLoad(TabItemSelector.Second)).toBeTruthy();
-    expect(TabsPageObject.didAssertPopup()).toBeFalsy(TabsPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await TabsPageObject.didTabItemContentLoad(TabItemSelector.Second)).toBeTruthy();
+    await expect(await TabsPageObject.didAssertPopup()).toBeFalsy(TabsPageObject.ERRORMESSAGE_ASSERT);
   });
-  it('Keyboarding: Arrow Navigation: Right -> Down -> Left -> Up -> Validate the correct TabItem content is shown', () => {
+  it('Keyboarding: Arrow Navigation: Right -> Down -> Left -> Up -> Validate the correct TabItem content is shown', async () => {
     /* At First tab element, press Right Arrow to navigate to the Second tab element */
-    TabsPageObject.sendKey(Keys.Right_Arrow, TabItemSelector.First);
-    TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.Second, PAGE_TIMEOUT);
+    await TabsPageObject.sendKey(Keys.Right_Arrow, TabItemSelector.First);
+    await TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.Second, PAGE_TIMEOUT);
-    expect(TabsPageObject.didTabItemContentLoad(TabItemSelector.Second)).toBeTruthy();
+    await expect(await TabsPageObject.didTabItemContentLoad(TabItemSelector.Second)).toBeTruthy();
     /* At Second tab element, press Down Arrow to navigate to the Third tab element */
-    TabsPageObject.sendKey(Keys.Down_Arrow, TabItemSelector.Second);
-    TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.Third, PAGE_TIMEOUT);
+    await TabsPageObject.sendKey(Keys.Down_Arrow, TabItemSelector.Second);
+    await TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.Third, PAGE_TIMEOUT);
-    expect(TabsPageObject.didTabItemContentLoad(TabItemSelector.Third)).toBeTruthy();
+    await expect(await TabsPageObject.didTabItemContentLoad(TabItemSelector.Third)).toBeTruthy();
     /* At Third tab element, press Left Arrow to navigate to the Second tab element */
-    TabsPageObject.sendKey(Keys.Left_Arrow, TabItemSelector.Third);
-    TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.Second, PAGE_TIMEOUT);
+    await TabsPageObject.sendKey(Keys.Left_Arrow, TabItemSelector.Third);
+    await TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.Second, PAGE_TIMEOUT);
-    expect(TabsPageObject.didTabItemContentLoad(TabItemSelector.Second)).toBeTruthy();
+    await expect(await TabsPageObject.didTabItemContentLoad(TabItemSelector.Second)).toBeTruthy();
     /* At Second tab element, press Up Arrow to navigate to the First tab element */
-    TabsPageObject.sendKey(Keys.Up_Arrow, TabItemSelector.Second);
-    TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.First, PAGE_TIMEOUT);
+    await TabsPageObject.sendKey(Keys.Up_Arrow, TabItemSelector.Second);
+    await TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.First, PAGE_TIMEOUT);
-    expect(TabsPageObject.didTabItemContentLoad(TabItemSelector.First)).toBeTruthy();
-    expect(TabsPageObject.didAssertPopup()).toBeFalsy(TabsPageObject.ERRORMESSAGE_ASSERT);
+    await expect(await TabsPageObject.didTabItemContentLoad(TabItemSelector.First)).toBeTruthy();
+    await expect(await TabsPageObject.didAssertPopup()).toBeFalsy(TabsPageObject.ERRORMESSAGE_ASSERT);
   });
 });

package/src/E2E/Tabs/specs/Tabs.spec.windows.ts CHANGED Viewed

@@ -4,55 +4,55 @@ import { TAB_A11Y_ROLE, BOOT_APP_TIMEOUT, PAGE_TIMEOUT, TABITEM_A11Y_ROLE } from
 // Before testing begins, allow up to 60 seconds for app to open
 describe('Tabs 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 Tabs test page', () => {
+  it('Click and navigate to Tabs test page', async () => {
     /* Scroll to component test page button in scrollview if not already visible*/
-    TabsPageObject.scrollToComponentButton();
-    TabsPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
+    await TabsPageObject.scrollToComponentButton();
+    await TabsPageObject.waitForButtonDisplayed(PAGE_TIMEOUT);
     /* Click on component button to navigate to test page */
-    NavigateAppPage.clickAndGoToTabsPage();
-    TabsPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
+    await NavigateAppPage.clickAndGoToTabsPage();
+    await TabsPageObject.waitForPageDisplayed(PAGE_TIMEOUT);
-    expect(TabsPageObject.isPageLoaded()).toBeTruthy();
+    await expect(await TabsPageObject.isPageLoaded()).toBeTruthy();
   });
 });
 describe('Tabs Accessibility Testing', () => {
   /* Scrolls and waits for the Tabs to be visible on the Test Page */
-  beforeEach(() => {
-    TabsPageObject.scrollToTestElement();
-    TabsPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await TabsPageObject.scrollToTestElement();
+    await TabsPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
   });
-  it("Validate Tab's accessibilityRole is correct", () => {
-    expect(TabsPageObject.getAccessibilityRole()).toEqual(TAB_A11Y_ROLE);
+  it("Validate Tab's accessibilityRole is correct", async () => {
+    await expect(await TabsPageObject.getAccessibilityRole()).toEqual(TAB_A11Y_ROLE);
   });
-  it("Validate TabItem's accessibilityRole is correct", () => {
-    expect(TabsPageObject.getTabItemAccesibilityRole(TabItemSelector.First)).toEqual(TABITEM_A11Y_ROLE);
+  it("Validate TabItem's accessibilityRole is correct", async () => {
+    await expect(await TabsPageObject.getTabItemAccesibilityRole(TabItemSelector.First)).toEqual(TABITEM_A11Y_ROLE);
   });
 });
 describe('Tabs Functional Tests', () => {
   /* Scrolls and waits for the Tabs to be visible on the Test Page */
-  beforeEach(() => {
-    TabsPageObject.scrollToTestElement();
-    TabsPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
+  beforeEach(async () => {
+    await TabsPageObject.scrollToTestElement();
+    await TabsPageObject.waitForPrimaryElementDisplayed(PAGE_TIMEOUT);
     // Reset the TabGroup by putting focus on First tab item
-    TabsPageObject.clickOnTabItem(TabItemSelector.First);
+    await TabsPageObject.clickOnTabItem(TabItemSelector.First);
   });
-  it('Click on the second tab header and validate the correct TabItem content is shown', () => {
-    TabsPageObject.clickOnTabItem(TabItemSelector.Second);
-    TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.Second, PAGE_TIMEOUT);
+  it('Click on the second tab header and validate the correct TabItem content is shown', async () => {
+    await TabsPageObject.clickOnTabItem(TabItemSelector.Second);
+    await TabsPageObject.waitForTabsItemsToOpen(TabItemSelector.Second, PAGE_TIMEOUT);
-    expect(TabsPageObject.didTabItemContentLoad(TabItemSelector.Second)).toBeTruthy();
+    await expect(await TabsPageObject.didTabItemContentLoad(TabItemSelector.Second)).toBeTruthy();
   });
   // Keyboarding is currently not integrated for UWP tabs - Task #5758598

package/src/E2E/TabsExperimental/pages/ExperimentalTabsPageObject.macos.ts CHANGED Viewed

@@ -10,8 +10,8 @@ class ExperimentalTabsPageObject extends BasePage {
   /******************************************************************/
   /**************** UI Element Interaction Methods ******************/
   /******************************************************************/
-  getTabItemAccesibilityRole(): string {
-    return this._tabItem.getAttribute('ControlType');
+  async getTabItemAccesibilityRole(): Promise<string> {
+    return await this._tabItem.getAttribute('ControlType');
   }
   /*****************************************/