How to use annotatedClassesInPackage method of net.serenitybdd.jbehave.Finder class

A issue has been raised (including quick fix) with the bdd serenity-jbehave version 1.8.0 and higher:

issue #109

I do not know what was wrong but it is working now after restarting my IDE. My IDE was running for a while (more then a week).

Fail at end should work in your scenario.

Basic Def from Maven Specs :

--fail-at-end - if a particular module build fails, continue the rest of the reactor
           and report all failed modules at the end instead .

If you need to continue after a failed step, you should use soft assertions.

WebdriverIO is a JavaScript / nodejs implementation of the (Selenium 2.0) WebDriver API - one of many (Selendroid, Protractor, etc.) As the specification says:

WebDriver is a remote control interface that enables introspection and control of user agents. It provides a platform- and language-neutral wire protocol as a way for out-of-process programs to remotely instruct the behaviour of web browsers.

If you use Java, you'll use the Java implementation of WebDriver. Which language, and which implementation you choose, is up to you, your skills, and the skill of your team.

Though I very much doubt that WebdriverIO is "not mature enough". WebDriver is a fine spec, with a number of powerful implementations, but it is very frequently misused. Certainly as far as newbies go, a very large proportion of "random" failures are completely avoidable race conditions within their test code.

If you are using Maven take a look at Maven Failsafe plugin Rerun Failing Tests feature:

http://maven.apache.org/surefire/maven-failsafe-plugin/examples/rerun-failing-tests.html

I solved the issue by upgrading the Serenity Maven Plugin from:

2.0.89

to:

2.1.8

I solved this using the following hack (basically injecting the service(s) myself):

@ContextConfiguration(locations = "test-beans.xml", 
                      loader = TestContextLoader.class)
public class GreetingServiceTest extends SerenityStories {

    @Autowired
    private GreetingService greetingService;

    private String greeting;

    @When("I want a greeting")
    public void whenIWantAGreeting() {
        greeting = greetingService.getGreeting();
    }

    @Then("I shall be greeted with \"$greeting\"")
    public void thenIShallBeGreetedWith(String greeting) {
        assertEquals(greeting, this.greeting);
    }

    @Override
    public InjectableStepsFactory stepsFactory() {
        return new InstanceStepsFactory(configuration(), this);
    }

    @BeforeStories
    public final void beforeStories() {
        AutowireCapableBeanFactory beanFactory = getContext().getAutowireCapableBeanFactory();
        beanFactory.autowireBeanProperties(this, AutowireCapableBeanFactory.AUTOWIRE_NO, false);
        beanFactory.initializeBean(this, getClass().getName());
    }

    private ApplicationContext getContext() {
        return SpringClassRuleHack.getTestContextManager(getClass())
            .getTestContext()
            .getApplicationContext();
    }
}

SpringClassRuleHack (must be the same package as SpringClassRule to get access to the getTestContextManager method):

package org.springframework.test.context.junit4.rules;

import org.springframework.test.context.TestContextManager;

public final class SpringClassRuleHack {

   private SpringClassRuleHack() {}

   public static TestContextManager getTestContextManager(Class<?> testClass) {
      return SpringClassRule.getTestContextManager(testClass);
   }

}

I'm getting the Spring context through SpringClassRule so that it gets cached by Spring, letting Spring control when the context needs reloading (if I have understood correctly).

I'm not entirely satisfied with this solution and I suspect it's not equivalent to enabling SpringClassRule/SpringMethodRule in the standard way, but it works in my case.

Reading the extra comment / improves question, it sounds indeed like an Integration Test.

There are some need Integration Test libraries like JBehave, Serenity, Cucumber, etc which would probably better for setting this up.

With TestNG, you could create 3 tests, where each next test depends on the previous test. See code sample below, from testng dependency test

package com.mkyong.testng.examples.dependency;

import org.testng.annotations.Test;

public class App {

    @Test
    public void method1() {
        System.out.println("This is method 1");
    }

    @Test(dependsOnMethods = { "method1" })
    public void method2() {
        System.out.println("This is method 2");
    }

}

Here the most simple dependency is show. See the sample code for more complex cases, like groups etc. For setting up two test classes each with their own @Factory