This is an automated email from the ASF dual-hosted git repository.
totalo pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 6beb5c54193 Add test cases on ConnectionTransaction (#33085)
6beb5c54193 is described below
commit 6beb5c541935ed8644d3856709d775e1265c1c8f
Author: Liang Zhang <[email protected]>
AuthorDate: Tue Oct 1 19:33:59 2024 +0800
Add test cases on ConnectionTransaction (#33085)
* Add test cases on ConnectionTransaction
* Add test cases on ConnectionTransaction
---
.../transaction/ConnectionTransaction.java | 2 +-
.../transaction/ConnectionTransactionTest.java | 156 +++++++++++++++++----
2 files changed, 129 insertions(+), 29 deletions(-)
diff --git
a/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/ConnectionTransaction.java
b/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/ConnectionTransaction.java
index 262074d4f7b..8b91a4cf40b 100644
---
a/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/ConnectionTransaction.java
+++
b/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/ConnectionTransaction.java
@@ -52,7 +52,7 @@ public final class ConnectionTransaction {
* @return in transaction or not
*/
public boolean isInTransaction(final TransactionConnectionContext
transactionContext) {
- return transactionContext.isInTransaction() && null !=
distributionTransactionManager &&
distributionTransactionManager.isInTransaction();
+ return transactionContext.isInTransaction() && isInTransaction();
}
/**
diff --git
a/kernel/transaction/core/src/test/java/org/apache/shardingsphere/transaction/ConnectionTransactionTest.java
b/kernel/transaction/core/src/test/java/org/apache/shardingsphere/transaction/ConnectionTransactionTest.java
index 844bdd5fc86..b84be80faac 100644
---
a/kernel/transaction/core/src/test/java/org/apache/shardingsphere/transaction/ConnectionTransactionTest.java
+++
b/kernel/transaction/core/src/test/java/org/apache/shardingsphere/transaction/ConnectionTransactionTest.java
@@ -19,60 +19,160 @@ package org.apache.shardingsphere.transaction;
import
org.apache.shardingsphere.infra.session.connection.transaction.TransactionConnectionContext;
import
org.apache.shardingsphere.transaction.ConnectionTransaction.DistributedTransactionOperationType;
-import
org.apache.shardingsphere.transaction.config.TransactionRuleConfiguration;
+import org.apache.shardingsphere.transaction.api.TransactionType;
import org.apache.shardingsphere.transaction.rule.TransactionRule;
+import
org.apache.shardingsphere.transaction.spi.ShardingSphereDistributionTransactionManager;
import org.junit.jupiter.api.Test;
-import java.util.Collections;
-import java.util.Properties;
+import java.sql.Connection;
+import java.sql.SQLException;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
class ConnectionTransactionTest {
- private ConnectionTransaction connectionTransaction;
+ @Test
+ void assertIsNotInTransactionWhenTransactionIsNotBegin() {
+ TransactionConnectionContext context = new
TransactionConnectionContext();
+ assertFalse(new ConnectionTransaction(mock(TransactionRule.class,
RETURNS_DEEP_STUBS), context).isInTransaction(context));
+ }
+
+ @Test
+ void assertIsNotInTransactionWhenIsNotDistributionTransaction() {
+ TransactionConnectionContext context = new
TransactionConnectionContext();
+ context.beginTransaction("LOCAL");
+ assertFalse(new ConnectionTransaction(mock(TransactionRule.class),
context).isInTransaction(context));
+ }
@Test
- void assertDistributedTransactionOperationTypeCommit() {
- connectionTransaction = new
ConnectionTransaction(getXATransactionRule(), new
TransactionConnectionContext());
- DistributedTransactionOperationType operationType =
connectionTransaction.getDistributedTransactionOperationType(true);
- assertThat(operationType,
is(DistributedTransactionOperationType.COMMIT));
+ void assertIsNotInTransactionWhenDistributionTransactionIsNotBegin() {
+ TransactionConnectionContext context = new
TransactionConnectionContext();
+ context.beginTransaction("XA");
+ assertFalse(new ConnectionTransaction(mock(TransactionRule.class,
RETURNS_DEEP_STUBS), context).isInTransaction(context));
}
@Test
- void assertDistributedTransactionOperationTypeIgnore() {
- connectionTransaction = new
ConnectionTransaction(getXATransactionRule(), new
TransactionConnectionContext());
- DistributedTransactionOperationType operationType =
connectionTransaction.getDistributedTransactionOperationType(false);
- assertThat(operationType,
is(DistributedTransactionOperationType.IGNORE));
+ void assertIsInTransaction() {
+ TransactionConnectionContext context = new
TransactionConnectionContext();
+ context.beginTransaction("XA");
+ TransactionRule rule = mock(TransactionRule.class, RETURNS_DEEP_STUBS);
+
when(rule.getResource().getTransactionManager(rule.getDefaultType()).isInTransaction()).thenReturn(true);
+ assertTrue(new ConnectionTransaction(rule,
context).isInTransaction(context));
}
@Test
void assertIsLocalTransaction() {
- connectionTransaction = new
ConnectionTransaction(getLocalTransactionRule(), new
TransactionConnectionContext());
- assertTrue(connectionTransaction.isLocalTransaction());
- connectionTransaction = new
ConnectionTransaction(getXATransactionRule(), new
TransactionConnectionContext());
- assertFalse(connectionTransaction.isLocalTransaction());
+ TransactionRule rule = mock(TransactionRule.class);
+ when(rule.getDefaultType()).thenReturn(TransactionType.LOCAL);
+ assertTrue(new ConnectionTransaction(rule, new
TransactionConnectionContext()).isLocalTransaction());
}
@Test
- void assertIsHoldTransaction() {
- connectionTransaction = new
ConnectionTransaction(getLocalTransactionRule(), new
TransactionConnectionContext());
- assertTrue(connectionTransaction.isHoldTransaction(false));
- connectionTransaction = new
ConnectionTransaction(getXATransactionRule(), new
TransactionConnectionContext());
- assertTrue(connectionTransaction.isInTransaction());
- assertTrue(connectionTransaction.isHoldTransaction(true));
- connectionTransaction = new
ConnectionTransaction(getLocalTransactionRule(), new
TransactionConnectionContext());
- assertFalse(connectionTransaction.isHoldTransaction(true));
+ void assertIsNotLocalTransaction() {
+ TransactionRule rule = mock(TransactionRule.class, RETURNS_DEEP_STUBS);
+ when(rule.getDefaultType()).thenReturn(TransactionType.XA);
+ assertFalse(new ConnectionTransaction(rule, new
TransactionConnectionContext()).isLocalTransaction());
}
- private TransactionRule getLocalTransactionRule() {
- return new TransactionRule(new TransactionRuleConfiguration("LOCAL",
null, new Properties()), Collections.emptyMap());
+ @Test
+ void assertIsHoldTransactionWithLocalAndNotAutoCommit() {
+ TransactionRule rule = mock(TransactionRule.class);
+ when(rule.getDefaultType()).thenReturn(TransactionType.LOCAL);
+ assertTrue(new ConnectionTransaction(rule, new
TransactionConnectionContext()).isHoldTransaction(false));
}
- private TransactionRule getXATransactionRule() {
- return new TransactionRule(new TransactionRuleConfiguration("XA",
"Atomikos", new Properties()), Collections.emptyMap());
+ @Test
+ void assertIsHoldTransactionWithXAAndAutoCommit() {
+ TransactionRule rule = mock(TransactionRule.class, RETURNS_DEEP_STUBS);
+ when(rule.getDefaultType()).thenReturn(TransactionType.XA);
+
when(rule.getResource().getTransactionManager(TransactionType.XA).isInTransaction()).thenReturn(true);
+ TransactionConnectionContext context = new
TransactionConnectionContext();
+ context.beginTransaction("XA");
+ assertTrue(new ConnectionTransaction(rule,
context).isHoldTransaction(true));
+ }
+
+ @Test
+ void assertBegin() {
+ ShardingSphereDistributionTransactionManager
distributionTransactionManager =
mock(ShardingSphereDistributionTransactionManager.class);
+ TransactionRule rule = mock(TransactionRule.class, RETURNS_DEEP_STUBS);
+
when(rule.getResource().getTransactionManager(rule.getDefaultType())).thenReturn(distributionTransactionManager);
+ new ConnectionTransaction(rule, new
TransactionConnectionContext()).begin();
+ verify(distributionTransactionManager).begin();
+ }
+
+ @Test
+ void assertCommit() {
+ ShardingSphereDistributionTransactionManager
distributionTransactionManager =
mock(ShardingSphereDistributionTransactionManager.class);
+ TransactionRule rule = mock(TransactionRule.class, RETURNS_DEEP_STUBS);
+
when(rule.getResource().getTransactionManager(rule.getDefaultType())).thenReturn(distributionTransactionManager);
+ new ConnectionTransaction(rule, new
TransactionConnectionContext()).commit();
+ verify(distributionTransactionManager).commit(false);
+ }
+
+ @Test
+ void assertRollback() {
+ ShardingSphereDistributionTransactionManager
distributionTransactionManager =
mock(ShardingSphereDistributionTransactionManager.class);
+ TransactionRule rule = mock(TransactionRule.class, RETURNS_DEEP_STUBS);
+
when(rule.getResource().getTransactionManager(rule.getDefaultType())).thenReturn(distributionTransactionManager);
+ new ConnectionTransaction(rule, new
TransactionConnectionContext()).rollback();
+ verify(distributionTransactionManager).rollback();
+ }
+
+ @Test
+ void assertIsHoldTransactionWithLocalAndAutoCommit() {
+ TransactionRule rule = mock(TransactionRule.class);
+ when(rule.getDefaultType()).thenReturn(TransactionType.LOCAL);
+ assertFalse(new ConnectionTransaction(rule, new
TransactionConnectionContext()).isHoldTransaction(true));
+ }
+
+ @Test
+ void assertGetConnectionWithoutInDistributeTransaction() throws
SQLException {
+ TransactionRule rule = mock(TransactionRule.class);
+ when(rule.getDefaultType()).thenReturn(TransactionType.LOCAL);
+ TransactionConnectionContext context = new
TransactionConnectionContext();
+ assertFalse(new ConnectionTransaction(rule,
context).getConnection("foo_db", "foo_ds", context).isPresent());
+ }
+
+ @Test
+ void assertGetConnectionWithInDistributeTransaction() throws SQLException {
+ TransactionConnectionContext context = new
TransactionConnectionContext();
+ context.beginTransaction("XA");
+ TransactionRule rule = mock(TransactionRule.class, RETURNS_DEEP_STUBS);
+
when(rule.getResource().getTransactionManager(rule.getDefaultType()).isInTransaction()).thenReturn(true);
+
when(rule.getResource().getTransactionManager(rule.getDefaultType()).getConnection("foo_db",
"foo_ds")).thenReturn(mock(Connection.class));
+ assertTrue(new ConnectionTransaction(rule,
context).getConnection("foo_db", "foo_ds", context).isPresent());
+ }
+
+ @Test
+ void assertGetDistributedTransactionBeginOperationType() {
+ assertThat(new ConnectionTransaction(mock(TransactionRule.class,
RETURNS_DEEP_STUBS), new
TransactionConnectionContext()).getDistributedTransactionOperationType(false),
+ is(DistributedTransactionOperationType.BEGIN));
+ }
+
+ @Test
+ void assertGetDistributedTransactionCommitOperationType() {
+ TransactionRule rule = mock(TransactionRule.class, RETURNS_DEEP_STUBS);
+
when(rule.getResource().getTransactionManager(rule.getDefaultType()).isInTransaction()).thenReturn(true);
+ assertThat(new ConnectionTransaction(rule, new
TransactionConnectionContext()).getDistributedTransactionOperationType(true),
is(DistributedTransactionOperationType.COMMIT));
+ }
+
+ @Test
+ void assertDistributedTransactionIgnoreOperationTypeWhenIsAutoCommit() {
+ TransactionRule rule = mock(TransactionRule.class, RETURNS_DEEP_STUBS);
+
when(rule.getResource().getTransactionManager(rule.getDefaultType()).isInTransaction()).thenReturn(true);
+ assertThat(new ConnectionTransaction(rule, new
TransactionConnectionContext()).getDistributedTransactionOperationType(false),
is(DistributedTransactionOperationType.IGNORE));
+ }
+
+ @Test
+ void
assertDistributedTransactionIgnoreOperationTypeWhenIsNotInDistributedTransaction()
{
+ ConnectionTransaction connectionTransaction = new
ConnectionTransaction(mock(TransactionRule.class, RETURNS_DEEP_STUBS), new
TransactionConnectionContext());
+
assertThat(connectionTransaction.getDistributedTransactionOperationType(true),
is(DistributedTransactionOperationType.IGNORE));
}
}
