@eclipse-che/che-e2e 7.73.0 → 7.74.0-dev-41d1364

package/dist/utils/DriverHelper.js

@@ -18,17 +18,17 @@ const inversify_types_1 = require("../configs/inversify.types");
 const selenium_webdriver_1 = require("selenium-webdriver");
 require("reflect-metadata");
 const Logger_1 = require("./Logger");
-const TimeoutConstants_1 = require("../constants/TimeoutConstants");
+const TIMEOUT_CONSTANTS_1 = require("../constants/TIMEOUT_CONSTANTS");
 let DriverHelper = class DriverHelper {
     constructor(driver) {
         this.driver = driver.get();
     }
     getAction() {
-        Logger_1.Logger.trace('DriverHelper.getAction');
+        Logger_1.Logger.trace();
         return this.driver.actions();
     }
     async isVisible(locator) {
-        Logger_1.Logger.trace(`DriverHelper.isVisible ${locator}`);
+        Logger_1.Logger.trace(`${locator}`);
         try {
             const element = await this.driver.findElement(locator);
             return await element.isDisplayed();
@@ -38,15 +38,15 @@ let DriverHelper = class DriverHelper {
         }
     }
     async wait(milliseconds) {
-        Logger_1.Logger.trace(`DriverHelper.wait (${milliseconds} milliseconds)`);
+        Logger_1.Logger.trace(`(${milliseconds} milliseconds)`);
         await this.driver.sleep(milliseconds);
     }
     async refreshPage() {
-        Logger_1.Logger.trace(`DriverHelper.refreshPage`);
+        Logger_1.Logger.trace();
         await this.driver.navigate().refresh();
     }
-    async waitVisibilityBoolean(locator, attempts = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS, polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING) {
-        Logger_1.Logger.trace(`DriverHelper.waitVisibilityBoolean ${locator}`);
+    async waitVisibilityBoolean(locator, attempts = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_ATTEMPTS, polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING) {
+        Logger_1.Logger.trace(`${locator}`);
         for (let i = 0; i < attempts; i++) {
             const isVisible = await this.isVisible(locator);
             if (isVisible) {
@@ -56,8 +56,8 @@ let DriverHelper = class DriverHelper {
         }
         return false;
     }
-    async waitDisappearanceBoolean(locator, attempts = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS, polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING) {
-        Logger_1.Logger.trace(`DriverHelper.waitDisappearanceBoolean ${locator}`);
+    async waitDisappearanceBoolean(locator, attempts = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_ATTEMPTS, polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING) {
+        Logger_1.Logger.trace(`${locator}`);
         for (let i = 0; i < attempts; i++) {
             const isVisible = await this.isVisible(locator);
             if (!isVisible) {
@@ -67,10 +67,10 @@ let DriverHelper = class DriverHelper {
         }
         return false;
     }
-    async waitVisibility(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitVisibility(elementLocator, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.waitVisibility ${elementLocator}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         for (let i = 0; i < attempts; i++) {
             let element;
             try {
@@ -78,123 +78,122 @@ let DriverHelper = class DriverHelper {
             }
             catch (err) {
                 if (i >= attempts - 1) {
-                    Logger_1.Logger.error(`DriverHelper.waitVisibility - failed with exception, out of attempts - ${err}`);
+                    Logger_1.Logger.error(`failed with exception, out of attempts - ${err}`);
                     throw err;
                 }
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    if (attempts !== 1) { // waitVisibility was spamming other methods when the number of attempts was 1 - only show message if attempts > 1
-                        Logger_1.Logger.trace(`DriverHelper.waitVisibility - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    if (attempts !== 1) {
+                        // waitVisibility was spamming other methods when the number of attempts was 1 - only show message if attempts > 1
+                        Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     }
                     continue;
                 }
-                if (err instanceof selenium_webdriver_1.error.NoSuchWindowError) { // sometimes waitVisibility fails with NoSuchWindowError when the check is run too soon before the page loads
-                    Logger_1.Logger.trace(`DriverHelper.waitVisibility - failed with NoSuchWindow exception. Attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                if (err instanceof selenium_webdriver_1.error.NoSuchWindowError) {
+                    // sometimes waitVisibility fails with NoSuchWindowError when the check is run too soon before the page loads
+                    Logger_1.Logger.trace(`failed with NoSuchWindow exception. Attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitVisibility - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
             try {
                 const visibleWebElement = await this.driver.wait(selenium_webdriver_1.until.elementIsVisible(element), polling);
-                Logger_1.Logger.trace('DriverHelper.waitVisibility - Element is located and is visible.');
+                Logger_1.Logger.trace('element is located and is visible.');
                 return visibleWebElement;
             }
             catch (err) {
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    if (attempts !== 1) { // waitVisibility was spamming other methods when the number of attempts was 1 - only show message if attempts > 1
-                        Logger_1.Logger.trace(`DriverHelper.waitVisibility - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    if (attempts !== 1) {
+                        // waitVisibility was spamming other methods when the number of attempts was 1 - only show message if attempts > 1
+                        Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     }
                     continue;
                 }
                 if (err instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
-                    Logger_1.Logger.debug(`DriverHelper.waitVisibility - Stale element error - ${err}`);
+                    Logger_1.Logger.debug(`stale element error - ${JSON.stringify(err)}`);
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitVisibility - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
-        throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum visibility checkings attempts for '${elementLocator}' element, timeouted after ${timeout}`);
+        throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum visibility checking attempts for '${elementLocator}' element, timeouted after ${timeout}`);
     }
-    async waitPresence(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitPresence(elementLocator, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.waitPresence ${elementLocator}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         for (let i = 0; i < attempts; i++) {
             try {
                 return await this.driver.wait(selenium_webdriver_1.until.elementLocated(elementLocator), polling);
             }
             catch (err) {
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.waitPresence - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
                 if (err instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitPresence - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum presence checking attempts, problems with 'StaleElementReferenceError' of '${elementLocator}' element`);
     }
-    async waitAllPresence(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitAllPresence(elementLocator, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.waitAllPresence ${elementLocator}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         for (let i = 0; i < attempts; i++) {
             try {
                 return await this.driver.wait(selenium_webdriver_1.until.elementsLocated(elementLocator), polling);
             }
             catch (err) {
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.waitAllPresence - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
                 if (err instanceof selenium_webdriver_1.error.StaleElementReferenceError) {
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitAllPresence - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum presence checkings attempts, problems with 'StaleElementReferenceError' of '${elementLocator}' element`);
     }
     async waitAllVisibility(locators, timeout) {
-        Logger_1.Logger.trace(`DriverHelper.waitAllVisibility ${locators}`);
+        Logger_1.Logger.trace(`${locators}`);
         for (const elementLocator of locators) {
             await this.waitVisibility(elementLocator, timeout);
         }
     }
-    async waitDisappearance(elementLocator, attempts = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS, polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING) {
-        Logger_1.Logger.trace(`DriverHelper.waitDisappearance ${elementLocator}`);
+    async waitDisappearance(elementLocator, attempts = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_ATTEMPTS, polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING) {
+        Logger_1.Logger.trace(`${elementLocator}`);
         const isDisappeared = await this.waitDisappearanceBoolean(elementLocator, attempts, polling);
         if (!isDisappeared) {
             throw new selenium_webdriver_1.error.TimeoutError(`Waiting attempts exceeded, element '${elementLocator}' is still visible`);
         }
     }
-    async waitDisappearanceWithTimeout(elementLocator, timeout) {
-        Logger_1.Logger.trace(`DriverHelper.waitDisappearanceWithTimeout ${elementLocator}`);
-        await this.getDriver().wait(async () => {
-            const isVisible = await this.isVisible(elementLocator);
-            if (!isVisible) {
-                return true;
+    async waitAllDisappearance(locators, attemptsPerLocator = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_ATTEMPTS, pollingPerLocator = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING) {
+        Logger_1.Logger.trace(`${locators}`);
+        try {
+            for (const elementLocator of locators) {
+                await this.waitDisappearance(elementLocator, attemptsPerLocator, pollingPerLocator);
             }
-        }, timeout);
-    }
-    async waitAllDisappearance(locators, attemptsPerLocator = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS, pollingPerLocator = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING) {
-        Logger_1.Logger.trace(`DriverHelper.waitAllDisappearance ${locators}`);
-        for (const elementLocator of locators) {
-            await this.waitDisappearance(elementLocator, attemptsPerLocator, pollingPerLocator);
+        }
+        catch (e) {
+            throw e;
         }
     }
-    async waitAndClick(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitAndClick(elementLocator, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.waitAndClick ${elementLocator}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         for (let i = 0; i < attempts; i++) {
             let element;
             try {
@@ -202,14 +201,14 @@ let DriverHelper = class DriverHelper {
             }
             catch (err) {
                 if (i >= attempts - 1) {
-                    Logger_1.Logger.error(`DriverHelper.waitAndClick - failed with exception, out of attempts - ${err}`);
+                    Logger_1.Logger.error(`failed with exception, out of attempts - ${err}`);
                     throw err;
                 }
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.waitAndClick - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitAndClick - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
             try {
@@ -221,12 +220,12 @@ let DriverHelper = class DriverHelper {
                     return err instanceof selenium_webdriver_1.error.ElementClickInterceptedError && i === attempts - 1;
                 }
                 if (err instanceof selenium_webdriver_1.error.StaleElementReferenceError || err instanceof selenium_webdriver_1.error.ElementClickInterceptedError) {
-                    Logger_1.Logger.debug(`DriverHelper.waitAndClick - ${elementLocator} - ${err}`);
+                    Logger_1.Logger.debug(`${elementLocator} - ${JSON.stringify(err)}`);
                     await this.wait(polling);
                     continue;
                 }
                 if (isElementClickInterceptedOnLastAttempt(err, i)) {
-                    Logger_1.Logger.debug(`DriverHelper.waitAndClick - Element is not clickable, try to perform pointer click`);
+                    Logger_1.Logger.debug('element is not clickable, try to perform pointer click');
                     await this.getAction()
                         .move({
                         origin: await this.waitPresence(elementLocator)
@@ -235,16 +234,16 @@ let DriverHelper = class DriverHelper {
                         .perform();
                     return;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitAndClick - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum clicking attempts, the '${elementLocator}' element is not clickable`);
     }
-    async waitAndGetElementAttribute(elementLocator, attribute, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitAndGetElementAttribute(elementLocator, attribute, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.waitAndGetElementAttribute ${elementLocator} attribute: '${attribute}'`);
+        Logger_1.Logger.trace(`${elementLocator} attribute: '${attribute}'`);
         for (let i = 0; i < attempts; i++) {
             let element;
             try {
@@ -252,14 +251,14 @@ let DriverHelper = class DriverHelper {
             }
             catch (err) {
                 if (i >= attempts - 1) {
-                    Logger_1.Logger.error(`DriverHelper.waitAndGetElementAttribute - failed with exception, out of attempts - ${err}`);
+                    Logger_1.Logger.error(`failed with exception, out of attempts - ${err}`);
                     throw err;
                 }
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.waitAndGetElementAttribute - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitAndGetElementAttribute - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
             try {
@@ -270,16 +269,16 @@ let DriverHelper = class DriverHelper {
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitAndGetElementAttribute - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum gettin of the '${attribute}' attribute attempts, from the '${elementLocator}' element`);
     }
-    async waitAndGetCssValue(elementLocator, cssAttribute, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitAndGetCssValue(elementLocator, cssAttribute, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.waitAndGetCssValue ${elementLocator} cssAttribute: ${cssAttribute}`);
+        Logger_1.Logger.trace(`${elementLocator} cssAttribute: ${cssAttribute}`);
         for (let i = 0; i < attempts; i++) {
             let element;
             try {
@@ -287,14 +286,14 @@ let DriverHelper = class DriverHelper {
             }
             catch (err) {
                 if (i >= attempts - 1) {
-                    Logger_1.Logger.error(`DriverHelper.waitAndGetCssValue - failed with exception, out of attempts - ${err}`);
+                    Logger_1.Logger.error(`failed with exception, out of attempts - ${err}`);
                     throw err;
                 }
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.waitAndGetCssValue - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitAndGetCssValue - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
             try {
@@ -305,27 +304,27 @@ let DriverHelper = class DriverHelper {
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitAndGetCssValue - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum gettin of the '${cssAttribute}' css attribute attempts, from the '${elementLocator}' element`);
     }
     async waitAttributeValue(elementLocator, attribute, expectedValue, timeout) {
-        Logger_1.Logger.trace(`DriverHelper.waitAttributeValue ${elementLocator}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         await this.driver.wait(async () => {
             const attributeValue = await this.waitAndGetElementAttribute(elementLocator, attribute, timeout);
             return expectedValue === attributeValue;
         }, timeout, `The '${attribute}' attribute value doesn't match with expected value '${expectedValue}'`);
     }
-    async type(elementLocator, text, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async type(elementLocator, text, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
         if (elementLocator.toString().toLocaleLowerCase().includes('password')) {
-            Logger_1.Logger.trace(`DriverHelper.type ${elementLocator} text: ***`);
+            Logger_1.Logger.trace(`${elementLocator} text: ***`);
         }
         else {
-            Logger_1.Logger.trace(`DriverHelper.type ${elementLocator} text: ${text}`);
+            Logger_1.Logger.trace(`${elementLocator} text: ${text}`);
         }
         for (let i = 0; i < attempts; i++) {
             let element;
@@ -334,14 +333,14 @@ let DriverHelper = class DriverHelper {
             }
             catch (err) {
                 if (i >= attempts - 1) {
-                    Logger_1.Logger.error(`DriverHelper.type - failed with exception, out of attempts - ${err}`);
+                    Logger_1.Logger.error(`failed with exception, out of attempts - ${err}`);
                     throw err;
                 }
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.type - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.type - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
             try {
@@ -353,16 +352,16 @@ let DriverHelper = class DriverHelper {
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.type - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum typing attempts, to the '${elementLocator}' element`);
     }
-    async typeToInvisible(elementLocator, text, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async typeToInvisible(elementLocator, text, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.typeToInvisible ${elementLocator} text: ${text}`);
+        Logger_1.Logger.trace(`${elementLocator} text: ${text}`);
         for (let i = 0; i < attempts; i++) {
             let element;
             try {
@@ -370,14 +369,14 @@ let DriverHelper = class DriverHelper {
             }
             catch (err) {
                 if (i >= attempts - 1) {
-                    Logger_1.Logger.error(`DriverHelper.typeToInvisible - failed with exception, out of attempts - ${err}`);
+                    Logger_1.Logger.error(`failed with exception, out of attempts - ${err}`);
                     throw err;
                 }
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.typeToInvisible - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.typeToInvisible - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
             try {
@@ -389,16 +388,16 @@ let DriverHelper = class DriverHelper {
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.typeToInvisible - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum typing attempts, to the '${elementLocator}' element`);
     }
-    async clear(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async clear(elementLocator, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.clear ${elementLocator}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         for (let i = 0; i < attempts; i++) {
             let element;
             try {
@@ -406,14 +405,14 @@ let DriverHelper = class DriverHelper {
             }
             catch (err) {
                 if (i >= attempts - 1) {
-                    Logger_1.Logger.error(`DriverHelper.clear - failed with exception, out of attempts - ${err}`);
+                    Logger_1.Logger.error(`failed with exception, out of attempts - ${err}`);
                     throw err;
                 }
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.clear - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.clear - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
             try {
@@ -425,16 +424,16 @@ let DriverHelper = class DriverHelper {
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.clear - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum clearing attempts, to the '${elementLocator}' element`);
     }
-    async clearInvisible(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async clearInvisible(elementLocator, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.clearInvisible ${elementLocator}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         for (let i = 0; i < attempts; i++) {
             let element;
             try {
@@ -442,14 +441,14 @@ let DriverHelper = class DriverHelper {
             }
             catch (err) {
                 if (i >= attempts - 1) {
-                    Logger_1.Logger.error(`DriverHelper.clearInvisible - failed with exception, out of attempts - ${err}`);
+                    Logger_1.Logger.error(`failed with exception, out of attempts - ${err}`);
                     throw err;
                 }
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.clearInvisible - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.clearInvisible - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
             try {
@@ -461,18 +460,18 @@ let DriverHelper = class DriverHelper {
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.clearInvisible - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum clearing attempts, to the '${elementLocator}' element`);
     }
-    async enterValue(elementLocator, text, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+    async enterValue(elementLocator, text, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         if (elementLocator.toString().toLocaleLowerCase().includes('password')) {
-            Logger_1.Logger.trace(`DriverHelper.enterValue ${elementLocator} text: ***`);
+            Logger_1.Logger.trace(`${elementLocator} text: ***`);
         }
         else {
-            Logger_1.Logger.trace(`DriverHelper.enterValue ${elementLocator} text: ${text}`);
+            Logger_1.Logger.trace(`${elementLocator} text: ${text}`);
         }
         await this.waitVisibility(elementLocator, timeout);
         await this.clear(elementLocator);
@@ -481,13 +480,13 @@ let DriverHelper = class DriverHelper {
         await this.waitAttributeValue(elementLocator, 'value', text, timeout);
     }
     async waitAndSwitchToFrame(iframeLocator, timeout) {
-        Logger_1.Logger.trace(`DriverHelper.waitAndSwitchToFrame ${iframeLocator}`);
+        Logger_1.Logger.trace(`${iframeLocator}`);
         await this.driver.wait(selenium_webdriver_1.until.ableToSwitchToFrame(iframeLocator), timeout);
     }
-    async waitAndGetText(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitAndGetText(elementLocator, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.waitAndGetText ${elementLocator}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         for (let i = 0; i < attempts; i++) {
             let element;
             try {
@@ -495,14 +494,14 @@ let DriverHelper = class DriverHelper {
             }
             catch (err) {
                 if (i >= attempts - 1) {
-                    Logger_1.Logger.error(`DriverHelper.waitAndGetText - failed with exception, out of attempts - ${err}`);
+                    Logger_1.Logger.error(`failed with exception, out of attempts - ${err}`);
                     throw err;
                 }
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.waitAndGetText - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitAndGetText - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
             try {
@@ -513,24 +512,24 @@ let DriverHelper = class DriverHelper {
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.waitAndGetText - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum text obtaining attempts, from the '${elementLocator}' element`);
     }
     async waitAndGetValue(elementLocator, timeout) {
-        Logger_1.Logger.trace(`DriverHelper.waitAndGetValue ${elementLocator}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         return await this.waitAndGetElementAttribute(elementLocator, 'value', timeout);
     }
     async waitUntilTrue(callback, timeout) {
-        Logger_1.Logger.trace('DriverHelper.waitUntilTrue');
+        Logger_1.Logger.trace();
         await this.driver.wait(callback, timeout);
     }
-    async scrollTo(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
-        const polling = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async scrollTo(elementLocator, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+        const polling = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
         const attempts = Math.ceil(timeout / polling);
-        Logger_1.Logger.trace(`DriverHelper.scrollTo ${elementLocator}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         for (let i = 0; i < attempts; i++) {
             let element;
             try {
@@ -538,19 +537,18 @@ let DriverHelper = class DriverHelper {
             }
             catch (err) {
                 if (i >= attempts - 1) {
-                    Logger_1.Logger.error(`DriverHelper.scrollTo - failed with exception, out of attempts - ${err}`);
+                    Logger_1.Logger.error(`failed with exception, out of attempts - ${err}`);
                     throw err;
                 }
                 if (err instanceof selenium_webdriver_1.error.TimeoutError) {
-                    Logger_1.Logger.trace(`DriverHelper.scrollTo - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
+                    Logger_1.Logger.trace(`polling timed out attempt #${i + 1}, retrying with ${polling}ms timeout`);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.scrollTo - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
             try {
-                await this.getDriver()
-                    .executeScript('arguments[0].scrollIntoView(true);', element);
+                await this.getDriver().executeScript('arguments[0].scrollIntoView(true);', element);
                 return;
             }
             catch (err) {
@@ -558,26 +556,26 @@ let DriverHelper = class DriverHelper {
                     await this.wait(polling);
                     continue;
                 }
-                Logger_1.Logger.error(`DriverHelper.scrollTo - failed with an unexpected exception - ${err}`);
+                Logger_1.Logger.error(`failed with an unexpected exception - ${err}`);
                 throw err;
             }
         }
         throw new selenium_webdriver_1.error.TimeoutError(`Exceeded maximum mouse move attempts, for the '${elementLocator}' element`);
     }
-    async scrollToAndClick(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+    async scrollToAndClick(elementLocator, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         await this.scrollTo(elementLocator, timeout);
         await this.waitAndClick(elementLocator, timeout);
     }
-    async scrollToAndEnterValue(elementLocator, value, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+    async scrollToAndEnterValue(elementLocator, value, timeout = TIMEOUT_CONSTANTS_1.TIMEOUT_CONSTANTS.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         await this.scrollTo(elementLocator, timeout);
         await this.enterValue(elementLocator, value, timeout);
     }
     // method is useful to debug page object elements
     async highLightElement(element) {
-        await this.getDriver().executeScript('arguments[0].style.border=\'2px solid red\'', element);
+        await this.getDriver().executeScript('arguments[0].style.border="2px solid red"', element);
     }
     getDriver() {
-        Logger_1.Logger.trace('DriverHelper.getDriver');
+        Logger_1.Logger.trace();
         return this.driver;
     }
 };