@fluentui-react-native/tester 0.129.6 → 0.129.7

package/lib/E2E/src/common/BasePage.js

@@ -0,0 +1,654 @@
+import { __awaiter, __generator } from "tslib";
+import { ROOT_VIEW, TESTPAGE_CONTENT_SCROLLVIEWER } from './consts';
+import { attributeToEnumName, TESTPAGE_BUTTONS_SCROLLVIEWER } from './consts';
+var DUMMY_CHAR = '';
+// The E2ETEST_PLATFORM environment variable should be set in the beforeSession hook in the wdio.conf file for the respective platform
+var PLATFORM = process.env['E2ETEST_PLATFORM'];
+export var COMPONENT_SCROLL_COORDINATES = { x: -0, y: -100 }; // These are the offsets. Y is negative because we want the touch to move up (and thus it scrolls down)
+var rootView = null;
+/* Win32/UWP-Specific Selector. We use this to get elements on the test page */
+export function By(identifier) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(PLATFORM === 'windows')) return [3 /*break*/, 2];
+                    return [4 /*yield*/, $('~' + identifier)];
+                case 1: 
+                // For some reason, the rootView node is never put into the element tree on the UWP tester. Remove this when fixed.
+                return [2 /*return*/, _a.sent()];
+                case 2: return [4 /*yield*/, QueryWithChaining(identifier)];
+                case 3: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+function QueryWithChaining(identifier) {
+    return __awaiter(this, void 0, void 0, function () {
+        var selector, queryResult;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(rootView === null)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, $('~' + ROOT_VIEW)];
+                case 1:
+                    // Most of the elements we're searching for will be children of this rootView node.
+                    rootView = _a.sent();
+                    _a.label = 2;
+                case 2:
+                    selector = '~' + identifier;
+                    return [4 /*yield*/, rootView.$(selector)];
+                case 3:
+                    queryResult = _a.sent();
+                    if (!queryResult.error) return [3 /*break*/, 5];
+                    return [4 /*yield*/, $(selector)];
+                case 4:
+                    // In some cases, such as opened ContextualMenu items, the element nodes are not children of the rootView node, meaning we need to start our search from the top of the tree.
+                    queryResult = _a.sent();
+                    _a.label = 5;
+                case 5: return [2 /*return*/, queryResult];
+            }
+        });
+    });
+}
+/****************************** IMPORTANT! PLEASE READ! **************************************************
+ * Every component's page object extends this. We can assume each test page will interact with at least
+ * two UI elements, so we'll add integration for two UI elements in this file (See *Getters* section below).
+ * Every additional UI element that a test page wants to interact with should be handled in that respective
+ * component's page object.
+ *********************************************************************************************************/
+var BasePage = /** @class */ (function () {
+    function BasePage() {
+        // Default timeout to wait until page is displayed (10s)
+        this.waitForUiEvent = 25000;
+        if (PLATFORM) {
+            this.platform = PLATFORM;
+        }
+    }
+    /******************************************************************/
+    /**************** UI Element Interaction Methods ******************/
+    /******************************************************************/
+    /**
+     * Checks to see if an element attribute is strictly equal to an expected value the user passes in.
+     * The advantage to this over testing using .isEqual in a spec is that this throws a detailed error if
+     * the expected and actual values don't match. This should be called for attribute tests in specs. */
+    BasePage.prototype.compareAttribute = function (element, attribute, expectedValue) {
+        return __awaiter(this, void 0, void 0, function () {
+            var el, actualValue, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, element];
+                    case 1:
+                        el = _d.sent();
+                        return [4 /*yield*/, el.getAttribute(attribute)];
+                    case 2:
+                        actualValue = _d.sent();
+                        if (!(expectedValue !== actualValue)) return [3 /*break*/, 4];
+                        _a = Error.bind;
+                        _c = (_b = "On ".concat(this._pageName, ", a test component with a testID = '")).concat;
+                        return [4 /*yield*/, el.getAttribute("AutomationId" /* Attribute.TestID */)];
+                    case 3: throw new (_a.apply(Error, [void 0, _c.apply(_b, [_d.sent(), "' should have attribute, "]).concat(attributeToEnumName[attribute], " (which maps to windows attribute '").concat(attribute, "' property on the element), equal to '").concat(expectedValue, "'. Instead, ").concat(attributeToEnumName[attribute], " is equal to '").concat(actualValue, "'.")]))();
+                    case 4: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    BasePage.prototype.getAccessibilityRole = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.getElementAttribute;
+                        return [4 /*yield*/, this._primaryComponent];
+                    case 1: return [4 /*yield*/, _a.apply(this, [_b.sent(), "ControlType" /* Attribute.AccessibilityRole */])];
+                    case 2: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    /* Gets the accessibility label of an UI element given the selector */
+    BasePage.prototype.getAccessibilityLabel = function (componentSelector) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _a = componentSelector;
+                        switch (_a) {
+                            case 'Primary': return [3 /*break*/, 1];
+                            case 'Secondary': return [3 /*break*/, 4];
+                        }
+                        return [3 /*break*/, 7];
+                    case 1:
+                        _b = this.getElementAttribute;
+                        return [4 /*yield*/, this._primaryComponent];
+                    case 2: return [4 /*yield*/, _b.apply(this, [_d.sent(), "Name" /* Attribute.AccessibilityLabel */])];
+                    case 3: return [2 /*return*/, _d.sent()];
+                    case 4:
+                        _c = this.getElementAttribute;
+                        return [4 /*yield*/, this._secondaryComponent];
+                    case 5: return [4 /*yield*/, _c.apply(this, [_d.sent(), "Name" /* Attribute.AccessibilityLabel */])];
+                    case 6: return [2 /*return*/, _d.sent()];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* Returns true if the test page has loaded. To determine if it's loaded, each test page has a specific UI element we attempt to locate.
+     * If this UI element is located, we know the page as loaded correctly. The UI element we look for is a Text component that contains
+     * the title of the page (this._testPage returns that UI element)  */
+    BasePage.prototype.isPageLoaded = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var onPage, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._testPage];
+                    case 1: return [4 /*yield*/, (_b.sent()).isDisplayed()];
+                    case 2:
+                        _a = (_b.sent());
+                        if (_a) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this._primaryComponent];
+                    case 3: return [4 /*yield*/, (_b.sent()).isDisplayed()];
+                    case 4:
+                        _a = (_b.sent());
+                        _b.label = 5;
+                    case 5:
+                        onPage = _a;
+                        return [2 /*return*/, onPage];
+                }
+            });
+        });
+    };
+    /* Returns true if the test page's button is displayed (the button that navigates to each test page) */
+    BasePage.prototype.isButtonInView = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._pageButton];
+                    case 1: return [4 /*yield*/, (_a.sent()).isDisplayed()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    BasePage.prototype.clickComponent = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._primaryComponent];
+                    case 1: return [4 /*yield*/, (_a.sent()).click()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* The goal of click() and sendKeys() is to be generally used across all pageobjects to reduce code repetition in similar methods. */
+    BasePage.prototype.click = function (element) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, element];
+                    case 1: return [4 /*yield*/, (_a.sent()).click()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BasePage.prototype.sendKeys = function (element, keys) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, element];
+                    case 1: return [4 /*yield*/, (_a.sent()).addValue(keys)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BasePage.prototype.getElementAttribute = function (element, attribute) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, element.getAttribute(attribute)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /* Scrolls until the desired test page's button is displayed. We use the scroll viewer UI element as the point to start scrolling.
+     * We use a negative number as the Y-coordinate because that enables us to scroll downwards */
+    BasePage.prototype.mobileScrollToComponentButton = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var errorMsg, _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._pageButton];
+                    case 1: return [4 /*yield*/, (_b.sent()).isDisplayed()];
+                    case 2:
+                        if (_b.sent()) {
+                            return [2 /*return*/];
+                        }
+                        errorMsg = 'Could not scroll to the ' + this._pageName + "'s Button. Please see Pipeline artifacts for more debugging information.";
+                        _a = this.platform;
+                        switch (_a) {
+                            case 'ios': return [3 /*break*/, 3];
+                            case 'android': return [3 /*break*/, 5];
+                        }
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, browser.waitUntil(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, driver.execute('mobile: scroll', { direction: 'down' })];
+                                    case 1:
+                                        _a.sent();
+                                        return [4 /*yield*/, this._pageButton];
+                                    case 2: return [4 /*yield*/, (_a.sent()).isDisplayed()];
+                                    case 3: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); }, {
+                            timeout: this.waitForUiEvent,
+                            timeoutMsg: errorMsg,
+                        })];
+                    case 4:
+                        _b.sent();
+                        return [3 /*break*/, 7];
+                    case 5: 
+                    /* 'mobile: scroll' which is used for iOS, does not support direction option on Android.
+                     * Instead, we use the UiScrollable class to scroll down to the desired view based on its 'description' (accessibilityLabel).
+                     * The first selector tells which container to scroll in, and the other selector tells which component to scroll to. */
+                    return [4 /*yield*/, browser.waitUntil(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var buttonElementSelector, pageButton;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        buttonElementSelector = "new UiScrollable(new UiSelector().description(\"".concat(TESTPAGE_BUTTONS_SCROLLVIEWER, "\").scrollable(true)).setMaxSearchSwipes(10).setAsVerticalList().scrollIntoView(new UiSelector().description(\"").concat(this._pageButtonName, "\"))");
+                                        return [4 /*yield*/, $("android=".concat(buttonElementSelector))];
+                                    case 1:
+                                        pageButton = _a.sent();
+                                        return [4 /*yield*/, pageButton.isDisplayed()];
+                                    case 2: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); }, {
+                            timeout: this.waitForUiEvent,
+                            timeoutMsg: errorMsg,
+                        })];
+                    case 6:
+                        /* 'mobile: scroll' which is used for iOS, does not support direction option on Android.
+                         * Instead, we use the UiScrollable class to scroll down to the desired view based on its 'description' (accessibilityLabel).
+                         * The first selector tells which container to scroll in, and the other selector tells which component to scroll to. */
+                        _b.sent();
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* Waits for the test page to load. If the test page doesn't load before the timeout, it causes the test to fail. */
+    BasePage.prototype.waitForPageDisplayed = function (timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, browser.waitUntil(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, this.isPageLoaded()];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        }); }); }, {
+                            timeout: timeout !== null && timeout !== void 0 ? timeout : this.waitForUiEvent,
+                            timeoutMsg: this._pageName + ' did not render correctly. Please see /errorShots for more information.',
+                            interval: 1500,
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* Waits for the test page's button to be displayed. If the button doesn't load before the timeout, it causes the test to fail. */
+    BasePage.prototype.waitForButtonDisplayed = function (timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, browser.waitUntil(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, this.isButtonInView()];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        }); }); }, {
+                            timeout: timeout !== null && timeout !== void 0 ? timeout : this.waitForUiEvent,
+                            timeoutMsg: 'Could not find the button to navigate to ' + this._pageName + '. Please see /errorShots for more information.',
+                            interval: 1500,
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* @deprecated, only use `scrollToTestElement()` instead */
+    BasePage.prototype.waitForPrimaryElementDisplayed = function (timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.warn('`waitForPrimaryElementDisplayed` is deprecated. Only use `scrollToTestElement` in your spec to improve performance.');
+                        return [4 /*yield*/, browser.waitUntil(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this._primaryComponent];
+                                    case 1: return [4 /*yield*/, (_a.sent()).isDisplayed()];
+                                    case 2: return [2 /*return*/, _a.sent()];
+                                }
+                            }); }); }, {
+                                timeout: timeout !== null && timeout !== void 0 ? timeout : this.waitForUiEvent,
+                                timeoutMsg: 'The UI element for testing did not display correctly. Please see /errorShots of the first failed test for more information.',
+                                interval: 1500,
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* Scrolls to the specified or primary UI test element until it is displayed. */
+    BasePage.prototype.scrollToTestElement = function (component) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ComponentToScrollTo, _a, FocusButton, scrollDownKeys;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(component !== null && component !== void 0)) return [3 /*break*/, 1];
+                        _a = component;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this._primaryComponent];
+                    case 2:
+                        _a = (_b.sent());
+                        _b.label = 3;
+                    case 3:
+                        ComponentToScrollTo = _a;
+                        return [4 /*yield*/, ComponentToScrollTo.isDisplayed()];
+                    case 4:
+                        if (_b.sent()) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, By('Focus_Button')];
+                    case 5:
+                        FocusButton = _b.sent();
+                        scrollDownKeys = ["\uE00F" /* Keys.PAGE_DOWN */];
+                        return [4 /*yield*/, browser.waitUntil(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, FocusButton.addValue(scrollDownKeys)];
+                                        case 1:
+                                            _a.sent();
+                                            scrollDownKeys.push("\uE00F" /* Keys.PAGE_DOWN */);
+                                            return [4 /*yield*/, ComponentToScrollTo.isDisplayed()];
+                                        case 2: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                timeout: 30000,
+                                timeoutMsg: 'Could not scroll to the ' +
+                                    this._pageName +
+                                    "'s main test element. Please see Pipeline artifacts for more debugging information.",
+                            })];
+                    case 6:
+                        _b.sent();
+                        // We have this extra scroll here to ensure the whole component is visible.
+                        return [4 /*yield*/, FocusButton.addValue(scrollDownKeys)];
+                    case 7:
+                        // We have this extra scroll here to ensure the whole component is visible.
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* Scrolls to the specified or primary UI test element until it is displayed. */
+    BasePage.prototype.mobileScrollToTestElement = function (componentIdentifier) {
+        return __awaiter(this, void 0, void 0, function () {
+            var componentToScrollTo, errorMsg, _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        componentToScrollTo = componentIdentifier !== null && componentIdentifier !== void 0 ? componentIdentifier : this._primaryComponentName;
+                        return [4 /*yield*/, By(componentToScrollTo)];
+                    case 1: return [4 /*yield*/, (_b.sent()).isDisplayed()];
+                    case 2:
+                        if (_b.sent()) {
+                            return [2 /*return*/];
+                        }
+                        errorMsg = 'Could not scroll to the ' + componentToScrollTo + '. Please see Pipeline artifacts for more debugging information.';
+                        _a = this.platform;
+                        switch (_a) {
+                            case 'ios': return [3 /*break*/, 3];
+                            case 'android': return [3 /*break*/, 5];
+                        }
+                        return [3 /*break*/, 7];
+                    case 3: return [4 /*yield*/, browser.waitUntil(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, driver.execute('mobile: scroll', { direction: 'down' })];
+                                    case 1:
+                                        _a.sent();
+                                        return [4 /*yield*/, By(componentToScrollTo)];
+                                    case 2: return [4 /*yield*/, (_a.sent()).isDisplayed()];
+                                    case 3: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); }, {
+                            timeout: this.waitForUiEvent,
+                            timeoutMsg: errorMsg,
+                        })];
+                    case 4:
+                        _b.sent();
+                        return [3 /*break*/, 7];
+                    case 5: 
+                    /* 'mobile: scroll' which is used for iOS, does not support direction option on Android.
+                     * Instead, we use the UiScrollable class to scroll down to the desired view based on its 'description' (accessibilityLabel).
+                     * The first selector tells which container to scroll in, and the other selector tells which component to scroll to. */
+                    return [4 /*yield*/, browser.waitUntil(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var componentSelector, component;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        componentSelector = "new UiScrollable(new UiSelector().description(\"".concat(TESTPAGE_CONTENT_SCROLLVIEWER, "\").scrollable(true)).setMaxSearchSwipes(10).scrollIntoView(new UiSelector().description(\"").concat(componentIdentifier, "\"))");
+                                        return [4 /*yield*/, $("android=".concat(componentSelector))];
+                                    case 1:
+                                        component = _a.sent();
+                                        return [4 /*yield*/, component.isDisplayed()];
+                                    case 2: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); }, {
+                            timeout: this.waitForUiEvent,
+                            timeoutMsg: errorMsg,
+                        })];
+                    case 6:
+                        /* 'mobile: scroll' which is used for iOS, does not support direction option on Android.
+                         * Instead, we use the UiScrollable class to scroll down to the desired view based on its 'description' (accessibilityLabel).
+                         * The first selector tells which container to scroll in, and the other selector tells which component to scroll to. */
+                        _b.sent();
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* A method that allows the caller to pass in a condition. A wrapper for waitUntil(). Once testing becomes more extensive,
+     * this will allow cleaner code within all the Page Objects. */
+    BasePage.prototype.waitForCondition = function (condition, errorMsg, timeout, interval) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, browser.waitUntil(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, condition()];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        }); }); }, {
+                            timeout: timeout !== null && timeout !== void 0 ? timeout : this.waitForUiEvent,
+                            timeoutMsg: errorMsg !== null && errorMsg !== void 0 ? errorMsg : 'Error. Please see /errorShots and logs for more information.',
+                            interval: interval !== null && interval !== void 0 ? interval : 1000,
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* FUNCTIONALITY: Determines if an Assert has fired. True if yes; false otherwise
+     *
+     * WHY/HOW: Unfortunately, some Asserts don't take focus away from the test app. Because of this, the test execution is able
+     * to continue without realizing an assert as popped up (unless the assert is a crashing one).
+     *
+     * In order to detect an assert, this function gets the number of window handles currently open within the test app.
+     * Only one instance SHOULD be open at a time (the app itself). If another instance of the app is open, we know an assert dialogue
+     * has popped up. With this information, we know to fail the test.
+     *
+     * Additionally, you might think it's logical to simply place this in the afterEach() hook so it's called after every test (rather than duplicating this call in every test).
+     * Unfortunately, afterEach() is designed for setup/teardown - not for determining if a test should fail or not.
+     * */
+    BasePage.prototype.didAssertPopup = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var windowHandles;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(PLATFORM === 'android')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.isPageLoaded()];
+                    case 1: return [2 /*return*/, !(_a.sent())];
+                    case 2: return [4 /*yield*/, browser.getWindowHandles()];
+                    case 3:
+                        windowHandles = _a.sent();
+                        return [2 /*return*/, windowHandles.length > 1];
+                }
+            });
+        });
+    };
+    Object.defineProperty(BasePage.prototype, "_testPage", {
+        /*****************************************/
+        /**************** Getters ****************/
+        /*****************************************/
+        /*  IMPORTANT:
+         *  Each PageObject class that extends this class is expected to override these values.
+         *  This is necessary because each page will have different IDs for their respective UI elements.
+         *  DUMMY_CHAR is just a placeholder.
+         */
+        // Returns: UI Element
+        // The Text component on each test page containing the title of that page. We can use this to determine if a test page has loaded correctly.
+        get: function () {
+            return By(this._pageName);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePage.prototype, "_primaryComponent", {
+        // Returns: UI Element
+        // The primary UI element used for testing on the given test page.
+        get: function () {
+            return By(this._primaryComponentName);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePage.prototype, "_secondaryComponent", {
+        // Returns: UI Element
+        // The secondary UI element used for testing on the given test page. Often times, we'll want to set a
+        // prop on one component, and not set it on another to verify certain behaviors. This is why we have this secondary component.
+        get: function () {
+            return By(this._secondaryComponentName);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePage.prototype, "_pageButton", {
+        // Returns: UI Element
+        // The button that navigates you to the component's test page.
+        get: function () {
+            return By(this._pageButtonName);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePage.prototype, "_primaryComponentName", {
+        // Returns: String
+        // Returns the identifier of the primary UI element used for testing on the given test page.
+        get: function () {
+            console.warn('Please verify whether or not your page object should implement _primaryComponentName.');
+            return DUMMY_CHAR;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePage.prototype, "_secondaryComponentName", {
+        // Returns: String
+        // Returns the identifier of the secondary UI element used for testing on the given test page. Often times, we'll want to set a
+        // prop on one component, and not set it on another to verify certain behaviors. This is why we have this secondary component.
+        get: function () {
+            console.warn('Please verify whether or not your page object should implement _secondaryComponentName.');
+            return DUMMY_CHAR;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePage.prototype, "_testPageButtonScrollViewer", {
+        // The scrollviewer containing the list of buttons to navigate to each test page
+        get: function () {
+            return By(TESTPAGE_BUTTONS_SCROLLVIEWER);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePage.prototype, "ERRORMESSAGE_SUFFIX", {
+        /****************** Error Messages ******************/
+        get: function () {
+            return 'Please review logs and error screenshots for more information.';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePage.prototype, "ERRORMESSAGE_APPLOAD", {
+        get: function () {
+            return 'The FluentTester app did not load correctly. ' + this.ERRORMESSAGE_SUFFIX;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePage.prototype, "ERRORMESSAGE_PAGELOAD", {
+        get: function () {
+            return 'The ' + this._pageName + ' test page did not load correctly. ' + this.ERRORMESSAGE_SUFFIX;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePage.prototype, "ERRORMESSAGE_ASSERT", {
+        get: function () {
+            return 'An assert popped up. ' + this.ERRORMESSAGE_SUFFIX;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BasePage;
+}());
+export { BasePage };
+//# sourceMappingURL=BasePage.js.map