@eclipse-che/che-e2e 7.73.0 → 7.74.0-dev-1d09cb7

package/dist/utils/DriverHelper.js

@@ -24,11 +24,11 @@ let DriverHelper = class DriverHelper {
         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}`);
+        Logger_1.Logger.trace(`${locator}`);
         for (let i = 0; i < attempts; i++) {
             const isVisible = await this.isVisible(locator);
             if (isVisible) {
@@ -57,7 +57,7 @@ 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}`);
+        Logger_1.Logger.trace(`${locator}`);
         for (let i = 0; i < attempts; i++) {
             const isVisible = await this.isVisible(locator);
             if (!isVisible) {
@@ -70,7 +70,7 @@ let DriverHelper = class DriverHelper {
     async waitVisibility(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         const polling = TimeoutConstants_1.TimeoutConstants.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,63 +78,63 @@ 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`);
+                        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`);
+                    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`);
+                        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 - ${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;
         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;
             }
         }
@@ -143,41 +143,41 @@ let DriverHelper = class DriverHelper {
     async waitAllPresence(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         const polling = TimeoutConstants_1.TimeoutConstants.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}`);
+        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}`);
+        Logger_1.Logger.trace(`${elementLocator}`);
         await this.getDriver().wait(async () => {
             const isVisible = await this.isVisible(elementLocator);
             if (!isVisible) {
@@ -186,7 +186,7 @@ let DriverHelper = class DriverHelper {
         }, 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}`);
+        Logger_1.Logger.trace(`${locators}`);
         for (const elementLocator of locators) {
             await this.waitDisappearance(elementLocator, attemptsPerLocator, pollingPerLocator);
         }
@@ -194,7 +194,7 @@ let DriverHelper = class DriverHelper {
     async waitAndClick(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         const polling = TimeoutConstants_1.TimeoutConstants.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 +202,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 +221,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} - ${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,7 +235,7 @@ 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;
             }
         }
@@ -244,7 +244,7 @@ let DriverHelper = class DriverHelper {
     async waitAndGetElementAttribute(elementLocator, attribute, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         const polling = TimeoutConstants_1.TimeoutConstants.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 +252,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,7 +270,7 @@ 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;
             }
         }
@@ -279,7 +279,7 @@ let DriverHelper = class DriverHelper {
     async waitAndGetCssValue(elementLocator, cssAttribute, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         const polling = TimeoutConstants_1.TimeoutConstants.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 +287,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,14 +305,14 @@ 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;
@@ -322,10 +322,10 @@ let DriverHelper = class DriverHelper {
         const polling = TimeoutConstants_1.TimeoutConstants.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 +334,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,7 +353,7 @@ 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;
             }
         }
@@ -362,7 +362,7 @@ let DriverHelper = class DriverHelper {
     async typeToInvisible(elementLocator, text, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         const polling = TimeoutConstants_1.TimeoutConstants.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 +370,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,7 +389,7 @@ 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;
             }
         }
@@ -398,7 +398,7 @@ let DriverHelper = class DriverHelper {
     async clear(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         const polling = TimeoutConstants_1.TimeoutConstants.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 +406,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,7 +425,7 @@ 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;
             }
         }
@@ -434,7 +434,7 @@ let DriverHelper = class DriverHelper {
     async clearInvisible(elementLocator, timeout = TimeoutConstants_1.TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         const polling = TimeoutConstants_1.TimeoutConstants.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 +442,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,7 +461,7 @@ 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;
             }
         }
@@ -469,10 +469,10 @@ let DriverHelper = class DriverHelper {
     }
     async enterValue(elementLocator, text, timeout = TimeoutConstants_1.TimeoutConstants.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 +481,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;
         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 +495,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 +513,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;
         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,14 +538,14 @@ 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 {
@@ -558,7 +558,7 @@ 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;
             }
         }
@@ -577,7 +577,7 @@ let DriverHelper = class DriverHelper {
         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;
     }
 };