diff --git a/src/main/java/aquality/selenium/core/application/AqualityModule.java b/src/main/java/aquality/selenium/core/application/AqualityModule.java index 91a5e18..2e44633 100644 --- a/src/main/java/aquality/selenium/core/application/AqualityModule.java +++ b/src/main/java/aquality/selenium/core/application/AqualityModule.java @@ -3,8 +3,10 @@ import aquality.selenium.core.logging.Logger; import aquality.selenium.core.utilities.ISettingsFile; import aquality.selenium.core.utilities.JsonSettingsFile; +import aquality.selenium.core.configurations.*; import com.google.inject.AbstractModule; import com.google.inject.Provider; +import com.google.inject.Singleton; /** * Describes all dependencies which is registered for the project. @@ -25,6 +27,10 @@ protected void configure() { bind(IApplication.class).toProvider(applicationProvider); bind(ISettingsFile.class).toInstance(getSettings()); bind(Logger.class).toInstance(Logger.getInstance()); + bind(ILoggerConfiguration.class).to(LoggerConfiguration.class).in(Singleton.class); + bind(ITimeoutConfiguration.class).to(TimeoutConfiguration.class).in(Singleton.class); + bind(IRetryConfiguration.class).to(RetryConfiguration.class).in(Singleton.class); + bind(IElementCacheConfiguration.class).to(ElementCacheConfiguration.class).in(Singleton.class); } /** diff --git a/src/main/java/aquality/selenium/core/configurations/ElementCacheConfiguration.java b/src/main/java/aquality/selenium/core/configurations/ElementCacheConfiguration.java new file mode 100644 index 0000000..1e9a160 --- /dev/null +++ b/src/main/java/aquality/selenium/core/configurations/ElementCacheConfiguration.java @@ -0,0 +1,20 @@ +package aquality.selenium.core.configurations; + +import aquality.selenium.core.utilities.ISettingsFile; +import com.google.inject.Inject; + +public class ElementCacheConfiguration implements IElementCacheConfiguration{ + + private static final String IS_ENABLED_PATH = "/elementCache/isEnabled"; + private boolean isEnabled; + + @Inject + public ElementCacheConfiguration(ISettingsFile settingsFile){ + isEnabled = settingsFile.isValuePresent(IS_ENABLED_PATH) && Boolean.valueOf(settingsFile.getValue(IS_ENABLED_PATH).toString()); + } + + @Override + public boolean isEnabled() { + return isEnabled; + } +} diff --git a/src/main/java/aquality/selenium/core/configurations/IElementCacheConfiguration.java b/src/main/java/aquality/selenium/core/configurations/IElementCacheConfiguration.java new file mode 100644 index 0000000..93c16f4 --- /dev/null +++ b/src/main/java/aquality/selenium/core/configurations/IElementCacheConfiguration.java @@ -0,0 +1,12 @@ +package aquality.selenium.core.configurations; + +/** + * Provides element's cache configuration. + */ +public interface IElementCacheConfiguration { + + /** + * @return Is element caching allowed or not. + */ + boolean isEnabled(); +} diff --git a/src/main/java/aquality/selenium/core/configurations/ILoggerConfiguration.java b/src/main/java/aquality/selenium/core/configurations/ILoggerConfiguration.java new file mode 100644 index 0000000..99af3c8 --- /dev/null +++ b/src/main/java/aquality/selenium/core/configurations/ILoggerConfiguration.java @@ -0,0 +1,13 @@ +package aquality.selenium.core.configurations; + +/** + * Describes logger configuration. + */ +public interface ILoggerConfiguration { + + /** + * Gets language used inside the library for logging. + * @return language used for logging. + */ + String getLanguage(); +} diff --git a/src/main/java/aquality/selenium/core/configurations/IRetryConfiguration.java b/src/main/java/aquality/selenium/core/configurations/IRetryConfiguration.java new file mode 100644 index 0000000..e6d9ca3 --- /dev/null +++ b/src/main/java/aquality/selenium/core/configurations/IRetryConfiguration.java @@ -0,0 +1,21 @@ +package aquality.selenium.core.configurations; + +/** + * Describes retry configuration. + */ +public interface IRetryConfiguration { + + /** + * Gets the number of attempts during retry. + * + * @return Number of retry attempts. + */ + int getNumber(); + + /** + * Gets the polling interval used in retry. + * + * @return Polling interval for retry. + */ + long getPollingInterval(); +} diff --git a/src/main/java/aquality/selenium/core/configurations/ITimeoutConfiguration.java b/src/main/java/aquality/selenium/core/configurations/ITimeoutConfiguration.java new file mode 100644 index 0000000..bfc69c5 --- /dev/null +++ b/src/main/java/aquality/selenium/core/configurations/ITimeoutConfiguration.java @@ -0,0 +1,35 @@ +package aquality.selenium.core.configurations; + +/** + * Provides timeouts configuration. + */ +public interface ITimeoutConfiguration { + + /** + * Gets WedDriver ImplicitWait timeout. + * + * @return ImplicitWait timeout. + */ + long getImplicit(); + + /** + * Gets default ConditionalWait timeout. + * + * @return ConditionalWait timeout. + */ + long getCondition(); + + /** + * Gets ConditionalWait polling interval. + * + * @return polling interval. + */ + long getPollingInterval(); + + /** + * Gets Command timeout. + * + * @return Command timeout. + */ + long getCommand(); +} diff --git a/src/main/java/aquality/selenium/core/configurations/LoggerConfiguration.java b/src/main/java/aquality/selenium/core/configurations/LoggerConfiguration.java new file mode 100644 index 0000000..cb09a51 --- /dev/null +++ b/src/main/java/aquality/selenium/core/configurations/LoggerConfiguration.java @@ -0,0 +1,20 @@ +package aquality.selenium.core.configurations; + +import aquality.selenium.core.utilities.ISettingsFile; +import com.google.inject.Inject; + +public class LoggerConfiguration implements ILoggerConfiguration { + + private static final String DEFAULT_LANGUAGE = "en"; + private final ISettingsFile settingsFile; + + @Inject + public LoggerConfiguration(ISettingsFile settingsFile){ + this.settingsFile = settingsFile; + } + + @Override + public String getLanguage() { + return settingsFile.getValueOrDefault("/logger/language", DEFAULT_LANGUAGE).toString(); + } +} diff --git a/src/main/java/aquality/selenium/core/configurations/RetryConfiguration.java b/src/main/java/aquality/selenium/core/configurations/RetryConfiguration.java new file mode 100644 index 0000000..4121510 --- /dev/null +++ b/src/main/java/aquality/selenium/core/configurations/RetryConfiguration.java @@ -0,0 +1,25 @@ +package aquality.selenium.core.configurations; + +import aquality.selenium.core.utilities.ISettingsFile; +import com.google.inject.Inject; + +public class RetryConfiguration implements IRetryConfiguration { + private final int number; + private final long pollingInterval; + + @Inject + public RetryConfiguration(ISettingsFile settingsFile) { + this.number = Integer.parseInt(settingsFile.getValue("/retry/number").toString()); + this.pollingInterval = Long.parseLong(settingsFile.getValue("/retry/pollingInterval").toString()); + } + + @Override + public int getNumber() { + return number; + } + + @Override + public long getPollingInterval() { + return pollingInterval; + } +} diff --git a/src/main/java/aquality/selenium/core/configurations/TimeoutConfiguration.java b/src/main/java/aquality/selenium/core/configurations/TimeoutConfiguration.java new file mode 100644 index 0000000..b5d8cd9 --- /dev/null +++ b/src/main/java/aquality/selenium/core/configurations/TimeoutConfiguration.java @@ -0,0 +1,58 @@ +package aquality.selenium.core.configurations; + +import aquality.selenium.core.utilities.ISettingsFile; +import com.google.inject.Inject; + +public class TimeoutConfiguration implements ITimeoutConfiguration{ + + private final ISettingsFile settingsFile; + private final long condition; + private final long pollInterval; + private final long implicit; + private final long command; + + @Inject + public TimeoutConfiguration(ISettingsFile settingsFile) { + this.settingsFile = settingsFile; + condition = getTimeout(TIMEOUT.CONDITION); + pollInterval = getTimeout(TIMEOUT.POLL_INTERVAL); + implicit = getTimeout(TIMEOUT.IMPLICIT); + command = getTimeout(TIMEOUT.COMMAND); + } + + private long getTimeout(TIMEOUT timeout){ + return Long.valueOf(settingsFile.getValue(timeout.getKey()).toString()); + } + + public long getImplicit(){ + return implicit; + } + + public long getCondition(){ + return condition; + } + + public long getPollingInterval(){ + return pollInterval; + } + + public long getCommand(){ + return command; + } + + private enum TIMEOUT { + IMPLICIT("/timeouts/timeoutImplicit"), + CONDITION("/timeouts/timeoutCondition"), + POLL_INTERVAL("/timeouts/timeoutPollingInterval"), + COMMAND("/timeouts/timeoutCommand"); + + private String key; + TIMEOUT(String key){ + this.key = key; + } + + private String getKey(){ + return key; + } + } +} diff --git a/src/main/java/aquality/selenium/core/utilities/ISettingsFile.java b/src/main/java/aquality/selenium/core/utilities/ISettingsFile.java index a67987b..590e270 100644 --- a/src/main/java/aquality/selenium/core/utilities/ISettingsFile.java +++ b/src/main/java/aquality/selenium/core/utilities/ISettingsFile.java @@ -39,4 +39,15 @@ public interface ISettingsFile { * @return True if exists, false otherwise. */ boolean isValuePresent(String path); + + /** + * Gets value from settings file or default value. + * + * @param path Path to the values. Depending on file format, it can be jsonPath, xpath etc. + * @param defaultValue will be returned if there is no value by path in settings file. + * @return Value from settings file or default value. + */ + default Object getValueOrDefault(String path, Object defaultValue) { + return this.isValuePresent(path) ? this.getValue(path) : defaultValue; + } } diff --git a/src/main/resources/settings.json b/src/main/resources/settings.json index 2c63c08..cc2e51d 100644 --- a/src/main/resources/settings.json +++ b/src/main/resources/settings.json @@ -1,2 +1,18 @@ { + "timeouts": { + "timeoutImplicit": 0, + "timeoutCondition": 30, + "timeoutPollingInterval": 300, + "timeoutCommand": 60 + }, + "retry": { + "number": 2, + "pollingInterval": 300 + }, + "logger": { + "language": "en" + }, + "elementCache": { + "isEnabled": false + } } diff --git a/src/test/java/tests/configurations/BaseProfileTest.java b/src/test/java/tests/configurations/BaseProfileTest.java new file mode 100644 index 0000000..6ecb378 --- /dev/null +++ b/src/test/java/tests/configurations/BaseProfileTest.java @@ -0,0 +1,24 @@ +package tests.configurations; + +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; + +public class BaseProfileTest { + + protected static final String PROFILE_KEY = "profile"; + private String previousProfile; + + @BeforeMethod + public void saveProfile() { + previousProfile = System.getProperty(PROFILE_KEY); + } + + @AfterMethod + public void restoreProfile() { + if (previousProfile == null) { + System.clearProperty(PROFILE_KEY); + } else { + System.setProperty(PROFILE_KEY, previousProfile); + } + } +} diff --git a/src/test/java/tests/configurations/ElementCacheConfigurationTests.java b/src/test/java/tests/configurations/ElementCacheConfigurationTests.java new file mode 100644 index 0000000..f5735bd --- /dev/null +++ b/src/test/java/tests/configurations/ElementCacheConfigurationTests.java @@ -0,0 +1,16 @@ +package tests.configurations; + +import aquality.selenium.core.configurations.IElementCacheConfiguration; +import org.testng.annotations.Test; +import tests.application.CustomAqualityServices; + +import static org.testng.Assert.assertFalse; + +public class ElementCacheConfigurationTests { + + @Test + public void testShouldBePossibleCheckIsEnableElementCache() { + boolean isEnable = CustomAqualityServices.getServiceProvider().getInstance(IElementCacheConfiguration.class).isEnabled(); + assertFalse(isEnable, "Element cache is disabled by default"); + } +} diff --git a/src/test/java/tests/configurations/EnvConfigurationTests.java b/src/test/java/tests/configurations/EnvConfigurationTests.java new file mode 100644 index 0000000..5f3d9e8 --- /dev/null +++ b/src/test/java/tests/configurations/EnvConfigurationTests.java @@ -0,0 +1,100 @@ +package tests.configurations; + +import aquality.selenium.core.application.AqualityModule; +import aquality.selenium.core.configurations.IElementCacheConfiguration; +import aquality.selenium.core.configurations.ILoggerConfiguration; +import aquality.selenium.core.configurations.IRetryConfiguration; +import aquality.selenium.core.configurations.ITimeoutConfiguration; +import org.testng.Assert; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; +import tests.application.CustomAqualityServices; +import tests.application.TestModule; + +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertTrue; + +public class EnvConfigurationTests extends BaseProfileTest { + + private static final String LANGUAGE_KEY = "logger.language"; + private static final String ELEMENT_CACHE = "elementCache.isEnabled"; + private static final String NEW_BOOL_VALUE = "true"; + private static final String NEW_STRING_VALUE = "ru"; + private static final String DEFAULT_LANGUAGE = "en"; + private static final String CONDITION_TIMEOUT_KEY = "timeouts.timeoutCondition"; + private static final String NEW_INT_VALUE = "10000"; + private static final String RETRY_NUMBER_KEY = "retry.number"; + + @BeforeMethod + public void before() { + System.setProperty(LANGUAGE_KEY, NEW_STRING_VALUE); + System.setProperty(CONDITION_TIMEOUT_KEY, NEW_INT_VALUE); + System.setProperty(RETRY_NUMBER_KEY, NEW_INT_VALUE); + System.setProperty(ELEMENT_CACHE, NEW_BOOL_VALUE); + CustomAqualityServices.initInjector(new TestModule(CustomAqualityServices::getApplication)); + } + + @Test + public void testShouldBePossibleToOverrideLanguageWithEnvVariable() { + String language = CustomAqualityServices.getServiceProvider().getInstance(ILoggerConfiguration.class).getLanguage(); + assertEquals(language, "ru", "Current language should be overridden with env variable"); + } + + @Test + public void testShouldBePossibleToOverrideTimeoutWithEnvVariable() { + long conditionTimeout = CustomAqualityServices.getServiceProvider().getInstance(ITimeoutConfiguration.class).getCondition(); + assertEquals(conditionTimeout, Long.parseLong(NEW_INT_VALUE), "Condition timeout should be overridden with env variable"); + } + + @Test + public void testShouldBePossibleToOverrideRetryConfigurationWithEnvVariable() { + int retryNumber = CustomAqualityServices.getServiceProvider().getInstance(IRetryConfiguration.class).getNumber(); + assertEquals(retryNumber, Long.parseLong(NEW_INT_VALUE), "Number of retry attempts should be overridden with env variable"); + } + + @Test + public void testShouldBePossibleToOverrideElementCacheStateWithEnvVariable() { + boolean isEnabled = CustomAqualityServices.getServiceProvider().getInstance(IElementCacheConfiguration.class).isEnabled(); + assertTrue(isEnabled, "Element cache state should be overridden with env variable"); + } + + @Test + public void testNumberFormatExceptionShouldBeThrownIfTimeoutIsNotANumber() { + System.setProperty(CONDITION_TIMEOUT_KEY, NEW_STRING_VALUE); + checkNumberFormatException(() -> CustomAqualityServices.getServiceProvider().getInstance(ITimeoutConfiguration.class).getCommand()); + } + + @Test + public void testNumberFormatExceptionShouldBeThrownIfRetryConfigurationIsNotANumber() { + System.setProperty(RETRY_NUMBER_KEY, NEW_STRING_VALUE); + checkNumberFormatException(() -> CustomAqualityServices.getServiceProvider().getInstance(IRetryConfiguration.class).getNumber()); + } + + @Test + public void testShouldGetDefaultLanguageIfConfigurationIsAbsent() { + System.setProperty(PROFILE_KEY, "empty"); + System.clearProperty(LANGUAGE_KEY); + CustomAqualityServices.initInjector(new TestModule(CustomAqualityServices::getApplication)); + String language = CustomAqualityServices.getServiceProvider().getInstance(ILoggerConfiguration.class).getLanguage(); + assertEquals(language, DEFAULT_LANGUAGE, "Current language should be got from logger configuration"); + } + + @AfterMethod + public void after() { + System.clearProperty(LANGUAGE_KEY); + System.clearProperty(CONDITION_TIMEOUT_KEY); + System.clearProperty(RETRY_NUMBER_KEY); + System.clearProperty(ELEMENT_CACHE); + CustomAqualityServices.initInjector(new AqualityModule<>(CustomAqualityServices::getApplication)); + } + + private void checkNumberFormatException(Runnable getNumberAction) { + try { + CustomAqualityServices.initInjector(new TestModule(CustomAqualityServices::getApplication)); + getNumberAction.run(); + } catch (Exception e) { + Assert.assertSame(e.getCause().getClass(), NumberFormatException.class); + } + } +} diff --git a/src/test/java/tests/configurations/LoggerConfigurationTests.java b/src/test/java/tests/configurations/LoggerConfigurationTests.java new file mode 100644 index 0000000..de673d2 --- /dev/null +++ b/src/test/java/tests/configurations/LoggerConfigurationTests.java @@ -0,0 +1,16 @@ +package tests.configurations; + +import aquality.selenium.core.configurations.ILoggerConfiguration; +import org.testng.annotations.Test; +import tests.application.CustomAqualityServices; + +import static org.testng.Assert.assertEquals; + +public class LoggerConfigurationTests { + + @Test + public void testShouldBePossibleToGetLanguage() { + String language = CustomAqualityServices.getServiceProvider().getInstance(ILoggerConfiguration.class).getLanguage(); + assertEquals(language, "en", "Current language should be got from logger configuration"); + } +} diff --git a/src/test/java/tests/configurations/ProfileConfigurationTests.java b/src/test/java/tests/configurations/ProfileConfigurationTests.java new file mode 100644 index 0000000..4819c0c --- /dev/null +++ b/src/test/java/tests/configurations/ProfileConfigurationTests.java @@ -0,0 +1,26 @@ +package tests.configurations; + +import aquality.selenium.core.application.AqualityModule; +import aquality.selenium.core.configurations.ILoggerConfiguration; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; +import tests.application.CustomAqualityServices; + +import static org.testng.Assert.assertEquals; + +public class ProfileConfigurationTests extends BaseProfileTest { + + private static final String PROFILE = "custom"; + + @BeforeMethod + public void before() { + System.setProperty(PROFILE_KEY, PROFILE); + CustomAqualityServices.initInjector(new AqualityModule<>(CustomAqualityServices::getApplication)); + } + + @Test + public void testShouldBePossibleToGetLanguageFromNewSettingsFile() { + String language = CustomAqualityServices.getServiceProvider().getInstance(ILoggerConfiguration.class).getLanguage(); + assertEquals(language, "ru", String.format("Current language should be got from %s profile", PROFILE)); + } +} diff --git a/src/test/java/tests/configurations/RetryConfigurationTests.java b/src/test/java/tests/configurations/RetryConfigurationTests.java new file mode 100644 index 0000000..4e05212 --- /dev/null +++ b/src/test/java/tests/configurations/RetryConfigurationTests.java @@ -0,0 +1,18 @@ +package tests.configurations; + +import aquality.selenium.core.configurations.IRetryConfiguration; +import aquality.selenium.core.configurations.ITimeoutConfiguration; +import org.testng.annotations.Test; +import tests.application.CustomAqualityServices; + +import static org.testng.Assert.assertEquals; + +public class RetryConfigurationTests { + + @Test + public void testShouldBePossibleToGetRetryConfiguration() { + IRetryConfiguration retryConfiguration = CustomAqualityServices.getServiceProvider().getInstance(IRetryConfiguration.class); + assertEquals(retryConfiguration.getNumber(), 2, "Number of retry attempts timeout should be got"); + assertEquals(retryConfiguration.getPollingInterval(), 300, "Polling interval of retrier should be got"); + } +} diff --git a/src/test/java/tests/configurations/TimeoutConfigurationTests.java b/src/test/java/tests/configurations/TimeoutConfigurationTests.java new file mode 100644 index 0000000..9b2f84a --- /dev/null +++ b/src/test/java/tests/configurations/TimeoutConfigurationTests.java @@ -0,0 +1,19 @@ +package tests.configurations; + +import aquality.selenium.core.configurations.ITimeoutConfiguration; +import org.testng.annotations.Test; +import tests.application.CustomAqualityServices; + +import static org.testng.Assert.assertEquals; + +public class TimeoutConfigurationTests { + + @Test + public void testShouldBePossibleToGetTimeoutConfiguration() { + ITimeoutConfiguration timeoutConfiguration = CustomAqualityServices.getServiceProvider().getInstance(ITimeoutConfiguration.class); + assertEquals(timeoutConfiguration.getCommand(), 60, "Command timeout should be got"); + assertEquals(timeoutConfiguration.getCondition(), 30, "Condition timeout should be got"); + assertEquals(timeoutConfiguration.getImplicit(), 0, "Implicit timeout should be got"); + assertEquals(timeoutConfiguration.getPollingInterval(), 300, "Polling interval should be got"); + } +} diff --git a/src/test/java/tests/utilities/CustomSettingsFileTests.java b/src/test/java/tests/utilities/CustomSettingsFileTests.java index 67d9ba9..69b0c23 100644 --- a/src/test/java/tests/utilities/CustomSettingsFileTests.java +++ b/src/test/java/tests/utilities/CustomSettingsFileTests.java @@ -4,6 +4,7 @@ import aquality.selenium.core.utilities.ISettingsFile; import com.google.inject.Provider; import org.testng.Assert; +import org.testng.annotations.AfterMethod; import org.testng.annotations.Test; import tests.application.CustomAqualityServices; import tests.application.browser.ChromeApplication; @@ -21,6 +22,11 @@ public void testShouldBePossibleToOverrideSettingsFile() { Assert.assertNull(value, "Value should be got from CustomSettingsFile"); } + @AfterMethod + public void after(){ + CustomAqualityServices.initInjector(new AqualityModule<>(CustomAqualityServices::getApplication)); + } + private class CustomModule extends AqualityModule { CustomModule(Provider applicationProvider) { diff --git a/src/test/java/tests/utilities/SettingsFileTests.java b/src/test/java/tests/utilities/SettingsFileTests.java index bb285fe..f1fcef0 100644 --- a/src/test/java/tests/utilities/SettingsFileTests.java +++ b/src/test/java/tests/utilities/SettingsFileTests.java @@ -1,11 +1,13 @@ package tests.utilities; +import aquality.selenium.core.application.AqualityModule; import aquality.selenium.core.utilities.ISettingsFile; import org.testng.annotations.AfterMethod; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; import tests.application.CustomAqualityServices; import tests.application.TestModule; +import tests.configurations.BaseProfileTest; import java.util.Arrays; import java.util.HashMap; @@ -14,23 +16,20 @@ import static org.testng.Assert.*; -public class SettingsFileTests { +public class SettingsFileTests extends BaseProfileTest { private static final String TIMEOUT_POLLING_INTERVAL_PATH = "/timeouts/timeoutPollingInterval"; private static final String TIMEOUT_POLLING_INTERVAL_KEY = "timeouts.timeoutPollingInterval"; private static final String LANGUAGE_ENV_KEY = "logger.language"; private static final String ARGUMENTS_ENV_KEY = "arguments.start"; private static final String PROFILE = "jsontest"; - private static final String PROFILE_KEY = "profile"; private static final String FILE_NAME = String.format("settings.%s.json", PROFILE); private ISettingsFile jsonSettingsFile; - private String previousProfile; private static final Map EXPECTED_LANGUAGES = new HashMap() {{ put("language", "ru"); }}; @BeforeMethod public void before() { - previousProfile = System.getProperty(PROFILE_KEY); System.setProperty(PROFILE_KEY, PROFILE); CustomAqualityServices.initInjector(getTestModule()); jsonSettingsFile = CustomAqualityServices.getServiceProvider().getInstance(ISettingsFile.class); @@ -106,15 +105,10 @@ public void testShouldBePossibleToCheckIsValuePresent() { @AfterMethod public void after() { - if (previousProfile == null) { - System.clearProperty(PROFILE_KEY); - } else { - System.setProperty(PROFILE_KEY, previousProfile); - } - System.clearProperty(LANGUAGE_ENV_KEY); System.clearProperty(TIMEOUT_POLLING_INTERVAL_KEY); System.clearProperty(ARGUMENTS_ENV_KEY); + CustomAqualityServices.initInjector(new AqualityModule<>(CustomAqualityServices::getApplication)); } private TestModule getTestModule() { diff --git a/src/test/resources/TestSuite.xml b/src/test/resources/TestSuite.xml index 06edb02..d464978 100644 --- a/src/test/resources/TestSuite.xml +++ b/src/test/resources/TestSuite.xml @@ -6,6 +6,10 @@ + + + + @@ -17,6 +21,8 @@ + + \ No newline at end of file diff --git a/src/test/resources/settings.custom.json b/src/test/resources/settings.custom.json new file mode 100644 index 0000000..af6df49 --- /dev/null +++ b/src/test/resources/settings.custom.json @@ -0,0 +1,18 @@ +{ + "timeouts": { + "timeoutImplicit": 1, + "timeoutCondition": 300, + "timeoutPollingInterval": 3000, + "timeoutCommand": 600 + }, + "retry": { + "number": 20, + "pollingInterval": 3000 + }, + "logger": { + "language": "ru" + }, + "elementCache": { + "isEnabled": false + } +} diff --git a/src/test/resources/settings.empty.json b/src/test/resources/settings.empty.json new file mode 100644 index 0000000..2c63c08 --- /dev/null +++ b/src/test/resources/settings.empty.json @@ -0,0 +1,2 @@ +{ +} diff --git a/src/test/resources/settings.json b/src/test/resources/settings.json deleted file mode 100644 index 4271f20..0000000 --- a/src/test/resources/settings.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "timeouts": { - "timeoutImplicit": 0, - "timeoutCondition": 30, - "timeoutPollingInterval": 300, - "timeoutCommand": 60 - }, - "retry": { - "number": 2, - "pollingInterval": 300 - }, - "logger": { - "language": "en" - } -} diff --git a/src/test/resources/settings.local.json b/src/test/resources/settings.local.json index 4271f20..cc2e51d 100644 --- a/src/test/resources/settings.local.json +++ b/src/test/resources/settings.local.json @@ -11,5 +11,8 @@ }, "logger": { "language": "en" + }, + "elementCache": { + "isEnabled": false } }