From 646fa5765faad0b62889226f9d3ad2604a9335cd Mon Sep 17 00:00:00 2001 From: Olha Omelianchuk Date: Mon, 6 Nov 2023 15:49:51 +0100 Subject: [PATCH 1/2] implement for @After --- .../xceptance/neodymium/NeodymiumRunner.java | 13 ++ .../multibrowser/BrowserRunAfters.java | 160 ++++++++++++++ .../DontStartNewBrowserForCleanUp.java | 17 ++ .../util/NeodymiumConfiguration.java | 4 + .../ClassBrowserSuppressedWithAfter.java | 28 +++ .../NewBrowserIsNotStartedForCleanUp.java | 55 +++++ .../NewBrowserIsStartedForCleanUp.java | 67 ++++++ ...lassBrowserSuppressedAfterWithBrowser.java | 29 +++ ...ewBrowserIsNotStartedForOneOfCleanUps.java | 63 ++++++ .../browser/mixed/StartBrowserForCleanUp.java | 41 ++++ .../softassertion/UseSoftAssertions.java | 7 + .../webDriver/ValidateKeepWebDriverOpen.java | 41 ++++ ...dateKeepWebDriverOpenOnFailureInAfter.java | 195 ++++++++++++++++++ ...teKeepWebDriverOpenOnFailureWithAfter.java | 188 +++++++++++++++++ .../ValidatePreventReuseWebDriver.java | 2 + .../neodymium/tests/BrowserStatementTest.java | 55 +++++ .../tests/NeodymiumWebDriverTest.java | 18 ++ .../neodymium/tests/PlaygroundTest.java | 98 +++++++++ 18 files changed, 1081 insertions(+) create mode 100644 src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunAfters.java create mode 100644 src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/DontStartNewBrowserForCleanUp.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithAfter.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForCleanUp.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsStartedForCleanUp.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedAfterWithBrowser.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfCleanUps.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForCleanUp.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInAfter.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithAfter.java create mode 100644 src/test/java/com/xceptance/neodymium/tests/PlaygroundTest.java diff --git a/src/main/java/com/xceptance/neodymium/NeodymiumRunner.java b/src/main/java/com/xceptance/neodymium/NeodymiumRunner.java index 031bc9fec..b48bbbe6d 100644 --- a/src/main/java/com/xceptance/neodymium/NeodymiumRunner.java +++ b/src/main/java/com/xceptance/neodymium/NeodymiumRunner.java @@ -13,6 +13,7 @@ import org.apache.commons.lang3.StringUtils; import org.junit.After; import org.junit.Before; +import org.junit.internal.runners.statements.RunAfters; import org.junit.runner.Description; import org.junit.runner.RunWith; import org.junit.runner.notification.RunNotifier; @@ -29,6 +30,7 @@ import com.xceptance.neodymium.module.StatementBuilder; import com.xceptance.neodymium.module.order.DefaultStatementRunOrder; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.BrowserRunAfters; import com.xceptance.neodymium.util.Neodymium; import io.qameta.allure.selenide.AllureSelenide; @@ -401,6 +403,17 @@ private void recursiveBuildCrossProduct(Method method, List bu } } + @Override + protected Statement withAfters(FrameworkMethod method, Object target, + Statement statement) + { + List afters = getTestClass().getAnnotatedMethods( + After.class); + return afters.isEmpty() ? statement + : (Neodymium.configuration().startNewBrowserForCleanUp() ? new BrowserRunAfters(statement, afters, target) + : new RunAfters(statement, afters, target)); + } + @Override public Description getDescription() { diff --git a/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunAfters.java b/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunAfters.java new file mode 100644 index 000000000..91e07d4c1 --- /dev/null +++ b/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunAfters.java @@ -0,0 +1,160 @@ +package com.xceptance.neodymium.module.statement.browser.multibrowser; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.internal.runners.statements.RunAfters; +import org.junit.runners.model.FrameworkMethod; +import org.junit.runners.model.MultipleFailureException; +import org.junit.runners.model.Statement; +import org.openqa.selenium.WebDriver; +import org.openqa.selenium.support.events.EventFiringWebDriver; + +import com.browserup.bup.BrowserUpProxy; +import com.codeborne.selenide.WebDriverRunner; +import com.xceptance.neodymium.NeodymiumWebDriverListener; +import com.xceptance.neodymium.module.StatementBuilder; +import com.xceptance.neodymium.module.statement.browser.multibrowser.configuration.BrowserConfiguration; +import com.xceptance.neodymium.module.statement.browser.multibrowser.configuration.MultibrowserConfiguration; +import com.xceptance.neodymium.util.Neodymium; + +public class BrowserRunAfters extends RunAfters +{ + private final Statement next; + + private final List afters; + + public BrowserRunAfters(Statement next, List afters, Object target) + { + super(next, afters, target); + this.afters = afters; + this.next = next; + } + + @Override + public void evaluate() throws Throwable + { + List errors = new ArrayList(); + try + { + next.evaluate(); + } + catch (Throwable e) + { + errors.add(e); + } + finally + { + WebDriverStateContainer oldDriver = Neodymium.getWebDriverStateContainer(); + for (FrameworkMethod each : afters) + { + boolean isSuppressed = isSuppressed(each); + boolean startNewBrowserForCleanUp = shouldStartNewBrowser(each) && !isSuppressed; + + BrowserConfiguration browserConfiguration = MultibrowserConfiguration.getInstance().getBrowserProfiles() + .get(Neodymium.getBrowserProfileName()); + List methodBrowserAnnotations = StatementBuilder.getAnnotations(each.getMethod(), Browser.class); + + // if browserConfiguration equals null, this means that no browser was started for the test, let's + // check + // if browser should be started for @After + // if @After method is annotated with @Browser tag, it might need to be executed with another + // browser + if (browserConfiguration == null && !methodBrowserAnnotations.isEmpty()) + { + browserConfiguration = MultibrowserConfiguration.getInstance().getBrowserProfiles() + .get(methodBrowserAnnotations.get(0).value()); + } + + // if we don't need to start new browser for the cleanup and the browser for the test was not suppressed + // it means that we should use the same browser for cleanup + // as the might have been other @After methods with new browser running previously, let's explicitly set + // the driver to original + if (!startNewBrowserForCleanUp && !isSuppressed && (Neodymium.getDriver() == null || !Neodymium.getDriver().equals(oldDriver.getWebDriver()))) + { + WebDriverRunner.setWebDriver(oldDriver.getWebDriver()); + Neodymium.setWebDriverStateContainer(oldDriver); + } + // if we need to start new browser for the clean up and any browser configuration for the @After method + // was found, create a new driver + else if (startNewBrowserForCleanUp && browserConfiguration != null) + { + WebDriverStateContainer wDSCont = BrowserRunnerHelper.createWebDriverStateContainer(browserConfiguration); + + EventFiringWebDriver eFWDriver = new EventFiringWebDriver(wDSCont.getWebDriver()); + eFWDriver.register(new NeodymiumWebDriverListener()); + wDSCont.setWebDriver(eFWDriver); + + BrowserRunnerHelper.setBrowserWindowSize(browserConfiguration, wDSCont.getWebDriver()); + WebDriverRunner.setWebDriver(wDSCont.getWebDriver()); + Neodymium.setWebDriverStateContainer(wDSCont); + } + boolean afterFailed = false; + try + { + invokeMethod(each); + } + catch (Throwable e) + { + afterFailed = true; + errors.add(e); + } + finally + { + // if we did a set up of new driver before the @After method, we need to close it + if (startNewBrowserForCleanUp && browserConfiguration != null) + { + // avoid closing driver in case it's selected to keep browser open + if (!(!browserConfiguration.isHeadless() + && ((Neodymium.configuration().keepBrowserOpenOnFailure() && afterFailed) || Neodymium.configuration().keepBrowserOpen()))) + { + WebDriverStateContainer wdst = Neodymium.getWebDriverStateContainer(); + WebDriver driver = wdst != null ? wdst.getWebDriver() : null; + if (driver != null) + { + driver.quit(); + } + BrowserUpProxy proxy = wdst != null ? wdst.getProxy() : null; + if (proxy != null) + { + proxy.stop(); + } + Neodymium.setWebDriverStateContainer(null); + } + } + } + } + } + MultipleFailureException.assertEmpty(errors); + } + + private boolean shouldStartNewBrowser(FrameworkMethod each) + { + List methodStartNewBrowserForCleanUp = StatementBuilder.getAnnotations(each.getMethod(), + DontStartNewBrowserForCleanUp.class); + List classStartNewBrowserForCleanUp = StatementBuilder.getAnnotations(each.getDeclaringClass(), + DontStartNewBrowserForCleanUp.class); + + // if global config for dontStartNewBrowserForCleanUp is set to false, we should not reach this point + boolean dontStartNewBrowserForCleanUp = true; + if (!classStartNewBrowserForCleanUp.isEmpty()) + { + dontStartNewBrowserForCleanUp = false; + } + + if (!methodStartNewBrowserForCleanUp.isEmpty()) + { + dontStartNewBrowserForCleanUp = false; + } + + // if @After method is annotated with @SuppressBrowser annotation, no new browser should be started + return dontStartNewBrowserForCleanUp; + } + + private boolean isSuppressed(FrameworkMethod each) + { + List methodSuppressBrowserAnnotations = StatementBuilder.getAnnotations(each.getMethod(), SuppressBrowsers.class); + + return !methodSuppressBrowserAnnotations.isEmpty(); + } +} diff --git a/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/DontStartNewBrowserForCleanUp.java b/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/DontStartNewBrowserForCleanUp.java new file mode 100644 index 000000000..1e38767f8 --- /dev/null +++ b/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/DontStartNewBrowserForCleanUp.java @@ -0,0 +1,17 @@ +package com.xceptance.neodymium.module.statement.browser.multibrowser; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +@Retention(RUNTIME) +@Target( +{ + TYPE, METHOD +}) +public @interface DontStartNewBrowserForCleanUp +{ +} diff --git a/src/main/java/com/xceptance/neodymium/util/NeodymiumConfiguration.java b/src/main/java/com/xceptance/neodymium/util/NeodymiumConfiguration.java index d158a0519..9cfa3e422 100644 --- a/src/main/java/com/xceptance/neodymium/util/NeodymiumConfiguration.java +++ b/src/main/java/com/xceptance/neodymium/util/NeodymiumConfiguration.java @@ -231,6 +231,10 @@ public interface NeodymiumConfiguration extends Mutable @DefaultValue("-1") public int maxWebDriverReuse(); + @Key("neodymium.webDriver.startNewBrowserForCleanUp") + @DefaultValue("true") + public boolean startNewBrowserForCleanUp(); + @Key("neodymium.webDriver.keepBrowserOpen") @DefaultValue("false") public boolean keepBrowserOpen(); diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithAfter.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithAfter.java new file mode 100644 index 000000000..a13c60fef --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithAfter.java @@ -0,0 +1,28 @@ +package com.xceptance.neodymium.testclasses.browser.classonly; + +import org.junit.After; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.SuppressBrowsers; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +@SuppressBrowsers +public class ClassBrowserSuppressedWithAfter +{ + @Test + public void first() throws Exception + { + } + + @After + public void after() + { + Assert.assertNull("Browser should not be started for cleanup", Neodymium.getDriver()); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForCleanUp.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForCleanUp.java new file mode 100644 index 000000000..295106163 --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForCleanUp.java @@ -0,0 +1,55 @@ +package com.xceptance.neodymium.testclasses.browser.classonly; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForCleanUp; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@DontStartNewBrowserForCleanUp +@Browser("chrome") +public class NewBrowserIsNotStartedForCleanUp +{ + private static WebDriver webDriver1; + + @BeforeClass + public static void beforeClass() + { + Assert.assertNull(webDriver1); + Assert.assertNull(Neodymium.getDriver()); + } + + @Test + public void test1() + { + webDriver1 = Neodymium.getDriver(); + Assert.assertEquals(webDriver1, Neodymium.getDriver()); + } + + @After + public void after() + { + Assert.assertEquals(webDriver1, Neodymium.getDriver()); + } + + @After + public void after1() + { + Assert.assertEquals(webDriver1, Neodymium.getDriver()); + } + + @AfterClass + public static void afterClass() throws InterruptedException + { + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsStartedForCleanUp.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsStartedForCleanUp.java new file mode 100644 index 000000000..866d4351d --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsStartedForCleanUp.java @@ -0,0 +1,67 @@ +package com.xceptance.neodymium.testclasses.browser.classonly; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +public class NewBrowserIsStartedForCleanUp +{ + private static WebDriver webDriver1; + + private static WebDriver webDriver2; + + private static WebDriver webDriver3; + + @BeforeClass + public static void beforeClass() + { + Assert.assertNull(webDriver1); + Assert.assertNull(webDriver2); + Assert.assertNull(webDriver3); + Assert.assertNull(Neodymium.getDriver()); + } + + @Test + public void test1() + { + Assert.assertNotNull(Neodymium.getDriver()); + webDriver1 = Neodymium.getDriver(); + Assert.assertEquals(webDriver1, Neodymium.getDriver()); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); + } + + @After + public void after() + { + Assert.assertNotNull(Neodymium.getDriver()); + Assert.assertNotEquals(webDriver1, Neodymium.getDriver()); + webDriver2 = Neodymium.getDriver(); + } + + @After + public void after1() + { + Assert.assertNotNull(Neodymium.getDriver()); + Assert.assertNotEquals(webDriver2, Neodymium.getDriver()); + webDriver3 = Neodymium.getDriver(); + } + + @AfterClass + public static void afterClass() + { + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedAfterWithBrowser.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedAfterWithBrowser.java new file mode 100644 index 000000000..eaa2d38a0 --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedAfterWithBrowser.java @@ -0,0 +1,29 @@ +package com.xceptance.neodymium.testclasses.browser.mixed; + +import org.junit.After; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.SuppressBrowsers; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +@SuppressBrowsers +public class ClassBrowserSuppressedAfterWithBrowser +{ + @Test + public void first() throws Exception + { + } + + @After + @Browser("chrome") + public void after() + { + Assert.assertNotNull("Browser should be started for cleanup", Neodymium.getDriver()); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfCleanUps.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfCleanUps.java new file mode 100644 index 000000000..f1ad7fdfb --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfCleanUps.java @@ -0,0 +1,63 @@ +package com.xceptance.neodymium.testclasses.browser.mixed; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForCleanUp; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +public class NewBrowserIsNotStartedForOneOfCleanUps +{ + private static WebDriver webDriver1; + + private static WebDriver webDriver2; + + private static WebDriver webDriver3; + + @BeforeClass + public static void beforeClass() + { + Assert.assertNull(webDriver1); + Assert.assertNull(Neodymium.getDriver()); + } + + @Test + public void test1() + { + webDriver1 = Neodymium.getDriver(); + Assert.assertEquals(webDriver1, Neodymium.getDriver()); + } + + @After + @DontStartNewBrowserForCleanUp + public void after() + { + Assert.assertEquals(webDriver1, Neodymium.getDriver()); + webDriver2 = Neodymium.getDriver(); + } + + @After + public void after1() + { + Assert.assertNotEquals(webDriver1, Neodymium.getDriver()); + webDriver3 = Neodymium.getDriver(); + } + + @AfterClass + public static void afterClass() + { + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForCleanUp.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForCleanUp.java new file mode 100644 index 000000000..629230e23 --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForCleanUp.java @@ -0,0 +1,41 @@ +package com.xceptance.neodymium.testclasses.browser.mixed; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.SuppressBrowsers; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@SuppressBrowsers +public class StartBrowserForCleanUp +{ + private static WebDriver webdriver; + + @Test + public void first() throws Exception + { + Assert.assertNull("Browser should not be started for the test", Neodymium.getDriver()); + } + + @After + @Browser("chrome") + public void after() + { + Assert.assertNotNull("Browser should be started for the cleanup", Neodymium.getDriver()); + webdriver = Neodymium.getDriver(); + } + + @AfterClass + public static void afterClass() + { + NeodymiumWebDriverTest.assertWebDriverClosed(webdriver); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/softassertion/UseSoftAssertions.java b/src/test/java/com/xceptance/neodymium/testclasses/softassertion/UseSoftAssertions.java index f2948e880..87747d83e 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/softassertion/UseSoftAssertions.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/softassertion/UseSoftAssertions.java @@ -3,6 +3,7 @@ import static com.codeborne.selenide.Condition.exist; import static com.codeborne.selenide.Selenide.$; +import org.junit.After; import org.junit.Assert; import org.junit.Rule; import org.junit.Test; @@ -39,4 +40,10 @@ public void validateSoftAssertion() $("#notFound4").click(); }); } + + @After + public void after() + { + System.out.println("after"); + } } diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpen.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpen.java index 17174a3f8..8f5b15cd4 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpen.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpen.java @@ -34,10 +34,18 @@ public class ValidateKeepWebDriverOpen private static WebDriver webDriver2; + private static WebDriver webDriver3; + + private static WebDriver webDriver4; + private static BrowserUpProxy proxy1; private static BrowserUpProxy proxy2; + private static BrowserUpProxy proxy3; + + private static BrowserUpProxy proxy4; + private static File tempConfigFile; @BeforeClass @@ -120,6 +128,27 @@ public void test2() @After public void after() { + if (webDriver2 == null) + { + webDriver3 = Neodymium.getDriver(); + proxy3 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriver3, webDriver1); + Assert.assertNotEquals(webDriver3, webDriver2); + Assert.assertNotEquals(proxy3, proxy1); + Assert.assertNotEquals(proxy3, proxy2); + } + else + { + webDriver4 = Neodymium.getDriver(); + proxy4 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriver4, webDriver1); + Assert.assertNotEquals(webDriver4, webDriver2); + Assert.assertNotEquals(webDriver4, webDriver3); + Assert.assertNotEquals(proxy4, proxy1); + Assert.assertNotEquals(proxy4, proxy2); + Assert.assertNotEquals(proxy4, proxy3); + } + NeodymiumWebDriverTest.assertWebDriverAlive(Neodymium.getDriver()); NeodymiumWebDriverTest.assertProxyAlive(Neodymium.getLocalProxy()); } @@ -131,17 +160,29 @@ public static void afterClass() NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver3); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver4); webDriver1.quit(); webDriver2.quit(); + webDriver3.quit(); + webDriver4.quit(); NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver4); NeodymiumWebDriverTest.assertProxyAlive(proxy1); NeodymiumWebDriverTest.assertProxyAlive(proxy2); + NeodymiumWebDriverTest.assertProxyAlive(proxy3); + NeodymiumWebDriverTest.assertProxyAlive(proxy4); proxy1.stop(); proxy2.stop(); + proxy3.stop(); + proxy4.stop(); NeodymiumWebDriverTest.assertProxyStopped(proxy1); NeodymiumWebDriverTest.assertProxyStopped(proxy2); + NeodymiumWebDriverTest.assertProxyStopped(proxy3); + NeodymiumWebDriverTest.assertProxyStopped(proxy4); NeodymiumTest.deleteTempFile(tempConfigFile); } diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInAfter.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInAfter.java new file mode 100644 index 000000000..1b7babb8b --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInAfter.java @@ -0,0 +1,195 @@ +package com.xceptance.neodymium.testclasses.webDriver; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; + +import org.aeonbits.owner.ConfigFactory; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.browserup.bup.BrowserUpProxy; +import com.codeborne.selenide.Condition; +import com.codeborne.selenide.Selenide; +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; +import com.xceptance.neodymium.tests.NeodymiumTest; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +/* + * Validate that the web driver is kept open after an error occurred. + * Validate that the web driver is not reused. + * Attention: this test needs to use browsers that are not headless. + */ +@RunWith(NeodymiumRunner.class) +@Browser("Chrome_1024x768") +public class ValidateKeepWebDriverOpenOnFailureInAfter +{ + private static WebDriver webDriver1; + + private static WebDriver webDriver2; + + private static WebDriver webDriver3; + + private static WebDriver webDriver4; + + private static BrowserUpProxy proxy1; + + private static BrowserUpProxy proxy2; + + private static BrowserUpProxy proxy3; + + private static BrowserUpProxy proxy4; + + private static File tempConfigFile; + + @BeforeClass + public static void beforeClass() + { + // set up a temporary neodymium.properties + final String fileLocation = "config/temp-ValidateKeepWebDriverOpenOnFailure-neodymium.properties"; + tempConfigFile = new File("./" + fileLocation); + Map properties = new HashMap<>(); + properties.put("neodymium.webDriver.keepBrowserOpenOnFailure", "true"); + properties.put("neodymium.localproxy", "true"); + NeodymiumTest.writeMapToPropertiesFile(properties, tempConfigFile); + ConfigFactory.setProperty(Neodymium.TEMPORARY_CONFIG_FILE_PROPERTY_NAME, "file:" + fileLocation); + + Assert.assertNull(webDriver1); + Assert.assertNull(Neodymium.getDriver()); + } + + @Before + public void before() + { + if (webDriver1 == null) + { + webDriver1 = Neodymium.getDriver(); + } + else if (webDriver2 == null) + { + webDriver2 = Neodymium.getDriver(); + } + else + { + Assert.assertNotNull(Neodymium.getDriver()); + } + Assert.assertNotNull(webDriver1); + + if (proxy1 == null) + { + proxy1 = Neodymium.getLocalProxy(); + } + else if (proxy2 == null) + { + proxy2 = Neodymium.getLocalProxy(); + } + else + { + Assert.assertNotNull(Neodymium.getLocalProxy()); + } + Assert.assertNotNull(proxy1); + } + + @Test + public void test1() + { + Assert.assertEquals(webDriver1, Neodymium.getDriver()); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); + + Assert.assertEquals(proxy1, Neodymium.getLocalProxy()); + NeodymiumWebDriverTest.assertProxyAlive(proxy1); + } + + @Test + public void test2() + { + Assert.assertNotEquals(webDriver1, webDriver2); + Assert.assertEquals(webDriver2, Neodymium.getDriver()); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); + + Assert.assertNotEquals(proxy1, proxy2); + Assert.assertEquals(proxy2, Neodymium.getLocalProxy()); + NeodymiumWebDriverTest.assertProxyStopped(proxy1); + NeodymiumWebDriverTest.assertProxyAlive(proxy2); + } + + @After + public void after() + { + if (webDriver2 == null) + { + webDriver3 = Neodymium.getDriver(); + proxy3 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriver1, webDriver3); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver3); + + } + else + { + webDriver4 = Neodymium.getDriver(); + proxy4 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriver2, webDriver4); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver4); + } + + if (proxy2 == null) + { + Assert.assertNotEquals(proxy1, proxy3); + Assert.assertEquals(proxy3, Neodymium.getLocalProxy()); + NeodymiumWebDriverTest.assertProxyAlive(proxy3); + Assert.assertNotEquals(proxy1, proxy3); + } + else + { + NeodymiumWebDriverTest.assertProxyAlive(proxy2); + NeodymiumWebDriverTest.assertProxyAlive(proxy4); + NeodymiumWebDriverTest.assertProxyStopped(proxy1); + NeodymiumWebDriverTest.assertProxyStopped(proxy3); + + Assert.assertNotEquals(proxy2, proxy4); + Assert.assertNotEquals(proxy3, proxy4); + Assert.assertEquals(proxy4, Neodymium.getLocalProxy()); + // Let condition fail so that the WebDriver/browser is kept open + Selenide.$("#cantFindMe").should(Condition.exist); + } + } + + @AfterClass + public static void afterClass() + { + Assert.assertEquals(0, WebDriverCache.instance.getWebDriverStateContainerCacheSize()); + + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver4); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); + webDriver2.quit(); + webDriver4.quit(); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver4); + + NeodymiumWebDriverTest.assertProxyAlive(proxy2); + NeodymiumWebDriverTest.assertProxyAlive(proxy4); + NeodymiumWebDriverTest.assertProxyStopped(proxy3); + NeodymiumWebDriverTest.assertProxyStopped(proxy1); + proxy2.stop(); + proxy4.stop(); + NeodymiumWebDriverTest.assertProxyStopped(proxy2); + NeodymiumWebDriverTest.assertProxyStopped(proxy4); + + NeodymiumTest.deleteTempFile(tempConfigFile); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithAfter.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithAfter.java new file mode 100644 index 000000000..d57b8e14d --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithAfter.java @@ -0,0 +1,188 @@ +package com.xceptance.neodymium.testclasses.webDriver; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; + +import org.aeonbits.owner.ConfigFactory; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.browserup.bup.BrowserUpProxy; +import com.codeborne.selenide.Condition; +import com.codeborne.selenide.Selenide; +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; +import com.xceptance.neodymium.tests.NeodymiumTest; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +/* + * Validate that the web driver is kept open after an error occurred. + * Validate that the web driver is not reused. + * Attention: this test needs to use browsers that are not headless. + */ +@RunWith(NeodymiumRunner.class) +@Browser("Chrome_1024x768") +public class ValidateKeepWebDriverOpenOnFailureWithAfter +{ + private static WebDriver webDriver1; + + private static WebDriver webDriver2; + + private static WebDriver webDriver3; + + private static WebDriver webDriver4; + + private static BrowserUpProxy proxy1; + + private static BrowserUpProxy proxy2; + + private static BrowserUpProxy proxy3; + + private static BrowserUpProxy proxy4; + + private static File tempConfigFile; + + @BeforeClass + public static void beforeClass() + { + // set up a temporary neodymium.properties + final String fileLocation = "config/temp-ValidateKeepWebDriverOpenOnFailure-neodymium.properties"; + tempConfigFile = new File("./" + fileLocation); + Map properties = new HashMap<>(); + properties.put("neodymium.webDriver.keepBrowserOpenOnFailure", "true"); + properties.put("neodymium.localproxy", "true"); + NeodymiumTest.writeMapToPropertiesFile(properties, tempConfigFile); + ConfigFactory.setProperty(Neodymium.TEMPORARY_CONFIG_FILE_PROPERTY_NAME, "file:" + fileLocation); + + Assert.assertNull(webDriver1); + Assert.assertNull(Neodymium.getDriver()); + } + + @Before + public void before() + { + if (webDriver1 == null) + { + webDriver1 = Neodymium.getDriver(); + } + else if (webDriver2 == null) + { + webDriver2 = Neodymium.getDriver(); + } + else + { + Assert.assertNotNull(Neodymium.getDriver()); + } + Assert.assertNotNull(webDriver1); + + if (proxy1 == null) + { + proxy1 = Neodymium.getLocalProxy(); + } + else if (proxy2 == null) + { + proxy2 = Neodymium.getLocalProxy(); + } + else + { + Assert.assertNotNull(Neodymium.getLocalProxy()); + } + Assert.assertNotNull(proxy1); + } + + @Test + public void test1() + { + Assert.assertEquals(webDriver1, Neodymium.getDriver()); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); + + Assert.assertEquals(proxy1, Neodymium.getLocalProxy()); + NeodymiumWebDriverTest.assertProxyAlive(proxy1); + } + + @Test + public void test2() + { + Assert.assertNotEquals(webDriver1, webDriver2); + Assert.assertEquals(webDriver2, Neodymium.getDriver()); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); + + Assert.assertNotEquals(proxy1, proxy2); + Assert.assertEquals(proxy2, Neodymium.getLocalProxy()); + NeodymiumWebDriverTest.assertProxyStopped(proxy1); + NeodymiumWebDriverTest.assertProxyAlive(proxy2); + + // Let condition fail so that the WebDriver/browser is kept open + Selenide.$("#cantFindMe").should(Condition.exist); + } + + @After + public void after() + { + if (webDriver2 == null) + { + webDriver3 = Neodymium.getDriver(); + proxy3 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriver1, webDriver3); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver3); + } + else + { + webDriver4 = Neodymium.getDriver(); + proxy4 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriver2, webDriver4); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver4); + } + + if (proxy2 == null) + { + Assert.assertNotEquals(proxy1, proxy3); + Assert.assertEquals(proxy3, Neodymium.getLocalProxy()); + NeodymiumWebDriverTest.assertProxyAlive(proxy3); + } + else + { + NeodymiumWebDriverTest.assertProxyAlive(proxy2); + NeodymiumWebDriverTest.assertProxyAlive(proxy4); + NeodymiumWebDriverTest.assertProxyStopped(proxy1); + NeodymiumWebDriverTest.assertProxyStopped(proxy3); + + Assert.assertNotEquals(proxy2, proxy4); + Assert.assertNotEquals(proxy3, proxy4); + Assert.assertEquals(proxy4, Neodymium.getLocalProxy()); + } + } + + @AfterClass + public static void afterClass() + { + Assert.assertEquals(0, WebDriverCache.instance.getWebDriverStateContainerCacheSize()); + + NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver4); + webDriver2.quit(); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); + + NeodymiumWebDriverTest.assertProxyAlive(proxy2); + NeodymiumWebDriverTest.assertProxyStopped(proxy3); + NeodymiumWebDriverTest.assertProxyStopped(proxy1); + proxy2.stop(); + NeodymiumWebDriverTest.assertProxyStopped(proxy2); + + NeodymiumTest.deleteTempFile(tempConfigFile); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidatePreventReuseWebDriver.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidatePreventReuseWebDriver.java index 8e7316601..44a5d41c4 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidatePreventReuseWebDriver.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidatePreventReuseWebDriver.java @@ -17,6 +17,7 @@ import com.browserup.bup.BrowserUpProxy; import com.xceptance.neodymium.NeodymiumRunner; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForCleanUp; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; import com.xceptance.neodymium.tests.NeodymiumTest; import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; @@ -27,6 +28,7 @@ * Validate that the reuse of a web driver could be prevented programmatically. * Validate that the other web driver is not reused. */ +@DontStartNewBrowserForCleanUp @RunWith(NeodymiumRunner.class) public class ValidatePreventReuseWebDriver { diff --git a/src/test/java/com/xceptance/neodymium/tests/BrowserStatementTest.java b/src/test/java/com/xceptance/neodymium/tests/BrowserStatementTest.java index 962c22786..270e75c1a 100644 --- a/src/test/java/com/xceptance/neodymium/tests/BrowserStatementTest.java +++ b/src/test/java/com/xceptance/neodymium/tests/BrowserStatementTest.java @@ -27,6 +27,9 @@ import com.xceptance.neodymium.testclasses.browser.RandomBrowsersMethodInitialisationException; import com.xceptance.neodymium.testclasses.browser.classonly.ClassBrowserSuppressed; import com.xceptance.neodymium.testclasses.browser.classonly.ClassBrowserSuppressedNoBrowserAnnotation; +import com.xceptance.neodymium.testclasses.browser.classonly.ClassBrowserSuppressedWithAfter; +import com.xceptance.neodymium.testclasses.browser.classonly.NewBrowserIsNotStartedForCleanUp; +import com.xceptance.neodymium.testclasses.browser.classonly.NewBrowserIsStartedForCleanUp; import com.xceptance.neodymium.testclasses.browser.classonly.OneClassBrowserOneMethod; import com.xceptance.neodymium.testclasses.browser.classonly.RandomBrowserClassLevel; import com.xceptance.neodymium.testclasses.browser.classonly.TwoClassBrowserOneMethod; @@ -37,8 +40,11 @@ import com.xceptance.neodymium.testclasses.browser.methodonly.OneBrowserOneMethodBrowserSuppressed; import com.xceptance.neodymium.testclasses.browser.methodonly.RandomBrowserMethodLevel; import com.xceptance.neodymium.testclasses.browser.mixed.ClassAndMethodSameBrowserOneMethod; +import com.xceptance.neodymium.testclasses.browser.mixed.ClassBrowserSuppressedAfterWithBrowser; import com.xceptance.neodymium.testclasses.browser.mixed.MethodBrowserAnnotationOverwritesClassRandomBrowser; +import com.xceptance.neodymium.testclasses.browser.mixed.NewBrowserIsNotStartedForOneOfCleanUps; import com.xceptance.neodymium.testclasses.browser.mixed.RandomBrowserMixed; +import com.xceptance.neodymium.testclasses.browser.mixed.StartBrowserForCleanUp; import com.xceptance.neodymium.util.Neodymium; public class BrowserStatementTest extends NeodymiumTest @@ -183,6 +189,55 @@ public void testRandomBrowsersClassInitialisationException() "java.lang.IllegalArgumentException: Method 'test1' is marked to be run with 9 random browsers, but there are only 4 available"); } + @Test + public void testStartBrowserForCleanUp() + { + // by default, new browser is started for each @After + Result result = JUnitCore.runClasses(StartBrowserForCleanUp.class); + checkPass(result, 1, 0); + } + + @Test + public void testNewBrowserIsNotStartedForOneOfCleanUps() + { + // by default, new browser is started for each @After + Result result = JUnitCore.runClasses(NewBrowserIsNotStartedForOneOfCleanUps.class); + checkPass(result, 1, 0); + } + + @Test + public void testNewBrowserIsStartedForCleanUp() + { + // by default, new browser is started for each @After + Result result = JUnitCore.runClasses(NewBrowserIsStartedForCleanUp.class); + checkPass(result, 1, 0); + } + + @Test + public void testNewBrowserIsNotStartedForCleanUp() + { + // if test class is annotated with @@StartNewBrowserForCleanUp(false), no new browser is started for cleanup + Result result = JUnitCore.runClasses(NewBrowserIsNotStartedForCleanUp.class); + checkPass(result, 1, 0); + } + + @Test + public void testSupressBrowserWithAfter() + { + // if test class, marked to run without browser, it should not be started for clean up + Result result = JUnitCore.runClasses(ClassBrowserSuppressedWithAfter.class); + checkPass(result, 1, 0); + } + + @Test + public void testClassBrowserSuppressedAfterWithBrowser() + { + // although test class is marked to be run without browser, if @After method is annotated with @Browser, the + // browser should be started for clean up + Result result = JUnitCore.runClasses(ClassBrowserSuppressedAfterWithBrowser.class); + checkPass(result, 1, 0); + } + @Test public void testTestBrowser() throws Throwable { diff --git a/src/test/java/com/xceptance/neodymium/tests/NeodymiumWebDriverTest.java b/src/test/java/com/xceptance/neodymium/tests/NeodymiumWebDriverTest.java index 1d8cb9532..dbd2ccedb 100644 --- a/src/test/java/com/xceptance/neodymium/tests/NeodymiumWebDriverTest.java +++ b/src/test/java/com/xceptance/neodymium/tests/NeodymiumWebDriverTest.java @@ -17,6 +17,8 @@ import com.xceptance.neodymium.testclasses.webDriver.ValidateClearReuseWebDriverCache; import com.xceptance.neodymium.testclasses.webDriver.ValidateKeepWebDriverOpen; import com.xceptance.neodymium.testclasses.webDriver.ValidateKeepWebDriverOpenOnFailure; +import com.xceptance.neodymium.testclasses.webDriver.ValidateKeepWebDriverOpenOnFailureInAfter; +import com.xceptance.neodymium.testclasses.webDriver.ValidateKeepWebDriverOpenOnFailureWithAfter; import com.xceptance.neodymium.testclasses.webDriver.ValidatePreventReuseWebDriver; import com.xceptance.neodymium.testclasses.webDriver.ValidateReuseWebDriver; import com.xceptance.neodymium.testclasses.webDriver.ValidateWebDriverClosed; @@ -91,6 +93,22 @@ public void testValidateKeepWebDriverOpenOnFailure() checkFail(result, 3, 0, 1); } + @Test + public void testValidateKeepWebDriverOpenOnFailureWithAfter() + { + // XVFB or a display needed + Result result = JUnitCore.runClasses(ValidateKeepWebDriverOpenOnFailureWithAfter.class); + checkFail(result, 2, 0, 1); + } + + @Test + public void testValidateKeepWebDriverOpenOnFailureInAfter() + { + // XVFB or a display needed + Result result = JUnitCore.runClasses(ValidateKeepWebDriverOpenOnFailureInAfter.class); + checkFail(result, 2, 0, 1); + } + @Test public void testLocalProxyTrustAllServers() { diff --git a/src/test/java/com/xceptance/neodymium/tests/PlaygroundTest.java b/src/test/java/com/xceptance/neodymium/tests/PlaygroundTest.java new file mode 100644 index 000000000..ffc099c0f --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/tests/PlaygroundTest.java @@ -0,0 +1,98 @@ +package com.xceptance.neodymium.tests; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.codeborne.selenide.Selenide; +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.SuppressBrowsers; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("Chrome_headless") +public class PlaygroundTest +{ + private static WebDriver webDriver1; + + private static WebDriver webDriver2; + + private static WebDriver webDriver3; + + private static boolean alive; + + @BeforeClass + public static void beforeClass() + { + // Assert.assertNull(webDriver1); + // Assert.assertNull(Neodymium.getDriver()); + } + + @SuppressBrowsers + @Test + public void test1() + { + // webDriver1 = Neodymium.getDriver(); + // Assert.assertEquals(webDriver1, Neodymium.getDriver()); + // NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); + // + // Selenide.open("https://www.xceptance.com/"); + Assert.assertNull(Neodymium.getDriver()); + alive = false; + } + + @Test + public void test2() + { + // webDriver1 = Neodymium.getDriver(); + // Assert.assertEquals(webDriver1, Neodymium.getDriver()); + NeodymiumWebDriverTest.assertWebDriverAlive(Neodymium.getDriver()); + + Selenide.open("https://www.xceptance.com/"); + alive = true; + } + + @After + public void after() + { + // Assert.assertNotEquals(webDriver1, Neodymium.getDriver()); + // webDriver2 = Neodymium.getDriver(); + // Selenide.open("https://xtc.xceptance.com/"); + if (alive) + { + Selenide.open("https://xtc.xceptance.com/"); + } + else + { + Assert.assertNull(Neodymium.getDriver()); + } + } + + @After + public void after1() + { + // Assert.assertNotEquals(webDriver2, Neodymium.getDriver()); + // webDriver3 = Neodymium.getDriver(); + if (alive) + { + Selenide.open("https://github.com/Xceptance/neodymium-library/pull/194/files"); + } + else + { + Assert.assertNull(Neodymium.getDriver()); + } + } + + @AfterClass + public static void afterClass() + { + // NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); + // NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); + // NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); + } +} From 58e8a05aac3ebce6166ca202dd3c9a29fc110840 Mon Sep 17 00:00:00 2001 From: Olha Omelianchuk Date: Thu, 9 Nov 2023 12:25:35 +0100 Subject: [PATCH 2/2] mirror the feature for @Before and add unit tests --- .../xceptance/neodymium/NeodymiumRunner.java | 13 ++ .../multibrowser/BrowserRunAfters.java | 26 ++- .../multibrowser/BrowserRunBefores.java | 173 +++++++++++++++ .../DontStartNewBrowserForSetUp.java | 18 ++ .../util/NeodymiumConfiguration.java | 4 + .../ClassBrowserSuppressedWithBefore.java | 28 +++ .../MethodBrowserSuppressedWithAfter.java | 28 +++ .../NewBrowserIsNotStartedForCleanUp.java | 30 ++- .../NewBrowserIsNotStartedForSetUp.java | 74 +++++++ .../ClassBrowserSuppressedWithAfter.java | 2 +- ...DontStartNewBrowserForOneOfTheAfters.java} | 20 +- ...DontStartNewBrowserForOneOfTheBefores.java | 64 ++++++ ...lassBrowserSuppressedAfterWithBrowser.java | 1 + ...assBrowserSuppressedBeforeWithBrowser.java | 31 +++ ...ewBrowserIsNotStartedForOneOfCleanUps.java | 6 +- .../NewBrowserIsNotStartedForOneOfSetUps.java | 56 +++++ .../mixed/OverwriteBrowserForCleanUp.java | 28 +++ .../mixed/OverwriteBrowserForSetUp.java | 28 +++ .../browser/mixed/StartBrowserForCleanUp.java | 30 ++- .../browser/mixed/StartBrowserForSetUp.java | 57 +++++ .../ValidateClearReuseWebDriverCache.java | 2 + .../webDriver/ValidateKeepWebDriverOpen.java | 201 ++++++++++-------- .../ValidateKeepWebDriverOpenOnFailure.java | 53 +---- ...dateKeepWebDriverOpenOnFailureInAfter.java | 163 ++++++-------- ...ateKeepWebDriverOpenOnFailureInBefore.java | 151 +++++++++++++ ...teKeepWebDriverOpenOnFailureWithAfter.java | 145 +++++-------- ...eKeepWebDriverOpenOnFailureWithBefore.java | 153 +++++++++++++ .../ValidatePreventReuseWebDriver.java | 2 + .../webDriver/ValidateReuseWebDriver.java | 2 + .../webDriver/ValidateWebDriverClosed.java | 2 + .../webDriver/ValidateWebDriverMaxReuse.java | 2 + ...ateWebDriverMaxReuseWithTwoWebDrivers.java | 2 + .../ValidateWebDriverReuseCounter.java | 2 + .../neodymium/tests/BrowserStatementTest.java | 106 ++++++++- .../tests/NeodymiumWebDriverTest.java | 18 ++ .../neodymium/tests/PlaygroundTest.java | 98 --------- 36 files changed, 1349 insertions(+), 470 deletions(-) create mode 100644 src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunBefores.java create mode 100644 src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/DontStartNewBrowserForSetUp.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithBefore.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/MethodBrowserSuppressedWithAfter.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForSetUp.java rename src/test/java/com/xceptance/neodymium/testclasses/browser/{classonly => methodonly}/ClassBrowserSuppressedWithAfter.java (91%) rename src/test/java/com/xceptance/neodymium/testclasses/browser/{classonly/NewBrowserIsStartedForCleanUp.java => methodonly/DontStartNewBrowserForOneOfTheAfters.java} (65%) create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/methodonly/DontStartNewBrowserForOneOfTheBefores.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedBeforeWithBrowser.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfSetUps.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/OverwriteBrowserForCleanUp.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/OverwriteBrowserForSetUp.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForSetUp.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInBefore.java create mode 100644 src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithBefore.java delete mode 100644 src/test/java/com/xceptance/neodymium/tests/PlaygroundTest.java diff --git a/src/main/java/com/xceptance/neodymium/NeodymiumRunner.java b/src/main/java/com/xceptance/neodymium/NeodymiumRunner.java index b48bbbe6d..7145aaa90 100644 --- a/src/main/java/com/xceptance/neodymium/NeodymiumRunner.java +++ b/src/main/java/com/xceptance/neodymium/NeodymiumRunner.java @@ -14,6 +14,7 @@ import org.junit.After; import org.junit.Before; import org.junit.internal.runners.statements.RunAfters; +import org.junit.internal.runners.statements.RunBefores; import org.junit.runner.Description; import org.junit.runner.RunWith; import org.junit.runner.notification.RunNotifier; @@ -31,6 +32,7 @@ import com.xceptance.neodymium.module.order.DefaultStatementRunOrder; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; import com.xceptance.neodymium.module.statement.browser.multibrowser.BrowserRunAfters; +import com.xceptance.neodymium.module.statement.browser.multibrowser.BrowserRunBefores; import com.xceptance.neodymium.util.Neodymium; import io.qameta.allure.selenide.AllureSelenide; @@ -403,6 +405,17 @@ private void recursiveBuildCrossProduct(Method method, List bu } } + @Override + protected Statement withBefores(FrameworkMethod method, Object target, + Statement statement) + { + List befores = getTestClass().getAnnotatedMethods( + Before.class); + return befores.isEmpty() ? statement + : (Neodymium.configuration().startNewBrowserForSetUp() ? new BrowserRunBefores(statement, befores, target) + : new RunBefores(statement, befores, target)); + } + @Override protected Statement withAfters(FrameworkMethod method, Object target, Statement statement) diff --git a/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunAfters.java b/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunAfters.java index 91e07d4c1..434ee71cf 100644 --- a/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunAfters.java +++ b/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunAfters.java @@ -46,21 +46,19 @@ public void evaluate() throws Throwable finally { WebDriverStateContainer oldDriver = Neodymium.getWebDriverStateContainer(); + BrowserConfiguration oldBrowserConfiguration = MultibrowserConfiguration.getInstance().getBrowserProfiles() + .get(Neodymium.getBrowserProfileName()); for (FrameworkMethod each : afters) { boolean isSuppressed = isSuppressed(each); boolean startNewBrowserForCleanUp = shouldStartNewBrowser(each) && !isSuppressed; - BrowserConfiguration browserConfiguration = MultibrowserConfiguration.getInstance().getBrowserProfiles() - .get(Neodymium.getBrowserProfileName()); + BrowserConfiguration browserConfiguration = oldBrowserConfiguration; List methodBrowserAnnotations = StatementBuilder.getAnnotations(each.getMethod(), Browser.class); - // if browserConfiguration equals null, this means that no browser was started for the test, let's - // check - // if browser should be started for @After // if @After method is annotated with @Browser tag, it might need to be executed with another // browser - if (browserConfiguration == null && !methodBrowserAnnotations.isEmpty()) + if (!methodBrowserAnnotations.isEmpty()) { browserConfiguration = MultibrowserConfiguration.getInstance().getBrowserProfiles() .get(methodBrowserAnnotations.get(0).value()); @@ -70,10 +68,13 @@ public void evaluate() throws Throwable // it means that we should use the same browser for cleanup // as the might have been other @After methods with new browser running previously, let's explicitly set // the driver to original - if (!startNewBrowserForCleanUp && !isSuppressed && (Neodymium.getDriver() == null || !Neodymium.getDriver().equals(oldDriver.getWebDriver()))) + if (!startNewBrowserForCleanUp && !isSuppressed && (Neodymium.getDriver() == null || !Neodymium.getDriver().equals(oldDriver.getWebDriver())) + && oldDriver != null) { WebDriverRunner.setWebDriver(oldDriver.getWebDriver()); Neodymium.setWebDriverStateContainer(oldDriver); + Neodymium.setBrowserProfileName(oldBrowserConfiguration.getConfigTag()); + Neodymium.setBrowserName(oldBrowserConfiguration.getCapabilities().getBrowserName()); } // if we need to start new browser for the clean up and any browser configuration for the @After method // was found, create a new driver @@ -88,6 +89,17 @@ else if (startNewBrowserForCleanUp && browserConfiguration != null) BrowserRunnerHelper.setBrowserWindowSize(browserConfiguration, wDSCont.getWebDriver()); WebDriverRunner.setWebDriver(wDSCont.getWebDriver()); Neodymium.setWebDriverStateContainer(wDSCont); + Neodymium.setBrowserProfileName(browserConfiguration.getConfigTag()); + Neodymium.setBrowserName(browserConfiguration.getCapabilities().getBrowserName()); + } + else if (!isSuppressed && browserConfiguration == null) + { + throw new RuntimeException("No browser setting for @After method '" + each.getName() + + "' was found. " + + "If browser was suppressed for the test and is also not required for the clean up," + + " please mark the @After method with @DontStartNewBrowserForCleanUp annotation." + + " If you need to start a browser for the clean up," + + " please, use @Browser annotaion to mention what browser should be used exactly for this @After."); } boolean afterFailed = false; try diff --git a/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunBefores.java b/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunBefores.java new file mode 100644 index 000000000..f380c0c1e --- /dev/null +++ b/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/BrowserRunBefores.java @@ -0,0 +1,173 @@ +package com.xceptance.neodymium.module.statement.browser.multibrowser; + +import java.util.List; + +import org.junit.internal.runners.statements.RunBefores; +import org.junit.runners.model.FrameworkMethod; +import org.junit.runners.model.Statement; +import org.openqa.selenium.WebDriver; +import org.openqa.selenium.support.events.EventFiringWebDriver; + +import com.browserup.bup.BrowserUpProxy; +import com.codeborne.selenide.WebDriverRunner; +import com.xceptance.neodymium.NeodymiumWebDriverListener; +import com.xceptance.neodymium.module.StatementBuilder; +import com.xceptance.neodymium.module.statement.browser.multibrowser.configuration.BrowserConfiguration; +import com.xceptance.neodymium.module.statement.browser.multibrowser.configuration.MultibrowserConfiguration; +import com.xceptance.neodymium.util.Neodymium; + +public class BrowserRunBefores extends RunBefores +{ + private final Statement next; + + private final List befores; + + public BrowserRunBefores(Statement next, List befores, Object target) + { + super(next, befores, target); + this.befores = befores; + this.next = next; + } + + @Override + public void evaluate() throws Throwable + { + WebDriverStateContainer oldWDsCont = Neodymium.getWebDriverStateContainer(); + BrowserConfiguration oldBrowserConfiguration = MultibrowserConfiguration.getInstance().getBrowserProfiles() + .get(Neodymium.getBrowserProfileName()); + for (FrameworkMethod before : befores) + { + boolean isSuppressed = isSuppressed(before); + boolean startNewBrowserForSetUp = shouldStartNewBrowser(before) && !isSuppressed; + BrowserConfiguration browserConfiguration = oldBrowserConfiguration; + + List methodBrowserAnnotations = StatementBuilder.getAnnotations(before.getMethod(), Browser.class); + + // if @Before method is annotated with @Browser tag, it might need to be executed with another + // browser + if (!methodBrowserAnnotations.isEmpty()) + { + browserConfiguration = MultibrowserConfiguration.getInstance().getBrowserProfiles() + .get(methodBrowserAnnotations.get(0).value()); + } + + // if we don't need to start new browser for the setup and the browser for the test was not suppressed + // it means that we should use the same browser for setup + // as the might have been other @Before methods with new browser running previously, let's explicitly set + // the driver to original + if (!startNewBrowserForSetUp && !isSuppressed && (Neodymium.getDriver() == null || !Neodymium.getDriver().equals(oldWDsCont.getWebDriver())) + && oldWDsCont != null) + { + WebDriverRunner.setWebDriver(oldWDsCont.getWebDriver()); + Neodymium.setWebDriverStateContainer(oldWDsCont); + Neodymium.setBrowserProfileName(oldBrowserConfiguration.getConfigTag()); + Neodymium.setBrowserName(oldBrowserConfiguration.getCapabilities().getBrowserName()); + } + + // if we need to start new browser for the set up and any browser configuration for the @Before method + // was found, create a new driver + else if (startNewBrowserForSetUp && browserConfiguration != null) + { + WebDriverStateContainer wDSCont = BrowserRunnerHelper.createWebDriverStateContainer(browserConfiguration); + + EventFiringWebDriver eFWDriver = new EventFiringWebDriver(wDSCont.getWebDriver()); + eFWDriver.register(new NeodymiumWebDriverListener()); + wDSCont.setWebDriver(eFWDriver); + + BrowserRunnerHelper.setBrowserWindowSize(browserConfiguration, wDSCont.getWebDriver()); + WebDriverRunner.setWebDriver(wDSCont.getWebDriver()); + Neodymium.setWebDriverStateContainer(wDSCont); + Neodymium.setBrowserProfileName(browserConfiguration.getConfigTag()); + Neodymium.setBrowserName(browserConfiguration.getCapabilities().getBrowserName()); + + } + else if (startNewBrowserForSetUp) + { + throw new RuntimeException("No browser setting for @Before method '" + before.getName() + + "' was found. " + + "If browser is suppressed for the test and is also not required for the set up," + + " please mark the @Before method with @DontStartNewBrowserForSetUp annotation." + + " If you need to start a browser for the set up," + + " please, use @Browser annotaion to mention what browser should be used exactly for this @Before."); + } + boolean beforeFailed = false; + try + { + invokeMethod(before); + } + catch (Throwable e) + { + beforeFailed = true; + throw e; + } + finally + { + // if we did a set up of new driver before the @Before method, we need to close it + if (startNewBrowserForSetUp && browserConfiguration != null) + { + // avoid closing driver in case it's selected to keep browser open + if (!(!browserConfiguration.isHeadless() + && ((Neodymium.configuration().keepBrowserOpenOnFailure() && beforeFailed) || Neodymium.configuration().keepBrowserOpen()))) + { + WebDriverStateContainer wdst = Neodymium.getWebDriverStateContainer(); + WebDriver driver = wdst != null ? wdst.getWebDriver() : null; + if (driver != null) + { + driver.quit(); + } + BrowserUpProxy proxy = wdst != null ? wdst.getProxy() : null; + if (proxy != null) + { + proxy.stop(); + } + Neodymium.setWebDriverStateContainer(null); + } + } + + // set driver back to the original to execute the test or clean up (in case of failure) + Neodymium.setWebDriverStateContainer(oldWDsCont); + if (oldBrowserConfiguration != null) + { + Neodymium.setBrowserProfileName(oldBrowserConfiguration.getConfigTag()); + Neodymium.setBrowserName(oldBrowserConfiguration.getCapabilities().getBrowserName()); + } + if (oldWDsCont != null && oldWDsCont.getWebDriver() != null) + { + WebDriverRunner.setWebDriver(oldWDsCont.getWebDriver()); + } + } + } + + next.evaluate(); + } + + private boolean shouldStartNewBrowser(FrameworkMethod each) + { + List methodStartNewBrowserForSetUp = StatementBuilder.getAnnotations(each.getMethod(), + DontStartNewBrowserForSetUp.class); + List classStartNewBrowserForSetUp = StatementBuilder.getAnnotations(each.getDeclaringClass(), + DontStartNewBrowserForSetUp.class); + + // if global config for dontStartNewBrowserForSetUp is set to false, we should not reach this point + boolean dontStartNewBrowserForSetUp = true; + if (!classStartNewBrowserForSetUp.isEmpty()) + { + dontStartNewBrowserForSetUp = false; + } + + if (!methodStartNewBrowserForSetUp.isEmpty()) + { + dontStartNewBrowserForSetUp = false; + } + + // if @Before method is annotated with @SuppressBrowser annotation, no new browser should be started + return dontStartNewBrowserForSetUp; + } + + private boolean isSuppressed(FrameworkMethod each) + { + List methodSuppressBrowserAnnotations = StatementBuilder.getAnnotations(each.getMethod(), SuppressBrowsers.class); + + return !methodSuppressBrowserAnnotations.isEmpty(); + } +} diff --git a/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/DontStartNewBrowserForSetUp.java b/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/DontStartNewBrowserForSetUp.java new file mode 100644 index 000000000..0edc458ed --- /dev/null +++ b/src/main/java/com/xceptance/neodymium/module/statement/browser/multibrowser/DontStartNewBrowserForSetUp.java @@ -0,0 +1,18 @@ +package com.xceptance.neodymium.module.statement.browser.multibrowser; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +@Retention(RUNTIME) +@Target( +{ + TYPE, METHOD +}) +public @interface DontStartNewBrowserForSetUp +{ + +} diff --git a/src/main/java/com/xceptance/neodymium/util/NeodymiumConfiguration.java b/src/main/java/com/xceptance/neodymium/util/NeodymiumConfiguration.java index 9cfa3e422..5e7f98040 100644 --- a/src/main/java/com/xceptance/neodymium/util/NeodymiumConfiguration.java +++ b/src/main/java/com/xceptance/neodymium/util/NeodymiumConfiguration.java @@ -231,6 +231,10 @@ public interface NeodymiumConfiguration extends Mutable @DefaultValue("-1") public int maxWebDriverReuse(); + @Key("neodymium.webDriver.startNewBrowserForSetUp") + @DefaultValue("true") + public boolean startNewBrowserForSetUp(); + @Key("neodymium.webDriver.startNewBrowserForCleanUp") @DefaultValue("true") public boolean startNewBrowserForCleanUp(); diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithBefore.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithBefore.java new file mode 100644 index 000000000..b7728284f --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithBefore.java @@ -0,0 +1,28 @@ +package com.xceptance.neodymium.testclasses.browser.classonly; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.SuppressBrowsers; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +@SuppressBrowsers +public class ClassBrowserSuppressedWithBefore +{ + @Before + public void before() + { + Assert.assertNull("Browser should not be started for cleanup", Neodymium.getDriver()); + } + + @Test + public void first() throws Exception + { + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/MethodBrowserSuppressedWithAfter.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/MethodBrowserSuppressedWithAfter.java new file mode 100644 index 000000000..fb901ecaa --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/MethodBrowserSuppressedWithAfter.java @@ -0,0 +1,28 @@ +package com.xceptance.neodymium.testclasses.browser.classonly; + +import org.junit.After; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.SuppressBrowsers; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +public class MethodBrowserSuppressedWithAfter +{ + @SuppressBrowsers + @Test + public void first() throws Exception + { + } + + @After + public void after() + { + Assert.assertNull("Browser should not be started for cleanup", Neodymium.getDriver()); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForCleanUp.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForCleanUp.java index 295106163..fba623592 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForCleanUp.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForCleanUp.java @@ -19,37 +19,53 @@ @Browser("chrome") public class NewBrowserIsNotStartedForCleanUp { - private static WebDriver webDriver1; + private static WebDriver webDriverTest; + + private static WebDriver webDriverAfter; + + private static WebDriver webDriverAfter1; @BeforeClass public static void beforeClass() { - Assert.assertNull(webDriver1); + Assert.assertNull(webDriverTest); Assert.assertNull(Neodymium.getDriver()); } @Test public void test1() { - webDriver1 = Neodymium.getDriver(); - Assert.assertEquals(webDriver1, Neodymium.getDriver()); + webDriverTest = Neodymium.getDriver(); + Assert.assertEquals(webDriverTest, Neodymium.getDriver()); } @After public void after() { - Assert.assertEquals(webDriver1, Neodymium.getDriver()); + webDriverAfter = Neodymium.getDriver(); + Assert.assertEquals(webDriverAfter, webDriverTest); + if (webDriverAfter1 != null) + { + Assert.assertEquals(webDriverAfter, webDriverAfter1); + } } @After public void after1() { - Assert.assertEquals(webDriver1, Neodymium.getDriver()); + webDriverAfter1 = Neodymium.getDriver(); + Assert.assertEquals(webDriverAfter1, webDriverTest); + if (webDriverAfter != null) + { + Assert.assertEquals(webDriverAfter, webDriverAfter1); + } } @AfterClass public static void afterClass() throws InterruptedException { - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverAfter); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverAfter1); } } diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForSetUp.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForSetUp.java new file mode 100644 index 000000000..afd5fb0d9 --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsNotStartedForSetUp.java @@ -0,0 +1,74 @@ +package com.xceptance.neodymium.testclasses.browser.classonly; + +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForSetUp; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@DontStartNewBrowserForSetUp +@Browser("chrome") +public class NewBrowserIsNotStartedForSetUp +{ + private static WebDriver webDriverBefore; + + private static WebDriver webDriverBefore1; + + private static WebDriver webDriverTest; + + @BeforeClass + public static void beforeClass() + { + Assert.assertNull(webDriverBefore); + Assert.assertNull(webDriverBefore1); + Assert.assertNull(webDriverTest); + Assert.assertNull(Neodymium.getDriver()); + } + + @Before + public void before() + { + NeodymiumWebDriverTest.assertWebDriverAlive(Neodymium.getDriver()); + if (webDriverBefore1 != null) + { + Assert.assertEquals(webDriverBefore1, Neodymium.getDriver()); + } + webDriverBefore = Neodymium.getDriver(); + } + + @Before + public void before1() + { + NeodymiumWebDriverTest.assertWebDriverAlive(Neodymium.getDriver()); + if (webDriverBefore != null) + { + Assert.assertEquals(webDriverBefore, Neodymium.getDriver()); + } + webDriverBefore1 = Neodymium.getDriver(); + } + + @Test + public void test1() + { + webDriverTest = Neodymium.getDriver(); + Assert.assertEquals(webDriverBefore, webDriverTest); + Assert.assertEquals(webDriverBefore1, webDriverTest); + } + + @AfterClass + public static void afterClass() throws InterruptedException + { + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBefore); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBefore1); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithAfter.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/methodonly/ClassBrowserSuppressedWithAfter.java similarity index 91% rename from src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithAfter.java rename to src/test/java/com/xceptance/neodymium/testclasses/browser/methodonly/ClassBrowserSuppressedWithAfter.java index a13c60fef..1739e57c1 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/ClassBrowserSuppressedWithAfter.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/methodonly/ClassBrowserSuppressedWithAfter.java @@ -1,4 +1,4 @@ -package com.xceptance.neodymium.testclasses.browser.classonly; +package com.xceptance.neodymium.testclasses.browser.methodonly; import org.junit.After; import org.junit.Assert; diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsStartedForCleanUp.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/methodonly/DontStartNewBrowserForOneOfTheAfters.java similarity index 65% rename from src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsStartedForCleanUp.java rename to src/test/java/com/xceptance/neodymium/testclasses/browser/methodonly/DontStartNewBrowserForOneOfTheAfters.java index 866d4351d..c10babbeb 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/browser/classonly/NewBrowserIsStartedForCleanUp.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/methodonly/DontStartNewBrowserForOneOfTheAfters.java @@ -1,4 +1,4 @@ -package com.xceptance.neodymium.testclasses.browser.classonly; +package com.xceptance.neodymium.testclasses.browser.methodonly; import org.junit.After; import org.junit.AfterClass; @@ -10,58 +10,50 @@ import com.xceptance.neodymium.NeodymiumRunner; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForCleanUp; import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; import com.xceptance.neodymium.util.Neodymium; @RunWith(NeodymiumRunner.class) @Browser("chrome") -public class NewBrowserIsStartedForCleanUp +public class DontStartNewBrowserForOneOfTheAfters { private static WebDriver webDriver1; private static WebDriver webDriver2; - private static WebDriver webDriver3; - @BeforeClass public static void beforeClass() { Assert.assertNull(webDriver1); - Assert.assertNull(webDriver2); - Assert.assertNull(webDriver3); Assert.assertNull(Neodymium.getDriver()); } @Test public void test1() { - Assert.assertNotNull(Neodymium.getDriver()); webDriver1 = Neodymium.getDriver(); Assert.assertEquals(webDriver1, Neodymium.getDriver()); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); } @After public void after() { - Assert.assertNotNull(Neodymium.getDriver()); Assert.assertNotEquals(webDriver1, Neodymium.getDriver()); webDriver2 = Neodymium.getDriver(); } @After + @DontStartNewBrowserForCleanUp public void after1() { - Assert.assertNotNull(Neodymium.getDriver()); - Assert.assertNotEquals(webDriver2, Neodymium.getDriver()); - webDriver3 = Neodymium.getDriver(); + Assert.assertEquals(webDriver1, Neodymium.getDriver()); } @AfterClass - public static void afterClass() + public static void afterClass() throws InterruptedException { NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); } } diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/methodonly/DontStartNewBrowserForOneOfTheBefores.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/methodonly/DontStartNewBrowserForOneOfTheBefores.java new file mode 100644 index 000000000..00d7289bb --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/methodonly/DontStartNewBrowserForOneOfTheBefores.java @@ -0,0 +1,64 @@ +package com.xceptance.neodymium.testclasses.browser.methodonly; + +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForSetUp; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +public class DontStartNewBrowserForOneOfTheBefores +{ + private static WebDriver webDriverTest; + + private static WebDriver webDriverBefore; + + private static WebDriver webDriverBefore1; + + @BeforeClass + public static void beforeClass() + { + Assert.assertNull(webDriverTest); + Assert.assertNull(Neodymium.getDriver()); + } + + @Before + public void after() + { + webDriverBefore = Neodymium.getDriver(); + Assert.assertNotEquals(webDriverBefore, webDriverBefore1); + } + + @Before + @DontStartNewBrowserForSetUp + public void after1() + { + webDriverBefore1 = Neodymium.getDriver(); + Assert.assertNotEquals(webDriverBefore, webDriverBefore1); + } + + @Test + public void test1() + { + webDriverTest = Neodymium.getDriver(); + Assert.assertEquals(webDriverTest, webDriverBefore1); + Assert.assertNotEquals(webDriverTest, webDriverBefore); + } + + @AfterClass + public static void afterClass() throws InterruptedException + { + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBefore); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBefore1); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedAfterWithBrowser.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedAfterWithBrowser.java index eaa2d38a0..c8b5f1740 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedAfterWithBrowser.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedAfterWithBrowser.java @@ -18,6 +18,7 @@ public class ClassBrowserSuppressedAfterWithBrowser @Test public void first() throws Exception { + Assert.assertNull("Browser should not be started for the test", Neodymium.getDriver()); } @After diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedBeforeWithBrowser.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedBeforeWithBrowser.java new file mode 100644 index 000000000..eed1458ed --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/ClassBrowserSuppressedBeforeWithBrowser.java @@ -0,0 +1,31 @@ +package com.xceptance.neodymium.testclasses.browser.mixed; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.SuppressBrowsers; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +@SuppressBrowsers +public class ClassBrowserSuppressedBeforeWithBrowser +{ + + @Before + @Browser("chrome") + public void before() + { + Assert.assertNotNull("Browser should be started for cleanup", Neodymium.getDriver()); + } + + @Test + public void first() throws Exception + { + Assert.assertNull("Browser should not be started for the test", Neodymium.getDriver()); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfCleanUps.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfCleanUps.java index f1ad7fdfb..7096f4de5 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfCleanUps.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfCleanUps.java @@ -39,17 +39,17 @@ public void test1() } @After - @DontStartNewBrowserForCleanUp public void after() { - Assert.assertEquals(webDriver1, Neodymium.getDriver()); + Assert.assertNotEquals(webDriver1, Neodymium.getDriver()); webDriver2 = Neodymium.getDriver(); } @After + @DontStartNewBrowserForCleanUp public void after1() { - Assert.assertNotEquals(webDriver1, Neodymium.getDriver()); + Assert.assertEquals(webDriver1, Neodymium.getDriver()); webDriver3 = Neodymium.getDriver(); } diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfSetUps.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfSetUps.java new file mode 100644 index 000000000..516a3da7c --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/NewBrowserIsNotStartedForOneOfSetUps.java @@ -0,0 +1,56 @@ +package com.xceptance.neodymium.testclasses.browser.mixed; + +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForSetUp; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +public class NewBrowserIsNotStartedForOneOfSetUps +{ + private static WebDriver webDriverTest; + + private static WebDriver webDriverBefore; + + private static WebDriver webDriverBefore1; + + @Before + public void before() + { + webDriverBefore = Neodymium.getDriver(); + Assert.assertNotEquals(webDriverBefore, webDriverBefore1); + } + + @Before + @DontStartNewBrowserForSetUp + public void before1() + { + webDriverBefore1 = Neodymium.getDriver(); + Assert.assertNotEquals(webDriverBefore, webDriverBefore1); + } + + @Test + public void test1() + { + webDriverTest = Neodymium.getDriver(); + Assert.assertEquals(webDriverTest, webDriverBefore1); + Assert.assertNotEquals(webDriverTest, webDriverBefore); + } + + @AfterClass + public static void afterClass() + { + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBefore); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBefore1); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/OverwriteBrowserForCleanUp.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/OverwriteBrowserForCleanUp.java new file mode 100644 index 000000000..66103eba9 --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/OverwriteBrowserForCleanUp.java @@ -0,0 +1,28 @@ +package com.xceptance.neodymium.testclasses.browser.mixed; + +import org.junit.After; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +public class OverwriteBrowserForCleanUp +{ + @Test + public void first() throws Exception + { + Assert.assertEquals("chrome", Neodymium.getBrowserProfileName()); + } + + @After + @Browser("Chrome_headless") + public void after() + { + Assert.assertEquals("Chrome_headless", Neodymium.getBrowserProfileName()); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/OverwriteBrowserForSetUp.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/OverwriteBrowserForSetUp.java new file mode 100644 index 000000000..4afc260e9 --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/OverwriteBrowserForSetUp.java @@ -0,0 +1,28 @@ +package com.xceptance.neodymium.testclasses.browser.mixed; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +public class OverwriteBrowserForSetUp +{ + @Before + @Browser("Chrome_headless") + public void before() + { + Assert.assertEquals("Chrome_headless", Neodymium.getBrowserProfileName()); + } + + @Test + public void first() throws Exception + { + Assert.assertEquals("chrome", Neodymium.getBrowserProfileName()); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForCleanUp.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForCleanUp.java index 629230e23..f02f56e46 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForCleanUp.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForCleanUp.java @@ -9,33 +9,49 @@ import com.xceptance.neodymium.NeodymiumRunner; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; -import com.xceptance.neodymium.module.statement.browser.multibrowser.SuppressBrowsers; import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; import com.xceptance.neodymium.util.Neodymium; @RunWith(NeodymiumRunner.class) -@SuppressBrowsers +@Browser("chrome") public class StartBrowserForCleanUp { - private static WebDriver webdriver; + private static WebDriver webdriverTest; + + private static WebDriver webdriverAfter; + + private static WebDriver webdriverAfter1; @Test public void first() throws Exception { - Assert.assertNull("Browser should not be started for the test", Neodymium.getDriver()); + Assert.assertNotNull("Browser should be started for the cleanup", Neodymium.getDriver()); + webdriverTest = Neodymium.getDriver(); } @After - @Browser("chrome") public void after() { Assert.assertNotNull("Browser should be started for the cleanup", Neodymium.getDriver()); - webdriver = Neodymium.getDriver(); + webdriverAfter = Neodymium.getDriver(); + Assert.assertNotEquals(webdriverTest, webdriverAfter); + Assert.assertNotEquals(webdriverAfter, webdriverAfter1); + } + + @After + public void after1() + { + Assert.assertNotNull("Browser should be started for the cleanup", Neodymium.getDriver()); + webdriverAfter1 = Neodymium.getDriver(); + Assert.assertNotEquals(webdriverTest, webdriverAfter1); + Assert.assertNotEquals(webdriverAfter, webdriverAfter1); } @AfterClass public static void afterClass() { - NeodymiumWebDriverTest.assertWebDriverClosed(webdriver); + NeodymiumWebDriverTest.assertWebDriverClosed(webdriverTest); + NeodymiumWebDriverTest.assertWebDriverClosed(webdriverAfter); + NeodymiumWebDriverTest.assertWebDriverClosed(webdriverAfter1); } } diff --git a/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForSetUp.java b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForSetUp.java new file mode 100644 index 000000000..a1b7da08e --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/browser/mixed/StartBrowserForSetUp.java @@ -0,0 +1,57 @@ +package com.xceptance.neodymium.testclasses.browser.mixed; + +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +@RunWith(NeodymiumRunner.class) +@Browser("chrome") +public class StartBrowserForSetUp +{ + private static WebDriver webdriverTest; + + private static WebDriver webdriverBefore; + + private static WebDriver webdriverBefore1; + + @Before + public void before() + { + Assert.assertNotNull("Browser should be started for the setup", Neodymium.getDriver()); + webdriverBefore = Neodymium.getDriver(); + Assert.assertNotEquals(webdriverBefore, webdriverBefore1); + } + + @Before + public void before1() + { + Assert.assertNotNull("Browser should be started for the setup", Neodymium.getDriver()); + webdriverBefore1 = Neodymium.getDriver(); + Assert.assertNotEquals(webdriverBefore, webdriverBefore1); + } + + @Test + public void first() throws Exception + { + Assert.assertNotNull("Browser should be started for the setup", Neodymium.getDriver()); + webdriverTest = Neodymium.getDriver(); + Assert.assertNotEquals(webdriverTest, webdriverBefore); + Assert.assertNotEquals(webdriverTest, webdriverBefore1); + } + + @AfterClass + public static void afterClass() + { + NeodymiumWebDriverTest.assertWebDriverClosed(webdriverTest); + NeodymiumWebDriverTest.assertWebDriverClosed(webdriverBefore); + NeodymiumWebDriverTest.assertWebDriverClosed(webdriverBefore1); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateClearReuseWebDriverCache.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateClearReuseWebDriverCache.java index d789c4b91..5b22da1ee 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateClearReuseWebDriverCache.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateClearReuseWebDriverCache.java @@ -17,6 +17,7 @@ import com.browserup.bup.BrowserUpProxy; import com.xceptance.neodymium.NeodymiumRunner; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForSetUp; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; import com.xceptance.neodymium.tests.NeodymiumTest; import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; @@ -33,6 +34,7 @@ * clear the cache * validate the cache is empty */ +@DontStartNewBrowserForSetUp @RunWith(NeodymiumRunner.class) public class ValidateClearReuseWebDriverCache { diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpen.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpen.java index 8f5b15cd4..e84c31948 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpen.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpen.java @@ -30,21 +30,29 @@ @RunWith(NeodymiumRunner.class) public class ValidateKeepWebDriverOpen { - private static WebDriver webDriver1; + private static WebDriver webDriverBeforeForTest1; - private static WebDriver webDriver2; + private static WebDriver webDriverBeforeForTest2; - private static WebDriver webDriver3; + private static WebDriver webDriverTest1; - private static WebDriver webDriver4; + private static WebDriver webDriverTest2; - private static BrowserUpProxy proxy1; + private static WebDriver webDriverAfterForTest1; - private static BrowserUpProxy proxy2; + private static WebDriver webDriverAfterForTest2; - private static BrowserUpProxy proxy3; + private static BrowserUpProxy proxyBeforeForTest1; - private static BrowserUpProxy proxy4; + private static BrowserUpProxy proxyBeforeForTest2; + + private static BrowserUpProxy proxyTest1; + + private static BrowserUpProxy proxyTest2; + + private static BrowserUpProxy proxyAfterForTest1; + + private static BrowserUpProxy proxyAfterForTest2; private static File tempConfigFile; @@ -59,94 +67,93 @@ public static void beforeClass() properties.put("neodymium.localproxy", "true"); NeodymiumTest.writeMapToPropertiesFile(properties, tempConfigFile); ConfigFactory.setProperty(Neodymium.TEMPORARY_CONFIG_FILE_PROPERTY_NAME, "file:" + fileLocation); - - Assert.assertNull(webDriver1); - Assert.assertNull(Neodymium.getDriver()); - - Assert.assertNull(proxy1); - Assert.assertNull(Neodymium.getLocalProxy()); } @Before public void before() { - if (webDriver1 == null) + if (webDriverAfterForTest1 == null) { - webDriver1 = Neodymium.getDriver(); - } - else if (webDriver2 == null) - { - webDriver2 = Neodymium.getDriver(); + webDriverBeforeForTest1 = Neodymium.getDriver(); + proxyBeforeForTest1 = Neodymium.getLocalProxy(); } else { - Assert.assertNotNull(Neodymium.getDriver()); - } - Assert.assertNotNull(webDriver1); - - if (proxy1 == null) - { - proxy1 = Neodymium.getLocalProxy(); - } - else if (proxy2 == null) - { - proxy2 = Neodymium.getLocalProxy(); + webDriverBeforeForTest2 = Neodymium.getDriver(); + proxyBeforeForTest2 = Neodymium.getLocalProxy(); } - else - { - Assert.assertNotNull(Neodymium.getLocalProxy()); - } - Assert.assertNotNull(proxy1); } @Test @Browser("Chrome_1024x768") public void test1() { - Assert.assertEquals(webDriver1, Neodymium.getDriver()); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); + webDriverTest1 = Neodymium.getDriver(); + Assert.assertNotEquals(webDriverBeforeForTest1, webDriverTest1); + Assert.assertNotEquals(webDriverBeforeForTest2, webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverBeforeForTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest1); + if (webDriverAfterForTest2 != null) + { + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverAfterForTest2); + } - Assert.assertEquals(proxy1, Neodymium.getLocalProxy()); - NeodymiumWebDriverTest.assertProxyAlive(proxy1); + proxyTest1 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(proxyBeforeForTest1, proxyTest1); + Assert.assertNotEquals(proxyBeforeForTest2, proxyTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyBeforeForTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest1); + if (proxyBeforeForTest2 != null) + { + NeodymiumWebDriverTest.assertProxyAlive(proxyBeforeForTest2); + } } @Test @Browser("Chrome_1024x768") public void test2() { - Assert.assertNotEquals(webDriver1, webDriver2); - Assert.assertEquals(webDriver2, Neodymium.getDriver()); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); - - Assert.assertNotEquals(proxy1, proxy2); - Assert.assertEquals(proxy2, Neodymium.getLocalProxy()); - NeodymiumWebDriverTest.assertProxyAlive(proxy1); - NeodymiumWebDriverTest.assertProxyAlive(proxy2); + webDriverTest2 = Neodymium.getDriver(); + Assert.assertNotEquals(webDriverBeforeForTest1, webDriverTest2); + Assert.assertNotEquals(webDriverBeforeForTest2, webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverBeforeForTest2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest2); + if (webDriverAfterForTest2 != null) + { + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverAfterForTest2); + } + + proxyTest2 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(proxyBeforeForTest1, proxyTest2); + Assert.assertNotEquals(proxyBeforeForTest2, proxyTest2); + NeodymiumWebDriverTest.assertProxyAlive(proxyBeforeForTest2); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest2); + if (proxyBeforeForTest2 != null) + { + NeodymiumWebDriverTest.assertProxyAlive(proxyBeforeForTest2); + } } @After public void after() { - if (webDriver2 == null) + if (webDriverTest2 == null) { - webDriver3 = Neodymium.getDriver(); - proxy3 = Neodymium.getLocalProxy(); - Assert.assertNotEquals(webDriver3, webDriver1); - Assert.assertNotEquals(webDriver3, webDriver2); - Assert.assertNotEquals(proxy3, proxy1); - Assert.assertNotEquals(proxy3, proxy2); + webDriverAfterForTest1 = Neodymium.getDriver(); + proxyAfterForTest1 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriverAfterForTest1, webDriverTest1); + Assert.assertNotEquals(proxyAfterForTest1, proxyTest1); } else { - webDriver4 = Neodymium.getDriver(); - proxy4 = Neodymium.getLocalProxy(); - Assert.assertNotEquals(webDriver4, webDriver1); - Assert.assertNotEquals(webDriver4, webDriver2); - Assert.assertNotEquals(webDriver4, webDriver3); - Assert.assertNotEquals(proxy4, proxy1); - Assert.assertNotEquals(proxy4, proxy2); - Assert.assertNotEquals(proxy4, proxy3); + webDriverAfterForTest2 = Neodymium.getDriver(); + proxyAfterForTest2 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriverAfterForTest1, webDriverTest1); + Assert.assertNotEquals(webDriverAfterForTest2, webDriverTest1); + Assert.assertNotEquals(webDriverAfterForTest2, webDriverTest2); + Assert.assertNotEquals(proxyAfterForTest1, proxyTest1); + Assert.assertNotEquals(proxyAfterForTest2, proxyTest1); + Assert.assertNotEquals(proxyAfterForTest2, proxyTest2); } NeodymiumWebDriverTest.assertWebDriverAlive(Neodymium.getDriver()); @@ -158,31 +165,47 @@ public static void afterClass() { Assert.assertEquals(0, WebDriverCache.instance.getWebDriverStateContainerCacheSize()); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver3); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver4); - webDriver1.quit(); - webDriver2.quit(); - webDriver3.quit(); - webDriver4.quit(); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver4); - - NeodymiumWebDriverTest.assertProxyAlive(proxy1); - NeodymiumWebDriverTest.assertProxyAlive(proxy2); - NeodymiumWebDriverTest.assertProxyAlive(proxy3); - NeodymiumWebDriverTest.assertProxyAlive(proxy4); - proxy1.stop(); - proxy2.stop(); - proxy3.stop(); - proxy4.stop(); - NeodymiumWebDriverTest.assertProxyStopped(proxy1); - NeodymiumWebDriverTest.assertProxyStopped(proxy2); - NeodymiumWebDriverTest.assertProxyStopped(proxy3); - NeodymiumWebDriverTest.assertProxyStopped(proxy4); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverBeforeForTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverBeforeForTest2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverAfterForTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverAfterForTest2); + + webDriverBeforeForTest1.quit(); + webDriverBeforeForTest2.quit(); + webDriverTest1.quit(); + webDriverTest2.quit(); + webDriverAfterForTest1.quit(); + webDriverAfterForTest2.quit(); + + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeForTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeForTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverAfterForTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverAfterForTest2); + + NeodymiumWebDriverTest.assertProxyAlive(proxyBeforeForTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyAfterForTest2); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest2); + NeodymiumWebDriverTest.assertProxyAlive(proxyAfterForTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyAfterForTest2); + + proxyBeforeForTest1.stop(); + proxyBeforeForTest2.stop(); + proxyTest1.stop(); + proxyTest2.stop(); + proxyAfterForTest1.stop(); + proxyAfterForTest2.stop(); + + NeodymiumWebDriverTest.assertProxyStopped(proxyBeforeForTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyAfterForTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyAfterForTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyAfterForTest2); NeodymiumTest.deleteTempFile(tempConfigFile); } diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailure.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailure.java index 068b8ddf2..7e9ab2c31 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailure.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailure.java @@ -7,7 +7,6 @@ import org.aeonbits.owner.ConfigFactory; import org.junit.AfterClass; import org.junit.Assert; -import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -62,66 +61,26 @@ public static void beforeClass() Assert.assertNull(Neodymium.getDriver()); } - @Before - public void before() - { - if (webDriver1 == null) - { - webDriver1 = Neodymium.getDriver(); - } - else if (webDriver2 == null) - { - webDriver2 = Neodymium.getDriver(); - } - else if (webDriver3 == null) - { - webDriver3 = Neodymium.getDriver(); - } - else - { - Assert.assertNotNull(Neodymium.getDriver()); - } - Assert.assertNotNull(webDriver1); - - if (proxy1 == null) - { - proxy1 = Neodymium.getLocalProxy(); - } - else if (proxy2 == null) - { - proxy2 = Neodymium.getLocalProxy(); - } - else if (proxy3 == null) - { - proxy3 = Neodymium.getLocalProxy(); - } - else - { - Assert.assertNotNull(Neodymium.getLocalProxy()); - } - Assert.assertNotNull(proxy1); - } - @Test public void test1() { - Assert.assertEquals(webDriver1, Neodymium.getDriver()); + webDriver1 = Neodymium.getDriver(); NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); - Assert.assertEquals(proxy1, Neodymium.getLocalProxy()); + proxy1 = Neodymium.getLocalProxy(); NeodymiumWebDriverTest.assertProxyAlive(proxy1); } @Test public void test2() { + webDriver2 = Neodymium.getDriver(); Assert.assertNotEquals(webDriver1, webDriver2); - Assert.assertEquals(webDriver2, Neodymium.getDriver()); NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); + proxy2 = Neodymium.getLocalProxy(); Assert.assertNotEquals(proxy1, proxy2); - Assert.assertEquals(proxy2, Neodymium.getLocalProxy()); NeodymiumWebDriverTest.assertProxyStopped(proxy1); NeodymiumWebDriverTest.assertProxyAlive(proxy2); @@ -132,18 +91,18 @@ public void test2() @Test public void test3() { + webDriver3 = Neodymium.getDriver(); Assert.assertNotEquals(webDriver1, webDriver2); Assert.assertNotEquals(webDriver2, webDriver3); Assert.assertNotEquals(webDriver1, webDriver3); - Assert.assertEquals(webDriver3, Neodymium.getDriver()); NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); NeodymiumWebDriverTest.assertWebDriverAlive(webDriver3); + proxy3 = Neodymium.getLocalProxy(); Assert.assertNotEquals(proxy1, proxy2); Assert.assertNotEquals(proxy2, proxy3); Assert.assertNotEquals(proxy1, proxy3); - Assert.assertEquals(proxy3, Neodymium.getLocalProxy()); NeodymiumWebDriverTest.assertProxyStopped(proxy1); NeodymiumWebDriverTest.assertProxyAlive(proxy2); NeodymiumWebDriverTest.assertProxyAlive(proxy3); diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInAfter.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInAfter.java index 1b7babb8b..148cdeba0 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInAfter.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInAfter.java @@ -8,7 +8,6 @@ import org.junit.After; import org.junit.AfterClass; import org.junit.Assert; -import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -31,23 +30,23 @@ */ @RunWith(NeodymiumRunner.class) @Browser("Chrome_1024x768") -public class ValidateKeepWebDriverOpenOnFailureInAfter +public class ValidateKeepWebDriverOpenOnFailureInAfter { - private static WebDriver webDriver1; + private static WebDriver webDriverTest1; - private static WebDriver webDriver2; + private static WebDriver webDriverTest2; - private static WebDriver webDriver3; + private static WebDriver webDriverAfterTest1; - private static WebDriver webDriver4; + private static WebDriver webDriverAfterTest2; - private static BrowserUpProxy proxy1; + private static BrowserUpProxy proxyTest1; - private static BrowserUpProxy proxy2; + private static BrowserUpProxy proxyTest2; - private static BrowserUpProxy proxy3; + private static BrowserUpProxy proxyAfterTest1; - private static BrowserUpProxy proxy4; + private static BrowserUpProxy proxyAfterTest2; private static File tempConfigFile; @@ -63,105 +62,73 @@ public static void beforeClass() NeodymiumTest.writeMapToPropertiesFile(properties, tempConfigFile); ConfigFactory.setProperty(Neodymium.TEMPORARY_CONFIG_FILE_PROPERTY_NAME, "file:" + fileLocation); - Assert.assertNull(webDriver1); + Assert.assertNull(webDriverTest1); Assert.assertNull(Neodymium.getDriver()); } - @Before - public void before() - { - if (webDriver1 == null) - { - webDriver1 = Neodymium.getDriver(); - } - else if (webDriver2 == null) - { - webDriver2 = Neodymium.getDriver(); - } - else - { - Assert.assertNotNull(Neodymium.getDriver()); - } - Assert.assertNotNull(webDriver1); - - if (proxy1 == null) - { - proxy1 = Neodymium.getLocalProxy(); - } - else if (proxy2 == null) - { - proxy2 = Neodymium.getLocalProxy(); - } - else - { - Assert.assertNotNull(Neodymium.getLocalProxy()); - } - Assert.assertNotNull(proxy1); - } - @Test public void test1() { - Assert.assertEquals(webDriver1, Neodymium.getDriver()); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); + webDriverTest1 = Neodymium.getDriver(); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest1); - Assert.assertEquals(proxy1, Neodymium.getLocalProxy()); - NeodymiumWebDriverTest.assertProxyAlive(proxy1); + proxyTest1 = Neodymium.getLocalProxy(); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest1); } @Test public void test2() { - Assert.assertNotEquals(webDriver1, webDriver2); - Assert.assertEquals(webDriver2, Neodymium.getDriver()); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); - - Assert.assertNotEquals(proxy1, proxy2); - Assert.assertEquals(proxy2, Neodymium.getLocalProxy()); - NeodymiumWebDriverTest.assertProxyStopped(proxy1); - NeodymiumWebDriverTest.assertProxyAlive(proxy2); + webDriverTest2 = Neodymium.getDriver(); + Assert.assertNotEquals(webDriverTest1, webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest2); + + proxyTest2 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(proxyTest1, proxyTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest2); } @After public void after() { - if (webDriver2 == null) + if (webDriverTest2 == null) { - webDriver3 = Neodymium.getDriver(); - proxy3 = Neodymium.getLocalProxy(); - Assert.assertNotEquals(webDriver1, webDriver3); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver3); + webDriverAfterTest1 = Neodymium.getDriver(); + proxyAfterTest1 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriverTest1, webDriverAfterTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverAfterTest1); } else { - webDriver4 = Neodymium.getDriver(); - proxy4 = Neodymium.getLocalProxy(); - Assert.assertNotEquals(webDriver2, webDriver4); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver4); + webDriverAfterTest2 = Neodymium.getDriver(); + proxyAfterTest2 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriverTest2, webDriverAfterTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverAfterTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverAfterTest2); } - if (proxy2 == null) + if (proxyTest2 == null) { - Assert.assertNotEquals(proxy1, proxy3); - Assert.assertEquals(proxy3, Neodymium.getLocalProxy()); - NeodymiumWebDriverTest.assertProxyAlive(proxy3); - Assert.assertNotEquals(proxy1, proxy3); + Assert.assertNotEquals(proxyTest1, proxyAfterTest1); + Assert.assertEquals(proxyAfterTest1, Neodymium.getLocalProxy()); + NeodymiumWebDriverTest.assertProxyAlive(proxyAfterTest1); + Assert.assertNotEquals(proxyTest1, proxyAfterTest1); } else { - NeodymiumWebDriverTest.assertProxyAlive(proxy2); - NeodymiumWebDriverTest.assertProxyAlive(proxy4); - NeodymiumWebDriverTest.assertProxyStopped(proxy1); - NeodymiumWebDriverTest.assertProxyStopped(proxy3); - - Assert.assertNotEquals(proxy2, proxy4); - Assert.assertNotEquals(proxy3, proxy4); - Assert.assertEquals(proxy4, Neodymium.getLocalProxy()); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest2); + NeodymiumWebDriverTest.assertProxyAlive(proxyAfterTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyAfterTest1); + + Assert.assertNotEquals(proxyTest2, proxyAfterTest2); + Assert.assertNotEquals(proxyAfterTest1, proxyAfterTest2); + Assert.assertEquals(proxyAfterTest2, Neodymium.getLocalProxy()); // Let condition fail so that the WebDriver/browser is kept open Selenide.$("#cantFindMe").should(Condition.exist); } @@ -172,23 +139,23 @@ public static void afterClass() { Assert.assertEquals(0, WebDriverCache.instance.getWebDriverStateContainerCacheSize()); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver4); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); - webDriver2.quit(); - webDriver4.quit(); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver4); - - NeodymiumWebDriverTest.assertProxyAlive(proxy2); - NeodymiumWebDriverTest.assertProxyAlive(proxy4); - NeodymiumWebDriverTest.assertProxyStopped(proxy3); - NeodymiumWebDriverTest.assertProxyStopped(proxy1); - proxy2.stop(); - proxy4.stop(); - NeodymiumWebDriverTest.assertProxyStopped(proxy2); - NeodymiumWebDriverTest.assertProxyStopped(proxy4); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverAfterTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverAfterTest1); + webDriverTest2.quit(); + webDriverAfterTest2.quit(); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverAfterTest2); + + NeodymiumWebDriverTest.assertProxyAlive(proxyTest2); + NeodymiumWebDriverTest.assertProxyAlive(proxyAfterTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyAfterTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest1); + proxyTest2.stop(); + proxyAfterTest2.stop(); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyAfterTest2); NeodymiumTest.deleteTempFile(tempConfigFile); } diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInBefore.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInBefore.java new file mode 100644 index 000000000..448de6894 --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureInBefore.java @@ -0,0 +1,151 @@ +package com.xceptance.neodymium.testclasses.webDriver; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; + +import org.aeonbits.owner.ConfigFactory; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.browserup.bup.BrowserUpProxy; +import com.codeborne.selenide.Condition; +import com.codeborne.selenide.Selenide; +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForCleanUp; +import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; +import com.xceptance.neodymium.tests.NeodymiumTest; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +/* + * Validate that the web driver is kept open after an error occurred. + * Validate that the web driver is not reused. + * Attention: this test needs to use browsers that are not headless. + */ +@DontStartNewBrowserForCleanUp +@RunWith(NeodymiumRunner.class) +@Browser("Chrome_1024x768") +public class ValidateKeepWebDriverOpenOnFailureInBefore +{ + private static WebDriver webDriverTest1; + + private static WebDriver webDriverTest2; + + private static WebDriver webDriverBeforeTest1; + + private static WebDriver webDriverBeforeTest2; + + private static BrowserUpProxy proxyTest1; + + private static BrowserUpProxy proxyTest2; + + private static BrowserUpProxy proxyBeforeTest1; + + private static BrowserUpProxy proxyBeforeTest2; + + private static File tempConfigFile; + + @BeforeClass + public static void beforeClass() + { + // set up a temporary neodymium.properties + final String fileLocation = "config/temp-ValidateKeepWebDriverOpenOnFailure-neodymium.properties"; + tempConfigFile = new File("./" + fileLocation); + Map properties = new HashMap<>(); + properties.put("neodymium.webDriver.keepBrowserOpenOnFailure", "true"); + properties.put("neodymium.localproxy", "true"); + NeodymiumTest.writeMapToPropertiesFile(properties, tempConfigFile); + ConfigFactory.setProperty(Neodymium.TEMPORARY_CONFIG_FILE_PROPERTY_NAME, "file:" + fileLocation); + + Assert.assertNull(webDriverTest1); + Assert.assertNull(Neodymium.getDriver()); + } + + @Before + public void before() + { + if (webDriverBeforeTest1 == null) + { + webDriverBeforeTest1 = Neodymium.getDriver(); + proxyBeforeTest1 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriverTest1, webDriverBeforeTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverBeforeTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyBeforeTest1); + } + else + { + webDriverBeforeTest2 = Neodymium.getDriver(); + proxyBeforeTest2 = Neodymium.getLocalProxy(); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverBeforeTest2); + + NeodymiumWebDriverTest.assertProxyStopped(proxyBeforeTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyBeforeTest2); + Assert.assertNotEquals(proxyBeforeTest1, proxyBeforeTest2); + + // Let condition fail so that the WebDriver/browser is kept open + Selenide.$("#cantFindMe").should(Condition.exist); + } + } + + @Test + public void test1() + { + webDriverTest1 = Neodymium.getDriver(); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeTest1); + Assert.assertNotEquals(webDriverTest1, webDriverBeforeTest1); + + proxyTest1 = Neodymium.getLocalProxy(); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyBeforeTest1); + Assert.assertNotEquals(proxyTest1, proxyBeforeTest1); + } + + @Test + public void test2() + { + webDriverTest2 = Neodymium.getDriver(); + Assert.fail("this test should not be executed due to failure in @Before"); + } + + @After + public void closeDriverForNotStartedTest2() + { + if (webDriverBeforeTest2 != null) + { + Neodymium.getDriver().quit(); + Neodymium.getLocalProxy().stop(); + } + } + + @AfterClass + public static void afterClass() + { + Assert.assertEquals(0, WebDriverCache.instance.getWebDriverStateContainerCacheSize()); + + Assert.assertNull("test2 should not be started due to failure in @Before ", webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverBeforeTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeTest1); + webDriverBeforeTest2.quit(); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeTest2); + + Assert.assertNull("test2 should not be started due to failure in @Before ", proxyTest2); + NeodymiumWebDriverTest.assertProxyAlive(proxyBeforeTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyBeforeTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest1); + proxyBeforeTest2.stop(); + NeodymiumWebDriverTest.assertProxyStopped(proxyBeforeTest2); + + NeodymiumTest.deleteTempFile(tempConfigFile); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithAfter.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithAfter.java index d57b8e14d..1deba4ca8 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithAfter.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithAfter.java @@ -8,7 +8,6 @@ import org.junit.After; import org.junit.AfterClass; import org.junit.Assert; -import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -33,21 +32,21 @@ @Browser("Chrome_1024x768") public class ValidateKeepWebDriverOpenOnFailureWithAfter { - private static WebDriver webDriver1; + private static WebDriver webDriverTest1; - private static WebDriver webDriver2; + private static WebDriver webDriverTest2; - private static WebDriver webDriver3; + private static WebDriver webDriverAfterForTest1; - private static WebDriver webDriver4; + private static WebDriver webDriverAfterForTest2; - private static BrowserUpProxy proxy1; + private static BrowserUpProxy proxyTest1; - private static BrowserUpProxy proxy2; + private static BrowserUpProxy proxyTest2; - private static BrowserUpProxy proxy3; + private static BrowserUpProxy proxyAfterForTest1; - private static BrowserUpProxy proxy4; + private static BrowserUpProxy proxyAfterForTest2; private static File tempConfigFile; @@ -63,64 +62,32 @@ public static void beforeClass() NeodymiumTest.writeMapToPropertiesFile(properties, tempConfigFile); ConfigFactory.setProperty(Neodymium.TEMPORARY_CONFIG_FILE_PROPERTY_NAME, "file:" + fileLocation); - Assert.assertNull(webDriver1); + Assert.assertNull(webDriverTest1); Assert.assertNull(Neodymium.getDriver()); } - @Before - public void before() - { - if (webDriver1 == null) - { - webDriver1 = Neodymium.getDriver(); - } - else if (webDriver2 == null) - { - webDriver2 = Neodymium.getDriver(); - } - else - { - Assert.assertNotNull(Neodymium.getDriver()); - } - Assert.assertNotNull(webDriver1); - - if (proxy1 == null) - { - proxy1 = Neodymium.getLocalProxy(); - } - else if (proxy2 == null) - { - proxy2 = Neodymium.getLocalProxy(); - } - else - { - Assert.assertNotNull(Neodymium.getLocalProxy()); - } - Assert.assertNotNull(proxy1); - } - @Test public void test1() { - Assert.assertEquals(webDriver1, Neodymium.getDriver()); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); + webDriverTest1 = Neodymium.getDriver(); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest1); - Assert.assertEquals(proxy1, Neodymium.getLocalProxy()); - NeodymiumWebDriverTest.assertProxyAlive(proxy1); + proxyTest1 = Neodymium.getLocalProxy(); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest1); } @Test public void test2() { - Assert.assertNotEquals(webDriver1, webDriver2); - Assert.assertEquals(webDriver2, Neodymium.getDriver()); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); + webDriverTest2 = Neodymium.getDriver(); + Assert.assertNotEquals(webDriverTest1, webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest2); - Assert.assertNotEquals(proxy1, proxy2); - Assert.assertEquals(proxy2, Neodymium.getLocalProxy()); - NeodymiumWebDriverTest.assertProxyStopped(proxy1); - NeodymiumWebDriverTest.assertProxyAlive(proxy2); + proxyTest2 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(proxyTest1, proxyTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest2); // Let condition fail so that the WebDriver/browser is kept open Selenide.$("#cantFindMe").should(Condition.exist); @@ -129,40 +96,40 @@ public void test2() @After public void after() { - if (webDriver2 == null) + if (webDriverTest2 == null) { - webDriver3 = Neodymium.getDriver(); - proxy3 = Neodymium.getLocalProxy(); - Assert.assertNotEquals(webDriver1, webDriver3); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver3); + webDriverAfterForTest1 = Neodymium.getDriver(); + proxyAfterForTest1 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriverTest1, webDriverAfterForTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverAfterForTest1); } else { - webDriver4 = Neodymium.getDriver(); - proxy4 = Neodymium.getLocalProxy(); - Assert.assertNotEquals(webDriver2, webDriver4); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver4); + webDriverAfterForTest2 = Neodymium.getDriver(); + proxyAfterForTest2 = Neodymium.getLocalProxy(); + Assert.assertNotEquals(webDriverTest2, webDriverAfterForTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverAfterForTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverAfterForTest2); } - if (proxy2 == null) + if (proxyTest2 == null) { - Assert.assertNotEquals(proxy1, proxy3); - Assert.assertEquals(proxy3, Neodymium.getLocalProxy()); - NeodymiumWebDriverTest.assertProxyAlive(proxy3); + Assert.assertNotEquals(proxyTest1, proxyAfterForTest1); + Assert.assertEquals(proxyAfterForTest1, Neodymium.getLocalProxy()); + NeodymiumWebDriverTest.assertProxyAlive(proxyAfterForTest1); } else { - NeodymiumWebDriverTest.assertProxyAlive(proxy2); - NeodymiumWebDriverTest.assertProxyAlive(proxy4); - NeodymiumWebDriverTest.assertProxyStopped(proxy1); - NeodymiumWebDriverTest.assertProxyStopped(proxy3); - - Assert.assertNotEquals(proxy2, proxy4); - Assert.assertNotEquals(proxy3, proxy4); - Assert.assertEquals(proxy4, Neodymium.getLocalProxy()); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest2); + NeodymiumWebDriverTest.assertProxyAlive(proxyAfterForTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyAfterForTest1); + + Assert.assertNotEquals(proxyTest2, proxyAfterForTest2); + Assert.assertNotEquals(proxyAfterForTest1, proxyAfterForTest2); + Assert.assertEquals(proxyAfterForTest2, Neodymium.getLocalProxy()); } } @@ -171,17 +138,17 @@ public static void afterClass() { Assert.assertEquals(0, WebDriverCache.instance.getWebDriverStateContainerCacheSize()); - NeodymiumWebDriverTest.assertWebDriverAlive(webDriver2); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver4); - webDriver2.quit(); - NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); - - NeodymiumWebDriverTest.assertProxyAlive(proxy2); - NeodymiumWebDriverTest.assertProxyStopped(proxy3); - NeodymiumWebDriverTest.assertProxyStopped(proxy1); - proxy2.stop(); - NeodymiumWebDriverTest.assertProxyStopped(proxy2); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverAfterForTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverAfterForTest2); + webDriverTest2.quit(); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest2); + + NeodymiumWebDriverTest.assertProxyAlive(proxyTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyAfterForTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest1); + proxyTest2.stop(); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest2); NeodymiumTest.deleteTempFile(tempConfigFile); } diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithBefore.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithBefore.java new file mode 100644 index 000000000..8b8a10993 --- /dev/null +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateKeepWebDriverOpenOnFailureWithBefore.java @@ -0,0 +1,153 @@ +package com.xceptance.neodymium.testclasses.webDriver; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; + +import org.aeonbits.owner.ConfigFactory; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openqa.selenium.WebDriver; + +import com.browserup.bup.BrowserUpProxy; +import com.codeborne.selenide.Condition; +import com.codeborne.selenide.Selenide; +import com.xceptance.neodymium.NeodymiumRunner; +import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; +import com.xceptance.neodymium.tests.NeodymiumTest; +import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; +import com.xceptance.neodymium.util.Neodymium; + +/* + * Validate that the web driver is kept open after an error occurred. + * Validate that the web driver is not reused. + * Attention: this test needs to use browsers that are not headless. + */ +@RunWith(NeodymiumRunner.class) +@Browser("Chrome_1024x768") +public class ValidateKeepWebDriverOpenOnFailureWithBefore +{ + private static WebDriver webDriverTest1; + + private static WebDriver webDriverTest2; + + private static WebDriver webDriverBeforeForTest1; + + private static WebDriver webDriverBeforeForTest2; + + private static BrowserUpProxy proxyTest1; + + private static BrowserUpProxy proxyTest2; + + private static BrowserUpProxy proxyBeforeForTest1; + + private static BrowserUpProxy proxyBeforeForTest2; + + private static File tempConfigFile; + + @BeforeClass + public static void beforeClass() + { + // set up a temporary neodymium.properties + final String fileLocation = "config/temp-ValidateKeepWebDriverOpenOnFailure-neodymium.properties"; + tempConfigFile = new File("./" + fileLocation); + Map properties = new HashMap<>(); + properties.put("neodymium.webDriver.keepBrowserOpenOnFailure", "true"); + properties.put("neodymium.localproxy", "true"); + NeodymiumTest.writeMapToPropertiesFile(properties, tempConfigFile); + ConfigFactory.setProperty(Neodymium.TEMPORARY_CONFIG_FILE_PROPERTY_NAME, "file:" + fileLocation); + + Assert.assertNull(webDriverTest1); + Assert.assertNull(Neodymium.getDriver()); + } + + @Before + public void before() + { + if (webDriverBeforeForTest1 == null) + { + webDriverBeforeForTest1 = Neodymium.getDriver(); + proxyBeforeForTest1 = Neodymium.getLocalProxy(); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverBeforeForTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyBeforeForTest1); + } + else + { + webDriverBeforeForTest2 = Neodymium.getDriver(); + proxyBeforeForTest2 = Neodymium.getLocalProxy(); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeForTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverBeforeForTest2); + + NeodymiumWebDriverTest.assertProxyStopped(proxyBeforeForTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest1); + NeodymiumWebDriverTest.assertProxyAlive(proxyBeforeForTest2); + } + } + + @Test + public void test1() + { + webDriverTest1 = Neodymium.getDriver(); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeForTest1); + Assert.assertNotEquals(webDriverTest1, webDriverTest2); + Assert.assertNotEquals(webDriverTest1, webDriverBeforeForTest2); + Assert.assertNotEquals(webDriverTest1, webDriverBeforeForTest1); + + proxyTest1 = Neodymium.getLocalProxy(); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyBeforeForTest1); + Assert.assertNotEquals(proxyTest1, proxyTest2); + Assert.assertNotEquals(proxyTest1, proxyBeforeForTest2); + Assert.assertNotEquals(proxyTest1, proxyBeforeForTest1); + } + + @Test + public void test2() + { + webDriverTest2 = Neodymium.getDriver(); + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeForTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeForTest2); + Assert.assertNotEquals(webDriverTest1, webDriverTest2); + Assert.assertNotEquals(webDriverTest1, webDriverBeforeForTest2); + Assert.assertNotEquals(webDriverTest1, webDriverBeforeForTest1); + + proxyTest2 = Neodymium.getLocalProxy(); + NeodymiumWebDriverTest.assertProxyAlive(proxyTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyBeforeForTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyBeforeForTest2); + Assert.assertNotEquals(proxyTest1, proxyTest2); + Assert.assertNotEquals(proxyTest1, proxyBeforeForTest2); + Assert.assertNotEquals(proxyTest1, proxyBeforeForTest1); + + // Let condition fail so that the WebDriver/browser is kept open + Selenide.$("#cantFindMe").should(Condition.exist); + } + + @AfterClass + public static void afterClass() + { + Assert.assertEquals(0, WebDriverCache.instance.getWebDriverStateContainerCacheSize()); + + NeodymiumWebDriverTest.assertWebDriverAlive(webDriverTest2); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeForTest1); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverBeforeForTest2); + webDriverTest2.quit(); + NeodymiumWebDriverTest.assertWebDriverClosed(webDriverTest2); + + NeodymiumWebDriverTest.assertProxyAlive(proxyTest2); + NeodymiumWebDriverTest.assertProxyStopped(proxyBeforeForTest1); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest1); + proxyTest2.stop(); + NeodymiumWebDriverTest.assertProxyStopped(proxyTest2); + + NeodymiumTest.deleteTempFile(tempConfigFile); + } +} diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidatePreventReuseWebDriver.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidatePreventReuseWebDriver.java index 44a5d41c4..22e0069f6 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidatePreventReuseWebDriver.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidatePreventReuseWebDriver.java @@ -18,6 +18,7 @@ import com.xceptance.neodymium.NeodymiumRunner; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForCleanUp; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForSetUp; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; import com.xceptance.neodymium.tests.NeodymiumTest; import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; @@ -28,6 +29,7 @@ * Validate that the reuse of a web driver could be prevented programmatically. * Validate that the other web driver is not reused. */ +@DontStartNewBrowserForSetUp @DontStartNewBrowserForCleanUp @RunWith(NeodymiumRunner.class) public class ValidatePreventReuseWebDriver diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateReuseWebDriver.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateReuseWebDriver.java index 3139ec57e..3117b4c8f 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateReuseWebDriver.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateReuseWebDriver.java @@ -17,6 +17,7 @@ import com.browserup.bup.BrowserUpProxy; import com.xceptance.neodymium.NeodymiumRunner; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForSetUp; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverStateContainer; import com.xceptance.neodymium.tests.NeodymiumTest; @@ -27,6 +28,7 @@ * Validate that a web driver can be reused. * This is the minimal test setup for this feature. */ +@DontStartNewBrowserForSetUp @RunWith(NeodymiumRunner.class) public class ValidateReuseWebDriver { diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverClosed.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverClosed.java index 8571be980..a3b5ecad3 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverClosed.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverClosed.java @@ -17,6 +17,7 @@ import com.browserup.bup.BrowserUpProxy; import com.xceptance.neodymium.NeodymiumRunner; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForSetUp; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; import com.xceptance.neodymium.tests.NeodymiumTest; import com.xceptance.neodymium.tests.NeodymiumWebDriverTest; @@ -26,6 +27,7 @@ * Validate that web driver instances are closed after the test finished. * Validate that the web driver is not reused. */ +@DontStartNewBrowserForSetUp @RunWith(NeodymiumRunner.class) public class ValidateWebDriverClosed { diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverMaxReuse.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverMaxReuse.java index 907f83551..6805f49bb 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverMaxReuse.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverMaxReuse.java @@ -15,6 +15,7 @@ import com.xceptance.neodymium.NeodymiumRunner; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForSetUp; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverStateContainer; import com.xceptance.neodymium.tests.NeodymiumTest; @@ -24,6 +25,7 @@ /* * Validate that web driver instances are reused once and closed after their second use within a test function is finished. */ +@DontStartNewBrowserForSetUp @RunWith(NeodymiumRunner.class) public class ValidateWebDriverMaxReuse { diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverMaxReuseWithTwoWebDrivers.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverMaxReuseWithTwoWebDrivers.java index b601fdacd..a02e5aac7 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverMaxReuseWithTwoWebDrivers.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverMaxReuseWithTwoWebDrivers.java @@ -16,6 +16,7 @@ import com.browserup.bup.BrowserUpProxy; import com.xceptance.neodymium.NeodymiumRunner; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForSetUp; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverStateContainer; import com.xceptance.neodymium.tests.NeodymiumTest; @@ -25,6 +26,7 @@ /* * Validate that the reuse feature still works when there is more then one browser state within the cache. */ +@DontStartNewBrowserForSetUp @RunWith(NeodymiumRunner.class) public class ValidateWebDriverMaxReuseWithTwoWebDrivers { diff --git a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverReuseCounter.java b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverReuseCounter.java index f55539bc7..41e45f91d 100644 --- a/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverReuseCounter.java +++ b/src/test/java/com/xceptance/neodymium/testclasses/webDriver/ValidateWebDriverReuseCounter.java @@ -16,6 +16,7 @@ import com.browserup.bup.BrowserUpProxy; import com.xceptance.neodymium.NeodymiumRunner; import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; +import com.xceptance.neodymium.module.statement.browser.multibrowser.DontStartNewBrowserForSetUp; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverCache; import com.xceptance.neodymium.module.statement.browser.multibrowser.WebDriverStateContainer; import com.xceptance.neodymium.tests.NeodymiumTest; @@ -25,6 +26,7 @@ /* * Validate that the reuse of a web driver is counted correctly. */ +@DontStartNewBrowserForSetUp @RunWith(NeodymiumRunner.class) public class ValidateWebDriverReuseCounter { diff --git a/src/test/java/com/xceptance/neodymium/tests/BrowserStatementTest.java b/src/test/java/com/xceptance/neodymium/tests/BrowserStatementTest.java index 270e75c1a..43138d46a 100644 --- a/src/test/java/com/xceptance/neodymium/tests/BrowserStatementTest.java +++ b/src/test/java/com/xceptance/neodymium/tests/BrowserStatementTest.java @@ -27,24 +27,32 @@ import com.xceptance.neodymium.testclasses.browser.RandomBrowsersMethodInitialisationException; import com.xceptance.neodymium.testclasses.browser.classonly.ClassBrowserSuppressed; import com.xceptance.neodymium.testclasses.browser.classonly.ClassBrowserSuppressedNoBrowserAnnotation; -import com.xceptance.neodymium.testclasses.browser.classonly.ClassBrowserSuppressedWithAfter; +import com.xceptance.neodymium.testclasses.browser.classonly.ClassBrowserSuppressedWithBefore; +import com.xceptance.neodymium.testclasses.browser.classonly.MethodBrowserSuppressedWithAfter; import com.xceptance.neodymium.testclasses.browser.classonly.NewBrowserIsNotStartedForCleanUp; -import com.xceptance.neodymium.testclasses.browser.classonly.NewBrowserIsStartedForCleanUp; +import com.xceptance.neodymium.testclasses.browser.classonly.NewBrowserIsNotStartedForSetUp; import com.xceptance.neodymium.testclasses.browser.classonly.OneClassBrowserOneMethod; import com.xceptance.neodymium.testclasses.browser.classonly.RandomBrowserClassLevel; import com.xceptance.neodymium.testclasses.browser.classonly.TwoClassBrowserOneMethod; import com.xceptance.neodymium.testclasses.browser.classonly.TwoSameClassBrowserOneMethod; import com.xceptance.neodymium.testclasses.browser.inheritance.RandomBrowsersChild; import com.xceptance.neodymium.testclasses.browser.inheritance.RandomBrowsersOverwritingChild; +import com.xceptance.neodymium.testclasses.browser.methodonly.DontStartNewBrowserForOneOfTheAfters; +import com.xceptance.neodymium.testclasses.browser.methodonly.DontStartNewBrowserForOneOfTheBefores; import com.xceptance.neodymium.testclasses.browser.methodonly.MethodBrowserSuppressNoBrowserAnnotation; import com.xceptance.neodymium.testclasses.browser.methodonly.OneBrowserOneMethodBrowserSuppressed; import com.xceptance.neodymium.testclasses.browser.methodonly.RandomBrowserMethodLevel; import com.xceptance.neodymium.testclasses.browser.mixed.ClassAndMethodSameBrowserOneMethod; import com.xceptance.neodymium.testclasses.browser.mixed.ClassBrowserSuppressedAfterWithBrowser; +import com.xceptance.neodymium.testclasses.browser.mixed.ClassBrowserSuppressedBeforeWithBrowser; import com.xceptance.neodymium.testclasses.browser.mixed.MethodBrowserAnnotationOverwritesClassRandomBrowser; import com.xceptance.neodymium.testclasses.browser.mixed.NewBrowserIsNotStartedForOneOfCleanUps; +import com.xceptance.neodymium.testclasses.browser.mixed.NewBrowserIsNotStartedForOneOfSetUps; +import com.xceptance.neodymium.testclasses.browser.mixed.OverwriteBrowserForCleanUp; +import com.xceptance.neodymium.testclasses.browser.mixed.OverwriteBrowserForSetUp; import com.xceptance.neodymium.testclasses.browser.mixed.RandomBrowserMixed; import com.xceptance.neodymium.testclasses.browser.mixed.StartBrowserForCleanUp; +import com.xceptance.neodymium.testclasses.browser.mixed.StartBrowserForSetUp; import com.xceptance.neodymium.util.Neodymium; public class BrowserStatementTest extends NeodymiumTest @@ -190,26 +198,82 @@ public void testRandomBrowsersClassInitialisationException() } @Test - public void testStartBrowserForCleanUp() + public void testStartBrowserForSetUp() + { + // by default, new browser is started for each @Before + Result result = JUnitCore.runClasses(StartBrowserForSetUp.class); + checkPass(result, 1, 0); + } + + @Test + public void testNewBrowserIsNotStartedForOneOfSetUps() { // by default, new browser is started for each @After - Result result = JUnitCore.runClasses(StartBrowserForCleanUp.class); + Result result = JUnitCore.runClasses(NewBrowserIsNotStartedForOneOfSetUps.class); checkPass(result, 1, 0); } @Test - public void testNewBrowserIsNotStartedForOneOfCleanUps() + public void testNewBrowserIsNotStartedForSetUp() + { + // if test class is annotated with @@StartNewBrowserForCleanUp(false), no new browser is started for cleanup + Result result = JUnitCore.runClasses(NewBrowserIsNotStartedForSetUp.class); + checkPass(result, 1, 0); + } + + @Test + public void testClassBrowserSuppressedWithBefore() + { + // if test class, marked to run without browser but it's not marked that no new browser should be started for + // @After method, Runtime Exception should be thrown + Result result = JUnitCore.runClasses(ClassBrowserSuppressedWithBefore.class); + checkFail(result, 1, 0, 1, + "No browser setting for @Before method 'before' was found." + + " If browser is suppressed for the test and is also not required for the set up," + + " please mark the @Before method with @DontStartNewBrowserForSetUp annotation." + + " If you need to start a browser for the set up, please," + + " use @Browser annotaion to mention what browser should be used exactly for this @Before."); + } + + @Test + public void testDontStartNewBrowserForOneOfTheBefores() + { + // if test class, marked to run without browser but it's not marked that no new browser should be started for + // @After method, Runtime Exception should be thrown + Result result = JUnitCore.runClasses(DontStartNewBrowserForOneOfTheBefores.class); + checkPass(result, 1, 0); + } + + @Test + public void testClassBrowserSuppressedBeforeWithBrowser() + { + // although test class is marked to be run without browser, if @After method is annotated with @Browser, the + // browser should be started for clean up + Result result = JUnitCore.runClasses(ClassBrowserSuppressedBeforeWithBrowser.class); + checkPass(result, 1, 0); + } + + @Test + public void testOverwriteBrowserForSetUp() + { + // it should be possible to use different browser profle for clean up (using @Browser annotation) + Result result = JUnitCore.runClasses(OverwriteBrowserForSetUp.class); + checkPass(result, 1, 0); + } + + @Test + public void testStartBrowserForCleanUp() { // by default, new browser is started for each @After - Result result = JUnitCore.runClasses(NewBrowserIsNotStartedForOneOfCleanUps.class); + Result result = JUnitCore.runClasses(StartBrowserForCleanUp.class); checkPass(result, 1, 0); } @Test - public void testNewBrowserIsStartedForCleanUp() + public void testNewBrowserIsNotStartedForOneOfCleanUps() { // by default, new browser is started for each @After - Result result = JUnitCore.runClasses(NewBrowserIsStartedForCleanUp.class); + Result result = JUnitCore.runClasses(NewBrowserIsNotStartedForOneOfCleanUps.class); checkPass(result, 1, 0); } @@ -224,8 +288,22 @@ public void testNewBrowserIsNotStartedForCleanUp() @Test public void testSupressBrowserWithAfter() { - // if test class, marked to run without browser, it should not be started for clean up - Result result = JUnitCore.runClasses(ClassBrowserSuppressedWithAfter.class); + // if test class, marked to run without browser but it's not marked that no new browser should be started for + // @After method, Runtime Exception should be thrown + Result result = JUnitCore.runClasses(MethodBrowserSuppressedWithAfter.class); + checkFail(result, 1, 0, 1, "No browser setting for @After method 'after' was found. " + + "If browser was suppressed for the test and is also not required for the clean up," + + " please mark the @After method with @DontStartNewBrowserForCleanUp annotation." + + " If you need to start a browser for the clean up," + + " please, use @Browser annotaion to mention what browser should be used exactly for this @After."); + } + + @Test + public void testDontStartNewBrowserForOneOfTheAfters() + { + // if test class, marked to run without browser but it's not marked that no new browser should be started for + // @After method, Runtime Exception should be thrown + Result result = JUnitCore.runClasses(DontStartNewBrowserForOneOfTheAfters.class); checkPass(result, 1, 0); } @@ -238,6 +316,14 @@ public void testClassBrowserSuppressedAfterWithBrowser() checkPass(result, 1, 0); } + @Test + public void testOverwriteBrowserForCleanUp() + { + // it should be possible to use different browser profle for clean up (using @Browser annotation) + Result result = JUnitCore.runClasses(OverwriteBrowserForCleanUp.class); + checkPass(result, 1, 0); + } + @Test public void testTestBrowser() throws Throwable { diff --git a/src/test/java/com/xceptance/neodymium/tests/NeodymiumWebDriverTest.java b/src/test/java/com/xceptance/neodymium/tests/NeodymiumWebDriverTest.java index dbd2ccedb..7add9808d 100644 --- a/src/test/java/com/xceptance/neodymium/tests/NeodymiumWebDriverTest.java +++ b/src/test/java/com/xceptance/neodymium/tests/NeodymiumWebDriverTest.java @@ -18,7 +18,9 @@ import com.xceptance.neodymium.testclasses.webDriver.ValidateKeepWebDriverOpen; import com.xceptance.neodymium.testclasses.webDriver.ValidateKeepWebDriverOpenOnFailure; import com.xceptance.neodymium.testclasses.webDriver.ValidateKeepWebDriverOpenOnFailureInAfter; +import com.xceptance.neodymium.testclasses.webDriver.ValidateKeepWebDriverOpenOnFailureInBefore; import com.xceptance.neodymium.testclasses.webDriver.ValidateKeepWebDriverOpenOnFailureWithAfter; +import com.xceptance.neodymium.testclasses.webDriver.ValidateKeepWebDriverOpenOnFailureWithBefore; import com.xceptance.neodymium.testclasses.webDriver.ValidatePreventReuseWebDriver; import com.xceptance.neodymium.testclasses.webDriver.ValidateReuseWebDriver; import com.xceptance.neodymium.testclasses.webDriver.ValidateWebDriverClosed; @@ -109,6 +111,22 @@ public void testValidateKeepWebDriverOpenOnFailureInAfter() checkFail(result, 2, 0, 1); } + @Test + public void testValidateKeepWebDriverOpenOnFailureWithBefore() + { + // XVFB or a display needed + Result result = JUnitCore.runClasses(ValidateKeepWebDriverOpenOnFailureWithBefore.class); + checkFail(result, 2, 0, 1); + } + + @Test + public void testValidateKeepWebDriverOpenOnFailureInBefore() + { + // XVFB or a display needed + Result result = JUnitCore.runClasses(ValidateKeepWebDriverOpenOnFailureInBefore.class); + checkFail(result, 2, 0, 1); + } + @Test public void testLocalProxyTrustAllServers() { diff --git a/src/test/java/com/xceptance/neodymium/tests/PlaygroundTest.java b/src/test/java/com/xceptance/neodymium/tests/PlaygroundTest.java deleted file mode 100644 index ffc099c0f..000000000 --- a/src/test/java/com/xceptance/neodymium/tests/PlaygroundTest.java +++ /dev/null @@ -1,98 +0,0 @@ -package com.xceptance.neodymium.tests; - -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.openqa.selenium.WebDriver; - -import com.codeborne.selenide.Selenide; -import com.xceptance.neodymium.NeodymiumRunner; -import com.xceptance.neodymium.module.statement.browser.multibrowser.Browser; -import com.xceptance.neodymium.module.statement.browser.multibrowser.SuppressBrowsers; -import com.xceptance.neodymium.util.Neodymium; - -@RunWith(NeodymiumRunner.class) -@Browser("Chrome_headless") -public class PlaygroundTest -{ - private static WebDriver webDriver1; - - private static WebDriver webDriver2; - - private static WebDriver webDriver3; - - private static boolean alive; - - @BeforeClass - public static void beforeClass() - { - // Assert.assertNull(webDriver1); - // Assert.assertNull(Neodymium.getDriver()); - } - - @SuppressBrowsers - @Test - public void test1() - { - // webDriver1 = Neodymium.getDriver(); - // Assert.assertEquals(webDriver1, Neodymium.getDriver()); - // NeodymiumWebDriverTest.assertWebDriverAlive(webDriver1); - // - // Selenide.open("https://www.xceptance.com/"); - Assert.assertNull(Neodymium.getDriver()); - alive = false; - } - - @Test - public void test2() - { - // webDriver1 = Neodymium.getDriver(); - // Assert.assertEquals(webDriver1, Neodymium.getDriver()); - NeodymiumWebDriverTest.assertWebDriverAlive(Neodymium.getDriver()); - - Selenide.open("https://www.xceptance.com/"); - alive = true; - } - - @After - public void after() - { - // Assert.assertNotEquals(webDriver1, Neodymium.getDriver()); - // webDriver2 = Neodymium.getDriver(); - // Selenide.open("https://xtc.xceptance.com/"); - if (alive) - { - Selenide.open("https://xtc.xceptance.com/"); - } - else - { - Assert.assertNull(Neodymium.getDriver()); - } - } - - @After - public void after1() - { - // Assert.assertNotEquals(webDriver2, Neodymium.getDriver()); - // webDriver3 = Neodymium.getDriver(); - if (alive) - { - Selenide.open("https://github.com/Xceptance/neodymium-library/pull/194/files"); - } - else - { - Assert.assertNull(Neodymium.getDriver()); - } - } - - @AfterClass - public static void afterClass() - { - // NeodymiumWebDriverTest.assertWebDriverClosed(webDriver1); - // NeodymiumWebDriverTest.assertWebDriverClosed(webDriver2); - // NeodymiumWebDriverTest.assertWebDriverClosed(webDriver3); - } -}