Transaction commence and Rollback

[patrickmcmichael]

What is the current status and intended direction regarding transation/auto-rollback support for cucumber-jvm (in general, with a specific IoC factory in play)?

• manual callouts within @before or @after?
• counterpart for Java for Cucumber::Rails.use_transactional_fixtures?
• flag property on @Before/@after annotation?

Thanks,

PWM

[aslakhellesoy]

I'm not sure we'd want to build that in, as there are so many different Database APIs around. Have you tried just doing it yourself in a @before and @after hook? Shouldn't be more than a few LOC.

[patrickmcmichael]

That was option #1 above, but I wanted to get a feel for the direction intended before going there.

In my case, we'll be using Spring as our IoC container. It'd be cool if the Spring Factory looked for some flag annotation that on a scenario-by-scenario basis could kick off an auto-rollback tx before scenario start, similar to how @transactional and the Spring JUnit runner work together.

[aslakhellesoy]

I'm not sure a Java annotation would make sense here. Where would you put it? What if you could do:

public class MyTxnHooks {
    @Autowired
    private SpringTxn txn; // Or whatever it's called

    @Before
    public void startTxn() { txn.start(); }

    @After
    public void rollbackTxn() { txn.rollback(); }
}

I don't know much Spring, so let me know if that makes sense.

[patrickmcmichael]

@Before/@after are scenario boundary hooks vs step boundary, correct? Working on that assumption, we can definitely do simple tx start/rollback api calls.

Was just trying to think if, when SpringFactory was in play, if the runner (@RunWith(Cucumber.class)) or a TX-aware extension of it could function more like the spring junit runner that detects @transactional and does all the tx magic and auto-rollback for you.

thx, pwm

[aslakhellesoy]

Yes - @before runs before a Scenario, and @after runs after. There are no step hooks.

In Cucumber-Rails, transaction start/rollback is also implemented using After and Before hooks.

Are you going to contribute some code for this?

[patrickmcmichael]

I'm thinking of experimenting with some annotation-based hook points...if it proves to be something that could be done declaratively vs programatically inside @Before/@after, I'll fork and contribute the result.

[patrickmcmichael]

Think I have a reusable solution, though it is likely still something we'd do case-by-case vs bury in the global code, or perhaps we can add it as a support class alongside Spring for when it's useful.

Before going there, is it safe to assume that in the cuke lifecycle that any mapped stepdef or hook classes are instantiated per-scenario-run, and not reused? (in other words, if they hold state which is needed across step/hook defs (e.g. then needs state from when, or after needs state from before) is this thread safe by each scenario execution having its own runtime instance of the stepdef or hookdef class?

[aslakhellesoy]

All classes that contain stepdefs or hooks are instantiated anew for each scenario. If you are using cucumber-spring, application beans will carry over between scenarios: https://github.com/cucumber/cucumber-jvm/blob/master/spring/src/test/java/cucumber/runtime/java/spring/SpringFactoryTest.java

Regarding thread safety - I haven't tried to run Cucumber in a multi-threaded environment. Are you talking about multiple JUnit threads, or multiple threads in the code being tested?

[mmalmeida]

I'm also thinking about a way to tackle the problem. My main motivation is: ease of use.

Spring has a AbstractTransactionalJUnit4SpringContextTests class which you can extend in your tests (see http://www.jarvana.com/jarvana/view/org/springframework/spring-test/3.0.6.RELEASE/spring-test-3.0.6.RELEASE-sources.jar!/org/springframework/test/context/junit4/AbstractTransactionalJUnit4SpringContextTests.java?format=ok )

This makes transaction management in your test automatic: the abstract class is marked with @transactional, which means "each method is run in a transaction". As one method = one test, your tests are run inside a transaction, with the added benefit that you can set them to rollback automatically after the transaction.

Main advantages are:

• your transaction management will be the same for cucumber and for your integration tests
• if you let spring manage your transactions in the real application as well, you have a single point of transaction management.

The problem so far is one: those tests are run with @RunWith(SpringJUnit4ClassRunner.class), and Cucumber runs with Cucumber.class

The only way I see it is to have a Runner that has both runner's functionality. How difficult that is I have no idea.

[patrickmcmichael]

@mmalmeida Good reminder to post back here...here's what I've done here...working great so far. I considered trying to generalize this enough to issue a pull request for @aslakhellesoy, but feel like some of the specifics in here, while reusable across tests, may still make assumptions that are too environment specific to try for reuse at the cucumber-jvm lib level...?

Anyhow, here's the gist:

1. In my test class I have something like this:

@RunWith(Cucumber.class)
@Feature(value="features/foo_bar.feature", packages={"x.y.z.txhooks"})

• Recall that @feature checks for step and hook (e.g. before/after) defs in the same package as the test file itself lives, BUT ALSO in any packages specified.
• I leverage this, combined with a distinct package containing ONLY my TX Hook Defs, in this example x.y.z.txhooks.

2. I then create a simple hookdef file in that distinct package, something like this...

package x.y.z.txhooks;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import cucumber.annotation.After;
import cucumber.annotation.Before;

public class cukespike_TxHooks {

    private TransactionStatus txStatus;

    @Autowired
    private PlatformTransactionManager txMgr;

    @Before
    public void rollBackBeforeHook() {
        txStatus = txMgr.getTransaction(new DefaultTransactionDefinition());
    }

    @After
    public void rollBackAfterHook() {
        txMgr.rollback(txStatus);
    }

}

3. This gives me auto-rollback capability similar to the spring junit4 runner, w/o forcing us to mess with Cucumber.class as our runner at all.

4. In the form above, all scenarios in the given @feature would get the tx behavior. If (questionable need here, IMO) flexibility is needed from one scenario to the next within a single feature file, some w/ and some w/o tx support, the @before and @after tags could leverage cucumber-jvm's tag support for these annotations to wrap ONLY those scenarios with a "txRollback" tag, for example.

a) I'm not sure how likely it is that scenarios with enough in common to be grouped under a given feature would really need to vary on their tx behavior.
b) I prefer to keep tags in a .feature file more biz-centric than tech related, though admittedly the implementation is obviously decoupled, so this ain't an unpardonable sin.

Anyhow...this approach is meeting our needs quite well so far.

[patrickmcmichael]

P.S. Note that I'm using txStatus as an instance variable in the hookdef file above, and using a singleton @Autowired txMgr. Hence my prior confirmation questions for @aslakhellesoy that any stepdef or hook file is instantiated per scenario run. (see discussion above in this thread)

[aslakhellesoy]

@patrickmcmichael that looks great! It's pretty similar to how Cucumber-Rails uses DatabaseCleaner:

https://github.com/cucumber/cucumber-rails/blob/master/lib/cucumber/rails/hooks/database_cleaner.rb

I'd be happy to add this to Cucumber-JVM. P.S. I edited your comment to get proper syntax highlighting - see the Markdown guide linked at the bottom.

[patrickmcmichael]

Cool...see the rails example did go the tag route. Which levels in a .feature file can support tags...just scenario, or feature too?

[aslakhellesoy]

Feature, Scenario, Scenario Outline and Examples can have tags.

I'd like to use the tag @txn if you don't mind.