GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add nested propagation support to R2dbcTransactionManager 

Closes gh-30134
pull/30619/head
Juergen Hoeller 3 years ago
parent
22ef48bec2
commit
974e10379a
3 changed files with 232 additions and 78 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      spring-r2dbc/src/main/java/org/springframework/r2dbc/connection/ConnectionHolder.java
  2. 137
      spring-r2dbc/src/main/java/org/springframework/r2dbc/connection/R2dbcTransactionManager.java
  3. 151
      spring-r2dbc/src/test/java/org/springframework/r2dbc/connection/R2dbcTransactionManagerUnitTests.java

22
spring-r2dbc/src/main/java/org/springframework/r2dbc/connection/ConnectionHolder.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2022 the original author or authors. * Copyright 2002-2023 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -41,11 +41,20 @@ import org.springframework.util.Assert;
*/ */
public class ConnectionHolder extends ResourceHolderSupport { public class ConnectionHolder extends ResourceHolderSupport {
/**
* Prefix for savepoint names.
* @since 6.0.10
*/
static final String SAVEPOINT_NAME_PREFIX = "SAVEPOINT_";
@Nullable @Nullable
private Connection currentConnection; private Connection currentConnection;
private boolean transactionActive; private boolean transactionActive;
private int savepointCounter = 0;
/** /**
* Create a new ConnectionHolder for the given R2DBC {@link Connection}, * Create a new ConnectionHolder for the given R2DBC {@link Connection},
@ -112,6 +121,17 @@ public class ConnectionHolder extends ResourceHolderSupport {
return this.currentConnection; return this.currentConnection;
} }
/**
* Create a new savepoint for the current {@link Connection},
* using generated savepoint names that are unique for the Connection.
* @return the name of the new savepoint
* @since 6.0.10
*/
String nextSavepoint() {
this.savepointCounter++;
return SAVEPOINT_NAME_PREFIX + this.savepointCounter;
}
/** /**
* Releases the current {@link Connection}. * Releases the current {@link Connection}.
*/ */

137
spring-r2dbc/src/main/java/org/springframework/r2dbc/connection/R2dbcTransactionManager.java
Unescape View File

@ -24,7 +24,6 @@ import io.r2dbc.spi.IsolationLevel;
import io.r2dbc.spi.Option; import io.r2dbc.spi.Option;
import io.r2dbc.spi.R2dbcException; import io.r2dbc.spi.R2dbcException;
import io.r2dbc.spi.Result; import io.r2dbc.spi.Result;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Mono; import reactor.core.publisher.Mono;
import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.InitializingBean;
@ -38,46 +37,42 @@ import org.springframework.transaction.reactive.TransactionSynchronizationManage
import org.springframework.util.Assert; import org.springframework.util.Assert;
/** /**
* {@link org.springframework.transaction.ReactiveTransactionManager} * {@link org.springframework.transaction.ReactiveTransactionManager} implementation
* implementation for a single R2DBC {@link ConnectionFactory}. This class is * for a single R2DBC {@link ConnectionFactory}. This class is capable of working
* capable of working in any environment with any R2DBC driver, as long as the * in any environment with any R2DBC driver, as long as the setup uses a
* setup uses a {@code ConnectionFactory} as its {@link Connection} factory * {@code ConnectionFactory} as its {@link Connection} factory mechanism.
* mechanism. Binds a R2DBC {@code Connection} from the specified * Binds a R2DBC {@code Connection} from the specified {@code ConnectionFactory}
* {@code ConnectionFactory} to the current subscriber context, potentially * to the current subscriber context, potentially allowing for one context-bound
* allowing for one context-bound {@code Connection} per {@code ConnectionFactory}. * {@code Connection} per {@code ConnectionFactory}.
* *
* <p><b>Note: The {@code ConnectionFactory} that this transaction manager * <p><b>Note: The {@code ConnectionFactory} that this transaction manager operates
* operates on needs to return independent {@code Connection}s.</b> * on needs to return independent {@code Connection}s.</b> The {@code Connection}s
* The {@code Connection}s may come from a pool (the typical case), but the * typically come from a connection pool but the {@code ConnectionFactory} must not
* {@code ConnectionFactory} must not return scoped {@code Connection}s * return specifically scoped or constrained {@code Connection}s. This transaction
* or the like. This transaction manager will associate {@code Connection} * manager will associate {@code Connection} with context-bound transactions,
* with context-bound transactions itself, according to the specified propagation * according to the specified propagation behavior. It assumes that a separate,
* behavior. It assumes that a separate, independent {@code Connection} can * independent {@code Connection} can be obtained even during an ongoing transaction.
* be obtained even during an ongoing transaction.
* *
* <p>Application code is required to retrieve the R2DBC Connection via * <p>Application code is required to retrieve the R2DBC Connection via
* {@link ConnectionFactoryUtils#getConnection(ConnectionFactory)} * {@link ConnectionFactoryUtils#getConnection(ConnectionFactory)}
* instead of a standard R2DBC-style {@link ConnectionFactory#create()} call. * instead of a standard R2DBC-style {@link ConnectionFactory#create()} call.
* Spring classes such as {@code DatabaseClient} use this strategy implicitly. * Spring classes such as {@code DatabaseClient} use this strategy implicitly.
* If not used in combination with this transaction manager, the * If not used in combination with this transaction manager, the
* {@link ConnectionFactoryUtils} lookup strategy behaves exactly like the * {@link ConnectionFactoryUtils} lookup strategy behaves exactly like the native
* native {@code ConnectionFactory} lookup; it can thus be used in a portable fashion. * {@code ConnectionFactory} lookup; it can thus be used in a portable fashion.
* *
* <p>Alternatively, you can allow application code to work with the standard * <p>Alternatively, you can allow application code to work with the lookup pattern
* R2DBC lookup pattern {@link ConnectionFactory#create()}, for example for code * {@link ConnectionFactory#create()}, for example for code not aware of Spring.
* that is not aware of Spring at all. In that case, define a * In that case, define a {@link TransactionAwareConnectionFactoryProxy} for your
* {@link TransactionAwareConnectionFactoryProxy} for your target {@code ConnectionFactory}, * target {@code ConnectionFactory}, and pass that proxy {@code ConnectionFactory}
* and pass that proxy {@code ConnectionFactory} to your DAOs, which will automatically * to your DAOs which will automatically participate in Spring-managed transactions
* participate in Spring-managed transactions when accessing it. * when accessing it.
* *
* <p>This transaction manager triggers flush callbacks on registered transaction * <p>Spring's {@code TransactionDefinition} attributes are carried forward to
* synchronizations (if synchronization is generally active), assuming resources * R2DBC drivers using extensible R2DBC {@link io.r2dbc.spi.TransactionDefinition}.
* operating on the underlying R2DBC {@code Connection}. * Subclasses may override {@link #createTransactionDefinition(TransactionDefinition)}
* * to customize transaction definitions for vendor-specific attributes. As of 6.0.10,
* <p>Spring's {@code TransactionDefinition} attributes are carried forward to R2DBC drivers * this transaction manager supports nested transactions via R2DBC savepoints as well.
* using extensible R2DBC {@link io.r2dbc.spi.TransactionDefinition}. Subclasses may
* override {@link #createTransactionDefinition(TransactionDefinition)} to customize
* transaction definitions for vendor-specific attributes.
* *
* @author Mark Paluch * @author Mark Paluch
* @author Juergen Hoeller * @author Juergen Hoeller
@ -97,7 +92,7 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
/** /**
* Create a new {@code R2dbcTransactionManager} instance. * Create a new {@code R2dbcTransactionManager} instance.
* A ConnectionFactory has to be set to be able to use it. * A {@code ConnectionFactory} has to be set to be able to use it.
* @see #setConnectionFactory * @see #setConnectionFactory
*/ */
public R2dbcTransactionManager() {} public R2dbcTransactionManager() {}
@ -114,12 +109,13 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
/** /**
* Set the R2DBC {@link ConnectionFactory} that this instance should manage transactions for. * Set the R2DBC {@link ConnectionFactory} that this instance should manage transactions
* <p>This will typically be a locally defined {@code ConnectionFactory}, for example a connection pool. * for. This will typically be a locally defined {@code ConnectionFactory}, for example
* <p><b>The {@code ConnectionFactory} passed in here needs to return independent {@link Connection}s.</b> * an R2DBC connection pool.
* The {@code Connection}s may come from a pool (the typical case), but the {@code ConnectionFactory} * <p><b>The {@code ConnectionFactory} passed in here needs to return independent
* must not return scoped {@code Connection}s or the like. * {@link Connection}s.</b> The {@code Connection}s typically come from a connection
* @see TransactionAwareConnectionFactoryProxy * pool but the {@code ConnectionFactory} must not return specifically scoped or
* constrained {@code Connection}s.
*/ */
public void setConnectionFactory(@Nullable ConnectionFactory connectionFactory) { public void setConnectionFactory(@Nullable ConnectionFactory connectionFactory) {
this.connectionFactory = connectionFactory; this.connectionFactory = connectionFactory;
@ -183,8 +179,7 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
@Override @Override
protected boolean isExistingTransaction(Object transaction) { protected boolean isExistingTransaction(Object transaction) {
ConnectionFactoryTransactionObject txObject = (ConnectionFactoryTransactionObject) transaction; return ((ConnectionFactoryTransactionObject) transaction).isTransactionActive();
return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
} }
@Override @Override
@ -193,6 +188,11 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
ConnectionFactoryTransactionObject txObject = (ConnectionFactoryTransactionObject) transaction; ConnectionFactoryTransactionObject txObject = (ConnectionFactoryTransactionObject) transaction;
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED &&
txObject.isTransactionActive()) {
return txObject.createSavepoint();
}
return Mono.defer(() -> { return Mono.defer(() -> {
Mono<Connection> connectionMono; Mono<Connection> connectionMono;
@ -210,7 +210,7 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
connectionMono = Mono.just(txObject.getConnectionHolder().getConnection()); connectionMono = Mono.just(txObject.getConnectionHolder().getConnection());
} }
return connectionMono.flatMap(con -> Mono.from(doBegin(definition, con)) return connectionMono.flatMap(con -> doBegin(definition, con)
.then(prepareTransactionalConnection(con, definition)) .then(prepareTransactionalConnection(con, definition))
.doOnSuccess(v -> { .doOnSuccess(v -> {
txObject.getConnectionHolder().setTransactionActive(true); txObject.getConnectionHolder().setTransactionActive(true);
@ -234,12 +234,12 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
}).then(); }).then();
} }
private Publisher<Void> doBegin(TransactionDefinition definition, Connection con) { private Mono<Void> doBegin(TransactionDefinition definition, Connection con) {
io.r2dbc.spi.TransactionDefinition transactionDefinition = createTransactionDefinition(definition); io.r2dbc.spi.TransactionDefinition transactionDefinition = createTransactionDefinition(definition);
if (logger.isDebugEnabled()) { if (logger.isDebugEnabled()) {
logger.debug("Starting R2DBC transaction on Connection [" + con + "] using [" + transactionDefinition + "]"); logger.debug("Starting R2DBC transaction on Connection [" + con + "] using [" + transactionDefinition + "]");
} }
return con.beginTransaction(transactionDefinition); return Mono.from(con.beginTransaction(transactionDefinition));
} }
/** /**
@ -300,12 +300,11 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
GenericReactiveTransaction status) throws TransactionException { GenericReactiveTransaction status) throws TransactionException {
ConnectionFactoryTransactionObject txObject = (ConnectionFactoryTransactionObject) status.getTransaction(); ConnectionFactoryTransactionObject txObject = (ConnectionFactoryTransactionObject) status.getTransaction();
Connection connection = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) { if (status.isDebug()) {
logger.debug("Committing R2DBC transaction on Connection [" + connection + "]"); logger.debug("Committing R2DBC transaction on Connection [" +
txObject.getConnectionHolder().getConnection() + "]");
} }
return Mono.from(connection.commitTransaction()) return txObject.commit().onErrorMap(R2dbcException.class, ex -> translateException("R2DBC commit", ex));
.onErrorMap(R2dbcException.class, ex -> translateException("R2DBC commit", ex));
} }
@Override @Override
@ -313,12 +312,11 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
GenericReactiveTransaction status) throws TransactionException { GenericReactiveTransaction status) throws TransactionException {
ConnectionFactoryTransactionObject txObject = (ConnectionFactoryTransactionObject) status.getTransaction(); ConnectionFactoryTransactionObject txObject = (ConnectionFactoryTransactionObject) status.getTransaction();
Connection connection = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) { if (status.isDebug()) {
logger.debug("Rolling back R2DBC transaction on Connection [" + connection + "]"); logger.debug("Rolling back R2DBC transaction on Connection [" +
txObject.getConnectionHolder().getConnection() + "]");
} }
return Mono.from(connection.rollbackTransaction()) return txObject.rollback().onErrorMap(R2dbcException.class, ex -> translateException("R2DBC rollback", ex));
.onErrorMap(R2dbcException.class, ex -> translateException("R2DBC rollback", ex));
} }
@Override @Override
@ -496,6 +494,9 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
private boolean newConnectionHolder; private boolean newConnectionHolder;
@Nullable
private String savepointName;
void setConnectionHolder(@Nullable ConnectionHolder connectionHolder, boolean newConnectionHolder) { void setConnectionHolder(@Nullable ConnectionHolder connectionHolder, boolean newConnectionHolder) {
setConnectionHolder(connectionHolder); setConnectionHolder(connectionHolder);
this.newConnectionHolder = newConnectionHolder; this.newConnectionHolder = newConnectionHolder;
@ -505,10 +506,6 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
return this.newConnectionHolder; return this.newConnectionHolder;
} }
void setRollbackOnly() {
getConnectionHolder().setRollbackOnly();
}
public void setConnectionHolder(@Nullable ConnectionHolder connectionHolder) { public void setConnectionHolder(@Nullable ConnectionHolder connectionHolder) {
this.connectionHolder = connectionHolder; this.connectionHolder = connectionHolder;
} }
@ -521,6 +518,34 @@ public class R2dbcTransactionManager extends AbstractReactiveTransactionManager
public boolean hasConnectionHolder() { public boolean hasConnectionHolder() {
return (this.connectionHolder != null); return (this.connectionHolder != null);
} }
public boolean isTransactionActive() {
return (this.connectionHolder != null && this.connectionHolder.isTransactionActive());
}
public Mono<Void> createSavepoint() {
ConnectionHolder holder = getConnectionHolder();
this.savepointName = holder.nextSavepoint();
return Mono.from(holder.getConnection().createSavepoint(this.savepointName));
}
public Mono<Void> commit() {
Connection connection = getConnectionHolder().getConnection();
return (this.savepointName != null ?
Mono.from(connection.releaseSavepoint(this.savepointName)) :
Mono.from(connection.commitTransaction()));
}
public Mono<Void> rollback() {
Connection connection = getConnectionHolder().getConnection();
return (this.savepointName != null ?
Mono.from(connection.rollbackTransactionToSavepoint(this.savepointName)) :
Mono.from(connection.rollbackTransaction()));
}
public void setRollbackOnly() {
getConnectionHolder().setRollbackOnly();
}
} }
} }

151
spring-r2dbc/src/test/java/org/springframework/r2dbc/connection/R2dbcTransactionManagerUnitTests.java
Unescape View File

@ -231,7 +231,6 @@ class R2dbcTransactionManagerUnitTests {
@Test @Test
void testCommitFails() { void testCommitFails() {
when(connectionMock.commitTransaction()).thenReturn(Mono.defer(() -> Mono.error(new R2dbcBadGrammarException("Commit should fail")))); when(connectionMock.commitTransaction()).thenReturn(Mono.defer(() -> Mono.error(new R2dbcBadGrammarException("Commit should fail"))));
when(connectionMock.rollbackTransaction()).thenReturn(Mono.empty()); when(connectionMock.rollbackTransaction()).thenReturn(Mono.empty());
TransactionalOperator operator = TransactionalOperator.create(tm); TransactionalOperator operator = TransactionalOperator.create(tm);
@ -252,7 +251,6 @@ class R2dbcTransactionManagerUnitTests {
@Test @Test
void testRollback() { void testRollback() {
AtomicInteger commits = new AtomicInteger(); AtomicInteger commits = new AtomicInteger();
when(connectionMock.commitTransaction()).thenReturn( when(connectionMock.commitTransaction()).thenReturn(
Mono.fromRunnable(commits::incrementAndGet)); Mono.fromRunnable(commits::incrementAndGet));
@ -284,11 +282,8 @@ class R2dbcTransactionManagerUnitTests {
when(connectionMock.rollbackTransaction()).thenReturn(Mono.defer(() -> Mono.error(new R2dbcBadGrammarException("Commit should fail"))), Mono.empty()); when(connectionMock.rollbackTransaction()).thenReturn(Mono.defer(() -> Mono.error(new R2dbcBadGrammarException("Commit should fail"))), Mono.empty());
TransactionalOperator operator = TransactionalOperator.create(tm); TransactionalOperator operator = TransactionalOperator.create(tm);
operator.execute(reactiveTransaction -> { operator.execute(reactiveTransaction -> {
reactiveTransaction.setRollbackOnly(); reactiveTransaction.setRollbackOnly();
return ConnectionFactoryUtils.getConnection(connectionFactoryMock) return ConnectionFactoryUtils.getConnection(connectionFactoryMock)
.doOnNext(connection -> connection.createStatement("foo")).then(); .doOnNext(connection -> connection.createStatement("foo")).then();
}).as(StepVerifier::create) }).as(StepVerifier::create)
@ -306,11 +301,9 @@ class R2dbcTransactionManagerUnitTests {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
void testConnectionReleasedWhenRollbackFails() { void testConnectionReleasedWhenRollbackFails() {
when(connectionMock.rollbackTransaction()).thenReturn(Mono.defer(() -> Mono.error(new R2dbcBadGrammarException("Rollback should fail"))), Mono.empty()); when(connectionMock.rollbackTransaction()).thenReturn(Mono.defer(() -> Mono.error(new R2dbcBadGrammarException("Rollback should fail"))), Mono.empty());
TransactionalOperator operator = TransactionalOperator.create(tm);
when(connectionMock.setTransactionIsolationLevel(any())).thenReturn(Mono.empty()); when(connectionMock.setTransactionIsolationLevel(any())).thenReturn(Mono.empty());
TransactionalOperator operator = TransactionalOperator.create(tm);
operator.execute(reactiveTransaction -> ConnectionFactoryUtils.getConnection(connectionFactoryMock) operator.execute(reactiveTransaction -> ConnectionFactoryUtils.getConnection(connectionFactoryMock)
.doOnNext(connection -> { .doOnNext(connection -> {
throw new IllegalStateException("Intentional error to trigger rollback"); throw new IllegalStateException("Intentional error to trigger rollback");
@ -333,12 +326,9 @@ class R2dbcTransactionManagerUnitTests {
TransactionSynchronization.STATUS_ROLLED_BACK); TransactionSynchronization.STATUS_ROLLED_BACK);
TransactionalOperator operator = TransactionalOperator.create(tm); TransactionalOperator operator = TransactionalOperator.create(tm);
operator.execute(tx -> { operator.execute(tx -> {
tx.setRollbackOnly(); tx.setRollbackOnly();
assertThat(tx.isNewTransaction()).isTrue(); assertThat(tx.isNewTransaction()).isTrue();
return TransactionSynchronizationManager.forCurrentTransaction().doOnNext( return TransactionSynchronizationManager.forCurrentTransaction().doOnNext(
synchronizationManager -> { synchronizationManager -> {
assertThat(synchronizationManager.hasResource(connectionFactoryMock)).isTrue(); assertThat(synchronizationManager.hasResource(connectionFactoryMock)).isTrue();
@ -364,15 +354,12 @@ class R2dbcTransactionManagerUnitTests {
DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
TransactionalOperator operator = TransactionalOperator.create(tm, definition);
TransactionalOperator operator = TransactionalOperator.create(tm, definition);
operator.execute(tx1 -> { operator.execute(tx1 -> {
assertThat(tx1.isNewTransaction()).isTrue(); assertThat(tx1.isNewTransaction()).isTrue();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER); definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER);
return operator.execute(tx2 -> { return operator.execute(tx2 -> {
fail("Should have thrown IllegalTransactionStateException"); fail("Should have thrown IllegalTransactionStateException");
return Mono.empty(); return Mono.empty();
}); });
@ -384,24 +371,121 @@ class R2dbcTransactionManagerUnitTests {
} }
@Test @Test
void testPropagationSupportsAndRequiresNew() { void testPropagationNestedWithExistingTransaction() {
when(connectionMock.createSavepoint("SAVEPOINT_1")).thenReturn(Mono.empty());
when(connectionMock.releaseSavepoint("SAVEPOINT_1")).thenReturn(Mono.empty());
when(connectionMock.commitTransaction()).thenReturn(Mono.empty());
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
TransactionalOperator operator = TransactionalOperator.create(tm, definition);
operator.execute(tx1 -> {
assertThat(tx1.isNewTransaction()).isTrue();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
return operator.execute(tx2 -> {
assertThat(tx2.isNewTransaction()).isTrue();
return Mono.empty();
});
}).as(StepVerifier::create)
.verifyComplete();
verify(connectionMock).createSavepoint("SAVEPOINT_1");
verify(connectionMock).releaseSavepoint("SAVEPOINT_1");
verify(connectionMock).commitTransaction();
verify(connectionMock).close();
}
@Test
void testPropagationNestedWithExistingTransactionAndRollback() {
when(connectionMock.createSavepoint("SAVEPOINT_1")).thenReturn(Mono.empty());
when(connectionMock.rollbackTransactionToSavepoint("SAVEPOINT_1")).thenReturn(Mono.empty());
when(connectionMock.commitTransaction()).thenReturn(Mono.empty());
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
TransactionalOperator operator = TransactionalOperator.create(tm, definition);
operator.execute(tx1 -> {
assertThat(tx1.isNewTransaction()).isTrue();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
return operator.execute(tx2 -> {
assertThat(tx2.isNewTransaction()).isTrue();
tx2.setRollbackOnly();
return Mono.empty();
});
}).as(StepVerifier::create)
.verifyComplete();
verify(connectionMock).createSavepoint("SAVEPOINT_1");
verify(connectionMock).rollbackTransactionToSavepoint("SAVEPOINT_1");
verify(connectionMock).commitTransaction();
verify(connectionMock).close();
}
@Test
void testPropagationSupportsAndNested() {
when(connectionMock.commitTransaction()).thenReturn(Mono.empty()); when(connectionMock.commitTransaction()).thenReturn(Mono.empty());
DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
TransactionalOperator operator = TransactionalOperator.create(tm, definition); TransactionalOperator operator = TransactionalOperator.create(tm, definition);
operator.execute(tx1 -> {
assertThat(tx1.isNewTransaction()).isFalse();
DefaultTransactionDefinition innerDef = new DefaultTransactionDefinition();
innerDef.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
TransactionalOperator inner = TransactionalOperator.create(tm, innerDef);
return inner.execute(tx2 -> {
assertThat(tx2.isNewTransaction()).isTrue();
return Mono.empty();
});
}).as(StepVerifier::create)
.verifyComplete();
verify(connectionMock).commitTransaction();
verify(connectionMock).close();
}
@Test
void testPropagationSupportsAndNestedWithRollback() {
when(connectionMock.rollbackTransaction()).thenReturn(Mono.empty());
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
TransactionalOperator operator = TransactionalOperator.create(tm, definition);
operator.execute(tx1 -> { operator.execute(tx1 -> {
assertThat(tx1.isNewTransaction()).isFalse();
DefaultTransactionDefinition innerDef = new DefaultTransactionDefinition();
innerDef.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
TransactionalOperator inner = TransactionalOperator.create(tm, innerDef);
return inner.execute(tx2 -> {
assertThat(tx2.isNewTransaction()).isTrue();
tx2.setRollbackOnly();
return Mono.empty();
});
}).as(StepVerifier::create)
.verifyComplete();
assertThat(tx1.isNewTransaction()).isFalse(); verify(connectionMock).rollbackTransaction();
verify(connectionMock).close();
}
@Test
void testPropagationSupportsAndRequiresNew() {
when(connectionMock.commitTransaction()).thenReturn(Mono.empty());
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
TransactionalOperator operator = TransactionalOperator.create(tm, definition);
operator.execute(tx1 -> {
assertThat(tx1.isNewTransaction()).isFalse();
DefaultTransactionDefinition innerDef = new DefaultTransactionDefinition(); DefaultTransactionDefinition innerDef = new DefaultTransactionDefinition();
innerDef.setPropagationBehavior( innerDef.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
TransactionDefinition.PROPAGATION_REQUIRES_NEW);
TransactionalOperator inner = TransactionalOperator.create(tm, innerDef); TransactionalOperator inner = TransactionalOperator.create(tm, innerDef);
return inner.execute(tx2 -> { return inner.execute(tx2 -> {
assertThat(tx2.isNewTransaction()).isTrue(); assertThat(tx2.isNewTransaction()).isTrue();
return Mono.empty(); return Mono.empty();
}); });
@ -412,6 +496,31 @@ class R2dbcTransactionManagerUnitTests {
verify(connectionMock).close(); verify(connectionMock).close();
} }
@Test
void testPropagationSupportsAndRequiresNewWithRollback() {
when(connectionMock.rollbackTransaction()).thenReturn(Mono.empty());
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
TransactionalOperator operator = TransactionalOperator.create(tm, definition);
operator.execute(tx1 -> {
assertThat(tx1.isNewTransaction()).isFalse();
DefaultTransactionDefinition innerDef = new DefaultTransactionDefinition();
innerDef.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
TransactionalOperator inner = TransactionalOperator.create(tm, innerDef);
return inner.execute(tx2 -> {
assertThat(tx2.isNewTransaction()).isTrue();
tx2.setRollbackOnly();
return Mono.empty();
});
}).as(StepVerifier::create)
.verifyComplete();
verify(connectionMock).rollbackTransaction();
verify(connectionMock).close();
}
private static class TestTransactionSynchronization implements TransactionSynchronization { private static class TestTransactionSynchronization implements TransactionSynchronization {

Write Preview
Loading…
Cancel
Save