How to use TestMethodAnnotations class of net.serenitybdd.junit.runners package

...354            markAsPending(method);355            notifier.fireTestIgnored(describeChild(method));356            return;357        } else {358            processTestMethodAnnotationsFor(method);359        }360        StepEventBus.getEventBus().initialiseSession();361        prepareBrowserForTest();362        additionalBrowserCleanup();363        performRunChild(method, notifier);364        if (failureDetectingStepListener.lastTestFailed() && maxRetries() > 0) {365            retryAtMost(maxRetries(), new RerunSerenityTest(method, notifier));366        }367    }368    private void retryAtMost(int remainingTries,369                             RerunTest rerunTest) {370        if (remainingTries <= 0) { return; }371        logger.info(rerunTest.toString() + ": attempt " + (maxRetries() - remainingTries));372        StepEventBus.getEventBus().cancelPreviousTest();373        rerunTest.perform();374        if (failureDetectingStepListener.lastTestFailed()) {375            retryAtMost(remainingTries - 1, rerunTest);376        } else {377            StepEventBus.getEventBus().lastTestPassedAfterRetries(remainingTries,378                                                                  failureDetectingStepListener.getFailureMessages(),failureDetectingStepListener.getTestFailureCause());379        }380    }381    private void performRunChild(FrameworkMethod method, RunNotifier notifier) {382        super.runChild(method, notifier);383    }384    interface RerunTest {385        void perform();386    }387    class RerunSerenityTest implements RerunTest {388        private final FrameworkMethod method;389        private final RunNotifier notifier;390        RerunSerenityTest(FrameworkMethod method, RunNotifier notifier) {391            this.method = method;392            this.notifier = notifier;393        }394        @Override395        public void perform() {396            performRunChild(method, notifier);397        }398        @Override399        public String toString() {400            return "Retrying " + method.getDeclaringClass() + " " + method.getMethod().getName();401        }402    }403    private void clearMetadataIfRequired() {404        if (theTest.shouldClearMetadata()) {405            Serenity.getCurrentSession().clearMetaData();406        }407    }408    private void resetStepLibrariesIfRequired() {409        if (theTest.shouldResetStepLibraries()) {410            stepFactory.reset();411        }412    }413    protected void additionalBrowserCleanup() {414        // Template method. Override this to do additional cleanup e.g. killing IE processes.415    }416    private boolean shouldSkipTest(FrameworkMethod method) {417        return !tagScanner.shouldRunMethod(getTestClass().getJavaClass(), method.getName());418    }419    private void markAsPending(FrameworkMethod method) {420        testStarted(method);421        StepEventBus.getEventBus().testPending();422        StepEventBus.getEventBus().testFinished();423    }424    private Consumer<RunNotifier> markAsManual(FrameworkMethod method) {425        TestMethodConfiguration theMethod = TestMethodConfiguration.forMethod(method);426        testStarted(method);427        StepEventBus.getEventBus().testIsManual();428        StepEventBus.getEventBus().getBaseStepListener().latestTestOutcome().ifPresent(429                outcome -> {430                    outcome.setResult(theMethod.getManualResult());431                    if (theMethod.getManualResult() == FAILURE) {432                        outcome.setTestFailureMessage(manualReasonDeclaredIn(theMethod));433                    }434                }435        );436        List<Integer> ages = Arrays.asList(20,40,50,15,80);437        int totalAges = 0;438        for(int age : ages) {439            totalAges = totalAges + age;440        }441        double average = totalAges / ages.size();442        switch(theMethod.getManualResult()) {443            case SUCCESS:444                StepEventBus.getEventBus().testFinished();445                return (notifier -> notifier.fireTestFinished(Description.EMPTY));446            case FAILURE:447                Throwable failure = new ManualTestMarkedAsFailure(manualReasonDeclaredIn(theMethod));448                StepEventBus.getEventBus().testFailed(failure);449                return (notifier -> notifier.fireTestFailure(450                        new Failure(Description.createTestDescription(method.getDeclaringClass(), method.getName()),failure)));451            case ERROR:452            case COMPROMISED:453            case UNSUCCESSFUL:454                Throwable error = new ManualTestMarkedAsError(manualReasonDeclaredIn(theMethod));455                StepEventBus.getEventBus().testFailed(error);456                return (notifier -> notifier.fireTestFailure(457                        new Failure(Description.createTestDescription(method.getDeclaringClass(), method.getName()),error)));458            case IGNORED:459                StepEventBus.getEventBus().testIgnored();460                return (notifier -> notifier.fireTestIgnored(Description.createTestDescription(method.getDeclaringClass(), method.getName())));461            case SKIPPED:462                StepEventBus.getEventBus().testSkipped();463                return (notifier -> notifier.fireTestIgnored(Description.createTestDescription(method.getDeclaringClass(), method.getName())));464            default:465                StepEventBus.getEventBus().testPending();466                return (notifier -> notifier.fireTestIgnored(Description.createTestDescription(method.getDeclaringClass(), method.getName())));467        }468    }469    private String manualReasonDeclaredIn(TestMethodConfiguration theMethod) {470        return theMethod.getManualResultReason().isEmpty() ? "Manual test failure" : "Manual test failure: " + theMethod.getManualResultReason();471    }472    private void testStarted(FrameworkMethod method) {473        getStepListener().testStarted(Description.createTestDescription(method.getMethod().getDeclaringClass(), testName(method)));474    }475    /**476     * Process any Serenity annotations in the test class.477     * Ignored tests will just be skipped by JUnit - we need to ensure478     * that they are included in the Serenity reports479     * If a test method is pending, all the steps should be skipped.480     */481    private void processTestMethodAnnotationsFor(FrameworkMethod method) {482        if (isIgnored(method)) {483            testStarted(method);484            StepEventBus.getEventBus().testIgnored();485            StepEventBus.getEventBus().testFinished();486        }487    }488    protected void prepareBrowserForTest() {489        if (theTest.shouldClearTheBrowserSession()) {490            WebdriverProxyFactory.clearBrowserSession(getDriver());491        }492    }493    /**494     * Running a unit test, which represents a test scenario.495     */496    @Override497    protected Statement methodInvoker(final FrameworkMethod method, final Object test) {498        if (webtestsAreSupported()) {499            injectDriverInto(test);500            initPagesObjectUsing(driverFor(method));501            injectAnnotatedPagesObjectInto(test);502            initStepFactoryUsing(getPages());503        }504        injectScenarioStepsInto(test);505        injectEnvironmentVariablesInto(test);506        useStepFactoryForDataDrivenSteps();507        Statement baseStatement = super.methodInvoker(method, test);508        return new SerenityStatement(baseStatement, stepListener.getBaseStepListener());509    }510    private void useStepFactoryForDataDrivenSteps() {511        StepData.setDefaultStepFactory(stepFactory);512    }513    /**514     * Instantiate the @Managed-annotated WebDriver instance with current WebDriver.515     * @param testCase A Serenity-annotated test class516     */517    protected void injectDriverInto(final Object testCase) {518        TestCaseAnnotations.forTestCase(testCase).injectDrivers(ThucydidesWebDriverSupport.getDriver(),519                                                                ThucydidesWebDriverSupport.getWebdriverManager());520        dependencyInjector.injectDependenciesInto(testCase);521    }522    protected WebDriver driverFor(final FrameworkMethod method) {523        if (TestMethodAnnotations.forTest(method).isDriverSpecified()) {524            String testSpecificDriver = TestMethodAnnotations.forTest(method).specifiedDriver();525            String driverOptions = TestMethodAnnotations.forTest(method).driverOptions();526            return getDriver(testSpecificDriver, driverOptions);527        } else {528            return getDriver();529        }530    }531    /**532     * Instantiates the @ManagedPages-annotated Pages instance using current WebDriver.533     * @param testCase A Serenity-annotated test class534     */535    protected void injectScenarioStepsInto(final Object testCase) {536        StepAnnotations.injector().injectScenarioStepsInto(testCase, stepFactory);537    }538    /**539     * Instantiates the @ManagedPages-annotated Pages instance using current WebDriver....

...79    private Optional<ExplicitWebDriverConfiguration> explicitWebDriverConfiguration(final ExtensionContext extensionContext) {80        final Method testMethod = extensionContext.getRequiredTestMethod();81        final Class<?> requiredTestClass = extensionContext.getRequiredTestClass();82        if (hasExplicitWebDriverConfigurationOnTestMethod(testMethod)) {83            final String testSpecificDriver = TestMethodAnnotations.forTest(testMethod).specifiedDriver();84            final String driverOptions = TestMethodAnnotations.forTest(testMethod).driverOptions();85            return explicitWebDriverConfiguration(testSpecificDriver, driverOptions);86        } else if (hasExplicitWebDriverConfigurationOnTestClass(requiredTestClass)) {87            // CAUTION: unstable behaviour in case of multiple @Managed fields88            // findFirstAnnotatedField seems to be misleading. It finds "a" annotated field, because the ordering is not defined.89            // If there are multiple @Managed fields it is not clear which one should be used to define the default web driver used for the Steps.90            // So either A) this is an invalid use case that should be detected and rejected with an exception OR B) the default that would be used otherwise should be used91            // If net.thucydides.core.annotations.PatchedManagedWebDriverAnnotatedField.findAnnotatedFields would be public this case could at least be detected.92            // Note that even this block would be removed net.thucydides.core.annotations.TestCaseAnnotations#injectDrivers would still set a default but without explicitly93            // updating the PageFactory (which will happen as a side-effect to ThucydidesWebDriverSupport#getDriver calls.94            final ManagedWebDriverAnnotatedField firstAnnotatedField = ManagedWebDriverAnnotatedField.findFirstAnnotatedField(requiredTestClass);95            return explicitWebDriverConfiguration(firstAnnotatedField.getDriver(), firstAnnotatedField.getOptions());96        }97        return empty();98    }99    private void prepareBrowserForTest(final ExtensionContext extensionContext) {100        PatchedManagedWebDriverAnnotatedField.findAnnotatedFields(extensionContext.getRequiredTestClass()).stream()101                .filter(it -> ClearCookiesPolicy.BeforeEachTest.equals(it.getClearCookiesPolicy()))102                .map(it -> it.getValue(extensionContext.getRequiredTestInstance()))103                .forEach(WebdriverProxyFactory::clearBrowserSession);104        /* JUNIT4 analog impl:105        private void prepareBrowserForTest(TestConfiguration theTest) {106            if (theTest.shouldClearTheBrowserSession()) {107                // CAUTION: unstable behaviour in case of multiple @Managed fields108                // What is the expected behaviour in case of multiple @Managed fields? The current implementation picks an arbitrary @Managed field to decide109                // if a web driver instance should be cleared. It seems iterating over all @Manager fields and for those configured to clear the session, do so.110                // If net.thucydides.core.annotations.PatchedManagedWebDriverAnnotatedField.findAnnotatedFields would be public one could iterate easily111                // over the fields.112                WebdriverProxyFactory.clearBrowserSession(ThucydidesWebDriverSupport.getWebdriverManager().getCurrentDriver());113            }114        }115         */116    }117    @NotNull118    private Optional<ExplicitWebDriverConfiguration> explicitWebDriverConfiguration(final String testSpecificDriver, final String driverOptions) {119        return of(new ExplicitWebDriverConfiguration(testSpecificDriver, driverOptions));120    }121    private boolean hasExplicitWebDriverConfigurationOnTestClass(final Class<?> requiredTestClass) {122        return ManagedWebDriverAnnotatedField.hasManagedWebdriverField(requiredTestClass);123    }124    private boolean hasExplicitWebDriverConfigurationOnTestMethod(final Method testMethod) {125        return TestMethodAnnotations.forTest(testMethod).isDriverSpecified();126    }127    private void injectPageObjectIntoTest(final Object testClass) {128        new PageObjectDependencyInjector(getPages()).injectDependenciesInto(testClass);129    }130    public static class ExplicitWebDriverConfiguration {131        private final String testSpecificDriver;132        private final String driverOptions;133        public ExplicitWebDriverConfiguration(final String testSpecificDriver, final String driverOptions) {134            this.testSpecificDriver = testSpecificDriver;135            this.driverOptions = driverOptions;136        }137        public String getTestSpecificDriver() {138            return testSpecificDriver;139        }...

...3import net.thucydides.core.annotations.DriverOptions;4import net.thucydides.core.annotations.WithDriver;5import java.lang.reflect.Method;6import java.util.Optional;7// Junit4: net.serenitybdd.junit.runners.TestMethodAnnotations8public final class TestMethodAnnotations {9    private final Method method;10    private TestMethodAnnotations(final Method method) {11        this.method = method;12    }13    public static TestMethodAnnotations forTest(final Method method) {14        return new TestMethodAnnotations(method);15    }16    public boolean isDriverSpecified() {17        return (method.getAnnotation(WithDriver.class) != null);18    }19    public String specifiedDriver() {20        Preconditions.checkArgument(isDriverSpecified() == true);21        return (method.getAnnotation(WithDriver.class).value());22    }23    public String driverOptions() {24        Preconditions.checkArgument(isDriverSpecified() == true);25        return Optional.ofNullable(method.getAnnotation(DriverOptions.class)).map(DriverOptions::value).orElse("");26    }27}...

1import net.serenitybdd.junit.runners.SerenityRunner;2import net.serenitybdd.junit.runners.TestMethodAnnotations;3import org.junit.Before;4import org.junit.Test;5import org.junit.runner.RunWith;6@RunWith(SerenityRunner.class)7public class TestClass {8    public void beforeMethod() {9        TestMethodAnnotations.forClass(this.getClass()).beforeMethod();10    }11    public void testMethod() {12        TestMethodAnnotations.forClass(this.getClass()).testMethod();13    }14}

1@RunWith(SerenityRunner.class)2public class TestMethodAnnotations {3    @WithTag("tag1")4    @WithTag("tag2")5    @WithTag("tag3")6    @WithTags({7            @WithTag("tag4"),8            @WithTag("tag5"),9            @WithTag("tag6")10    })11    public void testMethod() {12    }13}14@RunWith(SerenityRunner.class)15@WithTag("tag1")16@WithTag("tag2")17@WithTag("tag3")18@WithTags({19        @WithTag("tag4"),20        @WithTag("tag5"),21        @WithTag("tag6")22})23public class TestClassAnnotations {24    public void testMethod() {25    }26}

1@RunWith(SerenityRunner.class)2public class TestMethodAnnotations {3    @WithTag("fast")4    public void fastTest() {5        System.out.println("Fast test");6    }7    @WithTag("slow")8    public void slowTest() {9        System.out.println("Slow test");10    }11}12@WithTagValuesOf({"fast", "slow"})13public class TestMethodAnnotations {14    public void fastTest() {15        System.out.println("Fast test");16    }17    public void slowTest() {18        System.out.println("Slow test");19    }20}21@WithTagValuesOf({"fast", "slow"})22public class TestMethodAnnotations {23    public void fastTest() {24        System.out.println("Fast test");25    }26    public void slowTest() {27        System.out.println("Slow test");28    }29}

1@RunWith(SerenityRunner.class)2public class TestMethodAnnotations {3    @WithDriver("chrome")4    public void testWithDriver() {5        WebDriver driver = getDriver();6        assertThat(driver.getTitle(), is("Google"));7    }8    @WithDriver("chrome")9    @WithTag("tag1")10    @WithTag("tag2")11    public void testWithDriverAndTags() {12        WebDriver driver = getDriver();13        assertThat(driver.getTitle(), is("Google"));14    }15    @WithDriver("chrome")16    @WithTag("tag1")17    @WithTag("tag2")18    public void testWithDriverAndTags2() {19        WebDriver driver = getDriver();20        assertThat(driver.getTitle(), is("Google"));21    }22    @WithDriver("chrome")23    @WithTag("tag1")24    @WithTag("tag2")25    public void testWithDriverAndTags3() {26        WebDriver driver = getDriver();27        assertThat(driver.getTitle(), is("Google"));28    }29    @WithDriver("chrome")30    @WithTag("tag1")31    @WithTag("tag2")32    @WithTag("tag3")33    @WithTag("tag4")34    public void testWithDriverAndTags4() {35        WebDriver driver = getDriver();36        assertThat(driver.getTitle(), is("Google"));37    }38    @WithDriver("chrome")39    @WithTag("tag1")40    @WithTag("tag2")41    @WithTag("tag3")42    @WithTag("tag4")43    public void testWithDriverAndTags5() {44        WebDriver driver = getDriver();45        assertThat(driver.getTitle(), is("Google"));46    }47}48public class TestMethodAnnotationsTest {49    public void test() {50        JUnitCore core = new JUnitCore();51        core.addListener(new SerenityReportingListener());52        core.run(TestMethodAnnotations.class);53    }54}55public class TestRunner {56    public static void main(String[] args) {

1@RunWith(SerenityRunner.class)2public class TestMethodAnnotations {3    @WithDriver("chrome")4    public void shouldOpenGooglePage(){5        Serenity.getCurrentSession().getDriver().getTitle().should().contain("Google");6    }7    @WithDriver("chrome")8    public void shouldOpenBingPage(){9        Serenity.getCurrentSession().getDriver().getTitle().should().contain("Bing");10    }11}12package net.serenitybdd.junit.runners;13import net.serenitybdd.junit.runners.annotations.UseTestDataFrom;14import net.serenitybdd.junit.runners.annotations.UseTestDataFrom;15import net.thucydides.core.annotations.Steps;16import net.thucydides.core.annotations.Title;17import net.thucydides.core.annotations.WithDriver;18import net.thucydides.core.steps.ScenarioSteps;19import org.junit.Test;20import org.junit.runner.RunWith;21import java.util.concurrent.TimeUnit;22@RunWith(SerenityRunner.class)23@UseTestDataFrom(value = "testdata.csv")24public class TestMethodAnnotations {25    ScenarioSteps steps;26    private String name;27    private String email;28    private String phone;29    private String address;30    @WithDriver("chrome")31    @Title("Test with {0}")32    public void shouldOpenGooglePage(String name){33        Serenity.getCurrentSession().getDriver().getTitle().should().contain("Google");34    }35    @WithDriver("chrome")36    @Title("Test with {0}")37    public void shouldOpenBingPage(String name){38        Serenity.getCurrentSession().getDriver().getTitle().should().contain("Bing");39    }40}

1@RunWith(SerenityRunner.class)2public class TestMethodAnnotations {3	@WithDriver("chrome")4	public void testWithDriver() {5	}6	@WithDriver("chrome")7	@Managed(uniqueSession = true)8	public void testWithDriverAndManaged() {9	}10	@Managed(uniqueSession = true)11	public void testWithManaged() {12	}13	@Managed(uniqueSession = true)14	@WithDriver("chrome")15	public void testWithManagedAndDriver() {16	}17	public void testWithoutDriver() {18	}19}20package net.serenitybdd.junit.runners;21import net.thucydides.core.webdriver.Configuration;22import net.thucydides.core.webdriver.DriverConfiguration;23import org.junit.runners.model.InitializationError;24import org.openqa.selenium.WebDriver;25import org.openqa.selenium.WebDriverException;26import org.openqa.selenium.remote.RemoteWebDriver;27import org.slf4j.Logger;28import org.slf4j.LoggerFactory;29import java.lang.reflect.Field;30import java.util.ArrayList;31import java.util.List;32import java.util.concurrent.TimeUnit;33public class SerenityRunner extends SerenityParameterizedRunner {34	private static final Logger LOGGER = LoggerFactory.getLogger(SerenityRunner.class);35	private final List<DriverConfiguration> driverConfigurations = new ArrayList<>();36	public SerenityRunner(Class<?> klass) throws InitializationError {37		super(klass);38	}39	protected void createDriverFor(Class<?> testClass) throws Exception {40		List<DriverConfiguration> driverConfigurations = DriverConfiguration.forTest(testClass);41		for (DriverConfiguration driverConfiguration : driverConfigurations) {42			if (driverConfiguration.isManaged()) {43				createManagedDriverFor(driverConfiguration);44			} else {45				createUnmanagedDriverFor(driverConfiguration);46			}47		}48	}49	private void createUnmanagedDriverFor(DriverConfiguration driverConfiguration) throws Exception {50		WebDriver driver = driverConfiguration.getDriver();51		driver.manage().timeouts().implicitlyWait(0, TimeUnit.SECONDS);52		setDriverFor(driverConfiguration, driver);53	}54	private void createManagedDriverFor(DriverConfiguration driverConfiguration) throws Exception {55		driverConfigurations.add(driverConfiguration);56		WebDriver driver = driverConfiguration.getDriver();57		driver.manage().timeouts().implicitlyWait(0, TimeUnit.SECONDS);58		setDriverFor(driver

1@RunWith(SerenityRunner.class)2public class TestMethodAnnotations {3    @WithTag("feature:Search")4    @WithTag("type:smoke")5    public void test1() {6    }7    @WithTag("feature:Search")8    @WithTag("type:functional")9    public void test2() {10    }11    @WithTag("feature:Search")12    @WithTag("type:regression")13    @WithTag("type:functional")14    public void test3() {15    }16}17@RunWith(SerenityRunner.class)18public class TestMethodAnnotations {19    @WithTag("feature:Search")20    @WithTag("type:smoke")21    public void test1() {22    }23    @WithTag("feature:Search")24    @WithTag("type:functional")25    public void test2() {26    }27    @WithTag("feature:Search")28    @WithTag("type:regression")29    @WithTag("type:functional")30    public void test3() {31    }32}

1@RunWith(SerenityRunner.class)2public class SerenityRunnerExample {3    @Title("This is a test")4    public void testOne() {5        System.out.println("This is test one");6    }7}8@RunWith(SerenityRunner.class)9public class SerenityRunnerExample {10    @Title("This is a test")11    public void testOne() {12        System.out.println("This is test one");13    }14}15@RunWith(SerenityRunner.class)16public class SerenityRunnerExample {17    @Title("This is a test")18    public void testOne() {19        System.out.println("This is test one");20    }21}22@RunWith(SerenityRunner.class)23public class SerenityRunnerExample {24    @Title("This is a test")25    public void testOne() {26        System.out.println("This is test one");27    }28}29@RunWith(SerenityRunner.class)30public class SerenityRunnerExample {31    @Title("This is a test")32    public void testOne() {33        System.out.println("This is test one");34    }35}36@RunWith(SerenityRunner.class)37public class SerenityRunnerExample {38    @Title("This is a test")39    public void testOne() {40        System.out.println("This is test one");41    }42}43@RunWith(SerenityRunner.class)44public class SerenityRunnerExample {45    @Title("This is a test")46    public void testOne() {47        System.out.println("This is test one");48    }49}50@RunWith(SerenityRunner.class)51public class SerenityRunnerExample {52    @Title("This is a test")53    public void testOne() {54        System.out.println("This is test one

1@RunWith(SerenityRunner.class)2public class TestRunner {3    public void test() {4        System.out.println("Test method");5    }6}